Bu, Classroom eklentilerinin adım adım açıklamalı ikinci kılavuzudur.
Bu adım adım açıklamalı kılavuzda, web uygulamasına Google ile Oturum Açma özelliğini ekleyeceksiniz. Bu, Classroom eklentileri için gerekli bir davranıştır. Gelecekte API'ye yapılacak tüm çağrılar için bu yetkilendirme akışındaki kimlik bilgilerini kullanın.
Bu adım adım açıklamalı kılavuz kapsamında aşağıdaki işlemleri tamamlayacaksınız:
- Web uygulamanızı, iFrame içindeki oturum verilerini koruyacak şekilde yapılandırın.
- Google OAuth 2.0 sunucudan sunucuya oturum açma akışını uygulayın.
- OAuth 2.0 API'ye bir çağrı gönderin.
- API çağrılarını yetkilendirme, çıkış yapma ve test etme işlemlerini desteklemek için ek rotalar oluşturun.
İşlem tamamlandığında, web uygulamanızda kullanıcıları tam olarak yetkilendirebilir ve Google API'lerine çağrı gönderebilirsiniz.
Yetkilendirme akışını anlama
Google API'leri, kimlik doğrulama ve yetkilendirme için OAuth 2.0 protokolünü kullanır. Google'ın OAuth uygulamasının tam açıklamasını Google Identity OAuth kılavuzunda bulabilirsiniz.
Uygulamanızın kimlik bilgileri Google Cloud'da yönetilir. Bunlar oluşturulduktan sonra kullanıcının kimliğini doğrulamak ve yetkilendirmek için dört adımlı bir işlem uygulayın:
- Yetkilendirme isteyin. Bu isteğin bir parçası olarak bir geri çağırma URL'si sağlayın. Tamamlandığında bir yetkilendirme URL'si alırsınız.
- Kullanıcıyı yetkilendirme URL'sine yönlendirin. Açılan sayfa, kullanıcıyı uygulamanızın gerektirdiği izinler konusunda bilgilendirir ve erişim izni vermelerini ister. İşlem tamamlandığında, kullanıcı geri çağırma URL'sine yönlendirilir.
- Geri arama rotanızda bir yetkilendirme kodu alın. Yetkilendirme kodunu erişim jetonu ve yenileme jetonu ile değiştirin.
- Jetonları kullanarak bir Google API'sine çağrı yapmak.
OAuth 2.0 kimlik bilgilerini alma
OAuth kimlik bilgilerini Genel Bakış sayfasında açıklandığı şekilde oluşturup indirdiğinizden emin olun. Projenizde kullanıcının oturum açmak için bu kimlik bilgilerini kullanması gerekir.
Yetkilendirme akışını uygulama
Aşağıdaki özellikler de dahil olmak üzere açıklanan akışı gerçekleştirmek için web uygulamamıza mantık ve rotalar ekleyin:
- Açılış sayfasına eriştikten sonra yetkilendirme akışını başlatın.
- Yetkilendirme isteyin ve yetkilendirme sunucusu yanıtını işleyin.
- Depolanmış kimlik bilgilerini temizleyin.
- Uygulamanın izinlerini iptal edin.
- API çağrısı test etme.
Yetkilendirmeyi başlat
Gerekirse açılış sayfanızı yetkilendirme akışını başlatacak şekilde değiştirin. Eklentinin iki durumu olabilir: geçerli oturumda kaydedilmiş jetonlar vardır veya OAuth 2.0 sunucusundan jeton almanız gerekir. Oturumda jetonlar varsa bir test API çağrısı gerçekleştirin veya kullanıcıdan başka bir şekilde oturum açmasını isteyin.
Python
routes.py dosyanızı açın. Öncelikle birkaç sabit değer ve çerez yapılandırmamızı iframe güvenlik önerilerine göre ayarlayın.
# The file that contains the OAuth 2.0 client_id and client_secret.
CLIENT_SECRETS_FILE = "client_secret.json"
# The OAuth 2.0 access scopes to request.
# These scopes must match the scopes in your Google Cloud project's OAuth Consent
# Screen: https://console.cloud.google.com/apis/credentials/consent
SCOPES = [
"openid",
"https://www.googleapis.com/auth/userinfo.profile",
"https://www.googleapis.com/auth/userinfo.email",
"https://www.googleapis.com/auth/classroom.addons.teacher",
"https://www.googleapis.com/auth/classroom.addons.student"
]
# Flask cookie configurations.
app.config.update(
SESSION_COOKIE_SECURE=True,
SESSION_COOKIE_HTTPONLY=True,
SESSION_COOKIE_SAMESITE="None",
)
Eklenti açılış rotanıza gidin (örnek dosyada /classroom-addon yeridir). Oturumda "kimlik bilgileri" anahtarı yoksa oturum açma sayfası oluşturmak için bir mantık ekleyin.
@app.route("/classroom-addon")
def classroom_addon():
if "credentials" not in flask.session:
return flask.render_template("authorization.html")
return flask.render_template(
"addon-discovery.html",
message="You've reached the addon discovery page.")
Java
Bu adım adım açıklamalı kılavuzun kodunu step_02_sign_in modülünde bulabilirsiniz.
application.properties dosyasını açın ve iframe güvenlik önerilerine uygun oturum yapılandırmasını ekleyin.
# iFrame security recommendations call for cookies to have the HttpOnly and
# secure attribute set
server.servlet.session.cookie.http-only=true
server.servlet.session.cookie.secure=true
# Ensures that the session is maintained across the iframe and sign-in pop-up.
server.servlet.session.cookie.same-site=none
Denetleyici dosyasındaki uç noktaların arkasındaki mantığı işlemek için bir hizmet sınıfı (step_02_sign_in modülünde AuthService.java) oluşturun ve yönlendirme URI'sini, istemci gizli anahtarı dosyasının konumunu ve eklentinizin gerektirdiği kapsamları ayarlayın. Yönlendirme URI'si, kullanıcılarınızı uygulamanızı yetkilendirdikten sonra belirli bir URI'ya yeniden yönlendirmek için kullanılır. client_secret.json dosyanızı nereye yerleştireceğinizle ilgili bilgi için kaynak koddaki README.md'ın Proje Kurulumu bölümüne bakın.
@Service
public class AuthService {
private static final String REDIRECT_URI = "https://localhost:5000/callback";
private static final String CLIENT_SECRET_FILE = "client_secret.json";
private static final HttpTransport HTTP_TRANSPORT = new NetHttpTransport();
private static final JsonFactory JSON_FACTORY = GsonFactory.getDefaultInstance();
private static final String[] REQUIRED_SCOPES = {
"https://www.googleapis.com/auth/userinfo.profile",
"https://www.googleapis.com/auth/userinfo.email",
"https://www.googleapis.com/auth/classroom.addons.teacher",
"https://www.googleapis.com/auth/classroom.addons.student"
};
/** Creates and returns a Collection object with all requested scopes.
* @return Collection of scopes requested by the application.
*/
public static Collection<String> getScopes() {
return new ArrayList<>(Arrays.asList(REQUIRED_SCOPES));
}
}
Denetleyici dosyasını (step_02_sign_in modülünde AuthController.java) açın ve oturumda credentials anahtarı yoksa oturum açma sayfasını oluşturmak için açılış rotasına mantık ekleyin.
@GetMapping(value = {"/start-auth-flow"})
public String startAuthFlow(Model model) {
try {
return "authorization";
} catch (Exception e) {
return onError(e.getMessage(), model);
}
}
@GetMapping(value = {"/addon-discovery"})
public String addon_discovery(HttpSession session, Model model) {
try {
if (session == null || session.getAttribute("credentials") == null) {
return startAuthFlow(model);
}
return "addon-discovery";
} catch (Exception e) {
return onError(e.getMessage(), model);
}
}
Yetkilendirme sayfanız, kullanıcının "oturum açması" için bir bağlantı veya düğme içermelidir. Bu düğme tıklandığında kullanıcı authorize yönlendirmesine yönlendirilir.
Yetkilendirme isteyin
Yetkilendirme istemek için kullanıcıyı oluşturun ve bir kimlik doğrulama URL'sine yönlendirin. Bu URL'de istenen kapsamlar, yetkilendirme sonrası için hedef rota ve web uygulamasının istemci kimliği gibi çeşitli bilgiler bulunur. Bunları bu örnek yetkilendirme URL'sinde görebilirsiniz.
Python
routes.py dosyanıza aşağıdaki içe aktarmayı ekleyin.
import google_auth_oauthlib.flow
Yeni bir rota oluşturun: /authorize. google_auth_oauthlib.flow.Flow örneği oluşturun. Bunun için dahil edilen from_client_secrets_file yöntemini kullanmanızı önemle tavsiye ederiz.
@app.route("/authorize")
def authorize():
# Create flow instance to manage the OAuth 2.0 Authorization Grant Flow
# steps.
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
CLIENT_SECRETS_FILE, scopes=SCOPES)
flow öğesinin redirect_uri değerini ayarlayın. Bu, kullanıcıların uygulamanızı yetkilendirdikten sonra geri dönmesini istediğiniz rotadır. Bu, aşağıdaki örnekte /callback olarak belirlenmiştir.
# The URI created here must exactly match one of the authorized redirect
# URIs for the OAuth 2.0 client, which you configured in the API Console. If
# this value doesn't match an authorized URI, you will get a
# "redirect_uri_mismatch" error.
flow.redirect_uri = flask.url_for("callback", _external=True)
authorization_url ve state oluşturmak için akış nesnesini kullanın. state öğesini oturumda depolayın. Daha sonra sunucu yanıtının gerçekliğini doğrulamak için kullanılır. Son olarak, kullanıcıyı authorization_url öğesine yönlendirin.
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")
# Store the state so the callback can verify the auth server response.
flask.session["state"] = state
# Redirect the user to the OAuth authorization URL.
return flask.redirect(authorization_url)
Java
Akış nesnesini örneklendirmek için AuthService.java dosyasına aşağıdaki yöntemleri ekleyin ve ardından, yetkilendirme URL'sini almak için bu yöntemleri kullanın:
getClientSecrets()yöntemi, istemci gizli anahtar dosyasını okur ve birGoogleClientSecretsnesnesi oluşturur.getFlow()yöntemi,GoogleAuthorizationCodeFlowöğesinin bir örneğini oluşturur.authorize()yöntemi, yetkilendirme URL'sini almak içinGoogleAuthorizationCodeFlownesnesini,stateparametresini ve yönlendirme URI'sini kullanır.stateparametresi, yetkilendirme sunucusundan gelen yanıtın özgünlüğünü doğrulamak için kullanılır. Daha sonra yöntem, yetkilendirme URL'si vestateparametresini içeren bir eşleme döndürür.
/** Reads the client secret file downloaded from Google Cloud.
* @return GoogleClientSecrets read in from client secret file. */
public GoogleClientSecrets getClientSecrets() throws Exception {
try {
InputStream in = SignInApplication.class.getClassLoader()
.getResourceAsStream(CLIENT_SECRET_FILE);
if (in == null) {
throw new FileNotFoundException("Client secret file not found: "
+ CLIENT_SECRET_FILE);
}
GoogleClientSecrets clientSecrets = GoogleClientSecrets
.load(JSON_FACTORY, new InputStreamReader(in));
return clientSecrets;
} catch (Exception e) {
throw e;
}
}
/** Builds and returns authorization code flow.
* @return GoogleAuthorizationCodeFlow object used to retrieve an access
* token and refresh token for the application.
* @throws Exception if reading client secrets or building code flow object
* is unsuccessful.
*/
public GoogleAuthorizationCodeFlow getFlow() throws Exception {
try {
GoogleAuthorizationCodeFlow authorizationCodeFlow =
new GoogleAuthorizationCodeFlow.Builder(
HTTP_TRANSPORT,
JSON_FACTORY,
getClientSecrets(),
getScopes())
.setAccessType("offline")
.build();
return authorizationCodeFlow;
} catch (Exception e) {
throw e;
}
}
/** Builds and returns a map with the authorization URL, which allows the
* user to give the app permission to their account, and the state parameter,
* which is used to prevent cross site request forgery.
* @return map with authorization URL and state parameter.
* @throws Exception if building the authorization URL is unsuccessful.
*/
public HashMap authorize() throws Exception {
HashMap<String, String> authDataMap = new HashMap<>();
try {
String state = new BigInteger(130, new SecureRandom()).toString(32);
authDataMap.put("state", state);
GoogleAuthorizationCodeFlow flow = getFlow();
String authUrl = flow
.newAuthorizationUrl()
.setState(state)
.setRedirectUri(REDIRECT_URI)
.build();
String url = authUrl;
authDataMap.put("url", url);
return authDataMap;
} catch (Exception e) {
throw e;
}
}
Denetleyici sınıfında hizmet sınıfının bir örneğini oluşturmak için oluşturucu yerleştirmeyi kullanın.
/** Declare AuthService to be used in the Controller class constructor. */
private final AuthService authService;
/** AuthController constructor. Uses constructor injection to instantiate
* the AuthService and UserRepository classes.
* @param authService the service class that handles the implementation logic
* of requests.
*/
public AuthController(AuthService authService) {
this.authService = authService;
}
/authorize uç noktasını denetleyici sınıfına ekleyin. Bu uç nokta, state parametresini ve yetkilendirme URL'sini almak için AuthService authorize() yöntemini kullanır. Ardından, uç nokta state parametresini oturumda depolar ve kullanıcıları yetkilendirme URL'sine yönlendirir.
/** Redirects the sign-in pop-up to the authorization URL.
* @param response the current response to pass information to.
* @param session the current session.
* @throws Exception if redirection to the authorization URL is unsuccessful.
*/
@GetMapping(value = {"/authorize"})
public void authorize(HttpServletResponse response, HttpSession session)
throws Exception {
try {
HashMap authDataMap = authService.authorize();
String authUrl = authDataMap.get("url").toString();
String state = authDataMap.get("state").toString();
session.setAttribute("state", state);
response.sendRedirect(authUrl);
} catch (Exception e) {
throw e;
}
}
Sunucu yanıtını işleme
Yetki verildikten sonra kullanıcı önceki adımdan redirect_uri rotasına döner. Yukarıdaki örnekte, bu rota /callback şeklindedir.
Kullanıcı yetkilendirme sayfasından döndüğünde yanıtta bir code alırsınız. Ardından, kodu erişim ve yenileme jetonlarıyla değiştirin:
Python
Aşağıdaki içe aktarmaları Flask sunucusu dosyanıza ekleyin.
import google.oauth2.credentials
import googleapiclient.discovery
Yolu sunucunuza ekleyin. Başka bir google_auth_oauthlib.flow.Flow örneği oluşturun. Ancak bu kez, önceki adımda kaydedilen durumu tekrar kullanın.
@app.route("/callback")
def callback():
state = flask.session["state"]
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
flow.redirect_uri = flask.url_for("callback", _external=True)
Ardından, erişim izni isteyin ve jetonları yenileyin. Neyse ki flow nesnesi, bunu başarmak için fetch_token yöntemini de içeriyor. Yöntem, code veya authorization_response bağımsız değişkenlerinin olmasını bekler. İstekteki tam URL olduğu için authorization_response öğesini kullanın.
authorization_response = flask.request.url
flow.fetch_token(authorization_response=authorization_response)
Artık tüm kimlik bilgilerine sahipsiniz. Başka yöntem veya rotalardan alınabilmesi için bunları oturumda depolayın ve ardından bir eklenti açılış sayfasına yönlendirin.
credentials = flow.credentials
flask.session["credentials"] = {
"token": credentials.token,
"refresh_token": credentials.refresh_token,
"token_uri": credentials.token_uri,
"client_id": credentials.client_id,
"client_secret": credentials.client_secret,
"scopes": credentials.scopes
}
# Close the pop-up by rendering an HTML page with a script that redirects
# the owner and closes itself. This can be done with a bit of JavaScript:
# <script>
# window.opener.location.href = "{{ url_for('classroom_addon') }}";
# window.close();
# </script>
return flask.render_template("close-me.html")
Java
Yetkilendirme URL'sinin gerçekleştirdiği yönlendirmeden alınan yetkilendirme kodunu ileterek hizmet sınıfınıza Credentials nesnesini döndüren bir yöntem ekleyin. Bu Credentials nesnesi daha sonra erişim jetonunu almak ve yenileme jetonunu almak için kullanılır.
/** Returns the required credentials to access Google APIs.
* @param authorizationCode the authorization code provided by the
* authorization URL that's used to obtain credentials.
* @return the credentials that were retrieved from the authorization flow.
* @throws Exception if retrieving credentials is unsuccessful.
*/
public Credential getAndSaveCredentials(String authorizationCode) throws Exception {
try {
GoogleAuthorizationCodeFlow flow = getFlow();
GoogleClientSecrets googleClientSecrets = getClientSecrets();
TokenResponse tokenResponse = flow.newTokenRequest(authorizationCode)
.setClientAuthentication(new ClientParametersAuthentication(
googleClientSecrets.getWeb().getClientId(),
googleClientSecrets.getWeb().getClientSecret()))
.setRedirectUri(REDIRECT_URI)
.execute();
Credential credential = flow.createAndStoreCredential(tokenResponse, null);
return credential;
} catch (Exception e) {
throw e;
}
}
Yönlendirme URI'niz için denetleyiciye bir uç nokta ekleyin. Yetkilendirme kodunu ve state parametresini istekten alın. Bu state parametresini oturumda depolanan state özelliğiyle karşılaştırın. Bunlar eşleşiyorsa yetkilendirme akışına devam edin. Eşleşmiyorlarsa
bir hata döndürürler.
Ardından AuthService getAndSaveCredentials yöntemini çağırın ve yetkilendirme kodunu parametre olarak iletin. Credentials nesnesini aldıktan sonra oturumda depolayın. Ardından, iletişim kutusunu kapatın ve kullanıcıyı
eklenti açılış sayfasına yönlendirin.
/** Handles the redirect URL to grant the application access to the user's
* account.
* @param request the current request used to obtain the authorization code
* and state parameter from.
* @param session the current session.
* @param response the current response to pass information to.
* @param model the Model interface to pass error information that's
* displayed on the error page.
* @return the close-pop-up template if authorization is successful, or the
* onError method to handle and display the error message.
*/
@GetMapping(value = {"/callback"})
public String callback(HttpServletRequest request, HttpSession session,
HttpServletResponse response, Model model) {
try {
String authCode = request.getParameter("code");
String requestState = request.getParameter("state");
String sessionState = session.getAttribute("state").toString();
if (!requestState.equals(sessionState)) {
response.setStatus(401);
return onError("Invalid state parameter.", model);
}
Credential credentials = authService.getAndSaveCredentials(authCode);
session.setAttribute("credentials", credentials);
return "close-pop-up";
} catch (Exception e) {
return onError(e.getMessage(), model);
}
}
API çağrısı test etme
Akış tamamlandıktan sonra artık Google API'lerine çağrı gönderebilirsiniz.
Örneğin, kullanıcının profil bilgilerini isteyebilirsiniz. Kullanıcının bilgilerini OAuth 2.0 API'den isteyebilirsiniz.
Python
OAuth 2.0 discovery API'si ile ilgili dokümanları okuyun. Doldurulan UserInfo nesnesini almak için bu API'yi kullanın.
# Retrieve the credentials from the session data and construct a
# Credentials instance.
credentials = google.oauth2.credentials.Credentials(
**flask.session["credentials"])
# Construct the OAuth 2.0 v2 discovery API library.
user_info_service = googleapiclient.discovery.build(
serviceName="oauth2", version="v2", credentials=credentials)
# Request and store the username in the session.
# This allows it to be used in other methods or in an HTML template.
flask.session["username"] = (
user_info_service.userinfo().get().execute().get("name"))
Java
Parametre olarak Credentials kullanıp UserInfo nesnesi oluşturan bir hizmet sınıfında yöntem oluşturun.
/** Obtains the Userinfo object by passing in the required credentials.
* @param credentials retrieved from the authorization flow.
* @return the Userinfo object for the currently signed-in user.
* @throws IOException if creating UserInfo service or obtaining the
* Userinfo object is unsuccessful.
*/
public Userinfo getUserInfo(Credential credentials) throws IOException {
try {
Oauth2 userInfoService = new Oauth2.Builder(
new NetHttpTransport(),
new GsonFactory(),
credentials).build();
Userinfo userinfo = userInfoService.userinfo().get().execute();
return userinfo;
} catch (Exception e) {
throw e;
}
}
Kullanıcının e-posta adresini gösteren denetleyiciye /test uç noktasını ekleyin.
/** Returns the test request page with the user's email.
* @param session the current session.
* @param model the Model interface to pass error information that's
* displayed on the error page.
* @return the test page that displays the current user's email or the
* onError method to handle and display the error message.
*/
@GetMapping(value = {"/test"})
public String test(HttpSession session, Model model) {
try {
Credential credentials = (Credential) session.getAttribute("credentials");
Userinfo userInfo = authService.getUserInfo(credentials);
String userInfoEmail = userInfo.getEmail();
if (userInfoEmail != null) {
model.addAttribute("userEmail", userInfoEmail);
} else {
return onError("Could not get user email.", model);
}
return "test";
} catch (Exception e) {
return onError(e.getMessage(), model);
}
}
Kimlik bilgilerini temizle
Bir kullanıcının kimlik bilgilerini geçerli oturumdan kaldırarak "temizleyebilirsiniz". Bu, eklenti açılış sayfasındaki yönlendirmeyi test etmenize olanak tanır.
Kullanıcıları eklenti açılış sayfasına yönlendirmeden önce, kullanıcının oturumunu kapattığına dair bir gösterge göstermenizi öneririz. Uygulamanız yeni kimlik bilgileri almak için yetkilendirme akışından geçmelidir ancak kullanıcılardan uygulamanızı yeniden yetkilendirmeleri istenmez.
Python
@app.route("/clear")
def clear_credentials():
if "credentials" in flask.session:
del flask.session["credentials"]
del flask.session["username"]
return flask.render_template("signed-out.html")
Alternatif olarak flask.session.clear() kullanın ancak oturumda depolanan başka değerler varsa bunun istenmeyen etkileri olabilir.
Java
Denetleyicide bir /clear uç noktası ekleyin.
/** Clears the credentials in the session and returns the sign-out
* confirmation page.
* @param session the current session.
* @return the sign-out confirmation page.
*/
@GetMapping(value = {"/clear"})
public String clear(HttpSession session) {
try {
if (session != null && session.getAttribute("credentials") != null) {
session.removeAttribute("credentials");
}
return "sign-out";
} catch (Exception e) {
return onError(e.getMessage(), model);
}
}
Uygulamanın iznini iptal etme
Bir kullanıcı, https://oauth2.googleapis.com/revoke adresine POST isteği göndererek uygulamanızın iznini iptal edebilir. İstek, kullanıcının erişim jetonunu içermelidir.
Python
import requests
@app.route("/revoke")
def revoke():
if "credentials" not in flask.session:
return flask.render_template("addon-discovery.html",
message="You need to authorize before " +
"attempting to revoke credentials.")
credentials = google.oauth2.credentials.Credentials(
**flask.session["credentials"])
revoke = requests.post(
"https://oauth2.googleapis.com/revoke",
params={"token": credentials.token},
headers={"content-type": "application/x-www-form-urlencoded"})
if "credentials" in flask.session:
del flask.session["credentials"]
del flask.session["username"]
status_code = getattr(revoke, "status_code")
if status_code == 200:
return flask.render_template("authorization.html")
else:
return flask.render_template(
"index.html", message="An error occurred during revocation!")
Java
Hizmet sınıfına, iptal uç noktasına çağrı yapan bir yöntem ekleyin.
/** Revokes the app's permissions to the user's account.
* @param credentials retrieved from the authorization flow.
* @return response entity returned from the HTTP call to obtain response
* information.
* @throws RestClientException if the POST request to the revoke endpoint is
* unsuccessful.
*/
public ResponseEntity<String> revokeCredentials(Credential credentials) throws RestClientException {
try {
String accessToken = credentials.getAccessToken();
String url = "https://oauth2.googleapis.com/revoke?token=" + accessToken;
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.APPLICATION_FORM_URLENCODED_VALUE);
HttpEntity<Object> httpEntity = new HttpEntity<Object>(httpHeaders);
ResponseEntity<String> responseEntity = new RestTemplate().exchange(
url,
HttpMethod.POST,
httpEntity,
String.class);
return responseEntity;
} catch (RestClientException e) {
throw e;
}
}
İptal işlemi başarılı olursa oturumu temizleyen ve kullanıcıyı yetkilendirme sayfasına yönlendiren bir uç nokta (/revoke) ekleyin.
/** Revokes the app's permissions and returns the authorization page.
* @param session the current session.
* @return the authorization page.
* @throws Exception if revoking access is unsuccessful.
*/
@GetMapping(value = {"/revoke"})
public String revoke(HttpSession session) throws Exception {
try {
if (session != null && session.getAttribute("credentials") != null) {
Credential credentials = (Credential) session.getAttribute("credentials");
ResponseEntity responseEntity = authService.revokeCredentials(credentials);
Integer httpStatusCode = responseEntity.getStatusCodeValue();
if (httpStatusCode != 200) {
return onError("There was an issue revoking access: " +
responseEntity.getStatusCode(), model);
}
session.removeAttribute("credentials");
}
return startAuthFlow(model);
} catch (Exception e) {
return onError(e.getMessage(), model);
}
}
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 ve 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 Kurulumu URI'sini yükler.
Tebrikler! Sonraki adıma geçmeye hazırsınız: eklentinize yinelenen ziyaretleri yönetme.