Gérer les Drive partagés

Ce guide contient des tâches liées à la gestion des Drive partagés, telles que la création de Drive partagés, la gestion des membres et des autorisations à l'aide de l'API Google Drive.

Si vous souhaitez spécifier les champs à renvoyer dans la réponse, vous pouvez définir le fields paramètre système avec n'importe quelle méthode de la ressource drives. Si vous ne spécifiez pas le paramètre fields, le serveur renvoie un ensemble de champs par défaut spécifique à la méthode. Par exemple, la list méthode ne renvoie que les champs kind, id, et name pour chaque Drive partagé. Pour en savoir plus, consultez la section Renvoyer des champs spécifiques.

Pour en savoir plus sur les limites applicables aux dossiers des Drive partagés, consultez Limites applicables aux dossiers des Drive partagés.

Créer un Drive partagé

Pour créer un Drive partagé, utilisez la create méthode sur la ressource drives avec le requestId paramètre.

Le paramètre requestId identifie la tentative logique de création idempotente d'un Drive partagé. Si la requête expire ou renvoie une erreur de backend indéterminée, la même requête peut être répétée sans créer de doublons. Le requestId et le corps de la requête doivent rester identiques.

L'exemple de code suivant montre comment créer un Drive partagé :

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

Les appels de la create méthode sont idempotents.

Si le Drive partagé a été créé lors d'une requête précédente ou en raison d'une nouvelle tentative, la méthode renvoie une instance de la ressource drives. Parfois, par exemple après une période prolongée ou si le corps de la requête a changé, une erreur 409 peut être renvoyée, indiquant que le requestId doit être ignoré.

Obtenir un Drive partagé

Pour obtenir les métadonnées d'un Drive partagé, utilisez la get méthode sur la ressource drives avec le paramètre de chemin d'accès driveId. Si vous ne connaissez pas l'ID du Drive, vous pouvez lister tous les Drive partagés à l'aide de la méthode list.

La méthode get renvoie un Drive partagé en tant qu'instance d'une ressource drives.

Pour émettre la requête en tant qu'administrateur de domaine, définissez le paramètre de requête useDomainAdminAccess sur true. Pour en savoir plus, consultez Gérer les Drive partagés en tant qu' administrateur de domaine.

Lister les Drive partagés

Pour lister les Drive partagés d'un utilisateur, utilisez la list méthode sur la drives ressource. La méthode renvoie une liste de Drive partagés.

Transmettez les paramètres de requête suivants pour personnaliser la pagination ou filtrer les Drive partagés :

  • pageSize : nombre maximal de Drive partagés à renvoyer par page.

  • pageToken : jeton de page reçu lors d'un appel de liste précédent. Fournissez ce jeton pour récupérer la page suivante.

  • q : chaîne de requête pour rechercher des Drive partagés. Pour en savoir plus, consultez Rechercher des Drive partagés.

  • useDomainAdminAccess: définissez la valeur sur true pour émettre la requête en tant qu'administrateur de domaine afin de renvoyer tous les Drive partagés du domaine dans lequel le demandeur est administrateur. Pour en savoir plus, consultez Gérer les Drive partagés en tant qu'administrateur de domaine.

Mettre à jour un Drive partagé

Pour mettre à jour les métadonnées d'un Drive partagé, utilisez la update méthode sur la drives ressource avec le driveId paramètre de chemin d'accès.

La méthode renvoie un Drive partagé en tant qu'instance d'une ressource drives.

Pour émettre la requête en tant qu'administrateur de domaine, définissez le paramètre de requête useDomainAdminAccess sur true. Pour en savoir plus, consultez Gérer les Drive partagés en tant qu' administrateur de domaine.

Masquer et afficher un Drive partagé

Pour masquer un Drive partagé dans la vue par défaut, utilisez la hide méthode sur la drives ressource avec le driveId paramètre.

Lorsqu'un Drive partagé est masqué, Drive marque la ressource de Drive partagé comme hidden=true. Les Drive partagés masqués n'apparaissent pas dans l'interface utilisateur de Drive ni dans la liste des fichiers renvoyés.

Pour rétablir un Drive partagé dans la vue par défaut, utilisez la unhide méthode sur la drives ressource avec le driveId paramètre.

Les deux méthodes renvoient un Drive partagé en tant qu'instance d'une ressource drives.

Supprimer un Drive partagé

Pour supprimer définitivement un Drive partagé, utilisez la delete méthode sur la drives ressource avec le driveId paramètre.

Avant de supprimer un Drive partagé, tout son contenu doit être placé dans la corbeille ou supprimé. L'utilisateur doit également disposer du role=organizer sur le dossier du Drive partagé. Pour en savoir plus, consultez Placer des fichiers et des dossiers dans la corbeille ou les supprimer.

Transmettez les paramètres de requête suivants pour filtrer les Drive partagés :

  • useDomainAdminAccess: définissez la valeur sur true pour émettre la requête en tant qu'administrateur de domaine afin de renvoyer tous les Drive partagés du domaine dans lequel le demandeur est administrateur. Pour en savoir plus, consultez Gérer les Drive partagés en tant qu'administrateur de domaine.

  • allowItemDeletion : définissez la valeur sur true pour supprimer des éléments dans le Drive partagé. Cette option n'est compatible que lorsque useDomainAdminAccess est également défini sur true.

Ajouter ou supprimer des membres d'un Drive partagé

Ajoutez ou supprimez des membres d'un Drive partagé à l'aide de la permissions ressource.

Pour ajouter un membre, créez l'autorisation sur le Drive partagé. Les méthodes d'autorisation peuvent également être utilisées sur des fichiers individuels d'un Drive partagé pour accorder des privilèges supplémentaires aux membres ou permettre aux non-membres de collaborer sur des éléments spécifiques.

Pour en savoir plus et obtenir un exemple de code, consultez Partager des fichiers, des dossiers et des Drive.

Gérer les Drive partagés en tant qu'administrateur de domaine

Appliquez le useDomainAdminAccess paramètre avec les drives et permissions ressources pour gérer les Drive partagés dans une organisation.

Les utilisateurs qui appellent ces méthodes avec useDomainAdminAccess=true doivent disposer du Drive and Docs privilège d'administrateur. Les administrateurs peuvent rechercher des Drive partagés ou mettre à jour les autorisations des Drive partagés appartenant à leur organisation, quel que soit leur statut de membre dans un Drive partagé donné.

Lorsque vous utilisez des comptes de service, vous devrez peut-être emprunter l'identité d'un administrateur authentifié à l'aide de l'emprunt d'identité de compte de service. Notez que les comptes de service n'appartiennent pas à votre domaine Google Workspace, contrairement aux comptes utilisateur. Si vous partagez des éléments Google Workspace, tels que des documents ou des événements, avec l'ensemble de votre domaine Google Workspace, ces éléments ne sont pas partagés avec les comptes de service. Pour en savoir plus, consultez la section Présentation des comptes de service.

Récupérer un Drive partagé qui n'a pas d'administrateur

L'exemple de code suivant montre comment récupérer des Drive partagés qui n'ont plus d'administrateur.

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

Empêcher les utilisateurs de télécharger, d'imprimer ou de copier votre fichier

Vous pouvez limiter la façon dont les utilisateurs peuvent télécharger, imprimer et copier des fichiers dans les Drive partagés.

Pour déterminer si l'utilisateur peut modifier les restrictions de téléchargement appliquées par l'administrateur d'un Drive partagé, cochez le champ booléen capabilities.canChangeDownloadRestriction. Si capabilities.canChangeDownloadRestriction est défini sur true, des restrictions de téléchargement peuvent être appliquées au Drive partagé. Pour en savoir plus, consultez Comprendre les fonctionnalités des fichiers.

La ressource drives contient une collection de champs booléens restrictions utilisés pour indiquer si une action peut être effectuée sur un Drive partagé. Les restrictions s'appliquent à un Drive partagé ou aux éléments qu'il contient. Les restrictions peuvent être définies à l'aide de la drives.update méthode.

