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

ไฟล์ โฟลเดอร์ และไดรฟ์ที่แชร์ทุกรายการใน 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

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

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

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

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

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

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

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

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

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

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() ยังใช้เพื่อลบสิทธิ์ที่ใช้กับไฟล์หรือโฟลเดอร์ในไดรฟ์ที่แชร์โดยตรงด้วย

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

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

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

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

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",
  )

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

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

หัวข้อที่เกี่ยวข้อง

• ปกป้องเนื้อหาไฟล์
• เข้าถึงไฟล์ในไดรฟ์ที่แชร์ลิงก์โดยใช้คีย์ทรัพยากร
• บทบาทและสิทธิ์