Administrar unidades compartidas

En este documento, se incluyen tareas relacionadas con la administración de unidades compartidas, como la creación de unidades compartidas y la administración de miembros y permisos, mediante la API de Google Drive.

Si deseas especificar los campos que se mostrarán en la respuesta, puedes configurar el fields parámetro del sistema con cualquier método del recurso drives. Si no especificas el parámetro fields, el servidor muestra un conjunto predeterminado de campos específicos del método. Por ejemplo, el list método solo muestra los kind, id, y name campos para cada unidad compartida. Para obtener más información, consulta Cómo mostrar campos específicos.

Para obtener más información sobre los límites de carpetas de unidades compartidas, consulta Límites de carpetas de unidades compartidas.

Requisitos previos

Antes de crear y administrar unidades compartidas, asegúrate de cumplir con los siguientes requisitos:

  • Cuenta de Google Workspace: Las unidades compartidas están disponibles con las ediciones compatibles de Google Workspace (como Business Standard, Business Plus, Enterprise y Education). Las cuentas personales de Google (@gmail.com) no pueden crear unidades compartidas.
  • Permiso de creación: Los administradores de dominios pueden configurar si los usuarios de su organización pueden crear unidades compartidas. El usuario autenticado debe pertenecer a una unidad organizativa que tenga permiso para crear unidades compartidas.
  • Alcance de OAuth 2.0: Tu app debe estar autorizada con el alcance https://www.googleapis.com/auth/drive.
  • Funciones: Cuando un usuario crea una unidad compartida, se le asigna automáticamente la función organizer en esa unidad compartida. Para administrar la configuración de Drive, cambiar el nombre de la unidad, agregar o quitar miembros y borrar la unidad compartida, se requiere la función organizer. Para obtener más información sobre las funciones, consulta Funciones para unidades compartidas.
  • Acceso de administrador de dominio: Los administradores de dominios pueden administrar cualquier unidad compartida dentro de su organización, independientemente de la membresía, pasando useDomainAdminAccess=true. Para obtener más información, consulta Administra unidades compartidas como administradores de dominio.

Cómo crear una unidad compartida

Para crear una unidad compartida, usa el create método en el recurso drives con el parámetro requestId.

El parámetro requestId identifica el intento lógico para la creación idempotente de una unidad compartida. Si se agota el tiempo de espera de la solicitud o se muestra un error de backend indeterminado, se puede repetir la misma solicitud y no se crearán duplicados. El requestId y el cuerpo de la solicitud deben seguir siendo los mismos.

En el siguiente ejemplo de código, se muestra cómo crear una unidad compartida:

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

Las llamadas al create método son idempotentes.

Si la unidad compartida se creó correctamente en una solicitud anterior o debido a un reintento, el método muestra una instancia del recurso drives. En ocasiones, como después de un tiempo prolongado o si cambió el cuerpo de la solicitud, es posible que se muestre un error 409 que indique que se debe descartar el requestId.

Cómo obtener una unidad compartida

Para obtener metadatos de una unidad compartida, usa el get método en el drives recurso con el driveId parámetro de ruta de acceso. Si no conoces el ID de la unidad, puedes enumerar todas las unidades compartidas con el método list.

El método get muestra una unidad compartida como una instancia de un recurso drives.

Para emitir la solicitud como administrador de dominio, establece el parámetro de consulta useDomainAdminAccess en true. Para obtener más información, consulta Administra unidades compartidas como administradores de dominio.

Cómo enumerar unidades compartidas

Para enumerar las unidades compartidas de un usuario, usa el list método en el drives recurso. El método muestra una lista de unidades compartidas.

Pasa los siguientes parámetros de consulta para personalizar la paginación o filtrar las unidades compartidas:

  • pageSize: Es la cantidad máxima de unidades compartidas que se mostrarán por página.

  • pageToken: Es un token de página que se recibe de una llamada de lista anterior. Proporciónalo para recuperar la página siguiente.

  • q: Es una cadena de consulta para buscar unidades compartidas. Para obtener más información, consulta Cómo buscar unidades compartidas.

  • useDomainAdminAccess: Se establece en true para emitir la solicitud como administrador de dominio y mostrar todas las unidades compartidas del dominio en el que el solicitante es administrador. Para obtener más información, consulta Administra unidades compartidas como administradores de dominio.

Cómo actualizar una unidad compartida

Para actualizar los metadatos de una unidad compartida, usa el update método en el drives recurso con el driveId parámetro de ruta de acceso.

El método muestra una unidad compartida como una instancia de un recurso drives.

Para emitir la solicitud como administrador de dominio, establece el parámetro de consulta useDomainAdminAccess en true. Para obtener más información, consulta Administra unidades compartidas como administradores de dominio.

Cómo ocultar y mostrar una unidad compartida

Para ocultar una unidad compartida de la vista predeterminada, usa el hide método en el drives recurso con el driveId parámetro.

Cuando se oculta una unidad compartida, Drive marca el recurso de unidad compartida como hidden=true. Las unidades compartidas ocultas no aparecen en la IU de Drive ni en la lista de archivos que se muestran.

Para restablecer una unidad compartida a la vista predeterminada, usa el unhide método en el drives recurso con el driveId parámetro.

Ambos métodos muestran una unidad compartida como una instancia de un recurso drives.

Cómo borrar una unidad compartida

Para borrar una unidad compartida de forma permanente, usa el delete método en el drives recurso con el driveId parámetro.

Antes de borrar una unidad compartida, todo el contenido de la unidad compartida debe moverse a la papelera o borrarse. El usuario también debe tener role=organizer en la carpeta de la unidad compartida. Para obtener más información, consulta Cómo mover archivos y carpetas a la papelera o borrarlos.

Pasa los siguientes parámetros de consulta:

  • useDomainAdminAccess: Se establece en true para emitir la solicitud como administrador de dominio. Para obtener más información, consulta Administra unidades compartidas como administradores de dominio.

  • allowItemDeletion: Se establece en true para borrar elementos dentro de la unidad compartida. Solo se admite cuando useDomainAdminAccess también se establece en true.

Cómo agregar o quitar miembros de unidades compartidas

Agrega o quita miembros de unidades compartidas con el permissions recurso.

Para agregar un miembro, crea el permiso en la unidad compartida. Los métodos de permisos también se pueden usar en archivos individuales dentro de una unidad compartida para otorgar privilegios adicionales a los miembros o permitir que los usuarios que no son miembros colaboren en elementos específicos.

Para obtener más información y código de muestra, consulta Cómo compartir archivos, carpetas y unidades.

Cómo administrar unidades compartidas como administradores de dominio

Aplica el parámetro useDomainAdminAccess con los drives y permissions recursos para administrar unidades compartidas en una organización.

Los usuarios que llamen a estos métodos con useDomainAdminAccess=true deben tener el Drive and Docs privilegio de administrador. Los administradores pueden buscar unidades compartidas o actualizar permisos para unidades compartidas que pertenecen a su organización, independientemente de la membresía del administrador en cualquier unidad compartida determinada.

Cuando usas cuentas de servicio, es posible que debas suplantar la identidad de un administrador autenticado con la suplantación de identidad de la cuenta de servicio. Ten en cuenta que las cuentas de servicio no pertenecen a tu dominio de Google Workspace, a diferencia de las cuentas de usuario. Si compartes elementos de Google Workspace, como documentos o eventos, con todo tu dominio de Google Workspace, no se compartirán con las cuentas de servicio. Para obtener más información, consulta Descripción general de cuentas de servicio.

Cómo recuperar una unidad compartida que no tiene un organizador

En el siguiente ejemplo de código, se muestra cómo recuperar unidades compartidas que ya no tienen un 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;
        }
    }
}

Cómo impedir que los usuarios descarguen, impriman o copien archivos

Puedes limitar la forma en que los usuarios pueden descargar, imprimir y copiar archivos dentro de las unidades compartidas.

Para determinar si el usuario puede cambiar las restricciones de descarga aplicadas por el organizador de una unidad compartida, verifica el capabilities.canChangeDownloadRestriction campo booleano. Si capabilities.canChangeDownloadRestriction se establece en true, se pueden aplicar restricciones de descarga a la unidad compartida. Para obtener más información, consulta Comprende las capacidades de los archivos.

