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

ไฟล์ โฟลเดอร์ และไดรฟ์ที่แชร์ทั้งหมดใน 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 วันที่และเวลา ที่ใช้เวลาเพียง 2 นาที เวลาหมดอายุมีข้อจำกัดดังต่อไปนี้

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

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

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

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

ในทางกลับกัน หากไฟล์รับค่า 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"
}

ใช้กลุ่มเป้าหมาย

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

วิธีใช้กลุ่มเป้าหมาย

  1. จากคอนโซลผู้ดูแลระบบของ Google ให้ไปที่เมนู > ไดเรกทอรี > กลุ่มเป้าหมาย

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

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

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

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

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

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

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

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

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

  • สร้างสิทธิ์ของไฟล์ที่ให้สิทธิ์ผู้ใช้ที่ระบุ (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;
        }
    }
}