Gerenciar drives compartilhados

Este documento contém tarefas relacionadas ao gerenciamento de drives compartilhados, como a criação deles e o gerenciamento de participantes e permissões, usando a API Google Drive.

Se você quiser especificar os campos a serem retornados na resposta, defina o fields parâmetro do sistemacom qualquer método do recurso drives. Se você não especificar o parâmetro fields, o servidor retornará um conjunto padrão de campos específicos do método. Por exemplo, o list método retorna apenas os campos kind, id, e name para cada drive compartilhado. Para mais informações, consulte Retornar campos específicos.

Para saber mais sobre os limites de pastas de drives compartilhados, consulte Limites de pastas de drives compartilhados.

Pré-requisitos

Antes de criar e gerenciar drives compartilhados, verifique se você atende aos seguintes requisitos:

  • Conta do Google Workspace:os drives compartilhados estão disponíveis nas edições compatíveis do Google Workspace (como Business Standard, Business Plus, Enterprise e Education). As Contas do Google pessoais (@gmail.com) não podem criar drives compartilhados.
  • Permissão de criação:os administradores de domínio podem configurar se os usuários da organização podem criar drives compartilhados. O usuário autenticado precisa pertencer a uma unidade organizacional que tenha permissão para criar drives compartilhados.
  • Escopo do OAuth 2.0:seu app precisa ser autorizado com o escopo https://www.googleapis.com/auth/drive.
  • Papéis:quando um usuário cria um drive compartilhado, ele recebe automaticamente o papel de organizer nesse drive. O gerenciamento das configurações do drive , a renomeação do drive, a adição ou remoção de participantes e a exclusão do drive compartilhado exigem o papel de organizer. Para mais informações sobre papéis, consulte Papéis para drives compartilhados.
  • Acesso de administrador de domínio:os administradores de domínio podem gerenciar qualquer drive compartilhado na organização, independentemente da participação, transmitindo useDomainAdminAccess=true. Para mais informações, consulte Gerenciar drives compartilhados como administradores de domínio.

Criar um drive compartilhado

Para criar um drive compartilhado, use o create método no drives recurso com o requestId parâmetro.

O parâmetro requestId identifica a tentativa lógica de criação idempotente de um drive compartilhado. Se a solicitação expirar ou retornar um erro de back-end indeterminado, a mesma solicitação poderá ser repetida e não criará duplicatas. O requestId e o corpo da solicitação precisam permanecer os mesmos.

O exemplo de código a seguir mostra como criar um drive compartilhado:

Java

drive/snippets/drive_v3/src/main/java/CreateDrive.java
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
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.DriveScopes;
import com.google.api.services.drive.model.Drive;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Arrays;
import java.util.UUID;

/* class to demonstrate use-case of Drive's create drive. */
public class CreateDrive {

  /**
   * Create a drive.
   *
   * @return Newly created drive id.
   * @throws IOException if service account credentials file not found.
   */
  public static String createDrive() 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.*/
    GoogleCredentials credentials =
        GoogleCredentials.getApplicationDefault().createScoped(Arrays.asList(DriveScopes.DRIVE));
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

    // Build a new authorized API client service.
    com.google.api.services.drive.Drive service =
        new com.google.api.services.drive.Drive.Builder(new NetHttpTransport(),
            GsonFactory.getDefaultInstance(),
            requestInitializer)
            .setApplicationName("Drive samples")
            .build();

    Drive driveMetadata = new Drive();
    driveMetadata.setName("Project Resources");
    String requestId = UUID.randomUUID().toString();
    try {
      Drive drive = service.drives().create(requestId,
              driveMetadata)
          .execute();
      System.out.println("Drive ID: " + drive.getId());

      return drive.getId();
    } catch (GoogleJsonResponseException e) {
      // TODO(developer) - handle error appropriately
      System.err.println("Unable to create drive: " + e.getDetails());
      throw e;
    }
  }
}

Python

drive/snippets/drive-v3/drive_snippet/create_drive.py
import uuid

