Condividere file, cartelle e Drive

A ogni file, cartella e Drive condiviso di Google Drive sono associate risorse permissions. Ogni risorsa identifica l'autorizzazione per un type (user, group, domain, anyone) e un role (owner, organizer, fileOrganizer, writer, commenter, reader) specifici. 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 si propagano 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 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 "autore", sostituisce il suo vecchio ruolo.

Al contrario, se un file eredita role=writer da una cartella e viene spostato in un'altra cartella che fornisce il 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 regolate nell'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 del mio Drive, puoi impostare role=reader sul file per abbassarne il livello di autorizzazione.

Informazioni sulle funzionalità dei file

La risorsa permissions non determina in ultima analisi la capacità dell'utente corrente di eseguire azioni su un file o una cartella. La risorsa files 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 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, viene controllato se il suo ruolo ha autorizzazioni per il file. Se il ruolo consente di condividere un file, i capabilities relativi al file, ad esempio canShare, vengono compilati in base al ruolo. Se Alex vuole condividere il file, la tua app controlla il valore di capabilities per assicurarsi che canShare sia impostato su true.

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

Ottenere le funzionalità dei file

Quando l'app apre un file, deve verificare le relative funzionalità e visualizzare l'interfaccia utente in modo che rifletta le autorizzazioni dell'utente corrente. Ad esempio, se l'utente non dispone di una funzionalità canComment per il file, la possibilità di aggiungere commenti dovrebbe essere disattivata nell'interfaccia utente.

Per controllare le funzionalità, chiama il metodo get() nella risorsa files con il parametro fileId del percorso e il parametro fields impostato sul campo capabilities. Per approfondire i campi da restituire utilizzando il parametro fields, consulta Restituire campi specifici.

Mostra un esempio

Il seguente esempio di codice mostra come verificare le autorizzazioni utente. La risposta restituisce un elenco delle funzionalità di cui l'utente dispone sul file. Ogni funzionalità corrisponde a un'azione granulare che un utente può eseguire. 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
  }
}

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 disporre del ruolo role=writer o role=owner.

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

    • Se il valore booleano writersCanShare è impostato su false per il file, l'utente deve disporre del valore 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, consulta la sezione Impostare una data di scadenza per limitare l'accesso ai file.

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

    • L'impostazione writersCanShare non si applica agli elementi dei Drive condivisi. Viene trattato come se fosse sempre impostato su true.

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

    • Se la limitazione sharingFoldersRequiresOrganizerPermission su un Drive condiviso è impostata su false, gli utenti con role=fileOrganizer possono condividere le cartelle al suo interno.

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

Creare un'autorizzazione

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

  • type: il valore 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 associare l'utente o il gruppo specifico all'autorizzazione.

Quando crei un'autorizzazione in cui type=domain, devi anche fornire un valore domain per associare 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 associato.
  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.

Mostra un esempio

Il seguente esempio di codice mostra come creare una autorizzazione. La risposta restituisce un'istanza di una risorsa Permission, incluso l'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 semplificare la condivisione da parte degli utenti in modo appropriato. 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 pubblico di destinazione. Per creare un pubblico di destinazione, consulta 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.

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

Aggiorna 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 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 appartenenza a un Drive condiviso. Tuttavia, la tua app può concedere ad Alexrole=writer l'accesso a 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.

Mostra un esempio

Il seguente esempio di codice mostra come modificare le autorizzazioni per un file o una cartella da utente che può aggiungere commenti a utente che può scrivere. 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"
}

Determina l'origine del ruolo

Per modificare il ruolo di un file o di una cartella, devi conoscere la relativa origine. 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 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 file ereditate e dirette per l'utente, il gruppo o il dominio.

Mostra un esempio

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.

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 richieste collettive

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

Di seguito è riportato un esempio di esecuzione di una modifica collettiva 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
/**
 * 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;
        }
    }
}

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 comporta la revoca dell'accesso all'elemento e agli eventuali elementi secondari.

Per gli elementi di un Drive condiviso, le autorizzazioni ereditate non possono essere revocate. Aggiorna o elimina l'autorizzazione sul file o sulla 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.

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 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 altre persone a un progetto sensibile, potresti voler limitare il loro accesso a determinati file su Drive dopo un determinato 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 periodi di scadenza sono soggetti alle seguenti limitazioni:

  • Possono essere impostati solo sulle autorizzazioni utente e gruppo.
  • L'ora deve essere futura.
  • L'ora non può essere successiva a quella corrente di più di un anno.

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