Ta strona została przetłumaczona przez Cloud Translation API.

Udostępnianie plików, folderów

Wszystkie pliki, foldery i dyski współdzielone na Dysku Google zostały powiązane permissions. Każdy zasób Określa uprawnienia do określonego elementu type (użytkownika, grupy, domeny, dowolnego użytkownika) i role, na przykład „komentator” czy „reader”. Na przykład plik może mieć uprawnienie przyznające konkretnemu użytkownikowi (type=user) dostęp tylko do odczytu (role=reader), podczas gdy inne uprawnienie zapewnia członkom konkretnej grupy (type=group) możliwość dodawania komentarzy do pliku (role=commenter).

Pełną listę ról i dozwolonych przez nie działań znajdziesz tutaj: Role .

Istnieje 5 różnych scenariuszy udostępniania:

Aby udostępnić plik z Mojego dysku, użytkownik musi mieć role=writer lub role=owner.
- Jeśli wartość logiczna writersCanShare ma wartość False dla pliku, użytkownik musi mieć role=owner.
- Jeśli użytkownik z dostępem role=writer ma dostęp tymczasowy, którym podlegają datę i godzinę wygaśnięcia, nie możesz udostępnić pliku. Więcej informacje znajdziesz w sekcji Ustawianie daty ważności dostępu do plików .
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 dla pliku, użytkownik musi mieć bardziej restrykcyjne ustawienie role=owner.
- Dostęp tymczasowy (zarządzany przez datę i godzinę wygaśnięcia) jest niedozwolony w folderach Mojego dysku za pomocą usługi role=writer. Więcej Więcej informacji zawiera Określ datę ważności, aby ograniczyć dostęp do pliku.
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. Funkcja jest traktowana tak, jakby zawsze miała wartość True.
Aby udostępnić folder na dysku współdzielonym, użytkownik musi mieć role=organizer.
- Jeśli ograniczenie sharingFoldersRequiresOrganizerPermission na dysk współdzielony jest ustawiony na False, użytkownicy mający role=fileOrganizer mogą foldery na tym dysku współdzielonym.
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.

Ustaw datę ważności, aby ograniczyć dostęp do pliku

Gdy pracujesz z innymi nad projektem o charakterze poufnym, ograniczy dostęp do niektórych plików na Dysku po okresie obecnie się znajdujesz. W przypadku plików na Moim dysku możesz ustawić datę ważności na ograniczyć lub zablokować dostęp do tego pliku.

Aby ustawić datę ważności:

Korzystanie z permissions.create i ustaw funkcję permissions.expirationTime (wraz z innymi wymaganymi polami). Więcej informacji: Utwórz uprawnienie.
Korzystanie z permissions.update i ustaw pole permissions.expirationTime (wraz z drugą wymagane pola). Więcej informacji znajdziesz w sekcji Zmiana .

Pole expirationTime wskazuje, kiedy uprawnienie wygasa. Służą do tego RFC 3339 data-godzina , Terminy ważności mają następujące ograniczenia:

Można je ustawiać tylko dla uprawnień użytkownika i grupy.
Godzina musi przypadać w przyszłości.
Godzina nie może być oddalona o więcej niż rok w przyszłość.

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

Propagacja uprawnień

Listy uprawnień dotyczące folderu są rozpowszechnione w dół, a wszystkie pliki podrzędne i foldery dziedziczą uprawnienia z folderu nadrzędnego. Jeśli uprawnienia lub zmieni się hierarchia, propagacja następuje rekurencyjnie przez wszystkie zagnieżdżone foldery. Jeśli na przykład plik istnieje w folderze, a ten folder zostanie przeniesiony w innym folderze, uprawnienia z nowego folderu zostaną rozpowszechnione w pliku. Jeśli nowy folder przypisze użytkownikowi pliku nową rolę, taką jak „zapisujący”, jego zastąpi ich starą rolę.

Jeśli plik dziedziczy właściwość role=writer z folderu i zostanie przeniesiony do inny folder, który zawiera „czytnika” , plik dziedziczy 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 odziedziczone. Odziedziczone uprawnienia można usunąć z elementów w „Mój dysk” lub „Udostępnione dla mnie”.

Możesz też zastąpić odziedziczone uprawnienia do pliku lub folderu w sekcji Moje Dysk. Jeśli więc plik dziedziczy właściwość role=writer z elementu Mój na Dysku, możesz ustawić role=reader w pliku, aby zmniejszyć jego poziom uprawnień.

Możliwości

Zasób Permissions nie zawsze Określają uprawnienia bieżącego użytkownika do wykonywania działań w pliku lub folderze. Zamiast tego zasób Files zawiera zbiór wartości logiczne capabilities są używane do wskazywania, czy działanie może wykonywać na pliku lub folderze. Interfejs Google Drive API ustawia te pola na podstawie zasób uprawnień bieżącego użytkownika powiązany z plikiem lub folderem.

