Tekrarlanan girişleri yönetme

Python

Flask rotalarınızın tanımlarına gidin (sağladığımız örneği izliyorsanız routes.py). Eklenti açılış rotanızın (örnekteki /classroom-addon) en üstünde login_hint sorgu parametresini alıp saklayın:

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

login_hint (varsa) değerinin oturumda depolandığından emin olun. Bu değerler geçicidir ve eklenti açıldığında yeni değerler alırsınız. Bu nedenle, bu değerleri saklamak için uygun bir yerdir.

# 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

Denetleyici sınıfınızdaki eklenti açılış yoluna gidin (sağlam örnekte AuthController.java içindeki /addon-discovery). Bu rotanın başında login_hint sorgu parametresini alıp saklayın.

/** Retrieve the login_hint query parameter from the request URL if present. */
String login_hint = request.getParameter("login_hint");

login_hint (varsa) öğesinin oturumda depolandığından emin olun. Bu değerler geçicidir ve eklenti açıldığında yeni değerler alırsınız. Bu nedenle, bu değerleri saklamak için uygun bir yerdir.

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

Python

Flask sunucu dosyanızdaki yetkilendirme yoluna gidin (sağladığımız örnekte /authorize). flow.authorization_url çağrısına login_hint bağımsız değişkenini 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"),

Java

AuthService.java sınıfındaki authorize() yöntemine gidin. login_hint parametresini yönteme, login_hint ve bağımsız değişkeni de yetkilendirme URL'si oluşturucuya ekleyin.

String authUrl = flow
    .newAuthorizationUrl()
    .setState(state)
    .set("login_hint", login_hint)
    .setRedirectUri(REDIRECT_URI)
    .build();

Python

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_hint sorgu parametresinde sağlanan değerlerle eşleşmelidir.
• display_name: Kullanıcının adı ve soyadı ("Ahmet Şahin" gibi).
• email: Kullanıcının e-posta adresi.
• portrait_url: Kullanıcının profil resminin URL'si.
• refresh_token: Daha önce edinilen yenileme jetonu.

Bu örnekte, Python tarafından doğal olarak desteklenen SQLite kullanılarak depolama alanı uygulanmaktadır. Veritabanı yönetimimizi kolaylaştırmak için flask_sqlalchemy modülü kullanılır.

Veritabanını ayarlama

Öncelikle veritabanımız için bir dosya konumu belirtin. Sunucu yapılandırma dosyanıza (sağlanan örnekte config.py) gidin ve aşağıdakileri 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, Flask'ı main.py dosyanızla aynı dizindeki data.sqlite dosyasına yönlendirir.

Ardından, modül dizininize gidin ve yeni bir models.py dosyası oluşturun. Bu, verdiğimiz örneği izliyorsanız webapp/models.py olur. User tablosunu tanımlamak için yeni dosyaya aşağıdakileri ekleyin. Farklıysa webapp yerine modül adınızı ekleyin.

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, modülünüzün __init__.py dosyasına yeni modelleri içe aktarmak ve veritabanını oluşturmak için 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_hint sorgu 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 veritabanı için uygun bir şema oluşturur. Tabloyu bir tablo adı, users ve User özelliklerini, id ve email'ı temsil edecek 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. Bu, verilen örnekte User.java'tir.

Bunun veritabanına kaydedilebilecek bir POJO olduğunu belirtmek için @Entity ek açıklamasını ekleyin. schema.sql notunu, schema.sql içinde yapılandırdığınız ilgili tablo adıyla ekleyin.@Table

Kod örneğinde, iki özellik için oluşturucu ve ayarlayıcılar bulunduğunu unutmayın. Oluşturucu ve ayarlayıcılar, veritabanında kullanıcı oluşturmak veya güncellemek için AuthController.java içinde kullanılır. Dilerseniz alıcı ve toString yöntemi de ekleyebilirsiniz ancak bu adım adım açıklamalı kılavuzda bu yöntemler kullanılmamıştır ve kısalık 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; }
}

Veritabanında CRUD işlemlerini yönetmek 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 depolama alanı arasındaki iletişimi kolaylaştırır. Bu nedenle, denetleyici sınıfı yapıcısını UserRepository sınıfını ekleyecek şekilde 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ı ayarlama

Kullanıcıyla ilgili bilgileri depolamak için Spring Boot'ta doğal olarak desteklenen bir H2 veritabanı kullanın. Bu veritabanı, Classroom ile ilgili diğer bilgileri saklamak için sonraki açıklamalı kılavuzlarda da kullanılır. H2 veritabanını ayarlamak için application.properties dosyasına aşağıdaki yapılandırmayı eklemeniz 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ı, içinde userdb dosyasının bulunduğu h2 adlı bir dizin oluşturur. H2 veritabanının yolunu .gitignore dosyasına ekleyin. Veri tabanını istediğiniz kullanıcı adı ve şifreyle ayarlamak için uygulamayı çalıştırmadan önce spring.datasource.username ve spring.datasource.password parametrelerini 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ı update olarak ayarlamak, 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 bilinmektedir.

