Condividi file, cartelle e unità

A ogni file, cartella e Drive condiviso di Google Drive sono associate risorse di autorizzazioni. Ogni risorsa identifica l'autorizzazione per uno specifico type (utente, gruppo, dominio, chiunque) e role, ad esempio "commenter" o "lettore". Ad esempio, un file potrebbe avere un'autorizzazione che concede a un utente specifico (type=user) l'accesso di sola lettura (role=reader), mentre un'altra autorizzazione concede ai membri di un gruppo specifico (type=group) la possibilità di aggiungere commenti a un file (role=commenter).

Per un elenco completo dei ruoli e delle operazioni consentite da ciascuno, consulta Ruoli e autorizzazioni.

Scenari per la condivisione di risorse di Drive

Esistono cinque diversi tipi di scenari di condivisione:

  1. Per condividere un file in Il mio Drive, l'utente deve avere role=writer o role=owner.

  2. Per condividere una cartella in Il mio Drive, l'utente deve avere role=writer o role=owner.

    • Se il valore booleano writersCanShare è impostato su False per il file, l'utente deve avere il valore role=owner più permissivo.

    • L'accesso temporaneo (regolato da una data e un'ora di scadenza) non è consentito alle cartelle di Il mio Drive con role=writer. Per ulteriori informazioni, consulta Impostare una data di scadenza per limitare l'accesso ai file.

  3. Per condividere un file in un Drive condiviso, l'utente deve avere role=writer, role=fileOrganizer o role=organizer.

    • L'impostazione writersCanShare non si applica agli elementi nei Drive condivisi. Viene trattato come se fosse sempre impostato su True.
  4. Per condividere una cartella in un Drive condiviso, l'utente deve avere role=organizer.

    • Se la limitazione sharingFoldersRequiresOrganizerPermission su un Drive condiviso è impostata su False, gli utenti con role=fileOrganizer possono condividere cartelle al suo interno.
  5. Per gestire l'appartenenza ai Drive condivisi, l'utente deve avere role=organizer. Solo gli utenti e i gruppi possono essere membri dei Drive condivisi.

Imposta una data di scadenza per limitare l'accesso ai file

Quando lavori con persone a un progetto sensibile, potresti voler limitare il loro accesso a determinati file su Drive dopo un determinato periodo di tempo. Puoi impostare una data di scadenza per limitare o rimuovere l'accesso ai file che si trovano in Il mio Drive.

Per impostare la data di scadenza:

Il campo expirationTime indica la scadenza dell'autorizzazione utilizzando la versione date-time RFC 3339. I tempi di scadenza sono soggetti alle seguenti limitazioni:

  • Possono essere impostate solo in base alle autorizzazioni utente e gruppo.
  • L'ora deve essere nel futuro.
  • L'ora non può essere più di un anno nel futuro.

Per ulteriori informazioni sulla data di scadenza, consulta i seguenti articoli:

Propagazione delle autorizzazioni

Gli elenchi di autorizzazioni per una cartella si propagano verso il basso e tutti i file e le cartelle secondari ereditano le autorizzazioni dalla cartella principale. Ogni volta che le autorizzazioni o la gerarchia vengono modificate, la propagazione avviene in modo ricorsivo in tutte le cartelle nidificate. Ad esempio, se un file esiste in una cartella che viene poi spostata all'interno di un'altra cartella, le autorizzazioni per la nuova cartella si propagano al file. Se la nuova cartella concede all'utente del file un nuovo ruolo, ad esempio "autore", sostituisce il ruolo precedente.

Al contrario, se un file eredita role=writer da una cartella e viene spostato in un'altra cartella che offre il ruolo di "lettore", il file eredita role=reader.

Non è possibile rimuovere le autorizzazioni ereditate da un file o una cartella di un Drive condiviso. Queste autorizzazioni devono invece essere regolate sull'elemento principale diretto o indiretto da cui sono state ereditate. Le autorizzazioni ereditate possono essere rimosse dagli elementi in "Il mio Drive" o "Condivisi con me".

