Udostępnianie plików, folderów i dysków

Każdy plik, folder i dysk współdzielony na Dysku Google ma powiązane zasoby permissions. Każdy zasób określa uprawnienia dla konkretnego type (user, group, domain, anyone) i role (owner, organizer, fileOrganizer, writer, commenter, reader). Na przykład plik może mieć uprawnienia przyznające konkretnemu użytkownikowi (type=user) dostęp tylko do odczytu (role=reader), a inne uprawnienia mogą przyznawać członkom konkretnej grupy (type=group) możliwość dodawania komentarzy do pliku (role=commenter).

Pełną listę ról i operacji, które umożliwiają, znajdziesz w artykule Role i uprawnienia.

Jak działają uprawnienia

Listy uprawnień do folderu są propagowane w dół. Wszystkie pliki i foldery podrzędne dziedziczą uprawnienia z folderu nadrzędnego. Gdy uprawnienia lub hierarchia zostaną zmienione, propagacja następuje rekurencyjnie we wszystkich zagnieżdżonych folderach. Jeśli na przykład plik znajduje się w folderze, a ten folder zostanie przeniesiony do innego folderu, uprawnienia nowego folderu zostaną przeniesione na plik. Jeśli nowy folder przyznaje użytkownikowi pliku nową rolę, np. „edytujący”, zastępuje ona starą rolę.

Jeśli plik dziedziczy role=writer z folderu i zostanie przeniesiony do innego folderu, który zapewnia rolę „czytelnik”, plik dziedziczy teraz role=reader.

Nie można usunąć odziedziczonych uprawnień dotyczących pliku lub folderu na dysku współdzielonym. Zamiast tego uprawnienia należy dostosować w bezpośrednim lub pośrednim elemencie nadrzędnym, z którego zostały odziedziczone. Uprawnienia dziedziczone można usuwać z elementów w sekcji „Mój dysk” lub „Udostępnione dla mnie”.

Z kolei uprawnienia odziedziczone można zastąpić w przypadku pliku lub folderu na Moim dysku. Jeśli więc plik dziedziczy role=writer z folderu Mój dysk, możesz ustawić role=reader w pliku, aby obniżyć poziom uprawnień.

Możliwości plików

Zasób permissions nie określa ostatecznie możliwości wykonywania przez bieżącego użytkownika działań na pliku lub folderze. Zamiast tego zasób files zawiera zbiór pól logicznych capabilities, które wskazują, czy można wykonać działanie na pliku lub folderze. Interfejs Google Drive API ustawia te pola na podstawie zasobu uprawnień bieżącego użytkownika powiązanego z plikiem lub folderem.

Jeśli na przykład Aleks zaloguje się w Twojej aplikacji i spróbuje udostępnić plik, sprawdzimy, czy ma do niego uprawnienia. Jeśli rola umożliwia udostępnianie pliku, pola capabilities związane z plikiem, np. canShare, są wypełniane w zależności od roli. Jeśli Alex chce udostępnić plik, Twoja aplikacja sprawdza capabilities, aby upewnić się, że canShare ma wartość true.

Przykład pobierania pliku capabilities znajdziesz w artykule Pobieranie możliwości pliku.

Pobieranie możliwości pliku

Gdy aplikacja otworzy plik, powinna sprawdzić jego możliwości i wyświetlić interfejs odzwierciedlający uprawnienia bieżącego użytkownika. Jeśli na przykład użytkownik nie ma canComment uprawnień do pliku, możliwość komentowania powinna być wyłączona w interfejsie.

Aby sprawdzić możliwości, wywołaj metodę get() w zasobie files z parametrem ścieżki fileId i parametrem fields ustawionym na pole capabilities. Więcej informacji o zwracaniu pól za pomocą parametru fields znajdziesz w artykule Zwracanie określonych pól.

Poniższy przykładowy kod pokazuje, jak sprawdzić uprawnienia użytkownika. Odpowiedź zawiera listę uprawnień użytkownika do pliku. Każda funkcja odpowiada szczegółowemu działaniu, które może wykonać użytkownik. Niektóre pola są wypełniane tylko w przypadku elementów na dyskach współdzielonych.

Wyślij prośbę

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

Odpowiedź

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

Scenariusze udostępniania zasobów Dysku

Istnieje 5 różnych scenariuszy udostępniania:

  1. Aby udostępnić plik na Moim dysku, użytkownik musi mieć uprawnienia role=writer lub role=owner.

    • Jeśli wartość logiczna writersCanShare jest ustawiona na false, użytkownik musi mieć role=owner.

    • Jeśli użytkownik z uprawnieniami role=writer ma tymczasowy dostęp określony przez datę i godzinę wygaśnięcia, nie może udostępnić pliku. Więcej informacji znajdziesz w artykule Ustawianie daty wygaśnięcia dostępu do pliku.

  2. Aby udostępnić folder na Moim dysku, użytkownik musi mieć uprawnienia role=writer lub role=owner.

    • Jeśli wartość logiczna writersCanShare jest ustawiona na false w przypadku pliku, użytkownik musi mieć większe uprawnienia role=owner.

    • Tymczasowy dostęp (z datą i godziną wygaśnięcia) nie jest dozwolony w przypadku folderów na Moim dysku z role=writer. Więcej informacji znajdziesz w artykule Ustawianie daty wygaśnięcia, aby ograniczyć dostęp do pliku.

  3. Aby udostępnić plik na dysku współdzielonym, użytkownik musi mieć uprawnienia role=writer, role=fileOrganizer lub role=organizer.

    • Ustawienie writersCanShare nie dotyczy elementów na dyskach współdzielonych. Jest traktowana tak, jakby zawsze miała wartość true.

  4. Aby udostępnić folder na dysku współdzielonym, użytkownik musi mieć uprawnienia role=organizer.

    • Jeśli sharingFoldersRequiresOrganizerPermission ograniczenie na dysku współdzielonym jest ustawione na false, użytkownicy z uprawnieniami role=fileOrganizer mogą udostępniać foldery na tym dysku współdzielonym.

  5. Aby zarządzać użytkownikami dysku współdzielonego, użytkownik musi mieć uprawnienia role=organizer. Tylko użytkownicy i grupy mogą być członkami dysków współdzielonych.

Tworzenie uprawnień

Podczas tworzenia uprawnień wymagane są te 2 pola:

  • type: znak type określa zakres uprawnień (user, group, domain lub anyone). Uprawnienie ze znakiem type=user dotyczy konkretnego użytkownika, a uprawnienie ze znakiem type=domain dotyczy wszystkich użytkowników w danej domenie.

  • role: pole role określa operacje, które może wykonać type. Na przykład uprawnienie z wartościami type=user i role=reader przyznaje konkretnemu użytkownikowi dostęp tylko do odczytu do pliku lub folderu. Uprawnienia z ikonami type=domain i role=commenter umożliwiają wszystkim osobom w domenie dodawanie komentarzy do pliku. Pełną listę ról i operacji, które są dozwolone w przypadku każdej z nich, znajdziesz w artykule Role i uprawnienia.

Gdy tworzysz uprawnienie, w którym występuje type=user lub type=group, musisz też podać emailAddress, aby powiązać konkretnego użytkownika lub grupę z tym uprawnieniem.

Gdy tworzysz uprawnienie, w którym type=domain, musisz też podać domain, aby powiązać konkretną domenę z uprawnieniem.

Aby utworzyć uprawnienie:

  1. Użyj metody create() z parametrem ścieżki fileId powiązanego pliku lub folderu.
  2. W treści żądania określ type i role.
  3. Jeśli wartość to type=user lub type=group, podaj emailAddress. Jeśli type=domain, podaj domain.

Poniższy przykładowy kod pokazuje, jak utworzyć uprawnienie. Odpowiedź zwraca instancję zasobu Permission, w tym przypisany element permissionId.

Wyślij prośbę

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

Odpowiedź

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

Korzystanie z grup odbiorców

Grupy odbiorców to obejmujące zbiory osób (na przykład działy lub zespoły) grupy, które możesz polecać użytkownikom, tak by ci udostępniali im swoje elementy. Możesz zachęcić użytkowników do udostępniania elementów konkretnym odbiorcom lub ograniczonej ich grupie, a nie całej organizacji. Grupy odbiorców mogą pomóc Ci zwiększyć bezpieczeństwo i prywatność danych oraz ułatwić użytkownikom odpowiednie udostępnianie. Więcej informacji znajdziesz w artykule Informacje o odbiorcach docelowych.

Aby korzystać z grup odbiorców:

  1. W konsoli administracyjnej Google otwórz Menu > Katalog > Grupy odbiorców.

    Otwórz Grupy odbiorców

    Aby wykonać te czynności, musisz zalogować się na konto z uprawnieniami superadministratora.

  2. Na liście grup odbiorców kliknij nazwę grupy odbiorców. Aby utworzyć grupę odbiorców, przeczytaj artykuł Tworzenie grupy odbiorców.

  3. Skopiuj unikalny identyfikator z adresu URL odbiorców docelowych: https://admin.google.com/ac/targetaudiences/ID.

  4. Utwórz uprawnienie z type=domain i ustaw pole domain na ID.audience.googledomains.com.

Aby dowiedzieć się, jak użytkownicy wchodzą w interakcje z odbiorcami docelowymi, przeczytaj artykuł Wpływ ustawień na interfejs udostępniania linku przez użytkownika.

Wyświetlanie listy wszystkich uprawnień

Użyj metody list() w zasobie permissions, aby pobrać wszystkie uprawnienia do pliku, folderu lub dysku współdzielonego.

Poniższy przykładowy kod pokazuje, jak uzyskać wszystkie uprawnienia. Odpowiedź zawiera listę uprawnień.

Wyślij prośbę

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

Odpowiedź

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

Zmień uprawnienia

Aby zaktualizować uprawnienia do pliku lub folderu, możesz zmienić przypisaną rolę. Więcej informacji o znajdowaniu źródła roli znajdziesz w artykule Określanie źródła roli.

  1. Wywołaj metodę update() w zasobie permissions z parametrem ścieżki permissionId ustawionym na uprawnienie do zmiany i parametrem ścieżki fileId ustawionym na powiązany plik, folder lub dysk współdzielony. Aby znaleźć permissionId, użyj metody list() w zasobie permissions z parametrem ścieżki fileId.

  2. W prośbie podaj nowy role.

Możesz przyznać uprawnienia do poszczególnych plików lub folderów na dysku współdzielonym, nawet jeśli użytkownik lub grupa jest już członkiem. Na przykład Alex ma role=commenter w ramach członkostwa na dysku współdzielonym. Aplikacja może jednak przyznać Alexowirole=writer dostęp do pliku na dysku współdzielonym. W tym przypadku, ponieważ nowa rola jest bardziej restrykcyjna niż rola przyznana w ramach subskrypcji, nowe uprawnienia stają się efektywną rolą dla pliku lub folderu.

Poniższy przykładowy kod pokazuje, jak zmienić uprawnienia do pliku lub folderu z komentującego na edytującego. Odpowiedź zwraca instancję zasobu permissions.

Wyślij prośbę

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

Odpowiedź

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

Określanie źródła roli

Aby zmienić rolę w przypadku pliku lub folderu, musisz znać źródło tej roli. W przypadku dysków współdzielonych źródłem roli może być członkostwo na dysku współdzielonym, rola w folderze lub rola w pliku.

Aby określić źródło roli na dysku współdzielonym lub w elementach na tym dysku, wywołaj metodę get() w zasobie permissions z parametrami ścieżki fileId i permissionId oraz parametrem fields ustawionym na pole permissionDetails.

Aby znaleźć permissionId, użyj metody list() w zasobie permissions z parametrem ścieżki fileId. Aby pobrać pole permissionDetails w żądaniu list, ustaw parametr fields na permissions/permissionDetails.

To pole zawiera wszystkie dziedziczone i bezpośrednie uprawnienia do plików użytkownika, grupy lub domeny.

Poniższy przykładowy kod pokazuje, jak określić źródło roli. Odpowiedź zwraca permissionDetails zasobu permissions. Pole inheritedFrom zawiera identyfikator elementu, z którego dziedziczone jest uprawnienie.

Wyślij prośbę

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

Odpowiedź

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

Aktualizowanie wielu uprawnień za pomocą żądań zbiorczych

Zdecydowanie zalecamy używanie żądań zbiorczych do modyfikowania wielu uprawnień.

Poniżej znajdziesz przykład zbiorczej modyfikacji uprawnień za pomocą biblioteki klienta.

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

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

Usuwanie uprawnień

Aby cofnąć dostęp do pliku lub folderu, wywołaj metodę delete() w zasobie permissions z parametrami ścieżki fileId i permissionId ustawionymi na usunięcie uprawnień.

W przypadku elementów na „Moim dysku” można usunąć odziedziczone uprawnienia. Usunięcie odziedziczonych uprawnień powoduje cofnięcie dostępu do elementu i jego elementów podrzędnych (jeśli takie istnieją).

W przypadku elementów na dysku współdzielonym nie można cofnąć odziedziczonych uprawnień. Zamiast tego zaktualizuj lub usuń uprawnienia dotyczące pliku lub folderu nadrzędnego.

Metoda delete() służy też do usuwania uprawnień zastosowanych bezpośrednio do pliku lub folderu na dysku współdzielonym.

Poniższy przykładowy kod pokazuje, jak cofnąć dostęp przez usunięcie permissionId. Jeśli operacja się uda, treść odpowiedzi będzie pusta. Aby potwierdzić usunięcie uprawnienia, użyj metody list() w zasobie permissions z parametrem ścieżki fileId.

Wyślij prośbę

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

Ustawianie daty wygaśnięcia, aby ograniczyć dostęp do pliku

Jeśli współpracujesz z osobami nad projektem, który zawiera dane poufne, możesz ograniczyć ich dostęp do wybranych plików na Dysku po upływie określonego czasu. W przypadku plików na Moim dysku możesz ustawić datę ważności, aby ograniczyć lub usunąć dostęp do pliku.

Aby ustawić datę ważności:

Pole expirationTime określa datę wygaśnięcia uprawnień w formacie RFC 3339 date-time. Czasy wygaśnięcia podlegają tym ograniczeniom:

  • Można je ustawić tylko w przypadku uprawnień użytkowników i grup.
  • Czas musi przypadać w przyszłości.
  • Czas nie może być oddalony o więcej niż rok do przodu.

Więcej informacji o dacie ważności znajdziesz w tych artykułach: