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

Każdy plik, folder i dysk współdzielony na Dysku Google ma powiązane z nim 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 każda z nich umożliwia, 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 jego 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ń z 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 odziedziczone uprawnienia 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ń.

Jednoczesne operacje dotyczące uprawnień do tego samego pliku nie są obsługiwane. Stosowana jest tylko ostatnia aktualizacja.

Możliwości plików

Zasób permissions nie określa ostatecznie możliwości bieżącego użytkownika do wykonywania 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 permissionszasobu powiązanego z plikiem lub folderem bieżącego użytkownika.

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, capabilities związane z plikiem, np. canShare, są ustawiane względem roli. Jeśli Alex chce udostępnić plik, Twoja aplikacja sprawdza, czy capabilities jest ustawione na true.canShare

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 uprawnień canComment 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 weryfikować 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.

Żądanie

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 (określony przez 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 ograniczenie na dysku współdzielonym sharingFoldersRequiresOrganizerPermission 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.

Używanie parametru fields

Jeśli chcesz określić pola, które mają być zwracane w odpowiedzi, możesz ustawić fields parametr systemfields w dowolnej metodzie zasobu permissions. Jeśli pominiesz parametr fields, serwer zwróci domyślny zestaw pól specyficznych dla danej metody. Na przykład metoda list zwraca tylko pola id, type, kind i role dla każdego pliku. Aby zwrócić inne pola, zobacz Zwracanie określonych pól.

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 – 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 do pliku lub folderu tylko do odczytu. Uprawnienia z ikonami type=domain i role=commenter umożliwiają wszystkim użytkownikom domeny dodawanie komentarzy do pliku. Pełną listę ról i operacji, które są dozwolone w przypadku każdej z nich, znajdziesz w sekcji 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 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 w przypadku zasobu permissions 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 permissions, w tym przypisany element permissionId.

Żądanie

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 list 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.

Uzyskiwanie uprawnień

Aby uzyskać uprawnienie, użyj metody get w zasobie permissions z parametrami ścieżki fileId i permissionId. Jeśli nie znasz identyfikatora uprawnienia, możesz wyświetlić listę wszystkich uprawnień za pomocą metody list.

Poniższy przykładowy kod pokazuje, jak uzyskać uprawnienia według identyfikatora. Odpowiedź zwraca instancję zasobu permissions.

Żądanie

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

Odpowiedź

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

Wyświetlanie listy wszystkich uprawnień

Aby wyświetlić listę uprawnień do pliku, folderu lub dysku współdzielonego, użyj metody list w zasobie permissions z parametrem ścieżki fileId.

Przekaż te parametry zapytania, aby dostosować stronicowanie uprawnień lub je filtrować:

  • pageSize: maksymalna liczba uprawnień do zwrócenia na stronę. Jeśli nie jest ustawiona w przypadku plików na dysku współdzielonym, zwracanych jest maksymalnie 100 wyników. Jeśli nie jest ustawiona w przypadku plików, które nie znajdują się na dysku współdzielonym, zwracana jest cała lista.

  • pageToken: token strony otrzymany z poprzedniego wywołania listy. Podaj ten token, aby pobrać następną stronę.

  • supportsAllDrives: czy aplikacja wysyłająca żądanie obsługuje zarówno Mój dysk, jak i dyski współdzielone.

  • useDomainAdminAccess: ustaw na true, aby wysłać żądanie jako administrator domeny. Jeśli parametr fileId odnosi się do dysku współdzielonego, a osoba wysyłająca żądanie jest administratorem domeny, do której należy dysk współdzielony. Więcej informacji znajdziesz w artykule Zarządzanie dyskami współdzielonymi jako administrator domeny.

  • includePermissionsForView: uprawnienia dodatkowego widoku, które mają być uwzględnione w odpowiedzi. Obsługiwana jest tylko wartość published.

Poniższy przykładowy kod pokazuje, jak uzyskać wszystkie uprawnienia. Odpowiedź zawiera listę uprawnień do pliku, folderu lub dysku współdzielonego.

Żądanie

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 fileIdpath ustawionym na powiązany plik, folder lub dysk współdzielony oraz parametrem permissionIdpath ustawionym na uprawnienie do zmiany. 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.

Aktualizacje możesz stosować za pomocą semantyki poprawek, co oznacza, że możesz wprowadzać częściowe modyfikacje zasobu. W żądaniu musisz wyraźnie ustawić pola, które chcesz zmodyfikować. Pola, które nie są uwzględnione w żądaniu, zachowują swoje dotychczasowe wartości. Więcej informacji znajdziesz w artykule Praca z częściowymi zasobami.

Poniższy przykładowy kod pokazuje, jak zmienić uprawnienia dotyczące pliku lub folderu z commenter na writer. Odpowiedź zwraca instancję zasobu permissions.

Żądanie

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 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.

Żądanie

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 przesyłania zbiorczego 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
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;
        }
    }
}

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 pustym obiektem JSON. Aby potwierdzić usunięcie uprawnienia, użyj metody list w zasobie permissions z parametrem ścieżki fileId.

Żądanie

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 zawierającym 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 data-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 w przyszłość.

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