Wiederholte Anmeldungen verarbeiten

Dies ist die dritte Schritt-für-Schritt-Anleitung für Classroom-Add-ons.

In dieser Anleitung erfahren Sie, wie Sie wiederholte Besuche unseres Add-ons verarbeiten, indem Sie die zuvor erteilten Anmeldedaten eines Nutzers automatisch abrufen. Anschließend leiten Sie Nutzer auf Seiten weiter, von denen aus sie sofort API-Anfragen senden können. Dies ist für Classroom-Add-ons erforderlich.

In dieser Anleitung führen Sie die folgenden Schritte aus:

• Nichtflüchtigen Speicher für Nutzeranmeldedaten implementieren
• Rufen Sie den Add-on-Suchparameter login_hint ab und bewerten Sie ihn. Dies ist eine eindeutige Google-ID des angemeldeten Nutzers.

Hinweis: login_hint wird erst gesendet, nachdem der Nutzer Ihre App autorisiert hat. Sie wird nicht gesendet, wenn ein Nutzer Ihr Add-on zum ersten Mal startet.

Danach können Sie Nutzer in Ihrer Webanwendung vollständig autorisieren und Google APIs aufrufen.

Wichtig :Bevor Sie diese Anleitung befolgen, müssen Sie die vorherigen Anleitungen in dieser Reihe durcharbeiten. In dieser Anleitung wird die in den vorherigen Anleitungen entwickelte Webanwendung erweitert. Auf der Übersichtsseite können Sie den vollständigen Quellcode für alle Schritt-für-Schritt-Anleitungen herunterladen. Den Code für diese spezielle Schritt-für-Schritt-Anleitung finden Sie im Verzeichnis /03-query-parameters/.

iFrame-Abfrageparameter

Beim Öffnen lädt Classroom den Einrichtungs-URI für Anhänge des Add-ons. Classroom hängt dem URI mehrere GET-Abfrageparameter an, die nützliche Kontextinformationen enthalten. Wenn der Discovery-URI für Anhänge beispielsweise https://example.com/addon lautet, wird in Classroom der Iframe mit der Quell-URL https://example.com/addon?courseId=XXX&itemId=YYY&itemType=courseWork&addOnToken=ZZZ erstellt. Dabei sind XXX, YYY und ZZZ String-IDs. Eine ausführliche Beschreibung dieses Szenarios finden Sie im Leitfaden zu Iframes.

Es gibt fünf mögliche Abfrageparameter für die Discovery-URL:

• courseId: Die ID des aktuellen Classroom-Kurses.
• itemId: Die ID des Streamelements, das der Nutzer bearbeiten oder erstellen möchte.
• itemType: Die Art des Streamelements, das der Nutzer erstellt oder bearbeitet, entweder courseWork, courseWorkMaterial oder announcement.
• addOnToken: Ein Token, mit dem bestimmte Aktionen von Classroom-Add-ons autorisiert werden.
• login_hint: Die Google-ID des aktuellen Nutzers.

Wichtig: login_hint wird nur gesendet, wenn der Nutzer Ihre Anwendung bereits autorisiert hat. Wenn die App zum ersten Mal gestartet wird, wird login_hint nicht gesendet.

Diese Schritt-für-Schritt-Anleitung befasst sich mit login_hint. Nutzer werden abhängig davon, ob dieser Abfrageparameter angegeben ist, an den Autorisierungsablauf (falls nicht vorhanden) oder zur Add-on-Erkennungsseite (falls vorhanden) weitergeleitet.

Auf die Abfrageparameter zugreifen

Die Abfrageparameter werden im URI-String an Ihre Webanwendung übergeben. Speichere diese Werte in deiner Sitzung. Sie werden im Autorisierungsablauf verwendet und zum Speichern und Abrufen von Informationen über den Nutzer. Diese Abfrageparameter werden nur übergeben, wenn das Add-on zum ersten Mal geöffnet wird.

Python

Rufen Sie die Definitionen Ihrer Flask-Routen auf (routes.py, wenn Sie unserem Beispiel folgen). Rufen Sie oben in Ihrer Add-on-Landingpage (in unserem Beispiel /classroom-addon) den Abfrageparameter login_hint ab und speichern Sie ihn:

# 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")

Achten Sie darauf, dass login_hint (falls vorhanden) in der Sitzung gespeichert wird. Dies ist ein geeigneter Ort zum Speichern dieser Werte. 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.
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

