To jest trzeci przewodnik z serii przewodników dotyczących dodatków do Classroom.
Z tego przewodnika dowiesz się, jak obsługiwać powtarzające się wizyty w naszym dodatku, automatycznie pobierając dane logowania przyznane wcześniej użytkownikowi. Następnie przekierowujesz użytkowników na strony, z których mogą natychmiast wysyłać żądania do interfejsu API. Jest to wymagane w przypadku dodatków do Classroom.
W tym przewodniku wykonasz te czynności:
- Zaimplementuj trwałą pamięć masową na dane logowania użytkownika.
- Pobierz i oceń parametr zapytania dodatku
login_hint. Jest to unikalny identyfikator Google zalogowanego użytkownika.
Po zakończeniu możesz w pełni autoryzować użytkowników w aplikacji internetowej i wysyłać wywołania do interfejsów API Google.
Omówienie parametrów zapytania iframe
Po uruchomieniu Classroom wczytuje identyfikator URI konfiguracji załączników dodatku. Classroom dołącza do identyfikatora URI kilka parametrów zapytania GET. Zawierają one przydatne informacje kontekstowe. Jeśli na przykład identyfikator URI wykrywania załączników to https://example.com/addon, Classroom utworzy element iframe z źródłowym adresem URL ustawionym na https://example.com/addon?courseId=XXX&itemId=YYY&itemType=courseWork&addOnToken=ZZZ, gdzie XXX, YYY i ZZZ to identyfikatory ciągu znaków. Szczegółowy opis tej sytuacji znajdziesz w przewodniku po elementach iframe.
W przypadku adresu URL odkrywania jest 5 możliwych parametrów zapytania:
courseId: identyfikator bieżących zajęć w Classroom.itemId: identyfikator elementu strumienia, który użytkownik edytuje lub tworzy.itemType: rodzaj elementu strumienia, który użytkownik tworzy lub edytuje, np.courseWork,courseWorkMateriallubannouncement.addOnToken: token używany do autoryzacji określonych działań dodatkowych Classroom.login_hint: identyfikator Google bieżącego użytkownika.
Ten przewodnik dotyczy: login_hint. Użytkownicy są przekierowywani na podstawie tego, czy ten parametr zapytania został dostarczony: do procesu autoryzacji (jeśli go brakuje) lub na stronę wykrywania dodatków (jeśli jest dostępna).
Dostęp do parametrów zapytania
Parametry zapytania są przekazywane do aplikacji internetowej w ciągu identyfikatora URI. Przechowuj te wartości w sesji. Są wykorzystywane w procesie autoryzacji oraz do przechowywania i pobierania informacji o użytkowniku. Te parametry zapytania są przekazywane tylko przy pierwszym uruchomieniu dodatku.
Python
Przejdź do definicji tras Flask (routes.py, jeśli korzystasz z podanego przykładu). Na górze trasy docelowej dodatku (/classroom-addon w podanym przykładzie) pobierz i zapisz parametr zapytania 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")
Upewnij się, że w sesji jest zapisany atrybut login_hint (jeśli jest dostępny). To odpowiednie miejsce na przechowywanie tych wartości. Są one efemeryczne i po otwarciu dodatku otrzymujesz nowe wartości.
# 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
Przejdź do trasy docelowej dodatku w klasie kontrolera (/addon-discovery w AuthController.java w podanym przykładzie). Na początku tej trasy pobierz i zapisz parametr zapytania login_hint.
/** Retrieve the login_hint or hd query parameters from the request URL. */
String login_hint = request.getParameter("login_hint");
String hd = request.getParameter("hd");
Upewnij się, że w sesji jest zapisany atrybut login_hint (jeśli jest dostępny). To odpowiednie miejsce na przechowywanie tych wartości. Są one efemeryczne i po otwarciu dodatku otrzymujesz nowe wartości.
/** 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);
}
Dodawanie parametrów zapytania do procesu autoryzacji
Parametr login_hint powinien też być przekazywany do serwerów uwierzytelniania Google. Ułatwia to proces uwierzytelniania. Jeśli aplikacja wie, który użytkownik próbuje się uwierzytelnić, serwer korzysta ze wskazówki, aby uprościć proces logowania przez wstępne wypełnienie pola adresu e-mail w formularzu logowania.
Python
Przejdź do trasy autoryzacji w pliku serwera Flask (/authorize w podanym przykładzie). Dodaj argument login_hint do wywołania 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
Przejdź do metody authorize() w klasie AuthService.java. Dodaj do metody login_hint i hd jako parametry, a potem argumenty login_hint i hd w kreatorze adresów URL do autoryzacji.
String authUrl = flow
.newAuthorizationUrl()
.setState(state)
.set("login_hint", login_hint)
.set("hd", hd)
.setRedirectUri(REDIRECT_URI)
.build();
Dodaj pamięć trwałą na dane logowania użytkownika
Jeśli po wczytaniu dodatku otrzymasz jako parametr zapytania login_hint, będzie to oznaczało, że użytkownik zakończył już proces autoryzacji naszej aplikacji. Zamiast wymuszać ponowne logowanie, pobierz ich poprzednie dane logowania.
Pamiętaj, że po zakończeniu procesu autoryzacji otrzymano token odświeżania. Zapisz ten token. Możesz go użyć ponownie do uzyskania tokenu dostępu, który jest krótkotrwały i niezbędny do korzystania z interfejsów API Google. Dane logowania zostały wcześniej zapisane w tej sesji, ale musisz je zachować, aby obsługiwać powtórne wizyty.
Definiowanie schematu użytkownika i konfigurowanie bazy danych
Skonfiguruj schemat bazy danych dla: User.
Python
Definiowanie schematu użytkownika
User zawiera te atrybuty:
id: identyfikator Google użytkownika. Powinna ona odpowiadać wartościom podanym w parametrze zapytanialogin_hint.display_name: imię i nazwisko użytkownika, na przykład „Jan Kowalski”.email: adres e-mail użytkownika.portrait_url: adres URL zdjęcia profilowego użytkownika.refresh_token: wcześniej pozyskany token odświeżania.
W tym przykładzie zaimplementowano pamięć masową z użyciem bazy danych SQLite, która jest natywnie obsługiwana przez Pythona. Wykorzystuje moduł flask_sqlalchemy do usprawniania zarządzania bazą danych.
Skonfiguruj bazę danych
Najpierw określ lokalizację pliku naszej bazy danych. Przejdź do pliku konfiguracji serwera (config.py w podanym przykładzie) i dodaj poniższy kod.
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
Spowoduje to przekierowanie Flask do pliku data.sqlite, który znajduje się w tym samym katalogu co plik main.py.
Następnie przejdź do katalogu modułu i utwórz nowy plik models.py.
Jest to webapp/models.py, jeśli korzystasz z podanego przykładu. Dodaj poniższy kod do nowego pliku, aby zdefiniować tabelę User. Jeśli inną, zastąp nazwę modułu nazwą webapp.
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())
Na koniec w pliku __init__.py modułu dodaj poniższy kod, aby zaimportować nowe modele i utworzyć bazę danych.
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
Definiowanie schematu użytkownika
User zawiera te atrybuty:
id: identyfikator Google użytkownika. Powinna ona odpowiadać wartości podanej w parametrze zapytanialogin_hint.email: adres e-mail użytkownika.
Utwórz plik schema.sql w katalogu resources modułu. Spring odczytuje ten plik i generuje odpowiedni schemat dla bazy danych.
Zdefiniuj tabelę, używając nazwy tabeli, kolumny users i kolumn reprezentujących atrybuty User, id i email.
CREATE TABLE IF NOT EXISTS users (
id VARCHAR(255) PRIMARY KEY, -- user's unique Google ID
email VARCHAR(255), -- user's email address
);
Utwórz klasę Java, aby zdefiniować model User bazy danych. W podanym przykładzie jest to User.java.
Dodaj adnotację @Entity, aby wskazać, że jest to POJO, które można zapisać w bazie danych. Dodaj adnotację @Table z odpowiednią nazwą tabeli skonfigurowaną w zadaniu schema.sql.
Zwróć uwagę, że przykładowy kod zawiera konstruktory i ustawienia dla obu atrybutów. Konstruktor i ustawienia są używane w AuthController.java do tworzenia lub aktualizowania użytkownika w bazie danych. Możesz też dodać metody get i toString, jeśli uznasz to za stosowne, ale w tym przewodniku nie są one używane i są pomijane w przykładowym kodzie na tej stronie dla zwięzłości.
/** 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; }
}
Utwórz interfejs o nazwie UserRepository.java do obsługi operacji CRUD w bazie danych. Ten interfejs rozszerza interfejs CrudRepository.
/** Provides CRUD operations for the User class by extending the
* CrudRepository interface. */
@Repository
public interface UserRepository extends CrudRepository<User, String> {
}
Klasa kontrolera ułatwia komunikację między klientem a repozytorium. Dlatego zaktualizuj konstruktor klasy kontrolera, aby wprowadzić klasę 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;
}
Skonfiguruj bazę danych
Aby przechowywać informacje związane z użytkownikami, używaj bazy danych H2, która jest nieodłącznie obsługiwana przez Spring Boot. Ta baza danych jest też używana w kolejnych instrukcjach do przechowywania innych informacji związanych z Classroom. Skonfigurowanie bazy danych H2 wymaga dodania do application.properties poniższej konfiguracji.
# 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
Konfiguracja spring.datasource.url tworzy katalog o nazwie h2, w którym jest zapisany plik userdb. Dodaj ścieżkę do bazy danych H2 do .gitignore. Zanim uruchomisz aplikację, musisz zaktualizować spring.datasource.username i spring.datasource.password, aby ustawić w bazie danych wybraną nazwę użytkownika i hasło. Aby zaktualizować nazwę użytkownika i hasło do bazy danych po uruchomieniu aplikacji, usuń wygenerowany katalog h2, zaktualizuj konfigurację i ponownie uruchom aplikację.
Ustawienie konfiguracji spring.jpa.hibernate.ddl-auto na update zapewnia, że dane przechowywane w bazie danych są zachowywane po ponownym uruchomieniu aplikacji.
Aby wyczyścić bazę danych przy każdym ponownym uruchomieniu aplikacji, ustaw tę konfigurację na create.
Ustaw konfigurację spring.jpa.open-in-view na false. Ta konfiguracja jest domyślnie włączona i może powodować problemy z wydajnością, które są trudne do zdiagnozowania w środowisku produkcyjnym.
Jak opisano wcześniej, musisz mieć możliwość pobrania danych logowania powracającego użytkownika. Ułatwia to wbudowana obsługa magazynu danych logowania oferowana przez GoogleAuthorizationCodeFlow.
W klasie AuthService.java zdefiniuj ścieżkę do pliku, w którym jest przechowywana klasa danych logowania. W tym przykładzie plik jest tworzony w katalogu /credentialStore. Dodaj ścieżkę do magazynu danych logowania do .gitignore. Ten katalog jest generowany, gdy użytkownik rozpocznie proces autoryzacji.
private static final File dataDirectory = new File("credentialStore");
Następnie utwórz w pliku AuthService.java metodę, która tworzy i zwraca obiekt FileDataStoreFactory. To magazyn danych, w którym są przechowywane dane logowania.
/** 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;
}
Zaktualizuj metodę getFlow() w AuthService.java, aby uwzględnić setDataStoreFactory w metodzie GoogleAuthorizationCodeFlow Builder(), i wywołaj getCredentialDataStore(), aby skonfigurować magazyn danych.
GoogleAuthorizationCodeFlow authorizationCodeFlow =
new GoogleAuthorizationCodeFlow.Builder(
HTTP_TRANSPORT,
JSON_FACTORY,
getClientSecrets(),
getScopes())
.setAccessType("offline")
.setDataStoreFactory(getCredentialDataStore())
.build();
Następnie zaktualizuj metodę getAndSaveCredentials(String authorizationCode).
Wcześniej ta metoda uzyskiwała dane logowania bez przechowywania ich nigdzie. Zaktualizuj metodę przechowywania danych logowania w magazynie danych indeksowanym według identyfikatora użytkownika.
Identyfikator użytkownika można uzyskać z obiektu TokenResponse za pomocą id_token, ale najpierw musisz go zweryfikować. W przeciwnym razie aplikacje klienckie mogą być w stanie podszywać się pod użytkowników przez wysyłanie zmodyfikowanych identyfikatorów użytkowników do serwera. Do zweryfikowania id_token zalecamy używanie bibliotek klienta interfejsu API Google. Więcej informacji znajdziesz na [stronie dotyczącej weryfikacji tożsamości 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.");
}
Po zweryfikowaniu id_token uzyskaj userId, który będzie przechowywany wraz z uzyskanymi danymi logowania.
// Obtain the user id from the id_token.
Payload payload = idToken.getPayload();
String userId = payload.getSubject();
Zaktualizuj wywołanie flow.createAndStoreCredential, aby uwzględnić userId.
// Save the user id and credentials to the configured FileDataStoreFactory.
Credential credential = flow.createAndStoreCredential(tokenResponse, userId);
Dodaj do klasy AuthService.java metodę, która zwraca dane logowania określonego użytkownika (jeśli istnieje on w magazynie danych).
/** 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;
}
}
Odzyskaj dane logowania
Zdefiniuj metodę pobierania danych Users. W parametrze zapytania login_hint podany jest id, którego możesz użyć do pobrania rekordu konkretnego użytkownika.
Python
def get_credentials_from_storage(id):
"""
Retrieves credentials from the storage and returns them as a dictionary.
"""
return User.query.get(id)
Java
W klasie AuthController.java określ metodę pobierania użytkownika z bazy danych na podstawie jego identyfikatora użytkownika.
/** 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;
}
Zapisz dane logowania
Istnieją 2 scenariusze przechowywania danych logowania. Jeśli pole id użytkownika znajduje się już w bazie danych, zaktualizuj istniejący rekord o nowe wartości. W przeciwnym razie utwórz nowy rekord User i dodaj go do bazy danych.
Python
Najpierw zdefiniuj metodę narzędziową, która obsługuje pamięć masową lub aktualizację.
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()
Dane logowania możesz zapisać w bazie danych w 2 przypadkach: gdy użytkownik powraca do aplikacji na końcu procesu autoryzacji i gdy wywołuje interfejs API. Tutaj ustawialiśmy wcześniej klucz sesji credentials.
Zadzwoń pod numer save_user_credentials na końcu trasy callback. Zachowaj obiekt user_info zamiast wyodrębniać samą nazwę użytkownika.
# 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)
Zaktualizuj też dane logowania po wywołaniu interfejsu API. W takim przypadku możesz podać zaktualizowane dane logowania jako argumenty metody save_user_credentials.
# Save credentials in case access token was refreshed.
flask.session["credentials"] = credentials_to_dict(credentials)
save_user_credentials(credentials)
Java
Najpierw zdefiniuj metodę, która przechowuje lub aktualizuje obiekt User w bazie danych 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);
}
}
Dane logowania możesz zapisać w bazie danych w 2 przypadkach: gdy użytkownik powraca do aplikacji na końcu procesu autoryzacji i gdy wywołuje interfejs API. Tutaj ustawialiśmy wcześniej klucz sesji credentials.
Zadzwoń pod numer saveUser na końcu trasy /callback. Zamiast wyodrębniać tylko e-maila użytkownika, lepiej zachować obiekt user_info.
/** 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);
Zaktualizuj też dane logowania po wywołaniu interfejsu API. W takim przypadku jako argumenty metody saveUser możesz podać zaktualizowane dane logowania.
/** Save credentials in case access token was refreshed. */
saveUser(credentials, null, session);
Wygasłe dane logowania
Pamiętaj, że tokeny odświeżania mogą stać się nieprawidłowe z kilku powodów. Obejmują one:
- Token odświeżania nie był używany od 6 miesięcy.
- Użytkownik unieważnia uprawnienia dostępu aplikacji.
- Użytkownik zmieni hasło.
- Użytkownik należy do organizacji Google Cloud, w której obowiązują zasady kontroli sesji.
Jeśli jego dane logowania stają się nieprawidłowe, musisz ponownie przeprowadzić proces autoryzacji, aby uzyskać nowe tokeny.
Kieruj użytkownika automatycznie
Zmodyfikuj trasę docelową dodatku, aby sprawdzić, czy użytkownik wcześniej autoryzował naszą aplikację. Jeśli tak, skieruj ich na naszą stronę główną dodatku. W przeciwnym razie poproś tę osobę o zalogowanie się.
Python
Sprawdź, czy plik bazy danych został utworzony podczas uruchamiania aplikacji. Wstaw ten kod do inicjatora modułu (np. webapp/__init__.py w naszym przykładzie) lub w głównej metodzie uruchamiającej serwer.
# Initialize the database file if not created.
if not os.path.exists(DATABASE_FILE_NAME):
db.create_all()
Twoja metoda powinna następnie obsługiwać parametr zapytania login_hint w sposób omówiony powyżej. Następnie załaduj dane logowania do sklepu, jeśli jest to kolejny użytkownik. Jeśli dotarły do Ciebie „login_hint”, oznacza to, że odwiedzają Twoją witrynę wielokrotnie.
Pobierz wszystkie zapisane dane logowania tego użytkownika i wczytaj je do sesji.
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
Jeśli nie mamy danych logowania, przekieruj użytkownika na stronę logowania. Jeśli tak, przekieruj ich na stronę główną dodatku.
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
Przejdź na trasę docelową dodatku (/addon-discovery w podanym przykładzie). Jak omówiliśmy powyżej, tutaj obsługiwano parametr zapytania login_hint.
Najpierw sprawdź, czy w sesji istnieją dane logowania. Jeśli tego nie zrobi, przekieruj użytkownika przez proces uwierzytelniania, wywołując metodę 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);
}
Następnie wczytaj użytkownika z bazy danych H2, jeśli jest to powracający użytkownik. Jeśli otrzymasz parametr zapytania login_hint, to użytkownik powracający. Jeśli użytkownik istnieje w bazie danych H2, wczytaj dane logowania ze skonfigurowanego wcześniej magazynu danych logowania, a następnie ustaw dane logowania w sesji. Jeśli dane logowania nie zostały uzyskane z magazynu danych logowania, przekieruj użytkownika przez proces uwierzytelniania, wywołując funkcję 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);
}
}
Na koniec skieruj użytkownika na stronę docelową dodatku.
/** Finally, if there are credentials in the session and in persistent
* storage, direct the user to the addon-discovery page. */
return "addon-discovery";
Testowanie dodatku
Zaloguj się w Google Classroom jako jeden z użytkowników testowych nauczyciel. Otwórz kartę Zadania i utwórz nowy projekt. Kliknij przycisk Dodatki pod obszarem tekstowym, a następnie wybierz dodatek. Element iframe otworzy się, a dodatek wczyta identyfikator URI konfiguracji załączników podany na stronie Konfiguracja aplikacji pakietu SDK Google Workspace Marketplace.
Gratulacje! Możesz teraz przejść do następnego kroku: tworzenia załączników i określania roli użytkownika.