Partager des fichiers, des dossiers et des disques

Chaque fichier, dossier et Drive partagé Google Drive est associé à des ressources permissions. Chaque ressource identifie l'autorisation pour un type (user, group, domain, anyone) et un role (owner, organizer, fileOrganizer, writer, commenter, reader) spécifiques. Par exemple, un fichier peut disposer d'une autorisation accordant à un utilisateur spécifique (type=user) un accès en lecture seule (role=reader), tandis qu'une autre autorisation accorde aux membres d'un groupe spécifique (type=group) la possibilité d'ajouter des commentaires à un fichier (role=commenter).

Pour obtenir la liste complète des rôles et des opérations autorisées pour chacun d'eux, consultez Rôles et autorisations.

Fonctionnement des autorisations

Les listes d'autorisations d'un dossier sont propagées vers le bas. Tous les fichiers et dossiers enfants héritent des autorisations du parent. Chaque fois que les autorisations ou la hiérarchie sont modifiées, la propagation se produit de manière récursive dans tous les dossiers imbriqués. Par exemple, si un fichier existe dans un dossier et que ce dossier est ensuite déplacé dans un autre dossier, les autorisations du nouveau dossier sont propagées au fichier. Si le nouveau dossier accorde un nouveau rôle à l'utilisateur du fichier, tel que "Rédacteur", il remplace son ancien rôle.

À l'inverse, si un fichier hérite de role=writer d'un dossier et est déplacé vers un autre dossier qui fournit un rôle de lecteur, le fichier hérite désormais de role=reader.

Les autorisations héritées ne peuvent pas être supprimées d'un fichier ou d'un dossier dans un Drive partagé. Ces autorisations doivent plutôt être ajustées sur le parent direct ou indirect dont elles ont été héritées. Les autorisations héritées peuvent être supprimées des éléments situés dans "Mon Drive" ou "Partagés avec moi".

À l'inverse, les autorisations héritées peuvent être remplacées sur un fichier ou un dossier dans Mon Drive. Par conséquent, si un fichier hérite de role=writer d'un dossier Mon Drive, vous pouvez définir role=reader sur le fichier pour abaisser son niveau d'autorisation.

Les opérations simultanées sur les autorisations d'un même fichier ne sont pas acceptées. Seule la dernière mise à jour est appliquée.

Comprendre les fonctionnalités des fichiers

La ressource permissions ne détermine pas en définitive la capacité de l'utilisateur actuel à effectuer des actions sur un fichier ou un dossier. À la place, la ressource files contient une collection de champs booléens capabilities utilisés pour indiquer si une action peut être effectuée sur un fichier ou un dossier. L'API Google Drive définit ces champs en fonction de la ressource permissions de l'utilisateur actuel associée au fichier ou au dossier.

Par exemple, lorsque Alex se connecte à votre application et tente de partager un fichier, son rôle est vérifié pour déterminer les autorisations dont il dispose sur le fichier. Si le rôle lui permet de partager un fichier, les capabilities associés au fichier, tels que canShare, sont définis par rapport au rôle. Si Alex souhaite partager le fichier, votre application vérifie capabilities pour s'assurer que canShare est défini sur true.

Obtenir les fonctionnalités des fichiers

Lorsque votre application ouvre un fichier, elle doit vérifier ses capacités et afficher l'UI en fonction des autorisations de l'utilisateur actuel. Par exemple, si l'utilisateur ne dispose pas de la fonctionnalité canComment sur le fichier, la possibilité d'ajouter des commentaires doit être désactivée dans l'interface utilisateur.

Pour vérifier les fonctionnalités, appelez la méthode get sur la ressource files avec le paramètre de chemin d'accès fileId et le paramètre fields défini sur le champ capabilities. Pour en savoir plus sur le renvoi de champs à l'aide du paramètre fields, consultez Renvoyer des champs spécifiques.

GET https://www.googleapis.com/drive/v3/files/FILE_ID?fields=capabilities

