เริ่มต้นใช้งาน Fleet Engine สำหรับการติดตามการจัดส่ง

สร้างแบบจำลองกิจกรรมของยานพาหนะสำหรับระยะแรกและระยะสุดท้ายในการนำส่งด้วย Fleet Engine Deliveries API คุณใช้ API นี้ได้โดยใช้ Driver SDK สำหรับ Android และ iOS หรือใช้การเรียก HTTP REST หรือ gRPC โดยตรง

การตั้งค่าเบื้องต้น

คุณกำหนดค่า Fleet Engine Deliveries API ใน Google Cloud Console

• สำหรับข้อมูลเกี่ยวกับขั้นตอนที่ต้องดำเนินการภายในคอนโซลและวิธีสร้าง JSON Web Token สำหรับการให้สิทธิ์ โปรดดูที่การตรวจสอบสิทธิ์และการให้สิทธิ์

• โปรดดูรายละเอียดการใช้คอนโซลในเอกสารประกอบเกี่ยวกับ Google Cloud Console

ตรวจสอบการตั้งค่า

หลังจากสร้างบัญชีบริการแล้ว ให้ยืนยันว่าการตั้งค่าเสร็จสมบูรณ์แล้ว และคุณสร้างยานพาหนะสำหรับนำส่งได้ การยืนยันการตั้งค่าทันทีช่วยให้แน่ใจว่าคุณได้แก้ปัญหาการให้สิทธิ์ทั่วไปที่อาจเกิดขึ้นเมื่อตั้งค่าโปรเจ็กต์ ซึ่งการยืนยันการตั้งค่าทำได้ 2 วิธีดังนี้

• ทดสอบ 2 ส่วนสำคัญในการตั้งค่า ได้แก่ การลงชื่อโทเค็นการให้สิทธิ์และการสร้างยานพาหนะแบบทดลองใช้ด้วยยูทิลิตีบรรทัดคำสั่ง gcloud โปรดดูรายละเอียดในคู่มือการยืนยันการตั้งค่า

• ทดสอบการตั้งค่าด้วยสคริปต์ตัวอย่างการตรวจสอบสิทธิ์ของ Fleet Engine

ไลบรารีไคลเอ็นต์

ใช้ไลบรารีของไคลเอ็นต์ในภาษาโปรแกรมทั่วไปหลายภาษาเพื่อประสบการณ์ของนักพัฒนาซอฟต์แวร์ที่ดีกว่า gRPC หรือ REST แบบข้อมูลดิบ สำหรับวิธีการรับไลบรารีของไคลเอ็นต์สำหรับแอปพลิเคชันเซิร์ฟเวอร์ โปรดดูไลบรารีของไคลเอ็นต์

ตัวอย่าง Java ในเอกสารประกอบนี้จะถือว่าคุณคุ้นเคยกับ gRPC อยู่แล้ว

โครงสร้างข้อมูล

Fleet Engine Deliveries API ใช้โครงสร้างข้อมูล 2 แบบในการสร้างแบบจำลองการมารับและนำส่ง

• รถนำส่งที่ใช้ลำเลียงสินค้า
• งานรับและจัดส่งพัสดุ

นอกจากนี้ คุณยังใช้งานเพื่อสร้างแบบจำลองการหยุดพักคนขับรถและจุดหยุดพักตามกำหนดการตลอดทั้งวันด้วย

รถส่งของ

รถส่งของจะขนส่งสินค้าจากคลังสินค้าไปยังสถานที่นำส่ง และจากจุดรับไปยังคลังสินค้า ในบางกรณี พวกเขาอาจส่งการจัดส่งจากจุดรับสินค้าไปยังสถานที่นำส่งโดยตรง

ใช้ Driver SDK เพื่อสร้างออบเจ็กต์ DeliveryVehicle ใน Fleet Engine และส่งข้อมูลอัปเดตตำแหน่งสำหรับการจัดส่งและการติดตามกลุ่มรถ

งาน

สำหรับการดำเนินการต่างๆ ของยานพาหนะในระหว่างวัน คุณจะมอบหมายงานตามประเภทการทำงาน ดังนี้

• สำหรับการรับสินค้าและการนำส่ง ให้มอบหมายงานการจัดส่ง
• สำหรับกรณีที่คนขับไม่พร้อมให้บริการ เช่น ต้องพักเบรก ให้กำหนดงานที่ไม่พร้อมใช้งาน
• สำหรับงานที่ไม่มีการขับรถที่กล่องส่งสินค้าหรือตำแหน่งของลูกค้า ให้มอบหมายงานแวะพักที่กำหนดเวลาไว้

งานแต่ละงานที่คุณมอบหมายจะต้องมีรหัสงานที่ไม่ซ้ำกัน แต่งานนั้นจะใช้รหัสติดตามเดียวกันได้ เมื่อ Fleet Engine คำนวณกรอบเวลาเวลาถึงโดยประมาณของแต่ละงาน จะใช้งานทั้งหมดและลำดับในการกำหนดเวลาเพื่อทำการประมาณค่า ดูข้อมูลเพิ่มเติมเกี่ยวกับรหัสงานได้ในหลักเกณฑ์เกี่ยวกับรหัสงาน

หากต้องการสร้างงานใน Fleet Engine ให้ใช้ Driver SDK Task Manager

งานการจัดส่ง

สร้างงานการจัดส่งสำหรับทั้งการรับสินค้าและการจัดส่ง โดยระบุข้อมูลดังต่อไปนี้

• สถานที่รับสินค้าหรือจัดส่ง
• หมายเลขหรือรหัสติดตาม
• เวลาที่พักสายตาเพื่อเผื่อเวลาไว้ทำงานให้เสร็จ หาที่จอดรถ หรือเดินไปยังสถานที่ส่งของ
• รหัสงานที่ไม่ซ้ำกัน ดูหลักเกณฑ์เกี่ยวกับรหัสงาน

สำหรับข้อมูลเพิ่มเติม โปรดดูหัวข้อต่อไปนี้

Android

• สร้างงานรับสินค้าสำหรับการจัดส่ง
• สร้างงานการนำส่งการจัดส่ง

iOS

• GMTD DeliveryTaskManager
• GMTSTaskType

งานที่ไม่พร้อมใช้งาน

งานที่ไม่พร้อมใช้งานครอบคลุมระยะเวลาที่รถไม่พร้อมให้ไปรับหรือจัดส่ง เช่น ช่วงพักเพื่อเติมน้ำมันรถหรือการพักเบรก

สร้างงานที่ไม่พร้อมใช้งานด้วยข้อมูลต่อไปนี้

• ระยะเวลาของช่วงพัก
• (ไม่บังคับ) ตำแหน่งของช่วงพัก คุณไม่จำเป็นต้องระบุตำแหน่งที่เจาะจง แต่การทำเช่นนั้นจะทำให้ช่วงเวลาถึงโดยประมาณที่แม่นยำมากขึ้นตลอดทั้งวัน

หมายเหตุ: ระหว่างงานที่ไม่พร้อมใช้งาน เราจะไม่แชร์ข้อมูลตำแหน่งกับผู้ใช้ปลายทางของไลบรารีการติดตามการจัดส่ง อย่างไรก็ตาม ผู้จัดการกลุ่มยานพาหนะจะใช้ไลบรารี การติดตาม Fleet Tracking ได้

สำหรับข้อมูลเพิ่มเติม โปรดดูหัวข้อต่อไปนี้

Android

• ความไม่พร้อมให้บริการตามกำหนดเวลา

iOS

• GMTD DeliveryTaskManager
• GMTSTaskType

งานที่กําหนดเวลาไว้

สร้างงานการหยุดที่กำหนดเวลาไว้เพื่อสร้างแบบจำลองจุดแวะพักที่รถส่งของต้องดำเนินการ ตัวอย่างเช่น สร้างงานที่มีกำหนดเวลาสำหรับการแวะรับผู้โดยสารตามกำหนดประจำวันที่สถานที่ใดสถานที่หนึ่ง โดยไม่อิงตามการจัดส่งอื่นๆ หรือการรับสินค้าในสถานที่เดียวกัน คุณยังสามารถสร้างงานที่ต้องหยุดตามกำหนดการสำหรับคอลเล็กชันจากกล่องรับสัญญาณ หรือโมเดลการโอนยานพาหนะ-รถฟีดเดอร์ หรือหยุดที่ศูนย์บริการและจุดบริการได้อีกด้วย

สำหรับข้อมูลเพิ่มเติม โปรดดูหัวข้อต่อไปนี้

Android

• แวะพักตามกำหนดการ

iOS

• GMTD DeliveryTaskManager
• GMTSTaskType

หลักเกณฑ์เกี่ยวกับรหัสงาน

เมื่อสร้างรหัสงาน ให้ทำตามหลักเกณฑ์เกี่ยวกับเนื้อหาและรูปแบบต่อไปนี้

• สร้างรหัสงานที่ไม่ซ้ำกัน
• อย่าเปิดเผยข้อมูลส่วนบุคคลที่ระบุตัวบุคคลนั้นได้ (PII) หรือข้อมูลที่ล้างข้อความ
• ใช้สตริง Unicode ที่ถูกต้อง
• ใช้อักขระไม่เกิน 64 ตัว
• อย่าใส่อักขระ ASCII ใดๆ ต่อไปนี้: "/", ":", "\", "?" หรือ "#"
• ทำให้เป็นมาตรฐานตามแบบฟอร์มการปรับมาตรฐานรหัส C ของ Unicode

เคล็ดลับ: คุณสร้างรหัสงานได้โดยใช้กลไกแบบเป็นโปรแกรมใดก็ได้ที่ต้องการ Google ขอแนะนำให้ใช้เครื่องมือ UUID เวอร์ชัน 4

ตัวอย่างของรหัสงานที่ดีมีดังต่อไปนี้

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

ตารางต่อไปนี้แสดงตัวอย่างรหัสงานที่ไม่รองรับ

รหัสงานที่ไม่รองรับ	เหตุผล
8/31/2019-20:48-46.70746,-130.10807,-85.17909,61.33680	ละเมิดข้อกำหนดด้าน PII และอักขระ เช่น คอมมา จุด โคลอน และเครื่องหมายทับ
JohnDoe-577b484da26f-Cupertino-SantaCruz	ละเมิดข้อกำหนดเกี่ยวกับ PII
4R0oXLToF"112 ฤดูร้อน ดร. อีสต์ฮาร์ตฟอร์ด, CT06118"577b484da26f8a	ละเมิดข้อกำหนดด้าน PII และอักขระ เช่น ช่องว่าง คอมมา และเครื่องหมายคำพูด ยาวกว่า 64 อักขระ

แหล่งข้อมูลเพิ่มเติม

หากต้องการดูช่องเฉพาะที่มีอยู่ในโครงสร้างข้อมูลแต่ละรายการ โปรดดูเอกสารอ้างอิง API สำหรับ DeliveryVehicle (gRPC, REST) และ Task (gRPC, REST)

อายุการใช้งานของยานพาหนะ

ออบเจ็กต์ DeliveryVehicle แสดงยานพาหนะที่นำส่งไมล์แรกหรือสุดท้าย คุณสร้างออบเจ็กต์ DeliveryVehicle โดยใช้สิ่งต่อไปนี้

• รหัสของโปรเจ็กต์ Google Cloud ที่มีบัญชีบริการที่ใช้เรียก Fleet Engine API
• รหัสยานพาหนะที่ลูกค้าเป็นเจ้าของ

ใช้รหัสยานพาหนะที่ไม่ซ้ำกันสำหรับยานพาหนะแต่ละคัน อย่าใช้รหัสรถซ้ำ เว้นแต่ว่าไม่มีงานที่ทำอยู่สำหรับยานพาหนะเดิม

Fleet Engine จะลบออบเจ็กต์ DeliveryVehicle รายการที่ยังไม่ได้อัปเดตโดยใช้ UpdateDeliveryVehicle โดยอัตโนมัติหลังจากผ่านไป 7 วัน วิธี ดูว่ามียานพาหนะอยู่หรือไม่

1. โทรหา UpdateDeliveryVehicle
2. หากพบข้อผิดพลาด NOT_FOUND โปรดโทรหา CreateDeliveryVehicle เพื่อสร้างยานพาหนะอีกครั้ง หากมีการส่งคืนรถยนต์ คุณก็จะยังคงอัปเดตได้

หมายเหตุ: คุณจะได้รับข้อผิดพลาด หากเรียกใช้ CreateDeliveryVehicle ด้วยรหัสโปรเจ็กต์และรหัสยานพาหนะที่มีอยู่แล้ว

