Gérer les autorisations OAuth granulaires pour les applications Google Chat

Les applications de chat qui utilisent l'authentification des utilisateurs doivent être compatibles avec les autorisations OAuth détaillées pour permettre aux utilisateurs d'accorder un sous-ensemble des habilitations demandées. Par exemple, un utilisateur peut accorder l'accès à son nom, mais refuser l'accès à son agenda.

La gestion des autorisations OAuth précises dépend de la façon dont vous créez votre application Chat :

Apps Script

Si vous créez votre application Chat à l'aide d'Apps Script, Apps Script gère automatiquement les autorisations OAuth précises. Toutefois, assurez-vous que votre code gère les cas où un utilisateur n'accorde pas tous les niveaux d'accès demandés. La méthode dépend de la nature de votre Apps Script : s'agit-il d'un module complémentaire Google Workspace qui étend Google Chat à l'aide d'Apps Script, ou d'une application Chat autonome conçue avec Apps Script et des événements d'interaction ?

Modules complémentaires Google Workspace qui étendent Chat

Si vous créez votre application Chat en tant que module complémentaire Google Workspace qui étend Google Chat à l'aide d'Apps Script, suivez les instructions de la section Gérer les autorisations OAuth précises dans Apps Script.

Applications Chat Apps Script autonomes

Si vous créez votre application Chat à l'aide d'Apps Script et d'événements d'interaction, les instructions de la section Gérer les autorisations OAuth granulaires dans Apps Script fonctionnent, mais avec une nuance :

ScriptApp.requireScopes arrête l'exécution du script si les autorisations spécifiées ne sont pas accordées, mais l'utilisateur voit une fiche de configuration dans Chat au lieu de l'écran de consentement OAuth. La fiche de configuration invite toujours l'utilisateur à accorder toutes les habilitations demandées au lieu de celles qui ne l'ont pas encore été.

Pour effectuer des vérifications individuelles au niveau du champ d'application de l'autorisation, utilisez ScriptApp.getAuthorizationInfo pour vérifier l'autorisation et, si nécessaire, la demander à l'aide d'un message privé.

L'exemple suivant montre comment rechercher une autorisation spécifique (comme l'accès à l'agenda) et, si elle est manquante, renvoyer un message privé avec l'URL d'autorisation requise.

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.
  // ...
}

Points de terminaison HTTP

Si vous créez votre application Chat à l'aide de points de terminaison HTTP, elle doit être compatible avec les autorisations OAuth précises.

Modules complémentaires Google Workspace qui étendent Chat

Si vous créez votre application Chat en tant que module complémentaire Google Workspace (par exemple, si elle étend d'autres applications Google Workspace comme Google Drive ou Gmail), configurez votre fichier manifeste et votre code pour gérer les autorisations OAuth précises :

  1. Dans le fichier manifeste de votre module complémentaire, définissez le champ granularOauthPermissionSupport sur OPT_IN. Pour en savoir plus sur le champ granularOauthPermissionSupport, consultez Migrer vers le flux d'autorisations OAuth précises.

    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": {},
    "httpOptions": {
      "granularOauthPermissionSupport": "OPT_IN"
    }
  }
}

  2. Pour voir les autorisations accordées par l'utilisateur, vérifiez le champ authorizationEventObject.authorizedScopes dans votre code. Si un champ d'application requis est manquant, renvoyez une action requesting_google_scopes pour inviter l'utilisateur à fournir les champs d'application manquants.

    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().getAuthorizedScopes();
if (!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();
}

    Pour demander tous les niveaux d'accès associés au module complémentaire, définissez all_scopes sur 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();

Pour obtenir des instructions détaillées, consultez Gérer les autorisations précises pour les modules complémentaires HTTP Google Workspace.

Applications Chat HTTP autonomes

Si votre application Chat est un service HTTP autonome (et non un module complémentaire Google Workspace), vous gérez vous-même le flux OAuth 2.0.

Lorsque vous récupérez un jeton stocké ou échangez un code d'autorisation, vérifiez les autorisations accordées. Si les niveaux d'accès requis sont manquants, invitez l'utilisateur à les autoriser.

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();

Pour en savoir plus, consultez Autorisations OAuth précises.