ตรวจสอบสิทธิ์และให้สิทธิ์ในฐานะผู้ใช้ Google Chat

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

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

  • สร้างพื้นที่ใน Chat
  • เพิ่มผู้ใช้ในพื้นที่ทำงานและการสนทนากลุ่มของ Chat
  • ทำงานกับข้อมูลผู้ใช้ใน Workspace API อื่นๆ เช่น ต่อไปนี้

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

แอป Google Chat สร้างพื้นที่ทำงานให้กับผู้ใช้
รูปที่ 1 ข้อความระบุแหล่งที่มาที่ Google Chat แสดงเมื่อแอปใน Chat สร้างพื้นที่ทำงานในนามของผู้ใช้

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

ตรวจสอบสิทธิ์และมอบสิทธิ์ในฐานะผู้ดูแลระบบ Google Workspace

ส่วนนี้จะอธิบายวิธีที่ผู้ดูแลระบบ Workspace ของ Google Workspace สามารถจัดการแอปและพื้นที่ทำงาน Google Chat ทั่วทั้งองค์กรด้วยการรับรองความถูกต้องของผู้ใช้

ตรวจสอบสิทธิ์และให้สิทธิ์โดยใช้การมอบสิทธิ์ทั่วทั้งโดเมน

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

ตรวจสอบสิทธิ์และให้สิทธิ์โดยใช้สิทธิ์ของผู้ดูแลระบบ

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

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

ข้อกำหนดเบื้องต้น

Java

  • บัญชี Google Workspace รุ่น Business หรือ Enterprise ที่มีสิทธิ์เข้าถึง Google Chat
  • สร้างโปรเจ็กต์ Google Cloud
  • เปิดใช้และกําหนดค่า Google Chat API พร้อมตั้งชื่อ ไอคอน และคําอธิบายสําหรับแอป Chat
  • JDK 1.7 ขึ้นไป
  • เครื่องมือจัดการแพ็กเกจ Maven
  • โปรเจ็กต์ Maven ที่เริ่มต้นแล้ว หากต้องการเริ่มต้นโปรเจ็กต์ใหม่ ให้เรียกใช้คำสั่งต่อไปนี้ในอินเทอร์เฟซบรรทัดคำสั่ง 
    mvn archetype:generate -DgroupId=com.google.chat.app.authsample -DartifactId=auth-sample-app -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false

Python

Node.js

  • บัญชี Google Workspace รุ่น Business หรือ Enterprise ที่มีสิทธิ์เข้าถึง Google Chat
  • สร้างโปรเจ็กต์ Google Cloud
  • เปิดใช้และกําหนดค่า Google Chat API พร้อมตั้งชื่อ ไอคอน และคําอธิบายสําหรับแอป Chat
  • Node.js 14 ขึ้นไป
  • เครื่องมือจัดการแพ็กเกจ npm
  • โปรเจ็กต์ Node.js ที่เริ่มต้นแล้ว หากต้องการเริ่มต้นโปรเจ็กต์ใหม่ ให้สร้างและเปลี่ยนไปใช้โฟลเดอร์ใหม่ จากนั้นเรียกใช้คำสั่งต่อไปนี้ในอินเทอร์เฟซบรรทัดคำสั่ง 
    npm init

Apps Script

ขั้นตอนที่ 1: กำหนดค่าหน้าจอขอความยินยอม OAuth, ระบุขอบเขต และลงทะเบียนแอป

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

แอปทั้งหมดที่ใช้ OAuth 2.0 ต้องมีการกำหนดค่าหน้าจอขอความยินยอม แต่คุณจะต้องระบุขอบเขตสำหรับแอปที่บุคคลภายนอกองค์กร Google Workspace ใช้เท่านั้น

  1. ในคอนโซล Google Cloud ให้ไปที่เมนู > API และบริการ > หน้าจอขอความยินยอม OAuth

    ไปที่หน้าจอขอความยินยอม OAuth

  2. เลือกประเภทผู้ใช้สําหรับแอป แล้วคลิกสร้าง

  3. กรอกแบบฟอร์มการลงทะเบียนแอปให้สมบูรณ์ แล้วคลิกบันทึกและดำเนินการต่อ

  4. คลิกเพิ่มหรือนำขอบเขตออก เพิ่มและยืนยันขอบเขตการให้สิทธิ์ที่จําเป็นสําหรับแอป แล้วคลิกอัปเดต จากนั้นคลิกบันทึกและดําเนินการต่อ

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

