Gérer les connexions répétées

Il s'agit du troisième tutoriel de la série de tutoriels sur les modules complémentaires Classroom.

Dans ce tutoriel, vous allez gérer les visites répétées de notre module complémentaire en récupérant automatiquement les identifiants précédemment accordés à un utilisateur. Vous dirigez ensuite les utilisateurs vers des pages à partir desquelles ils peuvent immédiatement émettre des requêtes API. Ce comportement est obligatoire pour les modules complémentaires Classroom.

Dans ce tutoriel, vous allez effectuer les opérations suivantes:

• Implémentez un stockage persistant pour nos identifiants utilisateur.
• Récupérez et évaluez les paramètres de requête de module complémentaire suivants :
  • login_hint: identifiant Google de l'utilisateur connecté.
  • hd: domaine de l'utilisateur connecté

Notez qu'un seul d'entre eux est envoyé. L'API Classroom envoie le paramètre hd si l'utilisateur n'a PAS ENCORE autorisé votre application. Dans le cas contraire, l'API envoie login_hint. La liste complète des paramètres de requête est disponible sur la page du guide des cadres iFrame.

Une fois l'opération terminée, vous pouvez autoriser entièrement les utilisateurs de votre application Web et émettre des appels vers les API Google.

Important :Avant de suivre ce tutoriel, suivez les précédents tutoriels de la série. Ce tutoriel développe l'application Web développée dans les tutoriels précédents. Vous pouvez télécharger le code source complet de tous les tutoriels sur la page "Présentation". Le code de ce tutoriel spécifique se trouve dans le répertoire /03-query-parameters/.

Comprendre les paramètres de requête iFrame

Classroom charge l'URI de configuration des pièces jointes de votre module complémentaire à l'ouverture. Classroom ajoute plusieurs paramètres de requête GET à l'URI. Ils contiennent des informations contextuelles utiles. Par exemple, si votre URI de découverte des pièces jointes est https://example.com/addon, Classroom crée l'iFrame avec l'URL source définie sur https://example.com/addon?courseId=XXX&postId=YYY&addOnToken=ZZZ, où XXX, YYY et ZZZ sont des ID de chaîne. Consultez le guide iFrame pour obtenir une description détaillée de ce scénario.

Il existe cinq paramètres de requête possibles pour l'URL de découverte:

• courseId: ID du cours Classroom actuel.
• postId: ID du post d'attribution que l'utilisateur modifie ou crée.
• addOnToken: jeton utilisé pour autoriser certaines actions du module complémentaire Classroom.
• login_hint: ID Google de l'utilisateur actuel.
• hd: domaine de l'hôte de l'utilisateur actuel, tel que example.com.

Important :Une seule des valeurs hd ou login_hint est fournie, pas les deux. hd est envoyé si l'utilisateur n'a pas encore autorisé votre application. Sinon, login_hint est envoyé.

Ce tutoriel concerne hd et login_hint. Les utilisateurs sont acheminés en fonction du paramètre de requête fourni, soit vers le flux d'autorisation si hd, soit vers la page de découverte du module complémentaire si login_hint.

Accéder aux paramètres de requête

Comme décrit ci-dessus, les paramètres de requête sont transmis à votre application Web dans la chaîne d'URI. Stockez ces valeurs dans votre session. Elles sont utilisées dans le flux d'autorisation, ainsi que pour stocker et récupérer des informations sur l'utilisateur. Ces paramètres de requête ne sont transmis que lorsque le module complémentaire est ouvert pour la première fois.

Python

Accédez aux définitions de vos routes Flask (routes.py si vous suivez l'exemple fourni). En haut de l'itinéraire de destination de votre module complémentaire (/classroom-addon dans notre exemple fourni), récupérez et stockez les paramètres de requête login_hint et hd:

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

Assurez-vous que login_hint et hd sont stockés dans la session. C'est l'endroit idéal pour stocker ces valeurs, car elles sont éphémères et vous en recevez de nouvelles lorsque le module complémentaire est ouvert.

# 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

Accédez à la route de destination du module complémentaire dans la classe de votre contrôleur (/addon-discovery dans AuthController.java dans l'exemple fourni). Au début de cette route, récupérez et stockez les paramètres de requête login_hint et hd.

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

Assurez-vous que login_hint et hd sont stockés dans la session. C'est l'endroit idéal pour stocker ces valeurs, car elles sont éphémères et vous en recevez de nouvelles lorsque le module complémentaire est ouvert.

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

Ajouter les paramètres de requête au flux d'autorisation

Les paramètres login_hint et hd doivent également être transmis aux serveurs d'authentification de Google. Ils facilitent le processus d'authentification. Si votre application sait quel utilisateur tente de s'authentifier, le serveur utilise la suggestion pour simplifier le flux de connexion en préremplissant le champ d'adresse e-mail dans le formulaire de connexion.

Python

Accédez à la route d'autorisation dans le fichier du serveur Flask (/authorize dans notre exemple fourni). Ajoutez les arguments login_hint et hd à l'appel de flow.authorization_url.

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

Java

Accédez à la méthode authorize() dans la classe AuthService.java. Ajoutez login_hint et hd en tant que paramètres à la méthode, puis ajoutez les arguments login_hint et hd à l'outil de création d'URL d'autorisation.

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

Ajouter un espace de stockage persistant pour les identifiants utilisateur

Si vous recevez login_hint en tant que paramètre de requête lors du chargement du module complémentaire, cela signifie que l'utilisateur a déjà terminé le flux d'autorisation pour notre application. Vous devez récupérer leurs identifiants précédents au lieu de l'obliger à se reconnecter.

Rappelez-vous que vous avez reçu un jeton d'actualisation à la fin du flux d'autorisation. Enregistrez ce jeton. Vous pourrez le réutiliser pour obtenir un jeton d'accès de courte durée et nécessaire à l'utilisation des API Google. Vous avez déjà enregistré ces identifiants dans la session, mais vous devez les stocker pour gérer les visites répétées.

Important :Si vous n'enregistrez pas le jeton d'actualisation, vous devez à nouveau rediriger l'utilisateur via le flux d'autorisation pour obtenir un jeton d'accès. Vous pouvez demander un nouveau jeton d'accès au serveur d'authentification de Google si vous disposez d'un jeton d'actualisation.

Les jetons d'actualisation ne sont accordés que lorsque l'utilisateur autorise votre application pour la première fois.

Définir le schéma utilisateur et configurer la base de données

Configurez un schéma de base de données pour un élément User.

Python

Définir le schéma utilisateur

Un User contient les attributs suivants:

• id: ID Google de l'utilisateur. Il doit correspondre aux valeurs fournies dans le paramètre de requête login_hint.
• display_name: prénom et nom de l'utilisateur, par exemple "Alex Smith".
• email : adresse e-mail de l'utilisateur.
• portrait_url: URL de la photo de profil de l'utilisateur.
• refresh_token: jeton d'actualisation précédemment obtenu.

Remarque :Ces attributs sont des types de chaîne.

Cet exemple met en œuvre le stockage à l'aide de SQLite, qui est compatible de manière native avec Python. Il utilise le module flask_sqlalchemy pour faciliter la gestion de la base de données.

Configurer la base de données

Tout d'abord, spécifiez un emplacement de fichier pour notre base de données. Accédez au fichier de configuration de votre serveur (config.py dans notre exemple fourni) et ajoutez ce qui suit.

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

Cette action renvoie Flask vers le fichier data.sqlite, qui se trouve dans le même répertoire que votre fichier main.py.

Accédez ensuite au répertoire de votre module et créez un fichier models.py. Il s'agit de webapp/models.py si vous suivez l'exemple fourni. Ajoutez le code suivant au nouveau fichier pour définir la table User, en remplaçant webapp par le nom de votre module, s'il est différent.

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())

Enfin, dans le fichier __init__.py de votre module, ajoutez les éléments suivants pour importer les nouveaux modèles et créer la base de données.

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

Définir le schéma utilisateur

Un User contient les attributs suivants:

• id: ID Google de l'utilisateur. Il doit correspondre à la valeur fournie dans le paramètre de requête login_hint.
• email : adresse e-mail de l'utilisateur.

Remarque :Ces attributs sont des types de chaîne.

Créez un fichier schema.sql dans le répertoire resources du module. Spring lit ce fichier et génère un schéma en conséquence pour la base de données. Définissez la table avec un nom de table (users) et des colonnes pour représenter les attributs User (id et email).

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

Créez une classe Java pour définir le modèle User de la base de données. Il s'agit de User.java dans l'exemple fourni.

Ajoutez l'annotation @Entity pour indiquer qu'il s'agit d'un POJO pouvant être enregistré dans la base de données. Ajoutez l'annotation @Table avec le nom de table correspondant que vous avez configuré dans schema.sql.

Notez que l'exemple de code inclut des constructeurs et des setters pour les deux attributs. Le constructeur et les setters sont utilisés dans AuthController.java pour créer ou mettre à jour un utilisateur dans la base de données. Vous pouvez également inclure des getters et une méthode toString si vous le jugez nécessaire, mais pour ce tutoriel particulier, ces méthodes ne sont pas utilisées et sont omises de l'exemple de code de cette page par souci de concision.

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

Créez une interface appelée UserRepository.java pour gérer les opérations CRUD vers la base de données. Cette interface étend l'interface CrudRepository.

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

La classe de contrôleur facilite la communication entre le client et le dépôt. Par conséquent, mettez à jour le constructeur de classe de contrôleur pour injecter la classe UserRepository.

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

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

Configurer la base de données

Pour stocker des informations sur l'utilisateur, utilisez une base de données H2 intrinsèquement compatible avec Spring Boot. Cette base de données est également utilisée dans les tutoriels suivants pour stocker d'autres informations liées à Classroom. La configuration de la base de données H2 nécessite d'ajouter la configuration suivante à 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 configuration spring.datasource.url crée un répertoire, appelé h2, dans lequel est stocké le fichier userdb. Ajoutez le chemin d'accès à la base de données H2 à .gitignore. Vous devez mettre à jour spring.datasource.username et spring.datasource.password avant d'exécuter l'application pour définir la base de données avec le nom d'utilisateur et le mot de passe de votre choix. Pour mettre à jour le nom d'utilisateur et le mot de passe de la base de données après avoir exécuté l'application, supprimez le répertoire h2 généré, mettez à jour la configuration, puis exécutez à nouveau l'application.

Définir la configuration spring.jpa.hibernate.ddl-auto sur update garantit que les données stockées dans la base de données sont conservées lors du redémarrage de l'application. Pour effacer la base de données à chaque redémarrage de l'application, définissez cette configuration sur create.

Définissez la configuration de spring.jpa.open-in-view sur false. Cette configuration est activée par défaut et peut entraîner des problèmes de performances difficiles à diagnostiquer en production.

Comme décrit précédemment, vous devez pouvoir récupérer les identifiants d'un utilisateur régulier. Cette opération est facilitée par la prise en charge intégrée du stockage d'identifiants offerte par GoogleAuthorizationCodeFlow.

Dans la classe AuthService.java, définissez un chemin d'accès au fichier dans lequel la classe d'identifiants est stockée. Dans cet exemple, le fichier est créé dans le répertoire /credentialStore. Ajoutez le chemin d'accès au magasin d'identifiants à .gitignore. Ce répertoire est généré lorsque l'utilisateur commence le flux d'autorisation.

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

Ensuite, créez dans le fichier AuthService.java une méthode qui crée et renvoie un objet FileDataStoreFactory. Il s'agit du datastore qui stocke les identifiants.

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

Mettez à jour la méthode getFlow() dans AuthService.java pour inclure setDataStoreFactory dans la méthode GoogleAuthorizationCodeFlow Builder() et appelez getCredentialDataStore() pour définir le datastore.

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

Ensuite, mettez à jour la méthode getAndSaveCredentials(String authorizationCode). Auparavant, cette méthode permettait d'obtenir des identifiants sans les stocker. Mettez à jour la méthode pour stocker les identifiants dans le datastore indexés par l'ID utilisateur.

L'ID utilisateur peut être obtenu à partir de l'objet TokenResponse à l'aide de id_token, mais il doit être validé au préalable. Sinon, les applications clientes risquent de se faire passer pour des utilisateurs en envoyant les ID utilisateur modifiés au serveur. Nous vous recommandons d'utiliser les bibliothèques clientes des API Google pour valider les id_token. Pour en savoir plus, consultez la page sur la [validation du jeton d'ID Google].

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

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

GoogleIdToken idToken = googleIdTokenVerifier.verify(idTokenString);

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

Une fois le id_token vérifié, obtenez le userId à stocker avec les identifiants obtenus.

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

Mettez à jour l'appel à flow.createAndStoreCredential pour inclure userId.

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

Ajoutez à la classe AuthService.java une méthode qui renvoie les identifiants d'un utilisateur spécifique si celui-ci existe dans le 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;
    }
}

Récupérer les identifiants

Définissez une méthode d'extraction de Users. Vous obtenez un id dans le paramètre de requête login_hint, que vous pouvez utiliser pour récupérer un enregistrement utilisateur spécifique.

Python

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

Java

Dans la classe AuthController.java, définissez une méthode pour récupérer un utilisateur de la base de données en fonction de son ID utilisateur.

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

Stocker les identifiants

Il existe deux scénarios pour le stockage des identifiants. Si le id de l'utilisateur se trouve déjà dans la base de données, mettez à jour l'enregistrement existant avec les nouvelles valeurs. Sinon, créez un enregistrement User et ajoutez-le à la base de données.

Remarque :L'exemple ci-dessous repose sur la clé de session login_hint, qui a été enregistrée lors d'une étape précédente.

Python

Commencez par définir une méthode utilitaire qui met en œuvre le comportement de stockage ou de mise à jour.

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()

Vous pouvez enregistrer des identifiants dans votre base de données à deux reprises: lorsque l'utilisateur revient dans votre application à la fin du flux d'autorisation et lors de l'émission d'un appel d'API. C'est là que nous avons précédemment défini la clé credentials de la session.

Appelez save_user_credentials à la fin de votre itinéraire callback. Conservez l'objet user_info au lieu d'extraire simplement le nom de l'utilisateur.

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