ประเภทยานพาหนะ

เอนทิตี VehicleType มีช่องที่ไม่บังคับของ VehicleType ซึ่งมี enum ของ Category ที่คุณระบุเป็น AUTO, TWO_WHEELER, BICYCLE หรือ PEDESTRIAN หากไม่ได้ตั้งค่าฟิลด์นี้ ค่าเริ่มต้นจะเป็น AUTO

การกำหนดเส้นทางทั้งหมดสำหรับยานพาหนะใช้ RouteTravelMode ที่เกี่ยวข้องสำหรับประเภทยานพาหนะ

แอตทริบิวต์ของยานพาหนะ

เอนทิตี DeliveryVehicle มีช่องที่ซ้ำของ DeliveryVehicleAttribute ListDeliveryVehicles API มีช่อง filter ที่สามารถจำกัดเอนทิตี DeliveryVehicle ที่แสดงผลไว้เฉพาะรายการที่มีแอตทริบิวต์ที่ระบุ DeliveryVehicleAttribute จะไม่ส่งผลต่อลักษณะการกำหนดเส้นทางของ Fleet Engine

อย่าใส่ข้อมูลส่วนบุคคลที่ระบุตัวบุคคลนั้นได้ (PII) หรือข้อมูลที่ละเอียดอ่อนในแอตทริบิวต์ เนื่องจากผู้ใช้อาจเห็นช่องนี้ได้

ชีวิตในการทำงาน

คุณสร้าง อัปเดต และค้นหางานใน Fleet Engine ได้ด้วยอินเทอร์เฟซ gRPC หรือ REST ของ Deliveries API

ออบเจ็กต์ Task มีช่องสถานะเพื่อติดตามความคืบหน้าผ่านวงจร ค่าจะย้ายจาก OPEN ไปยัง CLOSED ระบบจะสร้างงานใหม่ ในสถานะ "เปิด" ซึ่งระบุว่า

• ยังไม่มีการมอบหมายงานให้กับยานพาหนะที่นำส่งสินค้า
• ยานพาหนะที่นำส่งยังไม่ผ่านป้ายจอดรถที่ได้รับมอบหมายของงาน

หลักเกณฑ์ของงาน

คุณจะมอบหมายงานให้กับยานพาหนะได้เมื่ออยู่ในสถานะ "เปิด" เท่านั้น

คุณยกเลิกงานได้โดยการนำงานออกจากรายการจุดพักรถ ซึ่งจะตั้งค่าสถานะงานเป็น "ปิด" โดยอัตโนมัติ

เมื่อยานพาหนะของงานเสร็จสมบูรณ์

1. อัปเดตช่องผลลัพธ์ของงานเป็น "SUCCEEDED" หรือ "ล้มเหลว"

   หมายเหตุ: คุณตั้งค่าผลลัพธ์ของงานได้ทุกเมื่อทั้งก่อนหรือหลังจากที่งานเสร็จสิ้น แต่จะตั้งค่าได้เพียงครั้งเดียว

2. ระบุการประทับเวลาของเหตุการณ์

   จากนั้นไลบรารีการติดตามการจัดส่ง JavaScript จะระบุผลลัพธ์ของงาน และสถานะของงานจะถูกตั้งค่าเป็น "ปิด" โดยอัตโนมัติ ดูข้อมูลเพิ่มเติมได้ที่ติดตามการจัดส่งด้วยไลบรารีการติดตามการจัดส่งแบบ JavaScript

เช่นเดียวกับยานพาหนะ Fleet Engine จะลบงานที่ยังไม่ได้อัปเดตหลังจากผ่านไป 7 วัน และหากคุณพยายามสร้างงานด้วยรหัสที่มีอยู่แล้ว ระบบจะแสดงข้อผิดพลาด

หมายเหตุ: Fleet Engine ไม่รองรับการลบงานอย่างชัดแจ้ง บริการนี้จะลบงานโดยอัตโนมัติหากไม่มีการอัปเดตเป็นเวลา 7 วัน หากต้องการเก็บข้อมูลงานไว้นานกว่า 7 วัน คุณต้องใช้ความสามารถนั้นด้วยตนเอง

แอตทริบิวต์ของงาน

เอนทิตี Task มีช่องที่ซ้ำของ TaskAttribute ซึ่งอาจมีค่าจาก 3 ประเภทต่อไปนี้ ได้แก่ สตริง ตัวเลข และบูลีน ListTasks API มีช่อง filter ที่สามารถจำกัดเอนทิตี Task ที่แสดงผลไว้เฉพาะรายการที่มีแอตทริบิวต์ที่ระบุ แอตทริบิวต์งานจะไม่ส่งผลต่อ การทำงานของการกำหนดเส้นทาง Fleet Engine

อย่าใส่ข้อมูลส่วนบุคคลที่ระบุตัวบุคคลนั้นได้ (PII) หรือข้อมูลที่ละเอียดอ่อนอื่นๆ ในแอตทริบิวต์เนื่องจากผู้ใช้อาจเห็นแอตทริบิวต์เหล่านี้ได้

จัดการรถและวงจรงาน

โปรดทราบ: ระบบภายในของคุณทำหน้าที่เป็นแหล่งข้อมูลที่เชื่อถือได้ซึ่ง Fleet Engine Deliveries API สร้างขึ้นในนามของคุณ

หากต้องการจัดการอายุการใช้งานของยานพาหนะและงานในระบบ ให้ใช้ Fleet Engine Deliveries API เพื่อสร้าง อัปเดต และติดตามยานพาหนะของคุณและงานที่เกี่ยวข้อง

ในขณะเดียวกัน แอปพลิเคชันของผู้ขับจะสื่อสารกับ Fleet Engine โดยตรงเพื่ออัปเดตตำแหน่งของอุปกรณ์และข้อมูลเส้นทาง โมเดลนี้ช่วยให้ Fleet Engine จัดการตำแหน่งแบบเรียลไทม์ได้อย่างมีประสิทธิภาพ และส่งตำแหน่งไปยังไลบรารีการติดตามโดยตรง ซึ่งคุณใช้เพื่ออัปเดตสถานะคำสั่งซื้อของผู้บริโภคต่อผู้บริโภคได้

ตัวอย่างเช่น สมมติว่าคุณมีสถานการณ์ต่อไปนี้

• คนขับอยู่ใกล้กับจุดส่งสินค้า แอปพลิเคชันไดรเวอร์จะส่งตำแหน่งไปยัง Fleet Engine
• Fleet Engine จะส่งตำแหน่งของอุปกรณ์ไปยังไลบรารีการติดตาม ซึ่งแอปพลิเคชันสำหรับผู้บริโภคของคุณใช้เพื่อแจ้งเตือนผู้บริโภคเกี่ยวกับระยะใกล้/ไกลของพัสดุ
• หลังจากที่คนขับดำเนินการจัดส่งเรียบร้อยแล้ว ก็คลิกปุ่ม "จัดส่งแล้ว" บนแอปพลิเคชันของคนขับ
• การดำเนินการ "จัดส่งแล้ว" จะส่งข้อมูลไปยังระบบแบ็กเอนด์ ซึ่งจะทำการตรวจสอบธุรกิจและขั้นตอนการยืนยันที่จำเป็น
• ระบบของคุณยืนยันงานเป็น SUCCEEDED และอัปเดต Fleet Engine โดยใช้ Deliveries API

แผนภาพต่อไปนี้แสดงขั้นตอนเหล่านี้ในระดับทั่วไป นอกจากนี้ ยังแสดงความสัมพันธ์มาตรฐานระหว่างระบบ ไคลเอ็นต์ และ Fleet Engine ด้วย

จัดการโทเค็นของไคลเอ็นต์

การอัปเดตตำแหน่งที่มาจากแอปพลิเคชันไดรเวอร์และส่งไปยัง Fleet Engine โดยตรงต้องใช้โทเค็นการให้สิทธิ์ แนวทางที่แนะนำในการจัดการการอัปเดตจากไคลเอ็นต์ไปยัง Fleet Engine มีดังนี้

1. สร้างโทเค็นโดยใช้บทบาทบัญชีบริการผู้ใช้ไดรเวอร์ที่ไม่น่าเชื่อถือของ Fleet Engine Delivery

2. ระบุโทเค็นที่มีขอบเขตจำกัดให้กับแอปพลิเคชันไดรเวอร์ ขอบเขตนี้อนุญาตให้อัปเดตตำแหน่งอุปกรณ์ใน Fleet Engine เท่านั้น

วิธีนี้ทำให้มั่นใจได้ว่าการโทรที่มาจากอุปกรณ์เคลื่อนที่ซึ่งพิจารณาสภาพแวดล้อมที่มีความน่าเชื่อถือต่ำ จะปฏิบัติตามหลักการให้สิทธิ์ขั้นต่ำที่สุด

บทบาทอื่นๆ ของบัญชีบริการ

แต่หากต้องการให้สิทธิ์แอปพลิเคชันของผู้ขับขี่เพื่ออัปเดต Fleet Engine โดยตรงนอกเหนือจากที่จำกัดเฉพาะบทบาทไดรเวอร์ที่ไม่น่าเชื่อถือ เช่น สำหรับการอัปเดตงานบางรายการ ให้ใช้บทบาทไดรเวอร์ที่เชื่อถือได้ สำหรับข้อมูลเกี่ยวกับโมเดลที่ใช้บทบาทไดรเวอร์ที่เชื่อถือได้ โปรดดูโมเดลไดรเวอร์ที่เชื่อถือได้

ดูข้อมูลเพิ่มเติมเกี่ยวกับการใช้บทบาทไดรเวอร์ที่ไม่น่าเชื่อถือและเชื่อถือได้ที่การตั้งค่าโปรเจ็กต์ Cloud

จำลองวันทำงาน

ตารางต่อไปนี้อธิบายว่าวันทำงานสำหรับคนขับรถที่วิ่งทางไกลตั้งแต่ระยะแรกหรือระยะสุดท้ายจะมีลักษณะอย่างไรของบริษัทจัดส่งและโลจิสติกส์ ข้อมูลบริษัทของคุณอาจมีรายละเอียดแตกต่างกัน แต่คุณสามารถดูรูปแบบวันทำงานของคุณได้ด้วย

เวลา	กิจกรรม	การสร้างแบบจำลอง
ภายใน 24 ชั่วโมงหลังจากเริ่มต้นวัน	พนักงานมอบหมายการจัดส่งให้กับยานพาหนะหรือเส้นทางส่งของ	คุณสร้างงานสำหรับการนำส่งพัสดุ รับสินค้า ช่วงพัก และอื่นๆ ใน Fleet Engine ล่วงหน้าได้ ตัวอย่างเช่น คุณอาจสร้างงานการรับสินค้า งานการนำส่งการจัดส่ง ความไม่พร้อมให้บริการตามกำหนดเวลา หรือการหยุดจัดส่งตามกำหนดเวลา มอบหมายงานให้กับยานพาหนะเมื่อชุดพัสดุสำหรับนำส่งและคำสั่งซื้อที่ควรนำส่งเสร็จเรียบร้อยแล้ว
เมื่อเริ่มต้นวัน	คนขับเริ่มต้นวันใหม่ที่คลังสินค้าโดยเข้าสู่ระบบแอปคนขับ	เริ่มต้น Delivery Driver API สร้างยานพาหนะสำหรับนำส่งใน Fleet Engine ตามความจำเป็น
	คนขับบรรทุกสินค้าลงจอดบนรถนำส่ง โดยสแกนการจัดส่ง	หากไม่ได้สร้างงานนำส่งการจัดส่งล่วงหน้า ให้สร้างงานนำส่งพัสดุในขณะที่สแกน
	คนขับยืนยันลำดับงานที่ต้องทำ	หากไม่ได้สร้างไว้ล่วงหน้า ให้สร้างงานรับสินค้าสำหรับจัดส่ง ความไม่พร้อมใช้งานตามกำหนดเวลา และจุดแวะพักที่ตั้งเวลาไว้
	คนขับออกจากสถานีและตกลงให้งานจำนวนถัดไปต้องทำให้เสร็จ	มอบหมายงานทั้งหมดหรืองานย่อยงาน ให้กับยานพาหนะโดยมอบหมายคำสั่งให้ดำเนินการ
	คนขับจัดส่งสินค้า	หลังจากมาถึงจุดนำส่ง ให้ดำเนินการที่เกี่ยวข้องกับยานพาหนะที่มาถึงจุดแวะ หลังจากนำส่งพัสดุแล้ว ให้ปิดงานการนำส่ง และสถานะการจัดส่งของร้านค้าและข้อมูลเมตาอื่นๆ (ไม่บังคับ) หลังจากทำงานทั้งหมดที่ป้ายจอดรถและก่อนเริ่มขับรถไปยังจุดแวะถัดไปแล้ว ให้ดำเนินการที่เกี่ยวข้องกับยานพาหนะผ่านป้ายหยุด และพาหนะเดินทางเข้าจุดแวะถัดไป
	คนขับมาพบกับยานพาหนะที่ให้อาหารเพื่อถ่ายโอนการจัดส่งเพิ่มเติมไปยังรถนำส่ง	คุณควรสร้างจุดนัดพบสำหรับการโอนระหว่างฟีดเดอร์และยานพาหนะนำส่งเป็นจุดแวะพักที่ตั้งเวลาไว้ หลังจากโอนและสแกนการจัดส่งแล้ว ให้สร้างงานการนำส่งหากยังไม่ได้สร้าง จากนั้นอัปเดตลำดับงานที่ทำเสร็จแล้วโดยการมอบหมายงานให้ยานพาหนะและอัปเดตการเรียงลำดับงาน
	คนขับได้รับการแจ้งเตือนเกี่ยวกับคำขอให้ไปรับสินค้า	หลังจากยอมรับคำขอรับสินค้าแล้ว ให้สร้างงานรับสินค้าสำหรับการจัดส่ง จากนั้นอัปเดตลำดับการดำเนินการของงานโดยการมอบหมายงานให้ยานพาหนะและอัปเดตการเรียงลำดับงาน
