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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

• ยานพาหนะที่ใช้ขนส่งเพื่อการขนส่ง
• งานมารับสินค้าและนำส่ง

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

ยานพาหนะส่งของ

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

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

งาน

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

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

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

หากต้องการสร้างงานใน Fleet Engine ให้ใช้ตัวจัดการงาน SDK ของ Driver

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

สร้างงานการจัดส่งสำหรับทั้งการมารับและนำส่งพัสดุ รวมถึงระบุข้อมูลต่อไปนี้

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

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

Android

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

iOS

• GMTD DeliveryTaskManager
• GMTSTaskType

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

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

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

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

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

Android

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

iOS

• GMTD DeliveryTaskManager
• GMTSTaskType

งานหยุดที่กำหนดเวลาไว้

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

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

Android

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

iOS

• GMTD DeliveryTaskManager
• GMTSTaskType

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

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

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

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

• 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 Summer Dr. East Hartford, 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 เพื่อสร้างยานพาหนะอีกครั้ง หากโทรกลับสําหรับรถยนต์ คุณจะยังอัปเดตรถยนต์ได้

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

เอนทิตี 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 มีช่องสถานะเพื่อติดตามความคืบหน้าผ่านวงจรของออบเจ็กต์ ค่าจะย้ายจาก "เปิด" เป็น "ปิด" ระบบจะสร้างงานใหม่ในสถานะ "เปิด" ซึ่งระบุข้อใดข้อหนึ่งต่อไปนี้

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

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

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

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

เมื่อยานพาหนะของงานหยุดยานพาหนะของงานสำเร็จ

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

สร้างแบบจำลองวันทำงาน

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

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

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

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

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

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

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

จุดจอดคือจุดที่ยานพาหนะนำส่งสินค้าหรืองานอื่นๆ จนเสร็จ ซึ่งอาจเป็นจุดเข้าใช้งาน เช่น จุดขนย้ายสิ่งของ หรือตำแหน่งถนน

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

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

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

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

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

ก่อนที่จะเรียกใช้ Driver 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));
     }
   });

Use Case

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

รหัสเอนทิตีที่ไม่ซ้ำกัน

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

สร้างยานพาหนะ

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

gRPC

หากต้องการสร้างยานพาหนะใหม่ โปรดโทรไปที่ CreateDeliveryVehicle ไปยัง Fleet Engine ใช้ออบเจ็กต์ 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}"

สร้างงานรับพัสดุ

คุณสร้างงานรับพัสดุได้จาก 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

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

สร้างงานการนำส่งการจัดส่งจาก 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

ความไม่พร้อมใช้งานตามกำหนดเวลา

คุณจะสร้างงานที่ระบุความไม่พร้อมใช้งาน (เช่น รถเสียหรือเติมน้ำมันรถ) ได้จาก 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

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

คุณสร้างงานหยุดที่กำหนดเวลาไว้จาก 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 งานให้กับจุดแวะพักแต่ละแห่งได้ โปรดดูรายละเอียดที่อัปเดตลำดับงาน

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

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

คุณสามารถอัปเดตงานคำสั่งซื้อที่มอบหมายให้กับรถได้จาก 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	สถานที่วางแผนสำหรับจุดแวะพัก
  ที่เหลืออยู่VehicleJourneySegments[i].stop.tasks	รายการงานที่ต้องทำที่ป้ายจอดรถแห่งนี้
  remainingVehicleJourneySegments[i].stop.state	State.NEW

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

  • ไม่มี

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

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

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

รถกำลังอยู่ระหว่างทางไปยังป้ายถัดไป

Fleet Engine ต้องได้รับการแจ้งเตือนเมื่อรถออกจากจุดแวะพักหรือเริ่มการนำทาง คุณแจ้ง Fleet Engine ได้จาก 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

# 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 เมื่อยานพาหนะมาถึงจุดแวะพัก คุณแจ้ง Flet Engine ได้จาก 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

# 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 ได้จาก 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

    # 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 หรือ ผลลัพธ์.FAILED
  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 หรือ ผลลัพธ์.FAILED

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

  ฟิลด์	ค่า
  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 ให้ใช้รหัสติดตามที่เชื่อมโยงกับงานเป็นคีย์ในตารางภายนอก

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

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

คุณค้นหายานพาหนะได้จาก 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 เพื่อค้นหาข้อมูลการจัดส่งตามรหัสติดตาม 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 ไม่สนับสนุน การแสดงรายการงาน

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

งานที่แสดงจะมีการปกปิดช่องต่อไปนี้

• 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 และแอตทริบิวต์งาน การตอบกลับที่สำเร็จอาจยังว่างเปล่า การตอบกลับที่ว่างเปล่าแสดงว่าไม่มีงานใด ที่เชื่อมโยงกับ 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}"

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

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

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

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

• 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 ไม่ถือเป็นแหล่งข้อมูลที่เชื่อถือได้ คุณมีหน้าที่รับผิดชอบในการคืนค่าสถานะของระบบ หากจำเป็น โดยไม่ต้องอาศัย Flleet Engine

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

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

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

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

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

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

จะทำอย่างไรหากคนขับหยุดรับงานที่ไม่ได้อยู่ในคำสั่ง

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