ลงชื่อเข้าใช้ให้ผู้ใช้

นี่เป็นบทแนะนำที่ 2 ในชุดบทแนะนำส่วนเสริมของ Classroom

ในบทแนะนำนี้ คุณจะต้องเพิ่ม Google Sign-In ลงในเว็บแอปพลิเคชัน ซึ่งเป็นลักษณะการทำงานที่จำเป็นสำหรับส่วนเสริมของ Classroom ใช้ข้อมูลเข้าสู่ระบบจากขั้นตอนการให้สิทธิ์นี้สำหรับการเรียก API ทั้งหมดในอนาคต

ในระหว่างการแนะนำนี้ คุณจะทำสิ่งต่อไปนี้

  • กำหนดค่าเว็บแอปให้เก็บรักษาข้อมูลเซสชันภายใน iframe
  • ใช้ขั้นตอนการลงชื่อเข้าใช้แบบเซิร์ฟเวอร์ต่อเซิร์ฟเวอร์ของ Google OAuth 2.0
  • เรียกใช้ OAuth 2.0 API
  • สร้างเส้นทางเพิ่มเติมเพื่อรองรับการให้สิทธิ์ การออกจากระบบ และการทดสอบการเรียก API

เมื่อเสร็จแล้ว คุณจะให้สิทธิ์ผู้ใช้ในเว็บแอปได้อย่างเต็มรูปแบบและเรียกใช้ Google API ได้

ทำความเข้าใจขั้นตอนการกันวงเงินบัตรเครดิต/บัตรเดบิต

Google APIs ใช้โปรโตคอล OAuth 2.0 สำหรับการตรวจสอบสิทธิ์และการให้สิทธิ์ ดูคำอธิบายการใช้งาน OAuth ของ Google ฉบับเต็มได้ในคู่มือ OAuth ของ Google Identity

ข้อมูลเข้าสู่ระบบของแอปพลิเคชันจะจัดการใน Google Cloud เมื่อสร้างแล้ว ให้ใช้กระบวนการ 4 ขั้นตอนเพื่อตรวจสอบสิทธิ์และให้สิทธิ์ผู้ใช้ ดังนี้

  1. ขอสิทธิ์ ระบุ URL ติดต่อกลับเป็นส่วนหนึ่งของคำขอนี้ เมื่อดำเนินการเสร็จสิ้นแล้ว คุณจะได้รับ URL การให้สิทธิ์
  2. เปลี่ยนเส้นทางผู้ใช้ไปยัง URL การให้สิทธิ์ หน้าเว็บที่ปรากฏจะแจ้งให้ผู้ใช้ทราบถึงสิทธิ์ที่แอปของคุณจําเป็นต้องใช้ และแจ้งให้ผู้ใช้อนุญาตการเข้าถึง เมื่อดำเนินการเสร็จแล้ว ระบบจะเปลี่ยนเส้นทางผู้ใช้ไปยัง URL เรียกกลับ
  3. รับรหัสการให้สิทธิ์ในเส้นทางการติดต่อกลับ เปลี่ยนรหัสการให้สิทธิ์เป็นโทเค็นการเข้าถึงและโทเค็นการรีเฟรช
  4. เรียกใช้ Google API โดยใช้โทเค็น

รับข้อมูลเข้าสู่ระบบ OAuth 2.0

ตรวจสอบว่าคุณได้สร้างและดาวน์โหลดข้อมูลเข้าสู่ระบบ OAuth ตามที่อธิบายไว้ในหน้าภาพรวม โปรเจ็กต์ของคุณต้องใช้ข้อมูลเข้าสู่ระบบเหล่านี้เพื่อลงชื่อเข้าใช้ผู้ใช้

ใช้ขั้นตอนการให้สิทธิ์

เพิ่มตรรกะและเส้นทางลงในเว็บแอปของเราเพื่อทำให้ขั้นตอนที่อธิบายไว้เกิดขึ้นจริง รวมถึงฟีเจอร์ต่อไปนี้

  • เริ่มขั้นตอนการให้สิทธิ์เมื่อไปถึงหน้า Landing Page
  • ขอสิทธิ์และจัดการการตอบกลับของเซิร์ฟเวอร์การให้สิทธิ์
  • ล้างข้อมูลเข้าสู่ระบบที่เก็บไว้
  • เพิกถอนสิทธิ์ของแอป
  • ทดสอบการเรียก API

เริ่มการให้สิทธิ์

แก้ไขหน้า Landing Page เพื่อเริ่มขั้นตอนการให้สิทธิ์ หากจำเป็น ส่วนเสริมอาจมีสถานะได้ 2 สถานะ ได้แก่ มีโทเค็นที่บันทึกไว้ในเซสชันปัจจุบัน หรือคุณต้องรับโทเค็นจากเซิร์ฟเวอร์ OAuth 2.0 ทำการเรียก API ทดสอบหากมีโทเค็นในเซสชัน หรือแจ้งให้ผู้ใช้ลงชื่อเข้าใช้

Python

เปิดไฟล์ routes.py ก่อนอื่น ให้ตั้งค่าคงที่ 2-3 รายการและการกำหนดค่าคุกกี้ตามคําแนะนําด้านความปลอดภัยของ iframe

# 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",
)

ย้ายไปยังเส้นทางหน้า Landing Page ของส่วนเสริม (นี่คือ /classroom-addon ในไฟล์ตัวอย่าง) เพิ่มตรรกะเพื่อแสดงผลหน้าลงชื่อเข้าใช้หากเซสชันไม่มีคีย์ "credentials"

@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

โค้ดสําหรับการแนะนำแบบทีละขั้นตอนนี้อยู่ในโมดูล step_02_sign_in

เปิดไฟล์ application.properties แล้วเพิ่มการกําหนดค่าเซสชันที่เป็นไปตามคําแนะนําด้านความปลอดภัยของ iframe

# 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

สร้างคลาสบริการ (AuthService.java ในโมดูล step_02_sign_in) เพื่อจัดการตรรกะที่อยู่เบื้องหลังปลายทางในไฟล์คอนโทรลเลอร์ และตั้งค่า URI การเปลี่ยนเส้นทาง ตำแหน่งไฟล์ข้อมูลลับของไคลเอ็นต์ และขอบเขตที่จําเป็นสําหรับส่วนเสริม ระบบจะใช้ URI การเปลี่ยนเส้นทางเพื่อเปลี่ยนเส้นทางผู้ใช้ไปยัง URI ที่เจาะจงหลังจากที่ผู้ใช้ให้สิทธิ์แอปของคุณแล้ว ดูข้อมูลเกี่ยวกับตําแหน่งที่จะวางไฟล์ client_secret.json ได้ที่ส่วนการตั้งค่าโปรเจ็กต์ของ README.md ในซอร์สโค้ด

@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));
    }
}

เปิดไฟล์คอนโทรลเลอร์ (AuthController.java ในโมดูล step_02_sign_in) และเพิ่มตรรกะลงในเส้นทาง Landing Page เพื่อแสดงผลหน้าลงชื่อเข้าใช้หากเซสชันไม่มีคีย์ credentials

@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);
    }
}

หน้าการให้สิทธิ์ควรมีลิงก์หรือปุ่มให้ผู้ใช้ "ลงชื่อเข้าใช้" การคลิกนี้ควรเปลี่ยนเส้นทางผู้ใช้ไปยังเส้นทาง authorize

ส่งคำขอการให้สิทธิ์

หากต้องการขอสิทธิ์ ให้สร้างและเปลี่ยนเส้นทางผู้ใช้ไปยัง URL การตรวจสอบสิทธิ์ URL นี้มีข้อมูลหลายอย่าง เช่น ขอบเขตที่ขอ เส้นทางปลายทางสําหรับการให้สิทธิ์หลังการให้สิทธิ์ และรหัสไคลเอ็นต์ของเว็บแอป คุณดูข้อมูลเหล่านี้ได้ในตัวอย่าง URL การให้สิทธิ์นี้

Python

เพิ่มการนําเข้าต่อไปนี้ลงในไฟล์ routes.py

import google_auth_oauthlib.flow

สร้างเส้นทางใหม่ /authorize สร้างอินสแตนซ์ของ google_auth_oauthlib.flow.Flow เราขอแนะนําอย่างยิ่งให้ใช้เมธอด from_client_secrets_file ที่รวมมาด้วย

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

ตั้งค่า redirect_uri ของ flow ซึ่งเป็นเส้นทางที่คุณต้องการให้ผู้ใช้กลับมาหลังจากให้สิทธิ์แอป ในกรณีนี้ redirect_uri คือ /callback ในตัวอย่างต่อไปนี้

# 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 และ state จัดเก็บ state ในเซสชัน ซึ่งจะใช้เพื่อยืนยันความถูกต้องของการตอบกลับจากเซิร์ฟเวอร์ในภายหลัง สุดท้าย ให้เปลี่ยนเส้นทางผู้ใช้ไปยัง 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")

# 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

เพิ่มเมธอดต่อไปนี้ลงในไฟล์ AuthService.java เพื่อสร้างอินสแตนซ์ของออบเจ็กต์การเรียกใช้ฟีเจอร์ แล้วใช้เพื่อดึงข้อมูล URL การให้สิทธิ์

  • เมธอด getClientSecrets() จะอ่านไฟล์คีย์ลับไคลเอ็นต์และสร้างออบเจ็กต์ GoogleClientSecrets
  • เมธอด getFlow() สร้างอินสแตนซ์ของ GoogleAuthorizationCodeFlow
  • เมธอด authorize() ใช้ออบเจ็กต์ GoogleAuthorizationCodeFlow, พารามิเตอร์ state และ URI การเปลี่ยนเส้นทางเพื่อดึงข้อมูล URL การให้สิทธิ์ ระบบจะใช้พารามิเตอร์ state เพื่อยืนยันความถูกต้องของการตอบกลับจากเซิร์ฟเวอร์การให้สิทธิ์ จากนั้นเมธอดจะแสดงผลแผนที่ที่มี URL การให้สิทธิ์และพารามิเตอร์ state
/** 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;
    }
}

ใช้การฉีดคอนสตรัคเตอร์เพื่อสร้างอินสแตนซ์ของคลาสบริการในคลาสคอนโทรลเลอร์

/** 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 ลงในคลาสตัวควบคุม ปลายทางนี้จะเรียกใช้เมธอด authorize() ของ AuthService เพื่อดึงข้อมูลพารามิเตอร์ state และ URL การให้สิทธิ์ จากนั้นปลายทางจะจัดเก็บพารามิเตอร์ state ในเซสชันและเปลี่ยนเส้นทางผู้ใช้ไปยัง URL การให้สิทธิ์

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

จัดการการตอบกลับของเซิร์ฟเวอร์

หลังจากให้สิทธิ์แล้ว ผู้ใช้จะกลับไปที่เส้นทาง redirect_uri จากขั้นตอนก่อนหน้า ในตัวอย่างก่อนหน้านี้ เส้นทางนี้คือ /callback

คุณจะได้รับ code ในการตอบกลับเมื่อผู้ใช้กลับมาจากหน้าการให้สิทธิ์ จากนั้นเปลี่ยนรหัสเป็นโทเค็นการเข้าถึงและโทเค็นการรีเฟรชโดยทำดังนี้

Python

เพิ่มการนําเข้าต่อไปนี้ลงในไฟล์เซิร์ฟเวอร์ Flask

import google.oauth2.credentials
import googleapiclient.discovery

เพิ่มเส้นทางลงในเซิร์ฟเวอร์ สร้างอินสแตนซ์อื่นของ google_auth_oauthlib.flow.Flow แต่ครั้งนี้ให้ใช้สถานะที่บันทึกไว้ในขั้นตอนก่อนหน้าซ้ำ

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

จากนั้นขอโทเค็นการเข้าถึงและโทเค็นการรีเฟรช แต่โชคดีที่ออบเจ็กต์ flow ยังมีเมธอด fetch_token ที่ช่วยให้คุณดำเนินการนี้ได้ เมธอดต้องการอาร์กิวเมนต์ code หรือ authorization_response ใช้ authorization_response เนื่องจากเป็น URL แบบเต็มจากคําขอ

authorization_response = flask.request.url
flow.fetch_token(authorization_response=authorization_response)

ตอนนี้คุณมีข้อมูลเข้าสู่ระบบที่สมบูรณ์แล้ว จัดเก็บไว้ในเซสชันเพื่อให้เรียกข้อมูลด้วยวิธีหรือเส้นทางอื่นๆ ได้ จากนั้นเปลี่ยนเส้นทางไปยังหน้า Landing Page ของส่วนเสริม

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

เพิ่มเมธอดลงในคลาสบริการซึ่งแสดงผลออบเจ็กต์ Credentials โดยส่งรหัสการให้สิทธิ์ที่ดึงมาจากการเปลี่ยนเส้นทางที่ดำเนินการโดย URL การให้สิทธิ์ ระบบจะใช้ออบเจ็กต์ Credentials นี้ในภายหลังเพื่อดึงข้อมูลโทเค็นการเข้าถึงและโทเค็นการรีเฟรช

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

เพิ่มปลายทางสําหรับ URI การเปลี่ยนเส้นทางลงในตัวควบคุม เรียกข้อมูลรหัสการให้สิทธิ์และพารามิเตอร์ state จากคําขอ เปรียบเทียบพารามิเตอร์ state นี้กับแอตทริบิวต์ state ที่เก็บไว้ในเซสชัน หากตรงกัน ให้ดำเนินการตามขั้นตอนการให้สิทธิ์ต่อ หากไม่ตรงกัน ระบบจะแสดงข้อผิดพลาด

จากนั้นเรียกใช้เมธอด AuthService getAndSaveCredentials และส่งรหัสการให้สิทธิ์เป็นพารามิเตอร์ หลังจากดึงข้อมูลCredentials ออบเจ็กต์แล้ว ให้จัดเก็บไว้ในเซสชัน จากนั้นปิดกล่องโต้ตอบและเปลี่ยนเส้นทางผู้ใช้ไปยังหน้า Landing Page ของส่วนเสริม

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

เมื่อทำตามขั้นตอนเสร็จแล้ว คุณจะเรียกใช้ Google API ได้

เช่น ขอข้อมูลโปรไฟล์ของผู้ใช้ คุณสามารถขอข้อมูลผู้ใช้จาก OAuth 2.0 API ได้

Python

อ่านเอกสารประกอบของ OAuth 2.0 Discovery API ใช้เพื่อรับออบเจ็กต์ UserInfo ที่สร้างขึ้น

# 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

สร้างเมธอดในคลาสบริการที่สร้างออบเจ็กต์ UserInfo โดยใช้ Credentials เป็นพารามิเตอร์

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

เพิ่มปลายทาง /test ลงในตัวควบคุมที่แสดงอีเมลของผู้ใช้

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

ล้างข้อมูลรับรอง

คุณ "ล้าง" ข้อมูลเข้าสู่ระบบของผู้ใช้ได้โดยนำออกจากเซสชันปัจจุบัน ซึ่งจะช่วยให้คุณทดสอบการกำหนดเส้นทางในหน้า Landing Page ของส่วนเสริมได้

เราขอแนะนำให้แสดงตัวบ่งชี้ว่าผู้ใช้ออกจากระบบแล้วก่อนที่จะเปลี่ยนเส้นทางผู้ใช้ไปยังหน้า Landing Page ของส่วนเสริม แอปของคุณควรผ่านขั้นตอนการให้สิทธิ์เพื่อรับข้อมูลเข้าสู่ระบบใหม่ แต่ผู้ใช้จะไม่ได้รับการแจ้งให้ให้สิทธิ์แอปอีกครั้ง

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

หรือจะใช้ flask.session.clear() ก็ได้ แต่อาจส่งผลที่ไม่ตั้งใจหากคุณมีค่าอื่นๆ ที่จัดเก็บไว้ในเซสชัน

Java

ในตัวควบคุม ให้เพิ่มปลายทาง /clear

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

เพิกถอนสิทธิ์ของแอป

ผู้ใช้สามารถเพิกถอนสิทธิ์ของแอปได้โดยส่งคำขอ POST ไปยัง https://oauth2.googleapis.com/revoke คำขอควรมีโทเค็นการเข้าถึงของผู้ใช้

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

เพิ่มเมธอดลงในคลาสบริการที่เรียกใช้ปลายทางการเพิกถอน

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

เพิ่มปลายทาง /revoke ลงในตัวควบคุมที่จะล้างเซสชันและเปลี่ยนเส้นทางผู้ใช้ไปยังหน้าการให้สิทธิ์หากเพิกถอนสำเร็จ

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

ทดสอบส่วนเสริม

ลงชื่อเข้าใช้ Google Classroomในฐานะผู้ใช้ทดสอบที่เป็นครู ไปที่แท็บงานของชั้นเรียน แล้วสร้างงานใหม่ คลิกปุ่มส่วนเสริมใต้พื้นที่ข้อความ แล้วเลือกส่วนเสริม iframe จะเปิดขึ้นและส่วนเสริมจะโหลด URI การตั้งค่าไฟล์แนบที่คุณระบุไว้ในหน้าการกําหนดค่าแอปของ GWM SDK

ยินดีด้วย คุณพร้อมที่จะไปยังขั้นตอนถัดไป ซึ่งก็คือการจัดการกับการเข้าชมส่วนเสริมซ้ำ