Migracja do usług Google Identity

Uwierzytelnienie bezpośrednie

Uzyskaj token dostępu do użycia w przeglądarce, gdy użytkownik jest obecny.

Przykłady przepływu pośredniego: pokazuje aplikacje internetowe przed migracją do usług tożsamości i po ich zakończeniu.

Przepływ kodu autoryzacji

Google otrzymuje kod autoryzacji użytkownika wydany przez platformę backendu, gdzie jest on wymieniany na token dostępu i token odświeżania.

Przykłady przepływu kodu autoryzacji: wyświetlanie aplikacji internetowych przed migracją do usług tożsamości i po ich zakończeniu.

Uwierzytelnienie bezpośrednie

Rozdziel uwierzytelnianie użytkowników i autoryzację przez usunięcie obsługi profilu użytkownika z procesów autoryzacji.

Usuń te materiały referencyjne klienta JavaScript dotyczące logowania przez Google:

Metody

• GoogleUser.getBasicProfile()
• GoogleUser.getId()

Przepływ kodu autoryzacji

Usługi tożsamości dzielą dane logowania w przeglądarce na tokeny tożsamości i tokeny dostępu. Ta zmiana nie dotyczy danych logowania uzyskanych za pomocą bezpośrednich połączeń z punktami końcowymi Google OAuth 2.0 z platformy backendu ani z bibliotek działających na bezpiecznym serwerze na platformie, takiej jak klient Node.js interfejsów API Google.

Uwierzytelnienie bezpośrednie

Dodaj obiekt TokenClientConfig i wywołanie initTokenClient(), aby skonfigurować aplikację internetową zgodnie z przykładem z tego przykładu.

Zastąp odwołania do klienta JavaScriptu logowania przez Google usługami tożsamości Google:

Obiekty:

• gapi.auth2.AuthorizeConfig – TokenClientConfig

Metody:

• gapi.auth2.init() – google.accounts.oauth2.initTokenClient()

Parametry:

• gapi.auth2.AuthorizeConfig.login_hint – TokenClientConfig.login_hint.
• gapi.auth2.GoogleUser.getHostedDomain() – TokenClientConfig.hd.

Przepływ kodu autoryzacji

Dodaj obiekt CodeClientConfig i wywołanie initCodeClient(), aby skonfigurować aplikację internetową zgodnie z przykładem z tego, jak inicjować klienta kodu.

W przypadku przejściowych sesji kodu autoryzacji:

Usuń Materiały referencyjne klienta JavaScript dotyczącego logowania przez Google

Obiekty:

• gapi.auth2.AuthorizeConfig

Metody:

• gapi.auth2.init()

Parametry:

• gapi.auth2.AuthorizeConfig.login_hint
• gapi.auth2.GoogleUser.getHostedDomain()

Uwierzytelnienie bezpośrednie

Tokeny dostępu można uzyskać i wykorzystywać w przeglądarce, gdy użytkownik jest zalogowany i ma aktywną sesję z Google. W trybie poufnym gest użytkownika musi poprosić o token dostępu, nawet jeśli wcześniej nastąpiło żądanie.

Zastąp odwołania do klienta JavaScriptu logowania przez Google: usługami tożsamości Google:

Metody:

• gapi.auth2.authorize() – TokenClient.requestAccessToken()
• GoogleUser.reloadAuthResponse() – TokenClient.requestAccessToken()

Dodaj link lub przycisk, aby wywołać funkcję requestAccessToken() w celu zainicjowania wyskakującego przepływu UX w celu zażądania tokena dostępu lub uzyskania nowego tokena, gdy istniejący token wygaśnie.

Zaktualizuj bazę kodu, aby:

• Aktywuj przepływ tokenów OAuth 2.0 za pomocą polecenia requestAccessToken().
• Aby obsługiwać przyrostową autoryzację, używaj requestAccessToken i OverridableTokenClientConfig do rozdzielania jednego żądania na wiele zakresów na kilka mniejszych żądań.
• Poproś o nowy token, jeśli istniejący token wygaśnie lub zostanie unieważniony.

