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żde z tych zasobów identyfikuje uprawnienia dla konkretnego type (user, group, domain, anyone) i role (owner, organizer, fileOrganizer, writer, commenter, reader). Przykładowo 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 dozwolonych przez nie operacji znajdziesz w artykule Role i uprawnienia.

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 dla pliku, użytkownik musi mieć uprawnienia role=owner.

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

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 dla pliku, użytkownik musi mieć bardziej liberalne uprawnienia role=owner.

   • Tymczasowy dostęp (określany przez datę i godzinę wygaśnięcia) nie jest dozwolony w folderach na Moim dysku z uprawnieniami role=writer. Więcej informacji znajdziesz w artykule Ustawianie daty ważności w celu ograniczenia dostępu do plików.

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 on traktowany tak, jakby zawsze miał wartość true.

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

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

5. Aby zarządzać członkostwem na dysku współdzielonym, użytkownik musi mieć uprawnienia role=organizer. Do dysków współdzielonych mogą należeć tylko użytkownicy i grupy.

Ustawianie daty wygaśnięcia w celu ograniczenia dostępu do plików

Jeśli współpracujesz z innymi osobami przy projekcie 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 uniemożliwić dostęp do pliku.

Aby ustawić datę ważności:

• Użyj metody create() w zasobie permissions i ustaw pole expirationTime (oraz inne wymagane pola). Więcej informacji znajdziesz w artykule Tworzenie uprawnienia.

• Użyj metody update() zasobu permissions i ustaw pole expirationTime (oraz inne wymagane pola). Więcej informacji znajdziesz w artykule Zmiana uprawnień.

Pole expirationTime określa, kiedy uprawnienia wygasną. Używa ono formatu RFC 3339 data-time. Czasy ważności mają te ograniczenia:

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

Więcej informacji o dacie wygaśnięcia znajdziesz w tych artykułach:

• Ustawianie daty wygaśnięcia dostępu do pliku
• Dodawanie daty ważności

Rozpowszechnianie uprawnień

Listy uprawnień folderu są propagowane w dół, a wszystkie pliki i foldery podrzędne dziedziczą uprawnienia z folderu nadrzędnego. Gdy zmienisz uprawnienia lub hierarchię, propagacja nastąpi rekurencyjnie we wszystkich podfolderach. Jeśli na przykład plik znajduje się w folderze, który następnie zostanie przeniesiony do innego folderu, uprawnienia nowego folderu zostaną przeniesione do pliku. Jeśli nowy folder przyzna użytkownikowi pliku nową rolę, np. „Wpisujący”, zastąpi ona jego starą rolę.

Jeśli natomiast plik odziedziczy uprawnienia role=writer z folderu i zostanie przeniesiony do innego folderu, który zapewnia rolę „czytelnika”, plik odziedziczy uprawnienia role=reader.

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

Z drugiej strony, dziedziczone uprawnienia można zastąpić w przypadku pliku lub folderu w Moje Drive. Jeśli plik dziedziczy uprawnienia role=writer z folderu na Moim dysku, możesz ustawić dla niego uprawnienia role=reader, aby obniżyć poziom uprawnień.

Możliwości

Zasoby permissions nie decydują o tym, czy bieżący użytkownik może wykonywać operacje 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 Alex zaloguje się w aplikacji i próbuje udostępnić plik, sprawdzamy, czy jego rola ma uprawnienia do tego pliku. Jeśli rola umożliwia udostępnianie pliku, capabilities powiązane z plikiem, takie jak canShare, są wypełniane w zależności od roli. Jeśli Alex chce udostępnić plik, aplikacja sprawdza, czy w ustawieniu capabilities wartość canShare jest ustawiona na true.

Przykładowy sposób pobierania pliku capabilities znajdziesz w sekcji Weryfikowanie uprawnień użytkownika.

Tworzenie uprawnienia

Podczas tworzenia uprawnienia wymagane są 2 pola:

• type: type określa zakres uprawnień (user, group, domain lub anyone). Uprawnienia z type=user dotyczą konkretnego użytkownika, a te z type=domain – wszystkich użytkowników w konkretnej domenie.

• role: pole role określa operacje, które może wykonywać type. Na przykład uprawnienie z type=user i role=reader przyznaje konkretnemu użytkownikowi dostęp tylko do odczytu do pliku lub folderu. Uprawnienia z type=domain i role=commenter pozwalają wszystkim użytkownikom w domenie dodawać komentarze do pliku. Pełną listę ról i dozwolonych operacji znajdziesz w artykule Role i uprawnienia.

Podczas tworzenia uprawnienia, w którym występuje type=user lub type=group, musisz też podać emailAddress, aby powiązać określonego użytkownika lub grupę z uprawnieniem.

Podczas tworzenia uprawnienia, w którym występuje type=domain, musisz też podać domain, aby powiązać określone domeny 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 jest to type=user lub type=group, podaj wartość emailAddress. Jeśli type=domain, podaj domain.

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

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

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

Korzystanie z list 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 w poprawie bezpieczeństwa i prywatności danych oraz ułatwić użytkownikom odpowiednie udostępnianie treści. Więcej informacji znajdziesz w artykule Informacje o docelowych grupach odbiorców.

Aby korzystać z list odbiorców:

1. W konsoli administracyjnej Google kliknij Menu 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 Grupy odbiorców kliknij nazwę grupy odbiorców. Aby utworzyć grupę odbiorców, zapoznaj się z artykułem 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 poziomem dostępu type=domain i ustaw pole domain na ID.audience.googledomains.com.

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

Pobieranie wszystkich uprawnień do pliku, folderu lub dysku współdzielonego

Aby pobrać wszystkie uprawnienia dotyczące pliku, folderu lub dysku współdzielonego, użyj metody list() zasobu permissions.

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

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

Sprawdzanie uprawnień użytkowników

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

Więcej informacji o capabilities znajdziesz w sekcji Możliwości.

Aby sprawdzić możliwości, wywołaj metodę get() zasobu 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 pliku.

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

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

Określanie źródła ról dla plików i folderów na dysku współdzielonym

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

Aby określić źródło roli dysku współdzielonego lub elementów na tym dysku, wywołaj metodę get() zasobu 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 listę wszystkich dziedziczonych i bezpośrednich uprawnień do plików dla użytkownika, grupy lub domeny.

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

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

Zmień uprawnienia

Aby zmienić uprawnienia dotyczące pliku lub folderu, możesz zmienić przypisaną rolę:

1. Wywołaj metodę update() zasobu permissions, ustawiając parametr ścieżki permissionId na uprawnienia do zmiany, a parametr ścieżki fileId 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ż ich członkiem. Na przykład Alex ma dostęp do folderu role=commenterw ramach członkostwa na dysku współdzielonym. Twoja aplikacja może jednak przyznać Alexowi rolę role=writer w przypadku pliku na dysku współdzielonym. W tym przypadku, ponieważ nowa rola jest bardziej liberalna niż rola przyznana na podstawie członkostwa, nowe uprawnienia stają się efektywną rolą dla pliku lub folderu.

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

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

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

Wyświetlanie i rozwiązywanie oczekujących próśb o dostęp

Propozycja przyznania dostępu to propozycja od zgłaszającego do zatwierdzającego, aby przyznać odbiorcy dostęp do elementu na Dysku.

Osoba zatwierdzająca może sprawdzać wszystkie nierozstrzygnięte propozycje przyznania dostępu do plików na Dysku i podejmować w ich sprawie odpowiednie działania. Oznacza to, że możesz przyspieszyć proces zatwierdzania, wysyłając zapytanie o oferty dostępu w ramach procesu automatyzacji, a następnie rozwiązując je. Pozwala też zatwierdzającemu wyświetlać propozycje w ujęciu zbiorczym.

Interfejs Drive API udostępnia zasób accessproposals, dzięki któremu możesz wyświetlać i rozwiązywać oczekujące prośby o dostęp. Metody zasobu accessproposals działają na plikach, folderach i plikach na dysku współdzielonym, ale nie na dysku współdzielonym.

Te terminy dotyczą ofert dostępu:

• Prośbę o dostęp wysyła użytkownik, który inicjuje propozycję dostępu do elementu w Google Dysku.
• Odbiorca: użytkownik, który otrzyma dodatkowe uprawnienia do pliku, jeśli propozycja przyznania dostępu zostanie zaakceptowana. W większości przypadków adresat jest taki sam jak osoba, która wysłała prośbę, ale nie zawsze.
• Zatwierdzający: użytkownik odpowiedzialny za zatwierdzenie (lub odrzucenie) propozycji przyznania dostępu. Dzieje się tak zwykle dlatego, że są właścicielami dokumentu lub mają możliwość udostępniania dokumentu.

Wyświetlanie listy oczekujących ofert dostępu

Aby wyświetlić listę wszystkich oczekujących propozycji dostępu do elementu na Dysku, wywołaj metodę list() zasobu accessproposals i dodaj parametr ścieżki fileId.

Tylko zatwierdzający plik mogą wyświetlać oczekujące propozycje dotyczące tego pliku. Zatwierdzający to użytkownik, który ma uprawnienia can_approve_access_proposals do pliku. Jeśli w prośbie nie podano zatwierdzenia, zwracana jest pusta lista. Więcej informacji o capabilities znajdziesz w sekcji Możliwości.

Treść odpowiedzi składa się z obiektu AccessProposal, który reprezentuje listę nierozwiązanych propozycji dostępu do pliku.

Obiekt AccessProposal zawiera informacje o każdej propozycji, takie jak prośba, odbiorca i wiadomość dodana przez osobę przesyłającą prośbę. Zawiera też obiekt AccessProposalRoleAndView, który grupuje zaproponowany przez wnioskodawcę element role z elementem view. Pole role jest powtarzalne, więc w przypadku każdej oferty może występować wiele wartości. Na przykład propozycja może zawierać obiekt AccessProposalRoleAndView o wartości role=reader i view=published oraz dodatkowy obiekt AccessProposalRoleAndView z wartością tylko role=writer. Więcej informacji znajdziesz w sekcji Wyświetlenia.

Aby dostosować podział na strony lub filtrować propozycje dostępu, prześlij te parametry zapytania:

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

• pageSize: maksymalna liczba propozycji dostępu do wyświetlenia na stronie.

Rozwiązywanie oczekujących prośby o dostęp

Aby zaakceptować wszystkie oczekujące prośby o dostęp do elementu w usłudze Dysk, wywołaj metodę resolve() w zasobie accessproposals i uwzględnij parametry ścieżki fileId i proposalId.

Metoda resolve() zawiera parametr zapytania action, który określa działanie związane z propozycją. Obiekt Action śledzi stan oferty, dzięki czemu wiemy, czy została ona zaakceptowana czy odrzucona.

Metoda resolve() zawiera też opcjonalne parametry zapytania role i view. Obsługiwane są tylko role writer, commenter i reader. Jeśli rola nie jest określona, domyślnie jest używana wartość reader. Dodatkowy opcjonalny parametr zapytania send_notification umożliwia wysłanie e-maila z powiadomieniem do osoby, która poprosiła o przesłanie oferty, gdy zostanie ona zaakceptowana lub odrzucona.

Podobnie jak w przypadku metody list() użytkownicy rozwiązujący propozycję muszą mieć uprawnienia can_approve_access_proposals do pliku. Więcej informacji o capabilities znajdziesz w sekcji Możliwości.

Propozycje są rozwiązywane za pomocą tych samych wzorców, które są wymienione w sekcji Przypadki użycia udostępniania zasobów w Google Drive. Jeśli masz kilka propozycji dla tego samego użytkownika, ale z różnymi rolami, obowiązują następujące zasady:

• Jeśli jedna propozycja zostanie zaakceptowana, a druga odrzucona, zaakceptowana rola zostanie zastosowana do pliku na Dysku.
• Jeśli obie oferty zostaną zaakceptowane w tym samym czasie, zostanie zastosowana oferta z wyższym poziomem uprawnień (np. role=writer w porównaniu z role=reader). Druga propozycja dostępu zostaje usunięta z elementu.

Po przesłaniu propozycji do metody resolve() akcja udostępniania jest zakończona. AccessProposal nie jest już zwracany za pomocą metody list(). Gdy propozycja zostanie zaakceptowana, użytkownik musi użyć kolekcji permissions, aby zaktualizować uprawnienia do pliku lub folderu. Więcej informacji znajdziesz w sekcji Zmiana uprawnień.

Odbieranie dostępu do pliku lub folderu

Aby cofnąć dostęp do pliku lub folderu, wywołaj metodę delete() zasobu permissions z parametrami ścieżki fileId i permissionId, aby usunąć uprawnienia.

W przypadku elementów na „Moim dysku” można usunąć dziedziczone 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 odziedziczonych uprawnień nie można cofnąć. Zamiast tego zaktualizuj lub cofnij uprawnienia do 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.

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

Przenoszenie prawa własności do pliku na inne konto Google Workspace w tej samej organizacji

Własność plików znajdujących się na „Moim dysku” można przenieść z jednego konta Google Workspace na inne konto w tej samej organizacji. Organizacja, która jest właścicielem dysku współdzielonego, jest też właścicielem plików na tym dysku. Dlatego przenoszenie własności nie jest obsługiwane w przypadku plików i folderów na dyskach współdzielonych. Organizatorzy dysku współdzielonego mogą przenosić elementy z tego dysku na swój „Mój dysk”, co powoduje przeniesienie własności na nich.

Aby przenieść własność pliku na „Moim dysku”, wykonaj jedną z tych czynności:

• Utwórz uprawnienia pliku, które przyznają określonemu użytkownikowi (type=user) dostęp właściciela (role=owner).

• Zaktualizuj uprawnienia do istniejącego pliku za pomocą role=owner i przenieś własność na wskazanego użytkownika (transferOwnership=true).