Pour appliquer des restrictions de téléchargement à un Drive partagé, un administrateur de Drive partagé peut définir le restrictions.downloadRestriction champ de la drives ressource à l'aide de l' DownloadRestriction objet. Définir le champ booléen restrictedForReaders sur true déclare que le téléchargement et la copie sont limités pour les lecteurs. Définir le champ booléen restrictedForWriters sur true déclare que le téléchargement et la copie sont limités pour les rédacteurs. Notez que si le champ restrictedForWriters est true, le téléchargement et la copie sont également limités pour les lecteurs. De même, définir restrictedForWriters sur true et restrictedForReaders sur false équivaut à définir restrictedForWriters et restrictedForReaders sur true.

Rétrocompatibilité.

Avec l'introduction de l'objet DownloadRestriction, la fonctionnalité du champ booléen restrictions.copyRequiresWriterPermission a été mise à jour.

Désormais, définir restrictions.copyRequiresWriterPermission sur true met à jour le restrictedForReaders champ booléen de l'objet DownloadRestriction sur true pour déclarer que le téléchargement et la copie sont limités pour les lecteurs.

Définir le champ copyRequiresWriterPermission sur false met à jour les champs restrictedForWriters et restrictedForReaders sur false. Cela signifie que les paramètres de restriction de téléchargement ou de copie sont supprimés pour tous les utilisateurs.

Champs qui contrôlent les fonctionnalités de téléchargement, d'impression et de copie

Le tableau suivant répertorie les champs de ressource drives qui affectent les fonctionnalités de téléchargement, d'impression et de copie :

Champ Description Version
capabilities.canCopy Indique si l'utilisateur actuel peut copier des fichiers dans un Drive partagé. v2 et v3
capabilities.canDownload Indique si l'utilisateur actuel peut télécharger des fichiers dans un Drive partagé. v2 et v3
capabilities.canChangeCopyRequiresWriterPermission Indique si l'utilisateur actuel peut modifier la restriction copyRequiresWriterPermission d'un Drive partagé. v2 et v3
capabilities.canResetDriveRestrictions Indique si l'utilisateur actuel peut rétablir les restrictions par défaut du Drive partagé. v2 et v3
capabilities.canChangeDownloadRestriction Indique si l'utilisateur actuel peut modifier la restriction de téléchargement d'un Drive partagé. v3 uniquement
restrictions.copyRequiresWriterPermission Indique si les options permettant de copier, d'imprimer ou de télécharger des fichiers dans un Drive partagé sont désactivées pour les lecteurs et les commentateurs. Lorsque la valeur est true, le champ du même nom est défini sur true pour tous les fichiers de ce Drive partagé. v2 et v3
restrictions.downloadRestriction Restrictions de téléchargement appliquées par les administrateurs de Drive partagés. v3 uniquement

Limites applicables aux dossiers

Les dossiers des Drive partagés sont soumis à certaines limites de stockage. Pour en savoir plus, consultez Limites des Drive partagés dans Google Drive.

Nombre maximal d'éléments

Le Drive partagé de chaque utilisateur est limité à 500 000 éléments, y compris les fichiers, les dossiers et les raccourcis.

Une fois la limite atteinte, le Drive partagé ne peut plus accepter d'éléments. Pour continuer à recevoir des fichiers, les utilisateurs doivent supprimer définitivement des éléments du Drive partagé. Notez que les éléments de la corbeille sont pris en compte dans la limite, mais pas les éléments supprimés définitivement. Pour en savoir plus, consultez Placer des fichiers et des dossiers dans la corbeille ou les supprimer.

Limite de profondeur des dossiers

Un dossier dans un Drive partagé ne peut pas contenir plus de 100 niveaux de dossiers imbriqués. Cela signifie qu'un dossier enfant ne peut pas être stocké sous un dossier dont la profondeur est supérieure à 99 niveaux. Cette limitation ne s'applique qu'aux dossiers enfants.

Toute tentative d'ajout de plus de 100 niveaux de dossiers renvoie un teamDriveHierarchyTooDeep code d'état HTTP.