ดูการเริ่มต้นอย่างรวดเร็ว

สร้างแอปพลิเคชันบรรทัดคำสั่ง Go ที่ส่งคำขอไปยัง Google Drive Activity API

Quickstart อธิบายวิธีตั้งค่าและเรียกใช้แอปที่เรียกใช้ Google Workspace API การเริ่มต้นอย่างรวดเร็วนี้ใช้วิธีการตรวจสอบสิทธิ์แบบง่ายที่เหมาะกับสภาพแวดล้อมการทดสอบ สําหรับสภาพแวดล้อมการใช้งานจริง เราขอแนะนําให้ศึกษาเกี่ยวกับ การตรวจสอบสิทธิ์และการให้สิทธิ์ ก่อน เลือกข้อมูลเข้าถึง ที่เหมาะสมกับแอปของคุณ

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

วัตถุประสงค์

• ตั้งค่าสภาพแวดล้อม
• ตั้งค่าตัวอย่าง
• เรียกใช้ตัวอย่าง

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

• Go เวอร์ชันล่าสุด
• Git เวอร์ชันล่าสุด
• โปรเจ็กต์ Google Cloud

• บัญชี Google

ตั้งค่าสภาพแวดล้อม

ตั้งค่าสภาพแวดล้อมเพื่อทำ Quickstart นี้ให้เสร็จสมบูรณ์

เปิดใช้ API

ก่อนใช้ Google API คุณต้องเปิดใช้ API ในโปรเจ็กต์ Google Cloud คุณเปิด API อย่างน้อย 1 รายการในโปรเจ็กต์ Google Cloud เดียวได้

• ในคอนโซล Google Cloud ให้เปิดใช้ Google ไดรฟ์ Activity API

  เปิดใช้ API

กำหนดค่าหน้าจอขอความยินยอม OAuth

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

1. ในคอนโซล Google Cloud ให้ไปที่เมนู > Google Auth platform > การสร้างแบรนด์

   ไปที่การสร้างแบรนด์

2. หากกำหนดค่า Google Auth platformแล้ว คุณจะกำหนดค่าการตั้งค่าหน้าจอขอความยินยอม OAuth ต่อไปนี้ได้ในการสร้างแบรนด์ กลุ่มเป้าหมาย และการเข้าถึงข้อมูล หากเห็นข้อความที่ระบุว่าGoogle Auth platform ยังไม่ได้กำหนดค่า ให้คลิกเริ่มต้นใช้งาน
1. ในส่วนข้อมูลแอป ให้ป้อนชื่อแอปในชื่อแอป
2. ในอีเมลสนับสนุนสำหรับผู้ใช้ ให้เลือกอีเมลสนับสนุนที่ผู้ใช้สามารถติดต่อคุณได้หากมีข้อสงสัยเกี่ยวกับการยินยอม
3. คลิกถัดไป
4. เลือกภายในในส่วนผู้ชม
5. คลิกถัดไป
6. ในส่วนข้อมูลติดต่อ ให้ป้อนอีเมลที่คุณต้องการรับการแจ้งเตือนเกี่ยวกับการเปลี่ยนแปลงในโปรเจ็กต์
7. คลิกถัดไป
8. ในส่วนเสร็จสิ้น ให้อ่านนโยบายข้อมูลผู้ใช้ของบริการ Google API และหากยอมรับ ให้เลือกฉันยอมรับนโยบายข้อมูลผู้ใช้ของบริการ Google API
9. คลิกต่อไป
10. คลิกสร้าง
3. ในตอนนี้ คุณข้ามการเพิ่มขอบเขตได้ ในอนาคต เมื่อสร้างแอปเพื่อใช้ภายนอกองค์กร Google Workspace คุณจะต้องเปลี่ยนประเภทผู้ใช้เป็นภายนอก จากนั้น เพิ่มขอบเขตการให้สิทธิ์ที่แอปของคุณต้องการ ดูข้อมูลเพิ่มเติมได้ที่คู่มือกำหนดค่าความยินยอม OAuth ฉบับเต็ม

ให้สิทธิ์ข้อมูลเข้าสู่ระบบสำหรับแอปพลิเคชันบนเดสก์ท็อป

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

1. ในคอนโซล Google Cloud ให้ไปที่เมนู > Google Auth platform > ไคลเอ็นต์

   ไปที่ลูกค้า

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

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

6. บันทึกไฟล์ JSON ที่ดาวน์โหลดเป็น credentials.json แล้วย้ายไฟล์ ไปยังไดเรกทอรีการทำงาน

เตรียมพื้นที่ทำงาน

1. สร้างไดเรกทอรีการทำงาน

   mkdir quickstart
   

2. เปลี่ยนเป็นไดเรกทอรีที่ใช้งานอยู่

   cd quickstart
   

3. เริ่มต้นโมดูลใหม่

   go mod init quickstart
   

4. รับไลบรารีของไคลเอ็นต์ Google Drive Activity API สำหรับ Go และแพ็กเกจ OAuth2.0 โดยทำดังนี้

   go get google.golang.org/api/driveactivity/v2
   go get golang.org/x/oauth2/google
   

ตั้งค่าตัวอย่าง

1. สร้างไฟล์ชื่อ quickstart.go ในไดเรกทอรีการทำงาน

2. วางโค้ดต่อไปนี้ในไฟล์

   drive/activity-v2/quickstart/quickstart.go

   ดูใน GitHub
   package main
   
   import (
   	"context"
   	"encoding/json"
   	"fmt"
   	"log"
   	"net/http"
   	"os"
   	"reflect"
   	"strings"
   
   	"golang.org/x/oauth2"
   	"golang.org/x/oauth2/google"
   	"google.golang.org/api/driveactivity/v2"
   	"google.golang.org/api/option"
   )
   
   // Retrieve a token, saves the token, then returns the generated client.
   func getClient(config *oauth2.Config) *http.Client {
   	// The file token.json stores the user's access and refresh tokens, and is
   	// created automatically when the authorization flow completes for the first
   	// time.
   	tokFile := "token.json"
   	tok, err := tokenFromFile(tokFile)
   	if err != nil {
   		tok = getTokenFromWeb(config)
   		saveToken(tokFile, tok)
   	}
   	return config.Client(context.Background(), tok)
   }
   
   // Request a token from the web, then returns the retrieved token.
   func getTokenFromWeb(config *oauth2.Config) *oauth2.Token {
   	authURL := config.AuthCodeURL("state-token", oauth2.AccessTypeOffline)
   	fmt.Printf("Go to the following link in your browser then type the "+
   		"authorization code: \n%v\n", authURL)
   
   	var authCode string
   	if _, err := fmt.Scan(&authCode); err != nil {
   		log.Fatalf("Unable to read authorization code: %v", err)
   	}
   
   	tok, err := config.Exchange(context.TODO(), authCode)
   	if err != nil {
   		log.Fatalf("Unable to retrieve token from web: %v", err)
   	}
   	return tok
   }
   
   // Retrieves a token from a local file.
   func tokenFromFile(file string) (*oauth2.Token, error) {
   	f, err := os.Open(file)
   	if err != nil {
   		return nil, err
   	}
   	defer f.Close()
   	tok := &oauth2.Token{}
   	err = json.NewDecoder(f).Decode(tok)
   	return tok, err
   }
   
   // Saves a token to a file path.
   func saveToken(path string, token *oauth2.Token) {
   	fmt.Printf("Saving credential file to: %s\n", path)
   	f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
   	if err != nil {
   		log.Fatalf("Unable to cache oauth token: %v", err)
   	}
   	defer f.Close()
   	json.NewEncoder(f).Encode(token)
   }
   
   // Returns a string representation of the first elements in a list.
   func truncated(array []string) string {
   	return truncatedTo(array, 2)
   }
   
   // Returns a string representation of the first elements in a list.
   func truncatedTo(array []string, limit int) string {
   	var contents string
   	var more string
   	if len(array) <= limit {
   		contents = strings.Join(array, ", ")
   		more = ""
   	} else {
   		contents = strings.Join(array[0:limit], ", ")
   		more = ", ..."
   	}
   	return fmt.Sprintf("[%s%s]", contents, more)
   }
   
   // Returns the name of a set property in an object, or else "unknown".
   func getOneOf(m interface{}) string {
   	v := reflect.ValueOf(m)
   	for i := 0; i < v.NumField(); i++ {
   		if !v.Field(i).IsNil() {
   			return v.Type().Field(i).Name
   		}
   	}
   	return "unknown"
   }
   
   // Returns a time associated with an activity.
   func getTimeInfo(activity *driveactivity.DriveActivity) string {
   	if activity.Timestamp != "" {
   		return activity.Timestamp
   	}
   	if activity.TimeRange != nil {
   		return activity.TimeRange.EndTime
   	}
   	return "unknown"
   }
   
   // Returns the type of action.
   func getActionInfo(action *driveactivity.ActionDetail) string {
   	return getOneOf(*action)
   }
   
   // Returns user information, or the type of user if not a known user.
   func getUserInfo(user *driveactivity.User) string {
   	if user.KnownUser != nil {
   		if user.KnownUser.IsCurrentUser {
   			return "people/me"
   		}
   		return user.KnownUser.PersonName
   	}
   	return getOneOf(*user)
   }
   
   // Returns actor information, or the type of actor if not a user.
   func getActorInfo(actor *driveactivity.Actor) string {
   	if actor.User != nil {
   		return getUserInfo(actor.User)
   	}
   	return getOneOf(*actor)
   }
   
   // Returns information for a list of actors.
   func getActorsInfo(actors []*driveactivity.Actor) []string {
   	actorsInfo := make([]string, len(actors))
   	for i := range actors {
   		actorsInfo[i] = getActorInfo(actors[i])
   	}
   	return actorsInfo
   }
   
   // Returns the type of a target and an associated title.
   func getTargetInfo(target *driveactivity.Target) string {
   	if target.DriveItem != nil {
   		return fmt.Sprintf("driveItem:\"%s\"", target.DriveItem.Title)
   	}
   	if target.Drive != nil {
   		return fmt.Sprintf("drive:\"%s\"", target.Drive.Title)
   	}
   	if target.FileComment != nil {
   		parent := target.FileComment.Parent
   		if parent != nil {
   			return fmt.Sprintf("fileComment:\"%s\"", parent.Title)
   		}
   		return "fileComment:unknown"
   	}
   	return getOneOf(*target)
   }
   
   // Returns information for a list of targets.
   func getTargetsInfo(targets []*driveactivity.Target) []string {
   	targetsInfo := make([]string, len(targets))
   	for i := range targets {
   		targetsInfo[i] = getTargetInfo(targets[i])
   	}
   	return targetsInfo
   }
   
   func main() {
   	ctx := context.Background()
   	b, err := os.ReadFile("credentials.json")
   	if err != nil {
   		log.Fatalf("Unable to read client secret file: %v", err)
   	}
   
   	// If modifying these scopes, delete your previously saved token.json.
   	config, err := google.ConfigFromJSON(b, driveactivity.DriveActivityReadonlyScope)
   	if err != nil {
   		log.Fatalf("Unable to parse client secret file to config: %v", err)
   	}
   	client := getClient(config)
   
   	srv, err := driveactivity.NewService(ctx, option.WithHTTPClient(client))
   	if err != nil {
   		log.Fatalf("Unable to retrieve driveactivity Client %v", err)
   	}
   
   	q := driveactivity.QueryDriveActivityRequest{PageSize: 10}
   	r, err := srv.Activity.Query(&q).Do()
   	if err != nil {
   		log.Fatalf("Unable to retrieve list of activities. %v", err)
   	}
   
   	fmt.Println("Recent Activity:")
   	if len(r.Activities) > 0 {
   		for _, a := range r.Activities {
   			time := getTimeInfo(a)
   			action := getActionInfo(a.PrimaryActionDetail)
   			actors := getActorsInfo(a.Actors)
   			targets := getTargetsInfo(a.Targets)
   			fmt.Printf("%s: %s, %s, %s\n", time, truncated(actors), action, truncated(targets))
   		}
   	} else {
   		fmt.Print("No activity.")
   	}
   }

เรียกใช้ตัวอย่าง

1. ในไดเรกทอรีการทำงาน ให้สร้างและเรียกใช้ตัวอย่างโดยทำดังนี้

   go run quickstart.go
   

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

   แอปพลิเคชัน Go ของคุณจะเรียกใช้ Google ไดรฟ์ Activity API

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

ขั้นตอนถัดไป

• ลองใช้ Google Workspace API ในโปรแกรมสำรวจ API
  • แก้ปัญหาการตรวจสอบสิทธิ์และการให้สิทธิ์
  • เอกสารประกอบอ้างอิงของ Drive Activity API
  • google-api-go-client ของ GitHub