Gestire le autorizzazioni OAuth granulari per le app Google Chat

Le app di chat che utilizzano l'autenticazione utente devono supportare autorizzazioni OAuth granulari per consentire agli utenti di concedere un sottoinsieme di ambiti richiesti. Ad esempio, un utente potrebbe concedere l'accesso al proprio nome, ma rifiutare l'accesso al proprio calendario.

La gestione delle autorizzazioni OAuth granulari dipende da come crei la tua app di chat:

Apps Script

Se crei la tua app di Chat utilizzando Apps Script, Apps Script gestisce automaticamente le autorizzazioni OAuth granulari. Tuttavia, assicurati che il codice gestisca i casi in cui un utente non concede tutti gli ambiti richiesti. Segui le istruzioni riportate in Gestire le autorizzazioni OAuth granulari in Apps Script.

Endpoint HTTP

Se crei la tua app Chat utilizzando endpoint HTTP, configura il codice per gestire le autorizzazioni OAuth granulari. Controlla quali ambiti di autorizzazione ha concesso l'utente e, se necessario, richiedi l'autorizzazione per gli ambiti mancanti o per tutti gli ambiti.

  1. Nel file manifest della tua app Chat, specifica gli ambiti di autorizzazione richiesti nel campo oauthScopes. Questo campo fa parte della risorsa projects.deployments.

    L'esempio seguente richiede gli ambiti di autorizzazione chat.messages e calendar.events:

    JSON

    {
  "oauthScopes": [
    "https://www.googleapis.com/auth/chat.messages",
    "https://www.googleapis.com/auth/calendar.events"
  ],
  "addOns": {
    "common": {
      "name": "My Chat App",
      "logoUrl": "https://lh3.googleusercontent.com/..."
    },
    "chat": {},
    "calendar": {},
    "httpOptions": {}
  }
}

  2. Per vedere a quali ambiti ha concesso l'accesso l'utente, controlla il campo authorizationEventObject.authorizedScopes. Se manca un ambito obbligatorio, restituisci un'azione requesting_google_scopes per chiedere all'utente gli ambiti mancanti.

    Node.js

    // Check for authorized scopes.
const authorizedScopes = req.body.authorizationEventObject?.authorizedScopes || [];
if (!authorizedScopes.includes('https://www.googleapis.com/auth/chat.messages')) {
  // Respond with a request for the missing scope.
  res.send({
    'requesting_google_scopes': {
      'scopes': ['https://www.googleapis.com/auth/chat.messages']
    }
  });
  return;
}

    Python

    from flask import jsonify, request

# Check for authorized scopes.
event_data = request.get_json()
authorized_scopes = event_data.get('authorizationEventObject', {}).get('authorizedScopes', [])
if 'https://www.googleapis.com/auth/chat.messages' not in authorized_scopes:
    # Respond with a request for the missing scope.
    return jsonify({
        'requesting_google_scopes': {
            'scopes': ['https://www.googleapis.com/auth/chat.messages']
        }
    })

    Java

    import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import java.util.List;

// Check for authorized scopes.
List<String> authorizedScopes = event.getAuthorizationEventObject() != null
    ? event.getAuthorizationEventObject().getAuthorizedScopes()
    : null;
if (authorizedScopes == null || !authorizedScopes.contains("https://www.googleapis.com/auth/chat.messages")) {
  // Respond with a request for the missing scope.
  JsonObject requestingGoogleScopes = new JsonObject();
  JsonArray scopes = new JsonArray();
  scopes.add("https://www.googleapis.com/auth/chat.messages");
  requestingGoogleScopes.add("scopes", scopes);

  JsonObject response = new JsonObject();
  response.add("requesting_google_scopes", requestingGoogleScopes);
  return response.toString();
}

    Per richiedere tutti gli ambiti associati all'app Chat, imposta all_scopes su true:

    Node.js

    res.send({
  'requesting_google_scopes': { 'all_scopes': true }
});

    Python

    from flask import jsonify

return jsonify({
    'requesting_google_scopes': { 'all_scopes': True }
})

    Java

    import com.google.gson.JsonObject;

JsonObject requestingGoogleScopes = new JsonObject();
requestingGoogleScopes.addProperty("all_scopes", true);

JsonObject response = new JsonObject();
response.add("requesting_google_scopes", requestingGoogleScopes);
return response.toString();

Per istruzioni dettagliate, vedi Gestire le autorizzazioni granulari per i componenti aggiuntivi HTTP di Google Workspace.

App di Chat che non sono componenti aggiuntivi: gestire le autorizzazioni OAuth granulari per le app di Google Chat

Se gestisci un'app Chat che non è un componente aggiuntivo di Google Workspace, utilizza le seguenti istruzioni per gestire le autorizzazioni OAuth granulari.

App di Chat Apps Script che non sono componenti aggiuntivi

Se hai creato un'app Chat che non è un componente aggiuntivo utilizzando Apps Script, le istruzioni riportate in Gestire le autorizzazioni OAuth granulari in Apps Script funzionano con una sola considerazione:

