Condividere file, cartelle e Drive

Ogni file, cartella e Drive condiviso di Google Drive ha risorse associate permissions. Ogni risorsa identifica l'autorizzazione per un type (user, group, domain, anyone) e un role (owner, organizer, fileOrganizer, writer, commenter, reader). 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.

Come funzionano le autorizzazioni

Gli elenchi di autorizzazioni per una cartella vengono propagati verso il basso. 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 e questa cartella viene spostata in un'altra cartella, le autorizzazioni della nuova cartella vengono propagate al file. Se la nuova cartella concede all'utente del file un nuovo ruolo, ad esempio "writer", questo sostituisce il ruolo precedente.

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

Le autorizzazioni ereditate non possono essere rimosse o ridotte su nessun elemento. Queste autorizzazioni devono invece essere modificate nella cartella principale da cui provengono oppure una cartella nella gerarchia deve attivare l' impostazione di accesso limitato.

Le autorizzazioni ereditate possono essere aumentate su un elemento. Se un'autorizzazione viene aumentata su un elemento secondario, la modifica dell'autorizzazione di un elemento principale non influisce sull'autorizzazione dell'elemento secondario, a meno che la nuova autorizzazione dell'elemento principale non sia maggiore di quella dell'elemento secondario.

Le operazioni di autorizzazione simultanee sullo stesso file non sono supportate. Viene applicato solo l'ultimo aggiornamento.

Informazioni sulle funzionalità dei file

La risorsa permissions non determina in definitiva la capacità dell'utente attuale di eseguire azioni su un file o una cartella. La risorsa files contiene invece una raccolta di campi booleani capabilities utilizzati per indicare se un'azione può essere eseguita su un file o una cartella. L'API Google Drive imposta questi campi in base alla risorsa permissions dell'utente attuale associata al file o alla cartella.

Ad esempio, quando Alex accede alla tua app e tenta di condividere un file, il suo ruolo viene controllato per verificare le autorizzazioni sul file. Se il ruolo consente di condividere un file, le capabilities correlate al file, ad esempio canShare, vengono impostate in relazione al ruolo. Se Alex vuole condividere il file, la tua app controlla le capabilities per assicurarsi che canShare sia impostato su true.

Ottenere le funzionalità dei file

Quando la tua app apre un file, deve controllare le funzionalità del file e visualizzare l'interfaccia utente in modo da riflettere le autorizzazioni dell'utente attuale. Ad esempio, se l'utente non ha la funzionalità canComment sul file, la possibilità di aggiungere commenti deve essere disattivata nell'interfaccia utente.

Per controllare le funzionalità, chiama il get metodo sulla risorsa files con il parametro di percorso fileId e il parametro fields impostato sul campo capabilities. Per ulteriori informazioni sulla restituzione dei campi utilizzando il parametro fields, consulta Restituire campi specifici.

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

Richiesta

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

Risposta

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

Scenari per la condivisione delle risorse di Drive

Esistono cinque 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 ruolo più permissivo role=owner.

    • L'accesso temporaneo (regolato da una data e un'ora di scadenza) è consentito solo per le cartelle con role=reader. Per ulteriori informazioni, consulta consulta Impostare una data di scadenza per limitare l'accesso agli elementi.

  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 trattata come se fosse sempre impostata su true.

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

  5. Per gestire l'appartenenza a un Drive condiviso, l'utente deve avere role=organizer. Solo gli utenti e i gruppi possono essere membri dei Drive condivisi.

Utilizzare il parametro fields

Se vuoi specificare i campi da restituire nella risposta, puoi impostare il fields parametro di sistema con qualsiasi metodo della risorsa permissions. Se ometti il parametro fields, il server restituisce un insieme predefinito di campi specifici per il metodo. Ad esempio, il metodo list restituisce solo i campi id, type, kind, e role per ogni file. Per restituire campi diversi, consulta Restituire campi specifici.

Creare un'autorizzazione