{
  "capabilities": {
    "canAcceptOwnership": false,
    "canAddChildren": false,
    "canAddMyDriveParent": false,
    "canChangeCopyRequiresWriterPermission": true,
    "canChangeItemDownloadRestriction": true,
    "canChangeSecurityUpdateEnabled": false,
    "canChangeViewersCanCopyContent": true,
    "canComment": true,
    "canCopy": true,
    "canDelete": true,
    "canDisableInheritedPermissions": false,
    "canDownload": true,
    "canEdit": true,
    "canEnableInheritedPermissions": true,
    "canListChildren": false,
    "canModifyContent": true,
    "canModifyContentRestriction": true,
    "canModifyEditorContentRestriction": true,
    "canModifyOwnerContentRestriction": true,
    "canModifyLabels": true,
    "canMoveChildrenWithinDrive": false,
    "canMoveItemIntoTeamDrive": true,
    "canMoveItemOutOfDrive": true,
    "canMoveItemWithinDrive": true,
    "canReadLabels": true,
    "canReadRevisions": true,
    "canRemoveChildren": false,
    "canRemoveContentRestriction": false,
    "canRemoveMyDriveParent": true,
    "canRename": true,
    "canShare": true,
    "canTrash": true,
    "canUntrash": true
  }
}

Scénarios de partage des ressources Drive

Il existe cinq types de scénarios de partage différents :

1. Pour partager un fichier dans Mon Drive, l'utilisateur doit disposer de role=writer ou role=owner.

   • Si la valeur booléenne writersCanShare est définie sur false pour le fichier, l'utilisateur doit disposer de role=owner.

   • Si l'utilisateur disposant de role=writer bénéficie d'un accès temporaire régi par une date et une heure d'expiration, il ne peut pas partager le fichier. Pour en savoir plus, consultez Définir une date d'expiration pour limiter l'accès à des fichiers.

2. Pour partager un dossier dans Mon Drive, l'utilisateur doit disposer de l'autorisation role=writer ou role=owner.

   • Si la valeur booléenne writersCanShare est définie sur false pour le fichier, l'utilisateur doit disposer de l'autorisation role=owner, qui est plus permissive.

   • L'accès temporaire (réglementé par une date et une heure d'expiration) n'est pas autorisé pour les dossiers Mon Drive avec role=writer. Pour en savoir plus, consultez Définir une date d'expiration pour limiter l'accès à des fichiers.

3. Pour partager un fichier dans un Drive partagé, l'utilisateur doit disposer d'un accès role=writer, role=fileOrganizer ou role=organizer.

   • Le paramètre writersCanShare ne s'applique pas aux éléments des Drive partagés. Il est traité comme s'il était toujours défini sur true.

4. Pour partager un dossier dans un Drive partagé, l'utilisateur doit disposer de role=organizer.

   • Si la restriction sharingFoldersRequiresOrganizerPermission d'un Drive partagé est définie sur false, les utilisateurs disposant de role=fileOrganizer peuvent partager des dossiers dans ce Drive partagé.

5. Pour gérer les membres d'un Drive partagé, l'utilisateur doit disposer du rôle role=organizer. Seuls les utilisateurs et les groupes peuvent être membres de Drive partagés.

Utiliser le paramètre "fields"

Si vous souhaitez spécifier les champs à renvoyer dans la réponse, vous pouvez définir le paramètre système fields avec n'importe quelle méthode de la ressource permissions. Si vous omettez le paramètre fields, le serveur renvoie un ensemble de champs par défaut spécifiques à la méthode. Par exemple, la méthode list ne renvoie que les champs id, type, kind et role pour chaque fichier. Pour renvoyer différents champs, consultez Renvoyer des champs spécifiques.

Créer une autorisation

Les deux champs suivants sont nécessaires lorsque vous créez une autorisation :

• type : type identifie le champ d'application de l'autorisation (user, group, domain ou anyone). Une autorisation avec type=user s'applique à un utilisateur spécifique, tandis qu'une autorisation avec type=domain s'applique à tous les utilisateurs d'un domaine spécifique.

• role : le champ role identifie les opérations que type peut effectuer. Par exemple, une autorisation avec type=user et role=reader accorde à un utilisateur spécifique un accès en lecture seule au fichier ou au dossier. Une autorisation avec type=domain et role=commenter permet à tous les membres du domaine d'ajouter des commentaires à un fichier. Pour obtenir la liste complète des rôles et des opérations autorisées pour chacun d'eux, consultez Rôles et autorisations.