Na przykład gdy Olek loguje się w Twojej aplikacji i próbuje udostępnić plik, rola Alexa jest sprawdzana pod kątem uprawnień do pliku. Jeśli rola pozwala na udostępnienie pliku, pola capabilities powiązane z plikiem, na przykład canShare, są wypełnione w stosunku do roli. Jeśli Alex chce udostępnić plik, aplikacja sprawdza capabilities, aby upewnić się, że ustawienie canShare ma wartość true.

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

Utwórz uprawnienie

Te 2 pola są niezbędne podczas tworzenia uprawnień:

type – type określa zakres uprawnienia (user, group, domain lub anyone). Uprawnienie z type=user dotyczy konkretnego użytkownika, uprawnienie z type=domain ma zastosowanie do wszystkich użytkowników w określonej domenie.
role – pole role wskazuje operacje, które może wykonać type. Na przykład plik uprawnienie z type=user i role=reader przyznaje konkretnemu użytkownikowi dostęp tylko do odczytu pliku lub folderu. Możesz też użyć uprawnień z aplikacją type=domain a role=commenter umożliwia wszystkim użytkownikom w domenie dodawanie komentarzy do pliku. Dla: pełną listę ról i dozwolonych przez nie działań znajdziesz tutaj: Role .

Tworząc uprawnienie, w którym type=user lub type=group musisz też podaj emailAddress do dopasowania konkretnego użytkownika lub grupy z uprawnieniami.

Tworząc uprawnienie, w którym type=domain musisz też podać: domain, aby powiązać określoną domenę. uprawnienia.

Aby utworzyć uprawnienie:

Używanie metody permissions.create fileId dla powiązanego pliku lub folderu.
W treści żądania określ type i role.
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 instancję zasobu Permission, w tym przypisanego zasobu 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 grupy osób (np. działy lub zespoły), których możesz obejmować użytkownikom, którym mogą udostępnić swoje produkty. Można zachęcić użytkowników do tylko dla określonych elementów, a nie do całej grupy odbiorców Twojej organizacji. Grupy odbiorców mogą pomóc w poprawie bezpieczeństwa i prywatności swoje dane i ułatwiaj użytkownikom ich prawidłowe udostępnianie. Więcej więcej informacji można znaleźć w artykule Element docelowy – informacje odbiorcy ,

Aby użyć grup odbiorców:

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

Otwórz stronę Grupy odbiorców

Aby wykonać tę czynność, musisz zalogować się na konto z uprawnieniami superadministratora.
Na liście odbiorców docelowych kliknij nazwę wybranej grupy. Do jak utworzyć grupę odbiorców, przeczytaj artykuł Tworzenie grupy odbiorców odbiorcy
Skopiuj unikalny identyfikator z adresu URL grupy odbiorców: https://admin.google.com/ac/targetaudiences/ID.
Utwórz uprawnienie w: type=domain i ustaw pole domain na ID.audience.googledomains.com.

Informacje o tym, jak użytkownicy wchodzą w interakcje z grupami odbiorców, znajdziesz w artykule Interfejs użytkownika i link udostępnianie ,

Pobieranie wszystkich uprawnień dotyczących pliku, folderu lub dysku współdzielonego

Użyj metody permissions.list, aby pobierz 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, aby odzwierciedlić uprawnienia bieżącego użytkownika. Jeśli na przykład użytkownik nie ma funkcji canComment w pliku, możliwość komentowania powinna być wyłączona w interfejsie.

Więcej informacji o funkcji capabilities znajdziesz w sekcji Potencjał. powyżej.

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

Pokaż przykład

Przeanalizuj przykładowy kod poniżej, aby się dowiedzieć, jak sprawdzić uprawnienia użytkownika. Odpowiedź zwraca listę uprawnień użytkownika dotyczących 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ślanie źródła roli plików na dysku współdzielonym foldery

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 zależeć od członkostwa w na dysku, roli w folderze lub roli w pliku.

Aby określić źródło roli dysku współdzielonego lub znajdujących się na nim elementów zadzwoń do: permissions.get, podając fileId, permissionId i fields ustawione na permissionDetails. Aby znaleźć permissionId, użyj permissions.list z: fileId. Do pobierz pole permissionDetails w żądaniu permissions.list, ustaw fields parametr do permissions/permissionDetails.

To pole zawiera wszystkie odziedziczone i bezpośrednie uprawnienia do plików przypisane do użytkownika. grupę lub domenę.

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 dane uprawnienie jest dziedziczone.

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ę:

Zadzwoń pod numer permissions.update, podając permissionId uprawnień do zmiany i fileId dla powiązany plik, folder lub dysk współdzielony. Aby znaleźć permissionId, użyj permissions.list z: fileId.

Uwaga: pole permissionId oznacza użytkownika lub grupę, do której przyznane uprawnienie, na przykład alex@altostrat.com lub hiking-club@altostrat.com permissionId pozostaje bez zmian. użytkownika lub grupy we wszystkich plikach, folderach i dyskach współdzielonych.
W żądaniu znajdź nowy element 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ż członkiem. Na przykład Aleksander ma słowo role=commenter w ramach subskrypcji dysku współdzielonego. Jednak Twoja aplikacja może przyznać Alexowi uprawnienia role=writer. Ponieważ nowa rola jest bardziej mało restrykcyjna niż rola przyznawana przez członkostwo, staje się rolą efektywną dla 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 unieważnić dostęp do pliku lub folderu, wywołaj delete z: fileId i permissionId, aby usunąć to uprawnienie.

W przypadku elementów na „Moim dysku” można usunąć dziedziczone uprawnienia. Usunięcie dziedziczonych uprawnień cofa dostęp do elementu, a elementów podrzędnych, o ile takie istnieją.

Nie można cofnąć dziedziczonych uprawnień do elementów na dysku współdzielonym. Zaktualizuj lub odbierz uprawnienia do pliku lub folderu nadrzędnego.

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

Pokaż przykład

Poniższy przykładowy kod pokazuje, jak anulować dostęp przez usunięcie permissionId. Jeśli operacja się uda, treść odpowiedzi będzie pusta. Aby potwierdzić, że uprawnienia zostały usunięte, użyj uprawnienia permissions.list z: fileId.

Wyślij prośbę

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

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

Własność plików istniejących na „Moim dysku” Można przenieść z 1 konto Google Workspace. z innego konta w tej samej organizacji. Organizacja, do której należy plik udostępniony jest właścicielem znajdujących się na nim plików. W związku z tym przenoszenie własności nie jest obsługiwane. w plikach i folderach na dyskach współdzielonych. Organizatorzy dysku współdzielonego mogą przenosić pliki elementów z tego dysku współdzielonego na własny „Mój dysk” który przenosi własność na tego użytkownika.

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

Utwórz uprawnienia do pliku przyznające konkretnemu użytkownikowi (type=user) dostęp właściciela (role=owner).
Zaktualizuj uprawnienia istniejącego pliku o uprawnienia role=owner i przenieś prawa własności do określonego użytkownika (transferOwnership=true).

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

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

Obecny właściciel inicjuje przeniesienie własności przez utworzenie lub aktualizację uprawnienia nowego właściciela do plików. Uprawnienie musi zawierać te ustawienia: role=writer, type=user i pendingOwner=true. Jeśli nowy właściciel tworzy uprawnienia dla potencjalnego właściciela, adres e-mail do potencjalnego nowego właściciela zostanie wysłane powiadomienie, że poproszono o przyjęcie własności pliku.
Nowy właściciel akceptuje prośbę o przeniesienie własności przez utworzenie lub zaktualizowanie uprawnienia do plików. Uprawnienia muszą obejmować te ustawienia: role=owner i transferOwnership=true. Jeśli nowy właściciel tworzy nowe uprawnienia, poprzedni właściciel otrzyma e-maila z powiadomieniem z informacją, że prawo własności zostało przeniesione.

Po przeniesieniu pliku rola poprzedniego właściciela zmienia się na writer.

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

Zdecydowanie zalecamy użycie żądania zbiorcze modyfikowania wielu uprawnień.

Poniżej znajduje się przykład wykonania zbiorczej modyfikacji uprawnień za pomocą z biblioteką klienta.

Java

drive/snippets/drive_v3/src/main/java/ShareFile.java

Wyświetl w GitHubie

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

Wyświetl w GitHubie

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

Wyświetl w GitHubie

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

Wyświetl w GitHubie

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

Wyświetl w GitHubie

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

Udostępnianie plików, folderów

Scenariusze udostępniania zasobów z Dysku

Ustaw datę ważności, aby ograniczyć dostęp do pliku

Propagacja uprawnień

Możliwości

Utwórz uprawnienie

Pokaż przykład

Użyj grup odbiorców

Pobieranie wszystkich uprawnień dotyczących pliku, folderu lub dysku współdzielonego

Pokaż przykład

Weryfikowanie uprawnień użytkownika

Pokaż przykład

Określanie źródła roli plików na dysku współdzielonym foldery

Pokaż przykład

Zmień uprawnienia

Pokaż przykład

Anulowanie dostępu do pliku lub folderu

Pokaż przykład

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

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

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

Java

Python

Node.js

PHP

.NET