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

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 इनहेरिट करती है.

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

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

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

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

permissions संसाधन से, मौजूदा उपयोगकर्ता की किसी फ़ाइल या फ़ोल्डर पर कार्रवाई करने की क्षमता का पता नहीं चलता. इसके बजाय, files संसाधन में बूलियन capabilities फ़ील्ड का कलेक्शन होता है. इसका इस्तेमाल यह बताने के लिए किया जाता है कि किसी फ़ाइल या फ़ोल्डर पर कोई कार्रवाई की जा सकती है या नहीं. Google Drive API, इन फ़ील्ड को मौजूदा उपयोगकर्ता के permissions संसाधन के आधार पर सेट करता है. यह संसाधन, फ़ाइल या फ़ोल्डर से जुड़ा होता है.

उदाहरण के लिए, जब ऐलेक्स आपके ऐप्लिकेशन में लॉग इन करता है और कोई फ़ाइल शेयर करने की कोशिश करता है, तो ऐलेक्स की भूमिका की जांच की जाती है, ताकि यह पता चल सके कि उसके पास फ़ाइल शेयर करने की अनुमति है या नहीं. अगर उसकी भूमिका के हिसाब से, वह फ़ाइल शेयर कर सकता है, तो फ़ाइल से जुड़ी capabilities को उसकी भूमिका के हिसाब से सेट किया जाता है. जैसे, canShare को उसकी भूमिका के हिसाब से सेट किया जाता है. अगर ऐलेक्स को फ़ाइल शेयर करनी है, तो आपका ऐप्लिकेशन capabilities की जांच करता है, ताकि यह पक्का किया जा सके कि canShare को true पर सेट किया गया है.

फ़ाइल की क्षमताएं पाना

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

क्षमताओं की जांच करने के लिए, get तरीके को files संसाधन पर कॉल करें. इसके लिए, fileId पाथ पैरामीटर और fields पैरामीटर को capabilities फ़ील्ड पर सेट करें. `fields` पैरामीटर का इस्तेमाल करके, फ़ील्ड वापस पाने के बारे में ज़्यादा जानने के लिए, खास फ़ील्ड वापस पाना देखें.

GET https://www.googleapis.com/drive/v3/files/FILE_ID?fields=capabilities

{
  "capabilities": {
    "canAcceptOwnership": false,
    "canAddChildren": false,
    "canAddMyDriveParent": false,
    "canChangeCopyRequiresWriterPermission": true,
    "canChangeItemDownloadRestriction": true,
    "canChangeSecurityUpdateEnabled": false,
    "canChangeViewersCanCopyContent": true,
    "canComment": true,
    "canCopy": true,
    "canDelete": true,
    "canDisableInheritedPermissions": false,
    "canDownload": true,
    "canEdit": true,
    "canEnableInheritedPermissions": true,
    "canListChildren": false,
    "canModifyContent": true,
    "canModifyContentRestriction": true,
    "canModifyEditorContentRestriction": true,
    "canModifyOwnerContentRestriction": true,
    "canModifyLabels": true,
    "canMoveChildrenWithinDrive": false,
    "canMoveItemIntoTeamDrive": true,
    "canMoveItemOutOfDrive": true,
    "canMoveItemWithinDrive": true,
    "canReadLabels": true,
    "canReadRevisions": true,
    "canRemoveChildren": false,
    "canRemoveContentRestriction": false,
    "canRemoveMyDriveParent": true,
    "canRename": true,
    "canShare": true,
    "canTrash": true,
    "canUntrash": true
  }
}

Drive में मौजूद संसाधन शेयर करने के अलग-अलग तरीके

Drive में मौजूद संसाधन शेयर करने के पांच अलग-अलग तरीके हैं:

1. मेरी ड्राइव में मौजूद कोई फ़ाइल शेयर करने के लिए, उपयोगकर्ता के पास role=writer या role=owner होना चाहिए.

   • अगर फ़ाइल के लिए, writersCanShare बूलियन वैल्यू को false पर सेट किया गया है, तो उपयोगकर्ता के पास role=owner होना चाहिए.

   • अगर role=writer वाले उपयोगकर्ता के पास, तय समय के लिए ऐक्सेस है और यह ऐक्सेस, समयसीमा खत्म होने की तारीख और समय के हिसाब से तय किया गया है, तो वह फ़ाइल शेयर नहीं कर सकता. ज़्यादा जानकारी के लिए, आइटम के ऐक्सेस को सीमित करने के लिए, समयसीमा खत्म होने की तारीख सेट करना देखें.

2. मेरी ड्राइव में मौजूद कोई फ़ोल्डर शेयर करने के लिए, उपयोगकर्ता के पास role=writer या role=owner होना चाहिए.

   • अगर फ़ाइल के लिए, writersCanShare बूलियन वैल्यू को false पर सेट किया गया है, तो उपयोगकर्ता के पास ज़्यादा अनुमतियों वाली role=owner होनी चाहिए.

   • तय समय के लिए ऐक्सेस (समयसीमा खत्म होने की तारीख और समय के हिसाब से तय किया गया) सिर्फ़ उन फ़ोल्डर के लिए दिया जा सकता है जिनके लिए role=reader सेट है. ज़्यादा जानकारी के लिए, आइटम के ऐक्सेस को सीमित करने के लिए, समयसीमा खत्म होने की तारीख सेट करना देखें.

3. शेयर की गई ड्राइव में मौजूद कोई फ़ाइल शेयर करने के लिए, उपयोगकर्ता के पास role=writer, role=fileOrganizer या role=organizer होना चाहिए.

   • शेयर की गई ड्राइव में मौजूद आइटम पर, writersCanShare सेटिंग लागू नहीं होती. इसे हमेशा true पर सेट माना जाता है.

4. शेयर की गई ड्राइव में मौजूद कोई फ़ोल्डर शेयर करने के लिए, उपयोगकर्ता के पास role=organizer होना चाहिए.

   • अगर शेयर की गई ड्राइव पर, the sharingFoldersRequiresOrganizerPermission पाबंदी को false पर सेट किया गया है, तो role=fileOrganizer वाले उपयोगकर्ता, उस शेयर की गई ड्राइव में मौजूद फ़ोल्डर शेयर कर सकते हैं.

5. शेयर की गई ड्राइव की सदस्यता मैनेज करने के लिए, उपयोगकर्ता के पास role=organizer होना चाहिए. शेयर की गई ड्राइव के सदस्य सिर्फ़ उपयोगकर्ता और ग्रुप हो सकते हैं.

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

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

अनुमति बनाना

अनुमति बनाते समय, ये दो फ़ील्ड ज़रूरी होते हैं:

• type: type से, अनुमति के दायरे की पहचान होती है (user, group, domain, या anyone). type=user वाली अनुमति, किसी खास उपयोगकर्ता पर लागू होती है. वहीं, type=domain वाली अनुमति, किसी खास डोमेन में मौजूद सभी लोगों पर लागू होती है.

• role: role फ़ील्ड से, उन कार्रवाइयों की पहचान होती है जो type कर सकता है. उदाहरण के लिए, type=user और role=reader वाली अनुमति से, किसी खास उपयोगकर्ता को फ़ाइल या फ़ोल्डर को सिर्फ़ पढ़ने का ऐक्सेस मिलता है. इसके अलावा, type=domain और role=commenter वाली अनुमति से, डोमेन में मौजूद सभी लोग किसी फ़ाइल में टिप्पणियां जोड़ सकते हैं. भूमिकाओं की पूरी सूची और हर भूमिका के लिए अनुमति वाली कार्रवाइयों के बारे में जानने के लिए, भूमिकाएं और अनुमतियां देखें.

जब type=user या type=group वाली अनुमति बनाई जाती है, तो आपको भी emailAddress देना होगा, ताकि अनुमति को किसी खास उपयोगकर्ता या ग्रुप से जोड़ा जा सके.

