Gestisci Drive condivisi

Questo documento contiene le attività correlate alla gestione dei Drive condivisi, come la creazione di Drive condivisi e la gestione di membri e autorizzazioni, utilizzando l'API Google Drive.

Se vuoi specificare i campi da restituire nella risposta, puoi impostare il fields parametro di sistema con qualsiasi metodo della drives risorsa. Se non specifichi il parametro fields, il server restituisce un insieme predefinito di campi specifici del metodo. Ad esempio, il metodo list restituisce solo i campi kind, id, e name per ogni Drive condiviso. Per saperne di più, vedi Restituire campi specifici.

Per saperne di più sui limiti delle cartelle dei Drive condivisi, vedi Limiti delle cartelle dei Drive condivisi.

Prerequisiti

Prima di poter creare e gestire i Drive condivisi, assicurati di soddisfare i seguenti requisiti:

  • Account Google Workspace: i Drive condivisi sono disponibili con le versioni di Google Workspace supportate (ad esempio Business Standard, Business Plus, Enterprise ed Education). Gli Account Google personali (@gmail.com) non possono creare Drive condivisi.
  • Autorizzazione di creazione: gli amministratori di dominio possono configurare se gli utenti della loro organizzazione possono creare Drive condivisi. L'utente autenticato deve appartenere a un'unità organizzativa autorizzata a creare Drive condivisi.
  • Ambito OAuth 2.0: la tua app deve essere autorizzata con l'ambito https://www.googleapis.com/auth/drive.
  • Ruoli: quando un utente crea un Drive condiviso, gli viene assegnato automaticamente il ruolo di organizer su quel Drive condiviso. La gestione delle impostazioni del Drive, la ridenominazione del Drive, l'aggiunta o la rimozione di membri e l'eliminazione del Drive condiviso richiedono il ruolo di organizer. Per saperne di più sui ruoli, vedi Ruoli per i Drive condivisi.
  • Accesso amministratore di dominio: gli amministratori di dominio possono gestire qualsiasi Drive condiviso all'interno della loro organizzazione, indipendentemente dall'appartenenza, passando useDomainAdminAccess=true. Per saperne di più, vedi Gestire i Drive condivisi come amministratori di dominio.

Crea un Drive condiviso

Per creare un Drive condiviso, utilizza il create metodo sulla risorsa drives con il requestId parametro.

Il parametro requestId identifica il tentativo logico per la creazione idempotente di un Drive condiviso. Se la richiesta va in timeout o restituisce un errore di backend indeterminato, la stessa richiesta può essere ripetuta e non verranno creati duplicati. Il requestId e il corpo della richiesta devono rimanere invariati.

Il seguente esempio di codice mostra come creare un Drive condiviso:

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

Le chiamate al metodo create sono idempotenti.

Se il Drive condiviso è stato creato correttamente in una richiesta precedente o a causa di un nuovo tentativo, il metodo restituisce un'istanza della risorsa drives. A volte, ad esempio dopo un periodo di tempo prolungato o se il corpo della richiesta è cambiato, potrebbe essere restituito un errore 409 che indica che il requestId deve essere eliminato.

Ottieni un Drive condiviso

Per ottenere i metadati di un Drive condiviso, utilizza il get metodo sulla drives risorsa con il driveId parametro di percorso. Se non conosci l'ID del Drive, puoi elencare tutti i Drive condivisi utilizzando il metodo list.

Il metodo get restituisce un Drive condiviso come istanza di una risorsa drives.

Per inviare la richiesta come amministratore di dominio, imposta il parametro di query useDomainAdminAccess su true. Per saperne di più, vedi Gestire i Drive condivisi come amministratori di dominio.

Elenca i Drive condivisi

Per elencare i Drive condivisi di un utente, utilizza il list metodo sulla drives risorsa. Il metodo restituisce un elenco di Drive condivisi.

Passa i seguenti parametri di query per personalizzare la paginazione o filtrare i Drive condivisi:

  • pageSize: il numero massimo di Drive condivisi da restituire per pagina.

  • pageToken: un token di pagina ricevuto da una precedente chiamata dell'elenco. Fornisci questo token per recuperare la pagina successiva.

  • q: stringa di query per la ricerca di Drive condivisi. Per saperne di più, vedi Cercare Drive condivisi.

  • useDomainAdminAccess: imposta su true per inviare la richiesta come amministratore di dominio per restituire tutti i Drive condivisi del dominio in cui il richiedente è amministratore. Per saperne di più, vedi Gestire i Drive condivisi come amministratori di dominio.

Aggiorna un Drive condiviso

Per aggiornare i metadati di un Drive condiviso, utilizza il update metodo sulla drives risorsa con il driveId parametro di percorso.

Il metodo restituisce un Drive condiviso come istanza di una risorsa drives.

Per inviare la richiesta come amministratore di dominio, imposta il parametro di query useDomainAdminAccess su true. Per saperne di più, vedi Gestire i Drive condivisi come amministratori di dominio.

Nascondi e mostra un Drive condiviso

Per nascondere un Drive condiviso dalla visualizzazione predefinita, utilizza il hide metodo sulla drives risorsa con il driveId parametro.

Quando un Drive condiviso è nascosto, Drive contrassegna la risorsa del Drive condiviso come hidden=true. I Drive condivisi nascosti non vengono visualizzati nell'interfaccia utente di Drive o nell'elenco dei file restituiti.

Per ripristinare un Drive condiviso nella visualizzazione predefinita, utilizza il unhide metodo sulla drives risorsa con il driveId parametro.

Entrambi i metodi restituiscono un Drive condiviso come istanza di una risorsa drives.

Elimina un Drive condiviso

Per eliminare definitivamente un Drive condiviso, utilizza il delete metodo sulla drives risorsa con il driveId parametro.

Prima di eliminare un Drive condiviso, tutti i contenuti al suo interno devono essere spostati nel cestino o eliminati. L'utente deve anche avere role=organizer nella cartella del Drive condiviso. Per saperne di più, vedi Spostare file e cartelle nel cestino o eliminarli.

Passa i seguenti parametri di query:

  • useDomainAdminAccess: imposta su true per inviare la richiesta come amministratore di dominio. Per saperne di più, vedi Gestire i Drive condivisi come amministratori di dominio.

  • allowItemDeletion: imposta su true per eliminare gli elementi all'interno del Drive condiviso. Supportato solo quando anche useDomainAdminAccess è impostato su true.

Aggiungi o rimuovi membri del Drive condiviso

Aggiungi o rimuovi membri del Drive condiviso utilizzando la permissions risorsa.

Per aggiungere un membro, crea l'autorizzazione sul Drive condiviso. I metodi di autorizzazione possono essere utilizzati anche per i singoli file all'interno di un Drive condiviso per concedere ai membri privilegi aggiuntivi o consentire ai non membri di collaborare su elementi specifici.

Per saperne di più e per esempi di codice, vedi Condividere file, cartelle e Drive.

Gestire i Drive condivisi come amministratori di dominio

Applica il parametro useDomainAdminAccess con le risorse drives e permissions per gestire i Drive condivisi in un'organizzazione.

Gli utenti che chiamano questi metodi con useDomainAdminAccess=true devono disporre del Drive and Docs privilegio di amministratore. Gli amministratori possono cercare Drive condivisi o aggiornare le autorizzazioni per i Drive condivisi di proprietà della loro organizzazione, indipendentemente dall'appartenenza dell'amministratore a un determinato Drive condiviso.

Quando utilizzi i service account, potresti dover simulare l'identità di un amministratore autenticato utilizzando la simulazione dell'identità dei service account. Tieni presente che i service account non appartengono al tuo dominio Google Workspace, a differenza degli account utente. Se condividi asset di Google Workspace, come documenti o eventi, con l'intero dominio Google Workspace, questi non vengono condivisi con i service account. Per saperne di più, vedi Service accounts overview.

Recuperare un Drive condiviso che non ha un organizer

Il seguente esempio di codice mostra come recuperare i Drive condivisi che non hanno più un organizer.

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

Impedire agli utenti di scaricare, stampare o copiare file

Puoi limitare il modo in cui gli utenti possono scaricare, stampare e copiare i file all'interno dei Drive condivisi.

Per determinare se l'utente può modificare le limitazioni di download applicate dall'organizer di un Drive condiviso, controlla il campo booleano capabilities.canChangeDownloadRestriction. Se capabilities.canChangeDownloadRestriction è impostato su true, è possibile applicare limitazioni di download al Drive condiviso. Per saperne di più, vedi Informazioni sulle funzionalità dei file.

La risorsa drives contiene una raccolta di campi booleani restrictions utilizzati per indicare se un'azione può essere eseguita su un Drive condiviso. Le limitazioni si applicano a un Drive condiviso o agli elementi al suo interno. Le limitazioni possono essere impostate utilizzando il drives.update metodo.

Per applicare le limitazioni di download a un Drive condiviso, un gestore del Drive condiviso può impostare il restrictions.downloadRestriction campo della drives risorsa utilizzando l' DownloadRestriction oggetto. L'impostazione del campo booleano restrictedForReaders su true dichiara che sia il download sia la copia sono limitati per i lettori. L'impostazione del campo booleano restrictedForWriters su true dichiara che sia il download sia la copia sono limitati per gli autori. Tieni presente che se il campo restrictedForWriters è true, il download e la copia sono limitati anche per i lettori. Allo stesso modo, l'impostazione di restrictedForWriters su true e restrictedForReaders su false equivale all'impostazione di entrambi i campi restrictedForWriters e restrictedForReaders su true.

Compatibilità con le versioni precedenti

Con l'introduzione dell'oggetto DownloadRestriction, la funzionalità del campo booleano restrictions.copyRequiresWriterPermission è stata aggiornata.

Ora, l'impostazione di restrictions.copyRequiresWriterPermission su true aggiorna il restrictedForReaders campo booleano dell'oggetto DownloadRestriction su true per dichiarare che sia il download sia la copia sono limitati per i lettori.

L'impostazione del campo copyRequiresWriterPermission su false aggiorna entrambi i campi restrictedForWriters e restrictedForReaders su false. Ciò significa che le impostazioni di limitazione di download o copia vengono rimosse per tutti gli utenti.

Campi che controllano le funzionalità di download, stampa e copia

La tabella seguente elenca i campi della risorsa drives che influiscono sulle funzionalità di download, stampa e copia:

Campo Descrizione Versione
capabilities.canCopy Indica se l'utente attuale può copiare i file in un Drive condiviso. v2 e v3
capabilities.canDownload Indica se l'utente attuale può scaricare i file in un Drive condiviso. v2 e v3
capabilities.canChangeCopyRequiresWriterPermissionRestriction Indica se l'utente attuale può modificare la limitazione copyRequiresWriterPermission di un Drive condiviso. v2 e v3
capabilities.canResetDriveRestrictions Indica se l'utente attuale può reimpostare le limitazioni del Drive condiviso sui valori predefiniti. v2 e v3
capabilities.canChangeDownloadRestriction Indica se l'utente attuale può modificare la limitazione di download di un Drive condiviso. Solo v3
restrictions.copyRequiresWriterPermission Indica se le opzioni per copiare, stampare o scaricare i file all'interno di un Drive condiviso sono disattivate per lettori e commentatori. Se true, imposta il campo con lo stesso nome su true per qualsiasi file all'interno di questo Drive condiviso. v2 e v3
restrictions.downloadRestriction Le limitazioni di download applicate dai gestori del Drive condiviso. Solo v3

Limiti per le cartelle

I Drive condivisi hanno limiti di elementi e di profondità delle cartelle. Inoltre, l'utilizzo dello spazio di archiviazione viene gestito in base allo spazio di archiviazione in pool dell'organizzazione anziché alla quota di spazio di archiviazione personale di Il mio Drive di un singolo utente. Per saperne di più, vedi Limiti relativi ai Drive condivisi su Google Drive.

Limite massimo di elementi

Un Drive condiviso può contenere al massimo 500.000 elementi, compresi file, cartelle e scorciatoie.

Una volta raggiunto il limite, il Drive condiviso non può più accettare elementi. Per riprendere a ricevere file, gli utenti devono eliminare definitivamente gli elementi dal Drive condiviso. Tieni presente che gli elementi nel cestino vengono conteggiati ai fini del limite, ma gli elementi eliminati definitivamente no. Per saperne di più, vedi Spostare file e cartelle nel cestino o eliminarli.

Limite di profondità delle cartelle

Una cartella di un Drive condiviso non può contenere più di 100 livelli di cartelle nidificate. Ciò significa che una cartella secondaria non può essere archiviata in una cartella con una profondità superiore a 99 livelli. Questa limitazione si applica solo alle cartelle secondarie.

I tentativi di aggiungere più di 100 livelli di cartelle restituiscono una teamDriveHierarchyTooDeep risposta con codice di stato HTTP.