Wiederholte Anmeldungen verarbeiten

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

In dieser Schritt-für-Schritt-Anleitung werden wiederholte Besuche unseres Add-ons automatisch Abrufen der zuvor erteilten Anmeldedaten eines Nutzers Anschließend leiten Sie die Nutzenden an auf denen sie sofort API-Anfragen senden können. Dies ist ein Pflichtfeld für Classroom-Add-ons.

Im Verlauf dieser Schritt-für-Schritt-Anleitung führen Sie die folgenden Schritte aus:

  • Implementieren Sie nichtflüchtigen Speicher für die Nutzeranmeldedaten.
  • Rufen Sie den Abfrageparameter des Add-ons login_hint ab und werten Sie ihn aus. Dies ist ein eindeutige Google-ID des angemeldeten Nutzers.

Anschließend können Sie Nutzer in Ihrer Webanwendung vollständig autorisieren und Aufrufe an folgende Adressen senden: Google APIs

Informationen zu iFrame-Suchparametern

Classroom lädt den Einrichtungs-URI für Anhänge des Add-ons nach dem wird geöffnet. Google Classroom hängt mehrere GET-Suchparameter an den URI an. Sie enthalten nützliche Kontextinformationen. Wenn der URI für die Anhangerkennung beispielsweise https://example.com/addon, erstellt Classroom den iFrame mit ist die Quell-URL auf https://example.com/addon?courseId=XXX&itemId=YYY&itemType=courseWork&addOnToken=ZZZ, Dabei sind XXX, YYY und ZZZ String-IDs. Im iFrame-Leitfaden finden Sie ausführliche Beschreibung dieses Szenarios.

Für die Erkennungs-URL gibt es fünf mögliche Suchparameter:

  • courseId: Die ID des aktuellen Classroom-Kurses.
  • itemId: Die ID des Streamelements, das der Nutzer bearbeitet oder erstellt.
  • itemType: Die Art des Streamelements, das der Nutzer erstellt oder bearbeitet, entweder courseWork, courseWorkMaterial oder announcement.
  • addOnToken: Ein Token, mit dem bestimmte Aktionen für Classroom-Add-ons.
  • login_hint: Die Google-ID des aktuellen Nutzers.

Diese Schritt-für-Schritt-Anleitung befasst sich mit login_hint. Die Weiterleitung hängt davon ab, ob für den Autorisierungsvorgang, falls fehlt, oder für die Discovery-Seite des Add-ons, falls vorhanden.

Auf Abfrageparameter zugreifen

Die Abfrageparameter werden im URI-String an Ihre Webanwendung übergeben. Geschäft diese Werte in Ihrer Sitzung an. werden im Autorisierungsablauf verwendet und Informationen über Nutzende speichern und abrufen können. Diese Suchparameter sind nur wird beim ersten Öffnen des Add-ons übergeben.

Python

Navigieren Sie zu den Definitionen Ihrer Flask-Routen (routes.py, falls Sie gemäß unserem Beispiel). Oben auf Ihrer zusätzlichen Landingpage (in unserem Beispiel /classroom-addon) abrufen und speichern. Abfrageparameter 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")

Achten Sie darauf, dass login_hint (falls vorhanden) in der Sitzung gespeichert ist. Dies ist ein zum Speichern dieser Werte. sind sie sitzungsspezifisch und Sie erhalten beim Öffnen des Add-ons neue Werte.

# 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

Add-on-Landingpage in Ihrer Controller-Klasse aufrufen (im angegebenen Beispiel /addon-discovery in AuthController.java). Bei am Anfang dieser Route, rufen Sie die login_hint-Abfrage 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 (falls vorhanden) in der Sitzung gespeichert ist. Dies ist ein zum Speichern dieser Werte. sind sie sitzungsspezifisch und Sie erhalten beim Öffnen des Add-ons neue Werte.

