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

Python

Accédez aux définitions de vos routes Flask (routes.py si vous en suivant l'exemple fourni). en haut de votre itinéraire de destination du module complémentaire. (/classroom-addon dans l'exemple fourni), récupérez et stockez le Paramètre de requête 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")

Assurez-vous que login_hint (le cas échéant) est stocké dans la session. Il s'agit d'un à l'endroit approprié pour stocker ces valeurs ; ils sont éphémères et vous recevez de nouvelles valeurs 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.
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

Accéder à l'itinéraire d'arrivée du module complémentaire dans votre classe de manette (/addon-discovery dans AuthController.java dans l'exemple fourni). À le début de cette route, récupérer et stocker la requête login_hint .

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

Assurez-vous que login_hint (le cas échéant) est stocké dans la session. Il s'agit d'un à l'endroit approprié pour stocker ces valeurs ; ils sont éphémères et vous recevez de nouvelles valeurs lorsque le module complémentaire est ouvert.

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

Python

Accédez à la route d'autorisation dans votre fichier serveur Flask (/authorize). dans l'exemple fourni). Ajoutez l'argument login_hint à l'appel pour 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

Accédez à la méthode authorize() dans la classe AuthService.java. Ajouter login_hint en tant que paramètre de la méthode, puis ajoutez login_hint. et un argument à l'outil de création d'URL d'autorisation.

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

Python

Définir le schéma "User"

Un User contient les attributs suivants:

• id: ID Google de l'utilisateur. Il doit correspondre aux valeurs fournies dans les 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 acquis.

Cet exemple implémente le stockage à l'aide de SQLite, qui est compatible en mode natif avec Python. Il utilise le module flask_sqlalchemy pour faciliter notre base de données gestion de la sécurité.

Configurer la base de données

Tout d'abord, spécifiez un emplacement de fichier pour notre base de données. Accéder à votre serveur de configuration (config.py dans l'exemple fourni) et ajoutez le suivis.

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

Cela pointe Flask vers le fichier data.sqlite dans le même répertoire que votre 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 que nous fournissons. Ajouter dans le nouveau fichier pour définir la table User, en remplaçant votre nom du module pour webapp 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 le code suivant 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 "User"

Un User contient les attributs suivants:

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

Créez un fichier schema.sql dans le répertoire resources du module. Printemps lit ce fichier et génère un schéma pour la base de données en conséquence. Définissez la table en lui attribuant un nom, users, et des colonnes à 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. C'est User.java dans l'exemple fourni.

Ajoutez l'annotation @Entity pour indiquer qu'il s'agit d'un POJO pouvant être enregistrées dans la base de données. Ajoutez l'annotation @Table avec 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 . 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. Toi peut également inclure des getters et une méthode toString comme vous le souhaitez, mais pour dans ce tutoriel, ces méthodes ne sont pas utilisées et sont omises l'exemple de code présenté sur 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. à 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 un dépôt de clés. Par conséquent, mettez à jour le constructeur de la 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 liées à l'utilisateur, utilisez une base de données H2 intrinsèque compatibles avec Spring Boot. Cette base de données est également utilisée pour des tutoriels pour stocker d'autres applications des informations. La configuration de la base de données H2 nécessite l'ajout des éléments suivants la configuration sur 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, avec le fichier userdb qu'il contient. Ajoutez le chemin d'accès à la base de données H2 pour le .gitignore. Vous devez mettre à jour les spring.datasource.username et spring.datasource.password avant d'exécuter l'application pour définir base de données avec un nom d'utilisateur et un mot de passe de votre choix. Pour mettre à jour nom d'utilisateur et 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 réexécutez 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 ce sur create.

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

Comme décrit précédemment, vous devez être en mesure de récupérer les identifiants d'un un utilisateur régulier. Cette opération est facilitée par le magasin d'identifiants intégré. l'assistance proposée par GoogleAuthorizationCodeFlow.

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

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

Ensuite, créez une méthode dans le fichier AuthService.java qui crée et renvoie un objet FileDataStoreFactory. Il s'agit du datastore 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 pièce 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. n'importe où. Mettre à jour la méthode pour stocker les identifiants dans le datastore indexées par l'ID utilisateur.

Vous pouvez obtenir l'ID utilisateur à partir de l'objet TokenResponse à l'aide de la méthode id_token, mais il doit d'abord être validé. Sinon, le client applications peuvent usurper l'identité d'un utilisateur en envoyant des données au serveur. nous vous recommandons d'utiliser le client pour valider les id_token. Consultez la [page Google consacrée à l'identité vérification du jeton d'ID Google] pour en savoir plus.

// 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 validé, obtenez le userId pour le 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. pour un utilisateur spécifique, le cas échéant.

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

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 à partir de la base de données en fonction de leur 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;
}

Python

Commencez par définir une méthode utilitaire qui implémente le stockage comportemental.

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

Il existe deux cas dans lesquels vous pouvez enregistrer les identifiants database: lorsque l'utilisateur revient dans votre application à la fin de la flux d'autorisation et lors de l'émission d'un appel d'API. C'est là que nous défini précédemment la clé credentials de la session.

Appelez save_user_credentials au bout de votre itinéraire callback. Gardez le user_info au lieu d'extraire uniquement 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 vous pouvez fournir les identifiants mis à jour en tant qu'arguments 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 le H2. base de données.

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

Il existe deux cas dans lesquels vous pouvez enregistrer les identifiants database: lorsque l'utilisateur revient dans votre application à la fin de la flux d'autorisation et lors de l'émission d'un appel d'API. C'est là que nous défini précédemment la clé credentials de la session.

Appelez saveUser à la fin de la route /callback. Vous devez conserver user_info au lieu d'extraire uniquement 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 vous pouvez fournir les identifiants mis à jour en tant qu'arguments à saveUser .

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

Python

Assurez-vous que le fichier de base de données a été créé lorsque l'application lancements. Insérez le code suivant dans un initialiseur de module (tel que webapp/__init__.py dans l'exemple fourni) ou dans la méthode main 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 le paramètre de requête login_hint comme décrites ci-dessus. Chargez ensuite les identifiants du magasin s'il s'agit d'une répétition visiteur. Si vous avez reçu login_hint, il s'agit d'un visiteur régulier. Récupérez tous les identifiants stockés pour cet utilisateur, puis chargez-les dans le 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, redirigez l'utilisateur vers la page de connexion si nous n'avons pas son identifiants de connexion. Si c'est le cas, redirigez-le 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 à l'itinéraire de destination de votre module complémentaire (/addon-discovery dans le exemple). Comme décrit ci-dessus, c'est ici que vous avez géré login_hint. de requête.

Commencez par vérifier si des identifiants existent dans la session. Si ce n'est pas le cas, l'utilisateur dans 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);
}

Chargez ensuite l'utilisateur à partir de la base de données H2 s'il s'agit d'un visiteur régulier. Il est un visiteur régulier si vous recevez le paramètre de requête login_hint. Si le existe dans la base de données H2, chargez les identifiants à partir des identifiants datastore configuré précédemment, puis définissez les identifiants de la session. Si le 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";