Dateien, Ordner und Laufwerke freigeben

Jeder Google Drive-Datei, jedem Google Drive-Ordner und jeder geteilten Ablage sind permissions Ressourcen zugeordnet. Jede Ressource gibt die Berechtigung für einen bestimmten type (user, group, domain, anyone) und eine bestimmte role (owner, organizer, fileOrganizer, writer, commenter, reader) an. Für eine Datei kann beispielsweise eine Berechtigung vorhanden sein, die einem bestimmten Nutzer (type=user) schreibgeschützten Zugriff (role=reader) gewährt, während eine andere Berechtigung Mitgliedern einer bestimmten Gruppe (type=group) die Möglichkeit gibt, Kommentare zu einer Datei hinzuzufügen (role=commenter).

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

Funktionsweise von Berechtigungen

Berechtigungslisten für einen Ordner werden nach unten weitergegeben. Alle untergeordneten Dateien und Ordner übernehmen die Berechtigungen vom übergeordneten Element. Wenn Berechtigungen oder die Hierarchie geändert werden, erfolgt die Weitergabe rekursiv durch 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 der Nutzer der Datei durch den neuen Ordner eine neue Rolle erhält, z. B. „writer“, wird seine alte Rolle überschrieben.

Wenn eine Datei umgekehrt die role=writer von einem Ordner erbt und in einen anderen Ordner verschoben wird, der die Rolle „reader“ bietet, erbt die Datei jetzt role=reader.

Übernommene Berechtigungen können für kein Element entfernt oder eingeschränkt werden. Stattdessen müssen diese Berechtigungen im übergeordneten Element angepasst werden, aus dem sie stammen, oder in einem Ordner in der Hierarchie muss die Einstellung für eingeschränkten Zugriffaktiviert werden.

Übernommene Berechtigungen können für ein Element erweitert werden. Wenn eine Berechtigung für ein untergeordnetes Element erweitert wird, wirkt sich eine Änderung der Berechtigung eines übergeordneten Elements nicht auf die Berechtigung des untergeordneten Elements aus, es sei denn, die neue Berechtigung des übergeordneten Elements ist größer als die des untergeordneten Elements.

Gleichzeitige Berechtigungsvorgänge für dieselbe Datei werden nicht unterstützt. Nur die letzte Aktualisierung wird angewendet.

Dateifunktionen verstehen

Die permissions-Ressource bestimmt nicht letztendlich , ob der aktuelle Nutzer Aktionen für eine Datei oder einen Ordner ausführen kann. Stattdessen enthält die files-Ressource eine Sammlung boolescher capabilities -Felder, die angeben, ob eine Aktion für eine Datei oder einen Ordner ausgeführt werden kann. Die Google Drive API legt diese Felder basierend auf der permissions-Ressource des aktuellen Nutzers fest, die der Datei oder dem Ordner zugeordnet ist.

Wenn sich Alex beispielsweise in Ihrer App anmeldet und versucht, eine Datei freizugeben, wird die Rolle von Alex auf Berechtigungen für die Datei geprüft. Wenn die Rolle es zulässt, dass Alex eine Datei freigibt, werden die capabilities für die Datei, z. B. canShare, entsprechend der Rolle festgelegt. Wenn Alex die Datei freigeben möchte, prüft Ihre App die capabilities, um sicherzustellen, dass canShare auf true gesetzt ist.

Dateifunktionen abrufen

Wenn Ihre App eine Datei öffnet, sollten die Funktionen der Datei geprüft und die Benutzeroberfläche so gerendert werden, dass die Berechtigungen des aktuellen Nutzers berücksichtigt werden. Wenn der Nutzer beispielsweise nicht die Funktion canComment für die Datei hat, sollte die Möglichkeit, Kommentare hinzuzufügen, in der Benutzeroberfläche deaktiviert werden.

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

Das folgende Codebeispiel zeigt, wie Nutzerberechtigungen geprüft werden. Die Antwort gibt eine Liste der Funktionen zurück, die der Nutzer für die Datei hat. Jede Funktion entspricht einer detaillierten Aktion, die ein Nutzer ausführen kann. Einige Felder werden nur für Elemente in geteilten Ablagen ausgefüllt.

Anfrage

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

Antwort

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

Szenarien für die Freigabe von Drive-Ressourcen

Es gibt fünf verschiedene Arten von Freigabeszenarien:

  1. Wenn ein Nutzer eine Datei in „Meine Ablage“ freigeben möchte, muss er role=writer oder role=owner haben.

  2. Wenn ein Nutzer einen Ordner in „Meine Ablage“ freigeben möchte, muss er role=writer oder role=owner haben.

    • Wenn der boolesche Wert writersCanShare für die Datei auf false gesetzt ist, muss der Nutzer die Berechtigung role=owner haben, die mehr Berechtigungen bietet.

    • Temporärer Zugriff (geregelt durch ein Ablaufdatum und eine Ablaufzeit) ist nur für Ordner mit role=reader zulässig. Weitere Informationen finden Sie unter siehe Ablaufdatum festlegen, um den Zugriff auf Elemente zu beschränken.

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

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

  4. Wenn ein Nutzer einen Ordner in einer geteilten Ablage freigeben möchte, muss er role=organizer haben.

  5. Wenn ein Nutzer die Mitgliedschaft in einer geteilten Ablage verwalten möchte, muss er role=organizer haben. Nur Nutzer und Gruppen können Mitglieder von geteilten Ablagen sein.

Parameter „fields“ verwenden

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 permissions Ressource festlegen. Wenn Sie den Parameter fields weglassen, gibt der Server eine Standardgruppe von Feldern zurück, die für die Methode spezifisch sind. Die list Methode gibt beispielsweise nur die id, type, kind, und role Felder für jede Datei zurück. Informationen zum Zurückgeben anderer Felder finden Sie unter Bestimmte Felder zurückgeben.

Berechtigung erstellen

Beim Erstellen einer Berechtigung sind die folgenden beiden Felder erforderlich:

  • type: Der type gibt den Berechtigungsbereich an (user, group, domain, oder anyone). 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: Das Feld role gibt die Vorgänge an, die der type ausführen kann. Eine Berechtigung mit type=user und role=reader gewährt einem bestimmten Nutzer beispielsweise schreibgeschützten Zugriff auf die Datei oder den Ordner. Eine Berechtigung mit type=domain und role=commenter ermöglicht es allen Nutzern in der Domain, Kommentare zu einer Datei hinzuzufügen. Eine vollständige Liste der Rollen und der jeweils 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 erstellen, bei der type=domain, müssen Sie auch eine domain angeben, um eine bestimmte Domain mit der Berechtigung zu verknüpfen.

So erstellen Sie eine Berechtigung:

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

Das folgende Codebeispiel zeigt, wie eine Berechtigung erstellt wird. Die Antwort gibt eine Instanz einer permissions-Ressource zurück, einschließlich der zugewiesenen permissionId.

Anfrage

POST https://www.googleapis.com/drive/v3/files/FILE_ID/permissions
 
{
  "requests": [
    {
        "type": "user",
        "role": "commenter",
        "emailAddress": "alex@altostrat.com"
    }
  ]
}

Antwort

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

Zielgruppen verwenden

Zielgruppen sind Personengruppen, zum Beispiel Abteilungen oder Teams, die Sie Nutzerinnen und Nutzern zur Freigabe von Elementen empfehlen können. Sie können Nutzer ermutigen, Elemente nicht für die gesamte Organisation, sondern für einen eingeschränkten Personenkreis freizugeben. Zielgruppen können Ihnen helfen, die Sicherheit und den Datenschutz Ihrer Daten zu verbessern und Nutzern die Freigabe auf angemessene Weise zu erleichtern. Weitere Informationen finden Sie unter Zielgruppen.

So verwenden Sie Zielgruppen:

  1. Öffnen Sie in der Admin-Konsole das Dreistrich-Menü > Verzeichnis > Zielgruppen.

    Zielgruppen aufrufen

    Sie müssen mit einem Konto mit Superadministrator-Berechtigungen angemeldet sein, um diese Aufgabe auszuführen.

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

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

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

Informationen dazu, wie Nutzer mit Zielgruppen interagieren, finden Sie unter Nutzererfahrung bei der Link freigabe.

Berechtigung abrufen

Verwenden Sie die get Methode für die permissions Ressource mit den fileId und permissionId Pfadparametern, um eine Berechtigung abzurufen. Wenn Sie die Berechtigungs ID nicht kennen, können Sie alle Berechtigungen auflisten mit der list Methode.

