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). 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 permet aux membres d'un groupe spécifique (type=group) d'ajouter des commentaires à un fichier (role=commenter).

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

Fonctionnement des autorisations

Les listes d'autorisations d'un dossier se propagent 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 à l'utilisateur du fichier un nouveau rôle, tel que "writer", il remplace son ancien rôle.

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

Les autorisations héritées ne peuvent pas être supprimées ni réduites sur un élément. Au lieu de cela, ces autorisations doivent être ajustées sur le parent d'où elles proviennent, ou un dossier de la hiérarchie doit activer le paramètre d'accès limité.

Les autorisations héritées peuvent être augmentées sur un élément. Si une autorisation est augmentée sur un enfant, la modification de l'autorisation d'un parent n'affecte pas l'autorisation de l'enfant, sauf si la nouvelle autorisation parentale est supérieure à celle de l'enfant.

Les opérations d'autorisation simultanées sur le même fichier ne sont pas prises en charge. 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. Au lieu de cela, la files ressource 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, lorsqu'Alex se connecte à votre application et tente de partager un fichier, son rôle est vérifié pour les autorisations sur le fichier. Si le rôle lui permet de partager un fichier, les capabilities associées au fichier, telles que canShare, sont définies par rapport au rôle. Si Alex souhaite partager le fichier, votre application vérifie les 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 fonctionnalités et afficher l'interface utilisateur pour refléter les autorisations de l'utilisateur actuel. Par exemple, si l'utilisateur ne dispose pas de la fonctionnalité canComment sur le fichier, la possibilité de commenter doit être désactivée dans l'interface utilisateur.

Pour vérifier les fonctionnalités, appelez la get méthode 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 la section 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 writersCanShare valeur booléenne 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 à un élément.

2. Pour partager un dossier 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, qui est plus permissif.

   • L'accès temporaire (réglementé par une date et une heure d'expiration) n'est autorisé que sur les dossiers avec role=reader. Pour en savoir plus, consultez consultez Définir une date d'expiration pour limiter l'accès à un élément.

3. Pour partager un fichier dans un Drive partagé, l'utilisateur doit disposer de 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 sharingFoldersRequiresOrganizerPermission restriction sur 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 l'appartenance à un Drive partagé, l'utilisateur doit disposer de 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 fields paramètre système 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écifique à la méthode. Par exemple, la list méthode renvoie uniquement les champs id, type, kind, et role pour chaque fichier. Pour renvoyer d'autres champs, consultez la section Renvoyer des champs spécifiques.

Créer une autorisation

Les deux champs suivants sont nécessaires lors de la création d'une autorisation :

• type : le 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 membres d'un domaine spécifique.

• role: le champ role identifie les opérations que le 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 par chacun d'eux, consultez Rôles et autorisations.

Lorsque vous créez une autorisation où 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 le type et le role.
3. Si type=user ou type=group, fournissez une emailAddress. Si type=domain, fournissez 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 des audiences cibles

Les audiences cibles sont des groupes de personnes (tels que des services ou des équipes) que vous pouvez recommander aux utilisateurs pour partager leurs éléments. Vous pouvez encourager les utilisateurs à partager des éléments avec une audience plus spécifique ou limitée 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 à faciliter le partage approprié par les utilisateurs. Pour en savoir plus, consultez À propos des audiences cibles.

Pour utiliser des 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é à 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, puis définissez le champ domain sur ID.audience.googledomains.com.

Pour voir 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 get méthode sur la ressource permissions avec les fileId et permissionId paramètres de chemin d'accès. 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 list méthode sur la permissions ressource avec le fileId paramètre de chemin d'accès.

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

• pageSize : nombre maximal d'autorisations à renvoyer par page. S'il n'est pas défini pour les fichiers d'un Drive partagé, 100 résultats au maximum sont renvoyés. S'il n'est pas défini 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 demandant prend en charge à la fois Mon Drive et les Drive partagés.

• useDomainAdminAccess: définissez la valeur 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 s.

• includePermissionsForView: autorisations de vue supplémentaires à inclure dans la réponse. Seule la valeur published est acceptée.

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 modifier le rôle attribué. Pour en savoir plus sur la recherche de la source du rôle, consultez Déterminer la source du 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 list méthode sur la ressource permissions avec le paramètre de chemin d'accès fileId.

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

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

Vous pouvez appliquer des mises à jour via la sémantique de patch, 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

{
  "role": "writer"
}

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

Déterminer la source du rôle

Pour modifier le rôle sur un fichier ou un dossier, vous devez connaître la source du rôle. Pour les Drive 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 Drive 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 list méthode sur la permissions ressource avec le fileId paramètre de chemin d'accès. Pour récupérer le permissionDetails champ dans la list requête, définissez le fields paramètre 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
    }
  ]
}

Modifier plusieurs autorisations avec des requêtes par lot

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

Voici un exemple d'exécution d'une modification d'autorisation 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 delete méthode sur la permissions ressource avec les fileId et les permissionId paramètres de chemin d'accès définis pour supprimer l'autorisation.

Les autorisations héritées ne peuvent pas être révoquées. Modifiez ou supprimez plutôt l'autorisation sur le dossier parent. La suppression d'une autorisation sur un dossier révoque également tout accès équivalent sur les éléments enfants.

La réduction des autorisations par rapport à un parent nécessite l'utilisation du paramètre d'accès limité.

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

Définir une date d'expiration pour limiter l'accès à un élément

Lorsque vous travaillez avec des personnes sur un projet sensible, vous pouvez limiter leur accès à certains éléments de Drive après un certain temps. Pour les fichiers et les dossiers, vous pouvez définir une date d'expiration afin de limiter ou de supprimer l'accès à cet élément.

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 obligatoires). Pour en savoir plus, consultez Modifier les autorisations.

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

• Ils ne peuvent être définis que sur les autorisations d'utilisateur et de groupe.
• L'heure doit être future.
• L'heure ne peut pas être supérieure à un an.
• Seul le rôle reader peut expirer l'accès à un dossier.

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

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

Articles associés

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