เที่ยงวัน	คนขับรถพักกลางวัน	หากสถานที่เชื่อมโยงกับงานที่ไม่พร้อมให้บริการ ให้จัดการเหมือนกับงานอื่นๆ ดำเนินการที่เกี่ยวข้องกับยานพาหนะ ที่มาถึงจุดแวะ พาหนะผ่านจุดแวะ และขับยานพาหนะไปยังจุดแวะพักถัดไป หรือไม่เช่นนั้น ก็ไม่ต้องดำเนินการใดๆ จนกว่าจะสิ้นสุดช่วงพัก นํางานออกโดยยืนยันงานถัดไปและงานที่เหลืออยู่ รวมถึงอัปเดตการเรียงลำดับงาน
	คนขับไปรับพัสดุ	ซึ่งระบบจำลองนี้เหมือนกับจุดแวะแสดงโฆษณา ดำเนินการที่เกี่ยวข้องกับยานพาหนะที่มาถึงจุดแวะและปิดงาน รวมถึงการจัดเก็บสถานะการจัดส่งและข้อมูลเมตาอื่นๆ (ไม่บังคับ) หลังจากทำงานทั้งหมดที่ป้ายจอดรถแล้ว และก่อนที่จะเริ่มขับรถไปยังจุดแวะถัดไป ให้ดําเนินการที่เกี่ยวข้องกับยานพาหนะผ่านป้ายจอดรถ และพาหนะเดินทางไปยังจุดแวะถัดไป หมายเหตุ: การรับสินค้าทั้งหมดต้องมีงานการนำส่งที่เกี่ยวข้องเพื่อให้การเรียกเก็บเงินถูกต้อง หากต้องไปรับของในสถานที่อื่นบนเส้นทางเดียวกันของผู้ขับในวันนั้น เราขอแนะนำให้จำลองงานนำส่งดังกล่าวว่าเป็นงานนำส่งอื่นๆ บนเส้นทาง หากพนักงานขับรถนำสินค้าไปส่งที่คลังสินค้า เราขอแนะนำให้สร้างงานนำส่งที่ปลายทาง Depot
	คนขับได้นัดหมายเวลาเพื่อรับพัสดุจากกล่องส่งของ	โมเดลนี้จำลองมาเช่นเดียวกับจุดรับของอื่นๆ ดำเนินการที่เกี่ยวข้องกับยานพาหนะที่มาถึงจุดแวะและปิดงาน หลังจากทำงานทั้งหมดที่ป้ายจอดรถและเริ่มขับรถไปยังจุดแวะถัดไปแล้ว ให้ดำเนินการที่เกี่ยวข้องกับยานพาหนะผ่านป้ายหยุด และพาหนะเดินทางไปยังจุดแวะพักถัดไป
	คนขับได้รับการแจ้งเตือนว่ามีการจัดส่งถูกเปลี่ยนเส้นทางไปยังสถานที่อื่น	ตั้งค่าสถานะงานการนำส่งการจัดส่งเดิมเป็น "เสร็จสมบูรณ์" และสร้างงานการนำส่งใหม่สำหรับสถานที่นำส่งใหม่ ดูข้อมูลเพิ่มเติมได้ที่เปลี่ยนเส้นทางการจัดส่ง
	คนขับพยายามนำส่งพัสดุ แต่ไม่สามารถทำได้	การประมาณค่านี้คล้ายกับการหยุดนำส่งที่สำเร็จ ซึ่งทำเครื่องหมายงานการนำส่งว่าเสร็จสมบูรณ์แล้ว ดำเนินการที่เกี่ยวข้องกับยานพาหนะที่มาถึงจุดแวะพัก หลังจากที่นำส่งพัสดุไม่สำเร็จ ให้ปิดงานและสถานะการจัดส่งของร้านค้าและข้อมูลเมตาอื่นๆ (ไม่บังคับ) หลังจากทำงานทั้งหมดที่ป้ายจอดรถแล้ว และก่อนที่จะเริ่มขับรถไปยังจุดแวะถัดไป ให้ดําเนินการที่เกี่ยวข้องกับยานพาหนะผ่านป้ายจอดรถ และพาหนะเดินทางไปยังจุดแวะถัดไป
	คนขับได้รับการแจ้งเตือนให้ระงับ (ไม่นำส่ง) พัสดุ	หลังจากได้รับและยืนยันการแจ้งเตือนแล้ว ให้ตั้งค่าสถานะงานเป็น "เสร็จสมบูรณ์"
	คนขับได้รับการแจ้งเตือนให้นำส่งพัสดุบางรายการเป็นลำดับถัดไป และเปลี่ยนคำสั่งซื้อการนำส่งที่คอมมิต	อัปเดตลำดับงาน
	คนขับเลือกนำส่งพัสดุที่ล่าช้า	อัปเดตลำดับงานแล้วดำเนินการต่อตามปกติ
	คนขับส่งสินค้าหลายรายการไปยังสถานที่ตั้งแห่งเดียว	โมเดลนี้สร้างแบบจำลองคล้ายกับจุดแวะพักสำหรับนำส่งสินค้าแห่งเดียว หลังจากมาถึงป้ายหยุด ให้ดำเนินการที่เกี่ยวข้องกับยานพาหนะที่มาถึงป้ายหยุด หลังจากนำส่งแต่ละการจัดส่งแล้ว ให้ปิดแต่ละงาน และสถานะการจัดส่งของร้านค้าและข้อมูลเมตาอื่นๆ (ไม่บังคับ) หลังจากทำงานทั้งหมดที่ป้ายจอดรถแล้ว และก่อนที่จะเริ่มขับรถไปยังจุดแวะถัดไป ให้ดําเนินการที่เกี่ยวข้องกับยานพาหนะผ่านป้ายจอดรถ และพาหนะเดินทางไปยังจุดแวะถัดไป
เมื่อสิ้นสุดวัน	คนขับกลับไปที่สถานี	หากคนขับกลับไปที่สถานีขนส่งที่มีสิ่งที่ไปรับระหว่างเส้นทาง คุณจะต้องสร้างและปิดพัสดุแต่ละรายการเป็นงานนำส่งเพื่อให้การเรียกเก็บเงินถูกต้อง ซึ่งทำได้โดยการสร้างโมเดลร้านค้าเช่นเดียวกับจุดนำส่งอื่นๆ หากไม่ได้ใช้ Depot เป็นจุดแวะนำส่ง คุณอาจยังเลือก สร้างรูปแบบ Depot เป็นจุดแวะพักที่กำหนดเวลาไว้ได้ การประมาณจุดแวะช่วยให้คนขับเห็นเส้นทางกลับไปยังสถานีขนส่ง และแสดงเวลาถึงโดยประมาณ

วิธีการทำงานของการอัปเดตตำแหน่ง

เพื่อประสิทธิภาพที่ดีที่สุดเมื่อใช้ Fleet Engine ให้สตรีมการอัปเดตตำแหน่งของรถ ใช้วิธีใดวิธีหนึ่งต่อไปนี้เพื่อแจ้งการอัปเดต

1. ใช้ Driver SDK - Android, iOS -- ตัวเลือกที่ง่ายที่สุด
2. ใช้โค้ดที่กำหนดเอง ซึ่งมีประโยชน์หากมีการส่งต่อตำแหน่งผ่านแบ็กเอนด์ของคุณ หรือหากคุณใช้อุปกรณ์อื่นที่ไม่ใช่ Android หรือ iOS

ไม่ว่าคุณจะอัปเดตตำแหน่งของยานพาหนะอย่างไร แบ็กเอนด์ของคุณมีหน้าที่อัปเดต Fleet Engine เมื่อพาหนะที่นำส่งกำลังเปลี่ยนเส้นทางไปยังจุดแวะพัก (รวมถึงสถานีขนส่ง) และเมื่อมาถึงจุดแวะ Fleet Engine จะไม่ตรวจหาเหตุการณ์เหล่านี้โดยอัตโนมัติ

จุดจอดยานพาหนะและสถานที่นำส่ง

จุดแวะพักคือที่ที่รถส่งของเพื่อทำการจัดส่งหรืองานอื่นๆ จนเสร็จ เป็นจุดเชื่อมต่อ เช่น จุดขนถ่ายสินค้าหรือตำแหน่งบนถนน

สถานที่นำส่งคือสถานที่นำส่งหรือรับสินค้า การเดินทางไปและกลับจากสถานที่จัดส่งอาจต้องใช้เวลา เดินจากป้ายจอดรถ

ตัวอย่างเช่น เมื่อคนขับรถส่งของไปยังร้านค้าในห้างสรรพสินค้า รถนำส่งจะจอดที่ลานจอดรถของห้างสรรพสินค้าใกล้กับทางเข้าที่ใกล้ที่สุดของร้านค้า นี่เป็นป้ายจอดรถ จากนั้นคนขับจะเดินจากป้ายจอดรถไปยังตำแหน่งภายในศูนย์การค้าที่มีร้านตั้งอยู่ นี่คือสถานที่จัดส่ง

เพื่อประสบการณ์การติดตามการจัดส่งที่ดีที่สุดสำหรับผู้ใช้ ให้พิจารณาวิธีมอบหมายงานการจัดส่งให้กับจุดแวะพักของยานพาหนะ และโปรดทราบว่าจะมีการรายงานจำนวนจุดพักยานพาหนะที่เหลืออยู่สำหรับงานจัดส่งให้ผู้ใช้เพื่อช่วยให้ผู้ใช้ดูความคืบหน้าของการจัดส่งได้

ตัวอย่างเช่น หากคนขับรถส่งอาหารจำนวนมากไปยังอาคารสำนักงานแห่งเดียว ให้พิจารณามอบหมายงานจัดส่งทั้งหมดไปยังจุดแวะจอดรถเพียงแห่งเดียว หากงานการนำส่งแต่ละรายการได้รับการมอบหมายให้กับจุดจอดยานพาหนะของตัวเอง ประสบการณ์การติดตามการจัดส่งของคุณจะมีประโยชน์ต่อผู้ใช้น้อยลงเนื่องจากการติดตามจะใช้งานได้เมื่อรถอยู่ภายในจำนวนจุดจอดรถที่จำกัดก่อนถึงจุดหมายเท่านั้น การมีป้ายจอดรถหลายป้ายที่เสร็จภายในเวลาอันสั้นไม่ได้ทำให้ผู้ใช้มีเวลามากนักในการติดตามความคืบหน้าของการนำส่ง

ใช้ SDK อุปกรณ์เคลื่อนที่

ก่อนเรียกใช้ Driver SDK โปรดเริ่มต้นการทำงานของ SDK นั้น

เริ่มต้น Delivery Driver API

ก่อนเริ่มต้นใช้งาน Delivery Driver API ใน Driver SDK ให้ตรวจสอบว่าได้เริ่มต้น Navigation SDK แล้ว จากนั้นเริ่มต้น Delivery Driver API ดังที่ปรากฏในตัวอย่างต่อไปนี้

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

หมายเหตุ: Driver SDK มี API สำหรับธุรกิจหลายประเภท รวมถึงการนำส่ง หากต้องการลดขนาดไบนารีโดยรวม ให้ใช้ ProGuard หรือเครื่องมือเพิ่มประสิทธิภาพอื่นๆ เพื่อตัดโค้ดที่ไม่ได้ใช้ออก

