Dateien, Ordner und Laufwerke freigeben

Jede Google Drive-Datei, jeder Google Drive-Ordner und jede geteilte Google Drive-Ablage hat zugewiesene permissions-Ressourcen. Jede Ressource identifiziert die Berechtigung für einen bestimmten type (user, group, domain, anyone) und role (owner, organizer, fileOrganizer, writer, commenter, reader). So kann eine Datei beispielsweise eine Berechtigung haben, die einem bestimmten Nutzer (type=user) Lesezugriff (role=reader) gewährt, während eine andere Berechtigung Mitgliedern einer bestimmten Gruppe (type=group) die Möglichkeit gibt, einer Datei Kommentare hinzuzufügen (role=commenter).

Eine vollständige Liste der Rollen und der zugehörigen zulässigen Vorgänge finden Sie unter Rollen und Berechtigungen.

Szenarien für die Freigabe von Google Drive-Ressourcen

Es gibt fünf verschiedene Arten von Freigabeszenarien:

1. Um eine Datei in „Meine Ablage“ freizugeben, muss der Nutzer role=writer oder role=owner haben.

   • Wenn der boolesche Wert writersCanShare für die Datei auf false festgelegt ist, muss der Nutzer role=owner haben.

   • Wenn der Nutzer mit role=writer vorübergehenden Zugriff hat, der durch ein Ablaufdatum und eine Ablaufzeit geregelt ist, kann er die Datei nicht freigeben. Weitere Informationen finden Sie unter Ablaufdatum festlegen, um den Dateizugriff einzuschränken.

2. Wenn ein Nutzer einen Ordner in „Meine Ablage“ freigeben möchte, benötigt er die Berechtigung role=writer oder role=owner.

   • Wenn der boolesche Wert writersCanShare für die Datei auf false festgelegt ist, muss der Nutzer die umfassendere Berechtigung role=owner haben.

   • Der vorübergehende Zugriff (geregelt durch ein Ablaufdatum und eine Ablaufzeit) ist für Ordner in „Meine Ablage“ mit role=writer nicht zulässig. Weitere Informationen finden Sie unter Ein Ablaufdatum festlegen, um den Dateizugriff einzuschränken.

3. Wenn ein Nutzer eine Datei in einer geteilten Ablage freigeben möchte, muss er die Rolle role=writer, role=fileOrganizer oder role=organizer haben.

   • Die Einstellung writersCanShare gilt nicht für Elemente in geteilten Ablagen. Es wird so behandelt, als wäre es immer auf true festgelegt.

4. Wenn der Nutzer einen Ordner in einer geteilten Ablage freigeben möchte, benötigt er role=organizer.

   • Wenn die sharingFoldersRequiresOrganizerPermission-Einschränkung für eine geteilte Ablage auf false festgelegt ist, können Nutzer mit role=fileOrganizer Ordner in dieser geteilten Ablage freigeben.

5. Um die Mitgliedschaft in einer geteilten Ablage verwalten zu können, benötigt der Nutzer role=organizer. Nur Nutzer und Gruppen können Mitglieder von geteilten Ablagen sein.

Ablaufdatum festlegen, um den Dateizugriff einzuschränken

Wenn Sie mit anderen Personen an einem sensiblen Projekt arbeiten, möchten Sie deren Zugriff auf bestimmte Dateien in Drive möglicherweise nach einer bestimmten Zeit beschränken. Bei Dateien in „Meine Ablage“ können Sie ein Ablaufdatum festlegen, um den Zugriff auf eine Datei einzuschränken oder zu beenden.

So legen Sie das Ablaufdatum fest:

• Verwenden Sie die Methode create() für die Ressource permissions und legen Sie das Feld expirationTime (zusammen mit den anderen erforderlichen Feldern) fest. Weitere Informationen finden Sie unter Berechtigung erstellen.

• Verwenden Sie die Methode update() für die Ressource permissions und legen Sie das Feld expirationTime (zusammen mit den anderen erforderlichen Feldern) fest. Weitere Informationen finden Sie unter Berechtigungen ändern.

Im Feld expirationTime wird das Ablaufdatum der Berechtigung im RFC 3339-Datum-Uhrzeit-Format angegeben. Für Ablaufzeiten gelten die folgenden Einschränkungen:

• Sie können nur für Nutzer- und Gruppenberechtigungen festgelegt werden.
• Die Uhrzeit muss in der Zukunft liegen.
• Der Zeitpunkt darf nicht mehr als ein Jahr in der Zukunft liegen.

