शेयर की गई ड्राइव मैनेज करें

इस गाइड में, Google Drive API का इस्तेमाल करके शेयर की गई ड्राइव को मैनेज करने से जुड़े टास्क के बारे में बताया गया है. जैसे, शेयर की गई ड्राइव बनाना, सदस्यों और अनुमतियों को मैनेज करना.

शेयर की गई ड्राइव में फ़ोल्डर की सीमाओं के बारे में ज़्यादा जानने के लिए, फ़ोल्डर की सीमाएं लेख पढ़ें.

शेयर की गई ड्राइव बनाना

शेयर की गई ड्राइव बनाने के लिए, drives.create तरीके का इस्तेमाल करें.

Java

drive/snippets/drive_v3/src/main/java/CreateDrive.java
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
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
/**
 * Create a drive.
 * */
async function createDrive() {
  // Get credentials and build service
  // TODO (developer) - Use appropriate auth mechanism for your app

  const {GoogleAuth} = require('google-auth-library');
  const {google} = require('googleapis');
  const uuid = require('uuid');

  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });
  const service = google.drive({version: 'v3', auth});

  const driveMetadata = {
    name: 'Project resources',
  };
  const requestId = uuid.v4();
  try {
    const Drive = await service.drives.create({
      resource: driveMetadata,
      requestId: requestId,
      fields: 'id',
    });
    console.log('Drive Id:', Drive.data.id);
    return Drive.data.id;
  } catch (err) {
    // TODO(developer) - Handle error
    throw err;
  }
}

PHP

drive/snippets/drive_v3/src/DriveCreateDrive.php
<?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
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;
        }
    }
}

drives.create तरीके को कॉल करने पर, एक ही नतीजा मिलता है.

requestId पैरामीटर, शेयर की गई ड्राइव बनाने के तार्किक तरीके की पहचान करता है. अगर अनुरोध करने की समयसीमा खत्म हो जाती है या बैकएंड में कोई गड़बड़ी होती है, तो उसी अनुरोध को फिर से भेजा जा सकता है. अनुरोध का requestId और मुख्य हिस्सा एक जैसा होना चाहिए.

अगर पिछली बार किए गए अनुरोध या फिर से कोशिश करने पर, शेयर की गई ड्राइव बन गई है, तो सामान्य जवाब मिलता है. कभी-कभी, जैसे कि लंबे समय के बाद या अनुरोध के मुख्य हिस्से में बदलाव होने पर, 409 गड़बड़ी दिख सकती है. इससे पता चलता है कि requestId को खारिज कर दिया जाना चाहिए.

शेयर की गई ड्राइव के सदस्यों को जोड़ना या हटाना

permissions रिसॉर्स का इस्तेमाल करके, शेयर की गई ड्राइव के सदस्यों को जोड़ें या हटाएं.

किसी सदस्य को जोड़ने के लिए, शेयर की गई ड्राइव पर अनुमति बनाएं. अनुमति देने के तरीकों का इस्तेमाल, शेयर की गई ड्राइव में मौजूद अलग-अलग फ़ाइलों पर भी किया जा सकता है. इससे सदस्यों को अतिरिक्त सुविधाएं दी जा सकती हैं या उन लोगों को कुछ आइटम पर मिलकर काम करने की अनुमति दी जा सकती है जो सदस्य नहीं हैं.

ज़्यादा जानकारी और सैंपल कोड के लिए, फ़ाइलें, फ़ोल्डर, और ड्राइव शेयर करना लेख पढ़ें.

शेयर की गई ड्राइव मिटाना

शेयर की गई ड्राइव मिटाने के लिए, drives.delete तरीके का इस्तेमाल करें. शेयर की गई ड्राइव को मिटाने से पहले, उसमें मौजूद सारा कॉन्टेंट ट्रैश में ले जाना या मिटाना ज़रूरी है.

डोमेन एडमिन के लिए शेयर की गई ड्राइव मैनेज करना

किसी संगठन में शेयर की गई ड्राइव को मैनेज करने के लिए, drives और permissions संसाधनों के साथ useDomainAdminAccess पैरामीटर लागू करें.

useDomainAdminAccess=true के साथ इन तरीकों को कॉल करने वाले उपयोगकर्ताओं के पास, Drive and Docs एडमिन के खास अधिकार होने चाहिए. एडमिन, शेयर की गई ड्राइव खोज सकते हैं. इसके अलावा, वे अपने संगठन के मालिकाना हक वाली शेयर की गई ड्राइव के लिए अनुमतियां अपडेट कर सकते हैं. भले ही, एडमिन किसी शेयर की गई ड्राइव का सदस्य हो या न हो.

ऐसी शेयर की गई ड्राइव को वापस लाना जिसका कोई आयोजक नहीं है

यहां दिए गए उदाहरण में, उन शेयर की गई ड्राइव को वापस पाने का तरीका बताया गया है जिनके लिए अब कोई आयोजक नहीं है.