ขั้นตอนที่ 2: สร้างข้อมูลเข้าสู่ระบบรหัสไคลเอ็นต์ OAuth ในคอนโซล Google Cloud

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

สร้างข้อมูลเข้าสู่ระบบรหัสไคลเอ็นต์ OAuth

เลือกประเภทแอปพลิเคชันเพื่อดูวิธีการเฉพาะเกี่ยวกับวิธีสร้างรหัสไคลเอ็นต์ OAuth

เว็บแอปพลิเคชัน

  1. ในคอนโซล Google Cloud ให้ไปที่เมนู > API และบริการ > ข้อมูลเข้าสู่ระบบ

    ไปที่ข้อมูลเข้าสู่ระบบ

  2. คลิกสร้างข้อมูลเข้าสู่ระบบ > รหัสไคลเอ็นต์ OAuth
  3. คลิกประเภทแอปพลิเคชัน > เว็บแอปพลิเคชัน
  4. พิมพ์ชื่อของข้อมูลเข้าสู่ระบบในช่องชื่อ ชื่อนี้จะแสดงในคอนโซล Google Cloud เท่านั้น
  5. เพิ่ม URI ที่ได้รับอนุญาตที่เกี่ยวข้องกับแอปของคุณ โดยทำดังนี้
    • แอปฝั่งไคลเอ็นต์ (JavaScript) - ในส่วนต้นทาง JavaScript ที่ได้รับอนุญาต ให้คลิกเพิ่ม URI จากนั้นป้อน URI ที่จะใช้สําหรับคําขอของเบราว์เซอร์ ซึ่งจะระบุโดเมนที่แอปพลิเคชันสามารถส่งคําขอ API ไปยังเซิร์ฟเวอร์ OAuth 2.0 ได้
    • แอปฝั่งเซิร์ฟเวอร์ (Java, Python และอื่นๆ) - คลิกเพิ่ม URI ในส่วน URI การเปลี่ยนเส้นทางที่ได้รับอนุญาต จากนั้นป้อน URI ปลายทางที่เซิร์ฟเวอร์ OAuth 2.0 สามารถส่งการตอบกลับได้
  6. คลิกสร้าง หน้าจอ "สร้างไคลเอ็นต์ OAuth แล้ว" จะปรากฏขึ้นพร้อมแสดงรหัสไคลเอ็นต์และรหัสลับไคลเอ็นต์ใหม่

    จดรหัสไคลเอ็นต์ รหัสลับไคลเอ็นต์ไม่ได้ใช้สําหรับเว็บแอปพลิเคชัน

  7. คลิกตกลง ข้อมูลเข้าสู่ระบบที่สร้างขึ้นใหม่จะปรากฏในส่วนรหัสไคลเอ็นต์ OAuth 2.0

Android

  1. ในคอนโซล Google Cloud ให้ไปที่เมนู > API และบริการ > ข้อมูลเข้าสู่ระบบ

    ไปที่ข้อมูลเข้าสู่ระบบ

  2. คลิกสร้างข้อมูลเข้าสู่ระบบ > รหัสไคลเอ็นต์ OAuth
  3. คลิกประเภทแอปพลิเคชัน > Android
  4. ในช่อง "ชื่อ" ให้พิมพ์ชื่อของข้อมูลเข้าสู่ระบบ ชื่อนี้จะแสดงในคอนโซล Google Cloud เท่านั้น
  5. ในช่อง "ชื่อแพ็กเกจ" ให้ป้อนชื่อแพ็กเกจจากไฟล์ AndroidManifest.xml
  6. ในช่อง "ลายนิ้วมือใบรับรอง SHA-1" ให้ป้อนลายนิ้วมือใบรับรอง SHA-1 ที่สร้างขึ้น
  7. คลิกสร้าง หน้าจอ "สร้างไคลเอ็นต์ OAuth แล้ว" จะปรากฏขึ้นพร้อมแสดงรหัสไคลเอ็นต์ใหม่
  8. คลิกตกลง ข้อมูลเข้าสู่ระบบที่สร้างขึ้นใหม่จะปรากฏในส่วน "รหัสไคลเอ็นต์ OAuth 2.0"