Daha önce açıklandığı gibi, tekrarlanan bir kullanıcının kimlik bilgilerini alabilmeniz gerekir. Bu, GoogleAuthorizationCodeFlow tarafından sunulan yerleşik kimlik bilgisi mağazası desteğiyle kolaylaştırılı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şturulur. Kimlik bilgisi deposunun yolunu .gitignore alanına ekleyin. Bu dizin, kullanıcı yetkilendirme akışını başlattıktan sonra oluşturulur.

private static final File dataDirectory = new File("credentialStore");

Ardından, AuthService.java dosyasında bir FileDataStoreFactory nesnesi oluşturup döndüren bir yöntem oluşturun. Bu, kimlik bilgilerini depolayan veri mağazasıdır.

/** 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 yöntemindeki getFlow() yöntemini, GoogleAuthorizationCodeFlow Builder() yöntemine setDataStoreFactory eklemek için 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();

Ardından getAndSaveCredentials(String authorizationCode) yöntemini güncelleyin. Daha önce bu yöntem, kimlik bilgilerini herhangi bir yerde saklamaksızın elde ediyordu. Kimlik bilgilerini, kullanıcı kimliğine göre dizine eklenen veri deposunda depolama yöntemini güncelleyin.

Kullanıcı kimliği, id_token kullanılarak TokenResponse nesnesinden elde edilebilir ancak önce doğrulanmalıdır. Aksi takdirde istemci uygulamaları, sunucuya değiştirilmiş kullanıcı kimlikleri göndererek kullanıcıların kimliğine bürünebilir. id_token değerini doğrulamak için Google API istemci kitaplıklarını kullanmanız önerilir. Daha fazla bilgi için [Google kimlik jetonunu doğrulama hakkındaki Google Kimliği 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, elde edilen kimlik bilgileriyle birlikte saklanacak userId'ı alın.

// Obtain the user id from the id_token.
Payload payload = idToken.getPayload();
String userId = payload.getSubject();

flow.createAndStoreCredential çağrısını userId içerecek şekilde güncelleyin.

// Save the user id and credentials to the configured FileDataStoreFactory.
Credential credential = flow.createAndStoreCredential(tokenResponse, userId);

Veri deposunda varsa belirli bir kullanıcının kimlik bilgilerini döndüren bir yöntemi AuthService.java sınıfına 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;
    }
}

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, kullanıcı kimliğine göre veritabanından kullanıcıyı alacak 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;
}

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 durum vardır: kullanıcı, yetkilendirme akışının sonunda uygulamanıza geri döndüğünde ve API çağrısı yaptığında. Daha önce oturum credentials anahtarını burada ayarlamıştık.

callback rotanızın sonunda save_user_credentials numaralı telefonu arayın. Yalnızca kullanıcının adını ayıklamak 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 çağrılarından sonra kimlik bilgilerini de güncellemeniz gerekir. Bu durumda, güncellenmiş kimlik bilgilerini save_user_credentials yöntemine bağımsız değişken 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 durum vardır: kullanıcı, yetkilendirme akışının sonunda uygulamanıza geri döndüğünde ve API çağrısı yaptığında. Daha önce oturum credentials anahtarını burada ayarlamıştık.

/callback rotasının sonunda saveUser numaralı telefonu arayın. Yalnızca kullanıcının e-posta adresini ayıklamak yerine user_info nesnesini tutmanız gerekir.

/** 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 çağrılarından sonra kimlik bilgilerini de güncellemeniz gerekir. Bu durumda, güncellenmiş kimlik bilgilerini saveUser yöntemine bağımsız değişken olarak sağlayabilirsiniz.

/** Save credentials in case access token was refreshed. */
saveUser(credentials, null, session);

Python

Uygulama başlatıldığında veritabanı dosyasının oluşturulduğundan emin olun. Aşağıdakileri bir modül başlatıcıya (ör. sunduğumuz örnekteki webapp/__init__.py) 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()

Ardından yönteminiz, login_hint sorgu parametresini yukarıda açıklandığı gibi işlemelidir. Ardından, tekrar gelen bir ziyaretçiyse mağaza kimlik bilgilerini yükleyin. login_hint değerini alırsanız ziyaretçinin tekrar ziyaret ettiğini anlayabilirsiniz. Bu kullanıcının depolanan kimlik bilgilerini alıp 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ının kimlik bilgileri yoksa kullanıcıyı oturum açma sayfasına yönlendirin. Bu durumda, kullanıcıları 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

Eklenti açılış rotanıza gidin (sağlam örnekte /addon-discovery). Yukarıdan da bahsedildiği gibi, login_hint sorgusu parametresini burada işlediniz.

Öncelikle oturumda kimlik bilgilerinin olup olmadığını kontrol edin. Aksi takdirde, startAuthFlow yöntemini çağırarak kullanıcıyı kimlik doğrulama akışında 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 tekrar gelen bir ziyaretçidir. Kullanıcı H2 veritabanında mevcutsa kimlik bilgilerini daha önce ayarlanan kimlik bilgisi veri ambarından yükleyin ve oturumda kimlik bilgilerini ayarlayın. Kimlik bilgileri, kimlik bilgisi veri deposundan alınmadıysa startAuthFlow çağrısı yaparak kullanıcıyı kimlik doğrulama akışında 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ı eklenti 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";