Questa pagina è stata tradotta dall'API Cloud Translation.

Guida rapida di Go

Le guide rapide spiegano come configurare ed eseguire un'app che chiama un'API Google Workspace.

Le guide rapide di Google Workspace utilizzano le librerie client API per gestire alcuni dettagli del flusso di autenticazione e autorizzazione. Ti consigliamo di utilizzare le librerie client per le tue app. Questa guida rapida utilizza un approccio di autenticazione semplificato, appropriato per un ambiente di test. Per un ambiente di produzione, consigliamo di consultare l'autenticazione e l'autorizzazione prima di scegliere le credenziali di accesso appropriate per la tua app.

Creare un'applicazione a riga di comando Go che invia richieste all'API Google Apps Script.

Obiettivi

Configurare l'ambiente.
Configura il Sample.
Esegui l'esempio.

Prerequisiti

La versione più recente di Go.
La versione più recente di Git.
Un progetto Google Cloud.

Un Account Google con Google Drive attivato.

Configura l'ambiente

Per completare questa guida rapida, configura il tuo ambiente.

Abilita l'API

Prima di utilizzare le API di Google, devi attivarle in un progetto Google Cloud. Puoi attivare una o più API in un singolo progetto Google Cloud.

Nella console Google Cloud, abilita l'API Google Apps Script.

Abilita l'API

Configurare la schermata per il consenso OAuth

Se utilizzi un nuovo progetto Google Cloud per completare questa guida rapida, configura la schermata per il consenso OAuth e aggiungiti come utente di test. Se hai già completato questo passaggio per il tuo progetto Cloud, passa alla sezione successiva.

Nella console Google Cloud, vai a Menu > API e servizi > Schermata consenso OAuth.
Vai alla schermata per il consenso OAuth
In Tipo di utente, seleziona Interno, quindi fai clic su Crea.
Compila il modulo di registrazione dell'app, quindi fai clic su Salva e continua.
Per ora, puoi saltare l'aggiunta di ambiti e fare clic su Salva e continua. In futuro, quando creerai un'app da utilizzare al di fuori della tua organizzazione Google Workspace, dovrai cambiare il Tipo di utente in Esterno e poi aggiungere gli ambiti di autorizzazione richiesti dall'app.
Esamina il riepilogo della registrazione dell'app. Per apportare modifiche, fai clic su Modifica. Se la registrazione dell'app è a posto, fai clic su Torna alla dashboard.

Autorizzare le credenziali per un'applicazione desktop

Per autenticare gli utenti finali e accedere ai dati utente nella tua app, devi creare uno o più ID client OAuth 2.0. L'ID client viene utilizzato per identificare una singola app nei server OAuth di Google. Se l'app viene eseguita su più piattaforme, devi creare un ID client separato per ogni piattaforma.

Nella console Google Cloud, vai a Menu > API e servizi > Credenziali.
Vai a credenziali
Fai clic su Crea credenziali > ID client OAuth.
Fai clic su Tipo di applicazione > App desktop.
Nel campo Nome, digita un nome per la credenziale. Questo nome viene visualizzato solo nella console Google Cloud.
Fai clic su Crea. Viene visualizzata la schermata di creazione del client OAuth, che mostra il nuovo ID client e il nuovo client secret.
Fai clic su Ok. Le credenziali appena create vengono visualizzate nella sezione ID client OAuth 2.0.
Salva il file JSON scaricato come credentials.json e spostalo nella directory di lavoro.

Prepara l'area di lavoro

Crea una directory di lavoro:
```
mkdir quickstart
```
Passa alla directory di lavoro:
```
cd quickstart
```
Inizializza il nuovo modulo:
```
go mod init quickstart
```
Scarica la libreria client Go e il pacchetto OAuth2.0 dell'API Google Apps Script:
```
go get google.golang.org/api/script/v1
go get golang.org/x/oauth2/google
```

Configura l'esempio

Nella directory di lavoro, crea un file denominato quickstart.go.

Incolla il codice seguente nel file:

apps_script/quickstart/quickstart.go

Visualizza su GitHub

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

Esegui l'esempio

Nella directory di lavoro, crea ed esegui l'esempio:
```
go run quickstart.go
```

La prima volta che esegui l'esempio, ti viene chiesto di autorizzare l'accesso:
1. Se non hai ancora eseguito l'accesso al tuo Account Google, esegui l'accesso quando ti viene richiesto. Se hai eseguito l'accesso a più account, selezionane uno da utilizzare per l'autorizzazione.
2. Fai clic su Accept (accetta).
L'applicazione Go esegue e chiama l'API Google Apps Script.

Le informazioni sull'autorizzazione vengono archiviate nel file system, quindi la prossima volta che esegui il codice campione non ti verrà chiesta l'autorizzazione.