import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def create_drive():
  """Create a drive.
  Returns:
      Id of the created drive

  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)

    drive_metadata = {"name": "Project Resources"}
    request_id = str(uuid.uuid4())
    # pylint: disable=maybe-no-member
    drive = (
        service.drives()
        .create(body=drive_metadata, requestId=request_id, fields="id")
        .execute()
    )
    print(f'Drive ID: {drive.get("id")}')

  except HttpError as error:
    print(f"An error occurred: {error}")
    drive = None

  return drive.get("id")


if __name__ == "__main__":
  create_drive()

Node.js

drive/snippets/drive_v3/drive_snippets/create_drive.js
import {GoogleAuth} from 'google-auth-library';
import {google} from 'googleapis';
import {v4 as uuid} from 'uuid';

/**
 * Creates a new shared drive.
 * @return {Promise<string>} The ID of the created shared drive.
 */
async function createDrive() {
  // 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});

  // The metadata for the new shared drive.
  const driveMetadata = {
    name: 'Project resources',
  };

  // A unique request ID to avoid creating duplicate shared drives.
  const requestId = uuid();

  // Create the new shared drive.
  const Drive = await service.drives.create({
    requestBody: driveMetadata,
    requestId,
    fields: 'id',
  });

  // Print the ID of the new shared drive.
  console.log('Drive Id:', Drive.data.id);
  if (!Drive.data.id) {
    throw new Error('Drive ID not found.');
  }
  return Drive.data.id;
}

PHP

drive/snippets/drive_v3/src/DriveCreateDrive.php
<?php
use Google\Client;
use Google\Service\Drive;
use Ramsey\Uuid\Uuid;
function createDrive()
{
    try {
        $client = new Client();
        $client->useApplicationDefaultCredentials();
        $client->addScope(Drive::DRIVE);
        $driveService = new Drive($client);

        $driveMetadata = new Drive\Drive(array(
                'name' => 'Project Resources'));
        $requestId = Uuid::uuid4()->toString();
        $drive = $driveService->drives->create($requestId, $driveMetadata, array(
                'fields' => 'id'));
        printf("Drive ID: %s\n", $drive->id);
        return $drive->id;
    } catch(Exception $e)  {
        echo "Error Message: ".$e;
    }  

}

.NET

drive/snippets/drive_v3/DriveV3Snippets/CreateDrive.cs
using Google.Apis.Auth.OAuth2;
using Google.Apis.Drive.v3;
using Google.Apis.Drive.v3.Data;
using Google.Apis.Services;

namespace DriveV3Snippets
{
    // Class to demonstrate use of Drive's create drive.
    public class CreateDrive
    {
        /// <summary>
        /// Create a drive.
        /// </summary>
        /// <returns>newly created drive Id.</returns>
        public static string DriveCreateDrive()
        {
            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 driveMetadata = new Drive()
                {
                    Name = "Project Resources"
                };
                var requestId = Guid.NewGuid().ToString();
                var request = service.Drives.Create(driveMetadata, requestId);
                request.Fields = "id";
                var drive = request.Execute();
                Console.WriteLine("Drive ID: " + drive.Id);
                return drive.Id;
            }
            catch (Exception e)
            {
                // TODO(developer) - handle error appropriately
                if (e is AggregateException)
                {
                    Console.WriteLine("Credential Not found");
                }
                else
                {
                    throw;
                }
            }
            return null;
        }
    }
}

As chamadas para o create método são idempotentes.

Se o drive compartilhado foi criado com sucesso em uma solicitação anterior ou devido a uma nova tentativa, o método retorna uma instância do recurso drives. Às vezes, como após um período prolongado ou se o corpo da solicitação tiver mudado, um erro 409 poderá ser retornado indicando que o requestId precisa ser descartado.

Receber um drive compartilhado

Para receber metadados de um drive compartilhado, use o get método no drives recurso com o driveId parâmetro de caminho. Se você não souber o ID do drive, poderá listar todos os drives compartilhados usando o método list.

O método get retorna um drive compartilhado como uma instância de um recurso drives.

Para emitir a solicitação como administrador de domínio, defina o parâmetro de consulta useDomainAdminAccess como true. Para mais informações, consulte Gerenciar drives compartilhados como administradores de domínio.

Listar drives compartilhados

Para listar os drives compartilhados de um usuário, use o list método no drives recurso. O método retorna uma lista de drives compartilhados.

Transmita os seguintes parâmetros de consulta para personalizar a paginação ou filtrar drives compartilhados:

  • pageSize: o número máximo de drives compartilhados a serem retornados por página.

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

  • q: string de consulta para pesquisar drives compartilhados. Para mais informações, consulte Pesquisar drives compartilhados.

  • useDomainAdminAccess: defina como true para emitir a solicitação como administrador de domínio e retornar todos os drives compartilhados do domínio em que o solicitante é um administrador. Para mais informações, consulte Gerenciar drives compartilhados como administradores de domínio.

Atualizar um drive compartilhado

Para atualizar os metadados de um drive compartilhado, use o update método no drives recurso com o driveId parâmetro de caminho.

O método retorna um drive compartilhado como uma instância de um recurso drives.

Para emitir a solicitação como administrador de domínio, defina o parâmetro de consulta useDomainAdminAccess como true. Para mais informações, consulte Gerenciar drives compartilhados como administradores de domínio.

Ocultar e reexibir um drive compartilhado

Para ocultar um drive compartilhado da visualização padrão, use o hide método no drives recurso com o driveId parâmetro.

Quando um drive compartilhado é oculto, o Drive marca o recurso de drive compartilhado como hidden=true. Os drives compartilhados ocultos não aparecem na interface do Drive nem na lista de arquivos retornados.

Para restaurar um drive compartilhado para a visualização padrão, use o unhide método no drives recurso com o driveId parâmetro.

Os dois métodos retornam um drive compartilhado como uma instância de um recurso drives.

Excluir um drive compartilhado

Para excluir permanentemente um drive compartilhado, use o delete método no drives recurso com o driveId parâmetro.

Antes de excluir um drive compartilhado, todo o conteúdo dele precisa ser movido para a lixeira ou excluído. O usuário também precisa ter role=organizer na pasta do drive compartilhado. Para mais informações, consulte Colocar arquivos e pastas na lixeira ou excluir.

Transmita os seguintes parâmetros de consulta:

  • useDomainAdminAccess: defina como true para emitir a solicitação como administrador de domínio. Para mais informações, consulte Gerenciar drives compartilhados como administradores de domínio.

  • allowItemDeletion: defina como true para excluir itens no drive compartilhado. Só é compatível quando useDomainAdminAccess também está definido como true.

Adicionar ou remover participantes de um drive compartilhado

Adicione ou remova participantes de um drive compartilhado usando o permissions recurso.

Para adicionar um participante, crie a permissão no drive compartilhado. Os métodos de permissão também podem ser usados em arquivos individuais em um drive compartilhado para conceder privilégios extras aos participantes ou permitir que não participantes colaborem em itens específicos.

Para mais informações e exemplos de código, consulte Compartilhar arquivos, pastas e drives.

Gerenciar drives compartilhados como administradores de domínio

Aplique o useDomainAdminAccess parâmetro com os drives e permissions recursos para gerenciar drives compartilhados em uma organização.

Os usuários que chamam esses métodos com useDomainAdminAccess=true precisam ter o Drive and Docs privilégio de administrador. Os administradores podem pesquisar drives compartilhados ou atualizar permissões para drives compartilhados pertencentes à organização, independentemente da participação do administrador em qualquer drive compartilhado.

Ao usar contas de serviço, talvez seja necessário representar um administrador autenticado usando a representação de conta de serviço. As contas de serviço não pertencem ao seu domínio do Google Workspace, diferentemente das contas de usuário. Se você compartilhar recursos do Google Workspace, como documentos ou eventos, com todo o domínio do Google Workspace, eles não serão compartilhados com contas de serviço. Para mais informações, consulte Visão geral das contas de serviço.

Recuperar um drive compartilhado que não tem um organizador

O exemplo de código a seguir mostra como recuperar drives compartilhados que não têm mais um organizador.

Java

drive/snippets/drive_v3/src/main/java/RecoverDrive.java
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.DriveScopes;
import com.google.api.services.drive.model.Drive;
import com.google.api.services.drive.model.DriveList;
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 Drive's shared drive without an organizer. */
public class RecoverDrive {

  /**
   * Find all shared drives without an organizer and add one.
   *
   * @param realUser User's email id.
   * @return All shared drives without an organizer.
   * @throws IOException if shared drive not found.
   */
  public static List<Drive> recoverDrives(String realUser)
      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.*/
    GoogleCredentials credentials =
        GoogleCredentials.getApplicationDefault().createScoped(Arrays.asList(DriveScopes.DRIVE));
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

    // Build a new authorized API client service.
    com.google.api.services.drive.Drive service =
        new com.google.api.services.drive.Drive.Builder(new NetHttpTransport(),
            GsonFactory.getDefaultInstance(),
            requestInitializer)
            .setApplicationName("Drive samples")
            .build();
    List<Drive> drives = new ArrayList<Drive>();

    // Find all shared drives without an organizer and add one.
    // Note: This example does not capture all cases. Shared drives
    // that have an empty group as the sole organizer, or an
    // organizer outside the organization are not captured. A
    // more exhaustive approach would evaluate each shared drive
    // and the associated permissions and groups to ensure an active
    // organizer is assigned.
    String pageToken = null;
    Permission newOrganizerPermission = new Permission()
        .setType("user")
        .setRole("organizer");

    newOrganizerPermission.setEmailAddress(realUser);


    do {
      DriveList result = service.drives().list()
          .setQ("organizerCount = 0")
          .setFields("nextPageToken, drives(id, name)")
          .setUseDomainAdminAccess(true)
          .setPageToken(pageToken)
          .execute();
      for (Drive drive : result.getDrives()) {
        System.out.printf("Found drive without organizer: %s (%s)\n",
            drive.getName(), drive.getId());
        // Note: For improved efficiency, consider batching
        // permission insert requests
        Permission permissionResult = service.permissions()
            .create(drive.getId(), newOrganizerPermission)
            .setUseDomainAdminAccess(true)
            .setSupportsAllDrives(true)
            .setFields("id")
            .execute();
        System.out.printf("Added organizer permission: %s\n",
            permissionResult.getId());

      }

      drives.addAll(result.getDrives());

      pageToken = result.getNextPageToken();
    } while (pageToken != null);

    return drives;
  }
}

Python

drive/snippets/drive-v3/drive_snippet/recover_drives.py
import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def recover_drives(real_user):
  """Find all shared drives without an organizer and add one.
  Args:
      real_user:User ID for the new organizer.
  Returns:
      drives object

  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)

    drives = []

    # pylint: disable=maybe-no-member
    page_token = None
    new_organizer_permission = {
        "type": "user",
        "role": "organizer",
        "emailAddress": "user@example.com",
    }
    new_organizer_permission["emailAddress"] = real_user

    while True:
      response = (
          service.drives()
          .list(
              q="organizerCount = 0",
              fields="nextPageToken, drives(id, name)",
              useDomainAdminAccess=True,
              pageToken=page_token,
          )
          .execute()
      )
      for drive in response.get("drives", []):
        print(
            "Found shared drive without organizer: "
            f"{drive.get('title')}, {drive.get('id')}"
        )
        permission = (
            service.permissions()
            .create(
                fileId=drive.get("id"),
                body=new_organizer_permission,
                useDomainAdminAccess=True,
                supportsAllDrives=True,
                fields="id",
            )
            .execute()
        )
        print(f'Added organizer permission: {permission.get("id")}')

      drives.extend(response.get("drives", []))
      page_token = response.get("nextPageToken", None)
      if page_token is None:
        break

  except HttpError as error:
    print(f"An error occurred: {error}")

  return drives


