फ़ाइलें, फ़ोल्डर, और ड्राइव शेयर करना

Google Drive में मौजूद हर फ़ाइल, फ़ोल्डर, और शेयर की गई ड्राइव से permissions संसाधन जुड़े होते हैं. हर संसाधन, किसी खास type (user, group, domain, anyone) और role (owner, organizer, fileOrganizer, writer, commenter, reader) के लिए अनुमति की पहचान करता है. उदाहरण के लिए, किसी फ़ाइल के लिए ऐसी अनुमति हो सकती है जो किसी खास उपयोगकर्ता (type=user) को सिर्फ़ पढ़ने का ऐक्सेस (role=reader) देती है. वहीं, दूसरी अनुमति किसी खास ग्रुप (type=group) के सदस्यों को फ़ाइल में टिप्पणियां जोड़ने की सुविधा (role=commenter) देती है.

भूमिकाओं और उनसे जुड़ी अनुमतियों की पूरी सूची देखने के लिए, भूमिकाएं और अनुमतियां लेख पढ़ें.

ध्यान दें: किसी फ़ाइल, फ़ोल्डर या शेयर की गई ड्राइव से जुड़े सभी अनुमति संसाधनों की सूची को ऐक्सेस कंट्रोल लिस्ट (एसीएल) कहा जाता है.

अनुमतियां कैसे लागू होती हैं

अनुमतियां, पैरंट फ़ोल्डर से सभी चाइल्ड आइटम पर लागू होती हैं:

• डिफ़ॉल्ट रूप से लागू होती हैं: सभी चाइल्ड फ़ाइलें और फ़ोल्डर, अपने पैरंट फ़ोल्डर की अनुमतियां अपने-आप पा लेते हैं.
• बच्चों के लिए कम नहीं की जा सकती: किसी चाइल्ड आइटम के लिए पहले से मिले ऐक्सेस की सुविधा को हटाया या कम नहीं किया जा सकता. बदलाव, ओरिजनल पैरंट फ़ोल्डर में किए जाने चाहिए. इसके अलावा, फ़ोल्डर में सीमित ऐक्सेस की सेटिंग का इस्तेमाल किया जाना चाहिए.
• बच्चों के लिए ज़्यादा अनुमतियां दी जा सकती हैं: किसी चाइल्ड आइटम के लिए ज़्यादा अनुमतियों वाली भूमिका दी जा सकती है. जैसे, किसी फ़ोल्डर में मौजूद फ़ाइल के लिए role=writer की अनुमति देना, जबकि उपयोगकर्ता के पास उस फ़ोल्डर के लिए role=reader की अनुमति है.
• ट्रांसफ़र करने पर फिर से जांच की जाती है: किसी आइटम को नए पैरंट फ़ोल्डर में ट्रांसफ़र करने पर, उसकी अनुमतियों की फिर से जांच की जाती है. साथ ही, नए पैरंट फ़ोल्डर की अनुमतियां आइटम और उसके चाइल्ड फ़ोल्डर पर लागू की जाती हैं.

फ़ाइल के लिंक और ऐक्सेस कंट्रोल

किसी फ़ाइल या फ़ोल्डर को किसी उपयोगकर्ता या ग्रुप के साथ शेयर करने पर, उसे ऐक्सेस करने का यूआरएल नहीं बदलता. साथ ही, हर उपयोगकर्ता के लिए यूनीक लिंक जनरेट नहीं होता. इसके बजाय, आइटम का एक ही लिंक होता है, जो उसके fileId के आधार पर तय होता है.

Drive, आइटम के ACL का आकलन करके ऐक्सेस को कंट्रोल करता है. जब कोई उपयोगकर्ता किसी लिंक को खोलने की कोशिश करता है, तो Drive, एसीएल के हिसाब से उसकी पुष्टि की गई पहचान की पुष्टि करता है. अगर किसी अनुमति को रद्द कर दिया जाता है या उसकी समयसीमा खत्म हो जाती है, तो उपयोगकर्ता को एसीएल से हटा दिया जाता है. अगर उपयोगकर्ता लिंक पर फिर से जाने की कोशिश करता है, तो Drive उसे ऐक्सेस करने की अनुमति नहीं देता.

फ़ाइल की क्षमताओं के बारे में जानकारी

permissions संसाधन से यह पता चलता है कि किसके पास ऐक्सेस है (एसीएल). हालांकि, इससे यह सीधे तौर पर पता नहीं चलता कि मौजूदा उपयोगकर्ता, आपके ऐप्लिकेशन के यूज़र इंटरफ़ेस (यूआई) में कोई खास कार्रवाई कर सकता है या नहीं.

इसके बजाय, files संसाधन में बूलियन capabilities फ़ील्ड का कलेक्शन होता है. जैसे, canComment, canShare या canDelete. Google Drive API, उपयोगकर्ता की भूमिका और आइटम की सेटिंग के आधार पर, इन फ़ील्ड की वैल्यू को डाइनैमिक तरीके से कैलकुलेट करता है.

फ़ाइल से जुड़ी सुविधाएं पाना

अपने ऐप्लिकेशन के यूज़र इंटरफ़ेस (यूआई) को रेंडर करते समय, अनुमतियों को सीधे तौर पर पार्स करने के बजाय, files.capabilities की जांच करें:

• fields=capabilities के साथ files.get तरीके को कॉल करें. ज़्यादा जानकारी के लिए, चुनिंदा फ़ील्ड की वैल्यू वापस पाना लेख पढ़ें.
• बूलियन फ़्लैग का इस्तेमाल करके, अपने इंटरफ़ेस में कार्रवाइयों को चालू या बंद करें. उदाहरण के लिए, अगर canComment false है, तो टिप्पणी करने की सुविधा बंद करें.

Drive के संसाधन शेयर करने के उदाहरण

यहां दी गई टेबल में, अलग-अलग जगहों और आइटम टाइप के हिसाब से Drive के संसाधन शेयर करने के लिए ज़रूरी भूमिकाओं और शर्तों के बारे में बताया गया है:

जगह	आइटम	ज़रूरी भूमिकाएं	कुंजी से जुड़ी शर्तें
मेरी ड्राइव	फ़ाइल या फ़ोल्डर	owner या writer	अगर writersCanShare=false, तो owner ज़रूरी है. फ़ोल्डर पर सीमित समय के लिए खाते का ऐक्सेस देने के लिए, reader ज़रूरी है (ऐक्सेस खत्म होने की तारीख सेट करना लेख पढ़ें).
शेयर की गई ड्राइव	फ़ाइल	organizer, fileOrganizer या writer	writersCanShare को हमेशा true माना जाता है.
शेयर की गई ड्राइव	फ़ोल्डर	organizer	अगर sharingFoldersRequiresOrganizerPermission false है, तो fileOrganizer भी शेयर कर सकता है.
शेयर की गई ड्राइव	सदस्यता	organizer	सिर्फ़ user या group पर लागू होता है, डोमेन पर नहीं.

अनुमतियां प्रबंधित करें

यहां दी गई टेबल में, permissions संसाधन पर उपलब्ध तरीकों की खास जानकारी दी गई है:

तरीका	एपीआई एंडपॉइंट	मुख्य पैरामीटर	रेफ़रंस
बनाएं	POST https://www.googleapis.com/drive/v3/files/{fileId}/permissions	role, type, emailAddress या domain	permissions.create
पाएं	GET https://www.googleapis.com/drive/v3/files/{fileId}/permissions/{permissionId}	fields	permissions.get
सूची	GET https://www.googleapis.com/drive/v3/files/{fileId}/permissions	pageSize, supportsAllDrives, pageToken	permissions.list
अपडेट करें	PATCH https://www.googleapis.com/drive/v3/files/{fileId}/permissions/{permissionId}	role, allowFileDiscovery	permissions.update
मिटाएं	DELETE https://www.googleapis.com/drive/v3/files/{fileId}/permissions/{permissionId}	supportsAllDrives	permissions.delete

अनुमति बनाना

किसी फ़ाइल, फ़ोल्डर या शेयर की गई ड्राइव को शेयर करने के लिए, permissions संसाधन पर create तरीके को fileId के साथ कॉल करें. अनुमति बनाने पर, आइटम में एक नई ACL एंट्री जुड़ जाती है. साथ ही, असाइन किया गया permissionId दिखता है.

अनुरोध के मुख्य हिस्से में, ये फ़ील्ड शामिल करें:

• role: ऐक्सेस का वह लेवल जो देना है. उदाहरण के लिए, reader, commenter या writer. पूरी सूची देखने के लिए, भूमिकाएं और अनुमतियां देखें.
• type: यह, अनुमति पाने वाले व्यक्ति या कंपनी (user, group, domain या anyone) के स्कोप के बारे में बताता है.
• अनुदान पाने वाले का आइडेंटिफ़ायर (type के आधार पर ज़रूरी है):
  • emailAddress: जब type की वैल्यू user या group पर सेट हो, तब यह एट्रिब्यूट ज़रूरी होता है.
  • domain: type की वैल्यू domain होने पर, यह एट्रिब्यूट ज़रूरी है.

यहां दिए गए कोड के सैंपल में, अनुमति बनाने का तरीका बताया गया है. जवाब में, असाइन किए गए permissionId के साथ-साथ permissions संसाधन का एक इंस्टेंस दिखता है.

अनुरोध

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

{
  "role": "commenter",
  "type": "user",
  "emailAddress": "[e-mail]"
}

जवाब

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

ध्यान दें: permissions.create तरीके से, हर अनुरोध के लिए एक अनुमति बनाई जाती है. एक ही बैच में कई अनुमतियां बनाने या अपडेट करने के लिए, बैच में अनुरोध भेजकर कई अनुमतियां अपडेट करना लेख पढ़ें.

टारगेट ऑडियंस के साथ शेयर करना

टारगेट ऑडियंस, लोगों के ऐसे ग्रुप होते हैं जिनके साथ उपयोगकर्ता अपने आइटम शेयर कर सकते हैं. जैसे, डिपार्टमेंट या टीमें. उपयोगकर्ताओं को पूरे संगठन के बजाय, किसी खास या सीमित ऑडियंस के साथ आइटम शेयर करने के लिए बढ़ावा दिया जा सकता है. टारगेट ऑडियंस की मदद से, अपने डेटा की सुरक्षा और निजता को बेहतर बनाया जा सकता है. साथ ही, उपयोगकर्ताओं के लिए डेटा को सही तरीके से शेयर करना आसान बनाया जा सकता है.

टारगेट ऑडियंस के साथ शेयर करने के लिए, type=domain को सेट करें और domain को <TARGET_AUDIENCE_ID>.audience.googledomains.com पर सेट करें. Google Admin console में टारगेट ऑडियंस ढूंढने या बनाने के बारे में जानकारी के लिए, टारगेट ऑडियंस के बारे में जानकारी लेख पढ़ें.

यह देखने के लिए कि उपयोगकर्ता, टारगेट ऑडियंस के साथ कैसे इंटरैक्ट करते हैं, लिंक शेयर करने के लिए उपयोगकर्ता अनुभव देखें.

अनुमति पाना

अनुमति पाने के लिए, permissions संसाधन पर get तरीके को कॉल करें. इसके लिए, fileId और permissionId पाथ पैरामीटर का इस्तेमाल करें. अगर आपको अनुमति का आईडी नहीं पता है, तो पहले सभी अनुमतियों की सूची बनाएं.

अनुमतियों की सूची

किसी फ़ाइल, फ़ोल्डर या शेयर की गई ड्राइव के लिए अनुमतियों की सूची बनाने के लिए, permissions रिसॉर्स पर list तरीके को कॉल करें. इसके लिए, ज़रूरी fileId पाथ पैरामीटर का इस्तेमाल करें.

जवाब को पेज के हिसाब से बांटने या फ़िल्टर करने के लिए, इनमें से कोई भी वैकल्पिक क्वेरी पैरामीटर शामिल किया जा सकता है:

• pageSize (ज़रूरी नहीं): हर पेज के लिए, अनुमतियों की ज़्यादा से ज़्यादा संख्या. अगर शेयर की गई ड्राइव में मौजूद फ़ाइलों के लिए यह सेटिंग सेट नहीं की गई है, तो ज़्यादा से ज़्यादा 100 नतीजे दिखाए जाते हैं. अगर शेयर की गई ड्राइव में मौजूद फ़ाइलों के लिए यह सेटिंग सेट नहीं की गई है, तो पूरी सूची दिखाई जाती है.

• pageToken (ज़रूरी नहीं): यह पिछली सूची के कॉल का पेज टोकन होता है. इसका इस्तेमाल, अगले पेज को वापस पाने के लिए किया जाता है.

• supportsAllDrives (ज़रूरी नहीं): अनुरोध करने वाला ऐप्लिकेशन, 'मेरी ड्राइव' और शेयर की गई ड्राइव, दोनों के साथ काम करता है या नहीं.

• useDomainAdminAccess (ज़रूरी नहीं): डोमेन एडमिन के तौर पर अनुरोध करने के लिए, इसे true पर सेट करें. अगर अनुरोध करने वाला व्यक्ति, उस डोमेन का एडमिन है जिससे शेयर की गई ड्राइव जुड़ी है और fileId पैरामीटर, शेयर की गई ड्राइव को रेफ़र करता है, तो अनुरोध करने वाले व्यक्ति को ऐक्सेस दिया जाता है. ज़्यादा जानकारी के लिए, डोमेन एडमिन के तौर पर शेयर की गई ड्राइव मैनेज करना लेख पढ़ें.

• includePermissionsForView (ज़रूरी नहीं): जवाब में शामिल करने के लिए, व्यू की अतिरिक्त अनुमतियां. सिर्फ़ published का इस्तेमाल किया जा सकता है.

• fields (ज़रूरी नहीं): जवाब में दिखाने के लिए फ़ील्ड. डिफ़ॉल्ट रूप से, list सिर्फ़ id, type, kind, और role दिखाता है. permissionDetails जैसे अतिरिक्त फ़ील्ड वापस पाने के लिए, इस पैरामीटर का इस्तेमाल करके उन्हें तय करें. ज़्यादा जानकारी के लिए, चुनिंदा फ़ील्ड की वैल्यू वापस पाना लेख पढ़ें.

भूमिका के सोर्स का पता लगाना

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

शेयर की गई ड्राइव या उस ड्राइव में मौजूद आइटम के लिए भूमिका का सोर्स तय करने के लिए, permissions संसाधन पर get तरीके को कॉल करें. इसके लिए, fileId और permissionId पाथ पैरामीटर का इस्तेमाल करें. साथ ही, fields पैरामीटर को permissionDetails फ़ील्ड पर सेट करें.

permissionId को ढूंढने के लिए, fileId पाथ पैरामीटर के साथ permissions संसाधन पर list तरीके का इस्तेमाल करें. list अनुरोध पर permissionDetails फ़ील्ड को फ़ेच करने के लिए, fields पैरामीटर को permissions/permissionDetails पर सेट करें.

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

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

अनुरोध

GET https://www.googleapis.com/drive/v3/files/FILE_ID/permissions/PERMISSION_ID?fields=permissionDetails&supportsAllDrives=true

जवाब

{
  "permissionDetails": [
    {
      "permissionType": "member",
      "role": "commenter",
      "inheritedFrom": "INHERITED_FROM_ID",
      "inherited": true
    },
    {
      "permissionType": "file",
      "role": "writer",
      "inherited": false
    }
  ]
}

अनुमति अपडेट करना

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

1. permissions संसाधन पर update तरीके को कॉल करें. इसके लिए, fileId पाथ पैरामीटर को उससे जुड़ी फ़ाइल, फ़ोल्डर या शेयर की गई ड्राइव पर सेट करें. साथ ही, permissionId पाथ पैरामीटर को बदलने की अनुमति पर सेट करें. permissionId को ढूंढने के लिए, fileId पाथ पैरामीटर के साथ permissions रिसॉर्स पर list तरीके का इस्तेमाल करें.

   ध्यान दें: permissionId उस उपयोगकर्ता या ग्रुप को दिखाता है जिसे अनुमति दी गई है. जैसे, [e-mail] या [e-mail]. permissionId उस उपयोगकर्ता या ग्रुप के लिए, सभी फ़ाइलों, फ़ोल्डर, और शेयर की गई ड्राइव में एक जैसा रहता है.