iOS

  1. ในคอนโซล Google Cloud ให้ไปที่เมนู > API และบริการ > ข้อมูลเข้าสู่ระบบ

    ไปที่ข้อมูลเข้าสู่ระบบ

  2. คลิกสร้างข้อมูลเข้าสู่ระบบ > รหัสไคลเอ็นต์ OAuth
  3. คลิกประเภทแอปพลิเคชัน > iOS
  4. ในช่อง "ชื่อ" ให้พิมพ์ชื่อของข้อมูลเข้าสู่ระบบ ชื่อนี้จะแสดงในคอนโซล Google Cloud เท่านั้น
  5. ในช่อง "รหัสกลุ่ม" ให้ป้อนรหัสกลุ่มตามที่แสดงในไฟล์ Info.plist ของแอป
  6. ไม่บังคับ: หากแอปปรากฏใน Apple App Store ให้ป้อนรหัส App Store
  7. ไม่บังคับ: ในช่อง "รหัสทีม" ให้ป้อนสตริงแบบ 10 อักขระที่ไม่ซ้ำกันซึ่งสร้างโดย Apple และกำหนดให้กับทีมของคุณ
  8. คลิกสร้าง หน้าจอ "สร้างไคลเอ็นต์ OAuth แล้ว" จะปรากฏขึ้นพร้อมแสดงรหัสไคลเอ็นต์และรหัสลับไคลเอ็นต์ใหม่
  9. คลิกตกลง ข้อมูลเข้าสู่ระบบที่สร้างขึ้นใหม่จะปรากฏในส่วน "รหัสไคลเอ็นต์ OAuth 2.0"

แอป Chrome

  1. ในคอนโซล Google Cloud ให้ไปที่เมนู > API และบริการ > ข้อมูลเข้าสู่ระบบ

    ไปที่ข้อมูลเข้าสู่ระบบ

  2. คลิกสร้างข้อมูลเข้าสู่ระบบ > รหัสไคลเอ็นต์ OAuth
  3. คลิกประเภทแอปพลิเคชัน > แอป Chrome
  4. ในช่อง "ชื่อ" ให้พิมพ์ชื่อของข้อมูลเข้าสู่ระบบ ชื่อนี้จะแสดงในคอนโซล Google Cloud เท่านั้น
  5. ในช่อง "รหัสแอปพลิเคชัน" ให้ป้อนสตริงรหัส 32 อักขระที่ไม่ซ้ำกันของแอป คุณสามารถดูค่ารหัสนี้ได้ใน URL ของ Chrome เว็บสโตร์ของแอปและในหน้าแดชบอร์ดสำหรับนักพัฒนาแอป Chrome เว็บสโตร์
  6. คลิกสร้าง หน้าจอ "สร้างไคลเอ็นต์ OAuth แล้ว" จะปรากฏขึ้นพร้อมแสดงรหัสไคลเอ็นต์และรหัสลับไคลเอ็นต์ใหม่
  7. คลิกตกลง ข้อมูลเข้าสู่ระบบที่สร้างขึ้นใหม่จะปรากฏในส่วน "รหัสไคลเอ็นต์ OAuth 2.0"

แอปบนเดสก์ท็อป

  1. ในคอนโซล Google Cloud ให้ไปที่เมนู > API และบริการ > ข้อมูลเข้าสู่ระบบ

    ไปที่ข้อมูลเข้าสู่ระบบ

  2. คลิกสร้างข้อมูลเข้าสู่ระบบ > รหัสไคลเอ็นต์ OAuth
  3. คลิกประเภทแอปพลิเคชัน > แอปเดสก์ท็อป
  4. พิมพ์ชื่อของข้อมูลเข้าสู่ระบบในช่องชื่อ ชื่อนี้จะแสดงในคอนโซล Google Cloud เท่านั้น
  5. คลิกสร้าง หน้าจอ "สร้างไคลเอ็นต์ OAuth แล้ว" จะปรากฏขึ้นพร้อมแสดงรหัสไคลเอ็นต์และรหัสลับไคลเอ็นต์ใหม่
  6. คลิกตกลง ข้อมูลเข้าสู่ระบบที่สร้างขึ้นใหม่จะปรากฏในส่วนรหัสไคลเอ็นต์ OAuth 2.0

ทีวีและอุปกรณ์อินพุตที่จำกัด

  1. ในคอนโซล Google Cloud ให้ไปที่เมนู > API และบริการ > ข้อมูลเข้าสู่ระบบ

    ไปที่ข้อมูลเข้าสู่ระบบ

  2. คลิกสร้างข้อมูลเข้าสู่ระบบ > รหัสไคลเอ็นต์ OAuth
  3. คลิกประเภทแอปพลิเคชัน > ทีวีและอุปกรณ์อินพุตแบบจำกัด
  4. ในช่อง "ชื่อ" ให้พิมพ์ชื่อของข้อมูลเข้าสู่ระบบ ชื่อนี้จะแสดงในคอนโซล Google Cloud เท่านั้น
  5. คลิกสร้าง หน้าจอ "สร้างไคลเอ็นต์ OAuth แล้ว" จะปรากฏขึ้นพร้อมแสดงรหัสไคลเอ็นต์และรหัสลับไคลเอ็นต์ใหม่
  6. คลิกตกลง ข้อมูลเข้าสู่ระบบที่สร้างขึ้นใหม่จะปรากฏในส่วน "รหัสไคลเอ็นต์ OAuth 2.0"

Universal Windows Platform (UWP)

  1. ในคอนโซล Google Cloud ให้ไปที่เมนู > API และบริการ > ข้อมูลเข้าสู่ระบบ

    ไปที่ข้อมูลเข้าสู่ระบบ

  2. คลิกสร้างข้อมูลเข้าสู่ระบบ > รหัสไคลเอ็นต์ OAuth
  3. คลิกประเภทแอปพลิเคชัน > แพลตฟอร์ม Universal Windows (UWP)
  4. ในช่อง "ชื่อ" ให้พิมพ์ชื่อของข้อมูลเข้าสู่ระบบ ชื่อนี้จะแสดงในคอนโซล Google Cloud เท่านั้น
  5. ในช่อง "รหัสร้านค้า" ให้ป้อนค่ารหัส Microsoft Store ที่ไม่ซ้ำกัน 12 อักขระของแอป คุณจะพบรหัสนี้ใน URL ของ Microsoft Store ของแอปและใน Partner Center
  6. คลิกสร้าง หน้าจอ "สร้างไคลเอ็นต์ OAuth แล้ว" จะปรากฏขึ้นพร้อมแสดงรหัสไคลเอ็นต์และรหัสลับไคลเอ็นต์ใหม่
  7. คลิกตกลง ข้อมูลเข้าสู่ระบบที่สร้างขึ้นใหม่จะปรากฏในส่วน "รหัสไคลเอ็นต์ OAuth 2.0"

ดาวน์โหลดไฟล์ JSON ของรหัสลับไคลเอ็นต์

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

  1. ในคอนโซล Google Cloud ให้ไปที่เมนู > API และบริการ > ข้อมูลเข้าสู่ระบบ

    ไปที่ข้อมูลเข้าสู่ระบบ

  2. ในส่วนรหัสไคลเอ็นต์ OAuth 2.0 ให้คลิกรหัสไคลเอ็นต์ที่คุณสร้างขึ้น

  3. คลิกดาวน์โหลด JSON

  4. บันทึกไฟล์เป็น client_secrets.json

ขั้นตอนที่ 3: ติดตั้งไลบรารีของไคลเอ็นต์ Google และทรัพยากร Dependency อื่นๆ

ติดตั้งไลบรารีของไคลเอ็นต์ Google และทรัพยากร Dependency อื่นๆ ที่จําเป็นสําหรับโปรเจ็กต์

Java

หากต้องการเพิ่มไลบรารีไคลเอ็นต์ของ Google และไลบรารีอื่นๆ ที่ต้องใช้ในโปรเจ็กต์ Maven ให้แก้ไขไฟล์ pom.xml ในไดเรกทอรีของโปรเจ็กต์ แล้วเพิ่มไลบรารีต่อไปนี้

