Zarządzaj dyskami współdzielonymi

Z tego przewodnika dowiesz się, jak zarządzać dyskami współdzielonymi, m.in. jak je tworzyć oraz zarządzać użytkownikami i uprawnieniami za pomocą interfejsu Google Drive API.

Jeśli chcesz określić pola, które mają być zwracane w odpowiedzi, możesz ustawić parametr fields systemowy w dowolnej metodzie zasobu drives. Jeśli nie określisz parametru fields, serwer zwróci domyślny zestaw pól właściwy dla danej metody. Na przykład metoda list zwraca tylko pola kind, id, i name dla każdego dysku współdzielonego. Więcej informacji znajdziesz w artykule Zwracanie określonych pól.

Więcej informacji o limitach folderów na dyskach współdzielonych znajdziesz w artykule Limity folderów na dyskach współdzielonych.

Tworzenie dysku współdzielonego

Aby utworzyć dysk współdzielony, użyj create metody w zasobie drives z requestId parametrem.

Parametr requestId identyfikuje logiczną próbę idempotentnego utworzenia dysku współdzielonego. Jeśli żądanie przekroczy limit czasu lub zwróci nieokreślony błąd backendu, można je powtórzyć bez obawy o utworzenie duplikatów. Parametr requestId i treść żądania muszą pozostać takie same.

Poniższy przykład kodu pokazuje, jak utworzyć dysk współdzielony:

Java

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

Wyświetl w GitHubie

import com.google.api.client.googleapis.json.GoogleJsonResponseException;
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.DriveScopes;
import com.google.api.services.drive.model.Drive;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Arrays;
import java.util.UUID;

/* class to demonstrate use-case of Drive's create drive. */
public class CreateDrive {

  /**
   * Create a drive.
   *
   * @return Newly created drive id.
   * @throws IOException if service account credentials file not found.
   */
  public static String createDrive() 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.*/
    GoogleCredentials credentials =
        GoogleCredentials.getApplicationDefault().createScoped(Arrays.asList(DriveScopes.DRIVE));
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

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