Al contrario, le autorizzazioni ereditate possono essere sostituite su un file o una cartella in Il mio Drive. Pertanto, se un file eredita role=writer da una cartella Il mio Drive, puoi impostare role=reader sul file per abbassare il relativo livello di autorizzazione.

Funzionalità

La risorsa Autorizzazioni non determina in ultima analisi la capacità dell'utente corrente di eseguire azioni su un file o una cartella. Una risorsa File contiene invece una raccolta di campi capabilities booleani utilizzati per indicare se è possibile eseguire un'azione su un file o una cartella. L'API Google Drive imposta questi campi in base alla risorsa di autorizzazioni dell'utente corrente associata al file o alla cartella.

Ad esempio, quando Alex accede alla tua app e tenta di condividere un file, il ruolo di Alex viene controllato per verificare le autorizzazioni per il file. Se il ruolo consente agli utenti di condividere un file, i valori capabilities relativi al file, ad esempio canShare, vengono compilati in relazione al ruolo. Se Alessandro vuole condividere il file, la tua app controlla capabilities per garantire che canShare sia impostato su true.

Per un esempio di recupero del file capabilities, consulta Verificare le autorizzazioni degli utenti.

Crea un'autorizzazione

Per creare un'autorizzazione sono necessari i due campi seguenti:

  • type: type identifica l'ambito dell'autorizzazione (user, group, domain o anyone). Un'autorizzazione con type=user si applica a un utente specifico, mentre un'autorizzazione con type=domain si applica a tutti gli utenti di un dominio specifico.

  • role: il campo role identifica le operazioni che può essere eseguito da type. Ad esempio, un'autorizzazione con type=user e role=reader concede a un utente specifico l'accesso di sola lettura al file o alla cartella. In alternativa, un'autorizzazione con type=domain e role=commenter consente a tutti gli utenti del dominio di aggiungere commenti a un file. Per un elenco completo dei ruoli e delle operazioni consentite da ciascuno, consulta Ruoli e autorizzazioni.

Quando crei un'autorizzazione in cui type=user o type=group, devi anche fornire un valore emailAddress per collegare l'utente o il gruppo specifico all'autorizzazione.

Quando crei un'autorizzazione in cui type=domain, devi fornire anche un domain per collegare un dominio specifico all'autorizzazione.

Per creare un'autorizzazione:

  1. Utilizza il metodo permissions.create con fileId per il file o la cartella associati.
  2. Nel corpo della richiesta, specifica type e role.
  3. Se type=user o type=group, specifica un emailAddress. Se type=domain, specifica un valore domain.

Mostra un esempio

Il seguente esempio di codice mostra come creare un'autorizzazione. La risposta restituisce un'istanza di una risorsa Permission, compreso il valore permissionId assegnato.

Richiedi

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

Risposta

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

Utilizzare i segmenti di pubblico di destinazione

I segmenti di pubblico di destinazione sono gruppi di persone, ad esempio reparti o team, che puoi consigliare agli utenti con cui condividere i propri elementi. Puoi incoraggiare gli utenti a condividere gli elementi con un pubblico più specifico o limitato anziché con l'intera organizzazione. I segmenti di pubblico di destinazione possono aiutarti a migliorare la sicurezza e la privacy dei dati e a semplificare la condivisione appropriata dei dati. Per ulteriori informazioni, consulta Informazioni sui segmenti di pubblico di destinazione.