if __name__ == "__main__":
  recover_drives(real_user="gduser1@workspacesamples.dev")

Node.js

drive/snippets/drive_v3/drive_snippets/recover_drives.js
import {GoogleAuth} from 'google-auth-library';
import {google} from 'googleapis';

/**
 * Finds all shared drives without an organizer and adds one.
 * @param {string} userEmail The email of the user to assign ownership to.
 * @return {Promise<object[]>} A list of the recovered drives.
 */
async function recoverDrives(userEmail) {
  // 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});

  // The permission to add to the shared drive.
  const newOrganizerPermission = {
    type: 'user',
    role: 'organizer',
    emailAddress: userEmail, // e.g., 'user@example.com'
  };

  // List all shared drives with no organizers.
  const result = await service.drives.list({
    q: 'organizerCount = 0',
    fields: 'nextPageToken, drives(id, name)',
    useDomainAdminAccess: true,
  });

  // Add the new organizer to each found shared drive.
  for (const drive of result.data.drives ?? []) {
    if (!drive.id) {
      continue;
    }

    console.log('Found shared drive without organizer:', drive.name, drive.id);
    await service.permissions.create({
      requestBody: newOrganizerPermission,
      fileId: drive.id,
      useDomainAdminAccess: true,
      supportsAllDrives: true,
      fields: 'id',
    });
  }
  return result.data.drives ?? [];
}