I seguenti due campi sono necessari per creare un'autorizzazione:

  • type: Il 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 il type può eseguire. 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 con type=user o type=group, devi anche fornire un emailAddress per collegare l'utente o il gruppo specifico all'autorizzazione.

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

Per creare un'autorizzazione:

  1. Utilizza il create metodo sulla permissions risorsa con il fileId parametro di percorso 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, fornisci un domain.

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

Richiesta

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 che vogliono 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 tuoi dati e a semplificare la condivisione appropriata da parte degli utenti. 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 questa attività devi aver eseguito l'accesso utilizzando un account con privilegi di super amministratore.

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

  3. Copia l'ID univoco dall'URL del segmento di 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 la condivisione tramite link.

Ottenere un'autorizzazione

Per ottenere un'autorizzazione, utilizza il get metodo sulla risorsa permissions con i parametri di percorso fileId e permissionId. Se non conosci l'ID autorizzazione, puoi elencare tutte le autorizzazioni utilizzando il metodo list.

Il seguente esempio di codice mostra come ottenere un'autorizzazione per ID. La risposta restituisce un'istanza di una risorsa permissions.

Richiesta

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

Risposta

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

Elencare tutte le autorizzazioni

Per elencare le autorizzazioni per un file, una cartella o un Drive condiviso, utilizza il list metodo sulla risorsa permissions con il parametro di percorso fileId.

Trasmetti i seguenti parametri di query per personalizzare la paginazione o filtrare le autorizzazioni:

  • pageSize: il numero massimo di autorizzazioni da restituire per pagina. Se non è impostato per i file in un Drive condiviso, vengono restituiti al massimo 100 risultati. Se non è impostato per i file che non si trovano in un Drive condiviso, viene restituito l'intero elenco.

  • pageToken: un token di pagina ricevuto da una chiamata di elenco precedente. Fornisci questo token per recuperare la pagina successiva.

  • supportsAllDrives: indica se l'app richiedente supporta sia Il mio Drive sia i Drive condivisi.

  • useDomainAdminAccess: imposta su true per inviare la richiesta come amministratore di dominio. Se il parametro fileId fa riferimento a un Drive condiviso e il richiedente è un amministratore del dominio a cui appartiene il Drive condiviso. Per ulteriori informazioni, consulta Gestire i Drive condivisi come amministratori di dominio.

  • includePermissionsForView: le autorizzazioni della visualizzazione aggiuntiva da includere nella risposta. È supportato solo published.

Il seguente esempio di codice mostra come ottenere tutte le autorizzazioni. La risposta restituisce un elenco di autorizzazioni per un file, una cartella o un Drive condiviso.

Richiesta

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

Aggiornare le autorizzazioni

Per aggiornare le autorizzazioni per un file o una cartella, puoi modificare il ruolo assegnato. Per ulteriori informazioni su come trovare l'origine del ruolo, consulta Determinare l'origine del ruolo.

  1. Chiama il update metodo sulla permissions risorsa con il fileId parametro di percorso impostato sul file, sulla cartella o sul Drive condiviso associati e il permissionId parametro di percorso impostato sull'autorizzazione da modificare. Per trovare il permissionId, utilizza il list metodo sulla risorsa permissions con il parametro di percorso 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, Alex ha role=commenter come parte della sua appartenenza a un Drive condiviso. Tuttavia, la tua app può concedere ad Alex role=writer per un file in un Drive condiviso. In questo caso, poiché il nuovo ruolo è più permissivo del ruolo concesso tramite l'appartenenza, la nuova autorizzazione diventa il ruolo effettivo per il file o la cartella.

Puoi applicare gli aggiornamenti tramite la semantica delle patch, il che significa che puoi apportare modifiche parziali a una risorsa. Devi impostare esplicitamente i campi che intendi modificare nella richiesta. I campi non inclusi nella richiesta mantengono i valori esistenti. Per ulteriori informazioni, consulta Utilizzare risorse parziali.

Il seguente esempio di codice mostra come modificare le autorizzazioni per un file o una cartella da commenter a writer. La risposta restituisce un'istanza di una risorsa permissions.

