Geteilte Ablagen verwalten

Dieses Dokument enthält 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.

Wenn Sie die Felder angeben möchten, die in der Antwort zurückgegeben werden sollen, können Sie den fields System parameter mit einer beliebigen Methode der drives Ressource festlegen. Wenn Sie den Parameter fields nicht angeben, gibt der Server eine Standardgruppe von Feldern zurück, die für die Methode spezifisch sind. Die Methode list gibt beispielsweise nur die Felder kind, id, und name für jede geteilte Ablage zurück. Weitere Informationen finden Sie unter Bestimmte Felder zurückgeben.

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

Vorbereitung

Bevor Sie geteilte Ablagen erstellen und verwalten können, müssen Sie die folgenden Anforderungen erfüllen:

  • Google Workspace-Konto:Geteilte Ablagen sind in unterstützten Google Workspace-Versionen verfügbar, z. B. Business Standard, Business Plus, Enterprise und Education. Mit privaten Google-Konten (@gmail.com) können keine geteilten Ablagen erstellt werden.
  • Berechtigung zum Erstellen:Domainadministratoren können konfigurieren, ob Nutzer in ihrer Organisation geteilte Ablagen erstellen dürfen. Der authentifizierte Nutzer muss zu einer Organisationseinheit gehören, die geteilte Ablagen erstellen darf.
  • OAuth 2.0-Bereich:Ihre App muss mit dem Bereich https://www.googleapis.com/auth/drive autorisiert sein.
  • Rollen:Wenn ein Nutzer eine geteilte Ablage erstellt, wird ihm automatisch die Rolle organizer für diese geteilte Ablage zugewiesen. Für die Verwaltung der Drive-Einstellungen, das Umbenennen der Ablage, das Hinzufügen oder Entfernen von Mitgliedern und das Löschen der geteilten Ablage ist die Rolle organizer erforderlich. Weitere Informationen zu Rollen finden Sie unter Rollen für geteilte Ablagen.
  • Zugriff als Domainadministrator:Domainadministratoren können alle geteilten Ablagen in ihrer Organisation verwalten, unabhängig von der Mitgliedschaft, indem sie useDomainAdminAccess=true übergeben. Weitere Informationen finden Sie unter Geteilte Ablagen als Domainadministrator verwalten.

Geteilte Ablage erstellen

Verwenden Sie die create Methode für die drives Ressource mit dem requestId Parameter, um eine geteilte Ablage zu erstellen.

Der Parameter requestId gibt den logischen Versuch zur idempotenten Erstellung einer geteilten Ablage an. Wenn bei der Anfrage ein Zeitlimit überschritten wird oder ein unbestimmter Backend-Fehler zurückgegeben wird, kann dieselbe Anfrage wiederholt werden, ohne dass Duplikate erstellt werden. Der requestId und der Text der Anfrage müssen gleich bleiben.

Das folgende Codebeispiel zeigt, wie Sie eine geteilte Ablage erstellen:

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

Aufrufe der create Methode sind idempotent.

Wenn die geteilte Ablage bei einer vorherigen Anfrage oder aufgrund eines Wiederholungsversuchs erfolgreich erstellt wurde, gibt die Methode eine Instanz der Ressource drives zurück. 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 der requestId verworfen werden muss.

Geteilte Ablage abrufen

Verwenden Sie die get Methode für die drives Ressource mit dem driveId Pfad parameter, um Metadaten für eine geteilte Ablage abzurufen. Wenn Sie die Ablage-ID nicht kennen, können Sie alle geteilten Ablagen mit der list Methode auflisten.

Die Methode get gibt eine geteilte Ablage als Instanz einer Ressource drives zurück.

Wenn Sie die Anfrage als Domainadministrator ausführen möchten, setzen Sie den Abfrageparameter useDomainAdminAccess auf true. Weitere Informationen finden Sie unter Geteilte Ablagen als Domainadministrator verwalten.

Geteilte Ablagen auflisten

Verwenden Sie die list Methode für die drives Ressource, um die geteilten Ablagen eines Nutzers aufzulisten. Die Methode gibt eine Liste der geteilten Ablagen zurück.

