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

Każdy plik, folder i dysk współdzielony na Dysku Google mają 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 rodzajów scenariuszy udostępniania:

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

  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 w pliku na false, użytkownik musi mieć bardziej restrykcyjne ustawienie 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 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 współdzielonym.

  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:

Pole expirationTime określa, kiedy uprawnienia wygasną. Używa ono formatu RFC 3339 data-time. Terminy ważności mają następujące ograniczenia:

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

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

Propagacja 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 plik dziedziczy właściwość role=writer z folderu i zostanie przeniesiony do innego folderu z rolą odczytującego, plik odziedziczy teraz role=reader.

Odziedziczonych uprawnień nie można usunąć z pliku ani folderu na dysku współdzielonym. Zamiast tego należy zmienić 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”.

Możesz też zastąpić odziedziczone uprawnienia do pliku lub folderu na Moim dysku. Jeśli plik dziedziczy uprawnienia role=writer z folderu Mój dysk, możesz ustawić role=reader w tym pliku, aby obniżyć jego 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 pozwala na 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ład wyodrębniania pliku capabilities znajdziesz w sekcji Weryfikowanie uprawnień użytkownika.

Tworzenie uprawnienia

Podczas tworzenia uprawnienia wymagane są 2 pola:

  • type: type określa zakres uprawnienia (user, group, domain lub anyone). Uprawnienie z wartością type=user dotyczy konkretnego użytkownika, a uprawnienie type=domain dotyczy wszystkich użytkowników w danej 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 opcją 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.

Pokaż przykład

Poniższy przykładowy kod pokazuje, jak utworzyć uprawnienie. Odpowiedź zwraca instancję zasobu Permission, w tym przypisaną wartość 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"
}

Użyj 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 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  > 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, 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 wartością 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

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

Pokaż przykład

Poniższy przykładowy kod pokazuje, jak uzyskać wszystkie uprawnienia. Odpowiedź zwraca 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"
    }
  ]
}

Sprawdzanie uprawnień użytkowników

Gdy aplikacja otwiera plik, powinna sprawdzić jego możliwości i wyświetlić 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.

Pokaż przykład

Przeanalizuj przykładowy kod poniżej, aby się dowiedzieć, jak sprawdzić uprawnienia użytkownika. Odpowiedź zwraca listę uprawnień użytkownika do pliku. Każda z nich 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,
    "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ę 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 w dysku współdzielonym, rola w folderze lub rola w pliku.

Aby określić źródło roli dysku współdzielonego lub znajdujących się na nim elementów, wywołaj metodę get() w zasobie permissions z parametrami ścieżki fileId i permissionId i wartością fields ustawioną w polu 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 odziedziczone i bezpośrednie uprawnienia do plików przyznane użytkownikowi, grupie lub domenie.

Pokaż przykład

Poniższy przykładowy kod pokazuje, jak określić źródło roli. Odpowiedź zwraca wartość permissionDetails zasobu permissions. Pole inheritedFrom zawiera identyfikator elementu, z którego dziedziczy się 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
    }
  ]
}

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 żądaniu znajdź nowy element 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 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.

Pokaż przykład

Poniższy przykładowy kod pokazuje, jak zmienić uprawnienia pliku lub folderu z „Komentator” na „Autor”. 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"
}

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 przeglądać wszystkie nierozstrzygnięte propozycje dostępu do plików na Dysku i podejmować dotyczące ich 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.

Dostęp do ofert pakietowych zależą od tych warunków:

  • 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, ponieważ 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 reprezentującego listę nierozstrzygniętych propozycji dostępu w 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 próśb 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 przyjmuje się 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 zamykający ofertę pakietową muszą mieć w pliku zdolność can_approve_access_proposals. Więcej informacji o capabilities znajdziesz w sekcji Możliwości.

Propozycje są rozwiązywane za pomocą tych samych wzorców wymienionych w sekcji Scenariusze 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 zaakceptujesz obie oferty pakietowe jednocześnie, zastosowana zostanie oferta z wyższymi uprawnieniami (np. role=writer w porównaniu z role=reader). Druga propozycja dostępu zostanie usunięta z elementu.

Po wysłaniu oferty pakietowej do metody resolve() działanie udostępniania zostaje zakończone. AccessProposal nie jest już zwracany za pomocą metody list(). Po zaakceptowaniu oferty pakietowej użytkownik musi zaktualizować uprawnienia pliku lub folderu za pomocą kolekcji permissions. Więcej informacji znajdziesz w sekcji Zmiana uprawnień.

Odbieranie dostępu do pliku lub folderu

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

W przypadku elementów z „Mojego dysku” możesz usunąć odziedziczone uprawnienie. Usunięcie odziedziczonych uprawnień powoduje cofnięcie dostępu do elementu i jego ewentualnych elementów podrzędnych.

W przypadku elementów na dysku współdzielonym nie można cofnąć odziedziczonych uprawnień. 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.

Pokaż przykład

Poniższy przykładowy kod pokazuje, jak cofnąć dostęp przez usunięcie elementu permissionId. W przypadku powodzenia treść odpowiedzi jest pusta. Aby sprawdzić, czy uprawnienia zostały usunięte, użyj metody list() zasobu permissions z parametrem ścieżki fileId.

Wyślij prośbę

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ć z niego elementy na własny „Mój dysk”, co powoduje przeniesienie ich własności na siebie.

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

  • Zmień uprawnienia istniejącego pliku w: role=owner i przenieś własność na określonego użytkownika (transferOwnership=true).

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

Własność plików można przenieść między kontem indywidualnym na inne. Jednak Dysk nie przenosi własności pliku między kontami dla klientów indywidualnych, dopóki potencjalny właściciel nie wyrazi na to 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. Uprawnienie musi 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 zostanie wysłany 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

Do modyfikowania wielu uprawnień zdecydowanie zalecamy korzystanie z żądań zbiorczych.

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