Geteilte Ablagen verwalten

In dieser Anleitung finden Sie Aufgaben im Zusammenhang mit der Verwaltung geteilter Ablagen, z. B. das Erstellen geteilter Ablagen und das Verwalten von Mitgliedern und Berechtigungen mit der Google Drive API.

Weitere Informationen zu Beschränkungen für Ordner in geteilten Ablagen finden Sie unter Beschränkungen für Ordner.

Geteilte Ablagen erstellen

Verwenden Sie zum Erstellen einer geteilten Ablage die Methode drives.create.

Hinweis :Wenn Sie die frühere Drive API v2 verwenden, nutzen Sie die Methode drives.insert. Codebeispiele finden Sie auf GitHub.

Java

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

Auf GitHub ansehen

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

Auf GitHub ansehen

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

Auf GitHub ansehen

/**
 * 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

Auf GitHub ansehen

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

Auf GitHub ansehen

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

Aufrufe der Methode drives.create sind idempotent.

Der Parameter requestId gibt den logischen Versuch an, das freigegebene Laufwerk zu erstellen. Wenn für die Anfrage ein Zeitlimit überschritten wird oder ein unbestimmter Backend-Fehler zurückgegeben wird, kann die Anfrage wiederholt werden. Die requestId und der Text der Anfrage müssen gleich bleiben.

Wenn die geteilte Ablage bei einer vorherigen Anfrage oder aufgrund eines Wiederholungsversuchs erfolgreich erstellt wurde, wird die normale Antwort zurückgegeben. Manchmal, z. B. nach längerer Zeit oder wenn sich der Text der Anfrage geändert hat, wird möglicherweise ein 409-Fehler zurückgegeben, der angibt, dass das requestId verworfen werden muss.

Mitglieder einer geteilten Ablage hinzufügen oder entfernen

Mit der Ressource permissions können Sie Mitglieder einer geteilten Ablage hinzufügen oder entfernen.

Wenn Sie ein Mitglied hinzufügen möchten, erstellen Sie die Berechtigung für die geteilte Ablage. Berechtigungsmethoden können auch für einzelne Dateien in einer geteilten Ablage verwendet werden, um Mitgliedern zusätzliche Berechtigungen zu erteilen oder Nichtmitgliedern die Zusammenarbeit an bestimmten Elementen zu ermöglichen.

Weitere Informationen und Beispielcode finden Sie unter Dateien, Ordner und Laufwerke freigeben.

Geteilte Ablagen löschen

Verwenden Sie die Methode drives.delete, um eine geteilte Ablage zu löschen. Alle Inhalte in der geteilten Ablage müssen in den Papierkorb verschoben oder gelöscht werden, bevor die geteilte Ablage gelöscht werden kann.

Geteilte Ablagen für Domainadministratoren verwalten

Wenden Sie den Parameter useDomainAdminAccess mit den Ressourcen drives und permissions an, um geteilte Ablagen in einer Organisation zu verwalten.

Nutzer, die diese Methoden mit useDomainAdminAccess=true aufrufen, müssen die Drive and Docs-Administratorberechtigung haben. Administratoren können nach geteilten Ablagen suchen oder Berechtigungen für geteilte Ablagen aktualisieren, die ihrer Organisation gehören, unabhängig davon, ob der Administrator Mitglied einer bestimmten geteilten Ablage ist.

Geteilte Ablage ohne Organisator wiederherstellen

Das folgende Beispiel zeigt, wie Sie diese Ressourcen verwenden, um freigegebene Ablagen wiederherzustellen, die keinen Organisator mehr haben.

Java

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

Auf GitHub ansehen

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

Auf GitHub ansehen

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": "[e-mail]",
    }
    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="[e-mail]")

Node.js

drive/snippets/drive_v3/drive_snippets/recover_drives.js

Auf GitHub ansehen

/**
 * 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: '[e-mail]'
  };

  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

Auf GitHub ansehen

<?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' => '[e-mail]'
    ));
    $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

Auf GitHub ansehen

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

Verhindern, dass Nutzer Ihre Datei herunterladen, drucken oder kopieren

Sie können einschränken, wie Nutzer Dateien in geteilten Ablagen herunterladen, drucken und kopieren dürfen.

Ob der Nutzer die vom Organisator angewendeten Downloadbeschränkungen einer geteilten Ablage ändern kann, sehen Sie im booleschen Feld capabilities.canChangeDownloadRestriction. Wenn capabilities.canChangeDownloadRestriction auf true festgelegt ist, können Downloadbeschränkungen auf die geteilte Ablage angewendet werden. Weitere Informationen finden Sie unter Dateifunktionen.

Die Ressource drives enthält eine Sammlung von booleschen restrictions-Feldern, die angeben, ob eine Aktion für eine geteilte Ablage ausgeführt werden kann. Einschränkungen gelten für eine geteilte Ablage oder Elemente in einer geteilten Ablage. Einschränkungen können mit der Methode drives.update festgelegt werden.

Wenn Sie Downloadbeschränkungen für eine geteilte Ablage festlegen möchten, kann ein Administrator der geteilten Ablage das Feld restrictions.downloadRestriction der Ressource drives mit dem Objekt DownloadRestriction festlegen. Wenn Sie das boolesche Feld restrictedForReaders auf true setzen, wird deklariert, dass sowohl das Herunterladen als auch das Kopieren für Leser eingeschränkt sind. Wenn Sie das boolesche Feld restrictedForWriters auf true setzen, wird erklärt, dass sowohl das Herunterladen als auch das Kopieren für Autoren eingeschränkt sind. Wenn das Feld restrictedForWriters den Wert true hat, sind Download und Kopieren auch für Leser eingeschränkt. Wenn Sie restrictedForWriters auf true und restrictedForReaders auf false festlegen, ist das dasselbe, als wenn Sie sowohl restrictedForWriters als auch restrictedForReaders auf true festlegen.

Abwärtskompatibilität

Mit der Einführung des Objekts DownloadRestriction wurde die Funktionalität des booleschen Felds restrictions.copyRequiresWriterPermission aktualisiert.

Wenn Sie restrictions.copyRequiresWriterPermission auf true setzen, wird das boolesche Feld restrictedForReaders des Objekts DownloadRestriction auf true aktualisiert, um anzugeben, dass sowohl das Herunterladen als auch das Kopieren für Leser eingeschränkt sind.

Wenn Sie das Feld copyRequiresWriterPermission auf false setzen, werden sowohl das Feld restrictedForWriters als auch das Feld restrictedForReaders auf false aktualisiert. Das bedeutet, dass die Einstellungen für Download- oder Kopierbeschränkungen für alle Nutzer entfernt werden.

Warnung: Sie sollten nur das alte Feld copyRequiresWriterPermissionoder das Objekt DownloadRestriction verwenden, um Einschränkungen für das Herunterladen, Drucken und Kopieren festzulegen. Die Felder sind nicht für die gemeinsame Verwendung vorgesehen, da die beiden Feldwerte in Konflikt stehen könnten.

Felder, mit denen die Funktionen zum Herunterladen, Drucken und Kopieren gesteuert werden

In der folgenden Tabelle sind die Ressourcenfelder für drives aufgeführt, die sich auf die Download-, Druck- und Kopierfunktionen auswirken:

Feld	Beschreibung	Version
capabilities.canCopy	Gibt an, ob der aktuelle Nutzer Dateien in einer geteilten Ablage kopieren kann.	v2 und v3
capabilities.canDownload	Gibt an, ob der aktuelle Nutzer Dateien in einer geteilten Ablage herunterladen kann.	v2 und v3
capabilities.canChangeCopyRequiresWriterPermission	Gibt an, ob der aktuelle Nutzer die copyRequiresWriterPermission-Einschränkung einer geteilten Ablage ändern kann.	v2 und v3
capabilities.canResetDriveRestrictions	Gibt an, ob der aktuelle Nutzer die Einschränkungen der geteilten Ablage auf die Standardeinstellungen zurücksetzen kann.	v2 und v3
capabilities.canChangeDownloadRestriction	Gibt an, ob der aktuelle Nutzer die Downloadbeschränkung einer geteilten Ablage ändern kann.	Nur v3
restrictions.copyRequiresWriterPermission	Gibt an, ob die Optionen zum Kopieren, Drucken oder Herunterladen von Dateien in einer geteilten Ablage für Leser und Kommentatoren deaktiviert sind. Wenn true, wird das gleichnamige Feld für alle Dateien in dieser geteilten Ablage auf true gesetzt.	v2 und v3
restrictions.downloadRestriction	Die von Administratoren für geteilte Ablagen angewendeten Downloadbeschränkungen.	Nur v3

Beschränkungen für Ordner

Für Ordner in geteilten Ablagen gelten einige Speicherlimits. Weitere Informationen finden Sie im Hilfeartikel Beschränkungen für geteilte Ablagen in Google Drive.

Elementobergrenze

Pro Ordner in der geteilten Ablage eines Nutzers sind 500.000 Elemente zulässig, darunter Dateien, Ordner und Verknüpfungen.

Wenn das Limit erreicht ist, können in der geteilten Ablage keine Elemente mehr gespeichert werden. Damit Nutzer wieder Dateien empfangen können, müssen sie Elemente aus dem Ordner endgültig löschen. Hinweis: Elemente im Papierkorb werden auf das Limit angerechnet, endgültig gelöschte Elemente jedoch nicht. Weitere Informationen finden Sie unter Dateien und Ordner in den Papierkorb verschieben oder löschen.

Beschränkung der Ordnertiefe

Ein Ordner in einer geteilten Ablage darf nicht mehr als 100 Ebenen verschachtelter Ordner beinhalten. Das bedeutet, dass ein untergeordneter Ordner nicht in einem Ordner gespeichert werden kann, der mehr als 99 Ebenen tief verschachtelt ist. Diese Einschränkung gilt nur für untergeordnete Ordner.

Wenn Sie versuchen, mehr als 100 Ebenen von Ordnern hinzuzufügen, wird der HTTP-Statuscode teamDriveHierarchyTooDeep zurückgegeben.

Hinweis :In der Drive API gibt es kein Feld drives, das die Tiefe eines Ordners zurückgeben kann. Um die Ordnerstruktur zu ermitteln, müssen Sie die Ordnerhierarchie manuell durchlaufen.

Weitere Informationen

• Beschränkungen von Dateien und Ordnern in Dateien