Udostępnianie plików, folderów

Każdy plik, folder i dysk współdzielony na Dysku Google ma powiązane uprawnienia. Każdy zasób określa uprawnienia dla konkretnego elementu type (użytkownika, grupy, domeny, każdego) i elementu role, na przykład „komentujący” lub „czytnik”. Na przykład plik może mieć uprawnienie, które przyznaje konkretnemu użytkownikowi (type=user) dostęp tylko do odczytu (role=reader), a inne uprawnienie umożliwia członkom określonej grupy (type=group) dodawanie komentarzy do pliku (role=commenter).

Pełną listę ról i operacji dozwolonych przez każdą z nich znajdziesz w artykule Role i uprawnienia.

Scenariusze udostępniania zasobów z Dysku

Istnieje 5 różnych scenariuszy udostępniania:

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

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

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

    • Dostęp tymczasowy (zarządzany przez datę i godzinę wygaśnięcia) nie jest dozwolony do folderów na Moim dysku w przypadku ustawienia role=writer. Więcej informacji znajdziesz w artykule Ustawianie daty ważności, aby ograniczyć dostęp do pliku.

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

    • Ustawienie writersCanShare nie ma zastosowania do elementów na dyskach współdzielonych. Jest traktowana tak, jakby miała zawsze 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 atrybutem role=fileOrganizer mogą udostępniać na nim foldery.
  5. Aby zarządzać użytkownikami dysku współdzielonego, użytkownik musi mieć role=organizer. Tylko użytkownicy i grupy mogą być użytkownikami dysków współdzielonych.

Aby ograniczyć dostęp do pliku, ustaw datę ważności

Gdy współpracujesz z osobami zajmującymi się projektem poufnym, możesz po pewnym czasie ograniczyć im dostęp do niektórych plików na Dysku. W przypadku plików na Moim dysku możesz ustawić datę ważności, aby ograniczyć lub zablokować dostęp do pliku.

Aby ustawić datę ważności:

Pole expirationTime wskazuje, kiedy uprawnienia wygasa, w formacie RFC 3339 data i godzina. Obowiązują następujące ograniczenia dotyczące okresu ważności:

  • Można je ustawiać tylko na poziomie uprawnień użytkownika i grupy.
  • Godzina musi przypadać w przyszłości.
  • Nie może być oddalony o więcej niż rok do przodu.

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

Propagacja uprawnień

Listy uprawnień folderu są rozpowszechniane w dół, a wszystkie pliki podrzędne i foldery dziedziczą uprawnienia od elementu nadrzędnego. Po każdej zmianie uprawnień lub hierarchii rozpowszechnienie odbywa się rekurencyjnie we wszystkich zagnieżdżonych folderach. Jeśli na przykład plik istnieje w folderze, a następnie zostanie on przeniesiony do innego folderu, uprawnienia do nowego folderu zostaną przeniesione do pliku. Jeśli nowy folder przypisze użytkownikowi pliku nową rolę, na przykład „autor”, zastąpi ona jego starą rolę.

I odwrotnie: jeśli plik dziedziczy właściwość role=writer z folderu i zostanie przeniesiony do innego folderu, który pełni rolę odczytującego, odziedziczy element role=reader.

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

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

Możliwości

Zasób Permissions (Uprawnienia) nie określa możliwości wykonywania działań na pliku lub folderze przez bieżącego użytkownika. Zamiast tego zasób Files zawiera zbiór pól logicznych capabilities, które określają, czy działanie można wykonać 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.

Na przykład, gdy Alex loguje się w aplikacji i próbuje udostępnić plik, rola Alexa jest sprawdzana pod kątem uprawnień do tego pliku. Jeśli rola umożliwia użytkownikowi udostępnianie pliku, związane z nim capabilities, np. canShare, są wypełniane względem roli. Jeśli Alex chce udostępnić plik, aplikacja sprawdza, czy capabilities ma wartość true.canShare

Przykład pobierania pliku capabilities znajdziesz w sekcji Weryfikowanie uprawnień użytkownika.

Utwórz uprawnienie

Podczas tworzenia uprawnienia niezbędne są te 2 pola:

  • type – właściwość type określa zakres uprawnienia (user, group, domain lub anyone). Uprawnienie 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 uprawnieniami type=user i role=reader przyznaje określonemu użytkownikowi dostęp tylko do odczytu do pliku lub folderu. Z kolei uprawnienie type=domain i role=commenter umożliwia wszystkim w domenie dodawanie komentarzy do pliku. Pełną listę ról i operacji dozwolonych przez każdą z nich znajdziesz w sekcji Role i uprawnienia.

Gdy tworzysz uprawnienie w przypadku uprawnień type=user lub type=group, musisz też podać emailAddress, aby powiązać z tym uprawnieniem konkretnego użytkownika lub grupę.

Podczas tworzenia uprawnienia z uprawnieniem type=domain musisz też podać domain, aby powiązać z nim określoną domenę.

Aby utworzyć uprawnienie:

  1. Użyj metody permissions.create z metodą fileId w przypadku powiązanego pliku lub folderu.
  2. W treści żądania określ type i role.
  3. Jeśli type=user lub type=group, podaj emailAddress. Jeśli type=domain, podaj domain.

Pokaż przykład

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

Wyślij prośbę

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

Odpowiedź

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

Użyj grup odbiorców

Grupy odbiorców to określone grupy osób – na przykład działy lub zespoły. Możesz polecać je użytkownikom, aby 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. Dzięki grupom odbiorców możesz zwiększyć bezpieczeństwo i prywatność danych oraz ułatwić użytkownikom odpowiednie udostępnianie. Więcej informacji znajdziesz w artykule Grupy odbiorców.