Weitere Informationen zum Ablaufdatum finden Sie in den folgenden Artikeln:

• Ablaufdatum für Dateizugriff festlegen
• Ablaufdatum angeben

Berechtigungsverteilung

Berechtigungslisten für einen Ordner werden nach unten weitergegeben und alle untergeordneten Dateien und Ordner übernehmen die Berechtigungen des übergeordneten Elements. Jedes Mal, wenn Berechtigungen oder die Hierarchie geändert werden, erfolgt die Weiterleitung rekursiv über alle verschachtelten Ordner. Wenn sich beispielsweise eine Datei in einem Ordner befindet und dieser Ordner dann in einen anderen Ordner verschoben wird, werden die Berechtigungen für den neuen Ordner auf die Datei übertragen. Wenn dem Nutzer der Datei im neuen Ordner eine neue Rolle wie „Schreiber“ zugewiesen wird, wird seine alte Rolle überschrieben.

Wenn eine Datei hingegen role=writer von einem Ordner übernimmt und in einen anderen Ordner verschoben wird, der die Rolle „Leser“ bereitstellt, übernimmt die Datei jetzt role=reader.

Übernommene Berechtigungen können nicht aus einer Datei oder einem Ordner in einer geteilten Ablage entfernt werden. Stattdessen müssen diese Berechtigungen auf dem direkt oder indirekt übergeordneten Element angepasst werden, von dem sie übernommen wurden. Übernommene Berechtigungen können unter „Meine Ablage“ oder „Für mich freigegeben“ von Elementen entfernt werden.

Umgekehrt können übernommene Berechtigungen für eine Datei oder einen Ordner in „Mein Drive“ überschrieben werden. Wenn also eine Datei role=writer von einem Ordner in Google Drive erbt, können Sie für die Datei role=reader festlegen, um die Berechtigungsebene zu senken.

Leistungsspektrum

Die Ressource permissions bestimmt nicht letztendlich, ob der aktuelle Nutzer Aktionen auf einer Datei oder einem Ordner ausführen kann. Stattdessen enthält die Ressource files eine Reihe von booleschen capabilities-Feldern, die angeben, ob eine Aktion auf einer Datei oder einem Ordner ausgeführt werden kann. Die Google Drive API legt diese Felder basierend auf der Berechtigungsressource des aktuellen Nutzers fest, die mit der Datei oder dem Ordner verknüpft ist.

Wenn sich Alex beispielsweise in Ihrer App anmeldet und versucht, eine Datei freizugeben, wird seine Rolle auf Berechtigungen für die Datei geprüft. Wenn die Rolle die Freigabe einer Datei zulässt, werden die mit der Datei verknüpften capabilities-Werte, z. B. canShare, entsprechend der Rolle ausgefüllt. Wenn Alex die Datei freigeben möchte, prüft Ihre App die capabilities, um sicherzustellen, dass canShare auf true festgelegt ist.

Ein Beispiel zum Abrufen der Datei capabilities finden Sie unter Nutzerberechtigungen prüfen.

Berechtigung erstellen

Die folgenden beiden Felder sind beim Erstellen einer Berechtigung erforderlich:

• type: Mit type wird der Umfang der Berechtigung (user, group, domain oder anyone) angegeben. Eine Berechtigung mit type=user gilt für einen bestimmten Nutzer, während eine Berechtigung mit type=domain für alle Nutzer in einer bestimmten Domain gilt.

• role: Im Feld role werden die Vorgänge angegeben, die die type ausführen kann. Eine Berechtigung mit type=user und role=reader gewährt beispielsweise einem bestimmten Nutzer Lesezugriff auf die Datei oder den Ordner. Mit einer Berechtigung mit type=domain und role=commenter können alle Nutzer in der Domain Kommentare zu einer Datei hinzufügen. Eine vollständige Liste der Rollen und der zulässigen Vorgänge finden Sie unter Rollen und Berechtigungen.

Wenn Sie eine Berechtigung mit type=user oder type=group erstellen, müssen Sie auch eine emailAddress angeben, um den jeweiligen Nutzer oder die jeweilige Gruppe mit der Berechtigung zu verknüpfen.

Wenn Sie eine Berechtigung mit type=domain erstellen, müssen Sie auch einen domain angeben, um eine bestimmte Domain mit der Berechtigung zu verknüpfen.

So erstellen Sie eine Berechtigung:

1. Verwenden Sie die Methode create() mit dem Pfadparameter fileId für die zugehörige Datei oder den zugehörigen Ordner.
2. Geben Sie im Anfragetext type und role an.
3. Geben Sie bei type=user oder type=group ein emailAddress an. Wenn type=domain, geben Sie einen domain an.

POST https://www.googleapis.com/drive/v3/files/FILE_ID/permissions

{
  "requests": [
    {
        "type": "user",
        "role": "commenter",
        "emailAddress": "alex@altostrat.com"
    }
  ]
}

{
    "kind": "drive#permission",
    "id": "PERMISSION_ID",
    "type": "user",
    "role": "commenter"
}

Zielgruppen verwenden

Zielgruppen sind Personengruppen, z. B. Abteilungen oder Teams, die Sie Nutzern zur Freigabe von Elementen empfehlen können. Sie können Nutzer dazu anregen, Elemente nicht für die gesamte Organisation, sondern für eine bestimmte Gruppe freizugeben. Mit Zielgruppen können Sie die Sicherheit und den Datenschutz Ihrer Daten verbessern und es Nutzern erleichtern, Inhalte angemessen zu teilen. Weitere Informationen finden Sie unter Zielgruppen.

So verwenden Sie Zielgruppen:

1. Klicken Sie in der Admin-Konsole auf das Dreistrich-Menü menu > Verzeichnis > Zielgruppen.

   Zu Zielgruppen

   Für diese Aufgabe müssen Sie mit einem Konto mit Super Admin-Berechtigungen angemeldet sein.

2. Klicken Sie in der Liste Zielgruppen auf den Namen der Zielgruppe. Weitere Informationen zum Erstellen einer Zielgruppe finden Sie unter Zielgruppe erstellen.

3. Kopieren Sie die eindeutige ID aus der URL der Zielgruppe: https://admin.google.com/ac/targetaudiences/ID.

4. Erstellen Sie eine Berechtigung mit type=domain und legen Sie das Feld domain auf ID.audience.googledomains.com fest.

Informationen dazu, wie Nutzer mit Zielgruppen interagieren, finden Sie unter Nutzerfreundlichkeit beim Teilen von Links.

Alle Berechtigungen für eine Datei, einen Ordner oder eine geteilte Ablage abrufen

Verwenden Sie die Methode list() für die Ressource permissions, um alle Berechtigungen für eine Datei, einen Ordner oder eine freigegebene Ablage abzurufen.

GET https://www.googleapis.com/drive/v3/files/FILE_ID/permissions

{
  "kind": "drive#permissionList",
  "permissions": [
    {
      "id": "PERMISSION_ID",
      "type": "user",
      "kind": "drive#permission",
      "role": "commenter"
    }
  ]
}

Nutzerberechtigungen prüfen

Wenn Ihre App eine Datei öffnet, sollte sie die Funktionen der Datei prüfen und die Benutzeroberfläche so rendern, dass die Berechtigungen des aktuellen Nutzers berücksichtigt werden. Wenn der Nutzer beispielsweise keine canComment-Funktion für die Datei hat, sollte die Kommentarfunktion in der Benutzeroberfläche deaktiviert sein.

Weitere Informationen zu capabilities finden Sie im Abschnitt Funktionen.

Rufen Sie zum Prüfen der Funktionen die Methode get() für die Ressource files mit dem Pfadparameter fileId und dem Parameter fields auf, der auf das Feld capabilities gesetzt ist. Weitere Informationen zum Zurückgeben von Feldern mit dem Parameter fields finden Sie unter Bestimmte Felder für eine Datei zurückgeben.

GET https://www.googleapis.com/drive/v3/files/FILE_ID?fields=capabilities

{
  "capabilities": {
    "canAcceptOwnership": false,
    "canAddChildren": false,
    "canAddMyDriveParent": false,
    "canChangeCopyRequiresWriterPermission": true,
    "canChangeSecurityUpdateEnabled": false,
    "canComment": true,
    "canCopy": true,
    "canDelete": true,
    "canDownload": true,
    "canEdit": true,
    "canListChildren": false,
    "canModifyContent": true,
    "canModifyContentRestriction": true,
    "canModifyLabels": true,
    "canMoveChildrenWithinDrive": false,
    "canMoveItemOutOfDrive": true,
    "canMoveItemWithinDrive": true,
    "canReadLabels": true,
    "canReadRevisions": true,
    "canRemoveChildren": false,
    "canRemoveMyDriveParent": true,
    "canRename": true,
    "canShare": true,
    "canTrash": true,
    "canUntrash": true
  }
}

