Partager des fichiers, des dossiers et des lecteurs

Chaque fichier, dossier et Drive partagé Google Drive est associé à des ressources d'autorisations. Chaque ressource identifie l'autorisation pour un type spécifique (utilisateur, groupe, domaine, tout le monde) et role, comme "commentateur" ou "lecteur". 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, consultez la page Rôles et autorisations.

Scénarios de partage de ressources Drive

Il existe cinq types de scénarios de partage:

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

  2. Pour partager un dossier dans Mon Drive, l'utilisateur doit disposer des autorisations suivantes : role=writer ou role=owner.

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

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

  3. Pour partager un fichier dans un Drive partagé, l'utilisateur doit disposer des autorisations 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 sur un Drive partagé est définie sur False, les utilisateurs disposant de l'autorisation role=fileOrganizer peuvent partager des dossiers dans ce Drive.
  5. Pour gérer les membres du Drive partagé, l'utilisateur doit disposer de role=organizer. Seuls les utilisateurs et les groupes peuvent être membres de Drive partagés.

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

Lorsque vous travaillez avec des personnes sur un projet sensible, vous pouvez restreindre leur accès à certains fichiers dans Drive après une période donnée. Pour les fichiers dans Mon Drive, vous pouvez définir une date d'expiration afin de limiter ou de supprimer l'accès à ces fichiers.

Pour définir la date d'expiration:

Le champ expirationTime indique la date et l'heure d'expiration de l'autorisation selon la méthode RFC 3339 de date et d'heure. Les délais d'expiration sont soumis aux restrictions suivantes:

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

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

Propagation des autorisations

Les listes d'autorisations d'un dossier se propagent vers le bas, et tous les fichiers et dossiers enfants héritent des autorisations du parent. Chaque fois que des autorisations ou la hiérarchie sont modifiées, la propagation se fait 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 sur le nouveau dossier se propagent au fichier. Si le nouveau dossier attribue à l'utilisateur du fichier un nouveau rôle, tel que "rédacteur", il remplace l'ancien rôle.

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

Les autorisations héritées ne peuvent pas être supprimées pour un fichier ou un dossier dans un Drive partagé. À la place, ces autorisations doivent ê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 sous "Mon Drive" ou "Partagés avec moi".

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

Capacités

Au final, la ressource Autorisations ne détermine pas la capacité de l'utilisateur actuel à effectuer des actions sur un fichier ou un dossier. Au lieu de cela, une ressource Files contient une collection de champs booléens capabilities permettant d'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 d'autorisations 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, les autorisations sur ce fichier sont vérifiées pour son rôle. Si le rôle leur permet de partager un fichier, les capabilities associés au fichier, tels que canShare, sont renseignés en fonction du rôle. Si Alex souhaite partager le fichier, votre application vérifie capabilities pour s'assurer que canShare est défini sur true.

Pour obtenir un exemple de récupération du fichier capabilities, consultez Vérifier les autorisations des utilisateurs.

Créer une autorisation

Les deux champs suivants sont nécessaires lors de la création d'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 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 également à 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, consultez la page Rôles et autorisations.

Lorsque vous créez une autorisation où type=user ou type=group, vous devez également fournir un emailAddress pour lier 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 lier un domaine spécifique à l'autorisation.

Pour créer une autorisation:

  1. Utilisez la méthode permissions.create avec le fileId pour le fichier ou le dossier associé.
  2. Dans le corps de la requête, spécifiez type et role.
  3. Si type=user ou type=group, indiquez un emailAddress. Si la valeur est type=domain, fournissez un domain.

Afficher un exemple

L'exemple de code suivant montre comment créer une autorisation. La réponse renvoie une instance d'une ressource Permission, y compris le permissionId attribué.

Requête

POST https://www.googleapis.com/drive/v3/files/FILE_ID/permissions
{
  "requests": [
    {
        "type": "user",
        "role": "commenter",
        "emailAddress": "alex@altostrat.com"
    }
  ]
}

Response (Réponse)