El recurso drives contiene una colección de campos booleanos restrictions que se usan para indicar si se puede realizar una acción en una unidad compartida. Las restricciones se aplican a una unidad compartida o a los elementos que se encuentran dentro de ella. Las restricciones se pueden establecer con el drives.update método.

Para aplicar restricciones de descarga a una unidad compartida, un administrador de unidades compartidas puede establecer el restrictions.downloadRestriction campo del drives recurso con el DownloadRestriction objeto. Si se establece el campo booleano restrictedForReaders en true, se declara que la descarga y la copia están restringidas para los lectores. Si se establece el campo booleano restrictedForWriters en true, se declara que la descarga y la copia están restringidas para los escritores. Ten en cuenta que, si el campo restrictedForWriters es true, la descarga y la copia también están restringidas para los lectores. Del mismo modo, establecer restrictedForWriters en true y restrictedForReaders en false equivale a establecer restrictedForWriters y restrictedForReaders en true.

Retrocompatibilidad

Con la introducción del objeto DownloadRestriction, se actualizó la funcionalidad del campo booleano restrictions.copyRequiresWriterPermission.

Ahora, si se establece restrictions.copyRequiresWriterPermission en true, se actualiza el restrictedForReaders campo booleano del DownloadRestriction objeto a true para declarar que la descarga y la copia están restringidas para los lectores.

Si se establece el campo copyRequiresWriterPermission en false, se actualizan los campos restrictedForWriters y restrictedForReaders a false. Esto significa que se quitan los parámetros de configuración de restricción de descarga o copia para todos los usuarios.

Campos que controlan las funciones de descarga, impresión y copia

En la siguiente tabla, se enumeran los campos de recursos drives que afectan la funcionalidad de descarga, impresión y copia:

Campo Descripción Versión
capabilities.canCopy Indica si el usuario actual puede copiar archivos en una unidad compartida. v2 y v3
capabilities.canDownload Indica si el usuario actual puede descargar archivos en una unidad compartida. v2 y v3
capabilities.canChangeCopyRequiresWriterPermissionRestriction Indica si el usuario actual puede cambiar la restricción copyRequiresWriterPermission de una unidad compartida. v2 y v3
capabilities.canResetDriveRestrictions Indica si el usuario actual puede restablecer las restricciones de la unidad compartida a los valores predeterminados. v2 y v3
capabilities.canChangeDownloadRestriction Indica si el usuario actual puede cambiar la restricción de descarga de una unidad compartida. Solo v3
restrictions.copyRequiresWriterPermission Indica si las opciones para copiar, imprimir o descargar archivos dentro de una unidad compartida están inhabilitadas para los lectores y comentaristas. Cuando es true, establece el campo con un nombre similar en true para cualquier archivo dentro de esta unidad compartida. v2 y v3
restrictions.downloadRestriction Son las restricciones de descarga que aplican los administradores de unidades compartidas. Solo v3

Límites de carpetas

Las unidades compartidas tienen límites de elementos y de profundidad de carpetas. Además, el uso de almacenamiento se administra en función del almacenamiento agrupado de la organización en lugar de la cuota de almacenamiento personal de Mi unidad de un usuario individual. Para obtener más información, consulta Límites de unidades compartidas en Google Drive.

Límite de elementos

Una unidad compartida puede contener un máximo de 500,000 elementos, incluidos archivos, carpetas y accesos directos.

Cuando se alcanza el límite, la unidad compartida ya no puede aceptar elementos. Para reanudar la recepción de archivos, los usuarios deben borrar elementos de la unidad compartida de forma permanente. Ten en cuenta que los elementos de la papelera cuentan para el límite, pero los elementos borrados de forma permanente no. Para obtener más información, consulta Cómo mover archivos y carpetas a la papelera o borrarlos.

Límite de profundidad de carpetas

Una carpeta de una unidad compartida no puede contener más de 100 niveles de carpetas anidadas. Esto significa que no se puede almacenar una carpeta secundaria en una carpeta que tenga más de 99 niveles de profundidad. Esta limitación solo se aplica a las carpetas secundarias.

Los intentos de agregar más de 100 niveles de carpetas muestran una teamDriveHierarchyTooDeep respuesta de código de estado HTTP.