<dependencies>
  <!-- ... existing dependencies ... -->
  <dependency>
    <groupId>com.google.apis</groupId>
    <artifactId>google-api-services-chat</artifactId>
    <version>v1-rev20230905-2.0.0</version>
  </dependency>
  <dependency>
    <groupId>com.google.auth</groupId>
    <artifactId>google-auth-library-oauth2-http</artifactId>
    <version>1.19.0</version>
  </dependency>
  <dependency>
    <groupId>com.google.oauth-client</groupId>
    <artifactId>google-oauth-client-jetty</artifactId>
    <version>1.34.1</version>
  </dependency>
  <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.10.1</version>
  </dependency>
</dependencies>

Python

หากยังไม่ได้ติดตั้งไลบรารีของไคลเอ็นต์ Google สำหรับ Python ให้เรียกใช้คำสั่งต่อไปนี้ในอินเทอร์เฟซบรรทัดคำสั่ง

pip3 install --upgrade google-api-python-client google-auth-oauthlib

Node.js

หากต้องการเพิ่มไลบรารีไคลเอ็นต์ของ Google และไลบรารีอื่นๆ ที่ต้องพึ่งพาลงในโปรเจ็กต์ Node.js ให้เปลี่ยนไปใช้ไดเรกทอรีของโปรเจ็กต์ แล้วเรียกใช้คำสั่งต่อไปนี้ในอินเทอร์เฟซบรรทัดคำสั่ง

npm install "@googleapis/chat" open server-destroy

Apps Script

ตัวอย่างนี้ใช้บริการ Chat ขั้นสูงเพื่อเรียกใช้ Google Chat API วิธีเปิดใช้บริการสําหรับโปรเจ็กต์ Apps Script

  1. คลิกตัดต่อวิดีโอ ทางด้านซ้าย
  2. ทางด้านซ้าย ให้คลิกเพิ่มบริการ ข้างบริการ
  3. เลือก Google Chat API
  4. ในเวอร์ชัน ให้เลือก v1
  5. คลิกเพิ่ม

คุณสามารถใช้ภาษาใดก็ได้ที่ไลบรารีไคลเอ็นต์ของเรารองรับ

ขั้นตอนที่ 4: เขียนสคริปต์ที่เรียกใช้ Chat API

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

  1. แอปจะนําผู้ใช้ไปยังหน้าการให้สิทธิ์เพื่อขอสิทธิ์เข้าถึงข้อมูลผู้ใช้ที่ระบุโดยขอบเขตการให้สิทธิ์ แอปจะระบุตัวตนด้วยข้อมูลเข้าสู่ระบบรหัสไคลเอ็นต์
  2. ผู้ใช้ตรวจสอบสิทธิ์ที่แอปขอและอนุมัติคำขอ
  3. เซิร์ฟเวอร์การตรวจสอบสิทธิ์ของ Google จะเปลี่ยนเส้นทางเบราว์เซอร์ไปยังปลายทาง HTTP ของแอปพร้อมกับรหัสการให้สิทธิ์
  4. แอปพลิเคชันจะส่งคําขออีกรายการไปยังเซิร์ฟเวอร์การให้สิทธิ์ของ Google เพื่อแลกรหัสการให้สิทธิ์เป็นโทเค็นการเข้าถึง
  5. แอปพลิเคชันใช้โทเค็นการเข้าถึงเพื่อเรียก API ในนามของผู้ใช้

ดูข้อมูลเพิ่มเติมเกี่ยวกับกระบวนการให้สิทธิ์ OAuth ได้ที่คู่มือการใช้ OAuth 2.0 เพื่อเข้าถึง Google API

ตัวอย่างโค้ดต่อไปนี้ใน Java, Python และ Node.js ใช้ไลบรารีของไคลเอ็นต์เพื่อดำเนินการตามขั้นตอนการให้สิทธิ์ OAuth โดยจะเปิดเซิร์ฟเวอร์ HTTP ในเครื่องเพื่อรับรหัสการให้สิทธิ์จากเซิร์ฟเวอร์การให้สิทธิ์ จากนั้นจึงแลกเปลี่ยนรหัสดังกล่าวเป็นโทเค็นการเข้าถึง ในตัวอย่างโค้ด Apps Script ขั้นตอนการให้สิทธิ์นี้จะดำเนินการโดย Apps Script

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

Java

  1. เปิดไฟล์ในไดเรกทอรีของโปรเจ็กต์ src/main/java/com/google/chat/app/authsample/App.java

  2. แทนที่เนื้อหาใน App.java ด้วยโค้ดต่อไปนี้

    package com.google.chat.app.authsample;

import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.extensions.java6.auth.oauth2.AuthorizationCodeInstalledApp;
import com.google.api.client.extensions.jetty.auth.oauth2.LocalServerReceiver;
import com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeFlow;
import com.google.api.client.googleapis.auth.oauth2.GoogleClientSecrets;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.client.util.store.FileDataStoreFactory;
import com.google.api.services.chat.v1.HangoutsChat;
import com.google.api.services.chat.v1.model.Space;

import java.io.InputStreamReader;
import java.util.Collection;
import java.util.Collections;

/**
 * Authenticates with Chat API via user credentials, then creates a Chat space.
 */
public class App {
    // Application OAuth credentials.
    private static final String KEYS_RESOURCE_URI = "/client_secrets.json";

    // Define your app's authorization scopes.
    private static final Collection<String> SCOPES =
        Collections.singleton("https://www.googleapis.com/auth/chat.spaces.create");

    // Directory to store user credentials.
    private static final java.io.File DATA_STORE_DIR =
        new java.io.File(System.getProperty("user.home"), ".store/auth-sample-app");

    // Global instance of the JSON factory.
    private static final JsonFactory JSON_FACTORY = GsonFactory.getDefaultInstance();

    // Global instance of the HTTP transport.
    private static HttpTransport httpTransport;

    // Global instance of the DataStoreFactory. The best practice is to make it a single
    // globally shared instance across your application.
    private static FileDataStoreFactory dataStoreFactory;

    public static void main( String[] args ) {
        try {
            // Run app.
            httpTransport = GoogleNetHttpTransport.newTrustedTransport();
            dataStoreFactory = new FileDataStoreFactory(DATA_STORE_DIR);
            Credential userCredential = authorize();
            Space response = App.createChatSpace(userCredential);
            // Print details about the created space.
            System.out.println(response);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * Authorizes the installed application to access user's protected data.
     */
    private static Credential authorize() throws Exception {
        // Load client secrets.
        GoogleClientSecrets clientSecrets = GoogleClientSecrets.load(JSON_FACTORY,
            new InputStreamReader(App.class.getResourceAsStream("/client_secrets.json")));
        // Set up authorization code flow.
        GoogleAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow.Builder(
            httpTransport, JSON_FACTORY, clientSecrets, SCOPES)
            .setDataStoreFactory(dataStoreFactory)
            .build();
        // Authorize.
        return new AuthorizationCodeInstalledApp(flow, new LocalServerReceiver()).authorize("user");
    }

    /**
     * Creates a Chat space.
     */
    private static Space createChatSpace(Credential userCredential) throws Exception {
        // Build the Chat API client and authenticate with the user account.
        HangoutsChat chatService = new HangoutsChat.Builder(
            httpTransport, JSON_FACTORY, userCredential)
            .setApplicationName("auth-sample-app")
            .build();

        // Create a Chat space.
        Space space = new Space()
            // To create a named space, set spaceType to SPACE.
            .setSpaceType("SPACE")
            // The user-visible name of the space.
            .setDisplayName("API-made");
        return chatService.spaces().create(space).execute();
    }
}

  3. สร้างไดเรกทอรีย่อยใหม่ชื่อ resources ภายในไดเรกทอรีของโปรเจ็กต์

  4. คัดลอกไฟล์ client_secrets.json ไปยังไดเรกทอรีย่อย resources

  5. หากต้องการกำหนดค่า Maven ให้รวมไฟล์รหัสลับไคลเอ็นต์ไว้ในแพ็กเกจโปรเจ็กต์ ให้แก้ไขไฟล์ pom.xml ในไดเรกทอรีของโปรเจ็กต์ แล้วเพิ่มการกําหนดค่าต่อไปนี้ลงในส่วน <build>

    <build>
  <!-- ... existing configurations ... -->
  <resources>
    <resource>
      <directory>resources</directory>
    </resource>
  </resources>
</build>

  6. หากต้องการกำหนดค่า Maven ให้รวมข้อกำหนดไว้ในแพ็กเกจโปรเจ็กต์และเพื่อเรียกใช้คลาสหลักของแอปพลิเคชัน ให้แก้ไขไฟล์ pom.xml ในไดเรกทอรีของโปรเจ็กต์ แล้วเพิ่มการกําหนดค่าต่อไปนี้ลงในส่วน <plugins>

    <plugins>
  <!-- ... existing configurations ... -->
  <plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <configuration>
      <archive>
        <manifest>
          <mainClass>com.google.chat.app.authsample.App</mainClass>
        </manifest>
      </archive>
      <descriptorRefs>
        <descriptorRef>jar-with-dependencies</descriptorRef>
      </descriptorRefs>
    </configuration>
  </plugin>
</plugins>

Python

  1. บันทึกโค้ดต่อไปนี้ในไฟล์ชื่อ chat_space_create_named.py ในไดเรกทอรีเดียวกับที่มี client_secrets.json

    from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build

# Define your app's authorization scopes.
# When modifying these scopes, delete the file token.json, if it exists.
SCOPES = ["https://www.googleapis.com/auth/chat.spaces.create"]

def main():
  '''
  Authenticates with Chat API via user credentials,
  then creates a Chat space.
  '''

  flow = InstalledAppFlow.from_client_secrets_file(
                    'client_secrets.json', SCOPES)
  creds = flow.run_local_server()

  # Build a service endpoint for Chat API.
  service = build('chat', 'v1', credentials=creds)

  # Use the service endpoint to call Chat API.
  result = service.spaces().create(

    # Details about the space to create.
    body = {

      # To create a named space, set spaceType to SPACE.
      'spaceType': 'SPACE',

      # The user-visible name of the space.
      'displayName': 'API-made'

    }

  ).execute()

  # Prints details about the created space.
  print(result)

if __name__ == '__main__':
  main()

Node.js

  1. บันทึกโค้ดต่อไปนี้ในไฟล์ชื่อ chat_space_create_named.js ในไดเรกทอรีเดียวกับที่มีโปรเจ็กต์ Node.js และ client_secrets.json

    const fs = require('fs');
const path = require('path');
const http = require('http');
const url = require('url');
const destroyer = require('server-destroy');

const chat = require('@googleapis/chat');

// Application OAuth credentials.
const keys = require('./client_secrets.json').installed;

// Define your app's authorization scopes.
// When modifying these scopes, delete the file token.json, if it exists.
const scopes = ["https://www.googleapis.com/auth/chat.spaces.create"];

// Create a new OAuth2 client with the configured keys.
const oauth2Client = new chat.auth.OAuth2(
  keys.client_id,
  keys.client_secret,
  'http://localhost:3000'
);

/**
 * Opens an HTTP server to accept the OAuth callback.
 * In this simple example, the only request to our webserver is to /?code=<code>.
 */
async function authenticate(scopes) {
  const opn = (await import('open')).default;

  return new Promise((resolve, reject) => {
    // Generate the URL for authorization.
    const authorizeUrl = oauth2Client.generateAuthUrl({
      access_type: 'offline',
      scope: scopes.join(' '),
    });
    // Start the HTTP server to listen for the callback.
    const server = http
      .createServer(async (req, res) => {
        try {
          const qs = new url.URL(req.url, 'http://localhost:3000').searchParams;
          res.end('Authentication successful! Please return to the console.');
          server.destroy();
          const { tokens } = await oauth2Client.getToken(qs.get('code'));
          oauth2Client.credentials = tokens;
          resolve(oauth2Client);
        } catch (e) {
          reject(e);
        }
      })
      .listen(3000, () => {
        // Open the browser to the authorize URL to start the workflow.
        opn(authorizeUrl, { wait: false }).then(cp => cp.unref());
      });
    destroyer(server);
  });
}

/**
 * Authenticates with Chat API via user credentials, then creates a Chat space.
 */
async function createSpace() {
  // Create the Chat API client and authenticate with the authorized user.
  const chatClient = await chat.chat({
    version: 'v1',
    auth: oauth2Client
  });

  // Call the Chat API to create a space.
  const result = await chatClient.spaces.create({

    // Details about the space to create.
    requestBody: {

      // To create a named space, set spaceType to SPACE.
      'spaceType': 'SPACE',

      // The user-visible name of the space.
      'displayName': 'API-made'

    }

  });
  return result;
}

// Authenticate the user, execute the function,
// then print details about the created space.
authenticate(scopes)
  .then(createSpace)
  .then(console.log);

Apps Script

  1. ในเครื่องมือแก้ไข Apps Script ให้แก้ไขไฟล์ appsscript.json และเพิ่มขอบเขต OAuth ที่จําเป็นในการเรียก API

      "oauthScopes": [
    "https://www.googleapis.com/auth/chat.spaces.create"
  ]

  2. บันทึกโค้ดต่อไปนี้ในไฟล์ชื่อ ChatSpaceCreateNamed.gs ในโปรเจ็กต์ Apps Script

    /**
 * Authenticates with Chat API via user credentials, then creates a
 * Chat space.
 */
function createSpace() {
  try {
    // Details about the space to create.
    // To create a named space, set spaceType to SPACE.
    // The user-visible name of the space is displayName.
    const space = {'displayName': 'API-made', 'spaceType': 'SPACE'};

    // Call Chat API with user credentials to create the space.
    const result = Chat.Spaces.create(space);

    // Log details about the created space.
    console.log(result);
  } catch (err) {
    // TODO (developer) - Handle exception
    console.log('Failed to create space with error %s', err.message);
  }
}

ขั้นตอนที่ 5: เรียกใช้สคริปต์ตัวอย่าง

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

Java

mvn compile assembly:single
java -jar target/auth-sample-app-1.0-SNAPSHOT-jar-with-dependencies.jar

Python

python3 chat_space_create_named.py

Node.js

node chat_space_create_named.js

Apps Script

เปิดไฟล์ ChatSpaceCreateNamed.gs ในเครื่องมือแก้ไข Apps Script แล้วคลิกเรียกใช้

เบราว์เซอร์จะเปิดขึ้นและแจ้งให้คุณลงชื่อเข้าใช้บัญชี Google

การลงชื่อเข้าใช้เพื่อให้สิทธิ์แอป Chat

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

หลังจากลงชื่อเข้าใช้แล้ว หน้าจอขอความยินยอม OAuth จะปรากฏขึ้นและขอให้คุณให้สิทธิ์แก่แอป

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

แก้ปัญหาตัวอย่าง

เมื่อเรียกใช้ chat_space_create_named.py คุณอาจได้รับข้อผิดพลาดที่ระบุว่า

Expected a JSON object with a single property for a "web" or "installed" application

ข้อความแสดงข้อผิดพลาดนี้หมายความว่าไฟล์ client_secrets.json ที่คุณดาวน์โหลดจากคอนโซล Google Cloud ไม่ได้ขึ้นต้นด้วยพร็อพเพอร์ตี้ "web" หรือ "installed" หลังจากตรวจสอบสิทธิ์ด้วยไฟล์ที่ดาวน์โหลดมา หากโค้ดไม่ได้บันทึกโทเค็นการเข้าถึงในไฟล์ใหม่ เช่น token.json ระบบจะเขียนโทเค็นการเข้าถึงลงใน client_secrets.json ซึ่งอาจทำให้เกิดข้อผิดพลาดนี้ระหว่างพยายามให้สิทธิ์ในภายหลัง

หากต้องการแก้ไขข้อผิดพลาด ให้ดาวน์โหลดไฟล์คีย์ไคลเอ็นต์จากคอนโซล Google Cloud อีกครั้ง แล้วบันทึกไฟล์ใหม่แทนไฟล์ปัจจุบัน

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

  • ดูสิ่งที่ Chat API ทำได้เพิ่มเติมโดยอ่านเอกสารอ้างอิงเกี่ยวกับ Chat API