Questa è la terza procedura dettagliata per i componenti aggiuntivi di Classroom di una serie di procedure dettagliate.
In questa procedura dettagliata, gestirai le visite ripetute al nostro componente aggiuntivo recuperare le credenziali concesse in precedenza a un utente. Quindi, indirizzi gli utenti a pagine da cui possono emettere immediatamente richieste API. Questo è un campo obbligatorio comportamento degli utenti per i componenti aggiuntivi di Classroom.
Nel corso di questa procedura dettagliata, completerai quanto segue:
- Implementa l'archiviazione permanente per le nostre credenziali utente.
- Recupera e valuta il parametro di query del componente aggiuntivo
login_hint
. Si tratta di un ID Google univoco dell'utente che ha eseguito l'accesso.
Al termine, puoi autorizzare completamente gli utenti nella tua applicazione web ed emettere chiamate a API di Google.
Informazioni sui parametri di query dell'iframe
Classroom carica l'URI di configurazione dell'allegato del componente aggiuntivo in
apertura in corso. Classe
aggiunge diversi parametri di query GET
all'URI; contengono informazioni
informazioni contestuali. Se, ad esempio, l'URI di rilevamento dell'allegato è
https://example.com/addon
, Classroom crea l'iframe con
l'URL di origine impostato
https://example.com/addon?courseId=XXX&itemId=YYY&itemType=courseWork&addOnToken=ZZZ
,
dove XXX
, YYY
e ZZZ
sono ID stringa. Consulta la guida agli iframe per un
una descrizione dettagliata di questo scenario.
Esistono cinque possibili parametri di query per l'URL di rilevamento:
courseId
: l'ID dell'attuale corso di Classroom.itemId
: l'ID dell'elemento dello streaming che l'utente sta modificando o creando.itemType
: il tipo di elemento dello stream che l'utente sta creando o modificando, uno deicourseWork
,courseWorkMaterial
oannouncement
.addOnToken
: un token utilizzato per autorizzare determinati Azioni del componente aggiuntivo di Classroom.login_hint
: l'ID Google dell'utente corrente.
Questa procedura dettagliata riguarda login_hint
. L'indirizzamento degli utenti avviene a seconda che
parametro di query al flusso di autorizzazione, se mancante, oppure
pagina di rilevamento del componente aggiuntivo, se presente.
Accedere ai parametri di query
I parametri di query vengono passati all'applicazione web nella stringa URI. Negozio questi valori nella sessione; utilizzate nel flusso di autorizzazione archiviare e recuperare informazioni sull'utente. Questi parametri di query vengono utilizzati e passare alla prima apertura del componente aggiuntivo.
Python
Vai alle definizioni delle route Flask (routes.py
se
seguendo l'esempio fornito). Nella parte superiore del percorso di destinazione del componente aggiuntivo
(/classroom-addon
nell'esempio fornito), recupera e memorizza
Parametro di query login_hint
:
# If the login_hint query parameter is available, we'll store it in the session.
if flask.request.args.get("login_hint"):
flask.session["login_hint"] = flask.request.args.get("login_hint")
Assicurati che login_hint
(se presente) sia archiviato nella sessione. Si tratta di un
luogo appropriato in cui archiviare questi valori; sono temporanee e puoi prevedere
nuovi valori quando il componente aggiuntivo viene aperto.
# 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.
login_hint = flask.session.get("login_hint")
# If there's still no login_hint query parameter, this must be their first
# time signing in, so send the user to the sign in page.
if login_hint is None:
return start_auth_flow()
Java
Vai al percorso di destinazione del componente aggiuntivo nella tua classe controller
(/addon-discovery
in AuthController.java
nell'esempio fornito). Alle ore
all'inizio di questa route, recupera e memorizza la query login_hint
.
/** Retrieve the login_hint query parameter from the request URL if present. */
String login_hint = request.getParameter("login_hint");
Assicurati che login_hint
(se presente) sia archiviato nella sessione. Si tratta di un
luogo appropriato in cui archiviare questi valori; sono temporanee e puoi prevedere
nuovi valori quando il componente aggiuntivo viene aperto.
/** If login_hint wasn't sent, use the values in the session. */
if (login_hint == null) {
login_hint = (String) session.getAttribute("login_hint");
}
/** If the there is still no login_hint, route the user to the authorization
* page. */
if (login_hint == null) {
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
Il parametro login_hint
deve essere trasmesso ai server di autenticazione di Google
. Questo facilita il processo di autenticazione; se la tua applicazione sa
l'utente che sta tentando di eseguire l'autenticazione, il server utilizza il suggerimento per semplificare
flusso di accesso precompilando il campo dell'email nel modulo di accesso.
Python
Accedi alla route di autorizzazione nel file del server Flask (/authorize
)
nel nostro esempio fornito). Aggiungi l'argomento login_hint
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"),
Java
Vai al metodo authorize()
nella classe AuthService.java
. Aggiungi
login_hint
come parametro al metodo e aggiungi login_hint
e l'argomento allo Strumento di creazione URL di autorizzazione.
String authUrl = flow
.newAuthorizationUrl()
.setState(state)
.set("login_hint", login_hint)
.setRedirectUri(REDIRECT_URI)
.build();
Aggiungi spazio di archiviazione permanente per le credenziali utente
Se ricevi login_hint
come parametro di query durante il caricamento del componente aggiuntivo,
indicare che l'utente ha già completato il flusso di autorizzazione per il nostro
un'applicazione. Dovresti recuperare le credenziali precedenti anziché forzare
di eseguire di nuovo l'accesso.
Ricorda che hai ricevuto un token di aggiornamento al termine dell'operazione flusso di autorizzazione. Salva questo token; può essere riutilizzato per ottenere un token di accesso di breve durata e necessaria per usare le API di Google. Hai salvato in precedenza le credenziali nella sessione, ma devi archiviarle gestire visite ripetute.
Definisci lo schema Utente e imposta 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 nei Parametro di querylogin_hint
.display_name
: nome e cognome dell'utente, ad esempio "Paolo Rossi".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 lo spazio di archiviazione utilizzando SQLite, supportato in modo nativo
come Python. Utilizza il modulo flask_sqlalchemy
per facilitare il nostro database
gestione dei dispositivi.
configura il database
Innanzitutto, specifica la posizione del file per il nostro database. Accedi al tuo server
di configurazione del deployment (config.py
nell'esempio fornito) e aggiungi
seguire.
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
Questo indirizza Flask al file data.sqlite
nella stessa directory del
main.py
file.
Quindi, vai alla directory del modulo e crea un nuovo file models.py
.
Questo è webapp/models.py
se stai seguendo l'esempio fornito. Aggiungi
quanto segue al nuovo file per definire la tabella User
, sostituendo il tuo
nome del modulo 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 nei Parametro di querylogin_hint
.email
: l'indirizzo email dell'utente.
Crea un file schema.sql
nella directory resources
del modulo. una scena primaverile
legge questo file e genera di conseguenza uno schema per il database.
Definisci la tabella con il nome della tabella, users
e le colonne da 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. Questo è
User.java
nell'esempio fornito.
Aggiungi l'annotazione @Entity
per indicare che si tratta di un POJO che può essere
possono essere salvate 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 sono utilizzati
AuthController.java
per creare o aggiornare un utente nel database. Tu
può includere anche getter e un metodo toString
, a seconda delle tue esigenze, ma per
questa particolare procedura dettagliata, questi metodi non vengono usati e vengono omessi
nell'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
al database. Questa interfaccia estende l'interfaccia 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
repository Git. Aggiorna quindi il costruttore della classe controller per inserire
il corso 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
supportate in Spring Boot. Questo database viene utilizzato anche
procedura dettagliata per archiviare altre applicazioni
informazioni. La configurazione del database H2 richiede l'aggiunta di quanto segue
configurazione in 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, chiamata h2
, con
il file userdb
archiviato al suo interno. Aggiungi il percorso al database H2 in
.gitignore
. Devi aggiornare spring.datasource.username
e
spring.datasource.password
prima di eseguire l'applicazione per impostare
con un nome utente e una password di tua scelta. Per aggiornare
e la password per il database dopo aver eseguito l'applicazione
eliminare la directory h2
generata, aggiornare la configurazione e
eseguire nuovamente l'applicazione.
L'impostazione della configurazione di spring.jpa.hibernate.ddl-auto
su update
garantisce che
e i dati archiviati nel database vengono conservati al riavvio dell'applicazione.
Per cancellare il database ogni volta che l'applicazione viene riavviata, imposta questo
configuro in create
.
Imposta la configurazione di spring.jpa.open-in-view
su false
. Questa configurazione è abilitata
per impostazione predefinita e può causare problemi di prestazioni
difficili da diagnosticare in produzione.
Come descritto in precedenza, devi essere in grado di recuperare le credenziali di un
come utente abituale. Ciò è possibile grazie all'archivio di credenziali integrato
assistenza offerta dal GoogleAuthorizationCodeFlow
.
Nella classe AuthService.java
, definisci un percorso al file in cui
della classe di credenziali dell'utente. In questo esempio, il file viene creato
Directory /credentialStore
. Aggiungi il percorso dell'archivio credenziali al
.gitignore
. Questa directory viene generata quando l'utente avvia la
flusso di autorizzazione.
private static final File dataDirectory = new File("credentialStore");
Quindi, crea un metodo nel file AuthService.java
per creare e
restituisce un oggetto FileDataStoreFactory
. Questo è il datastore
e archiviare 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
in GoogleAuthorizationCodeFlow Builder()
e richiama getCredentialDataStore()
per impostare il datastore.
GoogleAuthorizationCodeFlow authorizationCodeFlow =
new GoogleAuthorizationCodeFlow.Builder(
HTTP_TRANSPORT,
JSON_FACTORY,
getClientSecrets(),
getScopes())
.setAccessType("offline")
.setDataStoreFactory(getCredentialDataStore())
.build();
Dopodiché aggiorna il metodo getAndSaveCredentials(String authorizationCode)
.
In precedenza, questo metodo otteneva le credenziali senza archiviarle
ovunque. Aggiorna il metodo per archiviare le credenziali nel datastore
indicizzati dallo User-ID.
L'ID utente può essere ottenuto dall'oggetto TokenResponse
utilizzando il metodo
id_token
, ma deve essere prima verificata. Altrimenti, il cliente
le applicazioni potrebbero essere in grado di simulare l'identità degli utenti inviando
ID al server. ti consigliamo di utilizzare il client API di Google
librerie per convalidare id_token
. Consulta la [pagina Google Identity sul
verificare il token ID Google] per ulteriori informazioni.
// 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.");
}
Dopo la verifica di id_token
, ottieni il userId
da conservare insieme
con le 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
per 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 recuperare Users
. Ti è stato fornito un id
nel
Parametro di query login_hint
, che puoi utilizzare per recuperare un utente specifico
record.
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 da cui recuperare un utente
nel database in base al loro 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 le credenziali
Esistono due scenari per l'archiviazione delle credenziali. Se id
dell'utente è già
nel database, quindi aggiorna il record esistente con eventuali nuovi valori. Altrimenti,
crea un nuovo record User
e aggiungilo al database.
Python
Definisci innanzitutto un metodo di utilità che implementi lo spazio di archiviazione o l'aggiornamento comportamento degli utenti.
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 casi in cui puoi salvare le credenziali nel tuo
database: quando l'utente torna all'applicazione alla fine
nel flusso di autorizzazione e durante l'emissione di una chiamata API. È qui che
in precedenza ha impostato la chiave della sessione credentials
.
Chiama il numero save_user_credentials
alla fine del tuo percorso callback
. Mantieni il valore
user_info
invece di estrarre semplicemente 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)
Dovresti anche aggiornare le credenziali seguenti alle chiamate all'API. In questo
puoi fornire le credenziali aggiornate come argomenti
save_user_credentials
.
# Save credentials in case access token was refreshed.
flask.session["credentials"] = credentials_to_dict(credentials)
save_user_credentials(credentials)
Java
Definisci innanzitutto un metodo che archivi o aggiorni un oggetto User
nell'ambiente H2
per configurare un database.
/** 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 casi in cui puoi salvare le credenziali nel tuo
database: quando l'utente torna all'applicazione alla fine
nel flusso di autorizzazione e durante l'emissione di una chiamata API. È qui che
in precedenza ha impostato la chiave della sessione credentials
.
Chiama saveUser
alla fine del percorso /callback
. Devi mantenere
user_info
anziché semplicemente estrarre 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);
Dovresti anche aggiornare le credenziali seguenti alle chiamate all'API. In questo
in questo caso, puoi fornire le credenziali aggiornate come argomenti alla saveUser
.
/** Save credentials in case access token was refreshed. */
saveUser(credentials, null, session);
Credenziali scadute
Tieni presente che esistono alcuni motivi per cui i token di aggiornamento potrebbero non essere più validi. Questi include:
- Il token di aggiornamento non viene utilizzato da sei mesi.
- L'utente revoca le autorizzazioni di accesso dell'app.
- L'utente cambia le password.
- L'utente appartiene a un'organizzazione Google Cloud con controllo di sessione norme in vigore.
Acquisisci nuovi token indirizzando di nuovo l'utente al flusso di autorizzazione, se se le loro credenziali non sono più valide.
Indirizza automaticamente l'utente
Modificare il percorso di destinazione del componente aggiuntivo per rilevare se l'utente ha autorizzato in precedenza e la nostra applicazione. In tal caso, indirizzali alla nostra pagina principale dei componenti aggiuntivi. Altrimenti, chiedi di eseguire l'accesso.
Python
Assicurati che il file di database sia stato creato quando l'applicazione
viene avviato. 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 tuo metodo dovrebbe quindi gestire il parametro di query login_hint
come
trattati sopra. Quindi carica le credenziali del negozio se si tratta di una ripetizione
visitatore. Sai che si tratta di un visitatore abituale se hai ricevuto login_hint
.
Recupera le credenziali memorizzate per l'utente e caricale nella
durante la 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 è disponibile e credenziali. In tal caso, 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
Vai al percorso di destinazione del componente aggiuntivo (/addon-discovery
nel
esempio). Come illustrato in precedenza, è qui che hai gestito il login_hint
parametro di query.
Innanzitutto, controlla se esistono credenziali nella sessione. In caso contrario, indirizza il
l'utente attraverso il flusso di autorizzazione 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. È
un visitatore abituale se ricevi il parametro di ricerca login_hint
. Se
nel database H2, carica le credenziali dalla credenziale
datastore configurato in precedenza e impostare le credenziali nella sessione. Se
non sono state ottenute le credenziali 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
Accedere a Google Classroom come parte del test per insegnanti utenti. Vai alla scheda Lavori del corso e crea un nuovo compito. Clic il pulsante Componenti aggiuntivi sotto l'area di testo, quindi seleziona il componente aggiuntivo. L'iframe e il componente aggiuntivo carica l'URI di configurazione dell'allegato che hai specificato nella Pagina Configurazione app dell'SDK Google Workspace Marketplace.
Complimenti! È tutto pronto per andare al passaggio successivo: creazione di allegati e identificando il ruolo dell'utente.