Cette page a été traduite par l'API Cloud Translation.

Gérer les Drive partagés

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

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

Créer des Drive partagés

Pour créer un Drive partagé, utilisez la méthode drives.create.

Java

drive/snippets/drive_v3/src/main/java/CreateDrive.java

Afficher sur GitHub

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

Afficher sur GitHub

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

Afficher sur GitHub

/**
 * Create a drive.
 * */
async function createDrive() {
  // Get credentials and build service
  // TODO (developer) - Use appropriate auth mechanism for your app

  const {GoogleAuth} = require('google-auth-library');
  const {google} = require('googleapis');
  const uuid = require('uuid');

  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });
  const service = google.drive({version: 'v3', auth});

  const driveMetadata = {
    name: 'Project resources',
  };
  const requestId = uuid.v4();
  try {
    const Drive = await service.drives.create({
      resource: driveMetadata,
      requestId: requestId,
      fields: 'id',
    });
    console.log('Drive Id:', Drive.data.id);
    return Drive.data.id;
  } catch (err) {
    // TODO(developer) - Handle error
    throw err;
  }
}

PHP

drive/snippets/drive_v3/src/DriveCreateDrive.php

Afficher sur GitHub

<?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

Afficher sur GitHub

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 à la méthode drives.create sont idempotents.

Le paramètre requestId identifie la tentative logique de création du lecteur 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. Le requestId et le corps de la requête doivent rester identiques.

Si le Drive partagé a été créé avec succès lors d'une requête précédente ou en raison d'une nouvelle tentative, la réponse normale est renvoyée. Parfois, par exemple après une longue période ou si le corps de la requête a changé, une erreur 409 peut être renvoyée, indiquant que le requestId doit être supprimé.

Ajouter ou supprimer des membres d'un Drive partagé

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

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 droits supplémentaires aux membres ou permettre aux non-membres de collaborer sur des éléments spécifiques.

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

Supprimer un Drive partagé

Utilisez la méthode drives.delete pour supprimer un lecteur partagé. Avant de supprimer un Drive partagé, vous devez placer tout son contenu dans la corbeille ou le supprimer.

Gérer les Drive partagés pour les administrateurs de domaine

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

Les utilisateurs qui appellent ces méthodes avec useDomainAdminAccess=true doivent disposer du droit d'administrateur Drive and Docs. Les administrateurs peuvent rechercher des Drive partagés ou mettre à jour les autorisations des Drive partagés appartenant à leur organisation, quelle que soit leur appartenance à un Drive partagé donné.

Récupérer un Drive partagé sans organisateur

L'exemple suivant montre comment utiliser ces ressources pour récupérer des lecteurs partagés qui n'ont plus d'organisateur.

Java

drive/snippets/drive_v3/src/main/java/RecoverDrive.java

Afficher sur GitHub

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

Afficher sur GitHub

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

Afficher sur GitHub

/**
 * Find all shared drives without an organizer and add one.
 * @param{string} userEmail user ID to assign ownership to
 * */
async function recoverDrives(userEmail) {
  // Get credentials and build service
  // TODO (developer) - Use appropriate auth mechanism for your app

  const {GoogleAuth} = require('google-auth-library');
  const {google} = require('googleapis');

  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });
  const service = google.drive({version: 'v3', auth});
  const drives = [];
  const newOrganizerPermission = {
    type: 'user',
    role: 'organizer',
    emailAddress: userEmail, // Example: 'user@example.com'
  };

  let pageToken = null;
  try {
    const res = await service.drives.list({
      q: 'organizerCount = 0',
      fields: 'nextPageToken, drives(id, name)',
      useDomainAdminAccess: true,
      pageToken: pageToken,
    });
    Array.prototype.push.apply(drives, res.data.items);
    for (const drive of res.data.drives) {
      console.log(
          'Found shared drive without organizer:',
          drive.name,
          drive.id,
      );
      await service.permissions.create({
        resource: newOrganizerPermission,
        fileId: drive.id,
        useDomainAdminAccess: true,
        supportsAllDrives: true,
        fields: 'id',
      });
    }
    pageToken = res.nextPageToken;
  } catch (err) {
    // TODO(developer) - Handle error
    throw err;
  }
  return drives;
}

PHP

drive/snippets/drive_v3/src/DriveRecoverDrives.php

Afficher sur GitHub

<?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

Afficher sur GitHub

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 Drives partagés.

Pour déterminer si l'utilisateur peut modifier les restrictions de téléchargement appliquées par l'organisateur 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 permettant d'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 méthode drives.update.

Pour appliquer des restrictions de téléchargement à un Drive partagé, un administrateur de Drive partagé peut définir le champ restrictions.downloadRestriction de la ressource drives à l'aide de l'objet DownloadRestriction. Si vous définissez le champ booléen restrictedForReaders sur true, vous indiquez que le téléchargement et la copie sont restreints pour les lecteurs. Si vous définissez le champ booléen restrictedForWriters sur true, vous indiquez que le téléchargement et la copie sont restreints pour les rédacteurs. Notez que si le champ restrictedForWriters est défini sur 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 revient à 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.

Maintenant, en définissant restrictions.copyRequiresWriterPermission sur true, le champ booléen restrictedForReaders de l'objet DownloadRestriction est défini sur true pour indiquer que le téléchargement et la copie sont restreints pour les lecteurs.

Si vous définissez le champ copyRequiresWriterPermission sur false, les champs restrictedForWriters et restrictedForReaders sont également définis 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 liste les champs de ressources 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 `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`	Les restrictions de téléchargement appliquées par les administrateurs du Drive partagé.	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

Dans le Drive partagé d'un utilisateur, chaque dossier peut contenir 500 000 éléments au maximum, y compris des fichiers, des dossiers et des raccourcis.

Une fois la limite atteinte, le Drive partagé ne peut plus accepter d'éléments. Pour recevoir à nouveau des fichiers, les utilisateurs doivent supprimer définitivement des éléments du dossier. Notez que les éléments placés dans la corbeille sont pris en compte dans la limite, mais pas ceux qui ont été 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é dans un dossier dont la profondeur est supérieure à 99 niveaux. Cette limitation ne s'applique qu'aux dossiers enfants.

Si vous essayez d'ajouter plus de 100 niveaux de dossiers, vous recevrez un code d'état HTTP teamDriveHierarchyTooDeep.

Limites applicables aux fichiers et aux dossiers dans Fichiers

Gérer les Drive partagés Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Créer des Drive partagés

Java

Python

Node.js

PHP

.NET

Ajouter ou supprimer des membres d'un Drive partagé

Supprimer un Drive partagé

Gérer les Drive partagés pour les administrateurs de domaine

Récupérer un Drive partagé sans organisateur

Java

Python

Node.js

PHP

.NET

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

Rétrocompatibilité.

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

Limites applicables aux dossiers

Nombre maximal d'éléments

Limite de profondeur des dossiers

Articles associés

Gérer les Drive partagés