Dies ist die dritte Schritt-für-Schritt-Anleitung der Reihe zu Classroom-Add-ons.
In dieser Schritt-für-Schritt-Anleitung verwalten Sie wiederholte Besuche unseres Add-ons, indem Sie die zuvor gewährten Anmeldedaten eines Nutzers automatisch abrufen. Anschließend leiten Sie Nutzer auf Seiten weiter, von denen sie sofort API-Anfragen senden können. Dies ist ein erforderliches Verhalten für Classroom-Add-ons.
Im Verlauf dieser Schritt-für-Schritt-Anleitung führen Sie Folgendes aus:
- Implementieren Sie nichtflüchtigen Speicher für unsere Nutzeranmeldedaten.
- Rufen Sie die folgenden Add-on-Abfrageparameter ab und werten Sie sie aus:
login_hint: die Google-ID des angemeldeten Nutzers.hd: Domain des angemeldeten Nutzers
Beachten Sie, dass nur eines davon gesendet wird. Die Classroom API sendet den Parameter hd, wenn der Nutzer Ihre App NOCH NICHT autorisiert hat. Andernfalls sendet die API login_hint. Die vollständige Liste der Abfrageparameter ist auf der Seite mit dem Leitfaden für iFrames verfügbar.
Anschließend können Sie Nutzer in Ihrer Webanwendung vollständig autorisieren und Google APIs aufrufen.
iFrame-Abfrageparameter
Classroom lädt beim Öffnen des Add-ons den URI für die Anhangeinrichtung. Classroom hängt mehrere GET-Abfrageparameter an den URI an. Diese enthalten nützliche Kontextinformationen. Wenn der URI für die Anhangerkennung beispielsweise https://example.com/addon lautet, erstellt Classroom den iFrame mit der Quell-URL https://example.com/addon?courseId=XXX&postId=YYY&addOnToken=ZZZ, wobei XXX, YYY und ZZZ String-IDs sind. Eine detaillierte Beschreibung dieses Szenarios finden Sie im Leitfaden zu iFrames.
Für die Discovery-URL gibt es fünf mögliche Suchparameter:
courseId: Die ID des aktuellen Classroom-Kurses.postId: Die ID des Aufgabenbeitrags, den der Nutzer gerade bearbeitet oder erstellt.addOnToken: Token, mit dem bestimmte Add-on-Aktionen für Classroom autorisiert werden.login_hint: Die Google-ID des aktuellen Nutzers.hd: die Hostdomain des aktuellen Nutzers, z. B.example.com.
In dieser Schritt-für-Schritt-Anleitung werden hd und login_hint behandelt. Nutzer werden basierend auf dem angegebenen Abfrageparameter weitergeleitet – entweder zum Autorisierungsablauf bei hd oder zur Add-on-Erkennungsseite bei login_hint.
Abfrageparameter aufrufen
Wie oben beschrieben, werden die Abfrageparameter im URI-String an Ihre Webanwendung übergeben. Speichern Sie diese Werte in Ihrer Sitzung. Sie werden im Autorisierungsvorgang sowie zum Speichern und Abrufen von Nutzerinformationen verwendet. Diese Abfrageparameter werden nur übergeben, wenn das Add-on zum ersten Mal geöffnet wird.
Python
Rufen Sie die Definitionen Ihrer Bot-Routen auf (routes.py, wenn Sie dem bereitgestellten Beispiel folgen). Rufen Sie oben in der Add-on-Landingpage (in unserem Beispiel /classroom-addon) die Abfrageparameter login_hint und hd ab und speichern Sie sie:
# Retrieve the login_hint and hd query parameters.
login_hint = flask.request.args.get("login_hint")
hd = flask.request.args.get("hd")
Achten Sie darauf, dass login_hint und hd in der Sitzung gespeichert sind. Dies ist ein geeigneter Ort, um diese Werte zu speichern. Sie sind sitzungsspezifisch und Sie erhalten neue Werte, wenn das Add-on geöffnet wird.
# 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
Rufen Sie die Add-on-Landingpage in Ihrer Controller-Klasse auf (im bereitgestellten Beispiel /addon-discovery in AuthController.java). Rufen Sie am Anfang dieser Route die Abfrageparameter login_hint und hd ab und speichern Sie sie.
/** Retrieve the login_hint or hd query parameters from the request URL. */
String login_hint = request.getParameter("login_hint");
String hd = request.getParameter("hd");
Achten Sie darauf, dass login_hint und hd in der Sitzung gespeichert sind. Dies ist ein geeigneter Ort, um diese Werte zu speichern. Sie sind sitzungsspezifisch und Sie erhalten neue Werte, wenn das Add-on geöffnet wird.
/** 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);
}
Abfrageparameter in den Autorisierungsvorgang einfügen
Die Parameter login_hint und hd sollten auch an die Authentifizierungsserver von Google übergeben werden. Diese erleichtern den Authentifizierungsprozess. Wenn deine Anwendung weiß, welcher Nutzer sich authentifizieren möchte, nutzt der Server den Hinweis, um den Anmeldevorgang zu vereinfachen, indem das E-Mail-Feld im Anmeldeformular vorausgefüllt wird.
Python
Rufen Sie die Autorisierungsroute in der Prometheus-Serverdatei auf (in unserem Beispiel /authorize). Fügen Sie dem Aufruf von flow.authorization_url die Argumente login_hint und hd hinzu.
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
Rufen Sie die Methode authorize() in der Klasse AuthService.java auf. Fügen Sie der Methode die Parameter login_hint und hd und dem Tool zur Autorisierungs-URL die Argumente login_hint und hd hinzu.
String authUrl = flow
.newAuthorizationUrl()
.setState(state)
.set("login_hint", login_hint)
.set("hd", hd)
.setRedirectUri(REDIRECT_URI)
.build();
Nichtflüchtigen Speicher für Nutzeranmeldedaten hinzufügen
Wenn Sie beim Laden des Add-ons login_hint als Abfrageparameter erhalten, bedeutet dies, dass der Nutzer den Autorisierungsvorgang für unsere Anwendung bereits abgeschlossen hat. Sie sollten ihre vorherigen Anmeldedaten abrufen, anstatt sie noch einmal anmelden zu müssen.
Nach Abschluss des Autorisierungsvorgangs haben Sie ein Aktualisierungstoken erhalten. Speichern Sie dieses Token. Es wird dann wiederverwendet, um ein Zugriffstoken abzurufen, das kurzlebig und für die Verwendung von Google APIs erforderlich ist. Sie haben diese Anmeldedaten bereits in der Sitzung gespeichert, müssen aber für wiederholte Besuche gespeichert werden.
Nutzerschema definieren und Datenbank einrichten
Richten Sie ein Datenbankschema für eine User ein.
Python
Nutzerschema definieren
Ein User enthält die folgenden Attribute:
id: Google-ID des Nutzers Dies sollte mit den Werten im Abfrageparameterlogin_hintübereinstimmen.display_name: Vor- und Nachname des Nutzers, z. B. „Alex Smith“.email: E-Mail-Adresse des Nutzers.portrait_url: Die URL des Profilbilds des Nutzers.refresh_token: Das zuvor abgerufene Aktualisierungstoken.
In diesem Beispiel wird die Speicherung mithilfe von SQLite implementiert, das nativ von Python unterstützt wird. Sie nutzt das Modul flask_sqlalchemy, um die Datenbankverwaltung zu vereinfachen.
Datenbank einrichten
Geben Sie zuerst einen Dateispeicherort für unsere Datenbank an. Rufen Sie die Serverkonfigurationsdatei (in unserem Beispiel config.py) auf und fügen Sie Folgendes hinzu.
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
Dieser verweist Bot auf die Datei data.sqlite, die sich im selben Verzeichnis wie die Datei main.py befindet.
Gehen Sie als Nächstes zu Ihrem Modulverzeichnis und erstellen Sie eine neue models.py-Datei.
Dies ist webapp/models.py, wenn Sie dem bereitgestellten Beispiel folgen. Fügen Sie der neuen Datei Folgendes hinzu, um die Tabelle User zu definieren. Ersetzen Sie webapp durch Ihren Modulnamen, falls abweichend.
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())
Abschließend fügen Sie in der Datei __init__.py Ihres Moduls Folgendes hinzu, um die neuen Modelle zu importieren und die Datenbank zu erstellen.
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
Nutzerschema definieren
Ein User enthält die folgenden Attribute:
id: Google-ID des Nutzers Dies sollte mit dem Wert im Abfrageparameterlogin_hintübereinstimmen.email: E-Mail-Adresse des Nutzers.
Erstellen Sie eine schema.sql-Datei im Verzeichnis resources des Moduls. Spring liest diese Datei und generiert entsprechend ein Schema für die Datenbank.
Definieren Sie die Tabelle mit einem Tabellennamen, users und Spalten, die die User-Attribute id und email darstellen.
CREATE TABLE IF NOT EXISTS users (
id VARCHAR(255) PRIMARY KEY, -- user's unique Google ID
email VARCHAR(255), -- user's email address
);
Erstellen Sie eine Java-Klasse, um das Modell User für die Datenbank zu definieren. Im angegebenen Beispiel ist dies User.java.
Fügen Sie die Annotation @Entity hinzu, um anzugeben, dass dies ein POJO ist, das in der Datenbank gespeichert werden kann. Fügen Sie die Annotation @Table mit dem entsprechenden Tabellennamen hinzu, den Sie in schema.sql konfiguriert haben.
Das Codebeispiel enthält Konstruktoren und Setter für die beiden Attribute. Der Konstruktor und die Setter werden in AuthController.java verwendet, um einen Nutzer in der Datenbank zu erstellen oder zu aktualisieren. Sie können auch Getter und eine toString-Methode einfügen. In dieser Schritt-für-Schritt-Anleitung werden diese Methoden jedoch nicht verwendet und der Einfachheit halber im Codebeispiel auf dieser Seite weggelassen.
/** 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; }
}
Erstellen Sie eine Schnittstelle mit dem Namen UserRepository.java, um CRUD-Vorgänge für die Datenbank zu verarbeiten. Diese Schnittstelle erweitert die CrudRepository-Schnittstelle.
/** Provides CRUD operations for the User class by extending the
* CrudRepository interface. */
@Repository
public interface UserRepository extends CrudRepository<User, String> {
}
Die Controller-Klasse erleichtert die Kommunikation zwischen dem Client und dem Repository. Aktualisieren Sie daher den Controller-Klassenkonstruktor, um die UserRepository-Klasse einzufügen.
/** 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;
}
Datenbank einrichten
Verwenden Sie zum Speichern von nutzerbezogenen Informationen eine H2-Datenbank, die in Spring Boot standardmäßig unterstützt wird. Diese Datenbank wird auch in nachfolgenden Schritt-für-Schritt-Anleitungen verwendet, um andere Classroom-bezogene Informationen zu speichern. Für die Einrichtung der H2-Datenbank muss die folgende Konfiguration zu application.properties hinzugefügt werden.
# 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
Die Konfiguration spring.datasource.url erstellt ein Verzeichnis mit dem Namen h2, in dem die Datei userdb gespeichert ist. Fügen Sie den Pfad zur H2-Datenbank in .gitignore ein. Sie müssen spring.datasource.username und spring.datasource.password aktualisieren, bevor Sie die Anwendung ausführen, um für die Datenbank einen Nutzernamen und ein Passwort Ihrer Wahl festzulegen. Wenn Sie den Nutzernamen und das Passwort für die Datenbank nach dem Ausführen der Anwendung aktualisieren möchten, löschen Sie das generierte h2-Verzeichnis, aktualisieren Sie die Konfiguration und führen Sie die Anwendung noch einmal aus.
Wenn Sie die spring.jpa.hibernate.ddl-auto-Konfiguration auf update festlegen, bleiben die in der Datenbank gespeicherten Daten erhalten, wenn die Anwendung neu gestartet wird.
Soll die Datenbank bei jedem Neustart der Anwendung gelöscht werden, legen Sie diese Konfiguration auf create fest.
Legen Sie für die spring.jpa.open-in-view-Konfiguration false fest. Diese Konfiguration ist standardmäßig aktiviert und kann zu Leistungsproblemen führen, die in der Produktion schwierig zu diagnostizieren sind.
Wie bereits beschrieben, musst du die Anmeldedaten eines wiederholten Nutzers abrufen können. Dies wird durch die integrierte Unterstützung für den Anmeldedatenspeicher erleichtert, die von GoogleAuthorizationCodeFlow angeboten wird.
Definieren Sie in der Klasse AuthService.java einen Pfad zu der Datei, in der die Anmeldedatenklasse gespeichert ist. In diesem Beispiel wird die Datei im Verzeichnis /credentialStore erstellt. Fügen Sie .gitignore den Pfad zum Anmeldedatenspeicher hinzu. Dieses Verzeichnis wird generiert, sobald der Nutzer mit dem Autorisierungsvorgang beginnt.
private static final File dataDirectory = new File("credentialStore");
Erstellen Sie als Nächstes eine Methode in der Datei AuthService.java, mit der ein FileDataStoreFactory-Objekt erstellt und zurückgegeben wird. Dies ist der Datenspeicher, in dem Anmeldedaten gespeichert werden.
/** 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;
}
Aktualisieren Sie die Methode getFlow() in AuthService.java, um setDataStoreFactory in die Methode GoogleAuthorizationCodeFlow Builder() aufzunehmen, und rufen Sie getCredentialDataStore() auf, um den Datenspeicher festzulegen.
GoogleAuthorizationCodeFlow authorizationCodeFlow =
new GoogleAuthorizationCodeFlow.Builder(
HTTP_TRANSPORT,
JSON_FACTORY,
getClientSecrets(),
getScopes())
.setAccessType("offline")
.setDataStoreFactory(getCredentialDataStore())
.build();
Aktualisieren Sie als Nächstes die Methode getAndSaveCredentials(String authorizationCode).
Bisher wurden mit dieser Methode Anmeldedaten abgerufen, ohne dass sie irgendwo gespeichert wurden. Aktualisieren Sie die Methode, um die Anmeldedaten im Datenspeicher zu speichern, der durch die Nutzer-ID indexiert wurde.
Die Nutzer-ID kann mithilfe von id_token aus dem TokenResponse-Objekt abgerufen werden, muss aber zuerst bestätigt werden. Andernfalls können Clientanwendungen möglicherweise die Identität von Nutzern übernehmen, indem sie geänderte Nutzer-IDs an den Server senden. Es wird empfohlen, die id_token mithilfe der Google API-Clientbibliotheken zu validieren. Weitere Informationen finden Sie auf der [Google Identity-Seite zum Verifizieren des Google-ID-Tokens].
// 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.");
}
Nachdem die id_token verifiziert wurde, rufen Sie das zu speichernde userId-Objekt zusammen mit den abgerufenen Anmeldedaten ab.
// Obtain the user id from the id_token.
Payload payload = idToken.getPayload();
String userId = payload.getSubject();
Aktualisieren Sie den Aufruf zu flow.createAndStoreCredential, um userId einzubeziehen.
// Save the user id and credentials to the configured FileDataStoreFactory.
Credential credential = flow.createAndStoreCredential(tokenResponse, userId);
Fügen Sie der Klasse AuthService.java eine Methode hinzu, die die Anmeldedaten für einen bestimmten Nutzer zurückgibt, sofern er im Datenspeicher vorhanden ist.
/** 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;
}
}
Anmeldedaten abrufen
Definieren Sie eine Methode zum Abrufen von Users. Im Abfrageparameter login_hint ist ein id angegeben, mit dem Sie einen bestimmten Nutzerdatensatz abrufen können.
Python
def get_credentials_from_storage(id):
"""
Retrieves credentials from the storage and returns them as a dictionary.
"""
return User.query.get(id)
Java
Definieren Sie in der Klasse AuthController.java eine Methode, um einen Nutzer anhand seiner Nutzer-ID aus der Datenbank abzurufen.
/** 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;
}
Anmeldedaten speichern
Es gibt zwei Szenarien beim Speichern von Anmeldedaten. Wenn sich der id des Nutzers bereits in der Datenbank befindet, aktualisieren Sie den vorhandenen Eintrag mit allen neuen Werten. Andernfalls erstellen Sie einen neuen User-Eintrag und fügen ihn der Datenbank hinzu.
Python
Definieren Sie zuerst eine Dienstprogrammmethode, die das Speicher- oder Aktualisierungsverhalten implementiert.
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()
Es gibt zwei Fälle, in denen Sie Anmeldedaten in Ihrer Datenbank speichern können: wenn der Nutzer am Ende des Autorisierungsvorgangs zu Ihrer Anwendung zurückkehrt und wenn ein API-Aufruf gesendet wird. Hier haben wir zuvor den credentials-Sitzungsschlüssel festgelegt.
Rufe save_user_credentials am Ende deiner callback-Route an. Behalten Sie das user_info-Objekt bei, anstatt nur den Namen des Nutzers zu extrahieren.
# 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)
Nach Aufrufen der API sollten Sie auch die Anmeldedaten aktualisieren. In diesem Fall können Sie die aktualisierten Anmeldedaten als Argumente an die Methode save_user_credentials übergeben.
# Save credentials in case access token was refreshed.
flask.session["credentials"] = credentials_to_dict(credentials)
save_user_credentials(credentials)
Java
Definieren Sie zuerst eine Methode, mit der ein User-Objekt in der H2-Datenbank gespeichert oder aktualisiert wird.
/** 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);
}
}
Es gibt zwei Fälle, in denen Sie Anmeldedaten in Ihrer Datenbank speichern können: wenn der Nutzer am Ende des Autorisierungsvorgangs zu Ihrer Anwendung zurückkehrt und wenn ein API-Aufruf gesendet wird. Hier haben wir zuvor den credentials-Sitzungsschlüssel festgelegt.
Rufen Sie saveUser am Ende der Route /callback auf. Sie sollten das user_info-Objekt beibehalten, anstatt nur die E-Mail-Adresse des Nutzers zu extrahieren.
/** 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);
Nach Aufrufen der API sollten Sie auch die Anmeldedaten aktualisieren. In diesem Fall können Sie die aktualisierten Anmeldedaten als Argumente für die Methode saveUser angeben.
/** Save credentials in case access token was refreshed. */
saveUser(credentials, null, session);
Abgelaufene Anmeldedaten
Ein Aktualisierungstoken kann aus verschiedenen Gründen ungültig werden. Dazu gehören:
- Das Aktualisierungstoken wurde seit sechs Monaten nicht mehr verwendet.
- Der Nutzer widerruft die Zugriffsberechtigungen Ihrer App.
- Der Nutzer ändert sein Passwort.
- Der Nutzer gehört zu einer Google Cloud-Organisation, für die Richtlinien zur Sitzungssteuerung gelten.
Holen Sie neue Tokens ein, indem Sie den Nutzer noch einmal durch den Autorisierungsvorgang leiten, falls seine Anmeldedaten ungültig werden.
Nutzer automatisch weiterleiten
Ändern Sie die Add-on-Landingpage so, dass sie erkennt, ob der Nutzer unsere Anwendung zuvor autorisiert hat. Falls ja, leiten Sie sie auf unsere Hauptseite für Add-ons weiter. oder fordern Sie ihn auf, sich anzumelden.
Python
Prüfen Sie, ob die Datenbankdatei beim Start der Anwendung erstellt wurde. Fügen Sie Folgendes in einen Modulinitialisierer (z. B. webapp/__init__.py in unserem Beispiel) oder in die Hauptmethode zum Starten des Servers ein.
# Initialize the database file if not created.
if not os.path.exists(DATABASE_FILE_NAME):
db.create_all()
Ihre Methode sollte dann die Abfrageparameter login_hint und hd wie oben beschrieben verarbeiten. Laden Sie dann die Anmeldedaten des Geschäfts, wenn es sich um einen wiederkehrenden Besucher handelt. Wenn Sie login_hint erhalten haben, wissen Sie, dass es sich um einen wiederkehrenden Besucher handelt.
Rufen Sie alle gespeicherten Anmeldedaten für diesen Nutzer ab und laden Sie sie in die Sitzung.
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
Leiten Sie den Nutzer schließlich zur Anmeldeseite weiter, wenn wir seine Anmeldedaten nicht haben. Falls ja, leiten Sie sie zur Hauptseite des Add-ons weiter.
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
Rufen Sie die Landingpage-Route für das Add-on auf (im bereitgestellten Beispiel /addon-discovery). Wie oben erläutert haben Sie hier die Abfrageparameter login_hint und hd verarbeitet.
Prüfen Sie zuerst, ob in der Sitzung Anmeldedaten vorhanden sind. Ist dies nicht der Fall, leiten Sie den Nutzer durch den Authentifizierungsablauf weiter. Rufen Sie dazu die Methode startAuthFlow auf.
/** 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);
}
Laden Sie den Nutzer dann aus der H2-Datenbank, wenn es sich um einen wiederkehrenden Besucher handelt. Wenn Sie den Abfrageparameter login_hint erhalten, handelt es sich um einen wiederkehrenden Besucher. Ist der Nutzer in der H2-Datenbank vorhanden, laden Sie die Anmeldedaten aus dem bereits eingerichteten Anmeldedatendatenspeicher und legen Sie die Anmeldedaten in der Sitzung fest. Wenn die Anmeldedaten nicht aus dem Datenspeicher für Anmeldedaten abgerufen wurden, leiten Sie den Nutzer durch den Authentifizierungsvorgang weiter, indem Sie startAuthFlow aufrufen.
/** 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);
}
}
Leiten Sie den Nutzer schließlich zur Landingpage des Add-ons weiter.
/** Finally, if there are credentials in the session and in persistent
* storage, direct the user to the addon-discovery page. */
return "addon-discovery";
Add-on testen
Melden Sie sich als einer Ihrer Teacher-Testnutzer in Google Classroom an. Gehen Sie zum Tab Kursaufgaben und erstellen Sie eine neue Aufgabe. Klicken Sie unter dem Textbereich auf die Schaltfläche Add-ons und wählen Sie das Add-on aus. Der iFrame wird geöffnet und das Add-on lädt den URI für die Anhangeinrichtung, den Sie im GWM SDK auf der Seite App-Konfiguration angegeben haben.
Glückwunsch! Sie können mit dem nächsten Schritt fortfahren: Anhänge erstellen und die Rolle des Nutzers ermitteln.