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

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

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

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

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

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

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

  • บัญชี Google

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

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

เปิดใช้ API

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

    เปิดใช้ API

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

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

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

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

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

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

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

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

  2. คลิกสร้างข้อมูลเข้าสู่ระบบ > รหัสไคลเอ็นต์ OAuth
  3. คลิกประเภทแอปพลิเคชัน > แอปบนเดสก์ท็อป
  4. ในช่องชื่อ ให้พิมพ์ชื่อของข้อมูลเข้าสู่ระบบ ชื่อนี้จะแสดงในคอนโซล Google Cloud เท่านั้น
  5. คลิกสร้าง หน้าจอที่สร้างของไคลเอ็นต์ OAuth จะปรากฏขึ้นเพื่อแสดงรหัสไคลเอ็นต์และรหัสลับไคลเอ็นต์ใหม่
  6. คลิกตกลง ข้อมูลเข้าสู่ระบบที่สร้างขึ้นใหม่จะปรากฏในส่วนรหัสไคลเอ็นต์ OAuth 2.0
  7. บันทึกไฟล์ 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
    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
    
  1. ครั้งแรกที่เรียกใช้ตัวอย่าง ระบบจะแสดงข้อความแจ้งให้คุณให้สิทธิ์เข้าถึง
    1. หากยังไม่ได้ลงชื่อเข้าใช้บัญชี Google ให้ลงชื่อเข้าใช้เมื่อได้รับข้อความแจ้ง หากคุณลงชื่อเข้าใช้หลายบัญชี ให้เลือก 1 บัญชีที่จะใช้ในการให้สิทธิ์
    2. คลิกยอมรับ

    แอปพลิเคชัน Go จะเรียกใช้และเรียกใช้ Google Drive Activity API

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

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