Przenoszenie własności plików z jednego konta użytkownika na inne

Własność plików można przenosić z jednego konta użytkownika na inne. Dysk nie przenosi jednak własności pliku między 2 kontami użytkowników indywidualnych, dopóki potencjalny właściciel nie wyrazi na to wyraźnej zgody. Aby przenieść własność pliku z jednego konta użytkownika na inne:

1. Aktualny właściciel inicjuje przeniesienie własności, tworząc lub aktualizując uprawnienia do pliku dla potencjalnego właściciela. Uprawnienia muszą obejmować te ustawienia: role=writer, type=user i pendingOwner=true. Jeśli obecny właściciel tworzy uprawnienia dla potencjalnego właściciela, do tego ostatniego wysyłany jest e-mail z powiadomieniem, że prosi się go o przejęcie własności pliku.

2. Potencjalny właściciel akceptuje prośbę o przeniesienie własności, tworząc lub aktualizując uprawnienia do pliku. Uprawnienia muszą obejmować te ustawienia: role=owner i transferOwnership=true. Jeśli nowy właściciel utworzy nowe uprawnienie, do poprzedniego właściciela zostanie wysłany e-mail z powiadomieniem o przekazaniu własności.

Gdy plik zostanie przeniesiony, rola poprzedniego właściciela zostanie zmieniona na writer.

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

import com.google.api.client.googleapis.batch.BatchRequest;
import com.google.api.client.googleapis.batch.json.JsonBatchCallback;
import com.google.api.client.googleapis.json.GoogleJsonError;
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.HttpHeaders;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.drive.Drive;
import com.google.api.services.drive.DriveScopes;
import com.google.api.services.drive.model.Permission;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/* Class to demonstrate use-case of modify permissions. */
public class ShareFile {

  /**
   * Batch permission modification.
   * realFileId file Id.
   * realUser User Id.
   * realDomain Domain of the user ID.
   *
   * @return list of modified permissions if successful, {@code null} otherwise.
   * @throws IOException if service account credentials file not found.
   */
  public static List<String> shareFile(String realFileId, String realUser, String realDomain)
      throws IOException {
        /* Load pre-authorized user credentials from the environment.
         TODO(developer) - See https://developers.google.com/identity for
         guides on implementing OAuth2 for your application.application*/
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
        .createScoped(Arrays.asList(DriveScopes.DRIVE_FILE));
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

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

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


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

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

        ids.add(permission.getId());

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

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

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

      domainPermission.setDomain(realDomain);

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

      batch.execute();

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

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


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

  Load pre-authorized user credentials from the environment.
  TODO(developer) - See https://developers.google.com/identity
  for guides on implementing OAuth2 for the application.
  """
  creds, _ = google.auth.default()

  try:
    # create drive api client
    service = build("drive", "v3", credentials=creds)
    ids = []
    file_id = real_file_id

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

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

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

  return ids


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

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

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

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

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

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

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

}

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

namespace DriveV3Snippets
{
    // Class to demonstrate use-case of Drive modify permissions.
    public class ShareFile
    {
        /// <summary>
        /// Batch permission modification.
        /// </summary>
        /// <param name="realFileId">File id.</param>
        /// <param name="realUser">User id.</param>
        /// <param name="realDomain">Domain id.</param>
        /// <returns>list of modified permissions, null otherwise.</returns>
        public static IList<String> DriveShareFile(string realFileId, string realUser, string realDomain)
        {
            try
            {
                /* Load pre-authorized user credentials from the environment.
                 TODO(developer) - See https://developers.google.com/identity for
                 guides on implementing OAuth2 for your application. */
                GoogleCredential credential = GoogleCredential.GetApplicationDefault()
                    .CreateScoped(DriveService.Scope.Drive);

                // Create Drive API service.
                var service = new DriveService(new BaseClientService.Initializer
                {
                    HttpClientInitializer = credential,
                    ApplicationName = "Drive API Snippets"
                });

                var ids = new List<String>();
                var batch = new BatchRequest(service);
                BatchRequest.OnResponse<Permission> callback = delegate(
                    Permission permission,
                    RequestError error,
                    int index,
                    HttpResponseMessage message)
                {
                    if (error != null)
                    {
                        // Handle error
                        Console.WriteLine(error.Message);
                    }
                    else
                    {
                        Console.WriteLine("Permission ID: " + permission.Id);
                    }
                };
                Permission userPermission = new Permission()
                {
                    Type = "user",
                    Role = "writer",
                    EmailAddress = realUser
                };

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

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

Powiązane artykuły

• Ochrona treści pliku
• Uzyskiwanie dostępu do plików na Dysku udostępnionych za pomocą linku za pomocą kluczy zasobów
• Role i uprawnienia