Condividere file, cartelle e Drive

Ogni file, cartella e Drive condiviso di Google Drive ha risorse permissions associate. Ogni risorsa identifica l'autorizzazione per un type specifico (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 secondarie 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 all'interno di 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 "Editor", 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 "Lettore", il file eredita role=reader.

Le autorizzazioni ereditate non possono essere rimosse da un file o una cartella in un Drive condiviso. Queste autorizzazioni devono invece essere modificate nella risorsa padre diretta o indiretta 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 per un file o una cartella in My Drive. Pertanto, se un file eredita role=writer da una cartella di My Drive, puoi impostare role=reader sul file per ridurre il suo livello di autorizzazione.

Informazioni sulle funzionalità dei file

La risorsa permissions non determina in definitiva la capacità dell'utente corrente 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 delle 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 suo ruolo viene controllato per verificare le autorizzazioni sul file. Se il ruolo consente di condividere un file, i capabilities correlati al file, ad esempio canShare, vengono compilati in base al ruolo. Se Alex vuole condividere il file, la tua app controlla capabilities per assicurarsi che canShare sia impostato su true.

Per un esempio di recupero del file capabilities, vedi Recuperare le funzionalità del file.

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 corrente. Ad esempio, se l'utente non dispone della funzionalità canComment sul file, la possibilità di aggiungere commenti deve essere disattivata nell'interfaccia utente.

Per controllare le funzionalità, chiama il metodo get() nella risorsa files con il parametro di percorso fileId e il parametro fields impostato sul campo capabilities. Per ulteriori informazioni sui campi restituiti utilizzando il parametro fields, consulta Restituire campi specifici.

Il seguente esempio di codice mostra come verificare le autorizzazioni utente. La risposta restituisce un elenco delle 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.

Richiedi

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 diversi di scenari di condivisione:

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

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

    • Se il valore booleano writersCanShare è impostato su false per il file, l'utente deve disporre dell'autorizzazione role=owner più permissiva.

    • L'accesso temporaneo (regolato da una data e un'ora di scadenza) non è consentito nelle cartelle di Il mio Drive con role=writer. Per ulteriori 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 disporre dell'accesso 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 disporre di role=organizer.

    • Se la limitazione sharingFoldersRequiresOrganizerPermission di un Drive condiviso è impostata su false, gli utenti con role=fileOrganizer possono condividere cartelle nel Drive condiviso.

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

Crea un'autorizzazione

Quando crei un'autorizzazione, sono necessari i seguenti due campi:

  • 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 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 in cui type=user o type=group, devi anche fornire un 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 create() con il parametro di percorso 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, fornisci un domain.

Il seguente esempio di codice mostra come creare un'autorizzazione. La risposta restituisce un'istanza di una risorsa Permission, incluso il 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 per la condivisione dei propri elementi. Puoi incoraggiare gli utenti a condividere gli elementi con un pubblico più specifico o circoscritto 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 per gli utenti. Per ulteriori informazioni, consulta la sezione 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 dei segmenti di pubblico di destinazione, fai clic sul nome del segmento di pubblico di destinazione. Per creare un pubblico di destinazione, vedi Creare 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.

Elenca tutte le autorizzazioni

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

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

Aggiorna autorizzazioni

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

  1. Chiama il metodo update() sulla risorsa permissions con il parametro di percorso permissionId impostato sull'autorizzazione da modificare e il parametro di percorso fileId impostato sul file, sulla cartella o sul Drive condiviso associato. Per trovare permissionId, utilizza il metodo list() 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à un membro. Ad esempio, Alex ha role=commenter come parte della sua iscrizione 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'abbonamento, la nuova autorizzazione diventa il ruolo effettivo per il file o la cartella.

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

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

Determinare l'origine del ruolo

Per modificare il ruolo di 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 in un file.

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

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

Questo campo elenca tutte le autorizzazioni di accesso ai 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 permissionDetails di una risorsa permissions. 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
    }
  ]
}

Aggiornare 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 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
<?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 metodo delete() sulla risorsa permissions con i parametri di percorso fileId e permissionId impostati per eliminare l'autorizzazione.

Per gli elementi 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 elimina l'autorizzazione per il file o la cartella principale.

Il metodo delete() viene utilizzato anche per eliminare le autorizzazioni applicate direttamente a un file o a una cartella di un Drive condiviso.

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

Richiedi

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

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

Quando collabori con persone a un progetto sensibile, potresti voler limitare il loro accesso a determinati file su Drive dopo un periodo di tempo. Puoi farlo impostando una data di scadenza per limitare o rimuovere l'accesso a un file specifico su Il mio Drive.

Per impostare la data di scadenza:

Il campo expirationTime indica la data di scadenza dell'autorizzazione utilizzando il formato RFC 3339 data-ora. I tempi di scadenza presentano le seguenti limitazioni:

  • Possono essere impostate solo per le autorizzazioni di utenti e gruppi.
  • L'ora deve essere futura.
  • L'ora non può essere successiva a un anno.

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