Pierwsze kroki z Fleet Engine do śledzenia przesyłek

Modeluj działania floty na potrzeby pierwszego i ostatniego kilometra dostaw za pomocą interfejsu Fleet Engine Deliveries API. Możesz używać tego interfejsu API za pomocą pakietu Driver SDK na Androida i iOS lub bezpośrednio przy użyciu wywołań REST HTTP lub gRPC.

Konfiguracja początkowa

Interfejs Fleet Engine Deliveries API możesz skonfigurować w konsoli Google Cloud.

• Informacje o czynnościach, które należy wykonać w konsoli, oraz o tworzeniu token sieciowy JSON do autoryzacji, zobacz Uwierzytelnianie i autoryzacja.

• Więcej informacji o korzystaniu z konsoli znajdziesz w dokumentacji Google Cloud Console.

Sprawdzanie konfiguracji

Po utworzeniu kont usługi sprawdź, czy konfiguracja została zakończona i możesz utworzyć pojazd dostawczy. Natychmiastowa weryfikacja konfiguracji pozwala rozwiązać typowe problemy z autoryzacją, które mogą wystąpić podczas konfigurowania projektu. Konfigurację możesz zweryfikować na 2 sposoby:

• Testowanie 2 kluczowych elementów konfiguracji: podpisywania tokena autoryzacji i dostarczania wersji próbnej konstrukcja pojazdu z Narzędzie wiersza poleceń gcloud. Dla: szczegółowe informacje znajdziesz w sekcji Weryfikowanie konfiguracji. Google.

• Przetestuj konfigurację za pomocą Przykładowe skrypty uwierzytelniania Fleet Engine

Biblioteki klienta

Aby ułatwić pracę programistom zamiast nieprzetworzonego gRPC lub REST, użyj metody i biblioteki klienta w kilku popularnych językach programowania. Dla: instrukcje uzyskiwania bibliotek klienta dla aplikacji serwerowej, można znaleźć Biblioteki klienta.

W przykładach w Javie w tej dokumentacji zakładamy, że znasz gRPC.

Struktury danych

Interfejs Fleet Engine Deliveries API wykorzystuje 2 struktury danych do modelowania odbioru i dostawy ładunków:

• Pojazd dostawczy używany do transportu przesyłki.
• Zadania związane z odbiorem i dostawą przesyłki.

Za pomocą zadań możesz też modelować przerwy kierowcy i zaplanowane postoje w ciągu dnia.

Pojazdy dostawcze

Pojazdy dostawcze transportują ładunki z zajmu do miejsca dostawy i z miejsca odbioru do magazynu. W niektórych przypadkach mogą też umożliwia przesłanie przesyłki bezpośrednio z miejsca odbioru do miejsca dostawy.

Utwórz obiekt DeliveryVehicle we Fleet Engine za pomocą pakietu Driver SDK oraz wysyłać aktualne informacje o lokalizacjach do śledzenia przesyłek i floty.

Lista zadań

Do działań podejmowanych przez pojazd w ciągu dnia przypisujesz zadania według typ działania:

• W przypadku odbioru i dostawy przypisz Zadania związane z dostawą.
• W sytuacjach, gdy kierowcy są niedostępni, np. gdy wymagane przerwy przypisać zadania dotyczące niedostępności,
• W przypadku zadań, które nie są prowadzone w trybie samochodowym, w przypadku skrzynek referencyjnych lub lokalizacji klientów przypisz Zadania związane z zaplanowanym zatrzymywaniem.

Każde przypisane przez Ciebie zadanie musi mieć unikalny identyfikator zadania, ale zadania mogą mieć ten sam identyfikator identyfikatora śledzenia. Kiedy Fleet Engine oblicza szacowany czas dotarcia dla każdego zadania, uwzględnia wszystkie zadania oraz kolejność, mają zaplanowane szacunki. Więcej informacji o identyfikatorach zadań znajdziesz w tych artykułach: Wskazówki dotyczące identyfikatorów zadań

Aby utworzyć zadania we Fleet Engine, użyj menedżera zadań pakietu Driver SDK.

Zadania związane z dostawą

tworzyć zadania związane z dostawą przesyłki obejmujące zarówno odbiór, jak i dostawę; podaj następujące informacje:

• Lokalizacja odbioru lub dostawy.
• Numer śledzenia lub identyfikator.
• To dodatkowy czas na wykonanie zadania. aby zaparkować pojazd, lub przejść do miejsca przekazania.
• Unikalny identyfikator zadania. Zobacz wytyczne dotyczące identyfikatorów zadań.

Więcej informacji znajdziesz w tych tematach:

Android

• Tworzenie zadania odbioru przesyłki
• Tworzenie zadania dostawy

iOS

• DeliveryTaskManager (GMTD).
• GMTSTaskType

Zadania związane z niedostępnością

Zadania związane z niedostępnością obejmują okresy, w których pojazd nie jest dostępny odbioru lub dostawy, np. przerwy na uzupełnienie paliwa w pojeździe lub kierowcy przerwy na odpoczynek.

Utwórz zadanie dotyczące niedostępności z tymi informacjami:

• Długość przerwy.
• Opcjonalnie lokalizacja przerwy. Nie musisz podawać z konkretnej lokalizacji, ale tym samym zwiększa dokładność czasu dotarcia na miejsce. w ciągu dnia.

Więcej informacji znajdziesz w tych tematach:

Android

• Zaplanowana niedostępność

iOS

• DeliveryTaskManager (GMTD).
• GMTSTaskType

Zadania zaplanowanego zatrzymania

Tworzenie zadań zaplanowanych przystanków w celu modelowania przystanków, których potrzebuje pojazd dostawy i wykonania innych czynności. Można na przykład utworzyć zadanie zatrzymania dla zaplanowanego dnia punkt odbioru w określonej lokalizacji, niezależnie od innych dostaw lub odbiór w tym samym miejscu. Możesz też tworzyć zaplanowane zadania zatrzymania dla kolekcji, np. ze skrzynek referencyjnych lub do przesyłania modeli ładunków i pojazdów. lub zatrzymuje się w centrach obsługi i punktach obsługi.

Więcej informacji znajdziesz w tych tematach:

Android

• Zaplanowane przystanki

iOS

• DeliveryTaskManager (GMTD).
• GMTSTaskType

Wskazówki dotyczące identyfikatora zadania

Podczas tworzenia identyfikatorów zadań postępuj zgodnie z tymi wskazówkami dotyczącymi treści i formatu:

• Tworzenie unikalnych identyfikatorów zadań
• Nie ujawniaj żadnych informacji umożliwiających identyfikację osób ani czysty tekst.
• Użyj prawidłowych ciągów Unicode.
• Użyj maksymalnie 64 znaków.
• Nie używaj następujących znaków ASCII: „/”, „:”, „\"”, „?” lub „#”.
• Normalizuj zgodnie z formularzem normalizacji Unicode C.

Oto kilka przykładów prawidłowych identyfikatorów zadań:

• 566c33d9-2a31-4b6a-9cd4-80ba1a0c643b
• E4708eabcfa39bf2767c9546c9273f747b4626e8cc44e9630d50f6d129013d38
• NTA1YTliYWNkYmViMTI0ZmMzMZMWFMOWY2NzNkM2Jk

W tej tabeli znajdziesz przykłady nieobsługiwanych identyfikatorów zadań:

Więcej zasobów

Aby zobaczyć konkretne pola zawarte w poszczególnych danych można znaleźć w dokumentacji interfejsu API dla DeliveryVehicle (gRPC, REST) i Task (gRPC, REST).

Żywotność pojazdu

Obiekt DeliveryVehicle reprezentuje pojazd dostarczany na pierwszej lub ostatniej mili. Tworzysz obiekt DeliveryVehicle za pomocą:

• Identyfikator projektu Google Cloud zawierającego konto usługi używane do wywoływania interfejsów Fleet Engine API.
• Identyfikator pojazdu należący do klienta.

Każdy pojazd ma unikalny identyfikator. Nie wykorzystuj ponownie identyfikatora pojazdu chyba że pierwotny pojazd nie ma żadnych aktywnych zadań.

Fleet Engine automatycznie usuwa DeliveryVehicle obiektu, które nie zostały usunięte zostały zaktualizowane za pomocą UpdateDeliveryVehicle po 7 dniach. Zalecane aby zachować dostępność pojazdu we Fleet Engine, należy zaktualizować jego lokalizację w regularnych odstępach czasu. Aktualizacje większości innych pól w DeliveryVehicle encja przedłuży też swój czas życia, pod warunkiem że nowa wartość pola będzie inna w stosunku do już istniejącej.

Aby sprawdzić, czy pojazd istnieje:

1. Zadzwoń pod numer UpdateDeliveryVehicle.
2. Jeśli pojawi się błąd NOT_FOUND, zadzwoń pod numer CreateDeliveryVehicle aby odtworzyć pojazd. Jeśli połączenie zwróci pojazd, można go zaktualizować.

Rodzaj pojazdu

Element VehicleType zawiera opcjonalne pole VehicleType, w którym znajduje się wyliczenie Category, które możesz określić jako AUTO, TWO_WHEELER, BICYCLE lub PEDESTRIAN. Jeśli nie skonfigurujesz tego pola, domyślnie przyjęta zostanie wartość AUTO.

Wszystkie ustawienia wyznaczania tras dla pojazdów używają odpowiedniej funkcji RouteTravelMode odpowiadający typowi pojazdu.

Atrybuty pojazdu

Element DeliveryVehicle zawiera powtórzone pole: DeliveryVehicleAttribute Interfejs API ListDeliveryVehicles zawiera filter które może ograniczyć zwracane elementy DeliveryVehicle do tych z parametrem określonych atrybutów. DeliveryVehicleAttribute nie wpływa na Fleet Engine w kierunku routingu.

Nie podawaj informacji umożliwiających identyfikację osób ani informacji poufnych w atrybutach, ponieważ to pole może być widoczne dla użytkowników.

Cykl życia zadania

Możesz tworzyć i aktualizować zadania we Fleet Engine oraz wykonywać na nich zapytania za pomocą za pomocą interfejsów gRPC lub REST interfejsu Deliveries API.

Obiekt Task ma pole stanu, przez które można śledzić jego postęp cyklu życia usługi. Wartości zmienią się z OTWÓRZ na ZAMKNIĘTE. Tworzone są nowe zadania w stanie OTWÓRZ, co oznacza, że:

• Zadanie nie zostało jeszcze przypisane do pojazdu dostawczego.
• Pojazd dostarczający nie ukończył jeszcze przystanku pojazdu przypisanego do zadania.

Wytyczne dotyczące zadań

Zadanie możesz przypisać do pojazdu tylko w stanie OTWARTY.

Zadanie możesz anulować, usuwając je z listy przystanków pojazdów, co powoduje ustawienie wartości stan zadania na ZAMKNIĘTE.

Gdy pojazd wykonujący zadanie ukończy jego zatrzymanie:

1. Zmień pole wyniku zadania na SUCCEEDED lub FAILED.

2. Podaj sygnaturę czasową zdarzenia.

   Biblioteka śledzenia przesyłek JavaScript pokazuje wynik zadania i stan zadania zostanie automatycznie zmieniony na ZAMKNIĘTE. Więcej informacji: Śledź przesyłkę za pomocą biblioteki śledzenia przesyłki JavaScript.

Podobnie jak w przypadku pojazdów, Fleet Engine usuwa zadania, które nie zostały zaktualizowane po 7 dni. Jeśli spróbujesz utworzyć zadanie o identyfikatorze, który już istnieje, zwraca błąd.

Uwaga: Fleet Engine nie obsługuje wyraźnego usuwania zadania. Usługa automatycznie usuwa zadania po 7 dniach bez aktualizacji. Jeśli chcesz przechowywać dane zadań przez więcej niż 7 dni, musisz wdrożyć je samodzielnie.

Atrybuty zadania

Element Task zawiera powtórzone pole: TaskAttribute, który może mieć wartość jednego z 3 typów: ciąg znaków, liczba i wartość logiczna. Interfejs API ListTasks zawiera pole filter, które może ograniczać liczbę zwracanych wartości Task do tych o określonych atrybutach. Atrybuty zadań nie wpływać na zachowanie routingu Fleet Engine.

Nie podawaj informacji umożliwiających identyfikację osób ani innych informacji poufnych informacje w atrybutach, bo mogą one być widoczne dla użytkowników.

Zarządzanie cyklem życia pojazdu i zadań

Przypomnienie: Twój system wewnętrzny działa jako zaufane źródło danych, Rozszerzanie interfejsu Fleet Engine Deliveries API w Twoim imieniu.

Aby zarządzać cyklami życia pojazdów i zadań w systemie, użyj interfejsu Fleet Engine Deliveries API do tworzenia, aktualizowania i śledzenia pojazdów oraz powiązanych z nimi zadań.

Jednocześnie aplikacja sterownika komunikuje się bezpośrednio z Fleet Engine. aby zaktualizować lokalizację urządzenia i informacje o trasie. Ten model pozwala Fleet Engine i efektywnie zarządzać bieżącą lokalizacją. Wysyła lokalizację bezpośrednio do śledzenia biblioteki, która może służyć do informowania klientów o stanie zamówienia.

Załóżmy na przykład, że możliwy jest następujący scenariusz:

• Kierowca w pobliżu przystanku dostawy. Aplikacja sterownika wysyła swoją lokalizację do Fleet Engine.
• Fleet Engine wysyła lokalizację urządzenia do biblioteki śledzenia, której aplikacja konsumenta używa do powiadamiania konsumenta w pobliżu przesyłki.
• Gdy kierowca zakończy dostawę, klika „Przesyłka dostarczona”. w aplikacji sterownika.
• „Przesyłka dostarczona”. wysyła informacje do systemu backendu, w ramach której wykonamy niezbędne czynności weryfikacyjne i weryfikacyjne.
• Twój system potwierdza zadanie jako SUCCEEDED i aktualizuje Fleet Engine za pomocą Deliveries API.

Poniższy diagram przedstawia te procesy na poziomie ogólnym. Dodatkowo pokazuje standardową relację między Twoim systemem, klientem i Fleet Engine.

Zarządzanie tokenami klientów

aktualizacje lokalizacji pochodzące z aplikacji sterownika i wysyłane bezpośrednio; do Fleet Engine wymagają tokenów autoryzacji. Oto zalecane podejście w celu obsługi aktualizacji od klienta do Fleet Engine:

1. Wygeneruj token za pomocą niezaufanego użytkownika Fleet Engine Delivery. rolę konta usługi.

2. Udostępnij aplikacji sterownika token ograniczonego zakresu. Ten zakres pozwala tylko na aktualizację lokalizacji urządzenia we Fleet Engine.

Dzięki temu połączenia przychodzące z urządzeń mobilnych są brane pod uwagę o niskim stopniu zaufania, zasady jak najmniejszych uprawnień.

Inne role konta usługi

Jeśli zamiast tego chcesz autoryzować aplikacje sterownikowe do bezpośredniego Aktualizacje Fleet Engine wykraczające poza rolę niezaufanego sterownika. np. w przypadku niektórych aktualizacji zadań, możesz przypisać rolę Zaufany sterownik. Dla: informacji na temat modelu z rolą zaufanego kierowcy, zobacz Zaufany model kierowcy.

Więcej informacji o zastosowaniu niezaufanych i zaufanych ról kierowców znajdziesz w artykule Konfiguracja projektu w chmurze

Utwórz model dnia roboczego

W tabeli poniżej opisano sposób pracy kierowców pierwszego i ostatniego kilometra może przypominać firmę spedycyjną i logistyczną. Twoja firma może różnią się szczegółami, ale możesz zobaczyć, jak możesz modelować dzień pracy.

Jak działają aktualizacje lokalizacji

Aby uzyskać najlepszą wydajność we Fleet Engine, zapewnij jej strumień pojazdów aktualizacje lokalizacji. Zaktualizuj informacje na jeden z tych sposobów:

1. Użyj pakietu Driver SDK – Android iOS – najprostsza opcja.
2. Użyj kodu niestandardowego – przydatny, jeśli lokalizacje są przekazywane przez backend, lub jeśli używasz urządzeń innych niż Android iOS.

Niezależnie od tego, jak przekazujesz aktualizacje o lokalizacji pojazdu, wewnętrzna baza danych odpowiedzialny za aktualizację Fleet Engine, gdy pojazd dostawy w drodze do przystanku (także w stacji kolejowej) i kiedy przyjeżdża do przystanku. Fleet Engine nie wykrywa tych zdarzeń automatycznie.

Miejsca postojów i dostawy pojazdów

Stacja pojazdu to miejsce, w którym pojazd dostawczy kończy zadanie związane z dostawą lub innego zadania. Jest to punkt dostępu, taki jak stacja dokująca przyciągniętych do niej drogami.

Lokalizacja dostawy to miejsce, do którego zostanie dostarczona przesyłka lub odebrane. Dotarcie do miejsca dostawy i z niego może wymagać przejścia pieszo ze stacji pojazdów.