Vous devez également mettre à jour les identifiants après les appels à l'API. Dans ce cas, vous pouvez fournir les identifiants mis à jour en tant qu'arguments à la méthode save_user_credentials.

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

Java

Commencez par définir une méthode qui stocke ou met à jour un objet User dans la base de données H2.

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

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

Vous pouvez enregistrer des identifiants dans votre base de données à deux reprises: lorsque l'utilisateur revient dans votre application à la fin du flux d'autorisation et lors de l'émission d'un appel d'API. C'est là que nous avons précédemment défini la clé credentials de la session.

Appelez saveUser à la fin de la route /callback. Vous devez conserver l'objet user_info au lieu de simplement extraire l'adresse e-mail de l'utilisateur.

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

Vous devez également mettre à jour les identifiants après les appels à l'API. Dans ce cas, vous pouvez fournir les identifiants mis à jour en tant qu'arguments à la méthode saveUser.

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

Identifiants expirés

Notez que les jetons d'actualisation peuvent devenir non valides pour plusieurs raisons. Ceux-ci incluent les éléments suivants :

• Le jeton d'actualisation n'a pas été utilisé depuis six mois.
• L'utilisateur révoque les autorisations d'accès de votre application.
• L'utilisateur modifie les mots de passe.
• L'utilisateur appartient à une organisation Google Cloud qui a appliqué des règles de contrôle de session.

Pour obtenir de nouveaux jetons, renvoyez l'utilisateur via le flux d'autorisation si ses identifiants deviennent non valides.

Acheminer automatiquement l'utilisateur

Modifiez la route de destination du module complémentaire pour détecter si l'utilisateur a déjà autorisé notre application. Si tel est le cas, dirigez-les vers notre page de module complémentaire principale. Sinon, invitez-le à se connecter.

Python

Assurez-vous que le fichier de base de données a été créé au lancement de l'application. Insérez le code suivant dans un initialiseur de module (tel que webapp/__init__.py dans l'exemple fourni) ou dans la méthode principale qui lance le serveur.

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

Votre méthode doit ensuite gérer les paramètres de requête login_hint et hd, comme indiqué ci-dessus. Chargez ensuite les identifiants du magasin s'il s'agit d'un visiteur régulier. Si vous avez reçu login_hint, cela signifie qu'il s'agit d'un visiteur régulier. Récupérez tous les identifiants stockés pour cet utilisateur et chargez-les dans la session.

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

Enfin, dirigez l'utilisateur vers la page de connexion si nous ne disposons pas de ses identifiants. Si c'est le cas, dirigez-les vers la page principale du module complémentaire.

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

Accédez à la route de destination de votre module complémentaire (/addon-discovery dans l'exemple fourni). Comme indiqué ci-dessus, c'est ici que vous avez géré les paramètres de requête login_hint et hd.

Tout d'abord, vérifiez si des identifiants existent dans la session. Si ce n'est pas le cas, dirigez l'utilisateur via le flux d'authentification en appelant la méthode 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);
}

Ensuite, chargez l'utilisateur à partir de la base de données H2 s'il s'agit d'un visiteur régulier. Il s'agit d'un visiteur régulier si vous recevez le paramètre de requête login_hint. Si l'utilisateur existe dans la base de données H2, chargez les identifiants à partir du datastore d'identifiants configuré précédemment, puis définissez les identifiants dans la session. Si les identifiants n'ont pas été obtenus à partir du datastore des identifiants, acheminez l'utilisateur via le flux d'authentification en appelant 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);
    }
}

Enfin, redirigez l'utilisateur vers la page de destination du module complémentaire.

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

Tester le module complémentaire

Important :Bien que vous puissiez tester votre application directement à l'aide d'un navigateur Web, vous devez principalement la tester dans l'iFrame des modules complémentaires Classroom. Le chargement de votre application Web dans un iFrame peut produire des comportements atypiques. Consultez notre guide sur les paramètres iFrame et de requête pour obtenir une description de chaque iFrame. Toutes les instructions fournies dans ce tutoriel supposent que le module complémentaire est utilisable dans le contexte d'un iFrame.

Connectez-vous à Google Classroom en tant que l'un de vos utilisateurs test Teacher. Accédez à l'onglet Travaux et devoirs et créez un devoir. Cliquez sur le bouton Modules complémentaires sous la zone de texte, puis sélectionnez votre module complémentaire. L'iFrame s'ouvre et le module complémentaire charge l'URI de configuration des pièces jointes que vous avez spécifié sur la page Configuration de l'application du SDK GWM.

Félicitations ! Vous êtes prêt à passer à l'étape suivante: créer des pièces jointes et identifier le rôle de l'utilisateur.