กรณีการใช้งาน

ส่วนนี้จะอธิบายวิธีใช้ Deliveries API เพื่อสร้างรูปแบบสำหรับกรณีการใช้งานทั่วไป

ตัวระบุเอนทิตีที่ไม่ซ้ำกัน

รูปแบบและค่าของตัวระบุเอนทิตีที่ไม่ซ้ำกันที่ใช้ในการเรียก REST นั้นทึบต่อ Fleet Engine หลีกเลี่ยงการใช้รหัสที่เพิ่มขึ้นโดยอัตโนมัติ และตรวจสอบว่าตัวระบุไม่มีข้อมูลส่วนบุคคลที่ระบุตัวบุคคลนั้นได้ (PII) เช่น หมายเลขโทรศัพท์ของผู้ขับ

สร้างพาหนะ

คุณจะสร้างยานพาหนะจาก Driver SDK หรือจากสภาพแวดล้อมของเซิร์ฟเวอร์โดยใช้ gRPC หรือ REST ก็ได้

gRPC

หากต้องการสร้างยานพาหนะใหม่ โปรดโทรหา Fleet Engine ด้วย CreateDeliveryVehicle ใช้ออบเจ็กต์ CreateDeliveryVehicleRequest เพื่อกำหนดแอตทริบิวต์ของยานพาหนะนำส่งใหม่ โปรดทราบว่าระบบจะละเว้นค่าที่ระบุสำหรับช่อง Name ตามคำแนะนำของ API สำหรับรหัสที่ผู้ใช้ระบุ คุณควรใช้ช่อง DeliveryVehicleId เพื่อตั้งค่ารหัสของยานพาหนะ

เมื่อสร้าง DeliveryVehicle คุณจะระบุช่องต่อไปนี้หรือไม่ก็ได้

• Attributes
• LastLocation
• ประเภท

อย่าตั้งค่าช่องอื่นๆ หากมี Fleet Engine จะแสดงข้อผิดพลาดเนื่องจากช่องเหล่านั้นเป็นแบบอ่านอย่างเดียวหรือจะอัปเดตได้ด้วยการเรียกไปยัง UpdateDeliveryVehicle เท่านั้น

หากต้องการสร้างรถยนต์โดยไม่ตั้งค่าช่องที่ไม่บังคับ ให้ยกเลิกการเลือกช่อง DeliveryVehicle ใน CreateDeliveryVehicleRequest

ตัวอย่างต่อไปนี้แสดงวิธีใช้ไลบรารี Java gRPC เพื่อสร้างยานพาหนะ

    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

หากต้องการสร้างยานพาหนะจากสภาพแวดล้อมของเซิร์ฟเวอร์ ให้เรียก HTTP REST ไปยัง CreateDeliveryVehicle

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

<id> คือตัวระบุที่ไม่ซ้ำกันสำหรับยานพาหนะที่นำส่งสินค้าของคุณในยานพาหนะ

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็นโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหา POST แสดงเอนทิตี DeliveryVehicle ที่จะสร้าง คุณสามารถระบุฟิลด์ที่ไม่บังคับต่อไปนี้

• แอตทริบิวต์
• lastLocation
• ประเภท

ตัวอย่างคำสั่ง curl

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

Fleet Engine ไม่สนใจช่อง name ของเอนทิตี DeliveryVehicle ตามคำแนะนำของ API สำหรับรหัสที่ผู้ใช้ระบุ อย่าตั้งค่าช่องอื่นๆ หากมี Fleet Engine จะแสดงข้อผิดพลาดเนื่องจากช่องเหล่านั้นเป็นแบบอ่านอย่างเดียวหรือจะอัปเดตได้โดยใช้การเรียกไปยัง UpdateDeliveryVehicle เท่านั้น

หากต้องการสร้างยานพาหนะโดยไม่ตั้งค่าช่องใดๆ ให้เว้นว่างเนื้อหาของคำขอ POST ไว้ จากนั้นยานพาหนะที่สร้างขึ้นใหม่จะดึงข้อมูลรหัสยานพาหนะจากพารามิเตอร์ deliveryVehicleId ใน URL POST

ตัวอย่างคำสั่ง 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}"

สร้างงานรับสินค้าสำหรับการจัดส่ง

คุณจะสร้างงานรับสินค้าสำหรับการจัดส่งได้จาก Driver SDK หรือจากสภาพแวดล้อมของเซิร์ฟเวอร์โดยใช้ gRPC หรือ REST

gRPC

ตัวอย่างต่อไปนี้แสดงวิธีใช้ไลบรารี Java gRPC เพื่อสร้างงานรับสินค้าที่จัดส่ง

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

หากต้องการสร้างงานรับสินค้าสำหรับการจัดส่งจากสภาพแวดล้อมเซิร์ฟเวอร์ ให้เรียก HTTP REST ไปยัง CreateTask ดังนี้

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

<id> คือตัวระบุที่ไม่ซ้ำสำหรับงาน จะต้องไม่ใช่หมายเลขติดตาม สำหรับการจัดส่ง หากไม่มีรหัสงานในระบบ คุณอาจสร้างตัวระบุที่ไม่ซ้ำกัน (UUID) ให้เป็นสากล

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็นโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี Task

• ช่องที่ต้องกรอก

  ฟิลด์	ค่า
  ประเภท	Type.PICKUP
  state	State.OPEN
  trackingId	หมายเลขหรือตัวระบุที่คุณใช้ในการติดตามการจัดส่ง
  plannedLocation	ตำแหน่งที่งานเสร็จสมบูรณ์ ซึ่งในกรณีนี้คือสถานที่รับสินค้าสำหรับการจัดส่ง
  taskDuration	เวลาที่คาดว่าจะใช้ในการไปรับสินค้า ณ สถานที่รับของซึ่งมีหน่วยเป็นวินาที

• ช่องที่ไม่บังคับมีดังนี้

  ฟิลด์	ค่า
  targetTimeWindow	กรอบเวลาที่งานควรเสร็จสิ้น การดำเนินการนี้จะไม่ส่งผลต่อลักษณะการทำงานของการกำหนดเส้นทาง
  แอตทริบิวต์	รายการแอตทริบิวต์งานที่กำหนดเอง แอตทริบิวต์แต่ละรายการต้องมีคีย์ที่ไม่ซ้ำกัน

ระบบจะไม่พิจารณาช่องอื่นๆ ทั้งหมดในเอนทิตีในการสร้าง Fleet Engine จะยกเว้นหากคำขอมี deliveryVehicleId ที่มอบหมาย คุณสามารถมอบหมายงานโดยใช้ UpdateDeliveryVehicleRequest ดูข้อมูลเพิ่มเติมได้ที่มอบหมายงานให้กับยานพาหนะและ UpdateDeliveryVehicleRequest

ตัวอย่างคำสั่ง 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

สร้างงานการนำส่งการจัดส่ง

สร้างงานการนำส่งการจัดส่งจาก Driver SDK หรือจากสภาพแวดล้อมของเซิร์ฟเวอร์โดยใช้ gRPC หรือ REST

gRPC

ตัวอย่างต่อไปนี้แสดงวิธีใช้ไลบรารี Java gRPC เพื่อสร้างงานการนำส่งการจัดส่ง

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

หากต้องการสร้างงานการนำส่งการจัดส่งจากสภาพแวดล้อมเซิร์ฟเวอร์โดยใช้ gRPC หรือ REST ให้เรียกใช้ HTTP REST ไปยัง CreateTask ดังนี้

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

<id> คือตัวระบุที่ไม่ซ้ำสำหรับงาน จะต้องไม่ใช่หมายเลขติดตาม สำหรับการจัดส่ง หากไม่มีรหัสงานในระบบ คุณอาจสร้างตัวระบุที่ไม่ซ้ำกัน (UUID) ให้เป็นสากล

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็นโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี Task

• ช่องที่ต้องกรอก

  ฟิลด์	ค่า
  ประเภท	Type.DELIVERY
  state	State.OPEN
  trackingId	หมายเลขหรือตัวระบุที่คุณใช้ในการติดตามการจัดส่ง
  plannedLocation	สถานที่ที่จะดำเนินงานให้เสร็จ ซึ่งในกรณีนี้คือสถานที่นำส่งสำหรับการจัดส่งนี้
  taskDuration	เวลาที่คาดว่าจะใช้ในการส่งคืนสินค้า ณ สถานที่นำส่ง ซึ่งมีหน่วยเป็นวินาที

• ช่องที่ไม่บังคับมีดังนี้

  ฟิลด์	ค่า
  targetTimeWindow	กรอบเวลาที่งานควรเสร็จสิ้น การดำเนินการนี้จะไม่ส่งผลต่อลักษณะการทำงานของการกำหนดเส้นทาง
  แอตทริบิวต์	รายการแอตทริบิวต์งานที่กำหนดเอง แอตทริบิวต์แต่ละรายการต้องมีคีย์ที่ไม่ซ้ำกัน

ระบบจะไม่พิจารณาช่องอื่นๆ ทั้งหมดในเอนทิตีในการสร้าง Fleet Engine จะมีข้อยกเว้นหากคำขอมี deliveryVehicleId ที่ได้รับมอบหมาย คุณสามารถมอบหมายงานโดยใช้ UpdateDeliveryVehicleRequest ดูข้อมูลเพิ่มเติมได้ที่มอบหมายงานให้กับยานพาหนะและ UpdateDeliveryVehicleRequest

ตัวอย่างคำสั่ง 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

สร้างงานแบบกลุ่ม

คุณสร้างชุดงานจากสภาพแวดล้อมของเซิร์ฟเวอร์ได้โดยใช้ gRPC หรือ REST

gRPC

ตัวอย่างต่อไปนี้แสดงวิธีใช้ไลบรารี Java gRPC เพื่อสร้างงาน 2 รายการ งานแรกสําหรับการจัดส่ง และอีกงานสําหรับการรับสินค้าจากสถานที่เดียวกัน

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

หากต้องการสร้างการส่งและงานการรับจากสภาพแวดล้อมเซิร์ฟเวอร์ ให้เรียก HTTP REST ไปยัง BatchCreateTasks:

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

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็นโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี BatchCreateTasksRequest

• ช่องที่ต้องกรอก

  ฟิลด์	ค่า
  คำขอ	อาร์เรย์<CreateTasksRequest>

• ช่องที่ไม่บังคับมีดังนี้

  ฟิลด์	ค่า
  ส่วนหัว	" DeliveryRequestHeader"

องค์ประกอบ CreateTasksRequest แต่ละรายการใน requests ต้องผ่านกฎการตรวจสอบเดียวกันกับคำขอ CreateTask โดยมีข้อยกเว้นว่าช่อง parent และ header เป็นช่องที่ไม่บังคับ หากมีการตั้งค่า ช่องดังกล่าวจะต้องเหมือนกับช่องที่เกี่ยวข้องที่ BatchCreateTasksRequest ระดับบนสุด โปรดดูหัวข้อสร้างงานรับสินค้าสำหรับการจัดส่งและสร้างงานการนำส่งการจัดส่งสำหรับกฎการตรวจสอบที่เฉพาะเจาะจงสำหรับแต่ละรายการ

โปรดดูข้อมูลเพิ่มเติมในเอกสารอ้างอิง API สำหรับ BatchCreateTasks (gRPC, REST)

ตัวอย่างคำสั่ง 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

ความไม่พร้อมให้บริการตามกำหนดการ

คุณสามารถสร้างงานที่ระบุความไม่พร้อมใช้งาน (เช่น สำหรับช่วงพักคนขับหรือการเติมน้ำมันรถ) จาก Driver SDK หรือจากสภาพแวดล้อมของเซิร์ฟเวอร์ที่ใช้ gRPC หรือ REST งานความไม่พร้อมใช้งานที่กำหนดเวลาไว้จะต้องไม่มีรหัสติดตาม คุณสามารถระบุสถานที่ตั้งหรือไม่ก็ได้

gRPC

ตัวอย่างต่อไปนี้แสดงวิธีใช้ไลบรารี Java gRPC เพื่อสร้างงานที่ไม่พร้อมให้บริการ

    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

หากต้องการสร้างงานที่ไม่พร้อมใช้งานจากสภาพแวดล้อมเซิร์ฟเวอร์ ให้เรียก HTTP REST ไปที่ CreateTask

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