PHP

drive/snippets/drive_v3/src/DriveRecoverDrives.php
<?php
use Google\Client;
use Google\Service\Drive;
use Ramsey\Uuid\Uuid;
function recoverDrives()
{
   try {
    $client = new Client();
    $client->useApplicationDefaultCredentials();
    $client->addScope(Drive::DRIVE);
    $driveService = new Drive($client);

    $realUser = readline("Enter user email address: ");

    $drives = array();
    // Find all shared drives without an organizer and add one.
    // Note: This example does not capture all cases. Shared drives
    // that have an empty group as the sole organizer, or an
    // organizer outside the organization are not captured. A
    // more exhaustive approach would evaluate each shared drive
    // and the associated permissions and groups to ensure an active
    // organizer is assigned.
    $pageToken = null;
    $newOrganizerPermission = new Drive\Permission(array(
        'type' => 'user',
        'role' => 'organizer',
        'emailAddress' => 'user@example.com'
    ));
    $newOrganizerPermission['emailAddress'] = $realUser;
    do {
        $response = $driveService->drives->listDrives(array(
            'q' => 'organizerCount = 0',
            'fields' => 'nextPageToken, drives(id, name)',
            'useDomainAdminAccess' => true,
            'pageToken' => $pageToken
        ));
        foreach ($response->drives as $drive) {
            printf("Found shared drive without organizer: %s (%s)\n",
                $drive->name, $drive->id);
            $permission = $driveService->permissions->create($drive->id,
                $newOrganizerPermission,
                array(
                    'fields' => 'id',
                    'useDomainAdminAccess' => true,
                    'supportsAllDrives' => true
                ));
            printf("Added organizer permission: %s\n", $permission->id);
        }
        array_push($drives, $response->drives);
        $pageToken = $response->pageToken;
    } while ($pageToken != null);
    return $drives;
   } catch(Exception $e) {
      echo "Error Message: ".$e;
   }
}

.NET

drive/snippets/drive_v3/DriveV3Snippets/RecoverDrives.cs
using Google.Apis.Auth.OAuth2;
using Google.Apis.Drive.v3;
using Google.Apis.Drive.v3.Data;
using Google.Apis.Services;

namespace DriveV3Snippets
{
    // Class to demonstrate use-case of Drive's shared drive without an organizer.
    public class RecoverDrives
    {
        /// <summary>
        /// Find all shared drives without an organizer and add one.
        /// </summary>
        /// <param name="realUser">User ID for the new organizer.</param>
        /// <returns>all shared drives without an organizer.</returns>
        public static IList<Drive> DriveRecoverDrives(string realUser)
        {
            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 drives = new List<Drive>();
                // Find all shared drives without an organizer and add one.
                // Note: This example does not capture all cases. Shared drives
                // that have an empty group as the sole organizer, or an
                // organizer outside the organization are not captured. A
                // more exhaustive approach would evaluate each shared drive
                // and the associated permissions and groups to ensure an active
                // organizer is assigned.
                string pageToken = null;
                var newOrganizerPermission = new Permission()
                {
                    Type = "user",
                    Role = "organizer",
                    EmailAddress = realUser
                };

                do
                {
                    var request = service.Drives.List();
                    request.UseDomainAdminAccess = true;
                    request.Q = "organizerCount = 0";
                    request.Fields = "nextPageToken, drives(id, name)";
                    request.PageToken = pageToken;
                    var result = request.Execute();
                    foreach (var drive in result.Drives)
                    {
                        Console.WriteLine(("Found abandoned shared drive: {0} ({1})",
                            drive.Name, drive.Id));
                        // Note: For improved efficiency, consider batching
                        // permission insert requests
                        var permissionRequest = service.Permissions.Create(
                            newOrganizerPermission,
                            drive.Id
                        );
                        permissionRequest.UseDomainAdminAccess = true;
                        permissionRequest.SupportsAllDrives = true;
                        permissionRequest.Fields = "id";
                        var permissionResult = permissionRequest.Execute();
                        Console.WriteLine("Added organizer permission: {0}", permissionResult.Id);
                    }

                    pageToken = result.NextPageToken;
                } while (pageToken != null);

                return drives;
            }
            catch (Exception e)
            {
                // TODO(developer) - handle error appropriately
                if (e is AggregateException)
                {
                    Console.WriteLine("Credential Not found");
                }
                else
                {
                    throw;
                }
            }
            return null;
        }
    }
}

Impedir que os usuários façam o download, imprimam ou copiem arquivos

Você pode limitar como os usuários podem fazer o download, imprimir e copiar arquivos em drives compartilhados.

Para determinar se o usuário pode mudar as restrições de download aplicadas pelo organizador de um drive compartilhado, verifique o capabilities.canChangeDownloadRestriction campo booleano. Se capabilities.canChangeDownloadRestriction estiver definido como true, as restrições de download poderão ser aplicadas ao drive compartilhado. Para mais informações, consulte Entender os recursos de arquivos.

O drives recurso contém uma coleção de campos booleanos restrictions usados para indicar se uma ação pode ser realizada em um drive compartilhado. As restrições se aplicam a um drive compartilhado ou a itens dentro de um drive compartilhado. As restrições podem ser definidas usando o drives.update método.

Para aplicar restrições de download a um drive compartilhado, um administrador de drive compartilhado pode definir o restrictions.downloadRestriction campo do drives recurso usando o DownloadRestriction objeto. Definir o campo booleano restrictedForReaders como true declara que o download e a cópia são restritos para leitores. Definir o campo booleano restrictedForWriters como true declara que o download e a cópia são restritos para escritores. Se o campo restrictedForWriters for true, o download e a cópia também serão restritos para leitores. Da mesma forma, definir restrictedForWriters como true e restrictedForReaders como false é equivalente a definir restrictedForWriters e restrictedForReaders como true.

Compatibilidade com versões anteriores

Com a introdução do objeto DownloadRestriction, a funcionalidade do campo booleano restrictions.copyRequiresWriterPermission foi atualizada.

Agora, definir restrictions.copyRequiresWriterPermission como true atualiza o restrictedForReaders campo booleano do objeto DownloadRestriction para true para declarar que o download e a cópia são restritos para leitores.

Definir o campo copyRequiresWriterPermission como false atualiza os campos restrictedForWriters e restrictedForReaders para false. Isso significa que as configurações de restrição de download ou cópia são removidas para todos os usuários.

Campos que controlam os recursos de download, impressão e cópia

A tabela a seguir lista os campos de recursos drives que afetam a funcionalidade de download, impressão e cópia:

Campo Descrição Versão
capabilities.canCopy Se o usuário atual pode copiar arquivos em um drive compartilhado. v2 e v3
capabilities.canDownload Se o usuário atual pode fazer o download de arquivos em um drive compartilhado. v2 e v3
capabilities.canChangeCopyRequiresWriterPermissionRestriction Se o usuário atual pode mudar a restrição copyRequiresWriterPermission de um drive compartilhado. v2 e v3
capabilities.canResetDriveRestrictions Se o usuário atual pode redefinir as restrições do drive compartilhado para os padrões. v2 e v3
capabilities.canChangeDownloadRestriction Se o usuário atual pode mudar a restrição de download de um drive compartilhado. Somente v3
restrictions.copyRequiresWriterPermission Se as opções de copiar, imprimir ou fazer o download de arquivos em um drive compartilhado estão desativadas para leitores e comentadores. Quando true, ele define o campo com nome semelhante como true para qualquer arquivo dentro desse drive compartilhado. v2 e v3
restrictions.downloadRestriction As restrições de download aplicadas pelos administradores de drives compartilhados. Somente v3

Limites de pastas

Os drives compartilhados têm limites de itens e profundidade de pastas. Além disso, o uso do armazenamento é gerenciado no armazenamento em pool da organização, em vez da cota de armazenamento pessoal do Meu Drive de um usuário individual. Para mais informações, consulte Limites do drive compartilhado no Google Drive.

Limite de itens

Um drive compartilhado pode conter no máximo 500.000, incluindo arquivos, pastas e atalhos.

Quando o limite é atingido, o drive compartilhado não pode mais aceitar itens. Para retomar o recebimento de arquivos, os usuários precisam excluir permanentemente itens do drive compartilhado. Os itens na lixeira contam para o limite, mas os itens excluídos permanentemente não. Para mais informações, consulte Colocar arquivos e pastas na lixeira ou excluir.

Limite de profundidade da pasta

Uma pasta em um drive compartilhado não pode conter mais de 100 níveis de pastas aninhadas. Isso significa que uma pasta filha não pode ser armazenada em uma pasta com mais de 99 níveis de profundidade. Essa limitação se aplica apenas a pastas filhas.

As tentativas de adicionar mais de 100 níveis de pastas retornam uma teamDriveHierarchyTooDeep resposta de código de status HTTP.