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

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

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

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

สถานการณ์การแชร์มี 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 เฉพาะผู้ใช้และกลุ่มเท่านั้นที่จะเป็นสมาชิกของไดรฟ์ที่แชร์ได้

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

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

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

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

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

ช่อง expirationTime ระบุเวลาที่สิทธิ์จะหมดอายุโดยใช้ RFC 3339 date-time เวลาหมดอายุมีข้อจํากัดต่อไปนี้

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

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

การเผยแพร่สิทธิ์

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

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

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

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

ความสามารถ

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

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

โปรดดูตัวอย่างการดึงข้อมูลไฟล์ capabilities ที่หัวข้อยืนยันสิทธิ์ของผู้ใช้

สร้างสิทธิ์

คุณต้องกรอกข้อมูลใน 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() กับพารามิเตอร์เส้นทาง fileId สำหรับไฟล์หรือโฟลเดอร์ที่เชื่อมโยง
  2. ในเนื้อหาของคำขอ ให้ระบุ type และ role
  3. หากเป็น type=user หรือ type=group ให้ระบุ emailAddress หากเป็น type=domain ให้ระบุ domain

แสดงตัวอย่าง

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีสร้างสิทธิ์ การตอบกลับจะแสดงอินสแตนซ์ของทรัพยากร Permission รวมถึง 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

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

เรียกข้อมูลสิทธิ์ทั้งหมดสำหรับไฟล์ โฟลเดอร์ หรือไดรฟ์ที่แชร์

ใช้เมธอด list() ในทรัพยากร permissions เพื่อเรียกข้อมูลสิทธิ์ทั้งหมดสำหรับไฟล์ โฟลเดอร์ หรือไดรฟ์ที่แชร์

แสดงตัวอย่าง

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

คำขอ

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

ยืนยันสิทธิ์ของผู้ใช้

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

ดูข้อมูลเพิ่มเติมเกี่ยวกับ capabilities ได้ที่ส่วนความสามารถ

หากต้องการตรวจสอบความสามารถ ให้เรียกใช้เมธอด 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,
    "canChangeSecurityUpdateEnabled": false,
    "canComment": true,
    "canCopy": true,
    "canDelete": true,
    "canDownload": true,
    "canEdit": true,
    "canListChildren": false,
    "canModifyContent": true,
    "canModifyContentRestriction": true,
    "canModifyLabels": true,
    "canMoveChildrenWithinDrive": false,
    "canMoveItemOutOfDrive": true,
    "canMoveItemWithinDrive": true,
    "canReadLabels": true,
    "canReadRevisions": true,
    "canRemoveChildren": false,
    "canRemoveMyDriveParent": true,
    "canRename": true,
    "canShare": true,
    "canTrash": true,
    "canUntrash": true
  }
}

ระบุแหล่งที่มาของบทบาทสำหรับไฟล์และโฟลเดอร์ในไดรฟ์ที่แชร์

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

หากต้องการระบุแหล่งที่มาของบทบาทสำหรับไดรฟ์ที่แชร์หรือรายการภายในไดรฟ์นั้น ให้เรียกใช้เมธอด 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
    }
  ]
}

เปลี่ยนแปลงสิทธิ์

หากต้องการเปลี่ยนสิทธิ์ในไฟล์หรือโฟลเดอร์ ให้เปลี่ยนบทบาทที่มอบหมายโดยทำดังนี้

  1. เรียกใช้เมธอด update() ในทรัพยากร permissions โดยตั้งค่าพารามิเตอร์เส้นทาง permissionId เป็นสิทธิ์ในการเปลี่ยน และตั้งค่าพารามิเตอร์เส้นทาง fileId เป็นไฟล์ โฟลเดอร์ หรือไดรฟ์ที่แชร์ที่เกี่ยวข้อง หากต้องการค้นหา permissionId ให้ใช้เมธอด list() ในแหล่งข้อมูล permissions ที่มีพารามิเตอร์เส้นทาง fileId

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

คุณสามารถให้สิทธิ์ในไฟล์หรือโฟลเดอร์แต่ละรายการในไดรฟ์ที่แชร์ได้ แม้ว่าผู้ใช้หรือกลุ่มจะเป็นสมาชิกอยู่แล้วก็ตาม ตัวอย่างเช่น Alex มี role=commenter เป็นส่วนหนึ่งของการเป็นสมาชิกไดรฟ์ที่แชร์ อย่างไรก็ตาม แอปของคุณสามารถให้สิทธิ์ role=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"
}

แสดงรายการและแก้ไขข้อเสนอการเข้าถึงที่รอดำเนินการ

ข้อเสนอการเข้าถึงเป็นข้อเสนอจากผู้ส่งคำขอไปจนถึงผู้อนุมัติที่ให้สิทธิ์เข้าถึงรายการในไดรฟ์แก่ผู้รับ

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

Drive API มีแหล่งข้อมูล accessproposals เพื่อให้คุณดูและแก้ไขข้อเสนอการเข้าถึงที่รอดำเนินการได้ วิธีการของaccessproposalsทรัพยากรจะทำงานกับไฟล์ โฟลเดอร์ ไฟล์ภายในไดรฟ์ที่แชร์ แต่ไม่ทำงานในไดรฟ์ที่แชร์

คําศัพท์ต่อไปนี้ใช้เฉพาะกับข้อเสนอการเข้าถึง

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

แสดงรายการข้อเสนอการเข้าถึงที่รอดำเนินการ

หากต้องการแสดงรายการข้อเสนอการเข้าถึงที่รอดำเนินการทั้งหมดในรายการในไดรฟ์ ให้เรียกใช้เมธอด list() ในทรัพยากร accessproposals และรวมพารามิเตอร์เส้นทาง fileId

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

เนื้อหาตอบกลับประกอบด้วยออบเจ็กต์ AccessProposal ที่แสดงรายการข้อเสนอการเข้าถึงที่ยังไม่ได้รับการแก้ไขในไฟล์

ออบเจ็กต์ AccessProposal มีข้อมูลเกี่ยวกับข้อเสนอแต่ละรายการ เช่น ผู้ขอ ผู้รับ และข้อความที่ผู้ขอเพิ่ม นอกจากนี้ยังมีออบเจ็กต์ AccessProposalRoleAndView ที่จัดกลุ่ม role ที่ผู้ขอเสนอด้วย view ด้วย เนื่องจาก role เป็นฟิลด์ที่ซ้ำได้ จึงอาจมีหลายรายการสำหรับข้อเสนอแต่ละรายการ ตัวอย่างเช่น โปรไฟล์อาจประกอบด้วยออบเจ็กต์ AccessProposalRoleAndView ของ role=reader และ view=published รวมถึงออบเจ็กต์ AccessProposalRoleAndView เพิ่มเติมที่มีเฉพาะค่า role=writer ดูข้อมูลเพิ่มเติมได้ที่ยอดดู

ส่งพารามิเตอร์การค้นหาต่อไปนี้เพื่อปรับแต่งการใส่เลขหน้าหรือตัวกรองข้อเสนอการเข้าถึง

  • pageToken: โทเค็นหน้าเว็บที่ได้รับจากการเรียกใช้รายการก่อนหน้า ระบุโทเค็นนี้เพื่อดึงข้อมูลหน้าถัดไป

  • pageSize: จำนวนข้อเสนอการเข้าถึงสูงสุดที่จะแสดงต่อหน้า

แก้ไขข้อเสนอการเข้าถึงที่รอดำเนินการ

หากต้องการแก้ไขคําขอสิทธิ์เข้าถึงที่รอดําเนินการทั้งหมดในรายการในไดรฟ์ ให้เรียกใช้เมธอด resolve() ในทรัพยากร accessproposals และใส่พารามิเตอร์เส้นทาง fileId และ proposalId

เมธอด resolve() มีพารามิเตอร์การค้นหา action ซึ่งระบุการดำเนินการกับข้อเสนอ ออบเจ็กต์ Action จะติดตามการเปลี่ยนแปลงสถานะของข้อเสนอเพื่อให้เราทราบว่าข้อเสนอได้รับการยอมรับหรือถูกปฏิเสธ

นอกจากนี้ เมธอด resolve() ยังมีพารามิเตอร์การค้นหาที่ไม่บังคับของ role และ view ด้วย บทบาทที่รองรับมีเพียง writer, commenter และ reader หากไม่ได้ระบุบทบาท ระบบจะใช้ reader เป็นค่าเริ่มต้น พารามิเตอร์การค้นหาที่ไม่บังคับเพิ่มเติมของ send_notification ช่วยให้คุณส่งการแจ้งเตือนทางอีเมลไปยังผู้ส่งคำขอเมื่อมีการยอมรับหรือปฏิเสธข้อเสนอ

เช่นเดียวกับวิธีการ list() ผู้ใช้ที่แก้ไขข้อเสนอต้องมีความสามารถ can_approve_access_proposals ในไฟล์ ดูข้อมูลเพิ่มเติมเกี่ยวกับ capabilities ได้ที่ส่วนความสามารถ

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

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

หลังจากส่งข้อเสนอไปยังเมธอด resolve() แล้ว การแชร์ก็เสร็จสมบูรณ์ ระบบจะไม่แสดง AccessProposal ผ่านวิธี list() อีกต่อไป เมื่อยอมรับข้อเสนอแล้ว ผู้ใช้ต้องใช้คอลเล็กชัน permissions เพื่ออัปเดตสิทธิ์ในไฟล์หรือโฟลเดอร์ ดูข้อมูลเพิ่มเติมได้ที่ส่วนเปลี่ยนสิทธิ์

เพิกถอนสิทธิ์เข้าถึงไฟล์หรือโฟลเดอร์

หากต้องการเพิกถอนสิทธิ์เข้าถึงไฟล์หรือโฟลเดอร์ ให้เรียกใช้เมธอด delete() ในทรัพยากร permissions โดยตั้งค่าพารามิเตอร์เส้นทาง fileId และ permissionId เพื่อลบสิทธิ์

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

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

นอกจากนี้ วิธีการ delete() ยังใช้เพื่อลบสิทธิ์ที่ใช้กับไฟล์หรือโฟลเดอร์ในไดรฟ์ที่แชร์โดยตรงด้วย

แสดงตัวอย่าง

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

คำขอ

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

โอนความเป็นเจ้าของไฟล์ไปยังบัญชี Google Workspace อื่นในองค์กรเดียวกัน

คุณสามารถโอนการเป็นเจ้าของไฟล์ที่มีอยู่ใน "ไดรฟ์ของฉัน" จากบัญชี Google Workspace หนึ่งไปยังบัญชีอื่นในองค์กรเดียวกันได้ องค์กรที่เป็นเจ้าของไดรฟ์ที่แชร์ จะเป็นเจ้าของไฟล์ภายในไดรฟ์ที่แชร์นั้น ดังนั้นจึงไม่รองรับการโอนการเป็นเจ้าของสำหรับไฟล์และโฟลเดอร์ในไดรฟ์ที่แชร์ ผู้จัดระเบียบของไดรฟ์ที่แชร์สามารถย้ายรายการจากไดรฟ์ที่แชร์นั้นไปยัง "ไดรฟ์ของฉัน" ของตนเอง ซึ่งจะเป็นการโอนการเป็นเจ้าของไปยังผู้จัดระเบียบ

หากต้องการโอนการเป็นเจ้าของไฟล์ใน "ไดรฟ์ของฉัน" ให้ทําอย่างใดอย่างหนึ่งต่อไปนี้

  • สร้างไฟล์ที่ให้สิทธิ์แก่ผู้ใช้ที่เจาะจง (type=user) สิทธิ์เข้าถึงระดับเจ้าของ (role=owner)

  • อัปเดตสิทธิ์ของไฟล์ที่มีอยู่ด้วย role=owner และโอนการเป็นเจ้าของไปยังผู้ใช้ที่ระบุ (transferOwnership=true)

โอนการเป็นเจ้าของไฟล์จากบัญชีผู้ใช้รายหนึ่งไปยังอีกบัญชีหนึ่ง

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

  1. เจ้าของปัจจุบันจะเป็นผู้เริ่มการโอนการเป็นเจ้าของโดยการสร้างหรืออัปเดตสิทธิ์ในไฟล์ของเจ้าของในอนาคต สิทธิ์ต้องมีการตั้งค่า role=writer, type=user และ pendingOwner=true หากเจ้าของปัจจุบันกำลังสร้างสิทธิ์สำหรับผู้ที่อาจเป็นเจ้าของ ระบบจะส่งอีเมลแจ้งเตือนไปยังผู้ที่มีสิทธิ์รับโอนเพื่อแจ้งให้รับการเป็นเจ้าของไฟล์

  2. ผู้มีโอกาสเป็นเจ้าของยอมรับคำขอโอนการเป็นเจ้าของโดยการสร้างหรืออัปเดตสิทธิ์ในไฟล์ สิทธิ์ต้องมีการตั้งค่าต่อไปนี้ role=owner และ transferOwnership=true หากเจ้าของในอนาคตกำลังสร้างสิทธิ์ใหม่ ระบบจะส่งการแจ้งเตือนทางอีเมลไปยังเจ้าของคนก่อนหน้าเพื่อแจ้งให้ทราบว่ามีการโอนการเป็นเจ้าของแล้ว

เมื่อโอนไฟล์แล้ว บทบาทของเจ้าของคนก่อนจะถูกดาวน์เกรดเป็น writer

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

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

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

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
/**
 * Batch permission modification
 * @param{string} fileId file ID
 * @param{string} targetUserEmail username
 * @param{string} targetDomainName domain
 * @return{list} permission id
 * */
async function shareFile(fileId, targetUserEmail, targetDomainName) {
  const {GoogleAuth} = require('google-auth-library');
  const {google} = require('googleapis');

  // Get credentials and build service
  // TODO (developer) - Use appropriate auth mechanism for your app
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });
  const service = google.drive({version: 'v3', auth});
  const permissionIds = [];

  const permissions = [
    {
      type: 'user',
      role: 'writer',
      emailAddress: targetUserEmail, // 'user@partner.com',
    },
    {
      type: 'domain',
      role: 'writer',
      domain: targetDomainName, // 'example.com',
    },
  ];
  // Note: Client library does not currently support HTTP batch
  // requests. When possible, use batched requests when inserting
  // multiple permissions on the same item. For this sample,
  // permissions are inserted serially.
  for (const permission of permissions) {
    try {
      const result = await service.permissions.create({
        resource: permission,
        fileId: fileId,
        fields: 'id',
      });
      permissionIds.push(result.data.id);
      console.log(`Inserted permission id: ${result.data.id}`);
    } catch (err) {
      // TODO(developer): Handle failed permissions
      console.error(err);
    }
  }
  return permissionIds;
}

PHP

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