Compartilhar arquivos, pastas e unidades

Cada arquivo, pasta e drive compartilhado do Google Drive tem recursos permissions associados. Cada recurso identifica a permissão para um type (user, group, domain, anyone) e um role (owner, organizer, fileOrganizer, writer, commenter, reader) específicos. Por exemplo, um arquivo pode ter uma permissão que concede a um usuário específico (type=user) acesso somente leitura (role=reader), enquanto outra permissão concede aos membros de um grupo específico (type=group) a capacidade de adicionar comentários a um arquivo (role=commenter).

Para uma lista completa de papéis e as operações permitidas por cada um, consulte Papéis e permissões.

Como funcionam as permissões

As listas de permissões de uma pasta são propagadas para baixo. Todos os arquivos e pastas filhos herdam permissões da pasta principal. Sempre que as permissões ou a hierarquia são alteradas, a propagação ocorre de forma recursiva em todas as pastas aninhadas. Por exemplo, se um arquivo estiver em uma pasta e ela for movida para outra, as permissões da nova pasta serão propagadas para o arquivo. Se a nova pasta conceder ao usuário do arquivo uma nova função, como "gravador", ela vai substituir a função antiga.

Por outro lado, se um arquivo herdar role=writer de uma pasta e for movido para outra pasta que forneça uma função de "leitor", ele vai herdar role=reader.

Não é possível remover permissões herdadas de um arquivo ou pasta em um drive compartilhado. Em vez disso, essas permissões precisam ser ajustadas no item superior direto ou indireto de que foram herdadas. As permissões herdadas podem ser removidas dos itens em "Meu Drive" ou "Compartilhados comigo".

Por outro lado, as permissões herdadas podem ser substituídas em um arquivo ou pasta no Meu Drive. Assim, se um arquivo herdar role=writer de uma pasta do Meu Drive, você poderá definir role=reader no arquivo para diminuir o nível de permissão.

Não há suporte para operações simultâneas de permissões no mesmo arquivo. Somente a última atualização é aplicada.

Entender as funcionalidades dos arquivos

O recurso permissions não determina a capacidade do usuário atual de realizar ações em um arquivo ou pasta. Em vez disso, o recurso files contém uma coleção de campos booleanos capabilities usados para indicar se uma ação pode ser realizada em um arquivo ou pasta. A API Google Drive define esses campos com base no recurso permissions do usuário atual associado ao arquivo ou à pasta.

Por exemplo, quando Alex faz login no seu app e tenta compartilhar um arquivo, a função dele é verificada para conferir as permissões no arquivo. Se o papel permitir que eles compartilhem um arquivo, os capabilities relacionados a ele, como canShare, serão definidos em relação ao papel. Se Alex quiser compartilhar o arquivo, o app vai verificar o capabilities para garantir que canShare esteja definido como true.

Receber recursos de arquivo

Quando o app abre um arquivo, ele precisa verificar os recursos dele e renderizar a interface para refletir as permissões do usuário atual. Por exemplo, se o usuário não tiver a capacidade canComment no arquivo, a opção de comentar deverá ser desativada na interface.

Para verificar as funcionalidades, chame o método get no recurso files com o parâmetro de caminho fileId e o parâmetro fields definido como o campo capabilities. Para mais informações sobre como retornar campos usando o parâmetro fields, consulte Retornar campos específicos.

O exemplo de código a seguir mostra como verificar as permissões do usuário. A resposta retorna uma lista de recursos que o usuário tem no arquivo. Cada capacidade corresponde a uma ação refinada que um usuário pode realizar. Alguns campos só são preenchidos para itens em drives compartilhados.

Solicitação

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

Resposta

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

Cenários para compartilhar recursos do Drive

Há cinco tipos diferentes de cenários de compartilhamento:

  1. Para compartilhar um arquivo no Meu Drive, o usuário precisa ter role=writer ou role=owner.

  2. Para compartilhar uma pasta no Meu Drive, o usuário precisa ter role=writer ou role=owner.

    • Se o valor booleano writersCanShare estiver definido como false para o arquivo, o usuário precisará ter a permissão mais permissiva role=owner.

    • O acesso temporário (regido por uma data e hora de validade) não é permitido em pastas do Meu Drive com role=writer. Para mais informações, consulte Definir uma data de validade para limitar o acesso a arquivos.

  3. Para compartilhar um arquivo em um drive compartilhado, o usuário precisa ter role=writer, role=fileOrganizer ou role=organizer.

    • A configuração writersCanShare não se aplica a itens em drives compartilhados. Ele é tratado como se estivesse sempre definido como true.

  4. Para compartilhar uma pasta em um drive compartilhado, o usuário precisa ter role=organizer.

  5. Para gerenciar a participação em um drive compartilhado, o usuário precisa ter role=organizer. Somente usuários e grupos podem ser membros de drives compartilhados.