2. अनुरोध में, नए role की पहचान करें.

किसी उपयोगकर्ता या ग्रुप के पास पहले से ही शेयर की गई ड्राइव का ऐक्सेस होने पर भी, उसे शेयर की गई ड्राइव में मौजूद किसी फ़ाइल या फ़ोल्डर का ऐक्सेस दिया जा सकता है. उदाहरण के लिए, ऐलेक्स के पास शेयर की गई ड्राइव की सदस्यता के तौर पर role=commenter है. हालांकि, आपका ऐप्लिकेशन, शेयर की गई ड्राइव में मौजूद किसी फ़ाइल के लिए Alex role=writer को अनुमति दे सकता है. इस मामले में, नई भूमिका में सदस्यता के ज़रिए मिली भूमिका की तुलना में ज़्यादा अनुमतियां हैं. इसलिए, फ़ाइल या फ़ोल्डर के लिए नई भूमिका, लागू होने वाली भूमिका बन जाती है.

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

भूमिकाएं बदलने के साथ-साथ, किसी आइटम के दिखने की सेटिंग में भी बदलाव किया जा सकता है. ऐसा तब किया जा सकता है, जब अनुमति type या domain या anyone हो. शेयर की गई किसी फ़ाइल को खोजे जाने या 'सबके लिए मौजूद नहीं' के तौर पर सेट करने के लिए, अपने पैच अनुरोध में allowFileDiscovery बूलियन फ़ील्ड शामिल करें. इस विकल्प को true पर सेट करने से, आइटम को टारगेट की गई ऑडियंस के लिए खोज के नतीजों में दिखने की अनुमति मिलती है. भले ही, उन्हें सीधे तौर पर लिंक न दिया गया हो. इस सेटिंग को बदलने के लिए, आपको अनुमति को मिटाने और फिर से बनाने की ज़रूरत नहीं है.

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

अनुरोध

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

{
  "role": "writer"
}

जवाब

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

एक साथ कई अनुरोध करके, एक से ज़्यादा अनुमतियां अपडेट करना

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

Drive, किसी आइटम के लिए अनुमतियों का आकलन करता है और उन्हें एक ही एसीएल के तौर पर अपडेट करता है. एक साथ कई कार्रवाइयां करने से, रेस कंडीशन पैदा होती हैं. इनमें "आखिरी बार किए गए बदलाव लागू होते हैं." इससे अनुमति में किए गए बदलाव चुपचाप बदल सकते हैं या sharingRateLimitExceeded गड़बड़ियां ट्रिगर हो सकती हैं.

अनुमतियों में टकराव से बचने के लिए, एक ही आइटम की अनुमतियों में एक के बाद एक बदलाव करें. इसके अलावा, एक ही अनुरोध में कई अनुमतियों में बदलाव करने के लिए, बैच अनुरोधों का इस्तेमाल करें.

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

ध्यान दें: अगर Drive API v2 का इस्तेमाल किया जा रहा है, तो आपको कोड के सैंपल GitHub में मिल सकते हैं. Drive API v3 पर माइग्रेट करने का तरीका जानें.

Java

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

GitHub पर देखें

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

GitHub पर देखें

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": "[e-mail]",
    }
    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="[e-mail]",
      real_domain="workspacesamples.dev",
  )

Node.js

drive/snippets/drive_v3/file_snippets/share_file.js

GitHub पर देखें

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

/**
 * Shares a file with a user and a domain.
 * @param {string} fileId The ID of the file to share.
 * @param {string} targetUserEmail The email address of the user to share with.
 * @param {string} targetDomainName The domain to share with.
 * @return {Promise<Array<string>>} A promise that resolves to an array of permission IDs.
 */
async function shareFile(fileId, targetUserEmail, targetDomainName) {
  // 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});

  /** @type {Array<string>} */
  const permissionIds = [];

  // The permissions to create.
  const permissions = [
    {
      type: 'user',
      role: 'writer',
      emailAddress: targetUserEmail, // e.g., '[e-mail]'
    },
    {
      type: 'domain',
      role: 'writer',
      domain: targetDomainName, // e.g., 'example.com'
    },
  ];

  // Iterate through the permissions and create them one by one.
  for (const permission of permissions) {
    const result = await service.permissions.create({
      requestBody: permission,
      fileId,
      fields: 'id',
    });

    if (result.data.id) {
      permissionIds.push(result.data.id);
      console.log(`Inserted permission id: ${result.data.id}`);
    } else {
      throw new Error('Failed to create permission');
    }
  }
  return permissionIds;
}

PHP

drive/snippets/drive_v3/src/DriveShareFile.php

GitHub पर देखें

<?php
use Google\Client;
use Google\Service\Drive;
function shareFile()
{
    try {
        $client = new Client();
        $client->useApplicationDefaultCredentials();
        $client->addScope(Drive::DRIVE);
        $driveService = new Drive($client);
        $realFileId = readline("Enter File Id: ");
        $realUser = readline("Enter user email address: ");
        $realDomain = readline("Enter domain name: ");
        $ids = array();
            $fileId = '1sTWaJ_j7PkjzaBWtNc3IzovK5hQf21FbOw9yLeeLPNQ';
            $fileId = $realFileId;
            $driveService->getClient()->setUseBatch(true);
            try {
                $batch = $driveService->createBatch();

                $userPermission = new Drive\Permission(array(
                    'type' => 'user',
                    'role' => 'writer',
                    'emailAddress' => '[e-mail]'
                ));
                $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

GitHub पर देखें

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

अनुमति मिटाना

किसी फ़ाइल या फ़ोल्डर का ऐक्सेस रद्द करने के लिए, fileId और permissionId पाथ पैरामीटर के साथ permissions संसाधन पर delete तरीके को कॉल करें.

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

ध्यान दें कि किसी उपयोगकर्ता का ऐक्सेस पैरंट आइटम से हटाने पर, सिर्फ़ उस पैरंट आइटम से मिली अनुमतियां रद्द होती हैं. अगर उपयोगकर्ता को किसी चाइल्ड आइटम पर सीधे तौर पर अनुमतियां दी गई थीं, तो वह सीधे तौर पर ऐक्सेस कर सकता है. किसी अनुमति को हटाए जाने की पुष्टि करने के लिए, fileId के साथ list को कॉल करें.

ऐक्सेस खत्म होने की तारीख सेट करना

किसी फ़ाइल या फ़ोल्डर का कुछ समय के लिए ऐक्सेस देने के लिए, create या update तरीके कॉल करते समय, expirationTime फ़ील्ड (RFC 3339 तारीख-समय) सेट करें.

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

• इसे सिर्फ़ user और group अनुमतियों के लिए सेट किया जा सकता है. domain या anyone के लिए नहीं.
• समय, अभी से आगे का होना चाहिए. यह ज़्यादा से ज़्यादा एक साल तक का हो सकता है.
• फ़ोल्डर के लिए, कुछ समय के लिए ऐक्सेस देने की सुविधा सिर्फ़ reader भूमिका के साथ काम करती है.

ध्यान दें: अगर Drive API v2 का इस्तेमाल किया जा रहा है, तो expirationDate फ़ील्ड का इस्तेमाल करें. Drive API v3 पर माइग्रेट करने का तरीका जानें.

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

• ऐक्सेस के लंबित अनुरोध मैनेज करना
• सीमित और ज़्यादा ऐक्सेस वाले फ़ोल्डर मैनेज करना
• फ़ाइल का मालिकाना हक ट्रांसफ़र करना
• फ़ाइल के कॉन्टेंट को सुरक्षित रखना
• संसाधन कुंजियों का इस्तेमाल करके, लिंक शेयर करके Drive की गई फ़ाइलों को ऐक्सेस करना
• भूमिकाएं और अनुमतियां