แชร์ไฟล์ โฟลเดอร์ และไดรฟ์

ไฟล์ โฟลเดอร์ และไดรฟ์ที่แชร์ทุกรายการใน Google ไดรฟ์จะมีทรัพยากร permissions ที่เชื่อมโยงอยู่ แต่ละทรัพยากร จะระบุสิทธิ์สำหรับ type (user, group, domain, anyone) และ role (owner, organizer, fileOrganizer, writer, commenter, reader) ตัวอย่างเช่น ไฟล์ อาจมีสิทธิ์ที่ให้สิทธิ์การเข้าถึงแบบอ่านอย่างเดียว (role=reader) แก่ผู้ใช้ที่เฉพาะเจาะจง (type=user) ในขณะที่สิทธิ์อื่นให้สิทธิ์แก่สมาชิกของกลุ่มที่เฉพาะเจาะจง (type=group) ในการเพิ่มความคิดเห็นลงในไฟล์ (role=commenter)

ดูรายการบทบาททั้งหมดและการดำเนินการที่แต่ละบทบาทอนุญาตได้ที่บทบาท และสิทธิ์

วิธีการทำงานของสิทธิ์

รายการสิทธิ์สำหรับโฟลเดอร์จะส่งต่อลงไป ไฟล์และโฟลเดอร์ย่อยทั้งหมด จะรับช่วงสิทธิ์จากโฟลเดอร์หลัก เมื่อใดก็ตามที่มีการเปลี่ยนแปลงสิทธิ์หรือลำดับชั้น การส่งต่อจะเกิดขึ้นแบบเรียกซ้ำผ่านโฟลเดอร์ที่ซ้อนกันทั้งหมด ตัวอย่างเช่น หากมีไฟล์อยู่ในโฟลเดอร์และมีการย้ายโฟลเดอร์นั้นไปยังโฟลเดอร์อื่น สิทธิ์ในโฟลเดอร์ใหม่จะแพร่ไปยังไฟล์ หาก โฟลเดอร์ใหม่ให้บทบาทใหม่แก่ผู้ใช้ไฟล์ เช่น "ผู้เขียน" บทบาทใหม่จะลบล้างบทบาท เก่าของผู้ใช้

ในทางกลับกัน หากไฟล์รับค่า role=writer จากโฟลเดอร์ และย้ายไปยัง โฟลเดอร์อื่นที่มีบทบาท "ผู้อ่าน" ไฟล์จะรับค่า role=reader

นำสิทธิ์ที่ได้รับออกจากไฟล์หรือโฟลเดอร์ในไดรฟ์ที่แชร์ไม่ได้ แต่ต้องปรับสิทธิ์เหล่านี้ในระดับบนสุดโดยตรงหรือโดยอ้อมที่รับช่วงมา คุณสามารถนำสิทธิ์ที่รับช่วงมาจากรายการใน "ไดรฟ์ของฉัน" หรือ "แชร์กับฉัน" ได้

ในทางกลับกัน คุณสามารถลบล้างสิทธิ์ที่รับค่ามาในไฟล์หรือโฟลเดอร์ในไดรฟ์ของฉันได้ ดังนั้น หากไฟล์รับช่วง role=writer จากโฟลเดอร์ในไดรฟ์ของฉัน คุณจะตั้งค่า role=reader ในไฟล์เพื่อลดระดับสิทธิ์ได้

ระบบไม่รองรับการดำเนินการเกี่ยวกับสิทธิ์พร้อมกันในไฟล์เดียวกัน ระบบจะใช้เฉพาะ การอัปเดตล่าสุดเท่านั้น

ทำความเข้าใจความสามารถของไฟล์

ทรัพยากร permissions ไม่ได้เป็นตัวกำหนดความสามารถของผู้ใช้ปัจจุบันในการดำเนินการกับไฟล์หรือโฟลเดอร์ แต่ทรัพยากร files จะมีคอลเล็กชัน ของฟิลด์ capabilities บูลีนที่ใช้เพื่อระบุว่าดำเนินการกับไฟล์หรือโฟลเดอร์ได้หรือไม่ Google ไดรฟ์ API จะตั้งค่าฟิลด์เหล่านี้ตามpermissions ทรัพยากรที่เชื่อมโยงกับไฟล์หรือโฟลเดอร์ของผู้ใช้ปัจจุบัน

เช่น เมื่ออเล็กซ์เข้าสู่ระบบแอปของคุณและพยายามแชร์ไฟล์ ระบบจะตรวจสอบบทบาทของอเล็กซ์ เพื่อดูสิทธิ์ในไฟล์ หากบทบาทอนุญาตให้ผู้ใช้แชร์ไฟล์ได้ capabilitiesที่เกี่ยวข้องกับไฟล์ เช่น canShare จะได้รับการตั้งค่าตามบทบาท หากอเล็กซ์ต้องการแชร์ไฟล์ แอปของคุณจะตรวจสอบ capabilities เพื่อให้แน่ใจว่าได้ตั้งค่า canShare เป็น true

รับความสามารถของไฟล์

เมื่อแอปเปิดไฟล์ แอปควรตรวจสอบความสามารถของไฟล์และแสดงผล UI เพื่อแสดงสิทธิ์ของผู้ใช้ปัจจุบัน เช่น หากผู้ใช้ไม่มีcanCommentความสามารถในไฟล์ ความสามารถในการแสดงความคิดเห็น ควรปิดใช้ใน UI

หากต้องการตรวจสอบความสามารถ ให้เรียกใช้เมธอด 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
  }
}

สถานการณ์การแชร์ทรัพยากรในไดรฟ์

สถานการณ์การแชร์มี 5 ประเภท ดังนี้

  1. หากต้องการแชร์ไฟล์ในไดรฟ์ของฉัน ผู้ใช้ต้องมีสิทธิ์เข้าถึงระดับrole=writer หรือrole=owner

  2. หากต้องการแชร์โฟลเดอร์ในไดรฟ์ของฉัน ผู้ใช้ต้องมีสิทธิ์เข้าถึงระดับrole=writerหรือrole=owner

    • หากตั้งค่าwritersCanShareบูลีนเป็น false สำหรับไฟล์ ผู้ใช้ต้องมีrole=ownerที่มีสิทธิ์มากกว่า

    • ระบบไม่อนุญาตให้ใช้สิทธิ์เข้าถึงชั่วคราว (ควบคุมโดยวันที่และเวลาหมดอายุ) ในโฟลเดอร์ไดรฟ์ของฉันที่มี role=writer ดูข้อมูลเพิ่มเติมได้ที่กำหนดวันที่หมดอายุเพื่อจำกัดการเข้าถึงไฟล์

  3. หากต้องการแชร์ไฟล์ในไดรฟ์ที่แชร์ ผู้ใช้ต้องมีสิทธิ์ระดับrole=writer, role=fileOrganizer หรือrole=organizer

    • writersCanShare การตั้งค่าไม่มีผลกับรายการในไดรฟ์ที่แชร์ ระบบจะถือว่ามีการตั้งค่าเป็น true เสมอ

  4. หากต้องการแชร์โฟลเดอร์ในไดรฟ์ที่แชร์ ผู้ใช้ต้องมีrole=organizer

    • หากตั้งค่าข้อจำกัดของไดรฟ์ที่แชร์ sharingFoldersRequiresOrganizerPermission เป็น false ผู้ใช้ที่มี role=fileOrganizer จะแชร์โฟลเดอร์ในไดรฟ์ที่แชร์นั้นได้

  5. หากต้องการจัดการการเป็นสมาชิกไดรฟ์ที่แชร์ ผู้ใช้ต้องมีrole=organizer เฉพาะ ผู้ใช้และกลุ่มเท่านั้นที่เป็นสมาชิกของไดรฟ์ที่แชร์ได้

ใช้พารามิเตอร์ฟิลด์

หากต้องการระบุช่องที่จะแสดงผลในการตอบกลับ คุณสามารถตั้งค่า fields system parameter ด้วยเมธอดใดก็ได้ของทรัพยากร permissions หากคุณไม่ระบุพารามิเตอร์ fields เซิร์ฟเวอร์จะแสดงผลชุดฟิลด์เริ่มต้นที่เจาะจงสำหรับเมธอด เช่น เมธอด list จะแสดงเฉพาะฟิลด์ id, type, kind และ role สำหรับแต่ละไฟล์ หากต้องการแสดงช่องอื่น ให้ดูแสดงช่องที่เฉพาะเจาะจง

สร้างสิทธิ์

คุณต้องระบุข้อมูลใน 2 ฟิลด์ต่อไปนี้เมื่อสร้างสิทธิ์

  • 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 เพื่อเชื่อมโยงผู้ใช้หรือกลุ่มที่เฉพาะเจาะจงกับสิทธิ์ด้วย

เมื่อสร้างสิทธิ์ที่ type=domain คุณต้องระบุdomain ด้วยเพื่อเชื่อมโยงโดเมนที่เฉพาะเจาะจงกับสิทธิ์

วิธีสร้างสิทธิ์

  1. ใช้วิธี create กับทรัพยากร permissions โดยใช้พารามิเตอร์ fileId path สำหรับไฟล์หรือโฟลเดอร์ที่เชื่อมโยง
  2. ในเนื้อหาคำขอ ให้ระบุ type และ role
  3. หากเป็น type=user หรือ type=group ให้ระบุ emailAddress หากtype=domain โปรดระบุdomain

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีสร้างสิทธิ์ การตอบกลับจะแสดงอินสแตนซ์ของทรัพยากร permissions รวมถึง permissionId ที่กำหนด

คำขอ

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 ให้ไปที่เมนู > ไดเรกทอรี > กลุ่มเป้าหมาย

    ไปที่กลุ่มเป้าหมาย

    คุณต้องลงชื่อเข้าใช้ด้วยบัญชีที่มีสิทธิ์ของผู้ดูแลระบบขั้นสูงสำหรับงานนี้

  2. ในรายการกลุ่มเป้าหมาย ให้คลิกชื่อกลุ่มเป้าหมาย หากต้องการ สร้างกลุ่มเป้าหมาย โปรดดูสร้างกลุ่ม เป้าหมาย

  3. คัดลอกรหัสที่ไม่ซ้ำจาก URL กลุ่มเป้าหมาย https://admin.google.com/ac/targetaudiences/ID

  4. สร้างสิทธิ์ด้วย type=domain และตั้งค่าฟิลด์ domain เป็น ID.audience.googledomains.com

หากต้องการดูว่าผู้ใช้โต้ตอบกับกลุ่มเป้าหมายอย่างไร โปรดดูประสบการณ์ของผู้ใช้สําหรับการแชร์ลิงก์

รับสิทธิ์

หากต้องการรับสิทธิ์ ให้ใช้วิธี get ในทรัพยากร permissions ที่มีพารามิเตอร์เส้นทาง fileId และ permissionId หากไม่ทราบรหัสสิทธิ์ คุณสามารถแสดงรายการสิทธิ์ทั้งหมดโดยใช้วิธีlist

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีรับสิทธิ์ตามรหัส การตอบกลับจะแสดงผลอินสแตนซ์ของทรัพยากร permissions

คำขอ

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: โทเค็นหน้าเว็บที่ได้รับจากการเรียกใช้ list ก่อนหน้า ระบุโทเค็นนี้ เพื่อดึงข้อมูลหน้าถัดไป

  • 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 path เป็นไฟล์ โฟลเดอร์ หรือไดรฟ์ที่แชร์ที่เชื่อมโยง และตั้งค่าพารามิเตอร์ permissionId path เป็นสิทธิ์ที่จะเปลี่ยน หากต้องการค้นหา permissionId ให้ใช้วิธี list ในทรัพยากร permissions ที่มีพารามิเตอร์เส้นทาง fileId

  2. ระบุ role ใหม่ในคำขอ

คุณสามารถให้สิทธิ์ในไฟล์หรือโฟลเดอร์แต่ละรายการในไดรฟ์ที่แชร์ได้ แม้ว่าผู้ใช้หรือกลุ่มจะเป็นสมาชิกอยู่แล้วก็ตาม เช่น อเล็กซ์มี role=commenter เป็นส่วนหนึ่งของการเป็นสมาชิกไดรฟ์ที่แชร์ อย่างไรก็ตาม แอปของคุณสามารถให้สิทธิ์ Alex role=writer สำหรับไฟล์ในไดรฟ์ที่แชร์ได้ ในกรณีนี้ เนื่องจากบทบาทใหม่ มีสิทธิ์มากกว่าบทบาทที่ได้รับผ่านการเป็นสมาชิก สิทธิ์ใหม่ จึงกลายเป็นบทบาทที่มีผลสำหรับไฟล์หรือโฟลเดอร์

คุณใช้การอัปเดตผ่านความหมายของแพตช์ได้ ซึ่งหมายความว่าคุณสามารถแก้ไขทรัพยากรบางส่วนได้ คุณต้องตั้งค่าฟิลด์ที่ต้องการ แก้ไขในคำขออย่างชัดเจน ฟิลด์ที่ไม่ได้รวมไว้ในคำขอจะยังคงมีค่าเดิม ดูข้อมูลเพิ่มเติมได้ที่การทำงานกับทรัพยากรบางส่วน

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีเปลี่ยนสิทธิ์ในไฟล์หรือโฟลเดอร์จาก commenter เป็น writer การตอบกลับจะแสดงผลอินสแตนซ์ของทรัพยากร permissions

คำขอ

PATCH https://www.googleapis.com/drive/v3/files/FILE_ID/permissions/PERMISSION_ID
 
{
  "requests": [
    {
        "role": "writer"
    }
  ]
}

การตอบกลับ

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

กำหนดแหล่งที่มาของบทบาท

หากต้องการเปลี่ยนบทบาทในไฟล์หรือโฟลเดอร์ คุณต้องทราบแหล่งที่มาของบทบาท สำหรับไดรฟ์ที่แชร์ แหล่งที่มาของบทบาทอาจอิงตามการเป็นสมาชิกของไดรฟ์ที่แชร์ บทบาทในโฟลเดอร์ หรือบทบาทในไฟล์

หากต้องการกำหนดแหล่งที่มาของบทบาทสำหรับไดรฟ์ที่แชร์หรือรายการภายในไดรฟ์นั้น ให้เรียกใช้เมธอด get ในแหล่งข้อมูล permissions โดยมีพารามิเตอร์เส้นทาง fileId และ permissionId รวมถึงพารามิเตอร์ fields ที่ตั้งค่าเป็นฟิลด์ permissionDetails

หากต้องการค้นหา permissionId ให้ใช้วิธี list ในแหล่งข้อมูล permissions ที่มีพารามิเตอร์เส้นทาง fileId หากต้องการดึงข้อมูลฟิลด์ permissionDetails ในคำขอ list ให้ตั้งค่าพารามิเตอร์ fields เป็น permissions/permissionDetails

ฟิลด์นี้จะแสดงสิทธิ์ของไฟล์ทั้งหมดที่รับช่วงมาและสิทธิ์โดยตรงสำหรับผู้ใช้ กลุ่ม หรือโดเมน

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีระบุแหล่งที่มาของบทบาท การตอบกลับจะแสดงผล permissionDetails ของทรัพยากร permissions ฟิลด์ 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
    }
  ]
}

อัปเดตสิทธิ์หลายรายการด้วยคำขอแบบกลุ่ม

เราขอแนะนำอย่างยิ่งให้ใช้คำขอแบบกลุ่มเพื่อแก้ไขสิทธิ์หลายรายการ

ตัวอย่างต่อไปนี้แสดงการแก้ไขสิทธิ์แบบเป็นชุดด้วย ไลบรารีไคลเอ็นต์

Java

drive/snippets/drive_v3/src/main/java/ShareFile.java
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
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",
  )

Node.js

drive/snippets/drive_v3/file_snippets/share_file.js
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

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

}

.NET

drive/snippets/drive_v3/DriveV3Snippets/ShareFile.cs
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 เพื่อลบสิทธิ์ที่ใช้กับไฟล์หรือโฟลเดอร์ในไดรฟ์ที่แชร์โดยตรงได้ด้วย

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีเพิกถอนสิทธิ์เข้าถึงโดยการลบ permissionId หากทำสำเร็จ เนื้อหาการตอบกลับจะเป็นออบเจ็กต์ JSON ว่าง หากต้องการยืนยันว่าระบบนำสิทธิ์ออกแล้ว ให้ใช้เมธอด list ในทรัพยากร permissions ที่มีพารามิเตอร์เส้นทาง fileId

คำขอ

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

กำหนดวันที่หมดอายุเพื่อจำกัดการเข้าถึงไฟล์

เมื่อทำงานกับบุคคลในโปรเจ็กต์ที่มีความละเอียดอ่อน คุณอาจต้องการ จำกัดสิทธิ์เข้าถึงไฟล์บางไฟล์ในไดรฟ์หลังจากผ่านไประยะเวลาหนึ่ง สำหรับไฟล์ในไดรฟ์ของฉัน คุณสามารถกำหนดวันที่หมดอายุเพื่อ จำกัดหรือนำสิทธิ์เข้าถึงไฟล์ออกได้

วิธีกำหนดวันที่หมดอายุ

  • ใช้วิธี create กับแหล่งข้อมูล permissions และตั้งค่าฟิลด์ expirationTime (พร้อมกับฟิลด์อื่นๆ ที่จำเป็น) ดูข้อมูลเพิ่มเติมได้ที่สร้างสิทธิ์

  • ใช้วิธี update ในแหล่งข้อมูล permissions และตั้งค่าฟิลด์ expirationTime (พร้อมกับฟิลด์อื่นๆ ที่จำเป็น) ดูข้อมูลเพิ่มเติมได้ที่อัปเดต สิทธิ์

ฟิลด์ expirationTime จะระบุเวลาที่สิทธิ์หมดอายุโดยใช้วันที่และเวลาตาม RFC 3339 เวลาหมดอายุมีข้อจำกัดดังนี้

  • ตั้งค่าได้เฉพาะกับสิทธิ์ของผู้ใช้และกลุ่มเท่านั้น
  • เวลาต้องเป็นเวลาในอนาคต
  • เวลาต้องไม่เกิน 1 ปีนับจากนี้

ดูข้อมูลเพิ่มเติมเกี่ยวกับวันที่หมดอายุได้ที่บทความต่อไปนี้