जब अनुमति बनाई जाती है, तो आपको domain भी देना होगा, ताकि अनुमति को किसी खास डोमेन से जोड़ा जा सके.type=domain

अनुमति बनाने के लिए:

1. संबंधित फ़ाइल या फ़ोल्डर के लिए, fileId पाथ पैरामीटर के साथ, permissions संसाधन पर create तरीके का इस्तेमाल करें.
2. अनुरोध के मुख्य हिस्से में, type और role तय करें.
3. अगर type=user या type=group है, तो emailAddress दें. अगर type=domain है, तो domain दें.

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

{
  "requests": [
    {
        "type": "user",
        "role": "commenter",
        "emailAddress": "alex@altostrat.com"
    }
  ]
}

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

टारगेट ऑडियंस का इस्तेमाल करना

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

टारगेट ऑडियंस का इस्तेमाल करने के लिए:

1. Google Admin console में, मेन्यू menu > डायरेक्ट्री > टारगेट ऑडियंस पर जाएं.

   टारगेट ऑडियंस पर जाएं

   यह टास्क पूरा करने के लिए, आपको सुपर एडमिन के अधिकारों वाले खाते से साइन इन करना होगा.

2. टारगेट ऑडियंस की सूची में, टारगेट ऑडियंस के नाम पर क्लिक करें. टारगेट ऑडियंस बनाने के लिए, टारगेट ऑडियंस बनाना देखें

3. टारगेट ऑडियंस के यूआरएल से, यूनीक आईडी कॉपी करें: https://admin.google.com/ac/targetaudiences/ID.

4. अनुमति बनाएं. साथ ही, type=domain वाली अनुमति बनाएं और domain फ़ील्ड को ID.audience.googledomains.com पर सेट करें.

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

अनुमति पाना

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

GET https://www.googleapis.com/drive/v3/files/FILE_ID/permissionsPERMISSION_ID

{
  "kind": "drive#permissionList",
  "permissions": [
    {
      "kind": "drive#permission",
      "id": "PERMISSION_ID",
      "type": "user",
      "role": "commenter"
    }
  ]
}

सभी अनुमतियों की सूची देखना

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

अनुमतियों के पेज पर दिखने वाले नतीजों की संख्या तय करने या उन्हें फ़िल्टर करने के लिए, ये क्वेरी पैरामीटर पास करें:

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

• pageToken: पेज टोकन, जो सूची के लिए पहले किए गए कॉल से मिला है. अगला पेज वापस पाने के लिए, यह टोकन दें.

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

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

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

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

{
  "kind": "drive#permissionList",
  "permissions": [
    {
      "id": "PERMISSION_ID",
      "type": "user",
      "kind": "drive#permission",
      "role": "commenter"
    }
  ]
}

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

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

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

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

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

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

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

भूमिका का सोर्स तय करना

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

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

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

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

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

बैच अनुरोधों की मदद से, एक साथ कई अनुमतियां अपडेट करना

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

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

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

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


def share_file(real_file_id, real_user, real_domain):
  """Batch permission modification.
  Args:
      real_file_id: file Id
      real_user: User ID
      real_domain: Domain of the user ID
  Prints modified permissions

  Load pre-authorized user credentials from the environment.
  TODO(developer) - See https://developers.google.com/identity
  for guides on implementing OAuth2 for the application.
  """
  creds, _ = google.auth.default()

  try:
    # create drive api client
    service = build("drive", "v3", credentials=creds)
    ids = []
    file_id = real_file_id

    def callback(request_id, response, exception):
      if exception:
        # Handle error
        print(exception)
      else:
        print(f"Request_Id: {request_id}")
        print(f'Permission Id: {response.get("id")}')
        ids.append(response.get("id"))

    # pylint: disable=maybe-no-member
    batch = service.new_batch_http_request(callback=callback)
    user_permission = {
        "type": "user",
        "role": "writer",
        "emailAddress": "user@example.com",
    }
    batch.add(
        service.permissions().create(
            fileId=file_id,
            body=user_permission,
            fields="id",
        )
    )
    domain_permission = {
        "type": "domain",
        "role": "reader",
        "domain": "example.com",
    }
    domain_permission["domain"] = real_domain
    batch.add(
        service.permissions().create(
            fileId=file_id,
            body=domain_permission,
            fields="id",
        )
    )
    batch.execute()

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

  return ids


if __name__ == "__main__":
  share_file(
      real_file_id="1dUiRSoAQKkM3a4nTPeNQWgiuau1KdQ_l",
      real_user="gduser1@workspacesamples.dev",
      real_domain="workspacesamples.dev",
  )

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., 'user@partner.com'
    },
    {
      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
use Google\Client;
use Google\Service\Drive;
function shareFile()
{
    try {
        $client = new Client();
        $client->useApplicationDefaultCredentials();
        $client->addScope(Drive::DRIVE);
        $driveService = new Drive($client);
        $realFileId = readline("Enter File Id: ");
        $realUser = readline("Enter user email address: ");
        $realDomain = readline("Enter domain name: ");
        $ids = array();
            $fileId = '1sTWaJ_j7PkjzaBWtNc3IzovK5hQf21FbOw9yLeeLPNQ';
            $fileId = $realFileId;
            $driveService->getClient()->setUseBatch(true);
            try {
                $batch = $driveService->createBatch();

                $userPermission = new Drive\Permission(array(
                    'type' => 'user',
                    'role' => 'writer',
                    'emailAddress' => 'user@example.com'
                ));
                $userPermission['emailAddress'] = $realUser;
                $request = $driveService->permissions->create(
                    $fileId, $userPermission, array('fields' => 'id'));
                $batch->add($request, 'user');
                $domainPermission = new Drive\Permission(array(
                    'type' => 'domain',
                    'role' => 'reader',
                    'domain' => 'example.com'
                ));
                $userPermission['domain'] = $realDomain;
                $request = $driveService->permissions->create(
                    $fileId, $domainPermission, array('fields' => 'id'));
                $batch->add($request, 'domain');
                $results = $batch->execute();

                foreach ($results as $result) {
                    if ($result instanceof Google_Service_Exception) {
                        // Handle error
                        printf($result);
                    } else {
                        printf("Permission ID: %s\n", $result->id);
                        array_push($ids, $result->id);
                    }
                }
            } finally {
                $driveService->getClient()->setUseBatch(false);
            }
            return $ids;
    } catch(Exception $e) {
        echo "Error Message: ".$e;
    }

}

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

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

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

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

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

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

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

आइटम के ऐक्सेस को सीमित करने के लिए, समयसीमा खत्म होने की तारीख सेट करना

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

समयसीमा खत्म होने की तारीख सेट करने के लिए:

• create तरीके का इस्तेमाल करें और permissions संसाधन पर expirationTime फ़ील्ड (अन्य ज़रूरी फ़ील्ड के साथ) सेट करें. ज़्यादा जानकारी के लिए, अनुमति बनाना देखें.

• update तरीके का इस्तेमाल करें और permissions संसाधन पर expirationTime फ़ील्ड (अन्य ज़रूरी फ़ील्ड के साथ) सेट करें. ज़्यादा जानकारी के लिए, अनुमतियां अपडेट करना देखें.

expirationTime फ़ील्ड से पता चलता है कि आरएफ़़सी 3339 तारीख-समय के हिसाब से, अनुमति कब खत्म होगी. समयसीमा खत्म होने की तारीखों पर ये पाबंदियां लागू होती हैं:

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

समयसीमा खत्म होने की तारीख के बारे में ज़्यादा जानने के लिए, ये लेख देखें:

• फ़ाइल के ऐक्सेस के लिए, समयसीमा खत्म होने की तारीख सेट करना
• समयसीमा खत्म होने की तारीख जोड़ना

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

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