Lorsque vous créez une autorisation avec type=user ou type=group, vous devez également fournir un emailAddress pour associer l'utilisateur ou le groupe spécifique à l'autorisation.

Lorsque vous créez une autorisation où type=domain, vous devez également fournir un domain pour associer un domaine spécifique à l'autorisation.

Pour créer une autorisation :

1. Utilisez la méthode create sur la ressource permissions avec le paramètre de chemin d'accès fileId pour le fichier ou le dossier associé.
2. Dans le corps de la requête, spécifiez type et role.
3. Si la valeur est type=user ou type=group, indiquez emailAddress. Si type=domain, indiquez un domain.

POST https://www.googleapis.com/drive/v3/files/FILE_ID/permissions

{
  "requests": [
    {
        "type": "user",
        "role": "commenter",
        "emailAddress": "alex@altostrat.com"
    }
  ]
}

{
    "kind": "drive#permission",
    "id": "PERMISSION_ID",
    "type": "user",
    "role": "commenter"
}

Utiliser les audiences cibles

Les audiences cibles sont des groupes de personnes, comme des services ou des équipes, que vous pouvez recommander aux utilisateurs ayant l'intention de partager des éléments. Vous pouvez encourager les utilisateurs à partager des éléments avec une audience spécifique ou restreinte plutôt qu'avec l'ensemble de votre organisation. Les audiences cibles peuvent vous aider à améliorer la sécurité et la confidentialité de vos données, et à permettre aux utilisateurs de partager des éléments de manière appropriée. Pour en savoir plus, consultez À propos des audiences cibles.

Pour utiliser les audiences cibles :

1. Dans la console d'administration Google, accédez à Menu menu > Annuaire > Audiences cibles.

   Accéder aux audiences cibles

   Pour effectuer cette tâche, vous devez être connecté à l'aide d'un compte disposant de droits de super-administrateur.

2. Dans la liste des audiences cibles, cliquez sur le nom de l'audience cible. Pour créer une audience cible, consultez Créer une audience cible.

3. Copiez l'ID unique à partir de l'URL de l'audience cible : https://admin.google.com/ac/targetaudiences/ID.

4. Créez une autorisation avec type=domain et définissez le champ domain sur ID.audience.googledomains.com.

Pour savoir comment les utilisateurs interagissent avec les audiences cibles, consultez Expérience utilisateur pour le partage de liens.

Obtenir une autorisation

Pour obtenir une autorisation, utilisez la méthode get sur la ressource permissions avec les paramètres de chemin d'accès fileId et permissionId. Si vous ne connaissez pas l'ID d'autorisation, vous pouvez lister toutes les autorisations à l'aide de la méthode list.

GET https://www.googleapis.com/drive/v3/files/FILE_ID/permissionsPERMISSION_ID

{
  "kind": "drive#permissionList",
  "permissions": [
    {
      "kind": "drive#permission",
      "id": "PERMISSION_ID",
      "type": "user",
      "role": "commenter"
    }
  ]
}

Lister toutes les autorisations

Pour lister les autorisations d'un fichier, d'un dossier ou d'un Drive partagé, utilisez la méthode list sur la ressource permissions avec le paramètre de chemin d'accès fileId.

Transmettez les paramètres de requête suivants pour personnaliser la pagination ou filtrer les autorisations :

• pageSize : nombre maximal d'autorisations à renvoyer par page. Si ce paramètre n'est pas défini pour les fichiers d'un Drive partagé, 100 résultats au maximum sont renvoyés. Si cette valeur n'est pas définie pour les fichiers qui ne se trouvent pas dans un Drive partagé, la liste entière est renvoyée.

• pageToken : jeton de page reçu d'un appel de liste précédent. Fournissez ce jeton pour récupérer la page suivante.

• supportsAllDrives : indique si l'application à l'origine de la requête est compatible avec Mon Drive et les Drive partagés.

• useDomainAdminAccess : défini sur true pour émettre la requête en tant qu'administrateur de domaine. Si le paramètre fileId fait référence à un Drive partagé et que le demandeur est un administrateur du domaine auquel appartient le Drive partagé. Pour en savoir plus, consultez Gérer les Drive partagés en tant qu'administrateur de domaine.

• includePermissionsForView : autorisations de la vue supplémentaire à inclure dans la réponse. Seule la région published est compatible.

GET https://www.googleapis.com/drive/v3/files/FILE_ID/permissions

{
  "kind": "drive#permissionList",
  "permissions": [
    {
      "id": "PERMISSION_ID",
      "type": "user",
      "kind": "drive#permission",
      "role": "commenter"
    }
  ]
}

Modifier les autorisations

Pour modifier les autorisations sur un fichier ou un dossier, vous pouvez changer le rôle attribué. Pour savoir comment trouver la source d'un rôle, consultez Déterminer la source d'un rôle.

1. Appelez la méthode update sur la ressource permissions avec le paramètre de chemin d'accès fileId défini sur le fichier, le dossier ou le Drive partagé associé, et le paramètre de chemin d'accès permissionId défini sur l'autorisation à modifier. Pour trouver le permissionId, utilisez la méthode list sur la ressource permissions avec le paramètre de chemin fileId.

2. Dans la requête, identifiez le nouveau role.

Vous pouvez accorder des autorisations sur des fichiers ou des dossiers individuels d'un Drive partagé, même si l'utilisateur ou le groupe en est déjà membre. Par exemple, Alex dispose d'un accès role=commenter en tant que membre d'un Drive partagé. Toutefois, votre application peut accorder à Alexrole=writer pour un fichier dans un Drive partagé. Dans ce cas, comme le nouveau rôle est plus permissif que celui accordé par l'abonnement, la nouvelle autorisation devient le rôle effectif pour le fichier ou le dossier.

Vous pouvez appliquer des mises à jour à l'aide de la sémantique des correctifs, ce qui signifie que vous pouvez apporter des modifications partielles à une ressource. Vous devez définir explicitement les champs que vous souhaitez modifier dans votre requête. Tous les champs non inclus dans la requête conservent leurs valeurs existantes. Pour en savoir plus, consultez Utiliser des ressources partielles.

PATCH https://www.googleapis.com/drive/v3/files/FILE_ID/permissions/PERMISSION_ID

{
  "requests": [
    {
        "role": "writer"
    }
  ]
}

{
  "kind": "drive#permission",
  "id": "PERMISSION_ID",
  "type": "user",
  "role": "writer"
}

Déterminer la source du rôle

Pour modifier le rôle attribué à un fichier ou à un dossier, vous devez connaître la source du rôle. Pour les Drives partagés, la source d'un rôle peut être basée sur l'appartenance au Drive partagé, le rôle sur un dossier ou le rôle sur un fichier.

Pour déterminer la source du rôle d'un lecteur partagé ou des éléments qu'il contient, appelez la méthode get sur la ressource permissions avec les paramètres de chemin d'accès fileId et permissionId, et le paramètre fields défini sur le champ permissionDetails.

Pour trouver le permissionId, utilisez la méthode list sur la ressource permissions avec le paramètre de chemin fileId. Pour extraire le champ permissionDetails de la requête list, définissez le paramètre fields sur permissions/permissionDetails.

Ce champ énumère toutes les autorisations de fichier héritées et directes pour l'utilisateur, le groupe ou le domaine.

GET https://www.googleapis.com/drive/v3/files/FILE_ID/permissions/PERMISSION_ID?fields=permissionDetails&supportsAllDrives=true

{
  "permissionDetails": [
    {
      "permissionType": "member",
      "role": "commenter",
      "inheritedFrom": "INHERITED_FROM_ID",
      "inherited": true
    },
    {
      "permissionType": "file",
      "role": "writer",
      "inherited": false
    }
  ]
}

Mettre à jour plusieurs autorisations avec des requêtes par lot

Nous vous recommandons vivement d'utiliser les requêtes par lot pour modifier plusieurs autorisations.

Voici un exemple de modification des autorisations par lot avec une bibliothèque cliente.

import com.google.api.client.googleapis.batch.BatchRequest;
import com.google.api.client.googleapis.batch.json.JsonBatchCallback;
import com.google.api.client.googleapis.json.GoogleJsonError;
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.HttpHeaders;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.drive.Drive;
import com.google.api.services.drive.DriveScopes;
import com.google.api.services.drive.model.Permission;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/* Class to demonstrate use-case of modify permissions. */
public class ShareFile {

  /**
   * Batch permission modification.
   * realFileId file Id.
   * realUser User Id.
   * realDomain Domain of the user ID.
   *
   * @return list of modified permissions if successful, {@code null} otherwise.
   * @throws IOException if service account credentials file not found.
   */
  public static List<String> shareFile(String realFileId, String realUser, String realDomain)
      throws IOException {
        /* Load pre-authorized user credentials from the environment.
         TODO(developer) - See https://developers.google.com/identity for
         guides on implementing OAuth2 for your application.application*/
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
        .createScoped(Arrays.asList(DriveScopes.DRIVE_FILE));
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

    // Build a new authorized API client service.
    Drive service = new Drive.Builder(new NetHttpTransport(),
        GsonFactory.getDefaultInstance(),
        requestInitializer)
        .setApplicationName("Drive samples")
        .build();

    final List<String> ids = new ArrayList<String>();


    JsonBatchCallback<Permission> callback = new JsonBatchCallback<Permission>() {
      @Override
      public void onFailure(GoogleJsonError e,
                            HttpHeaders responseHeaders)
          throws IOException {
        // Handle error
        System.err.println(e.getMessage());
      }

      @Override
      public void onSuccess(Permission permission,
                            HttpHeaders responseHeaders)
          throws IOException {
        System.out.println("Permission ID: " + permission.getId());

        ids.add(permission.getId());

      }
    };
    BatchRequest batch = service.batch();
    Permission userPermission = new Permission()
        .setType("user")
        .setRole("writer");

    userPermission.setEmailAddress(realUser);
    try {
      service.permissions().create(realFileId, userPermission)
          .setFields("id")
          .queue(batch, callback);

      Permission domainPermission = new Permission()
          .setType("domain")
          .setRole("reader");

      domainPermission.setDomain(realDomain);

      service.permissions().create(realFileId, domainPermission)
          .setFields("id")
          .queue(batch, callback);

      batch.execute();

      return ids;
    } catch (GoogleJsonResponseException e) {
      // TODO(developer) - handle error appropriately
      System.err.println("Unable to modify permission: " + e.getDetails());
      throw e;
    }
  }
}

import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def share_file(real_file_id, real_user, real_domain):
  """Batch permission modification.
  Args:
      real_file_id: file Id
      real_user: User ID
      real_domain: Domain of the user ID
  Prints modified permissions

  Load pre-authorized user credentials from the environment.
  TODO(developer) - See https://developers.google.com/identity
  for guides on implementing OAuth2 for the application.
  """
  creds, _ = google.auth.default()

  try:
    # create drive api client
    service = build("drive", "v3", credentials=creds)
    ids = []
    file_id = real_file_id

    def callback(request_id, response, exception):
      if exception:
        # Handle error
        print(exception)
      else:
        print(f"Request_Id: {request_id}")
        print(f'Permission Id: {response.get("id")}')
        ids.append(response.get("id"))

    # pylint: disable=maybe-no-member
    batch = service.new_batch_http_request(callback=callback)
    user_permission = {
        "type": "user",
        "role": "writer",
        "emailAddress": "user@example.com",
    }
    batch.add(
        service.permissions().create(
            fileId=file_id,
            body=user_permission,
            fields="id",
        )
    )
    domain_permission = {
        "type": "domain",
        "role": "reader",
        "domain": "example.com",
    }
    domain_permission["domain"] = real_domain
    batch.add(
        service.permissions().create(
            fileId=file_id,
            body=domain_permission,
            fields="id",
        )
    )
    batch.execute()

  except HttpError as error:
    print(f"An error occurred: {error}")
    ids = None

  return ids


if __name__ == "__main__":
  share_file(
      real_file_id="1dUiRSoAQKkM3a4nTPeNQWgiuau1KdQ_l",
      real_user="gduser1@workspacesamples.dev",
      real_domain="workspacesamples.dev",
  )

import {GoogleAuth} from 'google-auth-library';
import {google} from 'googleapis';

/**
 * Shares a file with a user and a domain.
 * @param {string} fileId The ID of the file to share.
 * @param {string} targetUserEmail The email address of the user to share with.
 * @param {string} targetDomainName The domain to share with.
 * @return {Promise<Array<string>>} A promise that resolves to an array of permission IDs.
 */
async function shareFile(fileId, targetUserEmail, targetDomainName) {
  // Authenticate with Google and get an authorized client.
  // TODO (developer): Use an appropriate auth mechanism for your app.
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });

  // Create a new Drive API client (v3).
  const service = google.drive({version: 'v3', auth});

  /** @type {Array<string>} */
  const permissionIds = [];

  // The permissions to create.
  const permissions = [
    {
      type: 'user',
      role: 'writer',
      emailAddress: targetUserEmail, // e.g., 'user@partner.com'
    },
    {
      type: 'domain',
      role: 'writer',
      domain: targetDomainName, // e.g., 'example.com'
    },
  ];

  // Iterate through the permissions and create them one by one.
  for (const permission of permissions) {
    const result = await service.permissions.create({
      requestBody: permission,
      fileId,
      fields: 'id',
    });

    if (result.data.id) {
      permissionIds.push(result.data.id);
      console.log(`Inserted permission id: ${result.data.id}`);
    } else {
      throw new Error('Failed to create permission');
    }
  }
  return permissionIds;
}

<?php
use Google\Client;
use Google\Service\Drive;
function shareFile()
{
    try {
        $client = new Client();
        $client->useApplicationDefaultCredentials();
        $client->addScope(Drive::DRIVE);
        $driveService = new Drive($client);
        $realFileId = readline("Enter File Id: ");
        $realUser = readline("Enter user email address: ");
        $realDomain = readline("Enter domain name: ");
        $ids = array();
            $fileId = '1sTWaJ_j7PkjzaBWtNc3IzovK5hQf21FbOw9yLeeLPNQ';
            $fileId = $realFileId;
            $driveService->getClient()->setUseBatch(true);
            try {
                $batch = $driveService->createBatch();

                $userPermission = new Drive\Permission(array(
                    'type' => 'user',
                    'role' => 'writer',
                    'emailAddress' => 'user@example.com'
                ));
                $userPermission['emailAddress'] = $realUser;
                $request = $driveService->permissions->create(
                    $fileId, $userPermission, array('fields' => 'id'));
                $batch->add($request, 'user');
                $domainPermission = new Drive\Permission(array(
                    'type' => 'domain',
                    'role' => 'reader',
                    'domain' => 'example.com'
                ));
                $userPermission['domain'] = $realDomain;
                $request = $driveService->permissions->create(
                    $fileId, $domainPermission, array('fields' => 'id'));
                $batch->add($request, 'domain');
                $results = $batch->execute();

                foreach ($results as $result) {
                    if ($result instanceof Google_Service_Exception) {
                        // Handle error
                        printf($result);
                    } else {
                        printf("Permission ID: %s\n", $result->id);
                        array_push($ids, $result->id);
                    }
                }
            } finally {
                $driveService->getClient()->setUseBatch(false);
            }
            return $ids;
    } catch(Exception $e) {
        echo "Error Message: ".$e;
    }

}

using Google.Apis.Auth.OAuth2;
using Google.Apis.Drive.v3;
using Google.Apis.Drive.v3.Data;
using Google.Apis.Requests;
using Google.Apis.Services;

namespace DriveV3Snippets
{
    // Class to demonstrate use-case of Drive modify permissions.
    public class ShareFile
    {
        /// <summary>
        /// Batch permission modification.
        /// </summary>
        /// <param name="realFileId">File id.</param>
        /// <param name="realUser">User id.</param>
        /// <param name="realDomain">Domain id.</param>
        /// <returns>list of modified permissions, null otherwise.</returns>
        public static IList<String> DriveShareFile(string realFileId, string realUser, string realDomain)
        {
            try
            {
                /* Load pre-authorized user credentials from the environment.
                 TODO(developer) - See https://developers.google.com/identity for
                 guides on implementing OAuth2 for your application. */
                GoogleCredential credential = GoogleCredential.GetApplicationDefault()
                    .CreateScoped(DriveService.Scope.Drive);

                // Create Drive API service.
                var service = new DriveService(new BaseClientService.Initializer
                {
                    HttpClientInitializer = credential,
                    ApplicationName = "Drive API Snippets"
                });

                var ids = new List<String>();
                var batch = new BatchRequest(service);
                BatchRequest.OnResponse<Permission> callback = delegate(
                    Permission permission,
                    RequestError error,
                    int index,
                    HttpResponseMessage message)
                {
                    if (error != null)
                    {
                        // Handle error
                        Console.WriteLine(error.Message);
                    }
                    else
                    {
                        Console.WriteLine("Permission ID: " + permission.Id);
                    }
                };
                Permission userPermission = new Permission()
                {
                    Type = "user",
                    Role = "writer",
                    EmailAddress = realUser
                };

                var request = service.Permissions.Create(userPermission, realFileId);
                request.Fields = "id";
                batch.Queue(request, callback);

                Permission domainPermission = new Permission()
                {
                    Type = "domain",
                    Role = "reader",
                    Domain = realDomain
                };
                request = service.Permissions.Create(domainPermission, realFileId);
                request.Fields = "id";
                batch.Queue(request, callback);
                var task = batch.ExecuteAsync();
                task.Wait();
                return ids;
            }
            catch (Exception e)
            {
                // TODO(developer) - handle error appropriately
                if (e is AggregateException)
                {
                    Console.WriteLine("Credential Not found");
                }
                else
                {
                    throw;
                }
            }
            return null;
        }
    }
}

Supprimer une autorisation

Pour révoquer l'accès à un fichier ou à un dossier, appelez la méthode delete sur la ressource permissions avec les paramètres de chemin d'accès fileId et permissionId définis sur "delete" (supprimer) pour supprimer l'autorisation.

Pour les éléments dans "Mon Drive", il est possible de supprimer une autorisation héritée. La suppression d'une autorisation héritée révoque l'accès à l'élément et à ses éléments enfants, le cas échéant.

Pour les éléments d'un Drive partagé, les autorisations héritées ne peuvent pas être révoquées. Mettez à jour ou supprimez plutôt l'autorisation sur le fichier ou le dossier parent.

La méthode delete est également utilisée pour supprimer les autorisations appliquées directement à un fichier ou à un dossier d'un Drive partagé.

DELETE https://www.googleapis.com/drive/v3/files/FILE_ID/permissions/PERMISSION_ID

Définir une date d'expiration pour limiter l'accès aux fichiers

Si vous travaillez sur un projet sensible avec d'autres personnes, vous pouvez restreindre leur accès à certains fichiers dans Drive après un certain temps. Pour les fichiers dans le dossier Mon Drive, vous pouvez définir une date d'expiration afin d'en limiter l'accès ou d'y mettre fin.

Pour définir la date d'expiration :

• Utilisez la méthode create sur la ressource permissions et définissez le champ expirationTime (ainsi que les autres champs obligatoires). Pour en savoir plus, consultez Créer une autorisation.

• Utilisez la méthode update sur la ressource permissions et définissez le champ expirationTime (ainsi que les autres champs requis). Pour en savoir plus, consultez Mettre à jour les autorisations.

Le champ expirationTime indique la date d'expiration de l'autorisation au format RFC 3339. Les délais d'expiration sont soumis aux restrictions suivantes :

• Ils ne peuvent être définis que pour les autorisations des utilisateurs et des groupes.
• L'heure doit être située dans le futur.
• La date ne peut pas être postérieure de plus d'un an à la date du jour.

Pour en savoir plus sur la date d'expiration, consultez les articles suivants :

• Définir une date d'expiration pour l'accès à des fichiers
• Ajouter une date d'expiration

Articles associés

• Gérer les propositions d'accès en attente
• Gérer les dossiers en accès limité et étendu
• Transférer la propriété d'un fichier
• Protéger le contenu d'un fichier
• Accéder aux fichiers Drive partagés par lien à l'aide de clés de ressource
• Rôles et autorisations