Na przykład, gdy kierowca dostarcza przesyłkę do sklepu w centrum handlowym, samochód dostawczy zatrzymuje się na parkingu centrum handlowego w pobliżu od najbliższego wejścia. To jest postój dla pojazdów. Kierowca a potem idzie z przystanku do centrum handlowego, w której znajduje się sklep. Jest to miejsce dostawy.

Aby zapewnić użytkownikom najlepsze wrażenia podczas śledzenia przesyłki, zastanów się, jak są przypisane do postojów pojazdów. Należy też pamiętać, informacje o pozostałych postojach na dostawę pojazdu na potrzeby zadań są zgłaszane użytkownikowi, aby mógł mu pomóc sprawdzić postęp wysyłki.

Jeśli na przykład kierowca dostarcza wiele dostaw do jednego budynku biurowego, rozważ przypisanie wszystkich zadań związanych z dostawą do jednego przystanku. Jeśli każde zadanie dostawy jest przypisane do oddzielnego przystanku dla pojazdów, jest mniej przydatne dla użytkowników, ponieważ śledzenie obejmuje tylko dostępna, gdy pojazd znajduje się na ograniczonej liczbie przystanków przed przez jego miejsce docelowe. Szybkie zatrzymania się w wielu pojazdach nie oznacza, na śledzenie postępów użytkownika.

Korzystanie z mobilnych pakietów SDK

Zanim wyślesz jakiekolwiek wywołania pakietu Driver SDK, pamiętaj, aby go zainicjować.

Inicjowanie interfejsu Delivery Driver API

Zanim zainicjujesz interfejs Delivery Driver API w pakiecie Driver SDK, sprawdź, aby zainicjować pakiet Navigation SDK. Następnie zainicjuj interfejs Delivery Driver API zgodnie z poniższym przykładem:

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));
     }
   });

Przypadki użycia

W tej sekcji opisaliśmy, jak używać interfejsu Deliveries API do modelowania typowych przypadków użycia.

Unikalne identyfikatory jednostek

Format i wartość unikalnych identyfikatorów jednostek używanych w wywołaniach REST to nieprzezroczyste dla Fleet Engine. Unikaj stosowania identyfikatorów automatycznie przyrostowych i upewnij się, identyfikator nie zawiera żadnych informacji umożliwiających identyfikację osoby, np. numer telefonu kierowcy.

Utwórz pojazd

Pojazd możesz utworzyć z poziomu Driver SDK lub ze środowiska serwera za pomocą gRPC lub REST.

gRPC

Aby utworzyć nowy pojazd, CreateDeliveryVehicle wywołaj funkcję Fleet Engine. Za pomocą obiektu CreateDeliveryVehicleRequest zdefiniuj atrybuty: nowego pojazdu dostawczego. Pamiętaj, że dowolna wartość podana w polu Name jest są ignorowane zgodnie ze wskazówkami interfejsu API dotyczącymi identyfikatorów określonych przez użytkowników. Do skonfigurowania identyfikatora pojazdu należy użyć pola DeliveryVehicleId.

Podczas tworzenia obiektu DeliveryVehicle możesz opcjonalnie określić te pola:

• Atrybuty
• LastLocation
• Typ

Nie ustawiaj żadnych innych pól. Jeśli to zrobisz, Fleet Engine zwróci błąd. ponieważ te pola są tylko do odczytu lub można je zaktualizować tylko za pomocą wywołania funkcji UpdateDeliveryVehicle

Aby utworzyć pojazd bez ustawiania żadnych pól opcjonalnych, możesz zostawić Nie ustawiono pola DeliveryVehicle w CreateDeliveryVehicleRequest.

Poniższy przykład pokazuje, jak używać atrybutu Biblioteka Java gRPC Aby utworzyć pojazd:

    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

Aby utworzyć pojazd w środowisku serwera, wywołaj HTTP REST do CreateDeliveryVehicle:

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

<id> to unikalny identyfikator pojazdu dostawczego należącego do Twojej floty.

Nagłówek żądania musi zawierać pole Authorization z wartością Bearer <token>, gdzie <token> to token wydany przez fabrykę tokenów Fleet Engine.

Treść POST reprezentuje encję DeliveryVehicle, która ma zostać utworzona. Możesz określić tych pól opcjonalnych:

• atrybuty
• lastLocation
• typ

Przykładowe polecenie 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

W przypadku identyfikatorów określonych przez użytkowników Fleet Engine ignoruje pole name elementu DeliveryVehicle zgodnie ze wskazówkami dotyczącymi interfejsu API. Nie ustawiaj żadnych innych pól. Jeśli to zrobisz, Fleet Engine zwróci błąd. ponieważ te pola są tylko do odczytu lub można je zaktualizować tylko za pomocą wywołania funkcji UpdateDeliveryVehicle

Aby utworzyć pojazd bez ustawiania żadnych pól, pozostaw treść żądania POST. puste żądanie. Nowo utworzony pojazd wyodrębnia identyfikator z deliveryVehicleId w adresie URL żądania POST.

Przykładowe polecenie 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}"

Tworzenie zadania odbioru przesyłki

Zadanie odbioru przesyłki możesz utworzyć w Pakiet SDK sterowników lub ze środowiska serwera za pomocą protokołu gRPC albo REST.

gRPC

Poniższy przykład pokazuje, jak używać atrybutu Biblioteka Java gRPC Aby utworzyć zadanie odbioru przesyłki:

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

Aby utworzyć zadanie odbioru przesyłki w środowisku serwera, użyj wywołania HTTP REST do CreateTask:

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

&lt;id&gt; to unikalny identyfikator zadania. Nie może to być numer śledzenia przesyłki za dostawę. Jeśli nie masz w systemie identyfikatorów zadań, unikalny identyfikator uniwersalny (UUID).

Nagłówek żądania musi zawierać pole Authorization z wartością Bearer <token>, gdzie <token> to token wydany przez fabrykę tokenów Fleet Engine.

Treść żądania musi zawierać element Task:

• Pola wymagane:

  Pole	Wartość
  typ	Type.PICKUP
  stan	State.OPEN
  trackingId	Numer lub identyfikator, którego używasz do śledzenia przesyłki.
  plannedLocation	Lokalizacja, w której ma zostać wykonane zadanie (w tym przypadku). od miejsca odbioru przesyłki.
  taskDuration	Przewidywany czas w sekundach, jaki zajmuje odbiór przesyłki w miejscu odbioru.

• Pola opcjonalne:

  Pole	Wartość
  targetTimeWindow	Przedział czasu, w którym zadanie ma zostać wykonane. Nie nie wpływa na zachowanie routingu.
  atrybuty	Lista niestandardowych atrybutów Listy zadań. Każdy atrybut musi mieć unikalny klucz.

Podczas tworzenia wszystkie pozostałe pola elementu są ignorowane. Rzuty Fleet Engine wyjątek, jeśli żądanie zawiera przypisany element deliveryVehicleId. Ty przypisujesz zadania za pomocą funkcji UpdateDeliveryVehicleRequest. Więcej informacji: Przypisywanie zadań do pojazdu i UpdateDeliveryVehicleRequest.

Przykładowe polecenie 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

Tworzenie zadania dostawy

Utwórz zadanie dostarczenia przesyłki z poziomu Pakiet SDK sterowników lub ze środowiska serwera za pomocą protokołu gRPC albo REST.

gRPC

Poniższy przykład pokazuje, jak używać atrybutu Biblioteka Java gRPC Aby utworzyć zadanie dostawy:

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

Aby utworzyć zadanie dostawy w środowisku serwera za pomocą gRPC lub REST, wywołaj HTTP REST do CreateTask:

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

&lt;id&gt; to unikalny identyfikator zadania. Nie może to być numer śledzenia przesyłki za dostawę. Jeśli nie masz w systemie identyfikatorów zadań, unikalny identyfikator uniwersalny (UUID).

Nagłówek żądania musi zawierać pole Authorization z wartością Bearer <token>, gdzie <token> to token wydany przez fabrykę tokenów Fleet Engine.

Treść żądania musi zawierać element Task:

• Pola wymagane:

  Pole	Wartość
  typ	Type.DELIVERY
  stan	State.OPEN
  trackingId	Numer lub identyfikator, którego używasz do śledzenia przesyłki.
  plannedLocation	Lokalizacja, w której ma zostać wykonane zadanie (w tym przypadku). adres miejsca dostawy tej przesyłki.
  taskDuration	Przewidywany czas dostarczenia przesyłki (w sekundach) potrzebny do odesłania. w miejscu dostawy.

