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

บทแนะนำแบบย่อจะอธิบายวิธีตั้งค่าและเรียกใช้แอปที่เรียกใช้ Google Workspace API

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

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

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

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

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

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

• บัญชี Google

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

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

เปิดใช้ API

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

• เปิดใช้ Google Drive Activity API ในคอนโซล Google Cloud

  เปิดใช้ API

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

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

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

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

2. หากกําหนดค่า แล้ว คุณจะกําหนดการตั้งค่าหน้าจอขอความยินยอม OAuth ต่อไปนี้ได้ในการสร้างแบรนด์ กลุ่มเป้าหมาย และการเข้าถึงข้อมูล หากเห็นข้อความว่า not configured yet ให้คลิกเริ่มต้นใช้งาน
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 ให้ไปที่เมนู > > ไคลเอ็นต์

   ไปที่ลูกค้า

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 ให้ลงชื่อเข้าใช้เมื่อได้รับข้อความแจ้ง หากคุณลงชื่อเข้าใช้หลายบัญชี ให้เลือกบัญชีเดียวที่จะใช้สำหรับการให้สิทธิ์
   2. คลิกยอมรับ

   แอปพลิเคชัน Go ของคุณจะทํางานและเรียกใช้ Google Drive Activity API

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

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

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