Rollenquelle für Dateien und Ordner in geteilten Ablagen ermitteln

Wenn Sie die Rolle für eine Datei oder einen Ordner ändern möchten, müssen Sie die Quelle der Rolle kennen. Bei geteilten Ablagen kann die Quelle einer Rolle auf der Mitgliedschaft in der geteilten Ablage, der Rolle für einen Ordner oder der Rolle für eine Datei basieren.

Wenn Sie die Rollenquelle für ein freigegebenes Laufwerk oder Elemente auf diesem Laufwerk ermitteln möchten, rufen Sie die Methode get() für die Ressource permissions mit den Pfadparametern fileId und permissionId auf und legen Sie den Parameter fields auf das Feld permissionDetails fest.

Um permissionId zu finden, verwenden Sie die Methode list() für die Ressource permissions mit dem Pfadparameter fileId. Wenn Sie das Feld permissionDetails in der list-Anfrage abrufen möchten, setzen Sie den Parameter fields auf permissions/permissionDetails.

In diesem Feld werden alle übernommenen und direkten Dateiberechtigungen für den Nutzer, die Gruppe oder die Domain aufgelistet.

GET https://www.googleapis.com/drive/v3/files/FILE_ID/permissions/PERMISSION_ID?fields=permissionDetails&supportsAllDrives=true

{
  "permissionDetails": [
    {
      "permissionType": "member",
      "role": "commenter",
      "inheritedFrom": "INHERITED_FROM_ID",
      "inherited": true
    },
    {
      "permissionType": "file",
      "role": "writer",
      "inherited": false
    }
  ]
}

Berechtigungen ändern

Wenn Sie die Berechtigungen für eine Datei oder einen Ordner ändern möchten, können Sie die zugewiesene Rolle ändern:

1. Rufen Sie die Methode update() für die Ressource permissions auf. Dabei muss der Pfadparameter permissionId auf die Berechtigung zum Ändern und der Pfadparameter fileId auf die zugehörige Datei, den zugehörigen Ordner oder die zugehörige freigegebene Ablage festgelegt sein. Um permissionId zu finden, verwenden Sie die Methode list() für die Ressource permissions mit dem Pfadparameter fileId.

2. Geben Sie in der Anfrage die neue role an.

Sie können Berechtigungen für einzelne Dateien oder Ordner in einer geteilten Ablage gewähren, auch wenn der Nutzer oder die Gruppe bereits Mitglied ist. Alex hat beispielsweise role=commenter als Mitglied einer geteilten Ablage. Ihre App kann Alex jedoch role=writer für eine Datei in einer geteilten Ablage gewähren. Da die neue Rolle in diesem Fall großzügiger ist als die Rolle, die über die Mitgliedschaft gewährt wurde, wird die neue Berechtigung zur effektiven Rolle für die Datei oder den Ordner.

PATCH https://www.googleapis.com/drive/v3/files/FILE_ID/permissions/PERMISSION_ID

{
  "requests": [
    {
        "role": "writer"
    }
  ]
}

{
  "kind": "drive#permission",
  "id": "PERMISSION_ID",
  "type": "user",
  "role": "writer"
}

Ausstehende Zugriffsanfragen auflisten und bearbeiten

Ein Zugriffsvorschlag ist ein Vorschlag eines Antragstellers an einen Genehmiger, einem Empfänger Zugriff auf ein Drive-Element zu gewähren.

Genehmiger können alle nicht abgeschlossenen Zugriffsanfragen für Google Drive-Dateien prüfen und bearbeiten. So können Sie den Genehmigungsprozess beschleunigen, indem Sie programmatisch nach Zugriffsanfragen fragen und sie dann genehmigen. Außerdem können Genehmiger Vorschläge insgesamt ansehen.

Die Drive API bietet die Ressource accessproposals, mit der Sie ausstehende Zugriffsanfragen ansehen und bearbeiten können. Die Methoden der accessproposals-Ressource funktionieren für Dateien, Ordner und die Dateien in einer geteilten Ablage, nicht aber für die geteilte Ablage selbst.

Die folgenden Begriffe beziehen sich speziell auf Zugriffsanfragen:

• Antragsteller: Der Nutzer, der den Zugriff auf ein Drive-Element anfordert.
• Empfänger: Der Nutzer, der die zusätzlichen Berechtigungen für eine Datei erhält, wenn der Zugriffsvorschlag gewährt wird. In vielen Fällen ist der Empfänger mit dem Antragsteller identisch, aber nicht immer.
• Genehmiger: Der Nutzer, der für die Genehmigung oder Ablehnung des Zugriffsvorschlags verantwortlich ist. Das liegt in der Regel daran, dass sie Eigentümer des Dokuments sind oder die Möglichkeit haben, das Dokument freizugeben.

Ausstehende Zugriffsanfragen auflisten

Wenn Sie alle ausstehenden Zugriffsanfragen für ein Drive-Element auflisten möchten, rufen Sie die Methode list() für die Ressource accessproposals auf und geben Sie den Pfadparameter fileId an.

Nur Genehmiger einer Datei können die ausstehenden Vorschläge in einer Datei auflisten. Ein Genehmiger ist ein Nutzer mit der can_approve_access_proposals-Berechtigung für die Datei. Wenn der Antragsteller kein Genehmiger ist, wird eine leere Liste zurückgegeben. Weitere Informationen zu capabilities finden Sie im Abschnitt Funktionen.

Der Antwortkörper besteht aus einem AccessProposal-Objekt, das eine Liste der nicht abgeschlossenen Zugriffsanfragen für die Datei darstellt.

Das AccessProposal-Objekt enthält Informationen zu jedem Vorschlag, z. B. den Anfragenden, den Empfänger und die Nachricht, die der Anfragende hinzugefügt hat. Außerdem enthält sie ein AccessProposalRoleAndView-Objekt, in dem der vorgeschlagene role des Antragstellers mit einem view gruppiert wird. Da role ein wiederkehrendes Feld ist, kann es für jeden Vorschlag mehrere Einträge geben. Ein Vorschlag kann beispielsweise ein AccessProposalRoleAndView-Objekt mit role=reader und view=published sowie ein zusätzliches AccessProposalRoleAndView-Objekt mit nur dem Wert role=writer enthalten. Weitere Informationen finden Sie unter Aufrufe.

Mit den folgenden Abfrageparametern können Sie die Paginierung anpassen oder Zugriffsvorschläge filtern:

• pageToken: Ein Seitentoken, das von einem vorherigen Listenaufruf empfangen wurde. Geben Sie dieses Token an, um die nachfolgende Seite abzurufen.

• pageSize: Die maximale Anzahl von Zugriffsanträgen, die pro Seite zurückgegeben werden sollen.

Ausstehende Zugriffsanfragen bearbeiten

Wenn Sie alle ausstehenden Zugriffsanfragen für ein Drive-Element bearbeiten möchten, rufen Sie die Methode resolve() für die Ressource accessproposals auf und geben Sie die Pfadparameter fileId und proposalId an.

Die Methode resolve() enthält den Abfrageparameter action, der die Aktion angibt, die mit dem Vorschlag ausgeführt werden soll. Das Objekt Action überwacht den Statuswechsel des Angebots, damit wir wissen, ob es angenommen oder abgelehnt wird.

Die Methode resolve() umfasst auch die optionalen Abfrageparameter role und view. Die einzigen unterstützten Rollen sind writer, commenter und reader. Wenn die Rolle nicht angegeben ist, wird standardmäßig reader verwendet. Mit dem zusätzlichen optionalen Abfrageparameter send_notification können Sie dem Antragsteller eine E-Mail-Benachrichtigung senden, wenn der Vorschlag angenommen oder abgelehnt wird.

Genau wie bei der Methode list() müssen Nutzer, die den Vorschlag bearbeiten, die Funktion can_approve_access_proposals für die Datei haben. Weitere Informationen zu capabilities finden Sie im Abschnitt Funktionen.

Vorschläge werden anhand derselben Muster gelöst, die unter Szenarien für die Freigabe von Drive-Ressourcen aufgeführt sind. Wenn es mehrere Vorschläge für denselben Nutzer, aber mit unterschiedlichen Rollen gibt, gilt Folgendes:

• Wenn ein Vorschlag angenommen und ein anderer abgelehnt wird, gilt die angenommene Rolle für das Drive-Element.
• Wenn beide Vorschläge gleichzeitig angenommen werden, wird der Vorschlag mit der höheren Berechtigung angewendet (z. B. role=writer gegenüber role=reader). Der andere Zugriffsvorschlag wird aus dem Artikel entfernt.

Nachdem ein Vorschlag an die resolve()-Methode gesendet wurde, ist die Freigabe abgeschlossen. Die AccessProposal wird nicht mehr über die list()-Methode zurückgegeben. Sobald der Vorschlag akzeptiert wurde, muss der Nutzer die Sammlung permissions verwenden, um die Berechtigungen für eine Datei oder einen Ordner zu aktualisieren. Weitere Informationen finden Sie im Abschnitt Berechtigungen ändern.

