Bu, Classroom eklentileri serisinin üçüncü adım adım açıklamalı kılavuzudur.
Bu adım adım açıklamalı kılavuzda, kullanıcının önceden verilmiş kimlik bilgilerini otomatik olarak alarak eklentimize yapılan yinelenen ziyaretleri ele alacaksınız. Daha sonra kullanıcıları, hemen API istekleri gönderebilecekleri sayfalara yönlendirirsiniz. Bu, Classroom eklentileri için zorunlu bir davranıştır.
Bu adım adım açıklamalı kılavuzda aşağıdakileri tamamlarsınız:
- Kullanıcı kimlik bilgilerimiz için kalıcı depolama uygulayın.
- Aşağıdaki eklenti sorgu parametrelerini alın ve değerlendirin:
login_hint: Oturum açan kullanıcının Google kimlik numarası.hd: Oturum açan kullanıcının alan adı.
Bunlardan yalnızca birinin gönderildiğini unutmayın. Classroom API, kullanıcı uygulamanızı HENÜZ YETKİLEMEdiyse hd parametresini gönderir. Aksi takdirde API, login_hint değerini gönderir. Sorgu parametrelerinin tam listesini iframe kılavuzu sayfasında bulabilirsiniz.
İşlem tamamlandığında, web uygulamanızda kullanıcıları tam olarak yetkilendirebilir ve Google API'lerine çağrı gönderebilirsiniz.
iframe sorgu parametrelerini anlama
Classroom, açıldıktan sonra eklentinizin Ek Kurulumu URI'sını yükler. Classroom, URI'ye çeşitli GET sorgu parametreleri ekler. Bu parametreler, içeriğe dayalı faydalı bilgiler içerir. Örneğin, Ek Keşfi URI'nız https://example.com/addon ise Classroom, kaynak URL'si https://example.com/addon?courseId=XXX&postId=YYY&addOnToken=ZZZ olarak ayarlanmış iframe'i oluşturur. Burada XXX, YYY ve ZZZ dize kimlikleridir. Bu senaryonun ayrıntılı açıklaması için iframe'ler kılavuzuna bakın.
Keşif URL'si için beş olası sorgu parametresi vardır:
courseId: Mevcut Classroom dersinin kimliği.postId: Kullanıcının düzenlediği veya oluşturduğu ödev yayınının kimliği.addOnToken: Belirli Classroom eklentisi işlemlerini yetkilendirmek için kullanılan bir jeton.login_hint: Geçerli kullanıcının Google Kimliği.hd: Geçerli kullanıcının ana makine alan adı (ör.example.com).
Bu adım adım açıklamalı kılavuzda hd ve login_hint ele alınmaktadır. Kullanıcılar, sağlanan sorgu parametresine göre (hd) yetkilendirme akışına veya login_hint durumunda eklenti keşif sayfasına yönlendirilir.
Sorgu parametrelerine erişme
Yukarıda açıklandığı gibi, sorgu parametreleri web uygulamanıza URI dizesinde iletilir. Bu değerleri oturumunuzda depolayın. Bunlar yetkilendirme akışında ve kullanıcı hakkındaki bilgileri depolayıp almak için kullanılır. Bu sorgu parametreleri yalnızca eklenti ilk açıldığında iletilir.
Python
Flask rotalarınızın tanımlarına gidin (verdiğimiz örneği izliyorsanız routes.py). Eklenti açılış rotanızın en üstünde (sağladığımız örnekte /classroom-addon) login_hint ve hd sorgu parametrelerini alın ve depolayın:
# Retrieve the login_hint and hd query parameters.
login_hint = flask.request.args.get("login_hint")
hd = flask.request.args.get("hd")
Oturumda login_hint ve hd verilerinin depolandığından emin olun. Burası bu değerleri depolamak için uygun bir yerdir; geçicidir ve eklenti açıldığında yeni değerler alırsınız.
# 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
Denetleyici sınıfınızdaki eklenti açılış rotasına gidin (sağlanan örnekte AuthController.java içindeki /addon-discovery). Bu rotanın başında, login_hint ve hd sorgu parametrelerini alın ve depolayın.
/** Retrieve the login_hint or hd query parameters from the request URL. */
String login_hint = request.getParameter("login_hint");
String hd = request.getParameter("hd");
Oturumda login_hint ve hd verilerinin depolandığından emin olun. Burası bu değerleri depolamak için uygun bir yerdir; geçicidir ve eklenti açıldığında yeni değerler alırsınız.
/** 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);
}
Sorgu parametrelerini yetkilendirme akışına ekleme
login_hint ve hd parametreleri de Google'ın kimlik doğrulama sunucularına iletilmelidir. Bunlar, kimlik doğrulama işlemini kolaylaştırır. Uygulamanız hangi kullanıcının kimlik doğrulaması yapmaya çalıştığını bilirse sunucu, bu ipucunu kullanarak oturum açma formundaki e-posta alanını önceden doldurarak giriş akışını basitleştirir.
Python
Flask sunucusu dosyanızda (sağladığımız örnekte /authorize) yetkilendirme yoluna gidin. login_hint ve hd bağımsız değişkenlerini flow.authorization_url çağrısına ekleyin.
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
AuthService.java sınıfında authorize() yöntemine gidin. Yönteme parametre olarak login_hint ve hd, login_hint ve hd bağımsız değişkenlerini de yetkilendirme URL'si oluşturucuya ekleyin.
String authUrl = flow
.newAuthorizationUrl()
.setState(state)
.set("login_hint", login_hint)
.set("hd", hd)
.setRedirectUri(REDIRECT_URI)
.build();
Kullanıcı kimlik bilgileri için kalıcı depolama alanı ekleyin
Eklenti yüklendiğinde sorgu parametresi olarak login_hint kodunu almanız, kullanıcının uygulamamız için yetkilendirme akışını zaten tamamlamış olduğunu gösterir. Tekrar oturum açmaya zorlamak yerine önceki kimlik bilgilerini almanız gerekir.
Yetkilendirme akışının tamamlanmasının ardından bir yenileme jetonu aldığınızı unutmayın. Bu jetonu kaydedin. Kısa ömürlü ve Google API'lerinin kullanılması için gerekli olan bir erişim jetonu elde etmek için yeniden kullanılabilir. Bu kimlik bilgilerini daha önce oturumda kaydettiniz ancak yinelenen ziyaretleri işlemek için kimlik bilgilerini depolamanız gerekiyor.
Kullanıcı şemasını tanımlama ve veritabanını ayarlama
User için veritabanı şeması ayarlayın.
Python
Kullanıcı şemasını tanımlama
User aşağıdaki özellikleri içerir:
id: Kullanıcının Google kimliği. Bu,login_hintsorgu parametresinde sağlanan değerlerle eşleşmelidir.display_name: Kullanıcının adı ve soyadı (ör. "Ali Demir").email: Kullanıcının e-posta adresi.portrait_url: Kullanıcının profil resminin URL'si.refresh_token: Önceden alınan yenileme jetonu.
Bu örnekte, depolama alanı Python tarafından yerel olarak desteklenen SQLite kullanılarak uygulanır. Veritabanı yönetimimizi kolaylaştırmak için flask_sqlalchemy modülünü kullanır.
Veritabanını kurma
İlk olarak veritabanımız için bir dosya konumu belirtin. Sunucu yapılandırma dosyanıza (sağladığımız örnekte config.py) gidin ve aşağıdakini ekleyin.
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
Bu işlem, Flask'ı main.py dosyanızla aynı dizinde bulunan data.sqlite dosyasına yönlendirir.
Ardından, modül dizininize gidin ve yeni bir models.py dosyası oluşturun.
Verdiğimiz örneği takip ediyorsanız bu: webapp/models.py. User tablosunu tanımlamak için aşağıdaki kodu yeni dosyaya ekleyin. Farklıysa modül adınızı webapp ile değiştirin.
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())
Son olarak, yeni modelleri içe aktarmak ve veritabanını oluşturmak için modülünüzün __init__.py dosyasına aşağıdakileri ekleyin.
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
Kullanıcı şemasını tanımlama
User aşağıdaki özellikleri içerir:
id: Kullanıcının Google kimliği. Bu değer,login_hintsorgu parametresinde sağlanan değerle eşleşmelidir.email: Kullanıcının e-posta adresi.
Modülün resources dizininde bir schema.sql dosyası oluşturun. Spring bu dosyayı okur ve buna göre veritabanı için bir şema oluşturur.
Tabloyu User özelliklerini (id ve email) temsil edecek bir tablo adı, users ve sütunlarla tanımlayın.
CREATE TABLE IF NOT EXISTS users (
id VARCHAR(255) PRIMARY KEY, -- user's unique Google ID
email VARCHAR(255), -- user's email address
);
Veritabanı için User modelini tanımlamak üzere bir Java sınıfı oluşturun. Sağlanan örnekte User.java.
Bunun veritabanına kaydedilebilecek bir POJO olduğunu belirtmek için @Entity ek açıklamasını ekleyin. @Table ek açıklamasını, schema.sql sayfasında yapılandırdığınız ilgili tablo adıyla ekleyin.
Kod örneğinin bu iki özellik için kurucular ve belirleyiciler içerdiğini unutmayın. AuthController.java aracında, veritabanında kullanıcı oluşturmak veya kullanıcı güncellemek için kurucu ve belirleyiciler kullanılır. Uygun gördüğünüz şekilde alıcılar ve bir toString yöntemi de ekleyebilirsiniz ancak bu adım adım açıklamalı kılavuzda bu yöntemler kullanılmamaktadır ve kısa olması için bu sayfadaki kod örneğinden çıkarılmıştır.
/** 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; }
}
CRUD işlemlerini veritabanına taşımak için UserRepository.java adlı bir arayüz oluşturun. Bu arayüz, CrudRepository arayüzünü genişletir.
/** Provides CRUD operations for the User class by extending the
* CrudRepository interface. */
@Repository
public interface UserRepository extends CrudRepository<User, String> {
}
Denetleyici sınıfı, istemci ile depo arasındaki iletişimi kolaylaştırır. Bu nedenle, UserRepository sınıfını eklemek için denetleyici sınıfı oluşturucuyu güncelleyin.
/** 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;
}
Veritabanını kurma
Kullanıcı ile ilgili bilgileri depolamak için Spring Boot'ta yerleşik olarak desteklenen bir H2 veritabanı kullanın. Bu veritabanı, Classroom ile ilgili diğer bilgilerin depolanması için sonraki adım adım açıklamalı kılavuzlarda da kullanılır. H2 veritabanını kurmak için aşağıdaki yapılandırmanın application.properties ürününe eklenmesi gerekir.
# 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
spring.datasource.url yapılandırması, userdb dosyasının içinde depolandığı h2 adlı bir dizin oluşturur. H2 veritabanının yolunu .gitignore öğesine ekleyin. Veritabanını istediğiniz bir kullanıcı adı ve şifreyle ayarlamak için uygulamayı çalıştırmadan önce spring.datasource.username ve spring.datasource.password değerlerini güncellemeniz gerekir. Uygulamayı çalıştırdıktan sonra veritabanının kullanıcı adını ve şifresini güncellemek için oluşturulan h2 dizinini silin, yapılandırmayı güncelleyin ve uygulamayı yeniden çalıştırın.
spring.jpa.hibernate.ddl-auto yapılandırmasının update olarak ayarlanması, uygulama yeniden başlatıldığında veritabanında depolanan verilerin korunmasını sağlar.
Uygulama her yeniden başlatıldığında veritabanını temizlemek için bu yapılandırmayı create olarak ayarlayın.
spring.jpa.open-in-view yapılandırmasını false olarak ayarlayın. Bu yapılandırma varsayılan olarak etkindir ve üretimde teşhis edilmesi zor performans sorunlarına neden olduğu bilinebilir.
Daha önce açıklandığı gibi, tekrarlanan bir kullanıcının kimlik bilgilerini alabilmeniz gerekir. Bu, GoogleAuthorizationCodeFlow tarafından sunulan yerleşik kimlik bilgisi deposu desteği ile sağlanır.
AuthService.java sınıfında, kimlik bilgisi sınıfının depolandığı dosyanın yolunu tanımlayın. Bu örnekte dosya /credentialStore dizininde oluşturulmuştur. Kimlik bilgisi deposunun yolunu .gitignore öğesine ekleyin. Bu dizin, kullanıcı yetkilendirme akışını başlattıktan sonra oluşturulur.
private static final File dataDirectory = new File("credentialStore");
Daha sonra, AuthService.java dosyasında FileDataStoreFactory nesnesi oluşturup döndüren bir yöntem oluşturun. Kimlik bilgilerini depolayan veri deposudur.
/** 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;
}
AuthService.java öğesindeki getFlow() yöntemini, GoogleAuthorizationCodeFlow Builder() yöntemine setDataStoreFactory içerecek şekilde güncelleyin ve veri deposunu ayarlamak için getCredentialDataStore() yöntemini çağırın.
GoogleAuthorizationCodeFlow authorizationCodeFlow =
new GoogleAuthorizationCodeFlow.Builder(
HTTP_TRANSPORT,
JSON_FACTORY,
getClientSecrets(),
getScopes())
.setAccessType("offline")
.setDataStoreFactory(getCredentialDataStore())
.build();
Daha sonra, getAndSaveCredentials(String authorizationCode) yöntemini güncelleyin.
Daha önce bu yöntem kimlik bilgilerini herhangi bir yerde depolamadan elde ediyordu. Kimlik bilgilerini, kullanıcı kimliği tarafından dizine eklenen veri deposunda depolamak için yöntemi güncelleyin.
Kullanıcı kimliği, id_token kullanılarak TokenResponse nesnesinden alınabilir ancak önce bu kimliğin doğrulanması gerekir. Aksi takdirde, istemci uygulamaları, değiştirilmiş kullanıcı kimliklerini sunucuya göndererek kullanıcıların kimliğine bürünebilir. id_token özelliğini doğrulamak için Google API İstemci kitaplıklarını kullanmanız önerilir. Daha fazla bilgi için [Google kimliği jetonunu doğrulama hakkındaki Google Identity sayfasına] bakın.
// 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.");
}
id_token doğrulandıktan sonra, alınan kimlik bilgileriyle birlikte depolamak için userId öğesini edinin.
// Obtain the user id from the id_token.
Payload payload = idToken.getPayload();
String userId = payload.getSubject();
Çağrıyı, userId içerecek şekilde flow.createAndStoreCredential olarak güncelleyin.
// Save the user id and credentials to the configured FileDataStoreFactory.
Credential credential = flow.createAndStoreCredential(tokenResponse, userId);
AuthService.java sınıfına, veri deposunda mevcut olan belirli bir kullanıcının kimlik bilgilerini döndüren bir yöntem ekleyin.
/** 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;
}
}
Kimlik bilgilerini alma
Users getirmek için bir yöntem tanımlayın. login_hint sorgu parametresinde size belirli bir kullanıcı kaydını almak için kullanabileceğiniz bir id verilir.
Python
def get_credentials_from_storage(id):
"""
Retrieves credentials from the storage and returns them as a dictionary.
"""
return User.query.get(id)
Java
AuthController.java sınıfında, bir kullanıcıyı kullanıcı kimliğine göre veritabanından almak için bir yöntem tanımlayın.
/** 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;
}
Mağaza kimlik bilgileri
Kimlik bilgilerini depolarken iki senaryo mevcuttur. Kullanıcının id değeri zaten veritabanındaysa mevcut kaydı yeni değerlerle güncelleyin. Aksi takdirde yeni bir User kaydı oluşturun ve bu kaydı veritabanına ekleyin.
Python
Öncelikle, depolama veya güncelleme davranışını uygulayan bir yardımcı program yöntemi tanımlayın.
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()
Kimlik bilgilerini veritabanınıza kaydedebileceğiniz iki örnek vardır: kullanıcı, yetkilendirme akışının sonunda uygulamanıza geri döndüğünde ve bir API çağrısı gönderilirken. Önceden oturum credentials anahtarını buralarda ayarlıyorduk.
callback rotanızın sonunda save_user_credentials numaralı telefonu arayın. Kullanıcının adını çıkarmak yerine user_info nesnesini saklayın.
# 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)
API'ye yapılan çağrıların ardından kimlik bilgilerini de güncellemeniz gerekir. Bu durumda, güncellenen kimlik bilgilerini save_user_credentials yönteminin bağımsız değişkeni olarak sağlayabilirsiniz.
# Save credentials in case access token was refreshed.
flask.session["credentials"] = credentials_to_dict(credentials)
save_user_credentials(credentials)
Java
Öncelikle H2 veritabanında bir User nesnesini depolayan veya güncelleyen bir yöntem tanımlayın.
/** 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);
}
}
Kimlik bilgilerini veritabanınıza kaydedebileceğiniz iki örnek vardır: kullanıcı, yetkilendirme akışının sonunda uygulamanıza geri döndüğünde ve bir API çağrısı gönderilirken. Önceden oturum credentials anahtarını buralarda ayarlıyorduk.
/callback rotasının sonunda saveUser numaralı telefonu arayın. Kullanıcının e-postasını çıkarmak yerine user_info nesnesini saklamalısınız.
/** 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);
API'ye yapılan çağrıların ardından kimlik bilgilerini de güncellemeniz gerekir. Bu durumda, güncellenen kimlik bilgilerini saveUser yönteminin bağımsız değişkeni olarak sağlayabilirsiniz.
/** Save credentials in case access token was refreshed. */
saveUser(credentials, null, session);
Süresi dolmuş kimlik bilgileri
Yenileme jetonlarının geçersiz hale gelmesinin birkaç nedeni olabileceğini unutmayın. Bunlardan bazıları:
- Yenileme jetonu altı aydır kullanılmamıştır.
- Kullanıcı, uygulamanızın erişim izinlerini iptal eder.
- Kullanıcı şifreleri değiştirir.
- Kullanıcı, geçerli oturum kontrolü politikaları olan bir Google Cloud kuruluşunda yer almaktadır.
Kimlik bilgilerinin geçersiz hale gelmesi durumunda kullanıcıyı yetkilendirme akışından tekrar göndererek yeni jetonlar edinin.
Kullanıcıyı otomatik olarak yönlendir
Kullanıcının daha önce uygulamamıza yetki verip vermediğini tespit etmek için eklentinin açılış rotasını değiştirin. Varsa, bunları ana eklenti sayfamıza yönlendirin. Aksi takdirde, oturum açmalarını isteyin.
Python
Uygulama başlatıldığında veritabanı dosyasının oluşturulduğundan emin olun. Aşağıdaki komutu bir modül başlatıcıya (sağladığımız örnekte webapp/__init__.py gibi) veya sunucuyu başlatan ana yönteme ekleyin.
# Initialize the database file if not created.
if not os.path.exists(DATABASE_FILE_NAME):
db.create_all()
Daha sonra yönteminiz, login_hint ve hd sorgu parametrelerini yukarıda açıklandığı gibi işlemelidir. Ardından, bu ziyaretçi tekrar gelen bir kullanıcıysa mağaza kimlik bilgilerini yükleyin. login_hint ziyaret edenlerin tekrar gelen ziyaretçi olduğunu anlarsınız.
Bu kullanıcı için depolanan kimlik bilgilerini alın ve oturuma yükleyin.
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
Son olarak, kullanıcı kimlik bilgilerine sahip değilsek kullanıcıyı oturum açma sayfasına yönlendirin. Bu durumda, bunları ana eklenti sayfasına yönlendirin.
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
Eklentinizin açılış rotasına gidin (sağlanan örnekte /addon-discovery). Yukarıda açıklandığı gibi, login_hint ve hd sorgu parametrelerini burada işlediniz.
Öncelikle oturumda kimlik bilgilerinin mevcut olup olmadığını kontrol edin. Aksi takdirde startAuthFlow yöntemini çağırarak kullanıcıyı kimlik doğrulama akışına yönlendirin.
/** 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);
}
Ardından, tekrar gelen bir ziyaretçiyse kullanıcıyı H2 veritabanından yükleyin. login_hint sorgu parametresini alırsanız bu, tekrar gelen ziyaretçidir. Kullanıcı H2 veritabanında bulunuyorsa daha önce ayarlanan kimlik bilgisi veri deposundan kimlik bilgilerini yükleyin ve oturumda kimlik bilgilerini ayarlayın. Kimlik bilgileri, kimlik bilgisi veri deposundan alınmadıysa startAuthFlow yöntemini çağırarak kullanıcıyı kimlik doğrulama akışına yönlendirin.
/** 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);
}
}
Son olarak, kullanıcıyı eklentinin açılış sayfasına yönlendirin.
/** Finally, if there are credentials in the session and in persistent
* storage, direct the user to the addon-discovery page. */
return "addon-discovery";
Eklentiyi test etme
Google Classroom'da Öğretmen test kullanıcılarınızdan biri olarak oturum açın. Sınıf Çalışmaları sekmesine gidin ve yeni bir Ödev oluşturun. Metin alanının altındaki Eklentiler düğmesini tıklayın, ardından eklentinizi seçin. iframe açılır ve eklenti, GWM SDK'sının Uygulama Yapılandırması sayfasında belirttiğiniz Ek Kurulum URI'sı'nı yükler.
Tebrikler! Bir sonraki adıma (Ek oluşturma ve kullanıcı rolünü tanımlama) geçmeye hazırsınız.