Per utilizzare i segmenti di pubblico di destinazione:

  1. Nella Console di amministrazione Google, vai a Menu > Directory > Segmenti di pubblico di destinazione.

    Vai a Segmenti di pubblico di destinazione

    Per eseguire questa operazione, devi accedere utilizzando un account con privilegi di super amministratore.

  2. Nell'elenco Segmenti di pubblico di destinazione, fai clic sul nome del pubblico di destinazione. Per creare un pubblico di destinazione, consulta Creazione di un pubblico di destinazione

  3. Copia l'ID univoco dall'URL del pubblico di destinazione: https://admin.google.com/ac/targetaudiences/ID.

  4. Crea un'autorizzazione con type=domain e imposta il campo domain su ID.audience.googledomains.com.

Per visualizzare il modo in cui gli utenti interagiscono con i segmenti di pubblico di destinazione, consulta Esperienza utente per la condivisione tramite link.

Recuperare tutte le autorizzazioni per un file, una cartella o un Drive condiviso

Utilizza il metodo permissions.list per recuperare tutte le autorizzazioni per un file, una cartella o un Drive condiviso.

Mostra un esempio

Il seguente esempio di codice mostra come ottenere tutte le autorizzazioni. La risposta restituisce un elenco di autorizzazioni.

Richiedi

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

Risposta

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

Verifica le autorizzazioni utente

Quando l'app apre un file, dovrebbe controllarne le funzionalità ed eseguire il rendering dell'interfaccia utente in modo da riflettere le autorizzazioni dell'utente corrente. Ad esempio, se l'utente non dispone di una funzionalità canComment nel file, la possibilità di aggiungere commenti dovrebbe essere disattivata nell'interfaccia utente.

Per ulteriori informazioni su capabilities, consulta la sezione Funzionalità sopra.

Per verificare le funzionalità, chiama files.get con i parametri fileId e fields impostati sul campo capabilities. Per ulteriori informazioni sulla restituzione dei campi utilizzando il parametro fields, consulta Restituire campi specifici per un file.

Mostra un esempio

Il seguente esempio di codice mostra come verificare le autorizzazioni utente. La risposta restituisce un elenco di funzionalità dell'utente relative al file. Ogni funzionalità corrisponde a un'azione granulare che un utente può intraprendere. Alcuni campi vengono compilati solo per gli elementi dei Drive condivisi.

Richiedi

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

Risposta

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

Determinare l'origine del ruolo per i file e le cartelle dei Drive condivisi

Per modificare il ruolo per un file o una cartella, devi conoscere l'origine del ruolo. Per i Drive condivisi, l'origine di un ruolo può essere basata sull'appartenenza al Drive condiviso, sul ruolo in una cartella o sul ruolo nel file.

Per determinare l'origine del ruolo per un Drive condiviso o per gli elementi al suo interno, chiama permissions.get con i parametri fileId, permissionId e fields impostati sul campo permissionDetails. Per trovare permissionId, utilizza permissions.list con fileId. Per recuperare il campo permissionDetails nella richiesta permissions.list, imposta il parametro fields su permissions/permissionDetails.

Questo campo enumera tutte le autorizzazioni ereditate e dirette per i file per utente, gruppo o dominio.

Mostra un esempio

Il seguente esempio di codice mostra come determinare l'origine del ruolo. La risposta restituisce il valore permissionDetails di una risorsa Permission. Il campo inheritedFrom fornisce l'ID dell'elemento da cui viene ereditata l'autorizzazione.

Richiedi

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

Risposta

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

Modifica autorizzazioni

Per modificare le autorizzazioni per un file o una cartella, puoi modificare il ruolo assegnato:

  1. Chiama permissions.update con il permissionId di autorizzazione alla modifica e il fileId per il file, la cartella o il Drive condiviso associato. Per trovare permissionId, utilizza permissions.list con fileId.

  2. Nella richiesta, identifica il nuovo role.

Puoi concedere autorizzazioni per singoli file o cartelle di un Drive condiviso anche se l'utente o il gruppo è già membro. Ad esempio, Alex ha role=commenter come parte del suo abbonamento a un Drive condiviso. Tuttavia, la tua app può concedere ad Alessandro role=writer per un file in un Drive condiviso. In questo caso, poiché il nuovo ruolo è più permissivo di quello concesso tramite l'appartenenza, la nuova autorizzazione diventa il ruolo effettivo per il file o la cartella.

Mostra un esempio

Il seguente esempio di codice mostra come modificare le autorizzazioni per un file o una cartella da commentatore ad autore. La risposta restituisce un'istanza di una risorsa Permission.

Richiedi

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

Risposta

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

Revocare l'accesso a un file o a una cartella

Per revocare l'accesso a un file o a una cartella, chiama delete con fileId e permissionId per eliminare l'autorizzazione.

Per gli elementi che si trovano in "Il mio Drive", è possibile eliminare un'autorizzazione ereditata. L'eliminazione di un'autorizzazione ereditata revoca l'accesso all'elemento e agli elementi secondari, se presenti.

Per gli elementi di un Drive condiviso, le autorizzazioni ereditate non possono essere revocate. Aggiorna o revoca l'autorizzazione per il file o la cartella principale.

L'operazione delete viene utilizzata anche per eliminare le autorizzazioni applicate direttamente a un file o a una cartella di un Drive condiviso.

Mostra un esempio

Il seguente esempio di codice mostra come revocare l'accesso eliminando un permissionId. In caso di esito positivo, il corpo della risposta è vuoto. Per confermare che l'autorizzazione viene rimossa, usa permissions.list con fileId.

Richiedi

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

Trasferire la proprietà dei file a un altro account Google Workspace della stessa organizzazione

La proprietà dei file presenti in "Il mio Drive" può essere trasferita da un account Google Workspace a un altro account nella stessa organizzazione. Un'organizzazione proprietaria di un Drive condiviso è proprietaria dei file al suo interno. Di conseguenza, i trasferimenti di proprietà non sono supportati per file e cartelle nei Drive condivisi. Gli organizzatori di un Drive condiviso possono spostare gli elementi da quel Drive condiviso in "Il mio Drive", a cui verrà trasferita la proprietà.

Per trasferire la proprietà di un file in "Il mio Drive", esegui una delle seguenti operazioni:

  • Crea un'autorizzazione file per concedere a un utente specifico (type=user) l'accesso come proprietario (role=owner).

  • Aggiorna l'autorizzazione di un file esistente con role=owner e trasferisci la proprietà all'utente specificato (transferOwnership=true).

Trasferire la proprietà dei file da un account consumer a un altro

La proprietà dei file può essere trasferita da un account consumer a un altro. Tuttavia, Drive non trasferisce la proprietà di un file tra due account consumer finché il potenziale nuovo proprietario non acconsente esplicitamente al trasferimento. Per trasferire la proprietà dei file da un account consumer a un altro:

  1. Il proprietario attuale avvia un trasferimento di proprietà creando o aggiornando l'autorizzazione file per il nuovo proprietario. L'autorizzazione deve includere le seguenti impostazioni: role=writer, type=user e pendingOwner=true. Se il nuovo proprietario crea un'autorizzazione per il potenziale proprietario, viene inviata una notifica via email al potenziale nuovo proprietario in cui viene indicato che gli viene chiesto di assumere la proprietà del file.

  2. Il nuovo proprietario accetta la richiesta di trasferimento della proprietà creando o aggiornando la propria autorizzazione di accesso ai file. L'autorizzazione deve includere le seguenti impostazioni: role=owner e transferOwnership=true. Se il nuovo proprietario crea una nuova autorizzazione, viene inviata una notifica via email al proprietario precedente in cui viene indicato che la proprietà è stata trasferita.

Quando un file viene trasferito, il ruolo del proprietario precedente viene ridotto a writer.

Modifica di più autorizzazioni con le richieste batch

Ti consigliamo vivamente di utilizzare le richieste batch per modificare più autorizzazioni.

Di seguito è riportato un esempio di modifica delle autorizzazioni in batch con una libreria client.

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