Partager des fichiers, des dossiers et des lecteurs

Tous les fichiers, dossiers et Drive partagés Google Drive sont associés autorisations. Chaque ressource identifie l'autorisation pour un type spécifique (utilisateur, groupe, domaine, tout le monde) ; et role (par exemple, "commentateur") ou « lecteur ». Par exemple, un fichier peut contenir autorisation accordant un accès en lecture seule à un utilisateur spécifique (type=user) (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 par chacun d'eux, consultez Rôles et autorisations.

Scénarios de partage de ressources Drive

Il existe cinq 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éfini sur False pour le fichier, l'utilisateur doit disposer de role=owner.

   • Si l'utilisateur avec role=writer dispose d'un accès temporaire régi par une date et heure d'expiration, il ne peut pas partager le fichier. Pour plus pour plus d'informations, consultez la section Définir une date d'expiration pour limiter le fichier l'accès.

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

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

   • L'accès temporaire (soumis par une date et une heure d'expiration) n'est pas autorisé dans les dossiers Mon Drive par role=writer. Pour plus pour en savoir plus, consultez Définissez 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 droits suivants : role=writer, role=fileOrganizer ou role=organizer.

   • Le paramètre writersCanShare ne s'applique pas aux éléments des Drive partagés. Elle est traitée comme si elle était toujours définie sur True.

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

   • Si la restriction sharingFoldersRequiresOrganizerPermission sur un le Drive partagé est défini sur False, les utilisateurs disposant de role=fileOrganizer peuvent et partager des dossiers dans ce Drive partagé.

5. Pour gérer les membres des Drive partagés, l'utilisateur doit disposer de role=organizer. Uniquement les utilisateurs et les groupes peuvent être membres de Drive partagés.

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

Lorsque vous travaillez avec des personnes sur un projet sensible, vous voudrez peut-être restreindre l'accès à certains fichiers dans Drive après une période de en temps réel. Vous pouvez définir une date d'expiration pour les fichiers de Mon Drive, limiter ou supprimer l'accès à ce fichier.

Pour définir la date d'expiration:

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

Le champ expirationTime indique quand l'autorisation expire, au format RFC 3339 date-heure pour en savoir plus. Les délais d'expiration sont soumis aux restrictions suivantes:

• Elles ne peuvent être définies que sur des autorisations d'utilisateur et de groupe.
• L'heure doit être située dans le futur.
• La date ne peut pas être postérieure d'un an à plus tard.

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 pour en savoir plus.

Propagation des autorisations

Les listes d'autorisations d'un dossier se propagent vers le bas, et tous les fichiers enfants et les dossiers héritent des autorisations du parent. Lorsque les autorisations ou les la hiérarchie est modifiée, la propagation s'effectue de manière récursive dans tous les dossiers. 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 accorde à l'utilisateur du fichier un nouveau rôle, tel que « rédacteur », cette remplace son ancien rôle.

À l'inverse, si un fichier hérite du paramètre role=writer d'un dossier et est déplacé vers un autre dossier qui fournit un « lecteur » le fichier hérite désormais role=reader

Les autorisations héritées ne peuvent pas être supprimées pour un fichier ou un dossier d'un Drive partagé. Ces autorisations doivent être ajustées sur le parent direct ou indirect dont ils ont été hérités. 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 dans Mon Drive. Ainsi, si un fichier hérite de role=writer dossier Drive, vous pouvez définir role=reader sur le fichier pour réduire niveau d'autorisation.

Fonctionnalités

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

Par exemple, lorsqu'Alex se connecte à votre application et tente de partager un fichier, son rôle les autorisations sur le fichier sont vérifiées. Si le rôle leur permet de partager un fichier, les capabilities associés au fichier, par exemple canShare, sont renseignés ; par rapport au rôle. Si Alex souhaite partager le fichier, votre application vérifie capabilities pour vous assurer que canShare est défini sur true.

Pour obtenir un exemple de récupération du fichier capabilities, consultez Vérifier l'utilisateur autorisations.

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, alors que une autorisation avec type=domain s'applique à tous les membres d'un domaine spécifique.

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

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

Pour créer une autorisation:

1. Utiliser la méthode permissions.create par le fileId du fichier ou dossier associé.
2. Dans le corps de la requête, spécifiez les éléments type et role.
3. Si la valeur est type=user ou type=group, indiquez un emailAddress. Si la valeur est type=domain, fournir 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, comme des services ou des équipes, que vous pouvez recommandent aux utilisateurs de partager leurs éléments. Vous pouvez encourager les utilisateurs à partager articles avec une audience plus spécifique ou limitée plutôt que l'ensemble de votre organisation. Les audiences cibles peuvent vous aider à améliorer la sécurité et la confidentialité des vos données et faciliter le partage approprié pour les utilisateurs. Pour plus informations, consultez la section À propos de la cible audiences pour en savoir plus.

Pour utiliser des audiences cibles:

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

   Accéder à la page "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 "Audiences cibles", cliquez sur le nom de l'audience cible. À créer une audience cible, reportez-vous à la section Créer une audience cible audience

3. Copiez l'identifiant 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 savoir comment les utilisateurs interagissent avec les audiences cibles, consultez Expérience utilisateur pour les liens partager pour en savoir plus.

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 pour un fichier, un dossier ou un Drive partagé.

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"
    }
  ]
}

Vérifier les autorisations des utilisateurs

Lorsque votre application ouvre un fichier, elle doit en vérifier les fonctionnalités et le rendu l'UI pour refléter les autorisations de l'utilisateur actuel. Par exemple, si l'utilisateur ne dispose pas de la capacité canComment sur le fichier, il peut désormais ajouter des commentaires doit être désactivé dans l'interface utilisateur.

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

Pour vérifier les fonctionnalités, appelez files.get avec fileId et le paramètre fields défini sur le champ capabilities. Pour Pour en savoir plus sur le renvoi de champs à l'aide du paramètre fields, consultez Renvoyez des champs spécifiques pour un fichier.

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

{
  "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éterminez la source du rôle pour les fichiers des Drive partagés et dossiers

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 groupe le rôle au niveau d'un dossier ou d'un fichier.

Pour déterminer la source du rôle pour un Drive partagé ou les éléments qu'il contient Drive, appelez permissions.get avec le fileId, le permissionId et le paramètre fields définis sur permissionDetails. Pour trouver permissionId, utilisez permissions.list avec le fileId. À récupérez le champ permissionDetails dans la requête permissions.list, définissez le fields sur permissions/permissionDetails.

Ce champ énumère toutes les autorisations de fichiers héritées et directes pour l'utilisateur, un groupe ou un 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 les autorisations

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

1. Appelez permissions.update avec la permissionId de l'autorisation à modifier et le fileId pour la fichier, dossier ou Drive partagé associé. Pour trouver permissionId, utilisez permissions.list avec le fileId.

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

Vous pouvez accorder des autorisations sur des fichiers ou des dossiers spécifiques d'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 leur adhésion à un Drive partagé. Cependant, votre application peut accorder 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é via leur adhésion, le nouveau autorisation devient le rôle effectif pour le fichier ou le dossier.

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"
}

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

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

Pour les éléments de "Mon Drive", il est possible de supprimer l'autorisation. La suppression d'une autorisation héritée révoque l'accès à l'élément et é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. Mettre à jour ou révoquer l'autorisation sur le fichier ou le dossier parent à la place.

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

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

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

Propriété des fichiers existants dans "Mon Drive" peuvent être transférées depuis Un seul compte Google Workspace à un autre compte de la même organisation. Organisation propriétaire d'un espace partagé Drive est propriétaire des fichiers qu'il contient. Par conséquent, les transferts de propriété ne sont pas acceptés pour les fichiers et dossiers des Drive partagés. Les organisateurs d'un Drive partagé peuvent le déplacer éléments de ce Drive partagé dans leur propre dossier "Mon Drive" lequel lui 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 suivantes:

• Créer une autorisation de fichier accordant un utilisateur spécifique (type=user) accès propriétaire (role=owner)

• Modifier l'autorisation d'un fichier existant avec role=owner et transférer à 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 pas la propriété d'un fichier entre deux consommateur comptes jusqu'à ce que le nouveau propriétaire potentiel consente explicitement au transfert. Pour effectuer le transfert d'un compte personnel à un autre:

1. Le propriétaire actuel lance un transfert de propriété en créant ou en mettant à jour l’autorisation de fichier du nouveau propriétaire potentiel. L'autorisation doit inclure ces paramètres: role=writer, type=user et pendingOwner=true. Si le le nouveau propriétaire crée une autorisation pour le propriétaire potentiel, une adresse e-mail est envoyée au nouveau propriétaire potentiel, lui indiquant qu'il d’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 les autorisations d'accès aux fichiers. L'autorisation doit inclure les paramètres suivants: role=owner et transferOwnership=true. Si le nouveau propriétaire crée nouvelle autorisation, une notification par e-mail est envoyée à l'ancien propriétaire indiquant que la propriété a été transférée.

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

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

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

Voici un exemple d'exécution d'une modification d'autorisation par lot avec un 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",
  )

/**
 * 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;
}

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;
        }
    }
}