/** 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 zum Autorisierungsablauf hinzufügen

Der login_hint-Parameter muss an die Authentifizierungsserver von Google übergeben werden . Dies erleichtert den Authentifizierungsprozess. wenn Ihre Anwendung die welcher Nutzer versucht, sich zu authentifizieren, verwendet der Server den Hinweis, Log-in-Ablauf, indem du das E-Mail-Feld im Anmeldeformular vorab ausfüllst.

Python

Rufen Sie die Autorisierungsroute in der Flask-Serverdatei auf (/authorize). in unserem Beispiel). Fügen Sie das Argument login_hint in den Aufruf von 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

Rufen Sie in der Klasse AuthService.java die Methode authorize() auf. Hinzufügen login_hint und hd als Parameter für die Methode und fügen Sie login_hint hinzu. und hd für das Tool zur URL-Erstellung für die Autorisierung.

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, ist es eine dass der Nutzer den Autorisierungsvorgang für unsere . Sie sollten ihre vorherigen Anmeldedaten abrufen, anstatt sie zu erzwingen um sich wieder anzumelden.

Denken Sie daran, dass Sie nach Abschluss der Autorisierungsablauf. Speichern Sie dieses Token. es wiederverwendet wird, um ein Zugriffstoken zu erhalten, was kurzlebig und für die Nutzung von Google APIs erforderlich ist. Zuvor gespeichert in der Sitzung verwenden, aber Sie müssen die Anmeldedaten wiederholte Besuche verarbeitet werden können.

Nutzerschema definieren und Datenbank einrichten

Richten Sie ein Datenbankschema für ein User ein.

Python

Nutzerschema definieren

Ein User enthält die folgenden Attribute:

  • id: Die Google-ID des Nutzers. Dies sollte mit den Werten übereinstimmen, die in den login_hint.
  • 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 erhaltene Aktualisierungstoken.

In diesem Beispiel wird die Speicherung mit SQLite implementiert, das nativ von Python Dabei wird das Modul flask_sqlalchemy verwendet, um unsere Datenbank zu vereinfachen. zu verstehen.

Datenbank einrichten

Geben Sie zunächst einen Dateispeicherort für die Datenbank an. Server aufrufen Konfigurationsdatei (in unserem Beispiel config.py) und fügen Sie den Parameter folgen.

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 verweist Flask auf die Datei data.sqlite im selben Verzeichnis wie Ihr main.py-Datei.

Öffnen Sie als Nächstes Ihr Modulverzeichnis und erstellen Sie eine neue models.py-Datei. Dies ist webapp/models.py, wenn Sie sich an unser Beispiel halten. Hinzufügen Folgendes in die neue Datei einfügen, um die Tabelle User zu definieren. Dabei wird Ihr Modulname für webapp, 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 Datei __init__.py Ihres Moduls Folgendes zum Importieren hinzu: die neuen Modelle erstellen und die Datenbank 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. Dies sollte mit dem Wert übereinstimmen, der in den login_hint.
  • email: E-Mail-Adresse des Nutzers.

Erstellen Sie im Verzeichnis resources des Moduls eine schema.sql-Datei. Frühling diese Datei liest und ein Schema für die Datenbank generiert. Definieren Sie die Tabelle mit einem Tabellennamen, users und Spalten, die dargestellt werden sollen die User-Attribute 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. Dies ist User.java im angegebenen Beispiel.

Fügen Sie die Anmerkung @Entity hinzu, um anzugeben, dass es sich um einen POJO handelt, der in der Datenbank gespeichert sind. Fügen Sie die Anmerkung @Table mit der entsprechenden Tabellennamen, den Sie in schema.sql konfiguriert haben.

Beachten Sie, dass das Codebeispiel Konstruktoren und Setter für die beiden Attribute. Der Konstruktor und die Setter werden in AuthController.java, um einen Nutzer in der Datenbank zu erstellen oder zu aktualisieren. Ich können auch Getter und eine toString-Methode enthalten, aber für in dieser Schritt-für-Schritt-Anleitung gezeigt, werden diese Methoden nicht verwendet und in den der Einfachheit halber das Codebeispiel auf dieser Seite.

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

Schnittstelle mit dem Namen UserRepository.java zum Verarbeiten von CRUD-Vorgängen erstellen in der Datenbank. 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 Client und dem zu erstellen. Aktualisieren Sie daher den Controller-Klassenkonstruktor für die die Klasse 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;
}

Datenbank einrichten

Um nutzerbezogene Informationen zu speichern, verwenden Sie eine H2-Datenbank, die in Spring Boot unterstützt werden. Diese Datenbank wird auch in nachfolgenden Schritt-für-Schritt-Anleitungen zum Speichern Informationen. Für die Einrichtung der H2-Datenbank ist Folgendes erforderlich: Konfiguration auf 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

Die Konfiguration spring.datasource.url erstellt ein Verzeichnis namens h2 mit die darin gespeicherte Datei userdb. Fügen Sie den Pfad zur H2-Datenbank .gitignore. Sie müssen die spring.datasource.username und spring.datasource.password, bevor Sie die Anwendung ausführen, um die mit einem Nutzernamen und einem Passwort Ihrer Wahl erstellen. So aktualisieren Sie die Nutzername und Passwort für die Datenbank, nachdem Sie die Anwendung ausgeführt haben, Löschen Sie das generierte h2-Verzeichnis, aktualisieren Sie die Konfiguration und und führen Sie die Anwendung erneut aus.

Wenn Sie die spring.jpa.hibernate.ddl-auto-Konfiguration auf update festlegen, Daten, die in der Datenbank gespeichert sind, bleiben beim Neustart der Anwendung erhalten. Um die Datenbank bei jedem Neustart der Anwendung zu löschen, legen Sie Folgendes fest: config auf create.

Legen Sie die spring.jpa.open-in-view-Konfiguration auf false fest. Diese Konfiguration ist aktiviert Dies kann zu Leistungsproblemen führen, in der Produktion schwer zu diagnostizieren.

Wie bereits beschrieben, müssen Sie in der Lage sein, die Anmeldedaten eines Wiederkehrende Nutzer*innen. Dies wird durch den integrierten Anmeldedatenspeicher ermöglicht. Support von GoogleAuthorizationCodeFlow.

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

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

Erstellen Sie als Nächstes eine Methode in der Datei AuthService.java, die ein gibt ein FileDataStoreFactory-Objekt zurück. Dies ist der Datenspeicher, der Anmeldedaten speichert.

/** 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 Folgendes einzuschließen: setDataStoreFactory in: GoogleAuthorizationCodeFlow Builder() 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 sie zu speichern. überall. Methode zum Speichern der Anmeldedaten im Datenspeicher aktualisieren nach der User-ID indexiert wird.

Die Nutzer-ID kann mit demTokenResponse id_token, aber muss zuerst bestätigt werden. Andernfalls muss der Client Anwendungen können sich möglicherweise als Nutzer ausgeben, indem sie geänderte -IDs an den Server. sollten Sie den Google API-Client Bibliotheken zur Validierung von id_token verwenden. Weitere Informationen finden Sie auf der um weitere Informationen zu erhalten.

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

Sobald die id_token bestätigt wurde, besorgen Sie sich die userId zum Speichern durch die abgerufenen Anmeldedaten.

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

Aktualisieren Sie den Aufruf auf flow.createAndStoreCredential, um userId aufzunehmen.

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

Methode zur Klasse AuthService.java hinzufügen, die die Anmeldedaten zurückgibt für einen bestimmten Nutzer, wenn 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 in der login_hint-Abfrageparameter, mit dem Sie einen bestimmten Nutzer abrufen können Datensatz.

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 AuthController.java-Klasse eine Methode, aus der ein Nutzer abgerufen werden soll basierend auf ihrer User-ID in der Datenbank speichern.

/** 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 das id des Nutzers bereits in der Datenbank und aktualisieren Sie dann den vorhandenen Datensatz mit neuen Werten. Andernfalls einen neuen User-Eintrag erstellen und der Datenbank hinzufügen.

Python

Definieren Sie zunächst eine Dienstprogrammmethode, mit der die Speicherung oder Aktualisierung verhalten.

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 Ihrem database: wenn der Nutzer am Ende des und bei der Ausgabe eines API-Aufrufs. Hier werden wir zuvor den Sitzungsschlüssel credentials festgelegt.

Rufen Sie am Ende Ihrer callback-Route save_user_credentials auf. Behalten Sie die user_info-Objekts, 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)

Sie sollten auch die Anmeldedaten nach Aufrufen der API aktualisieren. In dieser können Sie die aktualisierten Anmeldedaten als Argumente an die save_user_credentials-Methode.

# 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, die ein User-Objekt im H2-Element speichert oder aktualisiert. Datenbank.

/** 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 Ihrem database: wenn der Nutzer am Ende des und bei der Ausgabe eines API-Aufrufs. Hier werden wir zuvor den Sitzungsschlüssel credentials festgelegt.

Rufen Sie am Ende der Route /callback saveUser auf. Sie sollten die user_info-Objekt zu erstellen, 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);

Sie sollten auch die Anmeldedaten nach Aufrufen der API aktualisieren. In dieser können Sie die aktualisierten Anmeldedaten als Argumente an die saveUser übergeben. .

/** 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 sechs Monate lang nicht verwendet.
  • Der Nutzer widerruft die Zugriffsberechtigungen Ihrer App.
  • Der Nutzer ändert seine Passwörter.
  • Der Nutzer gehört zu einer Google Cloud-Organisation mit Sitzungssteuerung geltenden Richtlinien.

Erlangen Sie neue Tokens, indem Sie den Nutzer noch einmal durch den Autorisierungsablauf leiten, wenn sind ihre Anmeldedaten ungültig.

Nutzer automatisch weiterleiten

Ändern Sie die Landing Route des Add-ons, damit erkannt wird, ob der Nutzer dies zuvor autorisiert hat unserer Anwendung. Falls ja, leiten Sie sie auf unsere Add-on-Hauptseite weiter. Andernfalls fordern Sie um sich anzumelden.

Python

Achten Sie darauf, dass die Datenbankdatei erstellt wurde, wenn die Anwendung erstellt wurde Markteinführungen. Fügen Sie Folgendes in einen Modulinitialisierer ein (z. B. webapp/__init__.py in unserem Beispiel) oder in der primären Methode, startet den Server.

# 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 folgt verarbeiten: wie oben beschrieben. Laden Sie dann die Anmeldedaten, falls es sich um eine Besucher. Wenn Sie login_hint erhalten haben, wissen Sie, dass es sich um einen wiederholten Besucher handelt. Rufen Sie alle gespeicherten Anmeldedaten für diesen Nutzer ab und laden Sie sie in den 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 zur Anmeldeseite weiter, falls Anmeldedaten. Falls ja, leiten Sie sie zur Add-on-Hauptseite 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

Add-on-Landingpage aufrufen (/addon-discovery in den angegebenen ) Wie oben erwähnt, haben Sie hier die login_hint verarbeitet Suchparameter angeben.

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

/** 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 dann den Nutzer aus der H2-Datenbank, wenn es sich um einen wiederholten Besucher handelt. Es ist für wiederkehrende Besucher, wenn Sie den Abfrageparameter login_hint erhalten. Wenn die Nutzer in der H2-Datenbank vorhanden ist, laden Sie die Anmeldedaten aus den Anmeldedaten des zuvor eingerichteten Datenspeichers und legen die Anmeldedaten in der Sitzung fest. Wenn die Anmeldedaten nicht aus dem Anmeldedatendatenspeicher abgerufen wurden, leiten Sie den Nutzer durch Aufrufen von 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);
    }
}

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 eine Ihrer Lehrkräftetests in Google Classroom an. Nutzenden. Gehen Sie zum Tab Kursaufgaben und erstellen Sie eine neue Aufgabe. Klicken Sie auf auf die Schaltfläche Add-ons unter dem Textbereich und wählen Sie das gewünschte Add-on aus. Der iFrame wird geöffnet und das Add-on lädt URI für die Anhangseinrichtung, den Sie im Google Workspace Marketplace SDK auf der Seite App-Konfiguration

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