Aby używać grup odbiorców:

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

    Otwórz stronę 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 dowiedzieć się, jak utworzyć grupę odbiorców, przeczytaj artykuł Tworzenie grupy odbiorców.

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

  4. Utwórz uprawnienie w polu type=domain i ustaw wartość ID.audience.googledomains.com w polu domain.

Informacje o tym, jak użytkownicy wchodzą w interakcję z grupami odbiorców, znajdziesz w artykule Wrażenia użytkowników dotyczące udostępniania linków.

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

Użyj metody permissions.list, aby uzyskać wszystkie uprawnienia do 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"
    }
  ]
}

Weryfikowanie uprawnień użytkownika

Gdy aplikacja otwiera plik, powinna sprawdzać jego możliwości i renderować interfejs użytkownika tak, aby odzwierciedlał 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.

Więcej informacji na temat capabilities znajdziesz w sekcji Możliwości powyżej.

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

Pokaż przykład

Poniższy przykładowy kod pokazuje, jak zweryfikować uprawnienia użytkownika. Odpowiedź zawiera listę uprawnień użytkownika w pliku. Każda możliwość 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śl źródło roli dla plików i folderów na dysku współdzielonym

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

Aby określić źródło roli dysku współdzielonego lub elementów na tym dysku, wywołaj permissions.get z wartością fileId, permissionId i fields wartością w polu permissionDetails. Aby znaleźć permissionId, użyj permissions.list z fileId. Aby pobierać pole permissionDetails w żądaniu permissions.list, ustaw parametr fields na permissions/permissionDetails.

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

Pokaż przykład

Poniższy przykładowy kod pokazuje, jak określić źródło roli. Odpowiedź zwraca wartość permissionDetails zasobu Permission. Pole inheritedFrom zawiera identyfikator elementu, z którego odziedziczone są uprawnienia.

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 do pliku lub folderu, możesz zmienić przypisaną rolę:

  1. Wywołaj permissions.update, podając permissionId uprawnienia do zmiany, oraz fileId powiązany plik, folder lub dysk współdzielony. Aby znaleźć permissionId, użyj permissions.list z fileId.

  2. Odszukaj w żądaniu nowe role.

Możesz przyznawać uprawnienia do poszczególnych plików i folderów na dysku współdzielonym, nawet jeśli użytkownik lub grupa jest już ich użytkownikami. Na przykład w ramach subskrypcji dysku współdzielonego Alex ma role=commenter. Aplikacja może jednak przyznać Alexowi role=writer dostęp do pliku na dysku współdzielonym. W tym przypadku nowa rola jest mniej rygorystyczna niż ta przypisana do użytkownika, dlatego nowe uprawnienie staje się efektywną rolą w przypadku pliku lub folderu.

Pokaż przykład

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

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

Anulowanie dostępu do pliku lub folderu

Aby odebrać dostęp do pliku lub folderu, wywołaj delete, używając fileId i permissionId, aby usunąć uprawnienia.

W przypadku elementów na „Moim dysku” można usunąć odziedziczone uprawnienia. Usunięcie uprawnień odziedziczonych skutkuje odebraniem dostępu do danego elementu oraz ewentualnych elementów podrzędnych.

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

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

Pokaż przykład

Z przykładowego kodu poniżej dowiesz się, jak anulować dostęp przez usunięcie pola permissionId. Jeśli operacja się uda, treść odpowiedzi będzie pusta. Aby potwierdzić, że uprawnienia zostały usunięte, użyj permissions.list i fileId.

Wyślij prośbę

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

przenosić własność plików 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 właścicielem znajdujących się na nim plików. 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ć pliki z niego do własnego „Mojego dysku”, co przenosi własność na nich.

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

  • Utwórz uprawnienie do pliku przyznające określonemu użytkownikowi (type=user) uprawnienia właściciela (role=owner).

  • Zaktualizuj uprawnienia istniejącego pliku o role=owner i przenieś prawo własności na określonego użytkownika (transferOwnership=true).

Przenoszenie własności pliku z jednego konta klienta na inne

Własność plików można przenosić między kontami indywidualnymi. Dysk nie przenosi jednak własności pliku między dwoma kontami klientów, dopóki potencjalny nowy właściciel nie wyrazi zgody na przeniesienie. Aby przenieść własność pliku z jednego konta klienta na inne:

  1. Obecny właściciel inicjuje przeniesienie własności, tworząc lub aktualizując uprawnienia potencjalnego nowego właściciela do plików. Uprawnienie musi obejmować te ustawienia: role=writer, type=user i pendingOwner=true. Jeśli nowy właściciel tworzy uprawnienia dla potencjalnego właściciela, do potencjalnego właściciela zostanie wysłane powiadomienie e-mail z informacją, że został poproszony o przejęcie własności pliku.

  2. Nowy właściciel akceptuje prośbę o przeniesienie własności, tworząc lub aktualizując uprawnienia do plików. Uprawnienie musi obejmować te ustawienia: role=owner i transferOwnership=true. Jeśli nowy właściciel tworzy nowe uprawnienie, do poprzedniego właściciela jest wysyłany e-mail z powiadomieniem o przeniesieniu własności.

Po przeniesieniu pliku rola poprzedniego właściciela zostanie obniżona do writer.

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

Jeśli chcesz zmodyfikować kilka uprawnień, zdecydowanie zalecamy użycie żądań zbiorczych.

Poniżej znajdziesz przykład zbiorczej zmiany 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;
        }
    }
}