Übergeben Sie die folgenden Abfrageparameter, um die Paginierung anzupassen oder geteilte Ablagen zu filtern:

  • pageSize: Die maximale Anzahl der geteilten Ablagen, die pro Seite zurückgegeben werden sollen.

  • pageToken: Ein Seitentoken, das von einem vorherigen Aufruf der Methode `list` empfangen wurde. Geben Sie dieses Token an, um die nachfolgende Seite abzurufen.

  • q: Abfragestring zum Suchen in geteilten Ablagen. Weitere Informationen finden Sie unter Nach geteilten Ablagen suchen.

  • useDomainAdminAccess: Setzen Sie den Wert auf true, um die Anfrage als Domainadministrator auszuführen und alle geteilten Ablagen der Domain zurückzugeben, in der der Anfragende ein Administrator ist. Weitere Informationen finden Sie unter Geteilte Ablagen als Domainadministrator verwalten.

Geteilte Ablage aktualisieren

Verwenden Sie die update Methode für die drives Ressource mit dem driveId Pfad parameter, um die Metadaten für eine geteilte Ablage zu aktualisieren.

Die Methode gibt eine geteilte Ablage als Instanz einer Ressource drives zurück.

Wenn Sie die Anfrage als Domainadministrator ausführen möchten, setzen Sie den Abfrageparameter useDomainAdminAccess auf true. Weitere Informationen finden Sie unter Geteilte Ablagen als Domainadministrator verwalten.

Geteilte Ablage ausblenden und einblenden

Verwenden Sie die hide Methode für die drives Ressource mit dem driveId Parameter, um eine geteilte Ablage in der Standardansicht auszublenden.

Wenn eine geteilte Ablage ausgeblendet ist, wird die Ressource der geteilten Ablage in Drive als hidden=true gekennzeichnet. Ausgeblendete geteilte Ablagen werden nicht in der Drive-Benutzeroberfläche oder in der Liste der zurückgegebenen Dateien angezeigt.

Verwenden Sie die unhide Methode für die drives Ressource mit dem driveId Parameter, um eine geteilte Ablage in der Standardansicht wiederherzustellen.

Beide Methoden geben eine geteilte Ablage als Instanz einer Ressource drives zurück.

Geteilte Ablage löschen

Verwenden Sie die delete Methode für die drives Ressource mit dem driveId Parameter, um eine geteilte Ablage endgültig zu löschen.

Bevor Sie eine geteilte Ablage löschen, müssen alle Inhalte in der geteilten Ablage in den Papierkorb verschoben oder gelöscht werden. Der Nutzer muss außerdem role=organizer für den Ordner der geteilten Ablage haben. Weitere Informationen finden Sie unter Dateien und Ordner in den Papierkorb verschieben oder löschen.

Übergeben Sie die folgenden Suchparameter:

  • useDomainAdminAccess: Setzen Sie den Wert auf true, um die Anfrage als Domainadministrator auszuführen. Weitere Informationen finden Sie unter Geteilte Ablagen als Domainadministrator verwalten.

  • allowItemDeletion: Setzen Sie den Wert auf true, um Elemente in der geteilten Ablage zu löschen. Wird nur unterstützt, wenn useDomainAdminAccess ebenfalls auf true gesetzt ist.

Mitglieder einer geteilten Ablage hinzufügen oder entfernen

Verwenden Sie die permissions Ressource, um Mitglieder einer geteilten Ablage hinzuzufügen oder zu entfernen.

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

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

Geteilte Ablagen als Domainadministrator verwalten

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

Nutzer, die diese Methoden mit useDomainAdminAccess=true aufrufen, müssen die Drive and Docs Administrator Berechtigung 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.

Wenn Sie Dienstkonten verwenden, müssen Sie möglicherweise die Identität eines authentifizierten Administrators annehmen, indem Sie die Identitätsübernahme des Dienstkontos verwenden. Dienstkonten gehören im Gegensatz zu Nutzerkonten nicht zu Ihrer Google Workspace-Domain. Wenn Sie Google Workspace-Assets wie Dokumente oder Ereignisse für Ihre gesamte Google Workspace-Domain freigeben, werden diese nicht für Dienstkonten freigegeben. Weitere Informationen finden Sie unter Dienstkonten übersicht.

Geteilte Ablage wiederherstellen, die keinen Administrator hat

Das folgende Codebeispiel zeigt, wie Sie geteilte Ablagen wiederherstellen, die keinen Administrator mehr haben.

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

Verhindern, dass Nutzer Dateien herunterladen, drucken oder kopieren

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

Prüfen Sie das capabilities.canChangeDownloadRestriction boolesche Feld, um festzustellen, ob der Nutzer die vom Administrator angewendeten Download-Einschränkungen einer geteilten Ablage ändern kann. Wenn capabilities.canChangeDownloadRestriction auf true gesetzt ist, können Download-Einschränkungen auf die geteilte Ablage angewendet werden. Weitere Informationen finden Sie unter Dateifunktionen.

Die drives Ressource enthält eine Sammlung boolescher restrictions Felder, 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 drives.update Methode festgelegt werden.

Wenn ein Administrator einer geteilten Ablage Download-Einschränkungen auf eine geteilte Ablage anwenden möchte, kann er das Feld restrictions.downloadRestriction der drives Ressource mit dem DownloadRestriction Objekt festlegen. Wenn das boolesche Feld restrictedForReaders auf true gesetzt ist, sind sowohl das Herunterladen als auch das Kopieren für Leser eingeschränkt. Wenn das boolesche Feld restrictedForWriters auf true gesetzt ist, sind sowohl das Herunterladen als auch das Kopieren für Mitbearbeiter eingeschränkt. Wenn das Feld restrictedForWriters auf true gesetzt ist, sind das Herunterladen und Kopieren auch für Leser eingeschränkt. Wenn Sie restrictedForWriters auf true und restrictedForReaders auf false setzen, ist das gleichbedeutend damit, dass sowohl restrictedForWriters als auch restrictedForReaders auf true gesetzt sind.

Abwärtskompatibilität

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

Wenn Sie restrictions.copyRequiresWriterPermission jetzt auf true setzen, wird das restrictedForReaders boolesche Feld des Objekts DownloadRestriction auf true gesetzt, 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 die Felder restrictedForWriters als auch restrictedForReaders auf false gesetzt. Das bedeutet, dass die Einschränkungen für das Herunterladen oder Kopieren für alle Nutzer entfernt werden.

Felder, die die Funktionen zum Herunterladen, Drucken und Kopieren steuern

Die folgende Tabelle enthält die Felder der Ressource drives, die sich auf die Funktionen zum Herunterladen, Drucken und Kopieren 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.canChangeCopyRequiresWriterPermissionRestriction Gibt an, ob der aktuelle Nutzer die Einschränkung copyRequiresWriterPermission einer geteilten Ablage ändern kann. v2 und v3
capabilities.canResetDriveRestrictions Gibt an, ob der aktuelle Nutzer die Einschränkungen für die geteilte Ablage auf die Standardeinstellungen zurücksetzen kann. v2 und v3
capabilities.canChangeDownloadRestriction Gibt an, ob der aktuelle Nutzer die Download-Einschrä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 jede Datei in dieser geteilten Ablage auf true gesetzt. v2 und v3
restrictions.downloadRestriction Die von Administratoren für geteilte Ablagen angewendeten Download-Einschränkungen. Nur v3

Beschränkungen für Ordner

Für geteilte Ablagen gelten Beschränkungen für Elemente und die Ordnerstruktur. Außerdem wird die Speichernutzung mit dem gemeinsamen Speicher der Organisation verglichen, nicht mit dem persönlichen Speicherplatz des einzelnen Nutzers in „Meine Ablage“. Weitere Informationen finden Sie unter Beschränkungen für geteilte Ablagen in Google Drive.

Elementobergrenze

Eine geteilte Ablage kann maximal 500.000 Elemente enthalten, darunter Dateien, Ordner und Verknüpfungen.

Wenn das Limit erreicht ist, können in der geteilten Ablage keine Elemente mehr gespeichert werden. Wenn Nutzer wieder Dateien empfangen möchten, müssen sie Elemente endgültig aus der geteilten Ablage löschen. 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 für die Ordnerstruktur

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

Wenn Sie mehr als 100 Ordnerebenen hinzufügen möchten, wird eine teamDriveHierarchyTooDeep Antwort mit dem HTTP-Statuscode zurückgegeben.