Zugriff auf eine Datei oder einen Ordner widerrufen

Wenn Sie den Zugriff auf eine Datei oder einen Ordner widerrufen möchten, rufen Sie die Methode delete() für die Ressource permissions mit den Pfadparametern fileId und permissionId auf, um die Berechtigung zu löschen.

Bei Elementen in „Meine Ablage“ können Sie eine übernommene Berechtigung löschen. Wenn Sie eine übernommene Berechtigung löschen, wird der Zugriff auf das Element und gegebenenfalls auf untergeordnete Elemente widerrufen.

Für Elemente in einer geteilten Ablage können übernommene Berechtigungen nicht widerrufen werden. Aktualisieren oder widerrufen Sie stattdessen die Berechtigung für die übergeordnete Datei oder den übergeordneten Ordner.

Mit der delete()-Methode können auch Berechtigungen gelöscht werden, die direkt auf eine Datei oder einen Ordner in einer geteilten Ablage angewendet wurden.

DELETE https://www.googleapis.com/drive/v3/files/FILE_ID/permissions/PERMISSION_ID

Dateieigentümerschaft auf ein anderes Google Workspace-Konto in derselben Organisation übertragen

Die Inhaberschaft von Dateien in „Meine Ablage“ kann von einem Google Workspace-Konto auf ein anderes Konto in derselben Organisation übertragen werden. Die Organisation, die Eigentümer einer geteilten Ablage ist, ist auch Eigentümer der darin enthaltenen Dateien. Daher werden Eigentumsübertragungen für Dateien und Ordner in geteilten Ablagen nicht unterstützt. Organisatoren einer geteilten Ablage können Elemente aus dieser geteilten Ablage in ihre eigene „Meine Ablage“ verschieben. Dadurch werden die Eigentumsrechte auf sie übertragen.

So übertragen Sie die Eigentümerschaft einer Datei in „Meine Ablage“:

• Erstellen Sie eine Dateiberechtigung, die einem bestimmten Nutzer (type=user) Inhaberzugriff (role=owner) gewährt.

• Aktualisieren Sie die Berechtigung einer vorhandenen Datei mit role=owner und übertragen Sie die Eigentümerschaft an den angegebenen Nutzer (transferOwnership=true).

Inhaberschaft von Dateien von einem privaten Konto auf ein anderes übertragen

Die Inhaberschaft von Dateien kann zwischen zwei Nutzerkonten übertragen werden. In Drive wird die Inhaberschaft einer Datei jedoch erst dann zwischen den beiden Privatnutzerkonten übertragen, wenn der zukünftige Inhaber der Übertragung ausdrücklich zustimmt. So übertragen Sie die Inhaberschaft von Dateien von einem privaten Konto auf ein anderes:

1. Der aktuelle Inhaber initiiert eine Übertragung der Inhaberschaft, indem er die Dateiberechtigung des zukünftigen Inhabers erstellt oder aktualisiert. Die Berechtigung muss die folgenden Einstellungen enthalten: role=writer, type=user und pendingOwner=true. Wenn der aktuelle Inhaber eine Berechtigung für den zukünftigen Inhaber erstellt, wird dieser per E-Mail darüber informiert, dass er die Inhaberschaft der Datei übernehmen soll.

2. Der potenzielle Eigentümer akzeptiert die Anfrage zur Übertragung der Eigentümerschaft, indem er seine Dateiberechtigung erstellt oder aktualisiert. Die Berechtigung muss die folgenden Einstellungen enthalten: role=owner und transferOwnership=true. Wenn der potenzielle Eigentümer eine neue Berechtigung erstellt, wird der vorherige Eigentümer per E-Mail darüber informiert, dass die Inhaberschaft übertragen wurde.

Wenn eine Datei übertragen wird, wird die Rolle des vorherigen Inhabers auf writer herabgestuft.

Mehrere Berechtigungen mit Batchanfragen ändern

Wir empfehlen dringend, Batchanfragen zu verwenden, um mehrere Berechtigungen zu ändern.

Im Folgenden finden Sie ein Beispiel für die Änderung mehrerer Berechtigungen mit einer Clientbibliothek.

import com.google.api.client.googleapis.batch.BatchRequest;
import com.google.api.client.googleapis.batch.json.JsonBatchCallback;
import com.google.api.client.googleapis.json.GoogleJsonError;
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.HttpHeaders;
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.Drive;
import com.google.api.services.drive.DriveScopes;
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 modify permissions. */
public class ShareFile {

  /**
   * Batch permission modification.
   * realFileId file Id.
   * realUser User Id.
   * realDomain Domain of the user ID.
   *
   * @return list of modified permissions if successful, {@code null} otherwise.
   * @throws IOException if service account credentials file not found.
   */
  public static List<String> shareFile(String realFileId, String realUser, String realDomain)
      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.application*/
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
        .createScoped(Arrays.asList(DriveScopes.DRIVE_FILE));
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

    // Build a new authorized API client service.
    Drive service = new Drive.Builder(new NetHttpTransport(),
        GsonFactory.getDefaultInstance(),
        requestInitializer)
        .setApplicationName("Drive samples")
        .build();

    final List<String> ids = new ArrayList<String>();


    JsonBatchCallback<Permission> callback = new JsonBatchCallback<Permission>() {
      @Override
      public void onFailure(GoogleJsonError e,
                            HttpHeaders responseHeaders)
          throws IOException {
        // Handle error
        System.err.println(e.getMessage());
      }

      @Override
      public void onSuccess(Permission permission,
                            HttpHeaders responseHeaders)
          throws IOException {
        System.out.println("Permission ID: " + permission.getId());

        ids.add(permission.getId());

      }
    };
    BatchRequest batch = service.batch();
    Permission userPermission = new Permission()
        .setType("user")
        .setRole("writer");

    userPermission.setEmailAddress(realUser);
    try {
      service.permissions().create(realFileId, userPermission)
          .setFields("id")
          .queue(batch, callback);

      Permission domainPermission = new Permission()
          .setType("domain")
          .setRole("reader");

      domainPermission.setDomain(realDomain);

      service.permissions().create(realFileId, domainPermission)
          .setFields("id")
          .queue(batch, callback);

      batch.execute();

      return ids;
    } catch (GoogleJsonResponseException e) {
      // TODO(developer) - handle error appropriately
      System.err.println("Unable to modify permission: " + e.getDetails());
      throw e;
    }
  }
}