Rufen Sie in Ihrer Controller-Klasse die Landingpage-Route des Add-ons auf (/addon-discovery in AuthController.java im Beispiel). Rufe zu Beginn dieser Route den Abfrageparameter login_hint ab und speichere ihn.

/** Retrieve the login_hint query parameter from the request URL if present. */
String login_hint = request.getParameter("login_hint");

Achten Sie darauf, dass login_hint (falls vorhanden) in der Sitzung gespeichert wird. Das ist ein geeigneter Ort, um diese Werte zu speichern. Sie sind temporär und Sie erhalten neue Werte, wenn das Add-on geöffnet wird.

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

Abfrageparameter zum Autorisierungsablauf hinzufügen

Der Parameter login_hint sollte auch an die Authentifizierungsserver von Google übergeben werden. Dies erleichtert den Authentifizierungsprozess. Wenn Ihre Anwendung weiß, welcher Nutzer sich authentifizieren möchte, verwendet der Server den Hinweis, um den Anmeldevorgang zu vereinfachen, indem das E-Mail-Feld im Anmeldeformular vorab ausgefüllt wird.

Python

Rufen Sie in Ihrer Flask-Serverdatei den Autorisierungspfad auf (/authorize in unserem Beispiel). Fügen Sie dem Aufruf von flow.authorization_url das Argument login_hint 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"),

Java

Rufen Sie die Methode authorize() in der Klasse AuthService.java auf. Fügen Sie der Methode login_hint als Parameter und login_hint und das Argument dem Autorisierungs-URL-Builder hinzu.

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

Dauerhaften Speicher für Nutzeranmeldedaten hinzufügen

Wenn Sie beim Laden des Add-ons login_hint als Abfrageparameter erhalten, bedeutet das, dass der Nutzer den Autorisierungsvorgang für unsere Anwendung bereits abgeschlossen hat. Sie sollten die vorherigen Anmeldedaten abrufen, anstatt den Nutzer zu einer erneuten Anmeldung zu zwingen.

Sie erinnern sich, dass Sie nach Abschluss des Autorisierungsvorgangs ein Aktualisierungstoken erhalten haben. Speichern Sie dieses Token. Es kann wiederverwendet werden, um ein Zugriffstoken zu erhalten, das kurzlebig ist und für die Verwendung von Google APIs erforderlich ist. Sie haben diese Anmeldedaten bereits in der Sitzung gespeichert, müssen sie aber speichern, um wiederholte Besuche zu verarbeiten.

Wichtig :Wenn du das Aktualisierungstoken nicht speicherst, musst du den Nutzer noch einmal durch den Autorisierungsvorgang führen, um ein Zugriffstoken zu erhalten. Wenn Sie ein Aktualisierungstoken haben, können Sie vom Authentifizierungsserver von Google ein neues Zugriffstoken anfordern.

Aktualisierungstokens werden nur gewährt, wenn der Nutzer Ihre Anwendung zum ersten Mal autorisiert.

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: Die Google-ID des Nutzers. Dieser Wert muss mit den im Abfrageparameter login_hint angegebenen Werten ü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.

Hinweis: Diese Attribute sind Stringtypen.

In diesem Beispiel wird die Speicherung mit SQLite implementiert, das nativ von Python unterstützt wird. Dabei wird das Modul flask_sqlalchemy verwendet, um die Datenbankverwaltung zu vereinfachen.

Datenbank einrichten

Geben Sie zunächst einen Dateispeicherort für die Datenbank an. Rufen Sie Ihre Serverkonfigurationsdatei auf (in unserem Beispiel config.py) 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

Dadurch wird Flask auf die Datei data.sqlite im selben Verzeichnis wie die Datei main.py verwiesen.

Rufen Sie als Nächstes Ihr Modulverzeichnis auf und erstellen Sie eine neue models.py-Datei. Das ist webapp/models.py, wenn Sie unserem Beispiel folgen. Fügen Sie der neuen Datei Folgendes hinzu, um die Tabelle User zu definieren. Ersetzen Sie dabei webapp durch den 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())

Fügen Sie abschließend in der __init__.py-Datei 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: Die Google-ID des Nutzers. Dieser Wert muss mit dem im Abfrageparameter login_hint angegebenen Wert übereinstimmen.
• email: E-Mail-Adresse des Nutzers.