Usar o parâmetro "fields"

Se você quiser especificar os campos a serem retornados na resposta, defina o parâmetro do sistema fields com qualquer método do recurso permissions. Se você omitir o parâmetro fields, o servidor vai retornar um conjunto padrão de campos específicos do método. Por exemplo, o método list retorna apenas os campos id, type, kind e role de cada arquivo. Para retornar campos diferentes, consulte Retornar campos específicos.

Criar uma permissão

Os dois campos a seguir são necessários ao criar uma permissão:

  • type: o type identifica o escopo da permissão (user, group, domain ou anyone). Uma permissão com type=user se aplica a um usuário específico, enquanto uma permissão com type=domain se aplica a todos em um domínio específico.

  • role: o campo role identifica as operações que o type pode realizar. Por exemplo, uma permissão com type=user e role=reader concede a um usuário específico acesso somente leitura ao arquivo ou à pasta. Ou uma permissão com type=domain e role=commenter permite que todos no domínio adicionem comentários a um arquivo. Para conferir uma lista completa de papéis e as operações permitidas por cada um, consulte Papéis e permissões.

Ao criar uma permissão em que type=user ou type=group, você também precisa fornecer um emailAddress para vincular o usuário ou grupo específico à permissão.

Ao criar uma permissão em que type=domain, também é necessário fornecer um domain para vincular um domínio específico à permissão.

Para criar uma permissão:

  1. Use o método create no recurso permissions com o parâmetro de caminho fileId para o arquivo ou a pasta associada.
  2. No corpo da solicitação, especifique type e role.
  3. Se for type=user ou type=group, forneça um emailAddress. Se type=domain, forneça um domain.

O exemplo de código a seguir mostra como criar uma permissão. A resposta retorna uma instância de um recurso permissions, incluindo o permissionId atribuído.

Solicitação

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

Resposta

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

Usar públicos-alvo

Os públicos-alvo são grupos de pessoas, como departamentos ou equipes, que você pode recomendar para os usuários compartilharem itens. Você pode incentivar os usuários a compartilhar itens com um público mais específico ou limitado, e não com toda a organização. Os públicos-alvo podem ajudar você a melhorar a segurança e a privacidade dos seus dados e facilitar o compartilhamento adequado para os usuários. Para mais informações, consulte Sobre públicos-alvo.

Para usar públicos-alvo:

  1. No Google Admin Console, acesse Menu > Diretório > Públicos-alvo.

    Acesse Públicos-alvo

    Para realizar essa tarefa, você precisa fazer login usando uma conta com privilégios de superadministrador.

  2. Na lista de públicos-alvo, clique no nome do público-alvo. Para criar um público-alvo, consulte Criar um público-alvo.

  3. Copie o ID exclusivo do URL do público-alvo: https://admin.google.com/ac/targetaudiences/ID.

  4. Crie uma permissão com type=domain e defina o campo domain como ID.audience.googledomains.com.

Para saber como os usuários interagem com os públicos-alvo, consulte Experiência do usuário para compartilhamento de links.

Receber uma permissão

Para receber uma permissão, use o método get no recurso permissions com os parâmetros de caminho fileId e permissionId. Se você não souber o ID da permissão, liste todas as permissões usando o método list.

O exemplo de código a seguir mostra como receber uma permissão por ID. A resposta retorna uma instância de um recurso permissions.

Solicitação

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

Resposta

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

Listar todas as permissões

Para listar as permissões de um arquivo, pasta ou drive compartilhado, use o método list no recurso permissions com o parâmetro de caminho fileId.

Transmita os seguintes parâmetros de consulta para personalizar a paginação ou filtrar permissões:

  • pageSize: o número máximo de permissões a serem retornadas por página. Se não for definido para arquivos em um drive compartilhado, no máximo 100 resultados serão retornados. Se não for definido para arquivos que não estão em um drive compartilhado, toda a lista será retornada.

  • pageToken: um token de página recebido de uma chamada de lista anterior. Forneça esse token para recuperar a página subsequente.

  • supportsAllDrives: se o app solicitante é compatível com Meu Drive e drives compartilhados.

  • useDomainAdminAccess: defina como true para emitir a solicitação como um administrador de domínio. Se o parâmetro fileId se referir a um drive compartilhado e o solicitante for administrador do domínio a que o drive compartilhado pertence. Para mais informações, consulte Gerenciar drives compartilhados como administradores de domínio.

  • includePermissionsForView: as permissões da visualização adicional a serem incluídas na resposta. Somente published é aceito.

O exemplo de código a seguir mostra como receber todas as permissões. A resposta retorna uma lista de permissões para um arquivo, uma pasta ou um drive compartilhado.

Solicitação

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

Resposta

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

Atualizar permissões

Para atualizar as permissões de um arquivo ou pasta, mude a função atribuída. Para mais informações sobre como encontrar a origem do papel, consulte Determinar a origem do papel.

  1. Chame o método update no recurso permissions com o parâmetro de caminho fileId definido como o arquivo, a pasta ou o drive compartilhado associado e o parâmetro de caminho permissionId definido como a permissão a ser alterada. Para encontrar o permissionId, use o método list no recurso permissions com o parâmetro de caminho fileId.

  2. Na solicitação, identifique o novo role.

Você pode conceder permissões em arquivos ou pastas individuais em um drive compartilhado, mesmo que o usuário ou grupo já seja um participante. Por exemplo, Alex tem role=commenter como parte da participação em um drive compartilhado. No entanto, seu app pode conceder a Alex role=writer para um arquivo em um drive compartilhado. Nesse caso, como a nova função é mais permissiva do que a função concedida pela assinatura, a nova permissão se torna a função efetiva do arquivo ou da pasta.

É possível aplicar atualizações usando a semântica de patch, ou seja, fazer modificações parciais em um recurso. É necessário definir explicitamente os campos que você pretende modificar na solicitação. Os campos não incluídos na solicitação mantêm os valores atuais. Para mais informações, consulte Como trabalhar com recursos parciais.

O exemplo de código a seguir mostra como mudar as permissões de um arquivo ou pasta de commenter para writer. A resposta retorna uma instância de um recurso permissions.

Solicitação

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

Resposta

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

Determinar a origem da função

Para mudar a função em um arquivo ou pasta, você precisa saber a origem dela. Para drives compartilhados, a origem de uma função pode ser baseada na participação no drive compartilhado, na função em uma pasta ou na função em um arquivo.

Para determinar a origem da função de uma unidade compartilhada ou de itens nela, chame o método get no recurso permissions com os parâmetros de caminho fileId e permissionId, e o parâmetro fields definido como o campo permissionDetails.

Para encontrar o permissionId, use o método list no recurso permissions com o parâmetro de caminho fileId. Para buscar o campo permissionDetails na solicitação list, defina o parâmetro fields como permissions/permissionDetails.

Esse campo enumera todas as permissões de arquivo herdadas e diretas para o usuário, grupo ou domínio.

O exemplo de código a seguir mostra como determinar a origem da função. A resposta retorna o permissionDetails de um recurso permissions. O campo inheritedFrom fornece o ID do item de onde a permissão é herdada.

Solicitação

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

Resposta

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

Atualizar várias permissões com solicitações em lote

Recomendamos usar solicitações em lote para modificar várias permissões.

Este é um exemplo de como fazer uma modificação de permissão em lote com uma biblioteca de cliente.

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

Excluir uma permissão

Para revogar o acesso a um arquivo ou pasta, chame o método delete no recurso permissions com os parâmetros de caminho fileId e permissionId definidos para excluir a permissão.

Para itens em "Meu Drive", é possível excluir uma permissão herdada. A exclusão de uma permissão herdada revoga o acesso ao item e aos itens filhos, se houver.

Para itens em um drive compartilhado, não é possível revogar as permissões herdadas. Atualize ou exclua a permissão no arquivo ou pasta principal.

O método delete também é usado para excluir permissões aplicadas diretamente a um arquivo ou pasta de um drive compartilhado.

O exemplo de código a seguir mostra como revogar o acesso excluindo um permissionId. Se não houver nenhum problema, o corpo da resposta será um objeto JSON vazio. Para confirmar que a permissão foi removida, use o método list no recurso permissions com o parâmetro de caminho fileId.

Solicitação

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

Definir uma data de expiração para limitar o acesso a arquivos

Ao trabalhar com pessoas em um projeto sensível, talvez você queira restringir o acesso delas a determinados arquivos no Drive após um período. Nos arquivos no Meu Drive, você pode definir uma data de validade para limitar ou remover o acesso.

Para definir a data de validade:

O campo expirationTime indica quando a permissão expira usando data e hora RFC 3339. Os tempos de expiração têm as seguintes restrições:

  • Elas só podem ser definidas em permissões de usuários e grupos.
  • O horário precisa ser no futuro.
  • O horário não pode ser mais de um ano no futuro.

Para mais informações sobre a data de validade, consulte os seguintes artigos: