फ़ाइलें और फ़ोल्डर खोजना

इस गाइड में, Google Drive API की मदद से फ़ाइलों और फ़ोल्डर को खोजने के अलग-अलग तरीकों के बारे में बताया गया है.

Drive के किसी उपयोगकर्ता की सभी या कुछ फ़ाइलें और फ़ोल्डर देखने के लिए, files संसाधन पर list तरीके का इस्तेमाल किया जा सकता है. list तरीके का इस्तेमाल करके, fileId भी पाया जा सकता है. इसकी ज़रूरत कुछ संसाधन के तरीकों (जैसे कि get और update तरीकों) के लिए होती है.

fields पैरामीटर का इस्तेमाल करना

अगर आपको जवाब में दिखाए जाने वाले फ़ील्ड तय करने हैं, तो fields सिस्टम पैरामीटर को files संसाधन के किसी भी तरीके के साथ सेट किया जा सकता है. अगर fields पैरामीटर को शामिल नहीं किया जाता है, तो सर्वर, तरीके के हिसाब से फ़ील्ड का डिफ़ॉल्ट सेट दिखाता है. उदाहरण के लिए, list तरीका, हर फ़ाइल के लिए सिर्फ़ kind, id, name, mimeType, और resourceKey फ़ील्ड दिखाता है. अलग-अलग फ़ील्ड देखने के लिए, खास फ़ील्ड देखना लेख पढ़ें.

आईडी के हिसाब से कोई फ़ाइल पाना

किसी फ़ाइल को पाने के लिए, get तरीके का इस्तेमाल करें. इसके साथ, files fileId पाथ पैरामीटर का इस्तेमाल करें. अगर आपको फ़ाइल का आईडी नहीं पता है, तो सभी फ़ाइलें देखी जा सकती हैं list तरीके का इस्तेमाल करके.

यह तरीका, फ़ाइल को files संसाधन के इंस्टेंस के तौर पर दिखाता है. अगर alt=media पैरामीटर दिया जाता है, तो जवाब के मुख्य हिस्से में फ़ाइल का कॉन्टेंट शामिल होता है. ब्लॉब फ़ाइल डाउनलोड करने के लिए, ब्लॉब फ़ाइल का कॉन्टेंट डाउनलोड करना लेख पढ़ें.

मालवेयर या अन्य आपत्तिजनक फ़ाइलों को डाउनलोड करने के जोखिम को स्वीकार करने के लिए, acknowledgeAbuse क्वेरी पैरामीटर को true पर सेट करें. यह फ़ील्ड सिर्फ़ तब लागू होता है, जब alt=media पैरामीटर सेट किया गया हो और उपयोगकर्ता, फ़ाइल का मालिक हो या शेयर की गई ड्राइव का ऑर्गनाइज़र हो, जिसमें फ़ाइल मौजूद है.

'मेरी ड्राइव' में मौजूद सभी फ़ाइलें और फ़ोल्डर देखना

मौजूदा उपयोगकर्ता की 'मेरी ड्राइव' में मौजूद सभी फ़ाइलें और फ़ोल्डर देखने के लिए, बिना किसी पैरामीटर के list तरीके का इस्तेमाल करें.

यहां दिए गए curl कमांड से पता चलता है कि सभी फ़ाइलें कैसे देखी जाती हैं:

curl -X GET \
  'https://www.googleapis.com/drive/v3/files' \
  -H 'Authorization: Bearer ACCESS_TOKEN' \
  -H 'Accept: application/json'

ACCESS_TOKEN की जगह, अनुमति वाला OAuth 2.0 ऐक्सेस टोकन डालें.

'मेरी ड्राइव' में मौजूद खास फ़ाइलें और फ़ोल्डर खोजना

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

क्वेरी स्ट्रिंग के सिंटैक्स में ये तीन हिस्से होते हैं:

query_term operator values

कहां:

• query_term वह क्वेरी टर्म या फ़ील्ड है जिसे खोजना है.

• operator क्वेरी टर्म के लिए, कंडिशन तय करता है.

• values वे खास वैल्यू हैं जिनका इस्तेमाल करके, खोज के नतीजों को फ़िल्टर करना है.

उदाहरण के लिए, यहां दी गई क्वेरी स्ट्रिंग, MIME टाइप सेट करके खोज को सिर्फ़ फ़ोल्डर दिखाने के लिए फ़िल्टर करती है:

mimeType = 'application/vnd.google-apps.folder'

फ़ाइल की क्वेरी की सभी शर्तें देखने के लिए, फ़ाइल की क्वेरी की शर्तें देखें.

क्वेरी बनाने के लिए इस्तेमाल किए जा सकने वाले सभी क्वेरी ऑपरेटर देखने के लिए, क्वेरी ऑपरेटर देखें.

क्वेरी स्ट्रिंग के उदाहरण

यहां दी गई टेबल में, कुछ बुनियादी क्वेरी स्ट्रिंग के उदाहरण दिए गए हैं. खोज के लिए इस्तेमाल की जाने वाली क्लाइंट लाइब्रेरी के हिसाब से, असल कोड अलग-अलग होता है.

यह भी ज़रूरी है कि फ़ाइल के नामों में मौजूद खास वर्णों को एस्केप किया जाए, ताकि क्वेरी सही तरीके से काम करे. उदाहरण के लिए, अगर किसी फ़ाइल के नाम में ऐपोस्ट्रॉफ़ी (') और बैकस्लैश ("\") दोनों वर्ण शामिल हैं, तो उन्हें एस्केप करने के लिए बैकस्लैश का इस्तेमाल करें: name contains 'quinn\'s paper\\essay'.

क्लाइंट लाइब्रेरी की मदद से, खोज के नतीजों को फ़िल्टर करना

यहां दिए गए कोड सैंपल में, क्लाइंट लाइब्रेरी का इस्तेमाल करके, खोज के नतीजों को JPEG फ़ाइलों के नामों और आईडी के हिसाब से फ़िल्टर करने का तरीका बताया गया है. इस सैंपल में, नतीजों को image/jpeg टाइप की फ़ाइलों तक सीमित करने के लिए, mimeType क्वेरी टर्म का इस्तेमाल किया गया है. इसमें, खोज को Drive space तक सीमित करने के लिए, spaces को drive पर भी सेट किया गया है. जब nextPageToken की वैल्यू null होती है, तो इसका मतलब है कि अब कोई नतीजा नहीं है.

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.File;
import com.google.api.services.drive.model.FileList;
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 search files. */
public class SearchFile {

  /**
   * Search for specific set of files.
   *
   * @return search result list.
   * @throws IOException if service account credentials file not found.
   */
  public static List<File> searchFile() 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_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();

    List<File> files = new ArrayList<File>();

    String pageToken = null;
    do {
      FileList result = service.files().list()
          .setQ("mimeType='image/jpeg'")
          .setSpaces("drive")
          .setFields("nextPageToken, files(id, title)")
          .setPageToken(pageToken)
          .execute();
      for (File file : result.getFiles()) {
        System.out.printf("Found file: %s (%s)\n",
            file.getName(), file.getId());
      }

      files.addAll(result.getFiles());

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

    return files;
  }
}

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


def search_file():
  """Search file in drive location

  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)
    files = []
    page_token = None
    while True:
      # pylint: disable=maybe-no-member
      response = (
          service.files()
          .list(
              q="mimeType='image/jpeg'",
              spaces="drive",
              fields="nextPageToken, files(id, name)",
              pageToken=page_token,
          )
          .execute()
      )
      for file in response.get("files", []):
        # Process change
        print(f'Found file: {file.get("name")}, {file.get("id")}')
      files.extend(response.get("files", []))
      page_token = response.get("nextPageToken", None)
      if page_token is None:
        break

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

  return files


if __name__ == "__main__":
  search_file()

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

/**
 * Searches for files in Google Drive.
 * @return {Promise<object[]>} A list of files.
 */
async function searchFile() {
  // 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});

  // Search for files with the specified query.
  const result = await service.files.list({
    q: "mimeType='image/jpeg'",
    fields: 'nextPageToken, files(id, name)',
    spaces: 'drive',
  });

  // Print the name and ID of each found file.
  (result.data.files ?? []).forEach((file) => {
    console.log('Found file:', file.name, file.id);
  });

  return result.data.files ?? [];
}

<?php
use Google\Client;
use Google\Service\Drive;
function searchFiles()
{
    try {
        $client = new Client();
        $client->useApplicationDefaultCredentials();
        $client->addScope(Drive::DRIVE);
        $driveService = new Drive($client);
        $files = array();
        $pageToken = null;
        do {
            $response = $driveService->files->listFiles(array(
                'q' => "mimeType='image/jpeg'",
                'spaces' => 'drive',
                'pageToken' => $pageToken,
                'fields' => 'nextPageToken, files(id, name)',
            ));
            foreach ($response->files as $file) {
                printf("Found file: %s (%s)\n", $file->name, $file->id);
            }
            array_push($files, $response->files);

            $pageToken = $response->pageToken;
        } while ($pageToken != null);
        return $files;
    } catch(Exception $e) {
       echo "Error Message: ".$e;
    }
}

पब्लिक फ़ोल्डर में मौजूद फ़ाइलें देखना

पब्लिक तौर पर शेयर किए गए फ़ोल्डर में मौजूद फ़ाइलों को खोजने या देखने के लिए, files संसाधन पर list तरीके का इस्तेमाल करें. साथ ही, q क्वेरी पैरामीटर को सेट करके, parents कलेक्शन में फ़ोल्डर के आईडी के हिसाब से फ़िल्टर करें. यहां, ऐक्सेस "लिंक वाले किसी भी व्यक्ति" या "वेब पर सार्वजनिक" पर सेट होता है:

'FOLDER_ID' in parents and trashed = false

पब्लिक फ़ोल्डर में मौजूद फ़ाइलें देखते समय, OAuth 2.0 उपयोगकर्ता क्रेडेंशियल के बजाय, एपीआई पासकोड का इस्तेमाल करके अनुरोधों की पुष्टि की जा सकती है. अगर फ़ोल्डर, शेयर की गई ड्राइव में मौजूद है, तो अनुरोध पर supportsAllDrives=true और includeItemsFromAllDrives=true भी सेट करना होगा.

यहां दिए गए कोड सैंपल में, पब्लिक फ़ोल्डर में मौजूद फ़ाइलें देखने का तरीका बताया गया है:

/**
 * List files in a public folder using an API key.
 * @param {string} folderId The ID of the public folder.
 * @param {string} apiKey Your Google Cloud API key.
 * @return {Promise<Array>} The list of files.
 */
async function listPublicFolder(folderId, apiKey) {
  const {google} = require('googleapis');
  const service = google.drive({version: 'v3', auth: apiKey});

  try {
    const response = await service.files.list({
      q: `'${folderId}' in parents and trashed = false`,
      fields: 'nextPageToken, files(id, name, mimeType)',
      supportsAllDrives: true,
      includeItemsFromAllDrives: true,
    });
    const files = response.data.files;
    console.log('Files:');
    for (const file of files) {
      console.log(`${file.name} (${file.id})`);
    }
    return files;
  } catch (err) {
    // TODO(developer): Handle error
    console.error(err);
  }
}

curl -G \
  'https://www.googleapis.com/drive/v3/files' \
  --data-urlencode "q='FOLDER_ID' in parents and trashed = false" \
  --data-urlencode 'supportsAllDrives=true' \
  --data-urlencode 'includeItemsFromAllDrives=true' \
  --data-urlencode 'fields=nextPageToken,files(id,name,mimeType)' \
  --data-urlencode 'key=API_KEY' \
  -H 'Accept: application/json'

सब-फ़ोल्डर और फ़ाइलें, बार-बार खोजें

parents क्वेरी टर्म से, सिर्फ़ वे डायरेक्ट चाइल्ड फ़ाइलें और फ़ोल्डर दिखते हैं जो दिए गए फ़ोल्डर में मौजूद हैं. Drive API में, एपीआई कॉल करके, सब-फ़ोल्डर के ट्री को बार-बार खोजने के लिए, कोई क्वेरी ऑपरेटर या पैरामीटर उपलब्ध नहीं है.

किसी फ़ोल्डर और उसके सभी सब-फ़ोल्डर और फ़ाइलों को खोजने के लिए, आपके ऐप्लिकेशन को क्लाइंट-साइड ट्री ट्रैवर्सल करना होगा:

1. टारगेट फ़ोल्डर के डायरेक्ट चाइल्ड की क्वेरी करने के लिए 'FOLDER_ID' in parents and trashed = false का इस्तेमाल करें.
2. उन नतीजों को फ़िल्टर करके सब-फ़ोल्डर की पहचान करें जहां mimeType = 'application/vnd.google-apps.folder' है.
3. उसका कॉन्टेंट पाने के लिए, हर चाइल्ड फ़ोल्डर के आईडी की क्वेरी बार-बार या बार-बार करें.

यहां दिए गए कोड सैंपल में, किसी फ़ोल्डर और उसके सब-फ़ोल्डर को बार-बार खोजने का तरीका बताया गया है:

/**
 * Recursively searches a folder and all descendant subfolders for files.
 * @param {string} folderId The ID of the starting folder.
 * @param {Object} authClient An authorized OAuth 2.0 client.
 * @return {Promise<Array>} The list of all descendant files.
 */
async function searchFolderRecursively(folderId, authClient) {
  const {google} = require('googleapis');
  const service = google.drive({version: 'v3', auth: authClient});
  const allFiles = [];
  const foldersToSearch = [folderId];

  try {
    while (foldersToSearch.length > 0) {
      const currentFolderId = foldersToSearch.pop();
      let pageToken = null;

      do {
        const response = await service.files.list({
          q: `'${currentFolderId}' in parents and trashed = false`,
          fields: 'nextPageToken, files(id, name, mimeType)',
          pageSize: 1000,
          supportsAllDrives: true,
          includeItemsFromAllDrives: true,
          pageToken: pageToken,
        });

        const files = response.data.files || [];
        for (const file of files) {
          if (file.mimeType === 'application/vnd.google-apps.folder') {
            foldersToSearch.push(file.id);
          } else {
            allFiles.push(file);
          }
        }

        pageToken = response.data.nextPageToken;
      } while (pageToken);
    }
    return allFiles;
  } catch (err) {
    // TODO(developer): Handle error
    console.error(err);
    throw err;
  }
}

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

def search_folder_recursively(folder_id, creds):
    """Recursively searches a folder and all descendant subfolders for
    files.

    Args:
        folder_id: The ID of the starting folder.
        creds: An authorized OAuth 2.0 credentials object.

    Returns:
        A list of all descendant file resources.
    """
    service = build("drive", "v3", credentials=creds)
    all_files = []
    folders_to_search = [folder_id]

    try:
        while folders_to_search:
            current_folder_id = folders_to_search.pop()
            page_token = None

            while True:
                response = (
                    service.files()
                    .list(
                        q=f"'{current_folder_id}' in parents and trashed = false",
                        fields="nextPageToken, files(id, name, mimeType)",
                        pageSize=1000,
                        supportsAllDrives=True,
                        includeItemsFromAllDrives=True,
                        pageToken=page_token,
                    )
                    .execute()
                )

                for item in response.get("files", []):
                    if (
                        item.get("mimeType")
                        == "application/vnd.google-apps.folder"
                    ):
                        folders_to_search.append(item.get("id"))
                    else:
                        all_files.append(item)

                page_token = response.get("nextPageToken")
                if not page_token:
                    break

        return all_files
    except HttpError as error:
        # TODO(developer): Handle error
        print(f"An error occurred: {error}")
        return None

कस्टम प्रॉपर्टी वाली फ़ाइलें खोजना

फ़ाइल की किसी कस्टम प्रॉपर्टी वाली फ़ाइलें खोजने के लिए, कुंजी और वैल्यू के साथ properties या appProperties खोज क्वेरी टर्म का इस्तेमाल करें. उदाहरण के लिए, additionalID नाम की फ़ाइल की किसी ऐसी कस्टम प्रॉपर्टी को खोजने के लिए जो अनुरोध करने वाले ऐप्लिकेशन के लिए निजी है और जिसकी वैल्यू 8e8aceg2af2ge72e78 है:

appProperties has { key='additionalID' and value='8e8aceg2af2ge72e78' }

ज़्यादा जानकारी के लिए, फ़ाइल की कस्टम प्रॉपर्टी जोड़ना लेख पढ़ें.

लेबल या फ़ील्ड की वैल्यू के हिसाब से फ़ाइलें खोजना

खास लेबल वाली फ़ाइलें खोजने के लिए, labels सर्च क्वेरी टर्म का इस्तेमाल करें. इसके साथ, लेबल का आईडी भी शामिल करें.

वे फ़ाइलें खोजने के लिए जिन पर कोई खास लेबल लागू किया गया है:

'labels/LABEL_ID' in labels

वे फ़ाइलें खोजने के लिए जिन पर कोई खास लेबल लागू नहीं किया गया है:

not 'labels/LABEL_ID' in labels

किसी खास लेबल फ़ील्ड की वैल्यू के आधार पर फ़ाइलें खोजने के लिए:

labels/LABEL_ID.FIELD_ID = 'VALUE'

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

कॉर्पोरा में खोज करना

डिफ़ॉल्ट रूप से, user आइटम कलेक्शन, corpora क्वेरी पैरामीटर पर सेट होता है, जब list तरीका इस्तेमाल किया जाता है. आइटम के अन्य कलेक्शन खोजने के लिए, जैसे कि domain के साथ शेयर किए गए कलेक्शन, आपको corpora पैरामीटर को साफ़ तौर पर सेट करना होगा.

एक क्वेरी में, एक से ज़्यादा कॉर्पोरा खोजे जा सकते हैं. हालांकि, अगर मिलाया गया कॉर्पोरा बहुत बड़ा है, तो एपीआई, अधूरे नतीजे दिखा सकता है. जवाब के मुख्य हिस्से में, incompleteSearch फ़ील्ड देखें. अगर इसकी वैल्यू true है, तो इसका मतलब है कि कुछ दस्तावेज़ छोड़ दिए गए हैं. इसे ठीक करने के लिए, corpora को सीमित करें, ताकि user या drive का इस्तेमाल किया जा सके.

`list` तरीके पर ` orderBy` क्वेरी ` ` पैरामीटर का इस्तेमाल करते समय, आइटम के ` ` बड़े कलेक्शन पर क्वेरी के लिए `createdTime` कुंजी का इस्तेमाल न करें. ऐसा इसलिए, क्योंकि इसके लिए अतिरिक्त प्रोसेसिंग की ज़रूरत होती है और इससे टाइम आउट या अन्य समस्याएं हो सकती हैं. आइटम के बड़े कलेक्शन पर, समय के हिसाब से क्रम में लगाने के लिए, modifiedTime का इस्तेमाल किया जा सकता है. ऐसा इसलिए, क्योंकि इसे इन क्वेरी को मैनेज करने के लिए ऑप्टिमाइज़ किया गया है. उदाहरण के लिए, orderBy को modifiedTime (या modifiedTime desc) पर सेट करें.

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

मिलते-जुलते विषय

• शेयर की गई ड्राइव खोजना
• सर्च क्वेरी की शर्तें और ऑपरेटर
• Google Workspace और Google Drive के साथ काम करने वाले MIME टाइप
• भूमिकाएं और अनुमतियां
• किसी खास लेबल या फ़ील्ड की वैल्यू के हिसाब से फ़ाइलें खोजना