Java

drive/snippets/drive_v3/src/main/java/RecoverDrive.java
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
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
/**
 * Find all shared drives without an organizer and add one.
 * @param{string} userEmail user ID to assign ownership to
 * */
async function recoverDrives(userEmail) {
  // Get credentials and build service
  // TODO (developer) - Use appropriate auth mechanism for your app

  const {GoogleAuth} = require('google-auth-library');
  const {google} = require('googleapis');

  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });
  const service = google.drive({version: 'v3', auth});
  const drives = [];
  const newOrganizerPermission = {
    type: 'user',
    role: 'organizer',
    emailAddress: userEmail, // Example: 'user@example.com'
  };

  let pageToken = null;
  try {
    const res = await service.drives.list({
      q: 'organizerCount = 0',
      fields: 'nextPageToken, drives(id, name)',
      useDomainAdminAccess: true,
      pageToken: pageToken,
    });
    Array.prototype.push.apply(drives, res.data.items);
    for (const drive of res.data.drives) {
      console.log(
          'Found shared drive without organizer:',
          drive.name,
          drive.id,
      );
      await service.permissions.create({
        resource: newOrganizerPermission,
        fileId: drive.id,
        useDomainAdminAccess: true,
        supportsAllDrives: true,
        fields: 'id',
      });
    }
    pageToken = res.nextPageToken;
  } catch (err) {
    // TODO(developer) - Handle error
    throw err;
  }
  return drives;
}

PHP

drive/snippets/drive_v3/src/DriveRecoverDrives.php
<?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
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;
        }
    }
}

लोगों को, आपकी फ़ाइल डाउनलोड करने, प्रिंट करने या उसे कॉपी करने से रोकना

आपके पास यह तय करने का विकल्प होता है कि शेयर की गई ड्राइव में, उपयोगकर्ता फ़ाइलों को किस तरह डाउनलोड, प्रिंट, और कॉपी कर सकते हैं.

यह तय करने के लिए कि उपयोगकर्ता, शेयर की गई ड्राइव के आयोजक की ओर से लगाई गई डाउनलोड करने की पाबंदियों में बदलाव कर सकता है या नहीं, capabilities.canChangeDownloadRestriction बूलियन फ़ील्ड देखें. अगर capabilities.canChangeDownloadRestriction को true पर सेट किया जाता है, तो शेयर की गई ड्राइव पर डाउनलोड करने से जुड़ी पाबंदियां लागू की जा सकती हैं. ज़्यादा जानकारी के लिए, फ़ाइल की सुविधाओं के बारे में जानकारी लेख पढ़ें.

drives रिसॉर्स में, बूलियन restrictions फ़ील्ड का कलेक्शन होता है. इनका इस्तेमाल यह बताने के लिए किया जाता है कि शेयर की गई ड्राइव पर कोई कार्रवाई की जा सकती है या नहीं. पाबंदियां, शेयर की गई ड्राइव या शेयर की गई ड्राइव में मौजूद आइटम पर लागू होती हैं. drives.update तरीके का इस्तेमाल करके पाबंदियां सेट की जा सकती हैं.

शेयर की गई ड्राइव में मौजूद फ़ाइलों को डाउनलोड करने पर पाबंदियां लगाने के लिए, शेयर की गई ड्राइव का मैनेजर DownloadRestriction ऑब्जेक्ट का इस्तेमाल करके, drives रिसॉर्स के restrictions.downloadRestriction फ़ील्ड को सेट कर सकता है. restrictedForReaders बूलियन फ़ील्ड को true पर सेट करने का मतलब है कि ऑडियंस में शामिल लोगों के लिए, डाउनलोड और कॉपी करने की सुविधा पर पाबंदी है. restrictedForWriters बूलियन फ़ील्ड को true पर सेट करने का मतलब है कि लेखकों के लिए, डाउनलोड और कॉपी, दोनों पर पाबंदी है. ध्यान दें कि अगर restrictedForWriters फ़ील्ड true पर सेट है, तो पढ़ने वालों के लिए भी डाउनलोड करने और कॉपी करने की सुविधा उपलब्ध नहीं होती. इसी तरह, restrictedForWriters को true पर और restrictedForReaders को false पर सेट करने का मतलब है कि restrictedForWriters और restrictedForReaders, दोनों को true पर सेट किया गया है.

पिछले वर्शन के गेम खेलने की सुविधा

DownloadRestriction ऑब्जेक्ट के लॉन्च होने के बाद, restrictions.copyRequiresWriterPermission बूलियन फ़ील्ड की सुविधा को अपडेट कर दिया गया है.

अब restrictions.copyRequiresWriterPermission को true पर सेट करने से, DownloadRestriction ऑब्जेक्ट के restrictedForReaders बूलियन फ़ील्ड को true पर अपडेट किया जाता है. इससे यह पता चलता है कि पढ़ने वालों के लिए, डाउनलोड और कॉपी, दोनों पर पाबंदी है.

copyRequiresWriterPermission फ़ील्ड को false पर सेट करने से, restrictedForWriters और restrictedForReaders, दोनों फ़ील्ड false पर अपडेट हो जाते हैं. इसका मतलब है कि सभी उपयोगकर्ताओं के लिए, डाउनलोड करने या कॉपी करने से जुड़ी पाबंदी की सेटिंग हटा दी जाती हैं.

डाउनलोड, प्रिंट, और कॉपी करने की सुविधाओं को कंट्रोल करने वाले फ़ील्ड

नीचे दी गई टेबल में, drives संसाधन फ़ील्ड दिए गए हैं. इनसे डाउनलोड, प्रिंट, और कॉपी करने की सुविधा पर असर पड़ता है:

फ़ील्ड ब्यौरा वर्शन
capabilities.canCopy इससे पता चलता है कि मौजूदा उपयोगकर्ता, शेयर की गई ड्राइव में मौजूद फ़ाइलों को कॉपी कर सकता है या नहीं. v2 और v3
capabilities.canDownload इससे पता चलता है कि मौजूदा उपयोगकर्ता, शेयर की गई ड्राइव में मौजूद फ़ाइलें डाउनलोड कर सकता है या नहीं. v2 और v3
capabilities.canChangeCopyRequiresWriterPermission इससे पता चलता है कि मौजूदा उपयोगकर्ता, शेयर की गई ड्राइव की copyRequiresWriterPermission पाबंदी में बदलाव कर सकता है या नहीं. v2 और v3
capabilities.canResetDriveRestrictions इससे पता चलता है कि मौजूदा उपयोगकर्ता, शेयर की गई ड्राइव पर लगाई गई पाबंदियों को डिफ़ॉल्ट सेटिंग पर रीसेट कर सकता है या नहीं. v2 और v3
capabilities.canChangeDownloadRestriction यह कुकी यह तय करती है कि मौजूदा उपयोगकर्ता, शेयर की गई ड्राइव के लिए डाउनलोड करने से जुड़ी पाबंदी में बदलाव कर सकता है या नहीं. सिर्फ़ v3
restrictions.copyRequiresWriterPermission इससे पता चलता है कि शेयर की गई ड्राइव में मौजूद फ़ाइलों को कॉपी, प्रिंट या डाउनलोड करने के विकल्प, पढ़ने और टिप्पणी करने वाले लोगों के लिए बंद हैं या नहीं. true होने पर, यह शेयर की गई ड्राइव में मौजूद किसी भी फ़ाइल के लिए, इसी नाम वाले फ़ील्ड को true पर सेट कर देता है. v2 और v3
restrictions.downloadRestriction शेयर की गई ड्राइव के मैनेजर की ओर से, डाउनलोड करने से जुड़ी पाबंदियां लागू की गई हैं. सिर्फ़ v3

फ़ोल्डर की सीमाएं

शेयर की गई ड्राइव के फ़ोल्डर के लिए, स्टोरेज की कुछ सीमाएं होती हैं. ज़्यादा जानकारी के लिए, Google Drive में शेयर की गई ड्राइव की सीमाएं लेख पढ़ें.

आइटम की सीमा

किसी उपयोगकर्ता की शेयर की गई ड्राइव के हर फ़ोल्डर में ज़्यादा से ज़्यादा 5,00, 000 आइटम हो सकते हैं. इनमें फ़ाइलें, फ़ोल्डर, और शॉर्टकट शामिल हैं.

सीमा पूरी होने के बाद, शेयर की गई ड्राइव में और आइटम नहीं जोड़े जा सकते. फ़ाइलें वापस पाने के लिए, उपयोगकर्ताओं को फ़ोल्डर से आइटम हमेशा के लिए मिटाने होंगे. ध्यान दें कि ट्रैश में मौजूद आइटम, सीमा में गिने जाते हैं. हालांकि, हमेशा के लिए मिटाए गए आइटम नहीं गिने जाते. ज़्यादा जानकारी के लिए, फ़ाइलों और फ़ोल्डर को ट्रैश में डालना या मिटाना लेख पढ़ें.

फ़ोल्डर के लेवल की सीमा

शेयर की गई ड्राइव में मौजूद किसी फ़ोल्डर में 100 से ज़्यादा लेवल के नेस्ट किए गए फ़ोल्डर नहीं हो सकते. इसका मतलब है कि किसी चाइल्ड फ़ोल्डर को ऐसे फ़ोल्डर में सेव नहीं किया जा सकता जो 99 लेवल से ज़्यादा डीप हो. यह पाबंदी सिर्फ़ चाइल्ड फ़ोल्डर पर लागू होती है.

100 से ज़्यादा लेवल के फ़ोल्डर जोड़ने की कोशिश करने पर, teamDriveHierarchyTooDeep एचटीटीपी स्टेटस कोड रिस्पॉन्स मिलता है.