Ta strona została przetłumaczona przez Cloud Translation API.

Skorzystaj z krótkiego wprowadzenia

Krótkie wprowadzenia wyjaśniają, jak skonfigurować i uruchomić aplikację, która wywołuje interfejs Google Workspace API.

Krótkie wprowadzenia do Google Workspace wykorzystują biblioteki klienta interfejsu API do obsługi niektórych szczegółów procesu uwierzytelniania i autoryzacji. Na potrzeby własnych aplikacji zalecamy używanie bibliotek klienta. W tym krótkim wprowadzeniu używamy uproszczonej metody uwierzytelniania, która jest odpowiednia dla środowiska testowego. W przypadku środowiska produkcyjnego zalecamy zapoznanie się z uwierzytelnianiem i autoryzacją przed wybraniem danych logowania odpowiednich dla aplikacji.

Utworzyć aplikację wiersza poleceń Go wysyłającą żądania do interfejsu Google Apps Script API.

Cele

skonfigurować środowisko,
Skonfiguruj fragment.
Uruchom próbkę.

Wymagania wstępne

Najnowsza wersja Go.
Najnowsza wersja Git.
Projekt Google Cloud.

konto Google z włączonym Dyskiem Google,

Konfigurowanie środowiska

Aby wykonać to krótkie wprowadzenie, skonfiguruj środowisko.

Włącz API

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

W konsoli Google Cloud włącz interfejs Google Apps Script API.

Włączanie interfejsu API

Konfigurowanie ekranu zgody OAuth

Jeżeli do wykonania tego krótkiego wprowadzenia używasz nowego projektu Google Cloud, skonfiguruj ekran zgody OAuth i dodaj siebie jako użytkownika testowego. Jeśli masz już za sobą ten krok w swoim projekcie Cloud, przejdź do następnej sekcji.

W konsoli Google Cloud otwórz Menu > Interfejsy API i usługi > Ekran akceptacji OAuth.
Otwórz ekran zgody OAuth
W polu Typ użytkownika wybierz Wewnętrzny i kliknij Utwórz.
Wypełnij formularz rejestracji aplikacji, a następnie kliknij Zapisz i kontynuuj.
Na razie możesz pominąć dodawanie zakresów i kliknąć Zapisz i kontynuuj. Gdy w przyszłości będziesz tworzyć aplikację do użytku poza organizacją Google Workspace, musisz zmienić Typ użytkownika na Zewnętrzny, a następnie dodać zakresy autoryzacji wymagane przez Twoją aplikację.
Przejrzyj podsumowanie rejestracji aplikacji. Aby wprowadzić zmiany, kliknij Edytuj. Jeśli rejestracja aplikacji wygląda na prawidłową, kliknij Back to Dashboard (Powrót do panelu).

Autoryzacja danych logowania dla aplikacji komputerowej

Aby uwierzytelnić użytkowników i uzyskać dostęp do ich danych 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 wielu platformach, musisz utworzyć osobny identyfikator klienta dla każdej z nich.

W konsoli Google Cloud kliknij Menu > Interfejsy API i usługi > Dane logowania.
Otwórz stronę Dane logowania
Kliknij Utwórz dane logowania > Identyfikator klienta OAuth.
Kliknij Typ aplikacji > Aplikacja komputerowa.
W polu Nazwa wpisz nazwę danych logowania. Ta nazwa jest widoczna tylko w konsoli Google Cloud.
Kliknij Utwórz. Pojawi się ekran utworzony przez klienta OAuth zawierający nowy identyfikator i tajny klucz klienta.
Kliknij OK. Nowo utworzone dane logowania pojawią się w sekcji Identyfikatory klienta OAuth 2.0.
Zapisz pobrany plik JSON jako credentials.json i przenieś go do katalogu roboczego.

Przygotowywanie obszaru roboczego

Utwórz katalog roboczy:
```
mkdir quickstart
```
Przejdź do katalogu roboczego:
```
cd quickstart
```
Zainicjuj nowy moduł:
```
go mod init quickstart
```

Pobierz bibliotekę klienta Google Apps Script API w Go i pakiet OAuth2.0:

go get google.golang.org/api/script/v1
go get golang.org/x/oauth2/google

Konfigurowanie fragmentu

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

Wklej ten kod w pliku:

apps_script/quickstart/quickstart.go

Wyświetl w GitHubie

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"

	"golang.org/x/oauth2"
	"golang.org/x/oauth2/google"
	"google.golang.org/api/option"
	"google.golang.org/api/script/v1"
)

// 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)
}

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, "https://www.googleapis.com/auth/script.projects")
	if err != nil {
		log.Fatalf("Unable to parse client secret file to config: %v", err)
	}
	client := getClient(config)

	srv, err := script.NewService(ctx, option.WithHTTPClient(client))
	if err != nil {
		log.Fatalf("Unable to retrieve Script client: %v", err)
	}

	req := script.CreateProjectRequest{Title: "My Script"}
	createRes, err := srv.Projects.Create(&req).Do()
	if err != nil {
		// The API encountered a problem.
		log.Fatalf("The API returned an error: %v", err)
	}
	content := &script.Content{
		ScriptId: createRes.ScriptId,
		Files: []*script.File{{
			Name:   "hello",
			Type:   "SERVER_JS",
			Source: "function helloWorld() {\n  console.log('Hello, world!');}",
		}, {
			Name: "appsscript",
			Type: "JSON",
			Source: "{\"timeZone\":\"America/New_York\",\"exceptionLogging\":" +
				"\"CLOUD\"}",
		}},
	}
	updateContentRes, err := srv.Projects.UpdateContent(createRes.ScriptId,
		content).Do()
	if err != nil {
		// The API encountered a problem.
		log.Fatalf("The API returned an error: %v", err)
	}
	log.Printf("https://script.google.com/d/%v/edit", updateContentRes.ScriptId)
}

Uruchamianie przykładowego

W katalogu roboczym skompiluj i uruchom przykład:
```
go run quickstart.go
```

Przy pierwszym uruchomieniu przykładu wyświetli się prośba o autoryzację dostępu:
1. Jeśli wyświetli się prośba, zaloguj się na konto Google. Jeśli w danym momencie korzystasz z wielu kont, wybierz jedno, którego chcesz używać do autoryzacji.
2. Kliknij Accept (Zaakceptuj).
Aplikacja w języku Go uruchamia i wywołuje interfejs Google Apps Script 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ę.