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

ไฟล์ โฟลเดอร์ และไดรฟ์ที่แชร์ทั้งหมดใน Google ไดรฟ์จะมีทรัพยากรสิทธิ์ที่เชื่อมโยงกัน ทรัพยากรแต่ละรายการจะระบุสิทธิ์สำหรับ type ที่เจาะจง (ผู้ใช้ กลุ่ม โดเมน ทุกคน) และ role เช่น "ผู้แสดงความคิดเห็น" หรือ "ผู้อ่าน" ตัวอย่างเช่น ไฟล์อาจมี สิทธิ์ที่ให้สิทธิ์เข้าถึงแบบอ่านอย่างเดียวสำหรับผู้ใช้บางราย (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 จึงจะจัดการการเป็นสมาชิกไดรฟ์ที่แชร์ได้ เฉพาะผู้ใช้และกลุ่มเท่านั้นที่เป็นสมาชิกของไดรฟ์ที่แชร์ได้

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

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

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

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

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

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

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

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

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

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

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

ความสามารถ

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

เช่น เมื่อธำรงเข้าสู่ระบบแอปและพยายามแชร์ไฟล์ บทบาทของอเล็กซ์จะได้รับการตรวจสอบสิทธิ์ในไฟล์ หากบทบาทอนุญาตให้แชร์ไฟล์ ระบบจะเติม capabilities ที่เกี่ยวข้องกับไฟล์ เช่น canShare โดยสัมพันธ์กับบทบาท หากธำรงต้องการแชร์ไฟล์ แอปของคุณจะตรวจสอบ 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. ใช้เมธอด permissions.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

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

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

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

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

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

คำขอ

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 ได้ในส่วนความสามารถด้านบน

หากต้องการตรวจสอบความสามารถ ให้เรียก files.get โดยตั้งค่า 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
  }
}

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

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

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

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

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

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

คำขอ

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

คำตอบ

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

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

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

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

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

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

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

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

คำขอ

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

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

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

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

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

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

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

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีเพิกถอนสิทธิ์เข้าถึงด้วยการลบ permissionId หากสำเร็จ เนื้อหาการตอบกลับจะว่างเปล่า หากต้องการยืนยันว่ามีการนำสิทธิ์ออกแล้ว ให้ใช้ permissions.list ร่วมกับ 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;
        }
    }
}