Condividi file, cartelle e unità

Ogni file, cartella e Drive condiviso di Google Drive sono associati di autorizzazioni. Ogni risorsa identifica l'autorizzazione per un type specifico (utente, gruppo, dominio, chiunque) e role, ad esempio "commentatore" o "lettore". Ad esempio, un file potrebbe avere autorizzazione che concede l'accesso in sola lettura a un utente specifico (type=user) (role=reader) mentre un'altra autorizzazione concede i 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, fai riferimento a Ruoli e autorizzazioni.

Scenari per la condivisione delle 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.

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

   • Se l'utente con role=writer ha un accesso temporaneo regolato da un data e ora di scadenza, non potranno condividere il file. Per ulteriori informazioni informazioni, consulta Impostare una data di scadenza per limitare l'accesso alle app.

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 criterio role=owner più permissivo.

   • L'accesso temporaneo (regolato da una data e un'ora di scadenza) non è consentito nelle cartelle Il mio Drive con role=writer. Per ulteriori informazioni le informazioni, vedi 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 dei Drive condivisi. Viene considerato come se fosse sempre impostato su True.

4. Per condividere una cartella su un Drive condiviso, l'utente deve avere role=organizer.

   • Se la limitazione sharingFoldersRequiresOrganizerPermission su un il Drive condiviso è impostato su False, gli utenti con role=fileOrganizer possono condividere le cartelle in quel Drive condiviso.

5. Per gestire l'appartenenza ai Drive condivisi, l'utente deve avere role=organizer. Solo utenti e gruppi possono essere membri di Drive condivisi.

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

Quando lavori con persone su un progetto sensibile, potrebbe essere utile limitare l'accesso a determinati file su Drive dopo un periodo di nel tempo. Per i file che si trovano in Il mio Drive, puoi impostare una data di scadenza limitare o rimuovere l'accesso a quel file.

Per impostare la data di scadenza:

• Utilizza la permissions.create e imposta il metodo permissions.expirationTime campo (insieme agli altri campi obbligatori). Per ulteriori informazioni, vedi Crea un'autorizzazione.
• Utilizza la permissions.update e imposta il campo permissions.expirationTime (insieme all'altro campi obbligatori). Per ulteriori informazioni, consulta la sezione Modifica autorizzazioni.

Il campo expirationTime indica la scadenza dell'autorizzazione utilizzando RFC 3339 data e ora di Google. Le date di scadenza sono soggette alle seguenti restrizioni:

• Possono essere impostate solo sulle autorizzazioni utente e gruppo.
• L'ora deve essere nel futuro.
• Non può essere più di un anno nel futuro.

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

• Impostare una data di scadenza per l'accesso ai file
• Aggiungere una data di scadenza di Google.

Propagazione autorizzazioni

Gli elenchi di autorizzazioni per una cartella si propagano verso il basso e tutti i file secondari e le cartelle ereditano le autorizzazioni dall'elemento principale. Ogni volta che le autorizzazioni la gerarchia di auto viene modificata, la propagazione avviene in modo ricorsivo attraverso tutte le cartelle. Ad esempio, se un file esiste in una cartella, che viene poi spostato 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 "writer", questo elemento sostituisce il precedente ruolo.

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

Le autorizzazioni ereditate non possono essere rimosse da un file o una cartella di un Drive condiviso. Queste autorizzazioni devono invece essere regolate nell'elemento principale diretto o indiretto da che sono stati ereditati. Le autorizzazioni ereditate possono essere rimosse dagli elementi in "Il mio Drive" o "Condivisi con me".

Al contrario, è possibile eseguire l'override delle autorizzazioni ereditate su un file o una cartella in Il mio Drive. Quindi, se un file eredita role=writer da un Cartella Drive, puoi impostare role=reader sul file per ridurne livello di autorizzazione.

Funzionalità

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

Ad esempio, quando Alex accede alla tua app e prova a condividere un file, il ruolo di Alex per controllare le autorizzazioni relative al file. Se il ruolo consente loro di condividere un file, gli attributi capabilities relativi al file, ad esempio canShare, devono essere compilati rispetto al ruolo. Se Alex vuole condividere il file, la tua app controlla le capabilities per assicurarti che canShare sia impostato su true.

Per un esempio di recupero del file capabilities, consulta Verifica dell'utente autorizzazioni.

Crea un'autorizzazione

Per la creazione di 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: campo role identifica le operazioni che type può eseguire. Ad esempio, un l'autorizzazione con type=user e role=reader concede a un utente specifico 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, vedi Ruoli e autorizzazioni.

Quando crei un'autorizzazione in cui type=user o type=group, devi anche fornisci una emailAddress per legare 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, fornisci un emailAddress. Se type=domain, fornire 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"
}

Utilizza i segmenti di pubblico di destinazione

I segmenti di pubblico di destinazione sono gruppi di persone, ad esempio reparti o team, che puoi consigliano agli utenti di condividere i propri elementi. Puoi incoraggiare gli utenti a condividere articoli con un pubblico più specifico o limitato, anziché l'intero dell'organizzazione. I segmenti di pubblico di destinazione possono aiutarti a migliorare la sicurezza e la privacy dei i tuoi dati e semplificare la condivisione appropriata da parte degli utenti. Per ulteriori informazioni vedi Informazioni sul target segmenti di pubblico di Google.

Per utilizzare i segmenti di pubblico di destinazione:

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

   Vai a Segmenti di pubblico di destinazione

   Per questa attività devi accedere utilizzando un account con privilegi di super amministratore.

2. Nell'elenco dei segmenti di pubblico di destinazione, fai clic sul nome del pubblico di destinazione. A creare un pubblico di destinazione, consulta la sezione Creare un pubblico di destinazione pubblico

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 vedere come gli utenti interagiscono con i segmenti di pubblico di destinazione, consulta Esperienza utente per il link. condivisione di Google.

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

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

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

Verifica le autorizzazioni utente

Quando l'app apre un file, dovrebbe controllarne le capacità ed eseguire il rendering nell'interfaccia utente in modo da riflettere le autorizzazioni dell'utente corrente. Ad esempio, se l'utente non ha una funzionalità canComment sul file, la possibilità di commentare deve essere disabilitato nell'interfaccia utente.

Per ulteriori informazioni su capabilities, consulta le funzionalità sezione precedente.

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

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

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

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

Per determinare l'origine del ruolo per un Drive condiviso o per gli elementi al suo interno. in auto, chiama permissions.get con Il parametro fileId, permissionId e fields impostati su permissionDetails. Per trovare l'permissionId, usa permissions.list con fileId. A recupera il campo permissionDetails nella richiesta permissions.list, imposta fields su permissions/permissionDetails.

Questo campo elenca tutte le autorizzazioni di file ereditate e dirette dell'utente, gruppo o dominio.

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

Modifica autorizzazioni

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

1. Chiama permissions.update con il permissionId dell'autorizzazione di modifica e fileId per file, cartella o Drive condiviso associati. Per trovare l'permissionId, usa permissions.list con fileId.

2. Nella richiesta, identifica il nuovo role.

Puoi concedere autorizzazioni per singoli file o cartelle in un Drive condiviso anche se l'utente o il gruppo è già membro. Ad esempio, Alessandro ha role=commenter nell'ambito dell'appartenenza 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 del ruolo concesso tramite l'appartenenza, il nuovo diventa il ruolo effettivo per il file o la cartella.

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

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 in "Il mio Drive": è possibile eliminare un modello ereditato autorizzazione. L'eliminazione di un'autorizzazione ereditata revoca l'accesso all'elemento e elementi secondari, se presenti.

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

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

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

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

Proprietà dei file esistenti in "Il mio Drive" possono essere trasferiti Un account Google Workspace a un altro account della stessa organizzazione. Un'organizzazione proprietaria di un account condiviso Drive è proprietario dei file al suo interno. Di conseguenza, i trasferimenti di proprietà non sono supportati per i file e le cartelle dei Drive condivisi. Gli organizzatori di un Drive condiviso possono spostare elementi da quel Drive condiviso e nella propria cartella "Il mio Drive" quale ne trasferisce la proprietà.

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

• Creare un'autorizzazione relativa ai file per concedere a un utente specifico (type=user) accesso proprietario (role=owner).

• Aggiorna l'autorizzazione di un file esistente con role=owner e trasferisci la proprietà per l'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 consumatore account 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 dei file del potenziale nuovo proprietario. L'autorizzazione deve includere queste impostazioni: role=writer, type=user e pendingOwner=true. Se nuovo proprietario sta creando un'autorizzazione per il potenziale proprietario, un indirizzo email verrà inviata una notifica al potenziale nuovo proprietario per indicare che sta che viene chiesto di assumere la proprietà del file.

2. Il nuovo proprietario accetta la richiesta di trasferimento della proprietà creando o aggiornando le autorizzazioni per i file. L'autorizzazione deve includere le seguenti impostazioni: role=owner e transferOwnership=true. Se il nuovo proprietario sta creando un nuova autorizzazione, viene inviata una notifica via email al proprietario precedente a indicare che la proprietà è stata trasferita.

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

Modificare più autorizzazioni con richieste batch

Ti consigliamo vivamente di utilizzare richieste in batch per modificare autorizzazioni aggiuntive.

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

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