To jest trzeci przewodnik po dodatkach do Classroom. które zrecenzować w naszym serwisie.
Korzystając z tego przewodnika, obsługujesz wielokrotne wizyty w naszym dodatku, pobierania wcześniej przyznanych danych logowania użytkownika. Następnie przekierowujesz użytkowników do strony, z których mogą one natychmiast wysyłać żądania do interfejsu API. To pole jest wymagane działania 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
. To jest unikalny identyfikator Google zalogowanego użytkownika.
Po zakończeniu możesz w pełni autoryzować użytkowników w aplikacji internetowej i wysyłać połączenia do interfejsów API Google.
Omówienie parametrów zapytania iframe
Classroom wczytuje identyfikator URI konfiguracji załączników dodatku po
przed otwarciem. Classroom.
dołącza kilka parametrów zapytania GET
do identyfikatora URI; zawierają przydatne informacje.
informacji kontekstowych. Jeśli na przykład identyfikator URI wykrywania załączników to
https://example.com/addon
, Classroom tworzy element iframe z parametrem
źródłowy adres URL ustawiony na
https://example.com/addon?courseId=XXX&itemId=YYY&itemType=courseWork&addOnToken=ZZZ
,
gdzie XXX
, YYY
i ZZZ
to identyfikatory ciągu znaków. W przewodniku po elementach iframe znajdziesz
szczegółowy opis tego scenariusza.
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 w strumieniu, który użytkownik tworzy lub edytuje; jeden zcourseWork
,courseWorkMaterial
lubannouncement
.addOnToken
: token używany do autoryzowania określonych Działania dodatkowe Classroom.login_hint
: identyfikator Google bieżącego użytkownika.
Ten przewodnik dotyczy: login_hint
. Użytkownicy są przekierowywani w zależności od tego, czy
do procesu autoryzacji, jeśli go brakuje, albo do
stronie odkrywania dodatku (jeśli jest dostępna).
Dostęp do parametrów zapytania
Parametry zapytania są przekazywane do aplikacji internetowej w ciągu identyfikatora URI. Sklep wartości w sesji, są używane w procesie autoryzacji oraz do do przechowywania i pobierania informacji o użytkowniku. Te parametry zapytania to tylko są przekazywane przy pierwszym otwarciu dodatku.
Python
Przejdź do definicji tras Flask (routes.py
, jeśli
zgodnie z podanym przykładem). U góry trasy docelowej dodatku
(/classroom-addon
w naszym 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 jest
odpowiednie miejsce do ich przechowywania; są efemeryczne i otrzymujesz
nowe wartości po otwarciu dodatku.
# 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
na początku tej trasy, pobierz i zapisz zapytanie login_hint
.
/** Retrieve the login_hint query parameter from the request URL if present. */
String login_hint = request.getParameter("login_hint");
Upewnij się, że w sesji jest zapisany atrybut login_hint
(jeśli jest dostępny). To jest
odpowiednie miejsce do ich przechowywania; są efemeryczne i otrzymujesz
nowe wartości po otwarciu dodatku.
/** 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);
}
Dodawanie parametrów zapytania do procesu autoryzacji
Parametr login_hint
powinien zostać przekazany do serwerów uwierzytelniania Google
. Ułatwia to proces uwierzytelniania; jeśli aplikacja wie,
który próbuje uwierzytelnić użytkownika, serwer korzysta ze wskazówki, aby uprościć
przez 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 funkcji
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
login_hint
jako parametr metody i dodaj login_hint
i argumentu do konstruktora adresów URL do autoryzacji.
String authUrl = flow
.newAuthorizationUrl()
.setState(state)
.set("login_hint", login_hint)
.setRedirectUri(REDIRECT_URI)
.build();
Dodaj pamięć trwałą na dane logowania użytkownika
Jeśli po wczytaniu dodatku otrzymasz jako parametr zapytania login_hint
, oznacza to, że jest to
oznacza, że użytkownik ukończył już proces autoryzacji
aplikacji. Zamiast wymuszać, pobierz poprzednie dane logowania
musi zalogować się ponownie.
Pamiętaj, że po zakończeniu przetwarzania otrzymasz token odświeżania proces autoryzacji. Zapisz ten token. może zostać ponownie użyty do uzyskania tokenu dostępu, który jest krótki i niezbędny do korzystania z interfejsów API Google. Zapisane wcześniej tych danych logowania, ale musisz je przechowywać i 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 wlogin_hint
parametr zapytania.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 zastosowano pamięć masową SQLite, która jest natywnie obsługiwana przez
Pythona. Wykorzystuje moduł flask_sqlalchemy
, aby usprawnić naszą bazę danych
i zarządzania nimi.
Skonfiguruj bazę danych
Najpierw określ lokalizację pliku naszej bazy danych. Przejdź na swój serwer
(config.py
w podanym przykładzie) i dodaj do
następujących po sobie.
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 platformy Flask do pliku data.sqlite
w tym samym katalogu co
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
wpisz ten nowy plik, aby zdefiniować tabelę User
, zastępując fragment
nazwa modułu dla webapp
, jeśli jest inna.
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 ten kod, aby zaimportować
nowych modeli i utworzeniu bazy 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 wlogin_hint
parametr zapytania.email
: adres e-mail użytkownika.
Utwórz plik schema.sql
w katalogu resources
modułu. Wiosenne
odczytuje ten plik i odpowiednio generuje schemat dla bazy danych.
Zdefiniuj tabelę, podając jej nazwę, users
i kolumny do reprezentowania
atrybuty User
oraz 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. To jest
User.java
.
Dodaj adnotację @Entity
, aby wskazać, że mamy do czynienia z osobą, którą można
zapisane w bazie danych. Dodaj adnotację @Table
z atrybutem
odpowiadającej jej nazwy tabeli skonfigurowanej w tabeli schema.sql
.
Zwróć uwagę, że przykładowy kod zawiera konstruktory i mechanizmy wyznaczające dla obydwu stron
. Konstruktor i setery są używane w
AuthController.java
, aby utworzyć lub zaktualizować użytkownika w bazie danych. Ty
może również obejmować metody getterów i metody toString
, ale w przypadku
w tym przewodniku, metody te nie są używane i są pomijane
podamy zwięzły kod na tej stronie.
/** 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
do bazy 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
z repozytorium. Dlatego zaktualizuj konstruktor klas kontrolera do wstrzyknięcia
zajęcia 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
Do przechowywania informacji związanych z użytkownikiem używaj bazy danych H2, która jest
obsługiwane przez Spring Boot. Ta baza danych jest również używana w kolejnych
instrukcje dotyczące przechowywania innych plików związanych z Classroom,
i informacjami o nich. Skonfigurowanie bazy danych H2 wymaga dodania tych elementów
na 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
Konfiguracja spring.datasource.url
tworzy katalog o nazwie h2
z
zapisany w nim plik userdb
. Dodaj ścieżkę do bazy danych H2 do
.gitignore
. Musisz zaktualizować spring.datasource.username
oraz
spring.datasource.password
przed uruchomieniem aplikacji w celu ustawienia
z wybraną przez siebie nazwą użytkownika i hasłem. Aby zaktualizować
nazwę użytkownika i hasło do bazy danych po uruchomieniu aplikacji,
usuń wygenerowany katalog h2
, zaktualizuj konfigurację i
ponownie uruchomić aplikację.
Ustawienie konfiguracji spring.jpa.hibernate.ddl-auto
na update
zapewnia, że:
dane przechowywane w bazie danych są zachowywane po ponownym uruchomieniu aplikacji.
Aby czyścić bazę danych przy każdym ponownym uruchomieniu aplikacji, ustaw tę opcję
config na create
.
Ustaw konfigurację spring.jpa.open-in-view
na false
. Ta konfiguracja jest włączona
domyślnie i może powodować problemy z wydajnością
są bardzo trudne do zdiagnozowania w środowisku produkcyjnym.
Jak opisano wcześniej, musisz mieć możliwość pobrania danych logowania
powtórnego użytkownika. Ułatwia to wbudowany magazyn danych logowania
pomoc oferowana przez GoogleAuthorizationCodeFlow
.
W klasie AuthService.java
zdefiniuj ścieżkę do pliku, w której
klasa danych logowania jest przechowywana. W tym przykładzie plik jest tworzony w
Katalog /credentialStore
. Dodaj ścieżkę do magazynu danych logowania do pola
.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
. Jest to magazyn danych, który
przechowuje 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 obiekcie AuthService.java
, tak aby zawierała
setDataStoreFactory
w: 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 ich zapisywania
w dowolnym miejscu. Zaktualizuj metodę przechowywania danych logowania w magazynie danych
do zindeksowania według identyfikatora użytkownika.
Identyfikator użytkownika można uzyskać z obiektu TokenResponse
za pomocą funkcji
id_token
, ale najpierw musisz je zweryfikować. W przeciwnym razie klient
aplikacje mogą przyjmować tożsamość użytkowników przez wysyłanie zmodyfikowanych kont użytkowników
identyfikatory serwera. zalecamy korzystanie z klienta API Google
do weryfikacji biblioteki id_token
. Zajrzyj na [stronę tożsamości Google w
weryfikacji tokena tożsamości Google], aby dowiedzieć się więcej.
// 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 numeru id_token
uzyskaj userId
, który będzie służyć do przechowywania
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
dla 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
. Przyznano Ci id
w
login_hint
parametru zapytania, którego można użyć do pobrania konkretnego użytkownika.
nagrywać.
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
zdefiniuj metodę pobierania użytkownika
w bazie danych na podstawie 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 id
użytkownika jest już
w bazie danych, a następnie 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ędzia, która wdraża pamięć masową lub aktualizację zachowanie użytkownika.
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()
Są dwa przypadki, w których dane logowania można zapisać na koncie
bazy danych: gdy użytkownik wróci do aplikacji na końcu polecenia
procesu autoryzacji i wysyłania wywołań interfejsu API. W tych miejscach
ustawiono wcześniej klucz credentials
sesji.
Zadzwoń pod numer save_user_credentials
na końcu trasy callback
. Zachowaj
user_info
zamiast samo wyodrębniania nazwy 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 tym
możesz podać zaktualizowane dane logowania jako argumenty
Metoda 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 H2
w bazie danych.
/** 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);
}
}
Są dwa przypadki, w których dane logowania można zapisać na koncie
bazy danych: gdy użytkownik wróci do aplikacji na końcu polecenia
procesu autoryzacji i wysyłania wywołań interfejsu API. W tych miejscach
ustawiono wcześniej klucz credentials
sesji.
Zadzwoń pod numer saveUser
na końcu trasy /callback
. Należy zachować
user_info
zamiast wyodrębniać tylko e-maila użytkownika.
/** 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 tym
możesz podać zaktualizowane dane uwierzytelniające jako argumenty funkcji saveUser
.
/** 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. Te uwzględnij:
- 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, która ma kontrolę sesji obowiązujących zasad.
Aby uzyskać nowe tokeny, ponownie przeprowadź proces autoryzacji, jeśli że ich dane logowania stają się nieważne.
Kieruj użytkownika automatycznie
Zmodyfikuj trasę docelową dodatku, aby sprawdzić, czy użytkownik wcześniej zezwolił na dostęp. do aplikacji. Jeśli tak, skieruj ich na naszą stronę główną dodatku. W przeciwnym razie: aby się zalogować.
Python
Sprawdź, czy plik bazy danych został utworzony, gdy aplikacja
nowych funkcji. Wstaw ten kod do inicjatora modułu (np.
webapp/__init__.py
w naszym przykładzie) lub w głównej metodzie, która
uruchamia 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
jako
omówione powyżej. Następnie wczytaj dane logowania do sklepu, jeśli to się powtarza
użytkownika. Jeśli dotarły do Ciebie „login_hint
”, oznacza to, że odwiedzają Twoją witrynę wielokrotnie.
Pobierz wszystkie zapisane dane logowania tego użytkownika i załaduj je do
.
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
Na koniec skieruj użytkownika na stronę logowania, jeśli nie mamy jego dane 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
). Jak wspomniano powyżej, w tym miejscu zajęto się login_hint
parametru zapytania.
Najpierw sprawdź, czy w sesji istnieją dane logowania. Jeśli nie, skieruj kod
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. Jest
powtórnego użytkownika, jeśli otrzymasz parametr zapytania login_hint
. Jeśli
użytkownik istnieje w bazie danych H2, wczytaj dane logowania z danych logowania
wcześniej skonfigurowany magazyn danych i ustaw dane logowania w sesji. Jeśli
nie udało się uzyskać danych logowania z magazynu danych logowania, skieruj użytkownika
w procesie uwierzytelniania, dzwoniąc pod numer 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 testów nauczyciela. użytkowników. Otwórz kartę Zadania i utwórz nowy projekt. Kliknij kliknij przycisk Dodatki pod obszarem tekstowym, a następnie wybierz dodatek. Element iframe zostanie otwarty, a dodatek wczyta Identyfikator URI konfiguracji załącznika określony w Otwórz stronę Konfiguracja aplikacji pakietu SDK Google Workspace Marketplace.
Gratulacje! Możesz już przejść do następnego kroku: tworzenia załączników i określeniu roli użytkownika.