<id> คือตัวระบุที่ไม่ซ้ำสำหรับงาน หากไม่มีรหัสงานในระบบ คุณอาจสร้างตัวระบุที่ไม่ซ้ำกันทั้งหมด (UUID)

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็นโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี Task

• ช่องที่ต้องกรอก

  ฟิลด์	ค่า
  ประเภท	Type.UNAVAILABLE
  state	State.OPEN
  taskDuration	ระยะเวลาของช่วงพักเป็นวินาที

• ช่องที่ไม่บังคับมีดังนี้

  ฟิลด์	ค่า
  plannedLocation	ตำแหน่งของช่วงพักหากต้องดำเนินการในสถานที่ที่เฉพาะเจาะจง

ระบบจะไม่พิจารณาช่องอื่นๆ ทั้งหมดในเอนทิตีในการสร้าง Fleet Engine จะมีข้อยกเว้นหากคำขอมี deliveryVehicleId ที่ได้รับมอบหมาย คุณสามารถมอบหมายงานโดยใช้ UpdateDeliveryVehicleRequest ดูข้อมูลเพิ่มเติมได้ที่มอบหมายงานให้กับยานพาหนะและ UpdateDeliveryVehicleRequest

ตัวอย่างคำสั่ง 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

ป้ายจอดรถตามกำหนดการ

คุณสร้างงานการหยุดตามกำหนดการได้จาก Driver SDK หรือจากสภาพแวดล้อมของเซิร์ฟเวอร์โดยใช้ gRPC หรือ REST งานที่หยุดซึ่งกำหนดเวลาไว้อาจไม่มีรหัสติดตาม

gRPC

ตัวอย่างต่อไปนี้แสดงวิธีใช้ไลบรารี Java gRPC เพื่อสร้างงานการหยุดที่กำหนดเวลาไว้

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

หากต้องการสร้างงานการหยุดที่กำหนดเวลาไว้จากสภาพแวดล้อมเซิร์ฟเวอร์ ให้เรียก HTTP REST ไปยัง CreateTask ดังนี้

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

<id> คือตัวระบุที่ไม่ซ้ำสำหรับงาน หากไม่มีรหัสงานในระบบ คุณอาจสร้างตัวระบุที่ไม่ซ้ำกัน (UUID)

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็นโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี Task

• ช่องที่ต้องกรอก

  ฟิลด์	ค่า
  ประเภท	Type.SCHEDULED_STOP
  state	State.OPEN
  plannedLocation	ตำแหน่งของป้ายจอดรถ
  taskDuration	ความยาวที่คาดไว้ของจุดแวะ หน่วยเป็นวินาที

• ช่องที่ไม่บังคับมีดังนี้

  • ไม่มี

ระบบจะไม่พิจารณาช่องอื่นๆ ทั้งหมดในเอนทิตีในการสร้าง Fleet Engine จะมีข้อยกเว้นหากคำขอมี deliveryVehicleId ที่ได้รับมอบหมาย คุณสามารถมอบหมายงานโดยใช้ UpdateDeliveryVehicleRequest ดูข้อมูลเพิ่มเติมได้ที่มอบหมายงานให้กับยานพาหนะและ UpdateDeliveryVehicleRequest

ตัวอย่างคำสั่ง 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

กำหนดกรอบเวลาเป้าหมาย

กรอบเวลาเป้าหมายคือ TimeWindow ระหว่างที่ระบบควรทำงานให้เสร็จ เช่น หากคุณแจ้งกรอบเวลาการนำส่งให้ผู้รับนำส่งทราบ คุณก็ใช้กรอบเวลาเป้าหมายของงานเพื่อบันทึกกรอบเวลานี้และสร้างการแจ้งเตือน หรือวิเคราะห์ประสิทธิภาพหลังการเดินทางได้โดยใช้ช่องนี้

โดยกรอบเวลาเป้าหมายประกอบด้วยเวลาเริ่มต้นและเวลาสิ้นสุด โดยจะตั้งค่าเป็นงานประเภทใดก็ได้ กรอบเวลาเป้าหมายจะไม่มีผลต่อลักษณะการทำงานของการกำหนดเส้นทาง

gRPC

ตัวอย่างต่อไปนี้แสดงวิธีใช้ไลบรารี Java 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)
      .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

หากต้องการกำหนดกรอบเวลาของงานโดยใช้ HTTP ให้เรียกใช้ UpdateTask:

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

<id> คือตัวระบุที่ไม่ซ้ำสำหรับงาน

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็นโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี Task

• ช่องที่ต้องกรอก

  ฟิลด์	ค่า
  targetTimeWindow	กรอบเวลาที่งานควรเสร็จสิ้น การตั้งค่านี้ไม่มีผลกับลักษณะการทำงานของการกำหนดเส้นทาง

• ช่องที่ไม่บังคับมีดังนี้

  • ไม่มี

ระบบจะไม่สนใจช่องอื่นๆ ทั้งหมดในเอนทิตีสำหรับการอัปเดต

ตัวอย่างคำสั่ง 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

ตั้งค่าการกำหนดค่าระดับการเข้าถึงการติดตามงาน

ระดับการเข้าถึงข้อมูลในไลบรารีการติดตามการจัดส่งและข้อมูลที่ส่งคืนจากการเรียกไปยัง GetTaskTrackingInfo จะควบคุมได้ในระดับงานต่องานโดยการตั้งค่า TaskTrackingViewConfig ในงาน ดูข้อมูลเพิ่มเติมได้ที่งานเกี่ยวกับยานพาหนะที่ใช้งานอยู่ ซึ่งสามารถทำได้เมื่อสร้างหรืออัปเดตงาน ตัวอย่างของการอัปเดตงานด้วยการกำหนดค่านี้มีดังนี้

gRPC

ตัวอย่างต่อไปนี้แสดงวิธีใช้ไลบรารี Java 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)
  .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

หากต้องการตั้งค่าหน้าต่างการกำหนดค่ามุมมองการติดตามงานโดยใช้ HTTP ให้เรียกใช้ UpdateTask

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

<id> คือตัวระบุที่ไม่ซ้ำสำหรับงาน

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็นโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี Task

• ช่องที่ต้องกรอก

  ฟิลด์	ค่า
  taskTrackingViewConfig	การกำหนดค่าสำหรับการติดตามงานที่ระบุว่าองค์ประกอบข้อมูลใดที่ผู้ใช้ปลายทางจะเห็นได้ภายใต้สถานการณ์ใด

• ช่องที่ไม่บังคับมีดังนี้

  • ไม่มี

ระบบจะไม่สนใจช่องอื่นๆ ทั้งหมดในเอนทิตีสำหรับการอัปเดต

ตัวอย่างคำสั่ง 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

มอบหมายงานให้ยานพาหนะ

คุณมอบหมายงานให้กับยานพาหนะที่นำส่งสินค้าได้โดยการอัปเดตการเรียงลำดับงานสำหรับยานพาหนะ การเรียงลำดับงานสำหรับยานพาหนะจะพิจารณาจากรายการป้ายจอดรถสำหรับยานพาหนะที่นำส่ง และคุณสามารถมอบหมายงานอย่างน้อย 1 อย่างให้กับจุดแวะพักแต่ละจุดได้ โปรดดูรายละเอียดที่หัวข้ออัปเดตลำดับงาน

หากต้องการเปลี่ยนการจัดส่งจากยานพาหนะหนึ่งเป็นอีกคัน ให้ปิดงานเดิม แล้วสร้างใหม่ก่อนที่จะมอบหมายให้กับยานพาหนะใหม่ หากคุณอัปเดตการสั่งงานสำหรับงานที่มอบหมายให้กับรถคันอื่นแล้ว คุณจะได้รับข้อผิดพลาด

อัปเดตการเรียงลำดับงาน

คุณอัปเดตงานตามคำสั่งซื้อที่กำหนดให้กับยานพาหนะได้จาก Driver SDK หรือสภาพแวดล้อมของเซิร์ฟเวอร์ อย่าใช้ทั้ง 2 วิธีเพื่อหลีกเลี่ยงสภาวะการแข่งขัน และคงแหล่งข้อมูลที่เชื่อถือได้เพียงแหล่งเดียว

เมื่อคุณอัปเดตการเรียงลำดับงานสำหรับยานพาหนะ จะมีการดำเนินการดังต่อไปนี้ด้วย

• มอบหมายงานใหม่ๆ ให้กับยานพาหนะ
• ปิดงานที่เคยกำหนดให้รถแต่ไม่ได้อยู่ในลำดับที่อัปเดต

หากต้องการเปลี่ยนการจัดส่งจากยานพาหนะหนึ่งเป็นอีกคัน ให้ปิดงานเดิม แล้วสร้างใหม่ก่อนที่จะมอบหมายให้กับยานพาหนะใหม่ หากคุณอัปเดตการสั่งงานสำหรับงานที่มอบหมายให้กับรถคันอื่นแล้ว คุณจะได้รับข้อผิดพลาด

คุณอัปเดตลำดับงานได้ทุกเมื่อ

gRPC

ตัวอย่างต่อไปนี้แสดงวิธีใช้ไลบรารี Java gRPC เพื่ออัปเดตการเรียงลำดับงานสำหรับยานพาหนะ

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

หากต้องการอัปเดตการจัดลำดับงานสำหรับยานพาหนะจากสภาพแวดล้อมเซิร์ฟเวอร์ ให้เรียก HTTP REST ไปยัง UpdateDeliveryVehicle ดังนี้

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

<id> คือตัวระบุที่ไม่ซ้ำกันสำหรับรถส่งของที่คุณตั้งใจจะอัปเดตลำดับของงาน ซึ่งเป็นตัวระบุที่คุณระบุ เมื่อสร้างยานพาหนะ

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็นโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี DeliveryVehicle

• ช่องที่ต้องกรอก

  ฟิลด์	ค่า
  remainingVehicleJourneySegments	รายการกลุ่มเส้นทางสําหรับงานตามลำดับที่ควรดำเนินการ งานแรกในรายการจะดำเนินการก่อน
  การเดินทางยานพาหนะที่เหลืออยู่[i].stop	จุดแวะสำหรับงาน i ในรายการ
  leftVehicleJourneySegments[i].stop.plannedLocation	สถานที่ที่วางแผนไว้สำหรับป้ายจอดรถ
  เหลืออีก เส้นทางการเดินทาง [i].stop.tasks	รายการงานที่ต้องทำ ณ จุดแวะพักของยานพาหนะนี้
  remainingVehicleJourneySegments[i].stop.state	State.NEW

• ช่องที่ไม่บังคับมีดังนี้

  • ไม่มี

ระบบจะไม่สนใจช่องอื่นๆ ทั้งหมดในเอนทิตีสำหรับการอัปเดต

ตัวอย่างคำสั่ง curl

หมายเหตุ: คำสั่งนี้จะเขียนทับ remainingVehicleJourneySegments ที่ตั้งค่าไว้แล้วในยานพาหนะสำหรับนำส่ง

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

รถกำลังอยู่ระหว่างจอดไปยังจุดหมายถัดไป

Fleet Engine ต้องได้รับการแจ้งเตือนเมื่อยานพาหนะออกจากจุดหยุดหรือเริ่มการนำทาง คุณแจ้ง Fleet Engine ได้จาก Driver SDK หรือจากสภาพแวดล้อมของเซิร์ฟเวอร์โดยใช้ gRPC หรือ REST อย่าใช้ทั้ง 2 วิธีเพื่อหลีกเลี่ยงเงื่อนไข เกี่ยวกับเชื้อชาติและการรักษาแหล่งข้อมูลที่ถูกต้องเพียงแหล่งเดียว

gRPC

ตัวอย่างต่อไปนี้แสดงวิธีใช้ไลบรารี Java gRPC เพื่อแจ้ง 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
    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

หากต้องการแจ้ง Fleet Engine ว่ายานพาหนะกำลังถูกเปลี่ยนเส้นทางไปยังจุดแวะพักถัดไปจากสภาพแวดล้อมเซิร์ฟเวอร์ ให้เรียก HTTP REST ไปยัง UpdateDeliveryVehicle ดังนี้

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

<id> คือตัวระบุที่ไม่ซ้ำกันสำหรับรถส่งของที่คุณตั้งใจจะอัปเดตลำดับของงาน ซึ่งเป็นตัวระบุที่คุณระบุ เมื่อสร้างยานพาหนะ

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็นโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี DeliveryVehicle

• ช่องที่ต้องกรอก:

  ฟิลด์	ค่า
  remainingVehicleJourneySegments	รายการป้ายจอดรถที่เหลืออยู่ซึ่งมีรัฐมีสถานะเป็น "รัฐ" ใหม่ จุดแวะแรกในรายการต้องมีการทำเครื่องหมายสถานะเป็น State.ENROUTE