Richiesta

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

Risposta

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

Determinare l'origine del ruolo

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 al Drive condiviso, sul ruolo di una cartella o sul ruolo di un file.

Per determinare l'origine del ruolo per un Drive condiviso o per gli elementi al suo interno, chiama il get metodo sulla permissions risorsa con i parametri di percorso fileId e permissionId e il parametro fields impostato sul campo permissionDetails.

Per trovare il permissionId, utilizza il list metodo sulla permissions risorsa con il fileId parametro di percorso. Per recuperare il permissionDetails campo nella richiesta list, imposta il parametro fields su permissions/permissionDetails.

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

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

Richiesta

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

Aggiornare più autorizzazioni con richieste batch

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

Di seguito è riportato un esempio di esecuzione di una modifica batch delle autorizzazioni 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
import {GoogleAuth} from 'google-auth-library';
import {google} from 'googleapis';

/**
 * Shares a file with a user and a domain.
 * @param {string} fileId The ID of the file to share.
 * @param {string} targetUserEmail The email address of the user to share with.
 * @param {string} targetDomainName The domain to share with.
 * @return {Promise<Array<string>>} A promise that resolves to an array of permission IDs.
 */
async function shareFile(fileId, targetUserEmail, targetDomainName) {
  // Authenticate with Google and get an authorized client.
  // TODO (developer): Use an appropriate auth mechanism for your app.
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });

  // Create a new Drive API client (v3).
  const service = google.drive({version: 'v3', auth});

  /** @type {Array<string>} */
  const permissionIds = [];

  // The permissions to create.
  const permissions = [
    {
      type: 'user',
      role: 'writer',
      emailAddress: targetUserEmail, // e.g., 'user@partner.com'
    },
    {
      type: 'domain',
      role: 'writer',
      domain: targetDomainName, // e.g., 'example.com'
    },
  ];

  // Iterate through the permissions and create them one by one.
  for (const permission of permissions) {
    const result = await service.permissions.create({
      requestBody: permission,
      fileId,
      fields: 'id',
    });

    if (result.data.id) {
      permissionIds.push(result.data.id);
      console.log(`Inserted permission id: ${result.data.id}`);
    } else {
      throw new Error('Failed to create permission');
    }
  }
  return permissionIds;
}

PHP

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

Eliminare un'autorizzazione

Per revocare l'accesso a un file o a una cartella, chiama il delete metodo sulla permissions risorsa con i fileId e i permissionId parametri di percorso impostati per eliminare l'autorizzazione.

Le autorizzazioni ereditate non possono essere revocate. Aggiorna o elimina l'autorizzazione nella cartella principale. L'eliminazione di un'autorizzazione per una cartella revoca anche qualsiasi accesso equivalente agli elementi secondari.

La riduzione delle autorizzazioni rispetto a una cartella principale richiede l'utilizzo dell' impostazione di accesso limitato.

Il seguente esempio di codice mostra come revocare l'accesso eliminando un permissionId. In caso di esito positivo, il corpo della risposta è un oggetto JSON vuoto. Per verificare che l'autorizzazione sia stata rimossa, utilizza il list sulla permissions con il fileId.

Richiesta

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

Impostare una data di scadenza per limitare l'accesso agli elementi

Quando collabori con altre persone a un progetto sensibile, potresti voler limitare il loro accesso a determinati elementi di Drive dopo un periodo di tempo. Per file e cartelle, puoi impostare una data di scadenza per limitare o rimuovere l'accesso all'elemento.

Per impostare la data di scadenza:

Il expirationTime campo indica quando l'autorizzazione scade utilizzando RFC 3339 data e ora. Le ore di scadenza presentano le seguenti limitazioni:

  • Possono essere impostate solo per le autorizzazioni di utenti e gruppi.
  • L'ora deve essere nel futuro.
  • L'ora non può essere superiore a un anno nel futuro.
  • Solo il ruolo reader è idoneo per l'accesso con scadenza a una cartella.

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