Das folgende Codebeispiel zeigt, wie eine Berechtigung anhand der ID abgerufen wird. Die Antwort gibt eine Instanz einer permissions-Ressource zurück.

Anfrage

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

Antwort

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

Alle Berechtigungen auflisten

Verwenden Sie die list-Methode für die permissions-Ressource mit dem fileId-Pfadparameter, um Berechtigungen für eine Datei, einen Ordner oder eine geteilte Ablage aufzulisten.

Übergeben Sie die folgenden Abfrage parameter, um die Paginierung anzupassen oder Berechtigungen zu filtern:

  • pageSize: Die maximale Anzahl der Berechtigungen, die pro Seite zurückgegeben werden sollen. Wenn für Dateien in einer geteilten Ablage nicht festgelegt, werden maximal 100 Ergebnisse zurückgegeben. Wenn für Dateien, die sich nicht in einer geteilten Ablage befinden, nicht festgelegt, wird die gesamte Liste zurückgegeben.

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

  • supportsAllDrives: Gibt an, ob die anfragende App sowohl „Meine Ablage“ als auch geteilte Ablagen unterstützt.

  • useDomainAdminAccess: Legen Sie true fest, um die Anfrage als Domainadministrator auszugeben. Wenn der Parameter fileId auf eine geteilte Ablage verweist und der Anfragende ein Administrator der Domain ist, zu der die geteilte Ablage gehört. Weitere Informationen finden Sie unter Geteilte Ablagen als Domain administrator verwalten.

  • includePermissionsForView: Die Berechtigungen der zusätzlichen Ansicht, die in die Antwort aufgenommen werden sollen. Nur published wird unterstützt.

Das folgende Codebeispiel zeigt, wie alle Berechtigungen abgerufen werden. Die Antwort gibt eine Liste der Berechtigungen für eine Datei, einen Ordner oder eine geteilte Ablage zurück.

Anfrage

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

Antwort

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

Berechtigungen aktualisieren

Wenn Sie Berechtigungen für eine Datei oder einen Ordner aktualisieren möchten, können Sie die zugewiesene Rolle ändern. Weitere Informationen zum Ermitteln der Rollenquelle finden Sie unter Rollenquelle bestimmen.

  1. Rufen Sie die update Methode für die permissions Ressource auf. Setzen Sie den fileId Pfadparameter auf die zugehörige Datei, den zugehörigen Ordner oder die zugehörige geteilte Ablage und den permissionId Pfadparameter auf die zu ändernde Berechtigung. Verwenden Sie die list Methode für die permissions Ressource mit dem fileId Pfadparameter, um die permissionId zu finden.

  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 Teil seiner Mitgliedschaft in einer geteilten Ablage. Ihre App kann Alex jedoch role=writer für eine Datei in einer geteilten Ablage gewähren. Da die neue Rolle mehr Berechtigungen bietet als die Rolle, die durch die Mitgliedschaft gewährt wird, wird die neue Berechtigung zur effektiven Rolle für die Datei oder den Ordner.

Sie können Aktualisierungen mit Patch-Semantik anwenden. Das bedeutet, dass Sie teilweise Änderungen an einer Ressource vornehmen können. Sie müssen die Felder, die Sie ändern möchten, explizit in Ihrer Anfrage festlegen. Alle Felder, die nicht in der Anfrage enthalten sind, behalten ihre vorhandenen Werte bei. Weitere Informationen finden Sie unter Mit Teilressourcen arbeiten.

Das folgende Codebeispiel zeigt, wie Berechtigungen für eine Datei oder einen Ordner von commenter in writer geändert werden. Die Antwort gibt eine Instanz einer permissions-Ressource zurück.

Anfrage

PATCH https://www.googleapis.com/drive/v3/files/FILE_ID/permissions/PERMISSION_ID
 
{
  "role": "writer"
}

Antwort

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

Rollenquelle bestimmen

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.

Rufen Sie die Methode get für die permissions-Ressource mit den Pfadparametern fileId und permissionId und dem Parameter fields auf, der auf das Feld permissionDetails gesetzt ist, um die Rollenquelle für eine geteilte Ablage oder Elemente in dieser Ablage zu bestimmen.

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

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

Das folgende Codebeispiel zeigt, wie die Rollenquelle bestimmt wird. Die Antwort gibt die permissionDetails einer permissions-Ressource zurück. Das Feld inheritedFrom enthält die ID des Elements, von dem die Berechtigung übernommen wurde.