• ช่องที่ไม่บังคับมีดังนี้

  • ไม่มี

ระบบจะไม่สนใจช่องอื่นๆ ทั้งหมดในเอนทิตีสําหรับการแจ้งเตือน

ตัวอย่างคำสั่ง curl

หมายเหตุ: คำสั่งนี้จะเขียนทับremainingVehicleJourneySegments ที่ตั้งค่าไว้แล้วในพาหนะการนำส่ง

# 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

อัปเดตตำแหน่งของรถ

หากไม่ได้ใช้ Driver SDK เพื่ออัปเดตตำแหน่งของรถ คุณโทรหา Fleet Engine ได้โดยตรงพร้อมระบุตำแหน่งของรถ สำหรับยานพาหนะที่ใช้งานอยู่ Fleet Engine คาดว่าจะอัปเดตตำแหน่งอย่างน้อย 1 ครั้งทุกนาทีและสูงสุด 1 ครั้งทุก 5 วินาที

gRPC

ตัวอย่างต่อไปนี้แสดงวิธีใช้ไลบรารี Java gRPC เพื่ออัปเดตตำแหน่งของรถใน 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

หากต้องการอัปเดตตำแหน่งของรถใน Fleet Engine โดยใช้ HTTP REST ให้โทรหา UpdateDeliveryVehicle

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

<id> คือตัวระบุที่ไม่ซ้ำสำหรับรถส่งสินค้าในเที่ยวบินของคุณหรือซึ่งคุณตั้งใจจะอัปเดตตำแหน่ง ซึ่งเป็นตัวระบุที่คุณระบุ เมื่อสร้างยานพาหนะ

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็นโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี DeliveryVehicle

• ช่องที่ต้องกรอก:

  ฟิลด์	ค่า
  lastLocation.supplementalLocation	ตำแหน่งของยานพาหนะ
  lastLocation.supplementalLocationTime	การประทับเวลาล่าสุดที่ทราบที่ยานพาหนะอยู่ที่ตำแหน่งนี้
  lastLocation.supplementalLocationSensor	ควรป้อนข้อมูล CUSTOMER_SUPPLIED_LOCATION

• ช่องที่ไม่บังคับมีดังนี้

  ฟิลด์	ค่า
  lastLocation.supplementalLocationAccuracy	ความแม่นยำของตำแหน่งที่ระบุ หน่วยเป็นเมตร

ตัวอย่างคำสั่ง 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

รถมาถึงจุดแวะ

คุณต้องแจ้ง Fleet Engine เมื่อยานพาหนะมาถึงจุดแวะพัก คุณแจ้ง Fleet Engine ได้จาก Driver SDK หรือจากสภาพแวดล้อมของเซิร์ฟเวอร์โดยใช้ gRPC หรือ REST อย่าใช้ทั้ง 2 วิธีเพื่อหลีกเลี่ยงเงื่อนไข เกี่ยวกับเชื้อชาติและการรักษาแหล่งข้อมูลที่ถูกต้องเพียงแหล่งเดียว

gRPC

ตัวอย่างต่อไปนี้แสดงวิธีใช้ไลบรารี Java gRPC เพื่อแจ้ง 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 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

หากต้องการแจ้ง Fleet Engine เกี่ยวกับการมาถึงของยานพาหนะที่จุดแวะพักจากสภาพแวดล้อมเซิร์ฟเวอร์ ให้เรียกใช้ HTTP REST ไปยัง UpdateDeliveryVehicle

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

<id> คือตัวระบุที่ไม่ซ้ำกันสำหรับรถส่งของที่คุณตั้งใจจะอัปเดตลำดับของงาน ซึ่งเป็นตัวระบุที่คุณระบุ เมื่อสร้างยานพาหนะ

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็นโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี DeliveryVehicle

• ช่องที่ต้องกรอก

  ฟิลด์	ค่า
  remainingVehicleJourneySegments	จุดแวะพักไปถึงโดยกำหนดรัฐเป็น State.ARRIVED ตามด้วยรายการป้ายจอดรถที่เหลืออยู่ที่ระบุรัฐเป็น State.NEW

• ช่องที่ไม่บังคับมีดังนี้

  • ไม่มี

ระบบจะไม่สนใจช่องอื่นๆ ทั้งหมดในเอนทิตีสำหรับการอัปเดต

ตัวอย่างคำสั่ง curl

หมายเหตุ: คำสั่งนี้จะเขียนทับ remainingVehicleJourneySegments ที่ตั้งค่าไว้แล้วในยานพาหนะสำหรับนำส่ง

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

รถจอดสมบูรณ์

คุณต้องแจ้ง Fleet Engine เมื่อยานพาหนะจอดเสร็จแล้ว ซึ่งจะทำให้งานทั้งหมดที่เชื่อมโยงกับการหยุดตั้งค่าเป็นสถานะ "ปิด" คุณจะแจ้ง Fleet Engine ได้จาก Driver SDK หรือจากสภาพแวดล้อมของเซิร์ฟเวอร์โดยใช้ gRPC หรือ REST อย่าใช้ทั้ง 2 วิธีเพื่อหลีกเลี่ยงสภาวะการแข่งขันและคงแหล่งข้อมูลที่เชื่อถือได้เพียงแหล่งเดียว

gRPC

ตัวอย่างต่อไปนี้แสดงวิธีใช้ไลบรารี Java gRPC เพื่อแจ้ง 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 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

หากต้องการแจ้ง Fleet Engine เกี่ยวกับการหยุดจากสภาพแวดล้อมเซิร์ฟเวอร์ ให้เรียกใช้ HTTP REST ไปยัง UpdateDeliveryVehicle:

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

<id> คือตัวระบุที่ไม่ซ้ำกันสำหรับรถส่งของที่คุณตั้งใจจะอัปเดตลำดับของงาน ซึ่งเป็นตัวระบุที่คุณระบุ เมื่อสร้างยานพาหนะ

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็นโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี DeliveryVehicle

• ช่องที่ต้องกรอก

  ฟิลด์	ค่า
  remaining_vehicle_journey_segments	จุดแวะพักที่เสร็จสมบูรณ์แล้วไม่ควรอยู่ในรายการจุดแวะพักของยานพาหนะที่เหลืออยู่อีกต่อไป

• ช่องที่ไม่บังคับมีดังนี้

  • ไม่มี

ระบบจะไม่สนใจช่องอื่นๆ ทั้งหมดในเอนทิตีสำหรับการอัปเดต

ตัวอย่างคำสั่ง curl

หมายเหตุ: คำสั่งนี้จะเขียนทับ remainingVehicleJourneySegments ที่ตั้งค่าไว้แล้วในยานพาหนะสำหรับนำส่ง

    # 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

อัปเดตงาน

ช่องงานส่วนใหญ่จะเปลี่ยนแปลงไม่ได้ อย่างไรก็ตาม คุณสามารถแก้ไขสถานะ ผลลัพธ์ของงาน เวลาผลลัพธ์ของงาน ตำแหน่งของผลลัพธ์ของงาน และแอตทริบิวต์โดยการอัปเดตเอนทิตีงานได้โดยตรง ตัวอย่างเช่น ในกรณีที่ยังไม่ได้มอบหมายงานให้กับยานพาหนะ คุณสามารถปิดงานได้โดยอัปเดตสถานะโดยตรง

gRPC

นี่คือตัวอย่างของการอัปเดตงานผ่าน gRPC

REST

นี่คือตัวอย่างของการอัปเดตงานผ่าน REST

ปิดงาน

หากต้องการปิดงานที่มอบหมายให้กับยานพาหนะ ให้แจ้งเครื่องยนต์ Fleet Engine ว่ารถได้หยุดงานลงแล้วหรือนำงานออกจากรายการป้ายจอดรถ คุณสามารถตั้งค่ารายการป้ายจอดรถที่เหลือได้เหมือนกับเวลาอัปเดตลำดับงานสำหรับยานพาหนะ

หากยังไม่ได้มอบหมายยานพาหนะและจำเป็นต้องปิด ให้อัปเดตงานเป็นสถานะปิด แต่คุณจะเปิดงานที่ปิดไปแล้วอีกไม่ได้

การปิดงานไม่ได้บ่งบอกถึงความสำเร็จหรือล้มเหลว ซึ่งเป็นการระบุว่า งานไม่ถือว่ากำลังดำเนินการอยู่ ในการติดตามการจัดส่ง สิ่งสำคัญคือการระบุผลลัพธ์ที่แท้จริงของงานเพื่อให้แสดงสินค้าที่ส่งได้

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

หากต้องการทำเครื่องหมายงานว่าปิดจากสภาพแวดล้อมเซิร์ฟเวอร์ ให้เรียก HTTP REST ไปยัง UpdateTask โดยทำดังนี้

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

<id> คือตัวระบุที่ไม่ซ้ำสำหรับงาน

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็นโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

คุณต้องรวมเอนทิตี Task ไว้ในเนื้อหาของคำขอ

• ช่องที่ต้องกรอก

  ฟิลด์	ค่า
  state	State.CLOSED

• ช่องที่ไม่บังคับมีดังนี้

  ฟิลด์	ค่า
  taskOutcome	ผลลัพธ์.SUCCEEDED หรือผลลัพธ์ล้มเหลว
  taskOutcomeTime	เวลาที่งานเสร็จ
  taskOutcomeLocation	ตำแหน่งที่งานเสร็จแล้ว Fleet Engine กำหนดค่าเริ่มต้นนี้เป็นตำแหน่งสุดท้ายของยานพาหนะ เว้นแต่ว่าผู้ให้บริการจะลบล้างด้วยตนเอง

ระบบจะไม่สนใจช่องอื่นๆ ทั้งหมดในเอนทิตีสำหรับการอัปเดต

ตัวอย่างคำสั่ง 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

กำหนดผลลัพธ์ของงานและตำแหน่งผลลัพธ์

การปิดงานไม่ได้บ่งบอกถึงความสำเร็จหรือล้มเหลว แต่เป็นการระบุว่างานไม่ถือว่าอยู่ระหว่างดำเนินการอีกต่อไป ในการติดตามการจัดส่ง คุณควรระบุผลลัพธ์จริงของงานเพื่อให้แสดงผลการนำส่งและมีการเรียกเก็บเงินสำหรับบริการที่เหมาะสม เมื่อตั้งค่าแล้ว คุณจะเปลี่ยนผลลัพธ์ของงานไม่ได้ อย่างไรก็ตาม คุณสามารถแก้ไขเวลาผลลัพธ์ของงานและตำแหน่งผลลัพธ์ของงานได้หลังจากที่ตั้งค่าแล้ว

งานที่อยู่ในสถานะ "ปิด" สามารถกำหนดผลลัพธ์เป็น "SUCCEEDED" หรือ "ล้มเหลว" ได้ Fleet Engine จะเรียกเก็บเงินเฉพาะงานนำส่งที่มีสถานะเป็น SUCCEEDED เท่านั้น

เมื่อทำเครื่องหมายผลลัพธ์ของงาน Fleet Engine จะระบุตำแหน่งผลลัพธ์ของงานด้วยตำแหน่งล่าสุดที่ทราบของรถโดยอัตโนมัติ คุณสามารถลบล้างลักษณะการทำงานนี้ได้

gRPC

คุณจะมีตัวเลือกในการตั้งค่าตำแหน่งผลลัพธ์ของงานเมื่อตั้งค่าผลลัพธ์ การตั้งค่าตำแหน่งจะป้องกันไม่ให้ Fleet Engine ตั้งค่าเป็นค่าเริ่มต้นของตำแหน่งยานพาหนะล่าสุด คุณยังเขียนทับตำแหน่งผลลัพธ์ของงานที่ตั้งไว้ Fleet Engine ในภายหลังได้ด้วย Fleet Engine จะไม่เขียนทับตำแหน่งผลลัพธ์ของงานที่คุณระบุ คุณไม่สามารถตั้งค่าตำแหน่งผลลัพธ์ของงานสำหรับงานที่ไม่มีชุดผลลัพธ์ของงาน คุณสามารถตั้งค่าทั้งผลลัพธ์ของงานและตำแหน่งผลลัพธ์ของงานภายในคำขอเดียวกัน

ตัวอย่างต่อไปนี้แสดงวิธีใช้ไลบรารี Java gRPC เพื่อตั้งค่าผลลัพธ์ของงานเป็น SUCCEEDED และตั้งค่าตำแหน่งที่งานเสร็จสมบูรณ์

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