import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def share_file(real_file_id, real_user, real_domain):
  """Batch permission modification.
  Args:
      real_file_id: file Id
      real_user: User ID
      real_domain: Domain of the user ID
  Prints modified permissions

  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)
    ids = []
    file_id = real_file_id

    def callback(request_id, response, exception):
      if exception:
        # Handle error
        print(exception)
      else:
        print(f"Request_Id: {request_id}")
        print(f'Permission Id: {response.get("id")}')
        ids.append(response.get("id"))

    # pylint: disable=maybe-no-member
    batch = service.new_batch_http_request(callback=callback)
    user_permission = {
        "type": "user",
        "role": "writer",
        "emailAddress": "user@example.com",
    }
    batch.add(
        service.permissions().create(
            fileId=file_id,
            body=user_permission,
            fields="id",
        )
    )
    domain_permission = {
        "type": "domain",
        "role": "reader",
        "domain": "example.com",
    }
    domain_permission["domain"] = real_domain
    batch.add(
        service.permissions().create(
            fileId=file_id,
            body=domain_permission,
            fields="id",
        )
    )
    batch.execute()

  except HttpError as error:
    print(f"An error occurred: {error}")
    ids = None

  return ids


if __name__ == "__main__":
  share_file(
      real_file_id="1dUiRSoAQKkM3a4nTPeNQWgiuau1KdQ_l",
      real_user="gduser1@workspacesamples.dev",
      real_domain="workspacesamples.dev",
  )

/**
 * Batch permission modification
 * @param{string} fileId file ID
 * @param{string} targetUserEmail username
 * @param{string} targetDomainName domain
 * @return{list} permission id
 * */
async function shareFile(fileId, targetUserEmail, targetDomainName) {
  const {GoogleAuth} = require('google-auth-library');
  const {google} = require('googleapis');

  // Get credentials and build service
  // TODO (developer) - Use appropriate auth mechanism for your app
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });
  const service = google.drive({version: 'v3', auth});
  const permissionIds = [];

  const permissions = [
    {
      type: 'user',
      role: 'writer',
      emailAddress: targetUserEmail, // 'user@partner.com',
    },
    {
      type: 'domain',
      role: 'writer',
      domain: targetDomainName, // 'example.com',
    },
  ];
  // Note: Client library does not currently support HTTP batch
  // requests. When possible, use batched requests when inserting
  // multiple permissions on the same item. For this sample,
  // permissions are inserted serially.
  for (const permission of permissions) {
    try {
      const result = await service.permissions.create({
        resource: permission,
        fileId: fileId,
        fields: 'id',
      });
      permissionIds.push(result.data.id);
      console.log(`Inserted permission id: ${result.data.id}`);
    } catch (err) {
      // TODO(developer): Handle failed permissions
      console.error(err);
    }
  }
  return permissionIds;
}

use Google\Client;
use Google\Service\Drive;
function shareFile()
{
    try {
        $client = new Client();
        $client->useApplicationDefaultCredentials();
        $client->addScope(Drive::DRIVE);
        $driveService = new Drive($client);
        $realFileId = readline("Enter File Id: ");
        $realUser = readline("Enter user email address: ");
        $realDomain = readline("Enter domain name: ");
        $ids = array();
            $fileId = '1sTWaJ_j7PkjzaBWtNc3IzovK5hQf21FbOw9yLeeLPNQ';
            $fileId = $realFileId;
            $driveService->getClient()->setUseBatch(true);
            try {
                $batch = $driveService->createBatch();

                $userPermission = new Drive\Permission(array(
                    'type' => 'user',
                    'role' => 'writer',
                    'emailAddress' => 'user@example.com'
                ));
                $userPermission['emailAddress'] = $realUser;
                $request = $driveService->permissions->create(
                    $fileId, $userPermission, array('fields' => 'id'));
                $batch->add($request, 'user');
                $domainPermission = new Drive\Permission(array(
                    'type' => 'domain',
                    'role' => 'reader',
                    'domain' => 'example.com'
                ));
                $userPermission['domain'] = $realDomain;
                $request = $driveService->permissions->create(
                    $fileId, $domainPermission, array('fields' => 'id'));
                $batch->add($request, 'domain');
                $results = $batch->execute();

                foreach ($results as $result) {
                    if ($result instanceof Google_Service_Exception) {
                        // Handle error
                        printf($result);
                    } else {
                        printf("Permission ID: %s\n", $result->id);
                        array_push($ids, $result->id);
                    }
                }
            } finally {
                $driveService->getClient()->setUseBatch(false);
            }
            return $ids;
    } catch(Exception $e) {
        echo "Error Message: ".$e;
    }

}

using Google.Apis.Auth.OAuth2;
using Google.Apis.Drive.v3;
using Google.Apis.Drive.v3.Data;
using Google.Apis.Requests;
using Google.Apis.Services;

namespace DriveV3Snippets
{
    // Class to demonstrate use-case of Drive modify permissions.
    public class ShareFile
    {
        /// <summary>
        /// Batch permission modification.
        /// </summary>
        /// <param name="realFileId">File id.</param>
        /// <param name="realUser">User id.</param>
        /// <param name="realDomain">Domain id.</param>
        /// <returns>list of modified permissions, null otherwise.</returns>
        public static IList<String> DriveShareFile(string realFileId, string realUser, string realDomain)
        {
            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 ids = new List<String>();
                var batch = new BatchRequest(service);
                BatchRequest.OnResponse<Permission> callback = delegate(
                    Permission permission,
                    RequestError error,
                    int index,
                    HttpResponseMessage message)
                {
                    if (error != null)
                    {
                        // Handle error
                        Console.WriteLine(error.Message);
                    }
                    else
                    {
                        Console.WriteLine("Permission ID: " + permission.Id);
                    }
                };
                Permission userPermission = new Permission()
                {
                    Type = "user",
                    Role = "writer",
                    EmailAddress = realUser
                };

                var request = service.Permissions.Create(userPermission, realFileId);
                request.Fields = "id";
                batch.Queue(request, callback);

                Permission domainPermission = new Permission()
                {
                    Type = "domain",
                    Role = "reader",
                    Domain = realDomain
                };
                request = service.Permissions.Create(domainPermission, realFileId);
                request.Fields = "id";
                batch.Queue(request, callback);
                var task = batch.ExecuteAsync();
                task.Wait();
                return ids;
            }
            catch (Exception e)
            {
                // TODO(developer) - handle error appropriately
                if (e is AggregateException)
                {
                    Console.WriteLine("Credential Not found");
                }
                else
                {
                    throw;
                }
            }
            return null;
        }
    }
}

Weitere Informationen

• Dateiinhalte schützen
• Über Ressourcenschlüssel auf per Link freigegebene Drive-Dateien zugreifen
• Rollen und Berechtigungen