ScriptApp.requireScopes interrompe l'esecuzione dello script se gli ambiti specificati non vengono concessi, ma l'utente vede una scheda di configurazione in Chat anziché la schermata per il consenso OAuth. La scheda di configurazione richiede sempre all'utente di concedere tutti gli ambiti richiesti anziché solo quelli non concessi.

Per fornire controlli a livello di ambito di autorizzazione individuali, utilizza ScriptApp.getAuthorizationInfo per verificare l'autorizzazione e, se necessario, richiedere l'autorizzazione utilizzando un messaggio privato.

L'esempio seguente mostra come verificare la presenza di un'autorizzazione specifica (come l'accesso al calendario) e, in caso di assenza, restituire un messaggio privato con l'URL di autorizzazione richiesto.

Apps Script

/**
* Responds to a MESSAGE event in Google Chat.
* Checks for required permissions and if missing asks for them.
*
* @param {Object} event the event object from Chat
* @return {Object} JSON response
*/
function onMessage(event) {
  // Check if the script has the necessary permissions.
  // In this example, the script checks for the "calendar.events" scope.
  var requiredScopes = ['https://www.googleapis.com/auth/calendar.events'];
  var authInfo = ScriptApp.getAuthorizationInfo(ScriptApp.AuthMode.FULL, requiredScopes);

  // If permissions are missing, return a message with the authorization URL.
  if (authInfo.getAuthorizationStatus() === ScriptApp.AuthorizationStatus.REQUIRED) {
    var authUrl = authInfo.getAuthorizationUrl();
    return {
      "text": "This action requires authorization. Please <" + authUrl + "|click here to authorize>.",
      "privateMessageViewer": {
        "name": event.user.name
      }
    };
  }

  // Permission granted; proceed with the application logic.
  // ...
}

App di chat HTTP che non sono componenti aggiuntivi

Se la tua app di chat che non è un componente aggiuntivo è un servizio HTTP, gestisci autonomamente il flusso OAuth 2.0.

Quando recuperi un token memorizzato o scambi un codice di autorizzazione, controlla quali ambiti sono stati concessi. Se gli ambiti richiesti non sono presenti, chiedi all'utente di autorizzarli.

Node.js

// 1. List authorized scopes.
const fs = require('fs');
const tokens = JSON.parse(fs.readFileSync('token.json'));
const grantedScopes = tokens.scope.split(' ');

// 2. Detect missing scopes.
const requiredScopes = ['https://www.googleapis.com/auth/chat.messages'];
const missingScopes = requiredScopes.filter(scope => !grantedScopes.includes(scope));

if (missingScopes.length > 0) {
  // 3. Request missing scopes.
  const authUrl = oauth2Client.generateAuthUrl({
    access_type: 'offline',
    scope: missingScopes,
    include_granted_scopes: true
  });
  res.redirect(authUrl);
}

// To request all scopes instead of just the missing ones:
const allScopesAuthUrl = oauth2Client.generateAuthUrl({
  access_type: 'offline',
  scope: requiredScopes,
  include_granted_scopes: true
});

Python

from flask import redirect
from google.oauth2.credentials import Credentials

# 1. List authorized scopes.
credentials = Credentials.from_authorized_user_file('token.json')
granted_scopes = set(credentials.scopes)

# 2. Detect missing scopes.
required_scopes = {'https://www.googleapis.com/auth/chat.messages'}
missing_scopes = required_scopes - granted_scopes

if missing_scopes:
    # 3. Request missing scopes.
    flow.scope = list(missing_scopes)
    auth_url, _ = flow.authorization_url(
        access_type='offline',
        include_granted_scopes=True
    )
    return redirect(auth_url)

# To request all scopes instead of just the missing ones:
flow.scope = list(required_scopes)
all_scopes_auth_url, _ = flow.authorization_url(
    access_type='offline',
    include_granted_scopes='true'
)

Java

import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeRequestUrl;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

// 1. List authorized scopes.
// The "user" string is the user ID for which to load credentials.
Credential credential = flow.loadCredential("user");
Collection<String> grantedScopes = credential.getScopes();

// 2. Detect missing scopes.
// The `requiredScopes` variable contains a list of the OAuth scopes
// that your app requires to function. Define this variable with the
// scopes needed by your application.
List<String> requiredScopes = Arrays.asList("https://www.googleapis.com/auth/chat.messages");
List<String> missingScopes = new ArrayList<>();
for (String scope : requiredScopes) {
  if (!grantedScopes.contains(scope)) {
    missingScopes.add(scope);
  }
}

if (!missingScopes.isEmpty()) {
  // 3. Request missing scopes.
  GoogleAuthorizationCodeRequestUrl urlBuilder = new GoogleAuthorizationCodeRequestUrl(
      clientId, redirectUri, missingScopes)
      .setAccessType("offline")
      .set("include_granted_scopes", "true");
  String authUrl = urlBuilder.build();
  response.sendRedirect(authUrl);
}

// To request all scopes instead of just the missing ones:
GoogleAuthorizationCodeRequestUrl allScopesUrlBuilder = new GoogleAuthorizationCodeRequestUrl(
    clientId, redirectUri, requiredScopes)
    .setAccessType("offline")
    .set("include_granted_scopes", "true");
String allScopesAuthUrl = allScopesUrlBuilder.build();