• Pola opcjonalne:

  Pole	Wartość
  targetTimeWindow	Przedział czasu, w którym zadanie ma zostać wykonane. Nie nie wpływa na zachowanie routingu.
  atrybuty	Lista niestandardowych atrybutów Listy zadań. Każdy atrybut musi mieć unikalny klucz.

Podczas tworzenia wszystkie pozostałe pola elementu są ignorowane. Rzuty Fleet Engine wyjątek, jeśli żądanie zawiera przypisany identyfikator deliveryVehicleId. Ty przypisujesz zadania za pomocą funkcji UpdateDeliveryVehicleRequest. Więcej informacji: Przypisywanie zadań do pojazdu i UpdateDeliveryVehicleRequest.

Przykładowe polecenie 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

Zbiorcze tworzenie zadań

Grupę zadań możesz utworzyć ze środowiska serwera za pomocą gRPC lub REST.

gRPC

Poniższy przykład pokazuje, jak używać atrybutu Biblioteka Java gRPC aby utworzyć 2 zadania: jedno związane z dostawą, a drugie związane z odbiorem lokalizacja:

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

Aby utworzyć w środowisku serwera zadanie dostawy i odbioru, utwórz Wywołanie HTTP REST do BatchCreateTasks:

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

Nagłówek żądania musi zawierać pole Authorization o wartości Bearer <token>, gdzie <token> to token wydany przez fabrykę tokenów Fleet Engine.

Treść żądania musi zawierać element BatchCreateTasksRequest:

• Pola wymagane:

  Pole	Wartość
  żądania	Tablica<CreateTasksRequest>

• Pola opcjonalne:

  Pole	Wartość
  nagłówek	`DeliveryRequestHeader`

Każdy element CreateTasksRequest w elemencie requests musi przejść tę samą weryfikację jako żądanie CreateTask, z wyjątkiem żądania parent i header są opcjonalne. Jeśli są ustawione, muszą być identyczne z atrybutem odpowiednie pola na najwyższym poziomie BatchCreateTasksRequest. Zobacz utworzyć zadanie związane z odbiorem przesyłki oraz utwórz zadanie dostawy aby poznać określone reguły weryfikacji dla każdej z nich.

Więcej informacji znajdziesz w dokumentacji interfejsu API dla BatchCreateTasks (gRPC, REST).

Przykładowe polecenie 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

Zaplanowana niedostępność

Możesz utworzyć zadanie wskazujące niedostępność (na przykład dla kierowcy przerwy lub paliwo) z Driver SDK lub ze środowiska serwera za pomocą protokołu gRPC albo REST. Zaplanowane zadanie dotyczące niedostępności nie może zawierać identyfikatora śledzenia. Możesz opcjonalnie podać lokalizację.

gRPC

Poniższy przykład pokazuje, jak używać atrybutu Biblioteka Java gRPC aby utworzyć zadanie dotyczące niedostępności:

    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

Aby utworzyć zadanie dotyczące niedostępności w środowisku serwera, użyj wywołania HTTP REST do CreateTask:

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

&lt;id&gt; to unikalny identyfikator zadania. Jeśli nie chcesz identyfikatorów zadań w systemie, możesz wygenerować uniwersalny (UUID).

Nagłówek żądania musi zawierać pole Authorization z wartością Bearer <token>, gdzie <token> to token wydany przez fabrykę tokenów Fleet Engine.

Treść żądania musi zawierać element Task:

• Pola wymagane:

  Pole	Wartość
  typ	Type.UNAVAILABLE
  stan	State.OPEN
  taskDuration	Długość przerwy w sekundach.

• Pola opcjonalne:

  Pole	Wartość
  plannedLocation	Lokalizacja przerwy, jeśli ma zostać wykonana w określonym miejscu.

Podczas tworzenia wszystkie pozostałe pola elementu są ignorowane. Rzuty Fleet Engine wyjątek, jeśli żądanie zawiera przypisany identyfikator deliveryVehicleId. Ty przypisujesz zadania za pomocą funkcji UpdateDeliveryVehicleRequest. Więcej informacji: Przypisywanie zadań do pojazdu i UpdateDeliveryVehicleRequest.

Przykładowe polecenie 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

Zaplanowane przystanki

Zaplanowane zadanie zatrzymania możesz utworzyć w Driver SDK lub ze środowiska serwera za pomocą protokołu gRPC albo REST. Zaplanowane zadanie zatrzymania może nie zawierać śledzenia ID.

gRPC

Poniższy przykład pokazuje, jak używać atrybutu Biblioteka Java gRPC aby utworzyć zaplanowane zatrzymywanie:

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

Aby utworzyć zaplanowane zadanie zatrzymania w środowisku serwera, użyj wywołania HTTP typu REST do CreateTask:

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

&lt;id&gt; to unikalny identyfikator zadania. Jeśli nie masz identyfikatorów zadań w systemie, można wygenerować unikalny identyfikator uniwersalny (UUID).

Nagłówek żądania musi zawierać pole Authorization z wartością Bearer <token>, gdzie <token> to token wydany przez fabrykę tokenów Fleet Engine.

Treść żądania musi zawierać element Task:

• Pola wymagane:

  Pole	Wartość
  typ	Type.SCHEDULED_STOP
  stan	State.OPEN
  plannedLocation	Lokalizacja przystanku.
  taskDuration	Przewidywany czas zatrzymania w sekundach.

• Pola opcjonalne:

  • Brak

Podczas tworzenia wszystkie pozostałe pola elementu są ignorowane. Rzuty Fleet Engine wyjątek, jeśli żądanie zawiera przypisany identyfikator deliveryVehicleId. Ty przypisujesz zadania za pomocą funkcji UpdateDeliveryVehicleRequest. Więcej informacji: Przypisywanie zadań do pojazdu i UpdateDeliveryVehicleRequest.

Przykładowe polecenie 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

Ustaw docelowy przedział czasu

Przedział czasu docelowego to TimeWindow w trakcie których ma zostać wykonane. Na przykład, jeśli komunikujesz się przedział czasu dostawy do adresatów, możesz użyć czasu docelowego zadania okno, aby zarejestrować ten przedział czasu i generować alerty lub przeanalizować po podróży swoją skuteczność za pomocą tego pola.

Przedział czasu docelowego składa się z godziny rozpoczęcia i godziny zakończenia. Można go ustawić dowolnego typu. Przedział czasu docelowego nie ma wpływu na routing zachowanie użytkownika.

gRPC

Poniższy przykład pokazuje, jak używać atrybutu Biblioteka Java gRPC aby ustawić przedział czasowy dla zadania:

    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

Aby ustawić przedział czasu zadania za pomocą protokołu HTTP, wywołaj UpdateTask:

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

&lt;id&gt; to unikalny identyfikator zadania.

Nagłówek żądania musi zawierać pole Authorization z wartością Bearer <token>, gdzie <token> to token wydany przez fabrykę tokenów Fleet Engine.

Treść żądania musi zawierać element Task:

• Pola wymagane:

  Pole	Wartość
  targetTimeWindow	Przedział czasu, w którym zadanie ma zostać wykonane. To ustawienie nie ma wpływu na routing

• Pola opcjonalne:

  • Brak

Wszystkie pozostałe pola elementu są ignorowane podczas aktualizacji.

Przykładowe polecenie 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

Ustaw konfigurację widoczności śledzenia zadań

Widoczność danych w bibliotece śledzenia przesyłki oraz tych danych zwróconymi z wywołania do GetTaskTrackingInfo można kontrolować dla poszczególnych zadań na podstawie TaskTrackingViewConfig. w tym zadaniu. Zobacz Aktywne zadania związane z pojazdem . Można to zrobić podczas tworzenia lub aktualizowania zadanie. Oto przykład aktualizowania zadania za pomocą tej konfiguracji:

gRPC

Poniższy przykład pokazuje, jak używać atrybutu Biblioteka Java gRPC aby ustawić konfigurację widoku śledzenia zadań:

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

Aby ustawić okno konfiguracji widoku śledzenia zadań za pomocą protokołu HTTP, wywołaj UpdateTask:

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

&lt;id&gt; to unikalny identyfikator zadania.

Nagłówek żądania musi zawierać pole Authorization z wartością Bearer <token>, gdzie <token> to token wydany przez fabrykę tokenów Fleet Engine.

Treść żądania musi zawierać element Task:

• Pola wymagane:

  Pole	Wartość
  taskTrackingViewConfig	konfigurację śledzenia zadań, która określa, które elementy danych są widoczne dla użytkowników w określonych okolicznościach.

• Pola opcjonalne:

  • Brak

Wszystkie pozostałe pola elementu są ignorowane podczas aktualizacji.

Przykładowe polecenie 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

Przypisywanie zadań do pojazdu

Przypisujesz zadania do pojazdu dostawczego, aktualizując kolejność zadań dla pojazdu. Kolejność zadań dla pojazdu jest określana na podstawie listy możesz przypisać więcej niż 1 zadanie. do każdego przystanku. Więcej informacji: Zmień kolejność zadań.

Aby zmienić dostawę z jednego pojazdu na inny, zamknij pierwotne zadanie a następnie utwórz ją ponownie, zanim przypiszesz mu nowy pojazd. Jeśli zaktualizujesz zadanie kolejność zadań, które zostało już przypisane; do innego pojazdu, pojawi się błąd.

Zaktualizuj kolejność zadań

Możesz zaktualizować zadania związane z zamówieniem przypisane do pojazdu, które są wykonywane na Driver SDK lub środowisku serwera. Nie stosuj obu metod, aby uniknąć wyścigu w warunkach wyścigowych i utrzymywania jednego źródła prawdy.

Gdy zaktualizujesz kolejność zadań w pojeździe, funkcja wykona też te działania:

• Przypisuje nowe zadania do pojazdu.
• Zamyka wszystkie zadania, które zostały wcześniej przypisane do pojazdu, ale nie zostały według zaktualizowanej kolejności.

Aby zmienić dostawę z jednego pojazdu na inny, zamknij oryginalne zadanie a następnie utwórz ją ponownie, zanim przypiszesz mu nowy pojazd. Jeśli zaktualizujesz zadanie kolejność zadań, które zostało już przypisane; do innego pojazdu, pojawi się błąd.

Kolejność zadań możesz zmienić w każdej chwili.

gRPC

Poniższy przykład pokazuje, jak używać atrybutu Biblioteka Java gRPC aby zaktualizować kolejność zadań w pojeździe:

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

Aby zaktualizować kolejność zadań dla pojazdu w środowisku serwera, wykonaj wywołanie HTTP REST do UpdateDeliveryVehicle:

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

&lt;id&gt; to unikalny identyfikator pojazdu dostawczego należącego do Twojej floty. dla których chcesz zaktualizować kolejność zadań. To identyfikator, który określonych podczas tworzenia pojazdu.

Nagłówek żądania musi zawierać pole Authorization z wartością Bearer <token>, gdzie <token> to token wydany przez fabrykę tokenów Fleet Engine.

Treść żądania musi zawierać element DeliveryVehicle:

• Pola wymagane:

  Pole	Wartość
  remainingVehicleJourneySegments	Lista segmentów ścieżki dla zadań w kolejności ich wykonania. Pierwsze zadanie na liście jest wykonywane jako pierwsze.
  remainingVehicleJourneySegments[i].stop	Zatrzymanie zadania i na liście.
  remainingVehicleJourneySegments[i].stop.plannedLocation	Planowana lokalizacja przystanku.
  remainingVehicleJourneySegments[i].stop.tasks	Lista zadań do wykonania na tym postoju.
  remainingVehicleJourneySegments[i].stop.state	State.NEW

• Pola opcjonalne:

  • Brak

Wszystkie pozostałe pola elementu są ignorowane podczas aktualizacji.

Przykładowe polecenie 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

Pojazd jest w drodze do następnego przystanku

Należy powiadamiać Fleet Engine, gdy pojazd odjeżdża z przystanku lub się rozpoczyna nawigacji. Możesz powiadomić Fleet Engine z poziomu Driver SDK lub ze środowiska serwera za pomocą protokołu gRPC albo REST. Nie stosuj obu metod, aby uniknąć wyścigu warunki i utrzymanie jednego źródła danych.

gRPC

Poniższy przykład pokazuje, jak używać atrybutu Biblioteka Java gRPC aby powiadomić Fleet Engine o tym, że pojazd jest w drodze do następnego przystanku.

    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

Aby powiadomić Fleet Engine o tym, że pojazd jest w drodze do następnego przystanku , wyślij wywołanie HTTP REST do UpdateDeliveryVehicle:

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

&lt;id&gt; to unikalny identyfikator pojazdu dostawy należącego do Twojej floty. dla których chcesz zaktualizować kolejność zadań. To identyfikator, który określonych podczas tworzenia pojazdu.

Nagłówek żądania musi zawierać pole Authorization z wartością Bearer <token>, gdzie <token> to token wydany przez fabrykę tokenów Fleet Engine.

Treść żądania musi zawierać element DeliveryVehicle:

• Pole wymagane:

  Pole	Wartość
  remainingVehicleJourneySegments	Lista pozostałych przystanków dla pojazdów ze stanami oznaczonymi jako stan.NOWY. Pierwszy przystanek na liście musi mieć stan State.ENROUTE.

• Pola opcjonalne:

  • Brak

Wszystkie pozostałe pola elementu są ignorowane w powiadomieniu.

Przykładowe polecenie 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

Zaktualizuj lokalizację pojazdu

Jeśli nie używasz pakietu Driver SDK do aktualizowania lokalizacji pojazdu, możesz bezpośrednie połączenie z lokalizacją pojazdu we Fleet Engine. W przypadku każdego aktywnego pojazdu: Fleet Engine oczekuje aktualizacji lokalizacji co najmniej raz na minutę i nie częściej niż co 5 sekund.

gRPC

Poniższy przykład pokazuje, jak używać atrybutu Biblioteka Java gRPC aby zaktualizować lokalizację pojazdu we Fleet Engine:

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 myDeliveryVehicle = DeliveryVehicle.newBuilder()
    .setLastLocation(DeliveryVehicleLocation.newBuilder()
        .setSupplementalLocation(LatLng.newBuilder()
            .setLatitude(37.3382)
            .setLongitude(121.8863))
        .setSupplementalLocationTime(now())
        .setSupplementalLocationSensor(DeliveryVehicleLocationSensor.CUSTOMER_SUPPLIED_LOCATION)
        .setSupplementalLocationAccuracy(DoubleValue.of(15.0)))  // Optional
    .build();

// DeliveryVehicle request
UpdateDeliveryVehicleRequest updateDeliveryVehicleRequest =
  UpdateDeliveryVehicleRequest.newBuilder()  // No need for the header
      .setName(vehicleName)
      .setDeliveryVehicle(myDeliveryVehicle)
      .setUpdateMask(FieldMask.newBuilder()
          .addPaths("last_location"))
      .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

Aby zaktualizować lokalizację pojazdu we Fleet Engine za pomocą protokołu HTTP REST, wywołaj UpdateDeliveryVehicle:

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

&lt;id&gt; to unikalny identyfikator pojazdu dostawy w flotę urządzeń, w której chcesz zaktualizować lokalizację. To identyfikator, który określonych podczas tworzenia pojazdu.

Nagłówek żądania musi zawierać pole Authorization z wartością Bearer <token>, gdzie <token> to token wydany przez fabrykę tokenów Fleet Engine.

Treść żądania musi zawierać element DeliveryVehicle:

• Pole wymagane:

  Pole	Wartość
  lastLocation.supplementalLocation	Lokalizacja pojazdu.
  lastLocation.supplementalLocationTime	Ostatnia znana sygnatura czasowa, kiedy pojazd znajdował się w tym miejscu.
  lastLocation.supplementalLocationSensor	Pole powinno zawierać CUSTOMER_SUPPLIED_LOCATION.

• Pola opcjonalne:

  Pole	Wartość
  lastLocation.supplementalLocationAccuracy	Dokładność podanej lokalizacji w metrach.

Przykładowe polecenie 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
{
  "lastLocation": {
    "supplementalLocation": {"latitude": 12.1, "longitude": 14.5},
    "supplementalLocationTime": "$(date -u --iso-8601=seconds)",
    "supplementalLocationSensor": "CUSTOMER_SUPPLIED_LOCATION",
    "supplementalLocationAccuracy": 15
  }
}
EOM

Pojazd zbliża się do przystanku

Musisz powiadamiać Fleet Engine, gdy pojazd znajdzie się na przystanku. Możesz powiadamiać Fleet Engine z Driver SDK lub ze środowiska serwera za pomocą protokołu gRPC albo REST. Nie stosuj obu metod, aby uniknąć wyścigu warunki i utrzymanie jednego źródła danych.

gRPC

Poniższy przykład pokazuje, jak używać atrybutu Biblioteka Java gRPC aby powiadomić Fleet Engine o zatrzymaniu pojazdu:

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

Aby powiadomić Fleet Engine o przyjeździe pojazdu ze środowiska serwera, Wykonaj wywołanie HTTP REST do UpdateDeliveryVehicle:

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

&lt;id&gt; to unikalny identyfikator pojazdu dostawy należącego do Twojej floty. dla których chcesz zaktualizować kolejność zadań. To identyfikator, który określonych podczas tworzenia pojazdu.

Nagłówek żądania musi zawierać pole Authorization z wartością Bearer <token>, gdzie <token> to token wydany przez fabrykę tokenów Fleet Engine.

Treść żądania musi zawierać element DeliveryVehicle:

• Pola wymagane:

  Pole	Wartość
  remainingVehicleJourneySegments	Przystanek, do którego dotarłeś, ma ustawiony stan State.ARRIVED, a następnie lista pozostałych przystanków z oznaczeniami jako stanowe.NOWE.

• Pola opcjonalne:

  • Brak

Wszystkie pozostałe pola elementu są ignorowane podczas aktualizacji.

Przykładowe polecenie 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

Pojazd zatrzymuje się

Gdy pojazd się zatrzyma. To powoduje wszystkie zadania powiązane z przystankiem zostaną ustawione na ZAMKNIĘTE. Dostępne opcje powiadamia Fleet Engine z Driver SDK lub ze środowiska serwera za pomocą protokołu gRPC albo REST. Nie stosuj obu metod, aby uniknąć wyścigów i utrzymać jedno źródło prawdy.

gRPC

Poniższy przykład pokazuje, jak używać atrybutu Biblioteka Java gRPC w celu powiadomienia Fleet Engine o zatrzymaniu pojazdu.

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

Aby powiadomić Fleet Engine o zakończeniu zatrzymania ze środowiska serwera, Wykonaj wywołanie HTTP REST do UpdateDeliveryVehicle:

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

&lt;id&gt; to unikalny identyfikator pojazdu dostawy należącego do Twojej floty. dla których chcesz zaktualizować kolejność zadań. To identyfikator, który określonych podczas tworzenia pojazdu.

Nagłówek żądania musi zawierać pole Authorization z wartością Bearer <token>, gdzie <token> to token wydany przez fabrykę tokenów Fleet Engine.

Treść żądania musi zawierać element DeliveryVehicle:

• Pola wymagane:

  Pole	Wartość
  remaining_vehicle_journey_segments	Ukończonego przystanku nie powinno być już na liście na pozostałych przystankach.

• Pola opcjonalne:

  • Brak

Wszystkie pozostałe pola elementu są ignorowane podczas aktualizacji.

Przykładowe polecenie 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}"
              }
            ]
          }
        }
      ]
    }
    EOM

Aktualizowanie zadania

Większość pól zadań nie można zmienić. Można jednak zmienić stan, wyniku zadania, czasu jego realizacji, lokalizacji wyniku zadania i atrybutów według bezpośrednio aktualizując encję zadania. Jeśli na przykład zadanie nie zawiera została przypisana do pojazdu, możesz zamknąć zadanie, aktualizując bezpośrednio.

gRPC

Oto przykład aktualizowania zadania za pomocą gRPC.

REST

Oto przykład aktualizowania zadania za pomocą protokołu REST.

Zamykanie zadania

Aby zamknąć zadanie przypisane do pojazdu, powiadom o tym fakcie Fleet Engine. że pojazd zakończył zatrzymanie na miejscu, w którym odbywa się zadanie lub usunąć go z listy postojów. W tym celu możesz ustawić listę pozostały pojazd zatrzymuje się tak samo jak podczas aktualizowania kolejności zadań. dla pojazdu.

Jeśli zadanie nie zostało jeszcze przypisane do pojazdu i trzeba je zamknąć, zaktualizuj zadanie do stanu ZAMKNIĘTE. Nie możesz jednak ponownie otworzyć ZAMKNIĘTEGO zadania.

Zamknięcie zadania nie oznacza powodzenia ani niepowodzenia. Wskazuje on, że zadanie nie jest już uznawane za trwające. W przypadku śledzenia przesyłki ważne jest, aby wskazać rzeczywisty wynik zadania, aby było ono wynik optymalizacji.

gRPC

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) // You can only directly CLOSE a
  .build();                    // task that 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;
}

REST

Aby oznaczyć zadanie jako zamknięte w środowisku serwera, wyślij wywołanie HTTP REST do UpdateTask:

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

&lt;id&gt; to unikalny identyfikator zadania.

Nagłówek żądania musi zawierać pole Authorization z wartością Bearer <token>, gdzie <token> to token wydany przez fabrykę tokenów Fleet Engine.

W treści żądania musisz umieścić element Task:

• Pola wymagane:

  Pole	Wartość
  stan	State.CLOSED

• Pola opcjonalne:

  Pole	Wartość
  taskOutcome	Wynik.SUCCEEDED lub Wynik.FAILED
  taskOutcomeTime	Czas ukończenia zadania.
  taskOutcomeLocation	Lokalizacja, w której zadanie zostało ukończone. Domyślnie Fleet Engine ustawia do ostatniej lokalizacji pojazdu, chyba że zostanie zastąpiona ręcznie przez dostawcę.

Wszystkie pozostałe pola elementu są ignorowane podczas aktualizacji.

Przykładowe polecenie 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

Określanie wyniku i lokalizacji zadania

Zamknięcie zadania nie oznacza powodzenia ani niepowodzenia, zadanie nie jest już uznawane za trwające. W przypadku śledzenia przesyłki ważne jest, aby pokazać rzeczywisty wynik zadania, aby może zostać wyświetlony wynik realizacji usługi, a usługi będą rozliczane prawidłowo. Po skonfigurowaniu tego działania nie można zmienić jego wyniku. Możesz jednak zmienić czas i lokalizację wyniku zadania po ich ustawieniu.

Zadania, które są w stanie ZAMKNIĘTE, mogą mieć następujące wyniki: ZAKOŃCZONO lub NIEUDAŁO SIĘ. Fleet Engine nalicza opłaty tylko za zadania dostawy ze stanem UDAŁO SIĘ.

Zaznaczając wynik zadania, Fleet Engine automatycznie wypełnia pole lokalizację wyniku zadania z ostatnią znaną lokalizacją pojazdu. Dostępne opcje zastąpić to zachowanie.

gRPC

Podczas ustawiania wyniki. Ustawienie lokalizacji uniemożliwia Fleet Engine jej ustawienie na wartość domyślną lokalizacji pojazdu. Możesz też zastąpić lokalizację wyniku zadania we Fleet Engine ustawić je później. Fleet Engine nigdy nie zastępuje lokalizacji wyniku zadania podane przez reklamodawcę. Nie możesz ustawić lokalizacji wyniku zadania dla zadania który nie ma ustawionego wyniku zadania. Możesz ustawić wynik dla obu działań i lokalizacja wyniku w ramach tego samego żądania.

Poniższy przykład pokazuje, jak używać atrybutu Biblioteka Java gRPC aby ustawić wynik zadania jako SUCCEEDED i ustawić lokalizację, w której ukończono:

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;
}

REST

Aby oznaczyć zadanie jako ukończone w środowisku serwera: Wykonaj wywołanie HTTP REST do UpdateTask:

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

&lt;id&gt; to unikalny identyfikator zadania.

Nagłówek żądania musi zawierać pole Authorization z wartością Bearer <token>, gdzie <token> to token wydany przez fabrykę tokenów Fleet Engine.

Treść żądania musi zawierać element Task:

• Pola wymagane:

  Pole	Wartość
  taskOutcome	Wynik.SUCCEEDED lub Wynik.FAILED

• Pola opcjonalne:

  Pole	Wartość
  taskOutcomeLocation	Lokalizacja, w której zadanie zostało ukończone. Jeśli nie zostanie ustawiona, Fleet Engine domyślnie ustawiana jest ostatnia lokalizacja pojazdu.
  taskOutcomeTime	Sygnatura czasowa ukończenia zadania.

Wszystkie pozostałe pola elementu są ignorowane podczas aktualizacji.

Przykładowe polecenie 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

Przekierowywanie dostawy

Po utworzeniu zadania dotyczącego dostawy nie można zmienić jego planowanej lokalizacji. Aby przekierować przesyłkę, zamknij zadanie dostawy bez ustawienia możesz utworzyć nowe zadanie ze zaktualizowaną, zaplanowaną lokalizacją. Po utworzeniu nowego zadania przypisz je do tego samego pojazdu. Więcej Więcej informacji znajdziesz w artykule o zamykaniu zadań związanych z dostawą oraz przypisać zadanie.

Korzystanie z pojazdów dostarczających i dostarczających

Jeśli używasz pojazdów dostawczych do transportu przesyłek do pojazdów dostawczych w ciągu dnia modelować przesyłanie przesyłek jako zaplanowane zatrzymywanie dla pojazdu dostawczego. Aby zapewnić dokładne śledzenie lokalizacji, przypisz tylko zadania dostarczenia przesyłki dla przesłanej przesyłki po jej załadowaniu na pojazdem dostawczym. Więcej informacji znajdziesz w artykule o zaplanowanym przystanku.

Przechowywanie stanu wysyłki i innych metadanych

Po ukończeniu zadania dotyczącego dostawy zapisywane są jego stan i wynik. w zadaniu. Możesz jednak zaktualizować inne metadane związane z dostawą. Aby przechowywać inne metadane, poza usługą Fleet Engine, użyj identyfikatora śledzenia z zadaniem jako kluczem w tabeli zewnętrznej.

Więcej informacji znajdziesz w artykule Okres wykonywania zadania.

Wyszukaj pojazd

Pojazd możesz wyszukać w Driver SDK lub ze środowiska serwera za pomocą protokołu gRPC albo REST.

gRPC

Poniższy przykład pokazuje, jak używać atrybutu Biblioteka Java gRPC aby wyszukać pojazd:

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

Aby wyszukać pojazd w środowisku serwera: Wykonaj wywołanie HTTP REST do GetVehicle:

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

&lt;id&gt; to unikalny identyfikator zadania.

&lt;vehicleId&gt; to identyfikator pojazdu, który chcesz wyszukać.

Nagłówek żądania musi zawierać pole Authorization z wartością Bearer <token>, gdzie <token> to token wydany przez fabrykę tokenów Fleet Engine.

Treść żądania musi być pusta.

Jeśli wyszukiwanie zakończy się powodzeniem, treść odpowiedzi będzie zawierać element dotyczący pojazdu.

Przykładowe polecenie 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}"

Wyszukiwanie zadania

Możesz wyszukać zadanie ze środowiska serwera za pomocą gRPC lub REST. Pakiet Driver SDK nie pomaga wyszukiwać zadanie.

gRPC

Poniższy przykład pokazuje, jak używać atrybutu Biblioteka Java gRPC aby wyszukać zadanie:

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

Aby wyszukać zadanie w środowisku serwera, Wykonaj wywołanie HTTP REST do GetTask:

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

&lt;id&gt; to unikalny identyfikator zadania.

&lt;taskId&gt; to identyfikator zadania, które chcesz wyszukać.

Nagłówek żądania musi zawierać pole Authorization z wartością Bearer <token>, gdzie <token> to token wydany przez fabrykę tokenów Fleet Engine.

Treść żądania musi być pusta.

Jeśli wyszukiwanie zakończy się powodzeniem, treść odpowiedzi będzie zawierać encję zadania.

Przykładowe polecenie 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}"

Wyszukuj informacje o zadaniu związanym z dostawą według identyfikatora śledzenia

Informacje o zadaniach związanych z dostawą możesz wyszukiwać na następujące sposoby: każdy z nich ma inny cel:

• według identyfikatora zadania: używane przez użytkowników, takich jak operatorzy floty, którzy mają dostęp do pełny widok danych zadania.
• za pomocą identyfikatora śledzenia: używany przez oprogramowanie klienta w celu udostępniania informowania użytkownika, na przykład o tym, kiedy ma przyjść do niego przesyłka.

W tej sekcji omówiono wyszukiwanie informacji o zadaniach przy użyciu identyfikatora śledzenia. Jeśli chcesz aby wyszukać zadanie według identyfikatora zadania, przejdź do sekcji Wyszukiwanie zadania.

Aby wyszukiwać informacje według identyfikatora śledzenia, możesz skorzystać z jednej z tych opcji:

• Wyszukiwania w Javie przy użyciu gRPC
• Wyszukiwania przy użyciu HTTP

Wymagania dotyczące wyszukiwania

• Informacje o dostawie podane przez identyfikator śledzenia są zgodne z regułami widoczności napisano w Kontrolowanie widoczności śledzonych lokalizacji.

• Użyj Fleet Engine do wyszukiwania informacji o dostawie według identyfikatora śledzenia. Kierowca Pakiet SDK nie obsługuje wyszukiwania informacji według identyfikatora śledzenia. Do tego celu we flocie Engine, korzystasz ze środowiska serwera lub przeglądarki.

• Aby ograniczyć zagrożenia bezpieczeństwa, używaj najwęższego tokena. Jeśli na przykład użyjesz Delivery Consumer Token, wszystkie wywołania interfejsu Fleet Engine Deliveries API należy podać wyłącznie istotne informacje dotyczące danego użytkownika, takie jak firma kurierska czy odbiorcy przesyłki. Pozostałe informacje w odpowiedziach zostaną usunięte. Więcej informacji o tokenach znajdziesz tutaj: Tworzenie tokena internetowego JSON (JWT) na potrzeby autoryzacji

Wyszukiwanie w Javie przy użyciu gRPC

Poniższy przykład pokazuje, jak używać atrybutu Biblioteka Java gRPC do wyszukania informacji o zadaniu dostawy według identyfikatora śledzenia.

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;
}

Wyszukiwania z użyciem HTTP

Aby wyszukać zadanie związane z dostawą w przeglądarce, użyj wywołania HTTP typu REST do GetTaskTrackingInfo:

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

&lt;tracking_id&gt; to identyfikator śledzenia powiązany z zadaniem.

Nagłówek żądania musi zawierać pole Authorization z wartością Bearer <token>, gdzie <token> to token wydany przez fabrykę tokenów Fleet Engine.

Jeśli wyszukiwanie zakończy się powodzeniem, treść odpowiedzi będzie zawierać taskTrackingInfo podmiotu zabezpieczeń.

Przykładowe polecenie 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}"

Wyświetlenie listy zadań

Możesz wyświetlić listę zadań ze środowiska serwera lub przeglądarki. Pakiet Driver SDK nie w których możesz tworzyć listy zadań.

Zadania związane z wyświetlaniem listy wymagają szerokiego dostępu do zadań. Zadania związane z wyświetlaniem listy są przeznaczone tylko dla: zaufanych użytkowników. Użyj uwierzytelniania superużytkownika usługi dostarczania Tokeny podczas wysyłania żądań list zadań.

Te pola na liście zadań są usunięte:

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

Zadania na liście można filtrować według większości właściwości zadań. Jeśli chcesz użyć składni zapytania filtra, patrz AIP-160. Lista poniżej zawiera prawidłowe zadanie właściwości, których możesz używać do filtrowania:

• atrybuty
• delivery_vehicle_id
• stan
• planned_location
• task_duration
• task_outcome
• task_outcome_location
• task_outcome_location_source
• task_outcome_time
• tracking_id
• typ

Użyj tych formatów pól na podstawie propozycji ulepszeń interfejsu API Google:

Pełną listę zapytań związanych z filtrami znajdziesz w sekcji AIP-160. .

Jeśli nie podasz zapytania filtra, zostaną wyświetlone wszystkie zadania.

Listy zadań są podzielone na strony. Rozmiar strony można określić w żądaniach wyświetlenia listy zadań. Jeśli podasz rozmiar strony, liczba zwróconych zadań nie będzie większa. niż określono rozmiar strony. Jeśli nie ma rozmiaru strony, odpowiednia domyślna wartość i zgody na określone zastosowania ich danych. Jeśli żądany rozmiar strony przekracza wewnętrzną wartość maksymalną, używana jest wewnętrzna wartość maksymalna.

Lista zadań może zawierać token odczytu następnej strony wyników. Użyj tokena strony z żądaniem, które jest identyczne z poprzednim żądaniem aby pobrać następną stronę zadań. Kiedy zwrócony token strony jest puste, nie ma więcej zadań do pobrania.

gRPC

Poniższy przykład pokazuje, jak używać atrybutu Biblioteka Java gRPC aby wyświetlić listę zadań dla pola deliveryVehicleId i atrybut zadania. Zakończone powodzeniem odpowiedź może być nadal pusta. Pusta odpowiedź oznacza, że żadna Lista zadań nie jest powiązany z podanym parametrem deliveryVehicleId.

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

Aby wyświetlić listę zadań z przeglądarki, wyślij wywołanie HTTP REST do ListTasks:

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

Aby zastosować filtr do wymienionych zadań, dodaj „filtr” Parametr adresu URL z zapytaniem filtra ze zmianą znaczenia w adresie URL jako jego wartością.

Nagłówek żądania musi zawierać pole Authorization z wartością Bearer <token>, gdzie <token> to token wydany przez fabrykę tokenów Fleet Engine.

Jeśli wyszukiwanie zakończy się powodzeniem, treść odpowiedzi będzie zawierać dane o następującej strukturze:

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

Pomyślna odpowiedź może być pusta. Pusta odpowiedź oznacza, że nie Znalezione zadania spełniają określone kryteria filtra.

Przykładowe polecenie 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}"

Wyświetl listę pojazdów dostawczych

Możesz wyświetlić listę pojazdów dostawy ze środowiska serwera lub przeglądarki. Kierowca Pakiet SDK nie obsługuje wyświetlania informacji o pojazdach dostawczych.

Pojazdy dostawcze proszą o szeroki dostęp do pojazdów dostawczych. przeznaczone tylko dla zaufanych użytkowników. Użyj usługi Delivery Fleet Reader lub Delivery Super tokeny uwierzytelniania użytkowników podczas wysyłania żądań list pojazdów dostarczania.

Ze względu na wpływ pojazdów na liście pojazdów te pola zostały usunięte dotyczące rozmiaru odpowiedzi:

• CurrentRouteSegment
• RemainingVehicleJourneySegments

Możesz filtrować listę pojazdów dostawy według właściwości attributes. Dla: przykład, aby przesłać zapytanie do atrybutu o kluczu my_key o wartości my_value, skorzystaj z funkcji attributes.my_key = my_value Aby wysyłać zapytania dotyczące wielu atrybutów, połącz zapytania używając operatorów logicznych AND i OR, np. attributes.key1 = value1 AND attributes.key2 = value2. Pełną listę znajdziesz na stronie AIP-160. opis składni zapytań filtra.

Możesz przefiltrować wymienione pojazdy dostawcze według lokalizacji za pomocą żądania viewport . Parametr żądania viewport definiuje widoczne obszary przy użyciu 2 ograniczeń współrzędne: długość i szerokość geograficzna high (północny wschód) oraz low (południowy zachód) . Żądania, które zawierają dużą szerokość geograficzną, są odrzucane która geograficznie jest mniejsza niż niska szerokość geograficzna.

Listy pojazdów dostawy są domyślnie podzielone na strony w odpowiednim rozmiarze. Jeśli określisz rozmiar strony, żądanie zwróci tylko liczbę pojazdów określonych przez limit lub mniej. Jeśli żądany rozmiar strony przekracza wartość wewnętrzną wartość maksymalną, używana jest wewnętrzna wartość maksymalna. Stronę domyślną i maksymalną po 100 pojazdów.

Lista pojazdów dostawczych może zawierać token odczytu następnej strony wyników. Token strony występuje w odpowiedzi tylko wtedy, gdy więcej stron wyświetlania pojazdy są dostępne do pobrania. Aby wyświetlić następną stronę zadań, użyj token strony z żądaniem, które jest identyczne z poprzednim żądaniem. użytkownika.

gRPC

Poniższy przykład pokazuje, jak używać atrybutu Biblioteka Java gRPC do wyświetlania pojazdów dostawczych w konkretnym regionie z określonym atrybutem. O udana odpowiedź może być nadal pusta. Oznacza to, że nie pojazdy o określonym atrybucie znajdują się już w określonym obszarze.

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

Aby wyświetlić listę zadań z przeglądarki, wyślij wywołanie HTTP REST do ListDeliveryVehicles:

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

Aby zastosować filtr do wymienionych zadań, dodaj „filtr” Parametr adresu URL ze znakiem jako wartość zapytania filtra ze zmianą znaczenia w adresie URL.

Nagłówek żądania musi zawierać pole Authorization z wartością Bearer <token>, gdzie <token> to token wydany przez fabrykę tokenów Fleet Engine.

Jeśli wyszukiwanie zakończy się powodzeniem, treść odpowiedzi będzie zawierać dane o następującej strukturze:

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

Pomyślna odpowiedź może być pusta. Oznacza to, że nie znaleziono pojazdy dostawcze pasujące do określonego zapytania filtra i widocznego obszaru.

Przykładowe polecenie 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"

Śledzenie przesyłki

Dostępne są 2 opcje interfejsu Fleet Engine Deliveries API, aby umożliwić śledzenie przesyłek:

• Preferowana: użyj wartości Biblioteka JavaScriptu śledzenia przesyłki. Biblioteka umożliwia wizualizację położenia pojazdów i lokalizacji danych śledzonych przez Fleet Engine. Zawiera komponent mapy JavaScript który jest zwykłym zamiennikiem standardowego obiektu google.maps.Map, i komponentów danych, aby połączyć je z Fleet Engine. Ten komponent umożliwia zapewniają spersonalizowaną, animowaną funkcję śledzenia przesyłki z aplikacji internetowej lub mobilnej.

• Wdróż własne śledzenie przesyłek w ramach interfejsu Fleet Engine Deliveries API.

Najważniejsze jest wyszukiwanie zadań związanych z dostawą według identyfikatora śledzenia.

Jeśli używasz roli konsumenta dostarczania, wszystkie wywołania interfejsu Fleet Engine Deliveries API zwracają tylko te informacje istotne dla nadawcy lub odbiorcy. Wszystkie pozostałe informacje zawarte w odpowiedziach są usuwane. Ty odpowiadasz uwierzytelniania użytkowników. Ponadto informacje o lokalizacji są filtrowane na podstawie zadania, które jest już w toku. Podczas zadania dotyczącego niedostępności Dane o lokalizacji nie są udostępniane użytkownikowi.

Logowanie

Możesz skonfigurować usługę Fleet Engine tak, aby wysyłała logi RPC do Cloud Logging. Więcej Więcej informacji zawiera Logowanie.

Role i tokeny autoryzacji

Jak opisano w artykule Zarządzanie cyklem życia pojazdu i zadań. i notatki na temat autoryzacji dla poszczególnych przypadków użycia, dzięki czemu wywołania Fleet Engine wymagają uwierzytelniania za pomocą tokenów sieciowych JSON, które mają zostało podpisane przy użyciu danych logowania konta usługi. używane konta usługi; do przyznania tych tokenów może być 1 lub więcej ról, a każda z nich inny zestaw uprawnień.

Więcej informacji: Authentication and Authorization (Uwierzytelnianie i autoryzacja).

Rozwiązywanie typowych problemów

Jeśli napotkasz jakieś problemy, przeczytaj te sekcje, aby uzyskać pomoc.

Odporność

Fleet Engine nie jest uważany za źródło danych. Ty odpowiadasz do przywrócenia stanu systemu, jeśli jest to konieczne, bez Fleet Engine.

Utracony stan we Fleet Engine

Podczas pracy z Fleet Engine wdróż klienty, aby system naprawił się w razie awarii. Na przykład gdy Fleet Engine próbuje zaktualizować pojazdu, może odpowiedzieć z komunikatem o błędzie wskazującym, że pojazd nie istnieje. Następnie klient powinien odtworzyć pojazd w nowym stanie. Chociaż ten problem występuje rzadko, więc upewnij się, że Twój system jest wystarczająco odporny .

W skrajnie nieprawdopodobnym przypadku katastrofalnej awarii Fleet Engine może być konieczne odtworzenie większości lub wszystkich pojazdów i zadań. Jeśli częstotliwość tworzenia będzie zbyt duża, niektóre żądania mogą ponownie zostać odrzucone z powodu problemów z limitami, są kontrole limitów mające na celu uniknięcie ataków typu DoS. W takim przypadku zmniejsz wskaźnik odtworzenia, stosując strategię ponawiania dla ponownych prób.

Utracony stan w aplikacji kierowcy

Jeśli aplikacja sterownika ulegnie awarii, musi odtworzyć bieżący stan w pakiecie Driver SDK. Aplikacja powinna spróbować odtworzyć zadania, aby upewnić się, i przywrócić ich obecny stan. Aplikacja powinna też utwórz ponownie i jawnie ustaw listę przystanków dla pakietu Driver SDK.

Najczęstsze pytania

Co się stanie, jeśli kierowca zatrzyma się na niezrealizowane zadanie?

W takim przypadku najpierw zmień kolejność zadań, a potem postępuj jak zwykle, oznaczenie przyjazdu, zakończenia zadania i inne szczegóły. Jeśli tego nie zrobisz, system może stać się niespójny, szacowany czas dotarcia na miejsce może być nieprawidłowy. i mogą pojawić się nieoczekiwane błędy.