Krótkie wprowadzenie

utworzyć aplikację wiersza poleceń w Go, która wysyła żądania do interfejsu Google Drive Activity API.

Przewodniki Szybki start wyjaśniają, jak skonfigurować i uruchomić aplikację, która wywołuje interfejs API Google Workspace. W tym krótkim wprowadzeniu użyjemy uproszczonego podejścia do uwierzytelniania, które jest odpowiednie w środowisku testowym. W przypadku środowiska produkcyjnego zalecamy zapoznanie się z informacjami o uwierzytelnianiu i autoryzacji przed wybraniem danych logowania odpowiednich dla Twojej aplikacji.

W tym przewodniku Szybki start używane są zalecane biblioteki klienta interfejsu API Google Workspace, które obsługują niektóre szczegóły procesu uwierzytelniania i autoryzacji.

Cele

• skonfigurować środowisko,
• Skonfiguruj próbkę.
• Uruchom przykład.

Wymagania wstępne

• Najnowsza wersja Go.
• Najnowsza wersja Gita.
• Projekt Google Cloud.

• konto Google.

Konfigurowanie środowiska

Aby ukończyć ten przewodnik, skonfiguruj środowisko.

Włącz API

Zanim zaczniesz korzystać z interfejsów Google API, musisz je włączyć w projekcie Google Cloud. W jednym projekcie Google Cloud możesz włączyć co najmniej 1 interfejs API.

• W Google Cloud Console włącz interfejs Google Drive Activity API.

  Włączanie interfejsu API

Konfigurowanie ekranu zgody OAuth

Jeśli do wykonania zadań z tego krótkiego wprowadzenia posłużył Ci nowy projekt Google Cloud, skonfiguruj ekran akceptacji OAuth. Jeśli ten krok został już wykonany w przypadku Twojego projektu w Cloud, przejdź do następnej sekcji.

1. W konsoli Google Cloud otwórz Menu  > Google Auth platform > Branding.

   Otwórz Promowanie marki

2. Jeśli masz już skonfigurowany Google Auth platform, możesz skonfigurować te ustawienia ekranu zgody OAuth w sekcjach Branding, Odbiorcy i Dostęp do danych. Jeśli zobaczysz komunikat Google Auth platform Jeszcze nie skonfigurowano, kliknij Rozpocznij:
1. W sekcji Informacje o aplikacji w polu Nazwa aplikacji wpisz nazwę aplikacji.
2. W sekcji Adres e-mail pomocy dla użytkowników wybierz adres e-mail, na który użytkownicy mogą pisać, jeśli mają pytania dotyczące ich zgody.
3. Kliknij Dalej.
4. W sekcji Odbiorcy wybierz Wewnętrzny.
5. Kliknij Dalej.
6. W sekcji Dane kontaktowe wpisz adres e-mail, na który będziesz otrzymywać powiadomienia o wszelkich zmianach w projekcie.
7. Kliknij Dalej.
8. W sekcji Zakończ zapoznaj się z zasadami dotyczącymi danych użytkownika w usługach interfejsów API Google i jeśli się z nimi zgadzasz, kliknij Akceptuję zasady dotyczące danych użytkownika w usługach interfejsów API Google.
9. Kliknij Dalej.
10. Kliknij Utwórz.
3. Na razie możesz pominąć dodawanie zakresów. W przyszłości, gdy będziesz tworzyć aplikację do użytku poza organizacją Google Workspace, musisz zmienić Typ użytkownika na Zewnętrzny. Następnie dodaj zakresy autoryzacji wymagane przez aplikację. Więcej informacji znajdziesz w pełnym przewodniku Konfigurowanie zgody OAuth.

Autoryzowanie danych logowania w aplikacji na komputer

Aby uwierzytelniać użytkowników i uzyskiwać dostęp do danych użytkowników w aplikacji, musisz utworzyć co najmniej 1 identyfikator klienta OAuth 2.0. Identyfikator klienta wskazuje konkretną aplikację na serwerach OAuth Google. Jeśli Twoja aplikacja działa na kilku platformach, musisz utworzyć osobny identyfikator klienta dla każdej z nich.

1. W konsoli Google Cloud otwórz Menu  > Google Auth platform > Klienci.

   Otwórz stronę Klienci

2. Kliknij Utwórz klienta.
3. Kliknij Typ aplikacji > Aplikacja na komputer.
4. W polu Nazwa wpisz nazwę danych logowania. Ta nazwa jest widoczna tylko w konsoli Google Cloud.
5. Kliknij Utwórz.

   Nowo utworzone dane logowania pojawią się w sekcji „Identyfikatory klientów OAuth 2.0”.

6. Zapisz pobrany plik JSON jako credentials.json i przenieś go do katalogu roboczego.

Przygotowywanie obszaru roboczego

1. Utwórz katalog roboczy:

   mkdir quickstart
   

2. Przejdź do katalogu roboczego:

   cd quickstart
   

3. Zainicjuj nowy moduł:

   go mod init quickstart
   

4. Pobierz bibliotekę klienta interfejsu Google Drive Activity API dla języka Go i pakiet OAuth2.0:

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

Konfigurowanie próbki

1. W katalogu roboczym utwórz plik o nazwie quickstart.go.

2. Wklej do pliku ten kod:

   drive/activity-v2/quickstart/quickstart.go

   Wyświetl w GitHubie
   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.")
   	}
   }

Uruchamianie przykładu

1. W katalogu roboczym skompiluj i uruchom przykład:

   go run quickstart.go
   

2. Przy pierwszym uruchomieniu przykładu pojawi się prośba o autoryzację dostępu:
   1. Jeśli nie zalogowano się na konto Google, pojawi się prośba o zalogowanie. Jeśli logujesz się na wiele kont, wybierz jedno z nich, aby użyć go do autoryzacji.
   2. Kliknij Akceptuję.

   Aplikacja w Go działa i wywołuje interfejs Google Drive Activity API.

   Informacje o autoryzacji są przechowywane w systemie plików, więc przy następnym uruchomieniu przykładowego kodu nie pojawi się prośba o autoryzację.

Dalsze kroki

• Wypróbuj interfejsy Google Workspace API w narzędziu API Explorer
  • Rozwiązywanie problemów z uwierzytelnianiem i autoryzacją
  • Dokumentacja interfejsu Drive Activity API
  • sekcji google-api-go-client GitHub.