Anfrage

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

Antwort

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

Mehrere Berechtigungen mit Batchanfragen aktualisieren

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

Im Folgenden sehen Sie ein Beispiel für die Durchführung einer Batch-Berechtigungsänderung mit einer Clientbibliothek.

Java

drive/snippets/drive_v3/src/main/java/ShareFile.java
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;
    }
  }
}

Python

drive/snippets/drive-v3/file_snippet/share_file.py
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",
  )

Node.js

drive/snippets/drive_v3/file_snippets/share_file.js
import {GoogleAuth} from 'google-auth-library';
import {google} from 'googleapis';

/**
 * Shares a file with a user and a domain.
 * @param {string} fileId The ID of the file to share.
 * @param {string} targetUserEmail The email address of the user to share with.
 * @param {string} targetDomainName The domain to share with.
 * @return {Promise<Array<string>>} A promise that resolves to an array of permission IDs.
 */
async function shareFile(fileId, targetUserEmail, targetDomainName) {
  // 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});

  /** @type {Array<string>} */
  const permissionIds = [];

  // The permissions to create.
  const permissions = [
    {
      type: 'user',
      role: 'writer',
      emailAddress: targetUserEmail, // e.g., 'user@partner.com'
    },
    {
      type: 'domain',
      role: 'writer',
      domain: targetDomainName, // e.g., 'example.com'
    },
  ];

  // Iterate through the permissions and create them one by one.
  for (const permission of permissions) {
    const result = await service.permissions.create({
      requestBody: permission,
      fileId,
      fields: 'id',
    });

    if (result.data.id) {
      permissionIds.push(result.data.id);
      console.log(`Inserted permission id: ${result.data.id}`);
    } else {
      throw new Error('Failed to create permission');
    }
  }
  return permissionIds;
}

PHP

drive/snippets/drive_v3/src/DriveShareFile.php
<?php
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;
    }

}

.NET

drive/snippets/drive_v3/DriveV3Snippets/ShareFile.cs
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;
        }
    }
}

Berechtigung löschen

Rufen Sie die delete Methode für die permissions Ressource auf und setzen Sie die fileId und die permissionId Pfadparameter, um den Zugriff auf eine Datei oder einen Ordner zu widerrufen.

Übernommene Berechtigungen können nicht widerrufen werden. Aktualisieren oder löschen Sie stattdessen die Berechtigung für den übergeordneten Ordner. Wenn Sie eine Berechtigung für einen Ordner löschen, wird auch der entsprechende Zugriff auf untergeordnete Elemente widerrufen.

Wenn Sie Berechtigungen im Vergleich zu einem übergeordneten Element einschränken möchten, müssen Sie die Einstellung für eingeschränkten Zugriff verwenden.

Das folgende Codebeispiel zeigt, wie der Zugriff widerrufen wird, indem eine permissionId gelöscht wird. Wenn der Vorgang erfolgreich abgeschlossen wurde, ist der Antworttext ein leeres JSON-Objekt. Verwenden Sie die list-Methode für die permissions-Ressource mit dem fileId-Pfadparameter, um zu bestätigen, dass die Berechtigung entfernt wurde.

Anfrage

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

Ablaufdatum festlegen, um den Zugriff auf Elemente zu beschränken

Wenn Sie mit anderen an einem vertraulichen Projekt arbeiten, möchten Sie möglicherweise den Zugriff auf bestimmte Elemente in Google Drive nach einer bestimmten Zeit einschränken. Für Dateien und Ordner können Sie ein Ablaufdatum festlegen, um den Zugriff auf dieses Element einzuschränken oder zu entfernen.

So legen Sie das Ablaufdatum fest:

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

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

Das expirationTime Feld gibt an, wann die Berechtigung abläuft, und verwendet das RFC 3339 -Format für Datum und Uhrzeit. Für Ablaufzeiten gelten die folgenden Einschränkungen:

  • Sie können nur für Nutzer- und Gruppenberechtigungen festgelegt werden.
  • Die Zeit muss in der Zukunft liegen.
  • Die Zeit darf nicht mehr als ein Jahr in der Zukunft liegen.
  • Nur die Rolle reader kann für den ablaufenden Zugriff auf einen Ordner verwendet werden.

Weitere Informationen zum Ablaufdatum finden Sie in den folgenden Artikeln: