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 eine bestimmte type (user, group, domain, anyone) und role (owner, organizer, fileOrganizer, writer, commenter, reader) an. Eine Datei kann 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 jeweils zulässigen Vorgänge finden Sie unter Rollen und Berechtigungen.

So werden Berechtigungen übertragen

Berechtigungen werden von übergeordneten Ordnern an alle untergeordneten Elemente weitergegeben:

  • Standardmäßig übernommen: Alle untergeordneten Dateien und Ordner übernehmen automatisch Berechtigungen von ihrem übergeordneten Ordner.
  • Kann bei untergeordneten Elementen nicht reduziert werden: Sie können eine übernommene Berechtigung für ein untergeordnetes Element nicht entfernen oder reduzieren. Änderungen müssen am ursprünglichen übergeordneten Ordner vorgenommen werden oder der Ordner muss die Einstellung für eingeschränkten Zugriff verwenden.
  • Kann auf untergeordnete Elemente ausgeweitet werden: Für ein untergeordnetes Element kann eine weiter gefasste Rolle gewährt werden, z. B. role=writer für eine Datei in einem Ordner, in dem der Nutzer role=reader hat.
  • Bei Verschieben neu bewertet: Wenn ein Element in einen neuen übergeordneten Ordner verschoben wird, werden die Berechtigungen des neuen übergeordneten Ordners für das Element und seine untergeordneten Elemente neu bewertet und angewendet.

Dateilinks und Zugriffssteuerung

Wenn Sie eine Datei oder einen Ordner für einen bestimmten Nutzer oder eine bestimmte Gruppe freigeben, ändert sich die URL für den Zugriff auf das Element nicht und es wird nicht für jeden Nutzer ein eindeutiger Link generiert. Stattdessen hat das Element einen einzelnen, konstanten Link, der auf seiner fileId basiert.

Drive steuert den Zugriff, indem die ACL des Elements ausgewertet wird. Wenn ein Nutzer versucht, einen Link zu öffnen, wird seine authentifizierte Identität anhand der ACL überprüft. Wenn eine Berechtigung widerrufen wird oder ihr Ablaufdatum erreicht, wird der Nutzer aus der ACL entfernt. Wenn der Nutzer versucht, den Link noch einmal aufzurufen, wird der Zugriff in Drive verweigert.

Dateifunktionen

Die Ressource permissions definiert wer Zugriff hat (die ACL), gibt aber nicht direkt an, ob der aktuelle Nutzer eine bestimmte Aktion in der Benutzeroberfläche Ihrer Anwendung ausführen kann.

Stattdessen enthält die Ressource files eine Sammlung von booleschen capabilities-Feldern (z. B. canComment, canShare oder canDelete), die von der Google Drive API dynamisch auf Grundlage der Rolle des Nutzers und der Einstellungen des Elements berechnet werden.

Dateifunktionen abrufen

Prüfen Sie beim Rendern der Benutzeroberfläche Ihrer App files.capabilities, anstatt Berechtigungen direkt zu parsen:

  • Rufen Sie die Methode files.get mit fields=capabilities auf. Weitere Informationen finden Sie unter Bestimmte Felder zurückgeben.
  • Mit den zurückgegebenen booleschen Flags können Sie entsprechende Aktionen in Ihrer Benutzeroberfläche aktivieren oder deaktivieren. Deaktivieren Sie beispielsweise Kommentare, wenn canComment false ist.

Szenarien für die Freigabe von Drive-Ressourcen

In der folgenden Tabelle sind die erforderlichen Rollen und Bedingungen für die Freigabe von Drive-Ressourcen für verschiedene Standorte und Elementtypen aufgeführt:

Standort Element Erforderliche Rollen Schlüsseleinschränkungen
Meine Ablage Datei oder Ordner owner oder writer Erfordert owner, wenn writersCanShare=false.
Für den Ablauf des Zugriffs auf Ordner ist reader erforderlich (siehe Ablaufdatum festlegen).
Geteilte Ablage Datei organizer, fileOrganizer oder writer writersCanShare wird immer als true behandelt.
Geteilte Ablage Ordner organizer fileOrganizer kann auch Inhalte teilen, wenn sharingFoldersRequiresOrganizerPermission gleich false ist.
Geteilte Ablage Mitgliedschaft organizer Gilt nur für user oder group (nicht für Domains).

Berechtigungen verwalten

In der folgenden Tabelle sind die für die permissions-Ressource verfügbaren Methoden zusammengefasst:

Methode API-Endpunkt Wichtige Parameter Referenz
Erstellen POST https://www.googleapis.com/drive/v3/files/{fileId}/permissions role, type, emailAddress oder domain permissions.create
Abrufen GET https://www.googleapis.com/drive/v3/files/{fileId}/permissions/{permissionId} fields permissions.get
Liste GET https://www.googleapis.com/drive/v3/files/{fileId}/permissions pageSize, supportsAllDrives, pageToken permissions.list
Aktualisieren PATCH https://www.googleapis.com/drive/v3/files/{fileId}/permissions/{permissionId} role, allowFileDiscovery permissions.update
Löschen DELETE https://www.googleapis.com/drive/v3/files/{fileId}/permissions/{permissionId} supportsAllDrives permissions.delete

Berechtigung erstellen

Wenn Sie eine Datei, einen Ordner oder eine geteilte Ablage freigeben möchten, rufen Sie die Methode create für die Ressource permissions mit dem fileId auf. Beim Erstellen einer Berechtigung wird dem Element ein neuer ACL-Eintrag hinzugefügt und eine zugewiesene permissionId zurückgegeben.

Geben Sie im Anfragetext die folgenden Felder an:

  • role: Die zu gewährende Zugriffsebene (z. B. reader, commenter oder writer). Eine vollständige Liste finden Sie unter Rollen und Berechtigungen.
  • type: Der Bereich des Empfängers (user, group, domain oder anyone).
  • Kennung des Zuwendungsempfängers (erforderlich basierend auf type):
    • emailAddress: Erforderlich, wenn type gleich user oder group ist.
    • domain: Erforderlich, wenn type domain ist.

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

Ersuchen

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

Antwort

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

Inhalte für Zielgruppen freigeben

Zielgruppen sind Personengruppen, z. B. Abteilungen oder Teams, die Sie Nutzern zur Freigabe von Elementen empfehlen können. Sie können Nutzer dazu anhalten, 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 das angemessene Teilen zu erleichtern.

Wenn Sie die Datei für eine Zielgruppe freigeben möchten, legen Sie type=domain fest und setzen Sie domain auf <TARGET_AUDIENCE_ID>.audience.googledomains.com. Weitere Informationen zum Suchen oder Erstellen von Zielgruppen in der Google Admin-Konsole finden Sie unter Zielgruppen.

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

Berechtigung erhalten

Rufen Sie die Methode get für die Ressource permissions mit den Pfadparametern fileId und permissionId auf, um eine Berechtigung zu erhalten. Wenn Sie die Berechtigungs-ID nicht kennen, listen Sie zuerst alle Berechtigungen auf.

Berechtigungen auflisten

Wenn Sie Berechtigungen für eine Datei, einen Ordner oder eine geteilte Ablage auflisten möchten, rufen Sie die Methode list für die Ressource permissions mit dem erforderlichen Pfad-Parameter fileId auf.

Sie können einen der folgenden optionalen Abfrageparameter verwenden, um die Antwort zu paginieren oder zu filtern:

  • pageSize (optional): 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, kein Wert festgelegt ist, wird die gesamte Liste zurückgegeben.

  • pageToken (optional): Ein Seitentoken aus einem vorherigen Listenaufruf zum Abrufen der nächsten Seite.

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

  • useDomainAdminAccess (optional): Auf true festlegen, um die Anfrage als Domainadministrator zu stellen. Der Anfragende erhält Zugriff, wenn der fileId-Parameter auf eine geteilte Ablage verweist und der Anfragende Administrator der Domain ist, zu der die geteilte Ablage gehört. Weitere Informationen finden Sie unter Geteilte Ablagen als Domainadministrator verwalten.

  • includePermissionsForView (optional): Zusätzliche Berechtigungen für die Ansicht, die in die Antwort aufgenommen werden sollen. Nur published wird unterstützt.

  • fields (optional): Bestimmte Felder, die in der Antwort zurückgegeben werden sollen. Standardmäßig gibt list nur id, type, kind und role zurück. Wenn Sie zusätzliche Felder (z. B. permissionDetails) zurückgeben möchten, geben Sie sie mit diesem Parameter an. Weitere Informationen finden Sie unter Bestimmte Felder zurückgeben.

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.

Wenn Sie die Rollenquelle für ein gemeinsames 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 sowie dem Parameter fields auf, der auf das Feld permissionDetails festgelegt ist.

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

In diesem Feld werden alle geerbten und direkten Dateiberechtigungen für den Nutzer, die Gruppe oder die Domain aufgeführt.

Das folgende Codebeispiel zeigt, wie die Rollenquelle ermittelt 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 wird.

Ersuchen

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

Berechtigung aktualisieren

Wenn Sie die 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 ermitteln.

  1. Rufen Sie die Methode update für die Ressource permissions auf. Legen Sie den Pfad-Parameter fileId auf die zugehörige Datei, den Ordner oder die geteilte Ablage und den Pfad-Parameter permissionId auf die zu ändernde Berechtigung fest. Verwenden Sie die Methode list für die Ressource permissions mit dem Pfad-Parameter fileId, um das 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. Beispiel: Alex hat role=commenter als Teil seiner Mitgliedschaft in einer geteilten Ablage. Ihre App kann jedoch Alex 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 durch die Mitgliedschaft gewährt wird, wird die neue Berechtigung zur effektiven Rolle für die Datei oder den Ordner.

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

Neben dem Ändern von Rollen können Sie auch die Auffindbarkeit eines Elements ändern, wenn die Berechtigung type domain oder anyone ist. Wenn Sie eine freigegebene Datei durchsuchbar oder nicht aufgeführt machen möchten, fügen Sie das boolesche Feld allowFileDiscovery in Ihre Patch-Anfrage ein. Wenn Sie diese Option auf true festlegen, kann das Element in den Suchergebnissen für die angegebene Zielgruppe angezeigt werden, auch wenn sie nicht den direkten Link erhalten hat. Sie müssen die Berechtigung nicht löschen und neu erstellen, um diese Einstellung zu ändern.

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

Ersuchen

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

Mehrere Berechtigungen mit Batchanfragen aktualisieren

Gleichzeitige Änderungen der Berechtigungen für dieselbe Datei, denselben Ordner oder dieselbe geteilte Ablage werden nicht unterstützt. Diese Einschränkung gilt für alle Mutierungsoperationen (z. B. „update“ oder „delete“), unabhängig davon, ob Sie Berechtigungen für denselben oder verschiedene Empfänger ändern und ob Anfragen von einer einzelnen App oder mehreren Nutzern stammen.

In Drive werden die Berechtigungen eines Elements als einzelne ACL ausgewertet und aktualisiert. Gleichzeitige Vorgänge verursachen Race Conditions, bei denen „last write wins“ (letzter Schreibvorgang gewinnt). Dadurch können Berechtigungsänderungen unbemerkt überschrieben oder sharingRateLimitExceeded-Fehler ausgelöst werden.

Um Konflikte zu vermeiden, sollten Sie Berechtigungsänderungen für dasselbe Element sequenziell ausführen oder Batchanfragen verwenden, um mehrere Berechtigungen in einer einzigen Anfrage zu ändern.

Im Folgenden finden 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 Methode delete für die Ressource permissions mit den Pfadparametern fileId und permissionId auf, um den Zugriff auf eine Datei oder einen Ordner zu widerrufen.

Übernommene Berechtigungen können nicht direkt für untergeordnete Elemente widerrufen werden. Aktualisieren oder löschen Sie stattdessen die Berechtigung für den übergeordneten Ordner oder verwenden Sie die Einstellung für eingeschränkten Zugriff.

Wenn Sie den Zugriff eines Nutzers auf ein übergeordnetes Element entfernen, werden nur die Berechtigungen widerrufen, die von diesem übergeordneten Element übernommen wurden. Wenn dem Nutzer auch direkte Berechtigungen für ein untergeordnetes Element gewährt wurden, bleibt dieser direkte Zugriff bestehen. Rufen Sie list mit dem fileId auf, um zu bestätigen, dass eine Berechtigung entfernt wurde.

Ablaufdatum festlegen

Wenn Sie temporären Zugriff auf eine Datei oder einen Ordner gewähren möchten, legen Sie das Feld expirationTime (RFC 3339-Datum/Uhrzeit) beim Aufrufen der Methoden create oder update fest.

Für Ablaufzeiten gelten die folgenden Einschränkungen:

  • Kann nur für die Berechtigungen user und group festgelegt werden, nicht für domain oder anyone.
  • Der Zeitpunkt muss in der Zukunft liegen, maximal ein Jahr.
  • Für Ordner wird der temporäre Zugriff nur mit der Rolle reader unterstützt.