Gestire gli accessi ripetuti

Questa è la terza procedura dettagliata della serie di procedure dettagliate sui componenti aggiuntivi di Classroom.

In questa procedura dettagliata, devi gestire le visite ripetute al nostro componente aggiuntivo recuperando automaticamente le credenziali concesse in precedenza a un utente. Puoi quindi indirizzare gli utenti a pagine da cui possono emettere immediatamente richieste API. Si tratta di un comportamento obbligatorio per i componenti aggiuntivi di Classroom.

Nel corso di questa procedura dettagliata, eseguirai le seguenti operazioni:

  • Implementa l'archiviazione permanente per le nostre credenziali utente.
  • Recupera e valuta i seguenti parametri di query dei componenti aggiuntivi:
    • login_hint: l'ID Google dell'utente che ha eseguito l'accesso.
    • hd: il dominio dell'utente che ha eseguito l'accesso.

Tieni presente che ne viene inviato solo uno. L'API Classroom invia il parametro hd se l'utente NON ha ANCORA autorizzato la tua app. In caso contrario, l'API invia login_hint. L'elenco completo dei parametri di query è disponibile nella pagina della guida agli iframe.

Al termine, puoi autorizzare completamente gli utenti nella tua app web ed emettere chiamate alle API di Google.

Informazioni sui parametri di query degli iframe

Classroom carica l'URI di configurazione dell'allegato del componente aggiuntivo all'apertura. Classroom aggiunge diversi parametri di query GET all'URI, che contengono informazioni contestuali utili. Se, ad esempio, l'URI di rilevamento degli allegati è https://example.com/addon, Classroom crea l'iframe con l'URL di origine impostato su https://example.com/addon?courseId=XXX&postId=YYY&addOnToken=ZZZ, dove XXX, YYY e ZZZ sono ID stringa. Per una descrizione dettagliata di questo scenario, consulta la guida agli iframe.

Esistono cinque possibili parametri di query per l'URL di rilevamento:

  • courseId: l'ID del corso di Classroom corrente.
  • postId: l'ID del post del compito che l'utente sta modificando o creando.
  • addOnToken: un token utilizzato per autorizzare determinate azioni dei componenti aggiuntivi di Classroom.
  • login_hint: l'ID Google dell'utente corrente.
  • hd: il dominio host dell'utente corrente, ad esempio example.com.

Questa procedura dettagliata riguarda hd e login_hint. Il routing degli utenti viene eseguito in base a qualsiasi parametro di query fornito: al flusso di autorizzazione (se hd) o alla pagina di rilevamento del componente aggiuntivo (se login_hint).

Accedere ai parametri di query

Come descritto sopra, i parametri di query vengono passati all'applicazione web nella stringa URI. Archivia questi valori nella sessione; vengono utilizzati nel flusso di autorizzazione e per archiviare e recuperare informazioni sull'utente. Questi parametri di query vengono trasmessi solo alla prima apertura del componente aggiuntivo.

Python

Accedi alle definizioni dei percorsi Flask (routes.py se stai seguendo l'esempio fornito). Nella parte superiore della route di destinazione del componente aggiuntivo (/classroom-addon nell'esempio fornito), recupera e memorizza i parametri di query login_hint e hd:

# Retrieve the login_hint and hd query parameters.
login_hint = flask.request.args.get("login_hint")
hd = flask.request.args.get("hd")

Assicurati che login_hint e hd siano archiviati nella sessione. Questo è uno spazio appropriato in cui archiviare questi valori; sono temporanei e riceverai nuovi valori all'apertura del componente aggiuntivo.

# It's possible that we might return to this route later, in which case the
# parameters will not be passed in. Instead, use the values cached in the
# session.

# If neither query parameter is available, use the values in the session.
if login_hint is None and hd is None:
    login_hint = flask.session.get("login_hint")
    hd = flask.session.get("hd")

# If there's no login_hint query parameter, then check for hd.
# Send the user to the sign in page.
elif hd is not None:
    flask.session["hd"] = hd
    return start_auth_flow()

# If the login_hint query parameter is available, we'll store it in the
# session.
else:
    flask.session["login_hint"] = login_hint

Java

Accedi alla route di destinazione del componente aggiuntivo nella tua classe del controller (/addon-discovery in AuthController.java nell'esempio fornito). All'inizio di questa route, recupera e archivia i parametri di query login_hint e hd.

/** Retrieve the login_hint or hd query parameters from the request URL. */
String login_hint = request.getParameter("login_hint");
String hd = request.getParameter("hd");

Assicurati che login_hint e hd siano archiviati nella sessione. Questo è uno spazio appropriato in cui archiviare questi valori; sono temporanei e riceverai nuovi valori all'apertura del componente aggiuntivo.

/** If neither query parameter is sent, use the values in the session. */
if (login_hint == null && hd == null) {
    login_hint = (String) session.getAttribute("login_hint");
    hd = (String) session.getAttribute("hd");
}

/** If the hd query parameter is provided, add hd to the session and route
*   the user to the authorization page. */
else if (hd != null) {
    session.setAttribute("hd", hd);
    return startAuthFlow(model);
}

/** If the login_hint query parameter is provided, add it to the session. */
else if (login_hint != null) {
    session.setAttribute("login_hint", login_hint);
}

Aggiungere i parametri di query al flusso di autorizzazione

I parametri login_hint e hd devono essere trasmessi anche ai server di autenticazione di Google. Questi facilitano il processo di autenticazione; se la tua applicazione sa quale utente sta tentando di eseguire l'autenticazione, il server utilizza il suggerimento per semplificare il flusso di accesso precompilando il campo dell'email nel modulo di accesso.

Python

Accedi alla route di autorizzazione nel file del server Flask (/authorize nell'esempio fornito). Aggiungi gli argomenti login_hint e hd alla chiamata a flow.authorization_url.

authorization_url, state = flow.authorization_url(
    # Enable offline access so that you can refresh an access token without
    # re-prompting the user for permission. Recommended for web server apps.
    access_type="offline",
    # Enable incremental authorization. Recommended as a best practice.
    include_granted_scopes="true",
    # The user will automatically be selected if we have the login_hint.
    login_hint=flask.session.get("login_hint"),
    # If we don't have login_hint, passing hd will reduce the list of
    # accounts in the account chooser to only those with the same domain.
    hd=flask.session.get("hd"))

Java

Vai al metodo authorize() nella classe AuthService.java. Aggiungi login_hint e hd come parametri al metodo, poi aggiungi gli argomenti login_hint e hd allo strumento di creazione URL di autorizzazione.

String authUrl = flow
    .newAuthorizationUrl()
    .setState(state)
    .set("login_hint", login_hint)
    .set("hd", hd)
    .setRedirectUri(REDIRECT_URI)
    .build();

Aggiungi spazio di archiviazione permanente per le credenziali utente

Se ricevi login_hint come parametro di query quando viene caricato il componente aggiuntivo, significa che l'utente ha già completato il flusso di autorizzazione per la nostra applicazione. Dovresti recuperare le credenziali precedenti anziché obbligarli ad accedere di nuovo.

Ricorda di aver ricevuto un token di aggiornamento al completamento della procedura di autorizzazione. Salva questo token, che può essere riutilizzato per ottenere un token di accesso, che è di breve durata e necessario per l'utilizzo delle API di Google. In precedenza hai salvato queste credenziali nella sessione, ma devi memorizzarle per gestire le visite ripetute.

Definisci lo schema utente e configura il database

Configura uno schema di database per un User.

Python

Definisci lo schema utente

Un User contiene i seguenti attributi:

  • id: l'ID Google dell'utente. Deve corrispondere ai valori forniti nel parametro di query login_hint.
  • display_name: nome e cognome dell'utente, ad esempio "Alex Smith".
  • email: l'indirizzo email dell'utente.
  • portrait_url: l'URL dell'immagine del profilo dell'utente.
  • refresh_token: il token di aggiornamento acquisito in precedenza.

Questo esempio implementa l'archiviazione utilizzando SQLite, supportato in modo nativo da Python. Utilizza il modulo flask_sqlalchemy per facilitare la gestione del database.

Configura il database

Innanzitutto, specifica un percorso del file per il nostro database. Vai al file di configurazione del server (config.py nell'esempio fornito) e aggiungi quanto segue.

import os

# Point to a database file in the project root.
DATABASE_FILE_NAME = os.path.join(
    os.path.abspath(os.path.dirname(__file__)), 'data.sqlite')

class Config(object):
    SQLALCHEMY_DATABASE_URI = f"sqlite:///{DATABASE_FILE_NAME}"
    SQLALCHEMY_TRACK_MODIFICATIONS = False

In questo modo Flask rimanda al file data.sqlite nella stessa directory del file main.py.

Passa quindi alla directory del modulo e crea un nuovo file models.py. webapp/models.py se stai seguendo l'esempio fornito. Aggiungi quanto segue al nuovo file per definire la tabella User, sostituendo il nome del modulo con webapp, se diverso.

from webapp import db

# Database model to represent a user.
class User(db.Model):
    # The user's identifying information:
    id = db.Column(db.String(120), primary_key=True)
    display_name = db.Column(db.String(80))
    email = db.Column(db.String(120), unique=True)
    portrait_url = db.Column(db.Text())

    # The user's refresh token, which will be used to obtain an access token.
    # Note that refresh tokens will become invalid if:
    # - The refresh token has not been used for six months.
    # - The user revokes your app's access permissions.
    # - The user changes passwords.
    # - The user belongs to a Google Cloud organization
    #   that has session control policies in effect.
    refresh_token = db.Column(db.Text())

Infine, nel file __init__.py del modulo, aggiungi quanto segue per importare i nuovi modelli e creare il database.

from webapp import models
from os import path
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy(app)

# Initialize the database file if not created.
if not path.exists(config.DATABASE_FILE_NAME):
    db.create_all()

Java

Definisci lo schema utente

Un User contiene i seguenti attributi:

  • id: l'ID Google dell'utente. Deve corrispondere al valore fornito nel parametro di query login_hint.
  • email: l'indirizzo email dell'utente.

Crea un file schema.sql nella directory resources del modulo. Spring legge questo file e genera di conseguenza uno schema per il database. Definisci la tabella con un nome tabella (users) e le colonne per rappresentare gli attributi User, id e email.

CREATE TABLE IF NOT EXISTS users (
    id VARCHAR(255) PRIMARY KEY, -- user's unique Google ID
    email VARCHAR(255), -- user's email address
);

Crea una classe Java per definire il modello User per il database. User.java nell'esempio fornito.

Aggiungi l'annotazione @Entity per indicare che si tratta di un POJO che può essere salvato nel database. Aggiungi l'annotazione @Table con il nome della tabella corrispondente che hai configurato in schema.sql.

Tieni presente che l'esempio di codice include i costruttori e i setter per i due attributi. Il costruttore e i setter vengono utilizzati in AuthController.java per creare o aggiornare un utente nel database. Puoi anche includere getter e un metodo toString come meglio credi, ma per questa procedura dettagliata specifica, questi metodi non vengono utilizzati e vengono omessi dall'esempio di codice in questa pagina per brevità.

/** An entity class that provides a model to store user information. */
@Entity
@Table(name = "users")
public class User {
    /** The user's unique Google ID. The @Id annotation specifies that this
     *   is the primary key. */
    @Id
    @Column
    private String id;

    /** The user's email address. */
    @Column
    private String email;

    /** Required User class no args constructor. */
    public User() {
    }

    /** The User class constructor that creates a User object with the
    *   specified parameters.
    *   @param id the user's unique Google ID
    *   @param email the user's email address
    */
    public User(String id, String email) {
        this.id = id;
        this.email = email;
    }

    public void setId(String id) { this.id = id; }

    public void setEmail(String email) { this.email = email; }
}

Crea un'interfaccia denominata UserRepository.java per gestire le operazioni CRUD nel database. Questa interfaccia estende l'interfaccia di CrudRepository.

/** Provides CRUD operations for the User class by extending the
 *   CrudRepository interface. */
@Repository
public interface UserRepository extends CrudRepository<User, String> {
}

La classe controller facilita la comunicazione tra il client e il repository. Di conseguenza, aggiorna il costruttore della classe del controller per inserire la classe UserRepository.

/** Declare UserRepository to be used in the Controller class constructor. */
private final UserRepository userRepository;

/**
*   ...
*   @param userRepository the class that interacts with User objects stored in
*   persistent storage.
*/
public AuthController(AuthService authService, UserRepository userRepository) {
    this.authService = authService;
    this.userRepository = userRepository;
}

Configura il database

Per archiviare le informazioni relative agli utenti, utilizza un database H2 intrinsecamente supportato in Spring Boot. Questo database viene utilizzato anche in procedure dettagliate successive per archiviare altre informazioni relative a Classroom. La configurazione del database H2 richiede l'aggiunta della configurazione seguente a application.properties.

# Enable configuration for persistent storage using an H2 database
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.url=jdbc:h2:file:./h2/userdb
spring.datasource.username=<USERNAME>
spring.datasource.password=<PASSWORD>
spring.jpa.hibernate.ddl-auto=update
spring.jpa.open-in-view=false

La configurazione spring.datasource.url crea una directory denominata h2, in cui è archiviato il file userdb. Aggiungi il percorso al database H2 a .gitignore. Devi aggiornare spring.datasource.username e spring.datasource.password prima di eseguire l'applicazione per impostare il database con un nome utente e una password di tua scelta. Per aggiornare il nome utente e la password del database dopo l'esecuzione dell'applicazione, elimina la directory h2 generata, aggiorna la configurazione ed esegui di nuovo l'applicazione.

L'impostazione della configurazione di spring.jpa.hibernate.ddl-auto su update garantisce che i dati archiviati nel database vengano conservati al riavvio dell'applicazione. Per cancellare il database a ogni riavvio dell'applicazione, imposta questa configurazione su create.

Imposta la configurazione di spring.jpa.open-in-view su false. Questa configurazione è abilitata per impostazione predefinita e risulta noto per causare problemi di prestazioni difficili da diagnosticare in produzione.

Come descritto in precedenza, devi essere in grado di recuperare le credenziali di un utente ricorrente. Ciò è facilitato dal supporto dell'archivio credenziali integrato offerto da GoogleAuthorizationCodeFlow.

Nella classe AuthService.java, definisci un percorso al file in cui è archiviata la classe delle credenziali. In questo esempio, il file viene creato nella directory /credentialStore. Aggiungi il percorso dell'archivio credenziali a .gitignore. Questa directory viene generata all'avvio del flusso di autorizzazione da parte dell'utente.

private static final File dataDirectory = new File("credentialStore");

Quindi, nel file AuthService.java crea un metodo che crei e restituisca un oggetto FileDataStoreFactory. Questo è il datastore in cui sono archiviate le credenziali.

/** Creates and returns FileDataStoreFactory object to store credentials.
 *   @return FileDataStoreFactory dataStore used to save and obtain users ids
 *   mapped to Credentials.
 *   @throws IOException if creating the dataStore is unsuccessful.
 */
public FileDataStoreFactory getCredentialDataStore() throws IOException {
    FileDataStoreFactory dataStore = new FileDataStoreFactory(dataDirectory);
    return dataStore;
}

Aggiorna il metodo getFlow() in AuthService.java per includere setDataStoreFactory nel metodo GoogleAuthorizationCodeFlow Builder() e chiama getCredentialDataStore() per impostare il datastore.

GoogleAuthorizationCodeFlow authorizationCodeFlow =
    new GoogleAuthorizationCodeFlow.Builder(
        HTTP_TRANSPORT,
        JSON_FACTORY,
        getClientSecrets(),
        getScopes())
    .setAccessType("offline")
    .setDataStoreFactory(getCredentialDataStore())
    .build();

Quindi, aggiorna il metodo getAndSaveCredentials(String authorizationCode). In precedenza, questo metodo ottiene le credenziali senza archiviarle da nessuna parte. Aggiorna il metodo per archiviare le credenziali nel datastore indicizzate dallo User-ID.

Lo User-ID può essere ottenuto dall'oggetto TokenResponse utilizzando id_token, ma deve essere prima verificato. In caso contrario, le applicazioni client potrebbero essere in grado di impersonare gli utenti inviando al server ID utente modificati. Ti consigliamo di utilizzare le librerie client dell'API di Google per convalidare id_token. Per ulteriori informazioni, visita la [pagina di Google Identity sulla verifica del token ID Google].

// Obtaining the id_token will help determine which user signed in to the application.
String idTokenString = tokenResponse.get("id_token").toString();

// Validate the id_token using the GoogleIdTokenVerifier object.
GoogleIdTokenVerifier googleIdTokenVerifier = new GoogleIdTokenVerifier.Builder(
        HTTP_TRANSPORT,
        JSON_FACTORY)
    .setAudience(Collections.singletonList(
        googleClientSecrets.getWeb().getClientId()))
    .build();

GoogleIdToken idToken = googleIdTokenVerifier.verify(idTokenString);

if (idToken == null) {
    throw new Exception("Invalid ID token.");
}

Una volta verificato id_token, ottieni userId da archiviare insieme alle credenziali ottenute.

// Obtain the user id from the id_token.
Payload payload = idToken.getPayload();
String userId = payload.getSubject();

Aggiorna la chiamata a flow.createAndStoreCredential per includere userId.

// Save the user id and credentials to the configured FileDataStoreFactory.
Credential credential = flow.createAndStoreCredential(tokenResponse, userId);

Aggiungi alla classe AuthService.java un metodo che restituisca le credenziali di un utente specifico, se esiste nel datastore.

/** Find credentials in the datastore based on a specific user id.
*   @param userId key to find in the file datastore.
*   @return Credential object to be returned if a matching key is found in the datastore. Null if
*   the key doesn't exist.
*   @throws Exception if building flow object or checking for userId key is unsuccessful. */
public Credential loadFromCredentialDataStore(String userId) throws Exception {
    try {
        GoogleAuthorizationCodeFlow flow = getFlow();
        Credential credential = flow.loadCredential(userId);
        return credential;
    } catch (Exception e) {
        e.printStackTrace();
        throw e;
    }
}

Recupera le credenziali

Definisci un metodo per il recupero di Users. Nel parametro di query login_hint ti viene fornito un valore id, che puoi utilizzare per recuperare un record dell'utente specifico.

Python

def get_credentials_from_storage(id):
    """
    Retrieves credentials from the storage and returns them as a dictionary.
    """
    return User.query.get(id)

Java

Nella classe AuthController.java, definisci un metodo per recuperare un utente dal database in base al suo ID utente.

/** Retrieves stored credentials based on the user id.
*   @param id the id of the current user
*   @return User the database entry corresponding to the current user or null
*   if the user doesn't exist in the database.
*/
public User getUser(String id) {
    if (id != null) {
        Optional<User> user = userRepository.findById(id);
        if (user.isPresent()) {
            return user.get();
        }
    }
    return null;
}

Archivia credenziali

Esistono due scenari per l'archiviazione delle credenziali. Se id dell'utente è già presente nel database, aggiorna il record esistente con eventuali nuovi valori. Altrimenti, crea un nuovo record User e aggiungilo al database.

Python

Per prima cosa, definisci un metodo di utilità che implementa il comportamento di archiviazione o aggiornamento.

def save_user_credentials(credentials=None, user_info=None):
    """
    Updates or adds a User to the database. A new user is added only if both
    credentials and user_info are provided.

    Args:
        credentials: An optional Credentials object.
        user_info: An optional dict containing user info returned by the
            OAuth 2.0 API.
    """

    existing_user = get_credentials_from_storage(
        flask.session.get("login_hint"))

    if existing_user:
        if user_info:
            existing_user.id = user_info.get("id")
            existing_user.display_name = user_info.get("name")
            existing_user.email = user_info.get("email")
            existing_user.portrait_url = user_info.get("picture")

        if credentials and credentials.refresh_token is not None:
            existing_user.refresh_token = credentials.refresh_token

    elif credentials and user_info:
        new_user = User(id=user_info.get("id"),
                        display_name=user_info.get("name"),
                        email=user_info.get("email"),
                        portrait_url=user_info.get("picture"),
                        refresh_token=credentials.refresh_token)

        db.session.add(new_user)

    db.session.commit()

Esistono due istanze in cui puoi salvare le credenziali nel tuo database: quando l'utente torna alla tua applicazione al termine del flusso di autorizzazione e quando emette una chiamata API. Qui abbiamo impostato in precedenza la chiave della sessione credentials.

Chiama save_user_credentials alla fine del tuo percorso con callback. Conserva l'oggetto user_info anziché estrarre solo il nome dell'utente.

# The flow is complete! We'll use the credentials to fetch the user's info.
user_info_service = googleapiclient.discovery.build(
    serviceName="oauth2", version="v2", credentials=credentials)

user_info = user_info_service.userinfo().get().execute()

flask.session["username"] = user_info.get("name")

save_user_credentials(credentials, user_info)

Devi anche aggiornare le credenziali dopo le chiamate all'API. In questo caso, puoi fornire le credenziali aggiornate come argomenti per il metodo save_user_credentials.

# Save credentials in case access token was refreshed.
flask.session["credentials"] = credentials_to_dict(credentials)
save_user_credentials(credentials)

Java

Innanzitutto, definisci un metodo che archivi o aggiorni un oggetto User nel database H2.

/** Adds or updates a user in the database.
*   @param credential the credentials object to save or update in the database.
*   @param userinfo the userinfo object to save or update in the database.
*   @param session the current session.
*/
public void saveUser(Credential credential, Userinfo userinfo, HttpSession session) {
    User storedUser = null;
    if (session != null && session.getAttribute("login_hint") != null) {
        storedUser = getUser(session.getAttribute("login_hint").toString());
    }

    if (storedUser != null) {
        if (userinfo != null) {
            storedUser.setId(userinfo.getId());
            storedUser.setEmail(userinfo.getEmail());
        }
        userRepository.save(storedUser);
    } else if (credential != null && userinfo != null) {
        User newUser = new User(
            userinfo.getId(),
            userinfo.getEmail(),
        );
        userRepository.save(newUser);
    }
}

Esistono due istanze in cui puoi salvare le credenziali nel tuo database: quando l'utente torna alla tua applicazione al termine del flusso di autorizzazione e quando emette una chiamata API. Qui abbiamo impostato in precedenza la chiave della sessione credentials.

Chiama saveUser alla fine del percorso /callback. Dovresti conservare l'oggetto user_info anziché estrarre solo l'email dell'utente.

/** This is the end of the auth flow. We should save user info to the database. */
Userinfo userinfo = authService.getUserInfo(credentials);
saveUser(credentials, userinfo, session);

Devi anche aggiornare le credenziali dopo le chiamate all'API. In questo caso, puoi fornire le credenziali aggiornate come argomenti per il metodo saveUser.

/** Save credentials in case access token was refreshed. */
saveUser(credentials, null, session);

Credenziali scadute

Tieni presente che i token di aggiornamento potrebbero non essere più validi per diversi motivi. Questi includono:

  • Il token di aggiornamento non viene utilizzato da sei mesi.
  • L'utente revoca le autorizzazioni di accesso alla tua app.
  • L'utente cambia le password.
  • L'utente appartiene a un'organizzazione Google Cloud in cui sono applicati criteri di controllo della sessione.

Acquisisci nuovi token inviando nuovamente l'utente tramite il flusso di autorizzazione se le sue credenziali non sono più valide.

Indirizza automaticamente l'utente

Modificare la route di destinazione del componente aggiuntivo per rilevare se l'utente ha precedentemente autorizzato la nostra applicazione. In tal caso, indirizzali alla nostra pagina principale del componente aggiuntivo. In caso contrario, chiedigli di accedere.

Python

Assicurati che il file di database sia stato creato all'avvio dell'applicazione. Inserisci quanto segue in un inizializzatore di modulo (come webapp/__init__.py nell'esempio fornito) o nel metodo principale che avvia il server.

# Initialize the database file if not created.
if not os.path.exists(DATABASE_FILE_NAME):
    db.create_all()

Il metodo dovrebbe quindi gestire i parametri di query login_hint e hd come spiegato sopra. Quindi carica le credenziali del negozio se si tratta di un visitatore abituale. Sai che si tratta di un visitatore abituale se hai ricevuto login_hint. Recupera le credenziali archiviate per questo utente e caricale nella sessione.

stored_credentials = get_credentials_from_storage(login_hint)

# If we have stored credentials, store them in the session.
if stored_credentials:
    # Load the client secrets file contents.
    client_secrets_dict = json.load(
        open(CLIENT_SECRETS_FILE)).get("web")

    # Update the credentials in the session.
    if not flask.session.get("credentials"):
        flask.session["credentials"] = {}

    flask.session["credentials"] = {
        "token": stored_credentials.access_token,
        "refresh_token": stored_credentials.refresh_token,
        "token_uri": client_secrets_dict["token_uri"],
        "client_id": client_secrets_dict["client_id"],
        "client_secret": client_secrets_dict["client_secret"],
        "scopes": SCOPES
    }

    # Set the username in the session.
    flask.session["username"] = stored_credentials.display_name

Infine, indirizza l'utente alla pagina di accesso se non disponiamo delle sue credenziali. In caso affermativo, indirizzali alla pagina principale del componente aggiuntivo.

if "credentials" not in flask.session or \
    flask.session["credentials"]["refresh_token"] is None:
    return flask.render_template("authorization.html")

return flask.render_template(
    "addon-discovery.html",
    message="You've reached the addon discovery page.")

Java

Accedi al percorso di destinazione del componente aggiuntivo (/addon-discovery nell'esempio fornito). Come spiegato sopra, è qui che hai gestito i parametri di query login_hint e hd.

Innanzitutto, controlla se nella sessione esistono credenziali. In caso contrario, instrada l'utente tramite il flusso di autenticazione chiamando il metodo startAuthFlow.

/** Check if the credentials exist in the session. The session could have
 *   been cleared when the user clicked the Sign-Out button, and the expected
 *   behavior after sign-out would be to display the sign-in page when the
 *   iframe is opened again. */
if (session.getAttribute("credentials") == null) {
    return startAuthFlow(model);
}

Quindi, carica l'utente dal database H2 se si tratta di un visitatore abituale. Se ricevi il parametro di ricerca login_hint, si tratta di un visitatore abituale. Se l'utente esiste nel database H2, carica le credenziali dal datastore credenziali configurato in precedenza e imposta le credenziali nella sessione. Se le credenziali non sono state ottenute dal datastore delle credenziali, instrada l'utente attraverso il flusso di autenticazione chiamando startAuthFlow.

/** At this point, we know that credentials exist in the session, but we
 *   should update the session credentials with the credentials in persistent
 *   storage in case they were refreshed. If the credentials in persistent
 *   storage are null, we should navigate the user to the authorization flow
 *   to obtain persisted credentials. */

User storedUser = getUser(login_hint);

if (storedUser != null) {
    Credential credential = authService.loadFromCredentialDataStore(login_hint);
    if (credential != null) {
        session.setAttribute("credentials", credential);
    } else {
        return startAuthFlow(model);
    }
}

Infine, indirizza l'utente alla pagina di destinazione del componente aggiuntivo.

/** Finally, if there are credentials in the session and in persistent
 *   storage, direct the user to the addon-discovery page. */
return "addon-discovery";

Testa il componente aggiuntivo

Accedi a Google Classroom come utente di test Insegnante. Vai alla scheda Lavori del corso e crea un nuovo Compito. Fai clic sul pulsante Componenti aggiuntivi sotto l'area di testo, quindi seleziona il componente aggiuntivo. L'iframe si apre e il componente aggiuntivo carica l'URI di configurazione dell'allegato che hai specificato nella pagina Configurazione app dell'SDK GWM.

Complimenti! Puoi procedere con il passaggio successivo: creazione di allegati e identificazione del ruolo dell'utente.