Hinweis :Diese Attribute sind Stringtypen.

Erstellen Sie im Verzeichnis resources des Moduls eine Datei schema.sql. Spring liest diese Datei und generiert entsprechend ein Schema für die Datenbank. Definieren Sie die Tabelle mit dem Namen users und den Spalten User, id und email.

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 User-Modell für die Datenbank zu definieren. Im Beispiel ist das User.java.

Fügen Sie die Annotation @Entity hinzu, um anzugeben, dass dies ein POJO ist, der 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 nach Belieben auch Getter und eine toString-Methode einfügen. Für diese Demo werden diese Methoden jedoch nicht verwendet und aus dem Codebeispiel auf dieser Seite aus Gründen der Übersichtlichkeit 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 namens 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 Konstruktor der Controller-Klasse, um die UserRepository-Klasse zu injectieren.

/** 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 Informationen in Classroom zu speichern. Zum Einrichten der H2-Datenbank müssen Sie application.properties die folgende Konfiguration hinzufügen.

# 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

Mit der spring.datasource.url-Konfiguration wird ein Verzeichnis namens h2 mit der Datei userdb erstellt. 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 einen Nutzernamen und ein Passwort für die Datenbank 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 beim Neustart der Anwendung erhalten. Damit die Datenbank bei jedem Neustart der Anwendung gelöscht wird, legen Sie diese Konfiguration auf create fest.

Legen Sie die spring.jpa.open-in-view-Konfiguration auf false fest. Diese Konfiguration ist standardmäßig aktiviert und kann zu Leistungsproblemen führen, die sich in der Produktion nur schwer diagnostizieren lassen.

Wie bereits erwähnt, müssen Sie die Anmeldedaten eines wiederkehrenden Nutzers abrufen können. Dies wird durch den integrierten Anmeldedatenspeicher unterstützt, der von der GoogleAuthorizationCodeFlow angeboten wird.

Definieren Sie in der AuthService.java-Klasse einen Pfad zur Datei, in der die Anmeldedatenklasse gespeichert ist. In diesem Beispiel wird die Datei im Verzeichnis /credentialStore erstellt. Fügen Sie den Pfad zum Anmeldedatenspeicher zu .gitignore hinzu. Dieses Verzeichnis wird generiert, sobald der Nutzer den Autorisierungsablauf startet.

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

Erstellen Sie als Nächstes eine Methode in der Datei AuthService.java, die ein FileDataStoreFactory-Objekt erstellt und zurückgibt. Dies ist der Datenspeicher, in dem die 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() einzubeziehen, 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 getAndSaveCredentials(String authorizationCode)-Methode. Bisher wurden mit dieser Methode Anmeldedaten abgerufen, ohne sie irgendwo zu speichern. Aktualisieren Sie die Methode, um die Anmeldedaten im Datastore zu speichern, der nach der Nutzer-ID indexiert ist.

Die Nutzer-ID kann über das TokenResponse-Objekt mithilfe des id_token abgerufen werden, muss aber zuerst verifiziert werden. Andernfalls können Clientanwendungen Nutzer fälschlicherweise als Nutzer ausgeben, indem sie geänderte Nutzer-IDs an den Server senden. Wir empfehlen, die Google API-Clientbibliotheken zum Validieren der id_token zu verwenden. Weitere Informationen finden Sie auf der [Google Identity-Seite zur Bestätigung 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 id_token verifiziert wurde, rufen Sie die userId zum Speichern 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 von 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. Sie erhalten ein id im Abfrageparameter login_hint, 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 die id des Nutzers bereits in der Datenbank vorhanden ist, aktualisiere den vorhandenen Datensatz mit allen neuen Werten. Andernfalls erstellen Sie einen neuen User-Eintrag und fügen ihn der Datenbank hinzu.

Hinweis: Dieser Beispielcode basiert auf dem Sitzungsschlüssel login_hint, der in einem vorherigen Schritt gespeichert wurde.

Python

Definieren Sie zuerst eine Dienstmethode, 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 Autorisierungsablaufs zu Ihrer Anwendung zurückkehrt und wenn ein API-Aufruf erfolgt. Hier haben wir zuvor den Sitzungsschlüssel credentials festgelegt.

Rufen Sie am Ende Ihrer callback-Route save_user_credentials auf. 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)

Außerdem sollten Sie die Anmeldedaten nach Aufrufen der API 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 Autorisierungsablaufs zu Ihrer Anwendung zurückkehrt und wenn ein API-Aufruf erfolgt. Dort haben wir zuvor den Sitzungsschlüssel credentials festgelegt.

Rufen Sie am Ende der Route /callback saveUser 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);

Außerdem sollten Sie die Anmeldedaten nach Aufrufen der API 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

Es gibt verschiedene Gründe, warum Aktualisierungstokens ungültig werden können. Dazu gehören:

• Das Aktualisierungstoken wurde seit sechs Monaten nicht verwendet.
• Der Nutzer widerruft die Zugriffsberechtigungen Ihrer App.
• Der Nutzer ändert Passwörter.
• Der Nutzer gehört zu einer Google Cloud-Organisation, für die Richtlinien zur Sitzungssteuerung gelten.

Wenn seine Anmeldedaten ungültig werden, können Sie neue Tokens erwerben, indem Sie den Nutzer noch einmal durch den Autorisierungsablauf leiten.

Nutzer automatisch weiterleiten

Ändern Sie den Landingpage-Pfad des Add-ons, um zu erkennen, ob der Nutzer unsere Anwendung bereits autorisiert hat. Falls ja, leiten Sie sie auf unsere Add-on-Hauptseite weiter. Andernfalls bitte ihn, sich anzumelden.

Python

Die Datenbankdatei muss beim Starten der Anwendung erstellt werden. Fügen Sie Folgendes in einen Modulinitialisierer (wie webapp/__init__.py in unserem Beispiel) oder in die Hauptmethode ein, mit der der Server gestartet wird.

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

Die Methode sollte dann den Abfrageparameter login_hint wie oben beschrieben verarbeiten. Lade dann die Anmeldedaten für den Store, wenn es sich um einen wiederkehrenden Besucher handelt. Wenn Sie login_hint erhalten haben, handelt es sich um einen wiederkehrenden Besucher. Alle gespeicherten Anmeldedaten für diesen Nutzer abrufen und in die Sitzung laden.

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. Wenn ja, leite sie an die 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 Ihre Add-on-Landingpage (/addon-discovery im angegebenen Beispiel) auf. Wie oben erläutert, haben Sie hier den Abfrageparameter login_hint verarbeitet.

Prüfen Sie zuerst, ob Anmeldedaten in der Sitzung vorhanden sind. Ist dies nicht der Fall, leiten Sie den Nutzer durch den Authentifizierungsvorgang weiter, indem Sie die Methode startAuthFlow aufrufen.

/** 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. Es handelt sich um einen wiederkehrenden Besucher, wenn Sie den Abfrageparameter login_hint erhalten. Wenn der Nutzer in der H2-Datenbank vorhanden ist, laden Sie die Anmeldedaten aus dem zuvor eingerichteten Anmeldedatenspeicher und legen Sie sie in der Sitzung fest. Wenn die Anmeldedaten nicht aus dem Anmeldedatendatenspeicher 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 abschließend 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

Wichtig :Sie können Ihre Anwendung zwar direkt in einem Webbrowser testen, sollten sie aber hauptsächlich im iframe für Classroom-Add-ons testen. Wenn Sie Ihre Webanwendung in einen iFrame laden, kann es zu atypischen Verhaltensweisen kommen. Eine Beschreibung der einzelnen iFrames finden Sie in der Anleitung iFrame- und Abfrageparameter. Bei allen Anleitungen in dieser Schritt-für-Schritt-Anleitung wird davon ausgegangen, dass das Add-on in einem iFrame verwendet werden kann.

Melden Sie sich in Google Classroom als einer Ihrer Testnutzer vom Typ Lehrkraft an. Rufen Sie den Tab Kursaufgaben auf und erstellen Sie eine neue Aufgabe. Klicken Sie unter dem Textfeld auf die Schaltfläche Add-ons (Add-ons) und wählen Sie das gewünschte Add-on aus. Der Iframe wird geöffnet und das Add-on lädt den URI für die Einrichtung von Anhängen, den Sie auf der Seite App-Konfiguration des Google Workspace Marketplace SDK angegeben haben.

Glückwunsch! Sie können nun mit dem nächsten Schritt fortfahren: Anhänge erstellen und die Rolle des Nutzers ermitteln.