{
    "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 de partager des éléments. Vous pouvez encourager les utilisateurs à partager des éléments avec une audience plus spécifique ou plus 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 à faciliter le partage approprié pour les utilisateurs. Pour en savoir plus, consultez À propos des audiences cibles.

Pour utiliser les audiences cibles:

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

    Accéder à la page "Audiences cibles"

    Pour ce faire, vous devez être connecté à l'aide d'un compte disposant de droits de super-administrateur.

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

  3. Copiez l'ID unique à partir de l'URL de la 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 la section Expérience utilisateur pour le partage par lien.

Récupérer toutes les autorisations pour un fichier, un dossier ou un Drive partagé

Utilisez la méthode permissions.list pour récupérer toutes les autorisations sur un fichier, un dossier ou un Drive partagé.

Afficher un exemple

L'exemple de code suivant montre comment obtenir toutes les autorisations. La réponse renvoie une liste d'autorisations.

Requête

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

Response (Réponse)

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

Vérifier les autorisations des utilisateurs

Lorsque votre application ouvre un fichier, elle doit en vérifier les capacité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, cette option doit être désactivée dans l'interface utilisateur.

Pour en savoir plus sur capabilities, consultez la section Fonctionnalités ci-dessus.

Pour vérifier les fonctionnalités, appelez files.get avec fileId et le paramètre fields définis 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 pour un fichier.

Afficher un exemple

L'exemple de code suivant montre comment vérifier les autorisations des utilisateurs. La réponse renvoie la liste des droits dont dispose l'utilisateur sur le fichier. Chaque fonctionnalité correspond à une action précise qu'un utilisateur peut effectuer. Certains champs ne sont renseignés que pour les éléments des Drive partagés.

Requête

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

Response (Réponse)

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

Déterminer la source du rôle pour les fichiers et dossiers des Drive partagés

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 permissions.get avec les paramètres fileId, permissionId et fields définis sur le champ permissionDetails. Pour trouver permissionId, utilisez permissions.list avec fileId. Pour extraire le champ permissionDetails de la requête permissions.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.

Afficher un exemple

L'exemple de code suivant montre comment déterminer la source du rôle. La réponse renvoie le permissionDetails d'une ressource Permission. Le champ inheritedFrom fournit l'ID de l'élément dont l'autorisation est héritée.

Requête

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

Response (Réponse)

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

Modifier les autorisations

Pour modifier les autorisations sur un fichier ou un dossier, vous pouvez modifier le rôle attribué:

  1. Appelez permissions.update avec l'autorisation permissionId de modification et le fileId pour le fichier, le dossier ou le Drive partagé associé. Pour trouver permissionId, utilisez permissions.list avec 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 en est déjà membre. Par exemple, Alex a role=commenter dans le cadre de son appartenance à un Drive partagé. Cependant, votre application peut accorder à Alex le rôle role=writer pour un fichier situé dans un Drive partagé. Dans ce cas, comme le nouveau rôle est plus permissif que celui accordé via son appartenance, la nouvelle autorisation devient le rôle effectif pour le fichier ou le dossier.

Afficher un exemple

L'exemple de code suivant montre comment passer les autorisations de commentateur à rédacteur sur un fichier ou un dossier. La réponse renvoie une instance d'une ressource Permission.

Requête

PATCH https://www.googleapis.com/drive/v3/files/FILE_ID/permissions/PERMISSION_ID
{
  "requests": [
    {
        "role": "writer"
    }
  ]
}

Response (Réponse)

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

Révoquer l'accès à un fichier ou un dossier

Pour révoquer l'accès à un fichier ou à un dossier, appelez delete avec le fileId et le permissionId pour supprimer l'autorisation.

Pour les éléments de "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 aux éléments enfants, le cas échéant.

Il n'est pas possible de révoquer les autorisations héritées par les éléments d'un Drive partagé. Mettez plutôt à jour ou révoquez l'autorisation sur le fichier ou le dossier parent.

L'opération delete permet également de supprimer les autorisations directement appliquées à un fichier ou à un dossier de Drive partagé.

Afficher un exemple

L'exemple de code suivant montre comment révoquer l'accès en supprimant un permissionId. Si la requête aboutit, le corps de la réponse est vide. Pour vérifier que l'autorisation est supprimée, utilisez permissions.list avec fileId.

Requête

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

Transférer la propriété d'un fichier vers un autre compte Google Workspace de la même organisation

La propriété des fichiers existants dans "Mon Drive" peut être transférée d'un compte Google Workspace à un autre compte de la même organisation. Une organisation qui possède un Drive partagé est propriétaire des fichiers qu'il contient. Par conséquent, les transferts de propriété ne sont pas compatibles avec les fichiers et les dossiers des Drive partagés. Les organisateurs d'un Drive partagé peuvent déplacer des éléments de ce Drive vers leur propre Drive, ce qui leur en transfère la propriété.

Pour transférer la propriété d'un fichier dans "Mon Drive", effectuez l'une des opérations suivantes:

  • Créez une autorisation de fichier en accordant à un utilisateur spécifique (type=user) l'accès propriétaire (role=owner).

  • Mettez à jour l'autorisation d'un fichier existant avec role=owner et transférez sa propriété à l'utilisateur spécifié (transferOwnership=true).

Transférer la propriété d'un fichier d'un compte personnel à un autre

La propriété des fichiers peut être transférée d'un compte personnel à un autre. Toutefois, Drive ne transfère la propriété d'un fichier entre deux comptes personnels que lorsque le nouveau propriétaire potentiel accepte explicitement le transfert. Pour transférer la propriété d'un fichier d'un compte personnel à un autre:

  1. Le propriétaire actuel lance un transfert de propriété en créant ou en mettant à jour les autorisations de fichier du nouveau propriétaire potentiel. L'autorisation doit inclure les paramètres suivants: role=writer, type=user et pendingOwner=true. Si le nouveau propriétaire crée une autorisation pour le propriétaire potentiel, une notification par e-mail lui est envoyée pour l'informer qu'il est invité à assumer la propriété du fichier.

  2. Le nouveau propriétaire accepte la demande de transfert de propriété en créant ou en mettant à jour son autorisation d'accès au fichier. L'autorisation doit inclure les paramètres suivants : role=owner et transferOwnership=true. Si le nouveau propriétaire crée une autorisation, une notification par e-mail est envoyée à l'ancien propriétaire pour lui indiquer que la propriété a été transférée.

Lorsqu'un fichier est transféré, le rôle du propriétaire précédent est remis à writer.

Modifier plusieurs autorisations à l'aide de requêtes par lot

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

Voici un exemple de modification groupée d'autorisations avec une bibliothèque cliente.

Java

drive/snippets/drive_v3/src/main/java/ShareFile.java
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;
    }
  }
}

Python

drive/snippets/drive-v3/file_snippet/share_file.py
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",
  )

Node.js

drive/snippets/drive_v3/file_snippets/share_file.js
/**
 * Batch permission modification
 * @param{string} fileId file ID
 * @param{string} targetUserEmail username
 * @param{string} targetDomainName domain
 * @return{list} permission id
 * */
async function shareFile(fileId, targetUserEmail, targetDomainName) {
  const {GoogleAuth} = require('google-auth-library');
  const {google} = require('googleapis');

  // Get credentials and build service
  // TODO (developer) - Use appropriate auth mechanism for your app
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });
  const service = google.drive({version: 'v3', auth});
  const permissionIds = [];

  const permissions = [
    {
      type: 'user',
      role: 'writer',
      emailAddress: targetUserEmail, // 'user@partner.com',
    },
    {
      type: 'domain',
      role: 'writer',
      domain: targetDomainName, // 'example.com',
    },
  ];
  // Note: Client library does not currently support HTTP batch
  // requests. When possible, use batched requests when inserting
  // multiple permissions on the same item. For this sample,
  // permissions are inserted serially.
  for (const permission of permissions) {
    try {
      const result = await service.permissions.create({
        resource: permission,
        fileId: fileId,
        fields: 'id',
      });
      permissionIds.push(result.data.id);
      console.log(`Inserted permission id: ${result.data.id}`);
    } catch (err) {
      // TODO(developer): Handle failed permissions
      console.error(err);
    }
  }
  return permissionIds;
}

PHP

drive/snippets/drive_v3/src/DriveShareFile.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;
    }

}

.NET

drive/snippets/drive_v3/DriveV3Snippets/ShareFile.cs
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;
        }
    }
}