    Drive driveMetadata = new Drive();
    driveMetadata.setName("Project Resources");
    String requestId = UUID.randomUUID().toString();
    try {
      Drive drive = service.drives().create(requestId,
              driveMetadata)
          .execute();
      System.out.println("Drive ID: " + drive.getId());

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

Python

drive/snippets/drive-v3/drive_snippet/create_drive.py

Wyświetl w GitHubie

import uuid

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


def create_drive():
  """Create a drive.
  Returns:
      Id of the created drive

  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)

    drive_metadata = {"name": "Project Resources"}
    request_id = str(uuid.uuid4())
    # pylint: disable=maybe-no-member
    drive = (
        service.drives()
        .create(body=drive_metadata, requestId=request_id, fields="id")
        .execute()
    )
    print(f'Drive ID: {drive.get("id")}')

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

  return drive.get("id")


if __name__ == "__main__":
  create_drive()

Node.js

drive/snippets/drive_v3/drive_snippets/create_drive.js

Wyświetl w GitHubie

import {GoogleAuth} from 'google-auth-library';
import {google} from 'googleapis';
import {v4 as uuid} from 'uuid';

/**
 * Creates a new shared drive.
 * @return {Promise<string>} The ID of the created shared drive.
 */
async function createDrive() {
  // Authenticate with Google and get an authorized client.
  // TODO (developer): Use an appropriate auth mechanism for your app.
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });

  // Create a new Drive API client (v3).
  const service = google.drive({version: 'v3', auth});

  // The metadata for the new shared drive.
  const driveMetadata = {
    name: 'Project resources',
  };

  // A unique request ID to avoid creating duplicate shared drives.
  const requestId = uuid();

  // Create the new shared drive.
  const Drive = await service.drives.create({
    requestBody: driveMetadata,
    requestId,
    fields: 'id',
  });

  // Print the ID of the new shared drive.
  console.log('Drive Id:', Drive.data.id);
  if (!Drive.data.id) {
    throw new Error('Drive ID not found.');
  }
  return Drive.data.id;
}

PHP

drive/snippets/drive_v3/src/DriveCreateDrive.php

Wyświetl w GitHubie

<?php
use Google\Client;
use Google\Service\Drive;
use Ramsey\Uuid\Uuid;
function createDrive()
{
    try {
        $client = new Client();
        $client->useApplicationDefaultCredentials();
        $client->addScope(Drive::DRIVE);
        $driveService = new Drive($client);

        $driveMetadata = new Drive\Drive(array(
                'name' => 'Project Resources'));
        $requestId = Uuid::uuid4()->toString();
        $drive = $driveService->drives->create($requestId, $driveMetadata, array(
                'fields' => 'id'));
        printf("Drive ID: %s\n", $drive->id);
        return $drive->id;
    } catch(Exception $e)  {
        echo "Error Message: ".$e;
    }  

}

.NET

drive/snippets/drive_v3/DriveV3Snippets/CreateDrive.cs

Wyświetl w GitHubie

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

namespace DriveV3Snippets
{
    // Class to demonstrate use of Drive's create drive.
    public class CreateDrive
    {
        /// <summary>
        /// Create a drive.
        /// </summary>
        /// <returns>newly created drive Id.</returns>
        public static string DriveCreateDrive()
        {
            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 driveMetadata = new Drive()
                {
                    Name = "Project Resources"
                };
                var requestId = Guid.NewGuid().ToString();
                var request = service.Drives.Create(driveMetadata, requestId);
                request.Fields = "id";
                var drive = request.Execute();
                Console.WriteLine("Drive ID: " + drive.Id);
                return drive.Id;
            }
            catch (Exception e)
            {
                // TODO(developer) - handle error appropriately
                if (e is AggregateException)
                {
                    Console.WriteLine("Credential Not found");
                }
                else
                {
                    throw;
                }
            }
            return null;
        }
    }
}

Wywołania metody create są idempotentne.

Jeśli dysk współdzielony został utworzony w poprzednim żądaniu lub w wyniku ponowienia, metoda zwraca instancję zasobu drives. Czasami, np. po dłuższym czasie lub jeśli zmieniła się treść żądania, może zostać zwrócony błąd 409 wskazujący, że należy odrzucić parametr requestId.

Pobieranie dysku współdzielonego

Aby pobrać metadane dysku współdzielonego, użyj metody get w zasobie drives z parametrem ścieżki driveId. Jeśli nie znasz identyfikatora dysku, możesz wyświetlić listę wszystkich dysków współdzielonych za pomocą metody list.

Metoda get zwraca dysk współdzielony jako instancję zasobu drives.

Aby wysłać żądanie jako administrator domeny, ustaw parametr zapytania useDomainAdminAccess na true. Więcej informacji znajdziesz w artykule Zarządzanie dyskami współdzielonymi jako administrator domeny.

Wyświetlanie listy dysków współdzielonych

Aby wyświetlić listę dysków współdzielonych użytkownika, użyj list metody w zasobie drives. Metoda zwraca listę dysków współdzielonych.

Aby dostosować paginację lub filtrować dyski współdzielone, przekaż te parametry zapytania:

pageSize: maksymalna liczba dysków współdzielonych, które mają być zwracane na stronie.
pageToken: token strony otrzymany z poprzedniego wywołania listy. Podaj ten token, aby pobrać następną stronę.
q: ciąg zapytania do wyszukiwania dysków współdzielonych. Więcej informacji znajdziesz w artykule Wyszukiwanie dysków współdzielonych.
useDomainAdminAccess: ustaw na true, aby wysłać żądanie jako administrator domeny i zwrócić wszystkie dyski współdzielone w domenie, w której wysyłający jest administratorem. Więcej informacji znajdziesz w artykule Zarządzanie dyskami współdzielonymi jako administrator domeny.

Aktualizowanie dysku współdzielonego

Aby zaktualizować metadane dysku współdzielonego, użyj metody update w zasobie drives z parametrem ścieżki driveIdparameter.

Metoda zwraca dysk współdzielony jako instancję zasobu drives.

Ukrywanie i odkrywanie dysku współdzielonego

Aby ukryć dysk współdzielony w widoku domyślnym, użyj metody hide w zasobie drives z parametrem driveId.

Gdy dysk współdzielony jest ukryty, Dysk oznacza zasób dysku współdzielonego jako hidden=true. Ukryte dyski współdzielone nie są widoczne w interfejsie Dysku ani na liście zwracanych plików.

Aby przywrócić dysk współdzielony do widoku domyślnego, użyj metody unhide w zasobie drives z parametrem driveId.

Obie metody zwracają dysk współdzielony jako instancję zasobu drives.

Usuwanie dysku współdzielonego

Aby trwale usunąć dysk współdzielony, użyj metody delete w zasobie drives z parametrem driveId.

Zanim usuniesz dysk współdzielony, cała jego zawartość musi zostać przeniesiona do kosza lub usunięta. Użytkownik musi też mieć role=organizer w folderze dysku współdzielonego. Więcej informacji znajdziesz w artykule Przenoszenie plików i folderów do kosza oraz ich usuwanie.

Aby filtrować dyski współdzielone, przekaż te parametry zapytania:

useDomainAdminAccess: ustaw na true, aby wysłać żądanie jako administrator domeny i zwrócić wszystkie dyski współdzielone w domenie, w której wysyłający jest administratorem. Więcej informacji znajdziesz w artykule Zarządzanie dyskami współdzielonymi jako administrator domeny.
allowItemDeletion: ustaw na true, aby usunąć elementy z dysku współdzielonego. Ta opcja jest obsługiwana tylko wtedy, gdy parametr useDomainAdminAccess jest ustawiony na true.

Dodawanie i usuwanie użytkowników dysku współdzielonego

Dodawaj i usuwaj użytkowników dysku współdzielonego za pomocą zasobu permissions.

Aby dodać użytkownika, utwórz uprawnienie na dysku współdzielonym. Metody uprawnień można też stosować do poszczególnych plików na dysku współdzielonym, aby przyznawać użytkownikom dodatkowe uprawnienia lub umożliwiać osobom spoza zespołu współpracę nad określonymi elementami.

Więcej informacji i przykłady kodu znajdziesz w artykule Udostępnianie plików, folderów i dysków.

Zarządzanie dyskami współdzielonymi jako administrator domeny

Aby zarządzać dyskami współdzielonymi w organizacji, użyj parametru useDomainAdminAccess z zasobami drives i permissions.

Użytkownicy wywołujący te metody z parametrem useDomainAdminAccess=true muszą mieć uprawnienia Drive and Docs administratora. Administratorzy mogą wyszukiwać dyski współdzielone lub aktualizować uprawnienia do dysków współdzielonych należących do ich organizacji, niezależnie od tego, czy są użytkownikami danego dysku współdzielonego.

Jeśli używasz kont usługi, może być konieczne podszywanie się pod uwierzytelnionego administratora za pomocą podszywania się pod konto usługi. Pamiętaj, że konta usługi nie należą do Twojej domeny Google Workspace, w przeciwieństwie do kont użytkowników. Jeśli udostępniasz zasoby Google Workspace, takie jak dokumenty czy wydarzenia, całej domenie Google Workspace, nie są one udostępniane kontom usługi. Więcej informacji znajdziesz w artykule Omówienie kont usługi.

Odzyskiwanie dysku współdzielonego, który nie ma organizatora

Poniższy przykład kodu pokazuje, jak odzyskać dyski współdzielone, które nie mają już organizatora.

Java

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

Wyświetl w GitHubie

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.DriveScopes;
import com.google.api.services.drive.model.Drive;
import com.google.api.services.drive.model.DriveList;
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 Drive's shared drive without an organizer. */
public class RecoverDrive {

  /**
   * Find all shared drives without an organizer and add one.
   *
   * @param realUser User's email id.
   * @return All shared drives without an organizer.
   * @throws IOException if shared drive not found.
   */
  public static List<Drive> recoverDrives(String realUser)
      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.*/
    GoogleCredentials credentials =
        GoogleCredentials.getApplicationDefault().createScoped(Arrays.asList(DriveScopes.DRIVE));
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

    // Build a new authorized API client service.
    com.google.api.services.drive.Drive service =
        new com.google.api.services.drive.Drive.Builder(new NetHttpTransport(),
            GsonFactory.getDefaultInstance(),
            requestInitializer)
            .setApplicationName("Drive samples")
            .build();
    List<Drive> drives = new ArrayList<Drive>();

    // Find all shared drives without an organizer and add one.
    // Note: This example does not capture all cases. Shared drives
    // that have an empty group as the sole organizer, or an
    // organizer outside the organization are not captured. A
    // more exhaustive approach would evaluate each shared drive
    // and the associated permissions and groups to ensure an active
    // organizer is assigned.
    String pageToken = null;
    Permission newOrganizerPermission = new Permission()
        .setType("user")
        .setRole("organizer");

    newOrganizerPermission.setEmailAddress(realUser);


    do {
      DriveList result = service.drives().list()
          .setQ("organizerCount = 0")
          .setFields("nextPageToken, drives(id, name)")
          .setUseDomainAdminAccess(true)
          .setPageToken(pageToken)
          .execute();
      for (Drive drive : result.getDrives()) {
        System.out.printf("Found drive without organizer: %s (%s)\n",
            drive.getName(), drive.getId());
        // Note: For improved efficiency, consider batching
        // permission insert requests
        Permission permissionResult = service.permissions()
            .create(drive.getId(), newOrganizerPermission)
            .setUseDomainAdminAccess(true)
            .setSupportsAllDrives(true)
            .setFields("id")
            .execute();
        System.out.printf("Added organizer permission: %s\n",
            permissionResult.getId());

      }

      drives.addAll(result.getDrives());

      pageToken = result.getNextPageToken();
    } while (pageToken != null);

    return drives;
  }
}

Python

drive/snippets/drive-v3/drive_snippet/recover_drives.py

Wyświetl w GitHubie

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


def recover_drives(real_user):
  """Find all shared drives without an organizer and add one.
  Args:
      real_user:User ID for the new organizer.
  Returns:
      drives object

  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)

    drives = []

    # pylint: disable=maybe-no-member
    page_token = None
    new_organizer_permission = {
        "type": "user",
        "role": "organizer",
        "emailAddress": "user@example.com",
    }
    new_organizer_permission["emailAddress"] = real_user

    while True:
      response = (
          service.drives()
          .list(
              q="organizerCount = 0",
              fields="nextPageToken, drives(id, name)",
              useDomainAdminAccess=True,
              pageToken=page_token,
          )
          .execute()
      )
      for drive in response.get("drives", []):
        print(
            "Found shared drive without organizer: "
            f"{drive.get('title')}, {drive.get('id')}"
        )
        permission = (
            service.permissions()
            .create(
                fileId=drive.get("id"),
                body=new_organizer_permission,
                useDomainAdminAccess=True,
                supportsAllDrives=True,
                fields="id",
            )
            .execute()
        )
        print(f'Added organizer permission: {permission.get("id")}')

      drives.extend(response.get("drives", []))
      page_token = response.get("nextPageToken", None)
      if page_token is None:
        break

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

  return drives


if __name__ == "__main__":
  recover_drives(real_user="gduser1@workspacesamples.dev")

Node.js

drive/snippets/drive_v3/drive_snippets/recover_drives.js

Wyświetl w GitHubie

import {GoogleAuth} from 'google-auth-library';
import {google} from 'googleapis';

/**
 * Finds all shared drives without an organizer and adds one.
 * @param {string} userEmail The email of the user to assign ownership to.
 * @return {Promise<object[]>} A list of the recovered drives.
 */
async function recoverDrives(userEmail) {
  // Authenticate with Google and get an authorized client.
  // TODO (developer): Use an appropriate auth mechanism for your app.
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });

  // Create a new Drive API client (v3).
  const service = google.drive({version: 'v3', auth});

  // The permission to add to the shared drive.
  const newOrganizerPermission = {
    type: 'user',
    role: 'organizer',
    emailAddress: userEmail, // e.g., 'user@example.com'
  };

  // List all shared drives with no organizers.
  const result = await service.drives.list({
    q: 'organizerCount = 0',
    fields: 'nextPageToken, drives(id, name)',
    useDomainAdminAccess: true,
  });

  // Add the new organizer to each found shared drive.
  for (const drive of result.data.drives ?? []) {
    if (!drive.id) {
      continue;
    }

    console.log('Found shared drive without organizer:', drive.name, drive.id);
    await service.permissions.create({
      requestBody: newOrganizerPermission,
      fileId: drive.id,
      useDomainAdminAccess: true,
      supportsAllDrives: true,
      fields: 'id',
    });
  }
  return result.data.drives ?? [];
}

PHP

drive/snippets/drive_v3/src/DriveRecoverDrives.php

Wyświetl w GitHubie

<?php
use Google\Client;
use Google\Service\Drive;
use Ramsey\Uuid\Uuid;
function recoverDrives()
{
   try {
    $client = new Client();
    $client->useApplicationDefaultCredentials();
    $client->addScope(Drive::DRIVE);
    $driveService = new Drive($client);

    $realUser = readline("Enter user email address: ");

    $drives = array();
    // Find all shared drives without an organizer and add one.
    // Note: This example does not capture all cases. Shared drives
    // that have an empty group as the sole organizer, or an
    // organizer outside the organization are not captured. A
    // more exhaustive approach would evaluate each shared drive
    // and the associated permissions and groups to ensure an active
    // organizer is assigned.
    $pageToken = null;
    $newOrganizerPermission = new Drive\Permission(array(
        'type' => 'user',
        'role' => 'organizer',
        'emailAddress' => 'user@example.com'
    ));
    $newOrganizerPermission['emailAddress'] = $realUser;
    do {
        $response = $driveService->drives->listDrives(array(
            'q' => 'organizerCount = 0',
            'fields' => 'nextPageToken, drives(id, name)',
            'useDomainAdminAccess' => true,
            'pageToken' => $pageToken
        ));
        foreach ($response->drives as $drive) {
            printf("Found shared drive without organizer: %s (%s)\n",
                $drive->name, $drive->id);
            $permission = $driveService->permissions->create($drive->id,
                $newOrganizerPermission,
                array(
                    'fields' => 'id',
                    'useDomainAdminAccess' => true,
                    'supportsAllDrives' => true
                ));
            printf("Added organizer permission: %s\n", $permission->id);
        }
        array_push($drives, $response->drives);
        $pageToken = $response->pageToken;
    } while ($pageToken != null);
    return $drives;
   } catch(Exception $e) {
      echo "Error Message: ".$e;
   }
}

.NET

drive/snippets/drive_v3/DriveV3Snippets/RecoverDrives.cs

Wyświetl w GitHubie

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

namespace DriveV3Snippets
{
    // Class to demonstrate use-case of Drive's shared drive without an organizer.
    public class RecoverDrives
    {
        /// <summary>
        /// Find all shared drives without an organizer and add one.
        /// </summary>
        /// <param name="realUser">User ID for the new organizer.</param>
        /// <returns>all shared drives without an organizer.</returns>
        public static IList<Drive> DriveRecoverDrives(string realUser)
        {
            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 drives = new List<Drive>();
                // Find all shared drives without an organizer and add one.
                // Note: This example does not capture all cases. Shared drives
                // that have an empty group as the sole organizer, or an
                // organizer outside the organization are not captured. A
                // more exhaustive approach would evaluate each shared drive
                // and the associated permissions and groups to ensure an active
                // organizer is assigned.
                string pageToken = null;
                var newOrganizerPermission = new Permission()
                {
                    Type = "user",
                    Role = "organizer",
                    EmailAddress = realUser
                };

                do
                {
                    var request = service.Drives.List();
                    request.UseDomainAdminAccess = true;
                    request.Q = "organizerCount = 0";
                    request.Fields = "nextPageToken, drives(id, name)";
                    request.PageToken = pageToken;
                    var result = request.Execute();
                    foreach (var drive in result.Drives)
                    {
                        Console.WriteLine(("Found abandoned shared drive: {0} ({1})",
                            drive.Name, drive.Id));
                        // Note: For improved efficiency, consider batching
                        // permission insert requests
                        var permissionRequest = service.Permissions.Create(
                            newOrganizerPermission,
                            drive.Id
                        );
                        permissionRequest.UseDomainAdminAccess = true;
                        permissionRequest.SupportsAllDrives = true;
                        permissionRequest.Fields = "id";
                        var permissionResult = permissionRequest.Execute();
                        Console.WriteLine("Added organizer permission: {0}", permissionResult.Id);
                    }

                    pageToken = result.NextPageToken;
                } while (pageToken != null);

                return drives;
            }
            catch (Exception e)
            {
                // TODO(developer) - handle error appropriately
                if (e is AggregateException)
                {
                    Console.WriteLine("Credential Not found");
                }
                else
                {
                    throw;
                }
            }
            return null;
        }
    }
}

Uniemożliwianie użytkownikom pobierania, drukowania i kopiowania Twojego pliku

Możesz ograniczyć sposób, w jaki użytkownicy mogą pobierać, drukować i kopiować pliki na dyskach współdzielonych.

Aby sprawdzić, czy użytkownik może zmienić ograniczenia pobierania zastosowane przez organizatora na dysku współdzielonym, sprawdź pole logiczne capabilities.canChangeDownloadRestriction. Jeśli pole capabilities.canChangeDownloadRestriction jest ustawione na true, można zastosować ograniczenia pobierania na dysku współdzielonym. Więcej informacji znajdziesz w artykule Omówienie możliwości plików.

Zasób drives zawiera zbiór pól logicznych restrictions, które wskazują, czy można wykonać działanie na dysku współdzielonym. Ograniczenia dotyczą dysku współdzielonego lub elementów na nim. Ograniczenia można ustawić za pomocą metody drives.update.

Aby zastosować ograniczenia pobierania na dysku współdzielonym, menedżer dysku współdzielonego może ustawić pole restrictions.downloadRestriction zasobu drives za pomocą DownloadRestriction obiektu. Ustawienie pola logicznego restrictedForReaders na true oznacza, że pobieranie i kopiowanie jest ograniczone dla czytelników. Ustawienie pola logicznego restrictedForWriters na true oznacza, że pobieranie i kopiowanie jest ograniczone dla osób z uprawnieniami do edycji. Pamiętaj, że jeśli pole restrictedForWriters ma wartość true, pobieranie i kopiowanie jest też ograniczone dla czytelników. Podobnie ustawienie pola restrictedForWriters na true i pola restrictedForReaders na false jest równoznaczne z ustawieniem obu pól restrictedForWriters i restrictedForReaders na true.

Zgodność wsteczna

Wraz z wprowadzeniem obiektu DownloadRestriction zaktualizowano funkcję pola logicznego restrictions.copyRequiresWriterPermission.

Teraz ustawienie restrictions.copyRequiresWriterPermission na true powoduje zaktualizowanie pola wartości logicznej restrictedForReaders obiektu DownloadRestriction na true, co oznacza, że pobieranie i kopiowanie jest ograniczone dla czytelników.

Ustawienie pola copyRequiresWriterPermission na false powoduje zaktualizowanie pól restrictedForWriters i restrictedForReaders na false. Oznacza to, że ustawienia ograniczeń pobierania i kopiowania są usuwane dla wszystkich użytkowników.

Ostrzeżenie:do ustawiania ograniczeń pobierania, drukowania i kopiowania należy używać tylko starszego pola lub obiektu .copyRequiresWriterPermissionDownloadRestriction Nie należy używać tych pól razem, ponieważ ich wartości mogą być sprzeczne.

Pola, które kontrolują funkcje pobierania, drukowania i kopiowania

W tabeli poniżej znajdziesz listę pól zasobu drives które wpływają na funkcje pobierania, drukowania i kopiowania:

Pole	Opis	Wersja
`capabilities.canCopy`	Czy bieżący użytkownik może kopiować pliki na dysku współdzielonym.	v2 i v3
`capabilities.canDownload`	Czy bieżący użytkownik może pobierać pliki na dysku współdzielonym.	v2 i v3
`capabilities.canChangeCopyRequiresWriterPermission`	Czy bieżący użytkownik może zmienić ograniczenie `copyRequiresWriterPermission` na dysku współdzielonym.	v2 i v3
`capabilities.canResetDriveRestrictions`	Czy bieżący użytkownik może przywrócić domyślne ograniczenia dysku współdzielonego.	v2 i v3
`capabilities.canChangeDownloadRestriction`	Czy bieżący użytkownik może zmienić ograniczenie pobierania na dysku współdzielonym.	Tylko v3
`restrictions.copyRequiresWriterPermission`	Czy opcje kopiowania, drukowania i pobierania plików na dysku współdzielonym są wyłączone dla czytelników i komentujących. Gdy wartość tego pola to `true`, dla każdego pliku na tym dysku współdzielonym ustawia się pole o tej samej nazwie na `true`.	v2 i v3
`restrictions.downloadRestriction`	Ograniczenia pobierania zastosowane przez menedżerów dysku współdzielonego.	Tylko v3

Limity folderów

Foldery na dyskach współdzielonych mają pewne limity miejsca na dane. Więcej informacji znajdziesz w artykule Limity dotyczące dysków współdzielonych na Dysku Google.

Limit elementów

Każdy dysk współdzielony użytkownika ma limit 500 tys. elementów, w tym plików, folderów i skrótów.

Po osiągnięciu limitu dysk współdzielony nie może już przyjmować elementów. Aby wznowić odbieranie plików, użytkownicy muszą trwale usunąć elementy z dysku współdzielonego. Pamiętaj, że elementy w koszu są wliczane do limitu, ale elementy trwale usunięte nie. Więcej informacji znajdziesz w artykule Przenoszenie plików i folderów do kosza oraz ich usuwanie.

Limit głębokości folderu

Folder na dysku współdzielonym nie może zawierać więcej niż 100 poziomów zagnieżdżonych folderów. Oznacza to, że folder podrzędny nie może być przechowywany w folderze, który jest zagnieżdżony na więcej niż 99 poziomach. To ograniczenie dotyczy tylko folderów podrzędnych.

Próby dodania więcej niż 100 poziomów folderów powodują zwrócenie teamDriveHierarchyTooDeep kodu stanu HTTP.

Zarządzaj dyskami współdzielonymi Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Tworzenie dysku współdzielonego

Java

Python

Node.js

PHP

.NET

Pobieranie dysku współdzielonego

Wyświetlanie listy dysków współdzielonych

Aktualizowanie dysku współdzielonego

Ukrywanie i odkrywanie dysku współdzielonego

Usuwanie dysku współdzielonego

Dodawanie i usuwanie użytkowników dysku współdzielonego

Zarządzanie dyskami współdzielonymi jako administrator domeny

Odzyskiwanie dysku współdzielonego, który nie ma organizatora

Java

Python

Node.js

PHP

.NET

Uniemożliwianie użytkownikom pobierania, drukowania i kopiowania Twojego pliku

Zgodność wsteczna

Pola, które kontrolują funkcje pobierania, drukowania i kopiowania

Limity folderów

Limit elementów

Limit głębokości folderu

Powiązane artykuły

Zarządzaj dyskami współdzielonymi