Praca z wieloma zakresami może wymagać wprowadzenia zmian strukturalnych w bazie danych, aby żądać dostępu do zakresów tylko wtedy, gdy są potrzebne, a nie ze wszystkich naraz. Jest to tzw. autoryzacja przyrostowa. Każde żądanie powinno zawierać jak najwięcej zakresów, a najlepiej pojedynczy. Więcej informacji na temat aktualizowania aplikacji w celu przyrostowej autoryzacji znajdziesz w tym artykule.

Po wygaśnięciu tokena dostępu moduł gapi.auth2 automatycznie otrzymuje nowy, ważny token dostępu do aplikacji internetowej. Aby zwiększyć bezpieczeństwo użytkowników, ten proces automatycznego odświeżania tokenów nie jest obsługiwany przez bibliotekę usług tożsamości Google. Twoja aplikacja internetowa musi być zaktualizowana, aby wykrywać nieważny dostęp i poprosić o nowy. Więcej informacji znajdziesz w sekcji dotyczącej obsługi tokenów.

Przepływ kodu autoryzacji

Dodaj link lub przycisk, aby wywołać stronę requestCode() i poprosić Google o kod autoryzacji. Przykład znajdziesz w artykule Uruchamianie przepływu kodu OAuth 2.0.

Więcej informacji o tym, jak zareagować na wygasły lub unieważniony token dostępu, znajdziesz w sekcji dotyczącej obsługi tokenów poniżej.

Uwierzytelnienie bezpośrednie

Zastąp odwołania do klienta JavaScriptu logowania przez Google usługami tożsamości Google:

Obiekty:

• gapi.auth2.AuthorizeResponse – TokenClient.TokenResponse
• gapi.auth2.AuthResponse – TokenClient.TokenResponse

Metody:

• GoogleUser.hasGrantedScopes() – google.accounts.oauth2.hasGrantedAllScopes()
• GoogleUser.getGrantedScopes() – google.accounts.oauth2.hasGrantedAllScopes()

Usuń Dokumentacja klienta JavaScript Logowania przez Google:

Metody:

• GoogleUser.getAuthResponse()

Zaktualizuj aplikację internetową, podając wartości hasGrantedAllScopes() i hasGrantedAnyScope(), postępując zgodnie z tym przykładem uprawnień.

Przepływ kodu autoryzacji

Zaktualizuj lub dodaj do swojego backendu backendowy kod autoryzacji, postępując zgodnie z instrukcjami obsługi kodu autoryzacji.

Zaktualizuj platformę, aby wykonać czynności opisane w przewodniku po korzystaniu z modelu kodu, co pozwoli zweryfikować żądanie i uzyskać token dostępu oraz token odświeżania.

Zaktualizuj platformę, aby selektywnie włączać i wyłączać funkcje na podstawie poszczególnych zakresów zaakceptowanych przez użytkownika, postępując zgodnie z instrukcjami upoważnienia przyrostowego i sprawdzania zakresów dostępu przyznanych przez użytkownika.

Biblioteka klienta GAPI

Przykład biblioteki klienta interfejsu API Google dla JavaScriptu uruchomionej w przeglądarce w wyskakującym oknie dotyczącym zgody użytkownika.

Moduł gapi.auth2 jest automatycznie ładowany i używany przez usługę gapi.client.init(), dlatego jest ukryty.

<!DOCTYPE html>
  <html>
    <head>
      <script src="https://apis.google.com/js/api.js"></script>
      <script>
        function start() {
          gapi.client.init({
            'apiKey': 'YOUR_API_KEY',
            'clientId': 'YOUR_CLIENT_ID',
            'scope': 'https://www.googleapis.com/auth/cloud-translation',
            'discoveryDocs': ['https://www.googleapis.com/discovery/v1/apis/translate/v2/rest'],
          }).then(function() {
            // Execute an API request which is returned as a Promise.
            // The method name language.translations.list comes from the API discovery.
            return gapi.client.language.translations.list({
              q: 'hello world',
              source: 'en',
              target: 'de',
            });
          }).then(function(response) {
            console.log(response.result.data.translations[0].translatedText);
          }, function(reason) {
            console.log('Error: ' + reason.result.error.message);
          });
        };

        // Load the JavaScript client library and invoke start afterwards.
        gapi.load('client', start);
      </script>
    </head>
    <body>
      <div id="results"></div>
    </body>
  </html>

Biblioteka klienta JS

Protokół OAuth 2.0 dla aplikacji internetowych po stronie klienta uruchomiony w przeglądarce za pomocą wyskakującego okienka dotyczącego zgody użytkownika.

Moduł gapi.auth2 jest ładowany ręcznie.

<!DOCTYPE html>
<html><head></head><body>
<script>
  var GoogleAuth;
  var SCOPE = 'https://www.googleapis.com/auth/drive.metadata.readonly';
  function handleClientLoad() {
    // Load the API's client and auth2 modules.
    // Call the initClient function after the modules load.
    gapi.load('client:auth2', initClient);
  }

  function initClient() {
    // In practice, your app can retrieve one or more discovery documents.
    var discoveryUrl = 'https://www.googleapis.com/discovery/v1/apis/drive/v3/rest';

    // Initialize the gapi.client object, which app uses to make API requests.
    // Get API key and client ID from API Console.
    // 'scope' field specifies space-delimited list of access scopes.
    gapi.client.init({
        'apiKey': 'YOUR_API_KEY',
        'clientId': 'YOUR_CLIENT_ID',
        'discoveryDocs': [discoveryUrl],
        'scope': SCOPE
    }).then(function () {
      GoogleAuth = gapi.auth2.getAuthInstance();

      // Listen for sign-in state changes.
      GoogleAuth.isSignedIn.listen(updateSigninStatus);

      // Handle initial sign-in state. (Determine if user is already signed in.)
      var user = GoogleAuth.currentUser.get();
      setSigninStatus();

      // Call handleAuthClick function when user clicks on
      //      "Sign In/Authorize" button.
      $('#sign-in-or-out-button').click(function() {
        handleAuthClick();
      });
      $('#revoke-access-button').click(function() {
        revokeAccess();
      });
    });
  }

  function handleAuthClick() {
    if (GoogleAuth.isSignedIn.get()) {
      // User is authorized and has clicked "Sign out" button.
      GoogleAuth.signOut();
    } else {
      // User is not signed in. Start Google auth flow.
      GoogleAuth.signIn();
    }
  }

  function revokeAccess() {
    GoogleAuth.disconnect();
  }

  function setSigninStatus() {
    var user = GoogleAuth.currentUser.get();
    var isAuthorized = user.hasGrantedScopes(SCOPE);
    if (isAuthorized) {
      $('#sign-in-or-out-button').html('Sign out');
      $('#revoke-access-button').css('display', 'inline-block');
      $('#auth-status').html('You are currently signed in and have granted ' +
          'access to this app.');
    } else {
      $('#sign-in-or-out-button').html('Sign In/Authorize');
      $('#revoke-access-button').css('display', 'none');
      $('#auth-status').html('You have not authorized this app or you are ' +
          'signed out.');
    }
  }

  function updateSigninStatus() {
    setSigninStatus();
  }
</script>

<button id="sign-in-or-out-button"
        style="margin-left: 25px">Sign In/Authorize</button>
<button id="revoke-access-button"
        style="display: none; margin-left: 25px">Revoke access</button>

<div id="auth-status" style="display: inline; padding-left: 25px"></div><hr>

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.3/jquery.min.js"></script>
<script async defer src="https://apis.google.com/js/api.js"
        onload="this.onload=function(){};handleClientLoad()"
        onreadystatechange="if (this.readyState === 'complete') this.onload()">
</script>
</body></html>

Punkty końcowe OAuth 2.0

Protokół OAuth 2.0 dla aplikacji internetowych po stronie klienta, który działa w przeglądarce i przekierowuje użytkowników do Google na potrzeby zgody użytkownika.

Ten przykład pokazuje bezpośrednie wywołania punktów końcowych Google OAuth 2.0 w przeglądarce użytkownika i nie używa modułu gapi.auth2 ani biblioteki JavaScript.

<!DOCTYPE html>
<html><head></head><body>
<script>
  var YOUR_CLIENT_ID = 'REPLACE_THIS_VALUE';
  var YOUR_REDIRECT_URI = 'REPLACE_THIS_VALUE';
  var fragmentString = location.hash.substring(1);

  // Parse query string to see if page request is coming from OAuth 2.0 server.
  var params = {};
  var regex = /([^&=]+)=([^&]*)/g, m;
  while (m = regex.exec(fragmentString)) {
    params[decodeURIComponent(m[1])] = decodeURIComponent(m[2]);
  }
  if (Object.keys(params).length > 0) {
    localStorage.setItem('oauth2-test-params', JSON.stringify(params) );
    if (params['state'] && params['state'] == 'try_sample_request') {
      trySampleRequest();
    }
  }

  // If there's an access token, try an API request.
  // Otherwise, start OAuth 2.0 flow.
  function trySampleRequest() {
    var params = JSON.parse(localStorage.getItem('oauth2-test-params'));
    if (params && params['access_token']) {
      var xhr = new XMLHttpRequest();
      xhr.open('GET',
          'https://www.googleapis.com/drive/v3/about?fields=user&' +
          'access_token=' + params['access_token']);
      xhr.onreadystatechange = function (e) {
        if (xhr.readyState === 4 && xhr.status === 200) {
          console.log(xhr.response);
        } else if (xhr.readyState === 4 && xhr.status === 401) {
          // Token invalid, so prompt for user permission.
          oauth2SignIn();
        }
      };
      xhr.send(null);
    } else {
      oauth2SignIn();
    }
  }

  /*
   * Create form to request access token from Google's OAuth 2.0 server.
   */
  function oauth2SignIn() {
    // Google's OAuth 2.0 endpoint for requesting an access token
    var oauth2Endpoint = 'https://accounts.google.com/o/oauth2/v2/auth';

    // Create element to open OAuth 2.0 endpoint in new window.
    var form = document.createElement('form');
    form.setAttribute('method', 'GET'); // Send as a GET request.
    form.setAttribute('action', oauth2Endpoint);

    // Parameters to pass to OAuth 2.0 endpoint.
    var params = {'client_id': YOUR_CLIENT_ID,
                  'redirect_uri': YOUR_REDIRECT_URI,
                  'scope': 'https://www.googleapis.com/auth/drive.metadata.readonly',
                  'state': 'try_sample_request',
                  'include_granted_scopes': 'true',
                  'response_type': 'token'};

    // Add form parameters as hidden input values.
    for (var p in params) {
      var input = document.createElement('input');
      input.setAttribute('type', 'hidden');
      input.setAttribute('name', p);
      input.setAttribute('value', params[p]);
      form.appendChild(input);
    }

    // Add form to page and submit it to open the OAuth 2.0 endpoint.
    document.body.appendChild(form);
    form.submit();
  }
</script>

<button onclick="trySampleRequest();">Try sample request</button>
</body></html>

Tylko GIS

Ten przykład pokazuje tylko bibliotekę JavaScript usługi Google Identity przy użyciu modelu tokena i wyskakującego okienka dotyczącego zgody użytkownika. Ma ona ilustrować minimalną liczbę kroków wymaganych do skonfigurowania klienta, żądania i uzyskania tokena dostępu oraz wywoływania interfejsu API Google.

<!DOCTYPE html>
<html>
  <head>
    <script src="https://accounts.google.com/gsi/client" onload="initClient()" async defer></script>
  </head>
  <body>
    <script>
      var client;
      var access_token;

      function initClient() {
        client = google.accounts.oauth2.initTokenClient({
          client_id: 'YOUR_CLIENT_ID',
          scope: 'https://www.googleapis.com/auth/calendar.readonly \
                  https://www.googleapis.com/auth/contacts.readonly',
          callback: (tokenResponse) => {
            access_token = tokenResponse.access_token;
          },
        });
      }
      function getToken() {
        client.requestAccessToken();
      }
      function revokeToken() {
        google.accounts.oauth2.revoke(access_token, () => {console.log('access token revoked')});
      }
      function loadCalendar() {
        var xhr = new XMLHttpRequest();
        xhr.open('GET', 'https://www.googleapis.com/calendar/v3/calendars/primary/events');
        xhr.setRequestHeader('Authorization', 'Bearer ' + access_token);
        xhr.send();
      }
    </script>
    <h1>Google Identity Services Authorization Token model</h1>
    <button onclick="getToken();">Get access token</button><br><br>
    <button onclick="loadCalendar();">Load Calendar</button><br><br>
    <button onclick="revokeToken();">Revoke token</button>
  </body>
</html>

Synchronizacja/oczekiwanie na GAPI

Ten przykład pokazuje, jak dodać bibliotekę usługi Google Identity przy użyciu modelu tokena, usunąć moduł gapi.auth2 i wywołać interfejs API za pomocą biblioteki klienta interfejsu API Google dla JavaScriptu.

Obietnice, asynchroniczne i oczekiwania są używane do wymuszania kolejności wczytywania bibliotek oraz wykrywania i ponownych błędów autoryzacji. Wywołanie interfejsu API jest wykonywane dopiero po udostępnieniu prawidłowego tokena dostępu.

Użytkownicy powinni nacisnąć przycisk „Pokaż kalendarz”, gdy brakuje tokena dostępu podczas pierwszego wczytywania strony lub po wygaśnięciu tokena dostępu.

<!DOCTYPE html>
<html>
<head></head>
<body>
  <h1>GAPI with GIS async/await</h1>
  <button id="showEventsBtn" onclick="showEvents();">Show Calendar</button><br><br>
  <button id="revokeBtn" onclick="revokeToken();">Revoke access token</button>

  <script>

    const gapiLoadPromise = new Promise((resolve, reject) => {
      gapiLoadOkay = resolve;
      gapiLoadFail = reject;
    });
    const gisLoadPromise = new Promise((resolve, reject) => {
      gisLoadOkay = resolve;
      gisLoadFail = reject;
    });

    var tokenClient;

    (async () => {
      document.getElementById("showEventsBtn").style.visibility="hidden";
      document.getElementById("revokeBtn").style.visibility="hidden";

      // First, load and initialize the gapi.client
      await gapiLoadPromise;
      await new Promise((resolve, reject) => {
        // NOTE: the 'auth2' module is no longer loaded.
        gapi.load('client', {callback: resolve, onerror: reject});
      });
      await gapi.client.init({
        // NOTE: OAuth2 'scope' and 'client_id' parameters have moved to initTokenClient().
      })
      .then(function() {  // Load the Calendar API discovery document.
        gapi.client.load('https://www.googleapis.com/discovery/v1/apis/calendar/v3/rest');
      });

      // Now load the GIS client
      await gisLoadPromise;
      await new Promise((resolve, reject) => {
        try {
          tokenClient = google.accounts.oauth2.initTokenClient({
              client_id: 'YOUR_CLIENT_ID',
              scope: 'https://www.googleapis.com/auth/calendar.readonly',
              prompt: 'consent',
              callback: '',  // defined at request time in await/promise scope.
          });
          resolve();
        } catch (err) {
          reject(err);
        }
      });

      document.getElementById("showEventsBtn").style.visibility="visible";
      document.getElementById("revokeBtn").style.visibility="visible";
    })();

    async function getToken(err) {

      if (err.result.error.code == 401 || (err.result.error.code == 403) &&
          (err.result.error.status == "PERMISSION_DENIED")) {

        // The access token is missing, invalid, or expired, prompt for user consent to obtain one.
        await new Promise((resolve, reject) => {
          try {
            // Settle this promise in the response callback for requestAccessToken()
            tokenClient.callback = (resp) => {
              if (resp.error !== undefined) {
                reject(resp);
              }
              // GIS has automatically updated gapi.client with the newly issued access token.
              console.log('gapi.client access token: ' + JSON.stringify(gapi.client.getToken()));
              resolve(resp);
            };
            tokenClient.requestAccessToken();
          } catch (err) {
            console.log(err)
          }
        });
      } else {
        // Errors unrelated to authorization: server errors, exceeding quota, bad requests, and so on.
        throw new Error(err);
      }
    }

    function showEvents() {

      // Try to fetch a list of Calendar events. If a valid access token is needed,
      // prompt to obtain one and then retry the original request.
      gapi.client.calendar.events.list({ 'calendarId': 'primary' })
      .then(calendarAPIResponse => console.log(JSON.stringify(calendarAPIResponse)))
      .catch(err  => getToken(err))  // for authorization errors obtain an access token
      .then(retry => gapi.client.calendar.events.list({ 'calendarId': 'primary' }))
      .then(calendarAPIResponse => console.log(JSON.stringify(calendarAPIResponse)))
      .catch(err  => console.log(err));   // cancelled by user, timeout, etc.
    }

    function revokeToken() {
      let cred = gapi.client.getToken();
      if (cred !== null) {
        google.accounts.oauth2.revoke(cred.access_token, () => {console.log('Revoked: ' + cred.access_token)});
        gapi.client.setToken('');
      }
    }

  </script>

  <script async defer src="https://apis.google.com/js/api.js" onload="gapiLoadOkay()" onerror="gapiLoadFail(event)"></script>
  <script async defer src="https://accounts.google.com/gsi/client" onload="gisLoadOkay()" onerror="gisLoadFail(event)"></script>

</body>
</html>

Wywołanie zwrotne interfejsu GAPI

Ten przykład pokazuje, jak dodać bibliotekę usługi Google Identity przy użyciu modelu tokena, usunąć moduł gapi.auth2 i wywołać interfejs API za pomocą biblioteki klienta interfejsu API Google dla JavaScriptu.

Zmienne są używane do wymuszania kolejności wczytywania biblioteki. Wywołania GAPI są wykonywane w wywołaniu zwrotnym po zwróceniu prawidłowego tokena dostępu.

Użytkownicy powinni nacisnąć przycisk Pokaż kalendarz po pierwszym wczytaniu strony, a następnie, gdy chcą odświeżyć informacje o kalendarzu.

<!DOCTYPE html>
<html>
<head>
  <script async defer src="https://apis.google.com/js/api.js" onload="gapiLoad()"></script>
  <script async defer src="https://accounts.google.com/gsi/client" onload="gisInit()"></script>
</head>
<body>
  <h1>GAPI with GIS callbacks</h1>
  <button id="showEventsBtn" onclick="showEvents();">Show Calendar</button><br><br>
  <button id="revokeBtn" onclick="revokeToken();">Revoke access token</button>
  <script>
    let tokenClient;
    let gapiInited;
    let gisInited;

    document.getElementById("showEventsBtn").style.visibility="hidden";
    document.getElementById("revokeBtn").style.visibility="hidden";

    function checkBeforeStart() {
       if (gapiInited && gisInited){
          // Start only when both gapi and gis are initialized.
          document.getElementById("showEventsBtn").style.visibility="visible";
          document.getElementById("revokeBtn").style.visibility="visible";
       }
    }

    function gapiInit() {
      gapi.client.init({
        // NOTE: OAuth2 'scope' and 'client_id' parameters have moved to initTokenClient().
      })
      .then(function() {  // Load the Calendar API discovery document.
        gapi.client.load('https://www.googleapis.com/discovery/v1/apis/calendar/v3/rest');
        gapiInited = true;
        checkBeforeStart();
      });
    }

    function gapiLoad() {
        gapi.load('client', gapiInit)
    }

    function gisInit() {
     tokenClient = google.accounts.oauth2.initTokenClient({
                client_id: 'YOUR_CLIENT_ID',
                scope: 'https://www.googleapis.com/auth/calendar.readonly',
                callback: '',  // defined at request time
            });
      gisInited = true;
      checkBeforeStart();
    }

    function showEvents() {

      tokenClient.callback = (resp) => {
        if (resp.error !== undefined) {
          throw(resp);
        }
        // GIS has automatically updated gapi.client with the newly issued access token.
        console.log('gapi.client access token: ' + JSON.stringify(gapi.client.getToken()));

        gapi.client.calendar.events.list({ 'calendarId': 'primary' })
        .then(calendarAPIResponse => console.log(JSON.stringify(calendarAPIResponse)))
        .catch(err => console.log(err));

        document.getElementById("showEventsBtn").innerText = "Refresh Calendar";
      }

      // Conditionally ask users to select the Google Account they'd like to use,
      // and explicitly obtain their consent to fetch their Calendar.
      // NOTE: To request an access token a user gesture is necessary.
      if (gapi.client.getToken() === null) {
        // Prompt the user to select a Google Account and asked for consent to share their data
        // when establishing a new session.
        tokenClient.requestAccessToken({prompt: 'consent'});
      } else {
        // Skip display of account chooser and consent dialog for an existing session.
        tokenClient.requestAccessToken({prompt: ''});
      }
    }

    function revokeToken() {
      let cred = gapi.client.getToken();
      if (cred !== null) {
        google.accounts.oauth2.revoke(cred.access_token, () => {console.log('Revoked: ' + cred.access_token)});
        gapi.client.setToken('');
        document.getElementById("showEventsBtn").innerText = "Show Calendar";
      }
    }
  </script>
</body>
</html>

Aplikacje internetowe po stronie serwera

Logowanie przez Google w przypadku aplikacji po stronie serwera działające na platformie backendu z przekierowaniem do Google w celu uzyskania zgody użytkownika.

<!DOCTYPE html>
<html>
  <head>
    <script src="//ajax.googleapis.com/ajax/libs/jquery/1.8.2/jquery.min.js"></script>
    <script src="https://apis.google.com/js/client:platform.js?onload=start" async defer></script>
    <script>
      function start() {
        gapi.load('auth2', function() {
          auth2 = gapi.auth2.init({
            client_id: 'YOUR_CLIENT_ID',
            api_key: 'YOUR_API_KEY',
            discovery_docs: ['https://www.googleapis.com/discovery/v1/apis/translate/v2/rest'],
            // Scopes to request in addition to 'profile' and 'email'
            scope: 'https://www.googleapis.com/auth/cloud-translation',
          });
        });
      }
      function signInCallback(authResult) {
        if (authResult['code']) {
          console.log("sending AJAX request");
          // Send authorization code obtained from Google to backend platform
          $.ajax({
            type: 'POST',
            url: 'YOUR_AUTHORIZATION_CODE_ENDPOINT_URL',
            // Always include an X-Requested-With header to protect against CSRF attacks.
            headers: {
              'X-Requested-With': 'XMLHttpRequest'
            },
            contentType: 'application/octet-stream; charset=utf-8',
            success: function(result) {
              console.log(result);
            },
            processData: false,
            data: authResult['code']
          });
        } else {
          console.log('error: failed to obtain authorization code')
        }
      }
    </script>
  </head>
  <body>
    <button id="signinButton">Sign In With Google</button>
    <script>
      $('#signinButton').click(function() {
        // Obtain an authorization code from Google
        auth2.grantOfflineAccess().then(signInCallback);
      });
    </script>
  </body>
</html>

HTTP/REST za pomocą przekierowania

Używanie protokołu OAuth 2.0 w przypadku aplikacji serwera WWW do wysyłania kodu autoryzacji z przeglądarki użytkownika na platformę backendu. Zgoda użytkownika jest przetwarzana przez przekierowanie przeglądarki użytkownika do Google.

/\*
 \* Create form to request access token from Google's OAuth 2.0 server.
 \*/
function oauthSignIn() {
  // Google's OAuth 2.0 endpoint for requesting an access token
  var oauth2Endpoint = 'https://accounts.google.com/o/oauth2/v2/auth';
  // Create <form> element to submit parameters to OAuth 2.0 endpoint.
  var form = document.createElement('form');
  form.setAttribute('method', 'GET'); // Send as a GET request.
  form.setAttribute('action', oauth2Endpoint);
  // Parameters to pass to OAuth 2.0 endpoint.
  var params = {'client\_id': 'YOUR_CLIENT_ID',
                'redirect\_uri': 'YOUR_AUTHORIZATION_CODE_ENDPOINT_URL',
                'response\_type': 'token',
                'scope': 'https://www.googleapis.com/auth/drive.metadata.readonly',
                'include\_granted\_scopes': 'true',
                'state': 'pass-through value'};
  // Add form parameters as hidden input values.
  for (var p in params) {
    var input = document.createElement('input');
    input.setAttribute('type', 'hidden');
    input.setAttribute('name', p);
    input.setAttribute('value', params[p]);
    form.appendChild(input);
  }

  // Add form to page and submit it to open the OAuth 2.0 endpoint.
  document.body.appendChild(form);
  form.submit();
}

Wyskakujące okienko GIS

Ten przykład pokazuje tylko bibliotekę JavaScript usługi Google Identity Service za pomocą modelu kodu autoryzacji wyskakującego okienka służącego do uzyskiwania zgody użytkownika i modułu wywołania zwrotnego służącego do odbierania od Google kodu autoryzacji. Służy on do zilustrowania minimalnej liczby kroków wymaganych do skonfigurowania klienta, uzyskania zgody i wysłania kodu autoryzacji do platformy backendu.

<!DOCTYPE html>
<html>
  <head>
    <script src="https://accounts.google.com/gsi/client" onload="initClient()" async defer></script>
  </head>
  <body>
    <script>
      var client;
      function initClient() {
        client = google.accounts.oauth2.initCodeClient({
          client_id: 'YOUR_CLIENT_ID',
          scope: 'https://www.googleapis.com/auth/calendar.readonly',
          ux_mode: 'popup',
          callback: (response) => {
            var code_receiver_uri = 'YOUR_AUTHORIZATION_CODE_ENDPOINT_URI',
            // Send auth code to your backend platform
            const xhr = new XMLHttpRequest();
            xhr.open('POST', code_receiver_uri, true);
            xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
            xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
            xhr.onload = function() {
              console.log('Signed in as: ' + xhr.responseText);
            };
            xhr.send('code=' + response.code);
            // After receipt, the code is exchanged for an access token and
            // refresh token, and the platform then updates this web app
            // running in user's browser with the requested calendar info.
          },
        });
      }
      function getAuthCode() {
        // Request authorization code and obtain user consent
          client.requestCode();
      }
    </script>
    <button onclick="getAuthCode();">Load Your Calendar</button>
  </body>
</html>

Przekierowanie GIS

Model kodu autoryzacji obsługuje tryby wyskakujących okienek i przekierowań, które umożliwiają wysyłanie kodu autoryzacji poszczególnych użytkowników do punktu końcowego hostowanego przez Twoją platformę. Tryb UX przekierowania jest widoczny tutaj:

<!DOCTYPE html>
<html>
  <head>
    <script src="https://accounts.google.com/gsi/client" onload="initClient()" async defer></script>
  </head>
  <body>
    <script>
      var client;
      function initClient() {
        client = google.accounts.oauth2.initCodeClient({
          client_id: 'YOUR_CLIENT_ID',
          scope: 'https://www.googleapis.com/auth/calendar.readonly \
                  https://www.googleapis.com/auth/photoslibrary.readonly',
          ux_mode: 'redirect',
          redirect_uri: 'YOUR_AUTHORIZATION_CODE_ENDPOINT_URI'
        });
      }
      // Request an access token
      function getAuthCode() {
        // Request authorization code and obtain user consent
          client.requestCode();
      }
    </script>
    <button onclick="getAuthCode();">Load Your Calendar</button>
  </body>
</html>