หากต้องการทำเครื่องหมายงานว่าเสร็จสมบูรณ์จากสภาพแวดล้อมเซิร์ฟเวอร์ ให้เรียก HTTP REST ไปยัง UpdateTask ดังนี้

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

<id> คือตัวระบุที่ไม่ซ้ำสำหรับงาน

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็นโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี Task

• ช่องที่ต้องกรอก

  ฟิลด์	ค่า
  taskOutcome	ผลลัพธ์.SUCCEEDED หรือผลลัพธ์ล้มเหลว

• ช่องที่ไม่บังคับมีดังนี้

  ฟิลด์	ค่า
  taskOutcomeLocation	ตำแหน่งที่งานเสร็จแล้ว หากไม่ได้ตั้งค่า Fleet Engine จะใช้ตำแหน่งสุดท้ายของยานพาหนะ
  taskOutcomeTime	การประทับเวลาเมื่องานเสร็จสมบูรณ์

ระบบจะไม่สนใจช่องอื่นๆ ทั้งหมดในเอนทิตีสำหรับการอัปเดต

ตัวอย่างคำสั่ง 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

กำหนดเส้นทางการจัดส่งใหม่

เมื่อสร้างงานการจัดส่งแล้ว คุณจะเปลี่ยนตำแหน่งที่วางแผนไว้ไม่ได้ หากต้องการเปลี่ยนเส้นทางการจัดส่ง ให้ปิดงานการจัดส่งโดยไม่กำหนดผลลัพธ์ แล้วสร้างงานใหม่ที่มีการอัปเดตตำแหน่งที่วางแผนไว้ หลังจากสร้างงานใหม่แล้ว ให้มอบหมายงานให้กับรถยนต์คันเดิม ดูข้อมูลเพิ่มเติมได้ที่ปิดงานการจัดส่งและมอบหมายงาน

ใช้เครื่องให้อาหารและยานพาหนะนำส่ง

หากใช้ยานพาหนะฟีดเดอร์ในการขนส่งการจัดส่งไปยังยานพาหนะนำส่งตลอดทั้งวัน ให้จำลองการโอนการจัดส่งเป็นงานแวะพักที่กำหนดเวลาไว้สำหรับยานพาหนะที่นำส่ง โปรดมอบหมายงานสำหรับการนำส่งหลังจากที่มีการขนย้ายสินค้าลงในรถนำส่งแล้ว เพื่อให้มีการติดตามตำแหน่งที่แม่นยำ ดูข้อมูลเพิ่มเติมได้ที่จุดแวะพักที่ตั้งเวลาไว้

สถานะการจัดส่งร้านค้าและข้อมูลเมตาอื่นๆ

เมื่องานจัดส่งเสร็จสมบูรณ์ สถานะงานและผลลัพธ์จะได้รับการบันทึกไว้ในงาน อย่างไรก็ตาม คุณอาจต้องอัปเดตข้อมูลเมตาอื่นๆ เฉพาะสำหรับการจัดส่ง หากต้องการจัดเก็บข้อมูลเมตาอื่นๆ ที่คุณอ้างอิงนอกบริการ Fleet Engine ได้ ให้ใช้ Tracking_id ที่เชื่อมโยงกับงานเป็นคีย์ในตารางภายนอก

ดูข้อมูลเพิ่มเติมได้ที่ช่วงชีวิตของงาน

ค้นหายานพาหนะ

คุณสามารถค้นหายานพาหนะจาก Driver SDK หรือจากสภาพแวดล้อมของเซิร์ฟเวอร์โดยใช้ gRPC หรือ REST

gRPC

ตัวอย่างต่อไปนี้แสดงวิธีใช้ไลบรารี Java gRPC เพื่อค้นหายานพาหนะ

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

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

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

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

REST

หากต้องการค้นหายานพาหนะจากสภาพแวดล้อมของเซิร์ฟเวอร์ ให้เรียก HTTP REST ไปยัง GetVehicle

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

<id> คือตัวระบุที่ไม่ซ้ำสำหรับงาน

<vehicleId> คือรหัสของยานพาหนะที่จะค้นหา

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็นโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องว่างเปล่า

หากค้นหาสำเร็จ เนื้อหาการตอบกลับจะมีเอนทิตียานพาหนะ

ตัวอย่างคำสั่ง 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}"

ค้นหางาน

คุณค้นหางานจากสภาพแวดล้อมของเซิร์ฟเวอร์ได้โดยใช้ gRPC หรือ REST Driver SDK ไม่รองรับ การค้นหางาน

gRPC

ตัวอย่างต่อไปนี้แสดงวิธีใช้ไลบรารี Java gRPC เพื่อค้นหางาน

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

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

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

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

     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

หากต้องการค้นหางานจากสภาพแวดล้อมของเซิร์ฟเวอร์ ให้เรียก HTTP REST ไปยัง GetTask

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

<id> คือตัวระบุที่ไม่ซ้ำสำหรับงาน

<taskId> คือรหัสของงานที่จะค้นหา

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็นโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องว่างเปล่า

หากค้นหาสำเร็จ เนื้อหาการตอบกลับจะมีเอนทิตีงาน

ตัวอย่างคำสั่ง 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}"

ค้นหาข้อมูลงานการจัดส่งตามรหัสติดตาม

คุณค้นหาข้อมูลงานการจัดส่งได้ด้วยวิธีต่อไปนี้ ซึ่งแต่ละประเภทมีจุดประสงค์ที่แตกต่างกัน

• ตามรหัสงาน: ใช้โดยผู้ใช้ เช่น ผู้ให้บริการกลุ่มอุปกรณ์ที่มีสิทธิ์เข้าถึงข้อมูลงานแบบสมบูรณ์
• ตามรหัสติดตาม: ซอฟต์แวร์ไคลเอ็นต์ใช้เพื่อให้ข้อมูลที่จำกัดแก่ผู้ใช้ปลายทาง เช่น เมื่อคาดว่าจะมีพัสดุที่บ้าน

ส่วนนี้จะกล่าวถึงการค้นหาข้อมูลงานตามรหัสติดตาม หากต้องการค้นหางานด้วยรหัสงาน ให้ไปที่ค้นหางาน

หากต้องการค้นหาข้อมูลตามรหัสติดตาม คุณสามารถใช้ตัวเลือกใดตัวเลือกหนึ่งต่อไปนี้

• การค้นหาด้วย Java โดยใช้ gRPC
• การค้นหาโดยใช้ HTTP

ข้อกำหนดในการค้นหา

• ข้อมูลการจัดส่งที่ระบุโดยรหัสติดตามจะเป็นไปตามกฎระดับการเข้าถึงที่ระบุไว้ในควบคุมการเปิดเผยสถานที่ที่ติดตาม

• ใช้ Fleet Engine เพื่อค้นหาข้อมูลการจัดส่งด้วยรหัสติดตาม Driver SDK ไม่รองรับการค้นหาข้อมูลตามรหัสติดตาม ในการดำเนินการนี้กับ Fleet Engine ให้ใช้เซิร์ฟเวอร์หรือสภาพแวดล้อมของเบราว์เซอร์

• ใช้โทเค็นที่แคบที่สุดเท่าที่ทำได้เพื่อจำกัดความเสี่ยงด้านความปลอดภัย ตัวอย่างเช่น หากคุณใช้ Delivery Consumer Token การเรียก Fleet Engine Deliveries API จะแสดงเฉพาะข้อมูลที่เกี่ยวข้องกับผู้ใช้ปลายทาง เช่น ผู้จัดส่งหรือผู้ได้รับการจัดส่ง ส่วนข้อมูลอื่นๆ ทั้งหมดในคำตอบจะได้รับการปกปิด ดูข้อมูลเพิ่มเติมเกี่ยวกับโทเค็นได้ที่การสร้าง JSON Web Token (JWT) สำหรับการให้สิทธิ์

การค้นหาด้วย Java โดยใช้ gRPC

ตัวอย่างต่อไปนี้แสดงวิธีใช้ไลบรารี Java gRPC เพื่อค้นหาข้อมูลเกี่ยวกับงานการจัดส่งตามรหัสติดตาม

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

การค้นหาโดยใช้ HTTP

หากต้องการค้นหางานการจัดส่งจากเบราว์เซอร์ ให้เรียกใช้ HTTP REST ไปยัง GetTaskTrackingInfo โดยทำดังนี้

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

<tracking_id> คือรหัสติดตามที่เชื่อมโยงกับงาน

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็นโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

หากการค้นหาสำเร็จ เนื้อหาการตอบกลับจะมีเอนทิตี taskTrackingInfo

ตัวอย่างคำสั่ง 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}"

แสดงรายการงาน

คุณแสดงรายการงานจากเซิร์ฟเวอร์หรือสภาพแวดล้อมของเบราว์เซอร์ได้ Driver SDK ไม่รองรับ การแสดงรายการงาน

งานในรายการจะขอสิทธิ์เข้าถึงงานแบบกว้าง งานในหน้าข้อมูลมีไว้สำหรับผู้ใช้ที่เชื่อถือได้เท่านั้น ใช้ Delivery Fleet Reader หรือโทเค็นการตรวจสอบสิทธิ์ผู้ใช้ระดับสูงสำหรับการส่งเมื่อส่งคำของานของรายการ

งานที่ระบุมีการปกปิดช่องต่อไปนี้

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

พร็อพเพอร์ตี้งานส่วนใหญ่สามารถกรองงานที่ระบุไว้ตามพร็อพเพอร์ตี้งานได้ โปรดดูไวยากรณ์การค้นหาตัวกรอง โปรดดู AIP-160 รายการต่อไปนี้แสดงพร็อพเพอร์ตี้งาน ที่ถูกต้องที่คุณสามารถใช้ในการกรอง

• แอตทริบิวต์
• delivery_vehicle_id
• state
• planned_location
• task_duration
• task_outcome
• task_outcome_location
• task_outcome_location_source
• task_outcome_time
• tracking_id
• ประเภท

ใช้รูปแบบช่องต่อไปนี้ตามข้อเสนอการปรับปรุง Google API

ชนิดของฟิลด์	รูปแบบ	ตัวอย่าง
การประทับเวลา	RFC-3339	task_outcome_time = 2022-03-01T11:30:00-08:00
ระยะเวลา	จำนวนวินาทีที่ตามด้วย s	task_duration = 120s
ค่าแจกแจง	สตริง	state = CLOSED AND type = PICKUP
ตำแหน่ง	point.latitudeและpoint.longitude	planned_location.point.latitude > 36.1 AND planned_location.point.longitude < -122.0

โปรดดู AIP-160 สำหรับรายการโอเปอเรเตอร์การค้นหาตัวกรองทั้งหมด

หากไม่ได้ระบุคําค้นหาตัวกรองไว้ ระบบจะแสดงงานทั้งหมด

มีการแบ่งหน้ารายการงานแล้ว ขนาดหน้าเว็บสามารถระบุในคำของานรายการได้ หากระบุขนาดหน้า จำนวนงานที่ส่งคืนจะไม่มากกว่าขนาดหน้าที่ระบุ หากไม่มีขนาดหน้า จะใช้ค่าเริ่มต้นที่สมเหตุสมผล หากขนาดหน้าที่ขอเกินค่าสูงสุดภายใน ระบบจะใช้ขนาดสูงสุดภายใน

รายการงานอาจมีโทเค็นสำหรับอ่านผลการค้นหาหน้าถัดไปได้ ใช้โทเค็นหน้ากับคำขอที่เหมือนกับคำขอก่อนหน้าเพื่อเรียกข้อมูลหน้าถัดไปของงาน เมื่อโทเค็นหน้าเว็บที่ส่งกลับว่างเปล่า ก็จะไม่มีงานให้ดึงข้อมูลได้อีก

หมายเหตุ: การกรองแอตทริบิวต์ของงานอาจทําให้เวลาในการตอบสนองของการดึงข้อมูลเพิ่มขึ้นอย่างมาก คุณจึงควรใช้งานด้วยความระมัดระวัง

gRPC

ตัวอย่างต่อไปนี้แสดงวิธีใช้ไลบรารี Java gRPC เพื่อแสดงรายการงานสำหรับ deliveryVehicleId และแอตทริบิวต์งาน การตอบกลับที่สำเร็จ อาจว่างเปล่า การตอบกลับที่ว่างเปล่าหมายความว่าไม่มี Tasks ที่เชื่อมโยงกับ 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

หากต้องการแสดงรายการงานจากเบราว์เซอร์ ให้เรียก HTTP REST ไปยัง ListTasks

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

หากต้องการใช้ตัวกรองกับงานที่แสดง ให้ใส่พารามิเตอร์ของ URL "ตัวกรอง" โดยมีคำค้นหาตัวกรองที่ใช้อักขระหลีกกับ URL เป็นค่า

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็นโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

หากการค้นหาสำเร็จ เนื้อหาการตอบกลับจะมีข้อมูลที่มีโครงสร้างต่อไปนี้

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

การตอบกลับที่สำเร็จอาจว่างเปล่า การตอบกลับที่ว่างเปล่าหมายความว่าไม่พบงานที่ตรงกับเกณฑ์ตัวกรองที่ระบุ

ตัวอย่างคำสั่ง 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}"

แสดงรายการยานพาหนะสำหรับนำส่ง

คุณแสดงรายการยานพาหนะสำหรับนำส่งได้จากเซิร์ฟเวอร์หรือสภาพแวดล้อมของเบราว์เซอร์ Driver SDK ไม่รองรับยานพาหนะสำหรับนำส่งข้อมูล

ยานพาหนะสำหรับนำส่งข้อมูลจะขอสิทธิ์เข้าถึงแบบกว้างสำหรับยานพาหนะนำส่งและมีไว้สำหรับผู้ใช้ที่เชื่อถือได้เท่านั้น ใช้ Delivery Fleet Reader หรือโทเค็นการตรวจสอบสิทธิ์ผู้ใช้ระดับสูงสำหรับการส่งเมื่อสร้างรายการคำขอยานพาหนะสำหรับการส่ง

ยานพาหนะสำหรับนำส่งที่ระบุไว้มีการปกปิดช่องต่อไปนี้เนื่องจากผลกระทบต่อขนาดการตอบกลับ

• CurrentRouteSegment
• RemainingVehicleJourneySegments

คุณกรองรายการยานพาหนะสำหรับนำส่งสินค้าได้ตามพร็อพเพอร์ตี้ attributes ตัวอย่างเช่น หากต้องการค้นหาแอตทริบิวต์ที่มีคีย์ my_key และค่า my_value ให้ใช้ attributes.my_key = my_value หากต้องการค้นหาหลายแอตทริบิวต์ ให้ผนวกการค้นหาโดยใช้โอเปอเรเตอร์เชิงตรรกะ AND และ OR ดังเช่นใน attributes.key1 = value1 AND attributes.key2 = value2 ดูรายละเอียดทั้งหมดของไวยากรณ์การค้นหาตัวกรองได้ที่ AIP-160

คุณกรองยานพาหนะสำหรับนำส่งที่แสดงตามสถานที่ได้โดยใช้พารามิเตอร์คำขอ viewport พารามิเตอร์คำขอ viewport กำหนดวิวพอร์ตโดยใช้พิกัดขอบเขต 2 แบบ ได้แก่ คู่พิกัดละติจูดและลองจิจูด high (ตะวันออกเฉียงเหนือ) และ low (ตะวันตกเฉียงใต้) คำขอจะถูกปฏิเสธหากมีละติจูดสูง ซึ่งมีพื้นที่ทางภูมิศาสตร์ต่ำกว่าละติจูดต่ำ

หมายเหตุ: หากคุณไม่ระบุคำค้นหาหรือวิวพอร์ตตัวกรอง การตอบกลับจะรวมยานพาหนะสำหรับนำส่งทั้งหมด

ระบบจะใส่เลขหน้าให้กับรายการยานพาหนะสำหรับนำส่งโดยค่าเริ่มต้นโดยใช้ขนาดหน้าที่เหมาะสม หากคุณระบุขนาดหน้า คำขอจะแสดงเฉพาะจำนวนยานพาหนะที่ระบุตามขีดจำกัด หรือน้อยกว่านี้ หากขนาดหน้าที่ขอเกินค่าสูงสุดภายใน ระบบจะใช้ขนาดสูงสุดภายใน ขนาดหน้าเริ่มต้นและสูงสุด คือยานพาหนะ 100 ชิ้น

รายการยานพาหนะนำส่งอาจมีโทเค็นสำหรับอ่านผลการค้นหาหน้าถัดไป โทเค็นหน้าจะแสดงในการตอบกลับก็ต่อเมื่อมีพาหนะนำส่งหน้าพร้อมให้ดึงข้อมูลมากขึ้นเท่านั้น หากต้องการเรียกข้อมูลหน้าถัดไปของงาน ให้ใช้โทเค็นหน้าที่มีคำขอที่เหมือนกับคำขอก่อนหน้า

gRPC

ตัวอย่างต่อไปนี้แสดงวิธีใช้ไลบรารี Java gRPC เพื่อแสดงยานพาหนะสำหรับจัดส่งในภูมิภาคที่มีแอตทริบิวต์บางรายการ การตอบกลับที่สำเร็จอาจว่างเปล่า เมื่อเกิดกรณีนี้ขึ้น หมายความว่าไม่มียานพาหนะที่มีแอตทริบิวต์ที่ระบุอยู่ในวิวพอร์ตที่ระบุอยู่แล้ว

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

หากต้องการแสดงรายการงานจากเบราว์เซอร์ ให้เรียก HTTP REST ไปยัง ListDeliveryVehicles

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

หากต้องการใช้ตัวกรองกับงานที่แสดง ให้ใส่พารามิเตอร์ของ URL "ตัวกรอง" โดยใช้คำค้นหาตัวกรองที่ใช้ Escape URL เป็นค่า

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็นโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

หากการค้นหาสำเร็จ เนื้อหาการตอบกลับจะมีข้อมูลที่มีโครงสร้างต่อไปนี้

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

การตอบกลับที่สำเร็จอาจว่างเปล่า เมื่อเกิดกรณีนี้ขึ้น หมายความว่าไม่พบยานพาหนะสำหรับนำส่งที่เป็นไปตามคำค้นหาและวิวพอร์ตของตัวกรองที่ระบุ

ตัวอย่างคำสั่ง 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"

การติดตามการจัดส่ง

คุณมี 2 ตัวเลือกในการใช้ Fleet Engine Deliveries API เพื่อเปิดใช้การติดตามการจัดส่ง ดังนี้

• แนะนำ: ใช้ไลบรารีการติดตามการจัดส่ง JavaScript ไลบรารีช่วยให้คุณเห็นภาพตำแหน่งของยานพาหนะและตำแหน่งที่สนใจที่ติดตามใน Fleet Engine ไฟล์นี้มีคอมโพเนนต์แผนที่ JavaScript ที่เป็นการแทนที่แบบดร็อปอินสำหรับออบเจ็กต์ google.maps.Map มาตรฐาน และคอมโพเนนต์ข้อมูลเพื่อเชื่อมต่อกับ Fleet Engine คอมโพเนนต์นี้ช่วยให้คุณมอบประสบการณ์การติดตามการจัดส่งที่เป็นภาพเคลื่อนไหวที่ปรับแต่งได้ จากเว็บหรือแอปพลิเคชันบนอุปกรณ์เคลื่อนที่

• ใช้การติดตามการจัดส่งของคุณเองนอกเหนือจาก Fleet Engine Deliveries API

สิ่งสำคัญคือการค้นหางานการจัดส่งโดยใช้รหัสติดตาม

หากคุณใช้บทบาทผู้บริโภคในการนำส่ง การเรียก Fleet Engine Deliveries API จะแสดงเฉพาะข้อมูลที่เกี่ยวข้องสำหรับผู้จัดส่งหรือผู้รับ ส่วนข้อมูลอื่นๆ ทั้งหมดในคำตอบจะถูกปกปิด คุณมีหน้าที่รับผิดชอบในการตรวจสอบสิทธิ์ผู้ใช้ปลายทาง นอกจากนี้ ข้อมูลตำแหน่งยังถูกกรอง ตามงานที่ทำอยู่แล้วด้วย ในระหว่างงานที่ไม่พร้อมใช้งาน จะไม่มีการแชร์ข้อมูลตำแหน่งกับผู้ใช้ปลายทาง

Logging

คุณสามารถตั้งค่า Fleet Engine ให้ส่งบันทึก RPC ไปยัง Cloud Logging สำหรับ ข้อมูลเพิ่มเติม โปรดดู การบันทึก

บทบาทและโทเค็นการให้สิทธิ์

ตามที่อธิบายไว้ในส่วนจัดการวงจรงานและยานพาหนะ และหมายเหตุการให้สิทธิ์สำหรับกรณีการใช้งานแต่ละรายการ การเรียกใช้ Fleet Engine ต้องมีการตรวจสอบสิทธิ์ด้วย JSON Web Token ที่ได้ลงนามโดยใช้ข้อมูลเข้าสู่ระบบของบัญชีบริการ บัญชีบริการที่ใช้ในการออกโทเค็นเหล่านั้นอาจมีอย่างน้อย 1 บทบาท โดยแต่ละบทบาทจะให้สิทธิ์ที่แตกต่างกัน

สำหรับข้อมูลเพิ่มเติม โปรดดู การตรวจสอบสิทธิ์และการให้สิทธิ์

แก้ไขปัญหาทั่วไป

หากคุณพบปัญหาใดๆ โปรดดูส่วนต่อไปนี้เพื่อรับความช่วยเหลือ

ความยืดหยุ่น

Fleet Engine ไม่ถือเป็นแหล่งข้อมูลที่เชื่อถือได้ หากจำเป็น คุณมีหน้าที่รับผิดชอบในการกู้คืนสถานะระบบโดยไม่ต้องใช้ Fleet Engine

สถานะสูญหายใน Fleet Engine

เมื่อทำงานกับ Fleet Engine ให้ใช้ไคลเอ็นต์เพื่อให้ระบบเยียวยาตัวเองหากทำงานผิดพลาด ตัวอย่างเช่น เมื่อ Fleet Engine พยายามอัปเดตยานพาหนะ อาจมีการตอบสนองโดยมีข้อผิดพลาดที่ระบุว่าไม่มียานพาหนะอยู่ จากนั้นลูกค้าควรสร้างยานพาหนะใหม่ในสถานะใหม่ แม้ว่าปัญหานี้จะเกิดขึ้นไม่บ่อยนัก แต่โปรดตรวจสอบว่าระบบของคุณมีความยืดหยุ่นมากพอที่จะจัดการกับปัญหาได้

ในสถานการณ์ที่แทบไม่น่าเป็นไปได้อย่างมากของความเสียหายร้ายแรงของ Fleet Engine คุณอาจต้องสร้างยานพาหนะและงานส่วนใหญ่หรือทั้งหมดขึ้นมาใหม่ หากอัตราการสร้างสูงเกินไป คำขอบางรายการอาจล้มเหลวอีกครั้งเนื่องจากปัญหาด้านโควต้าเนื่องจากมีการตรวจสอบโควต้าเพื่อหลีกเลี่ยงการโจมตีแบบปฏิเสธการให้บริการ (DOS) ในกรณีนี้ ให้ชะลออัตราการสันทนาการลงโดยใช้กลยุทธ์ Backoff ในการพยายามซ้ำ

สถานะสูญหายในแอปคนขับ

หากแอปไดรเวอร์ขัดข้อง แอปต้องสร้างสถานะปัจจุบันขึ้นใหม่ภายใน Driver SDK แอปควรพยายามสร้างงานใหม่เพื่อให้แน่ใจว่า งานมีอยู่จริงและคืนค่าสถานะปัจจุบันได้ แอปควรสร้างใหม่และตั้งค่ารายการจุดแวะสำหรับ Driver SDK ให้ชัดเจนด้วย

หมายเหตุ: การกู้คืนเหล่านี้ต้องดำเนินการแบบอัตโนมัติโดยไม่ใช้ข้อมูลจาก Fleet Engine นอกเหนือจากข้อผิดพลาดที่ระบุว่ามีเอนทิตีในฐานข้อมูลอยู่แล้วหรือไม่และเมื่อก่อน หากมีเอนทิตีอยู่แล้ว ระบบจะแก้ไขข้อผิดพลาดดังกล่าวและอัปเดตเอนทิตีได้โดยใช้รหัส

คำถามที่พบบ่อย

จะเกิดอะไรขึ้นหากคนขับหยุดงานที่ไม่เป็นไปตามคำสั่ง

ในกรณีนี้ ให้อัปเดตลำดับของงานก่อน แล้วดำเนินการต่อตามปกติ โดยทำเครื่องหมายเมื่อมาถึงจุดแวะ งานเสร็จแล้ว และรายละเอียดอื่นๆ ไม่เช่นนั้นระบบอาจทำงานไม่สอดคล้อง เวลาถึงโดยประมาณอาจไม่ถูกต้อง และอาจมีการรายงานข้อผิดพลาดที่ไม่คาดคิด