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

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

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

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

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

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

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

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

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

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

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

ดูตัวอย่างการดึงข้อมูลไฟล์ capabilities ได้ที่รับความสามารถของไฟล์

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

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

หากต้องการตรวจสอบความสามารถ ให้เรียกใช้เมธอด get() ในแหล่งข้อมูล files โดยมีพารามิเตอร์เส้นทาง fileId และพารามิเตอร์ fields ตั้งค่าเป็นฟิลด์ capabilities ดูข้อมูลเพิ่มเติมเกี่ยวกับการส่งคืนฟิลด์โดยใช้พารามิเตอร์ fields ได้ที่ส่งคืนฟิลด์ที่เฉพาะเจาะจง

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

คำขอ

GET https://www.googleapis.com/drive/v3/files/FILE_ID?fields=capabilities

การตอบกลับ

{
  "capabilities": {
    "canAcceptOwnership": false,
    "canAddChildren": false,
    "canAddMyDriveParent": false,
    "canChangeCopyRequiresWriterPermission": true,
    "canChangeItemDownloadRestriction": true,
    "canChangeSecurityUpdateEnabled": false,
    "canChangeViewersCanCopyContent": true,
    "canComment": true,
    "canCopy": true,
    "canDelete": true,
    "canDisableInheritedPermissions": false,
    "canDownload": true,
    "canEdit": true,
    "canEnableInheritedPermissions": true,
    "canListChildren": false,
    "canModifyContent": true,
    "canModifyContentRestriction": true,
    "canModifyEditorContentRestriction": true,
    "canModifyOwnerContentRestriction": true,
    "canModifyLabels": true,
    "canMoveChildrenWithinDrive": false,
    "canMoveItemIntoTeamDrive": true,
    "canMoveItemOutOfDrive": true,
    "canMoveItemWithinDrive": true,
    "canReadLabels": true,
    "canReadRevisions": true,
    "canRemoveChildren": false,
    "canRemoveContentRestriction": false,
    "canRemoveMyDriveParent": true,
    "canRename": true,
    "canShare": true,
    "canTrash": true,
    "canUntrash": true
  }
}

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

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

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

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

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

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

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

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

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

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

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

สร้างสิทธิ์

เมื่อสร้างสิทธิ์ คุณต้องระบุข้อมูลใน 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"
    }
  ]
}

อัปเดตสิทธิ์

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

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

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

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

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

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

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

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

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

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

คำขอ

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

การตอบกลับ

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

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

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

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

Java

drive/snippets/drive_v3/src/main/java/ShareFile.java
import com.google.api.client.googleapis.batch.BatchRequest;
import com.google.api.client.googleapis.batch.json.JsonBatchCallback;
import com.google.api.client.googleapis.json.GoogleJsonError;
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.HttpHeaders;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.drive.Drive;
import com.google.api.services.drive.DriveScopes;
import com.google.api.services.drive.model.Permission;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/* Class to demonstrate use-case of modify permissions. */
public class ShareFile {

  /**
   * Batch permission modification.
   * realFileId file Id.
   * realUser User Id.
   * realDomain Domain of the user ID.
   *
   * @return list of modified permissions if successful, {@code null} otherwise.
   * @throws IOException if service account credentials file not found.
   */
  public static List<String> shareFile(String realFileId, String realUser, String realDomain)
      throws IOException {
        /* Load pre-authorized user credentials from the environment.
         TODO(developer) - See https://developers.google.com/identity for
         guides on implementing OAuth2 for your application.application*/
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
        .createScoped(Arrays.asList(DriveScopes.DRIVE_FILE));
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

    // Build a new authorized API client service.
    Drive service = new Drive.Builder(new NetHttpTransport(),
        GsonFactory.getDefaultInstance(),
        requestInitializer)
        .setApplicationName("Drive samples")
        .build();

    final List<String> ids = new ArrayList<String>();


    JsonBatchCallback<Permission> callback = new JsonBatchCallback<Permission>() {
      @Override
      public void onFailure(GoogleJsonError e,
                            HttpHeaders responseHeaders)
          throws IOException {
        // Handle error
        System.err.println(e.getMessage());
      }

      @Override
      public void onSuccess(Permission permission,
                            HttpHeaders responseHeaders)
          throws IOException {
        System.out.println("Permission ID: " + permission.getId());

        ids.add(permission.getId());

      }
    };
    BatchRequest batch = service.batch();
    Permission userPermission = new Permission()
        .setType("user")
        .setRole("writer");

    userPermission.setEmailAddress(realUser);
    try {
      service.permissions().create(realFileId, userPermission)
          .setFields("id")
          .queue(batch, callback);

      Permission domainPermission = new Permission()
          .setType("domain")
          .setRole("reader");

      domainPermission.setDomain(realDomain);

      service.permissions().create(realFileId, domainPermission)
          .setFields("id")
          .queue(batch, callback);

      batch.execute();

      return ids;
    } catch (GoogleJsonResponseException e) {
      // TODO(developer) - handle error appropriately
      System.err.println("Unable to modify permission: " + e.getDetails());
      throw e;
    }
  }
}

Python

drive/snippets/drive-v3/file_snippet/share_file.py
import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def share_file(real_file_id, real_user, real_domain):
  """Batch permission modification.
  Args:
      real_file_id: file Id
      real_user: User ID
      real_domain: Domain of the user ID
  Prints modified permissions

  Load pre-authorized user credentials from the environment.
  TODO(developer) - See https://developers.google.com/identity
  for guides on implementing OAuth2 for the application.
  """
  creds, _ = google.auth.default()

  try:
    # create drive api client
    service = build("drive", "v3", credentials=creds)
    ids = []
    file_id = real_file_id

    def callback(request_id, response, exception):
      if exception:
        # Handle error
        print(exception)
      else:
        print(f"Request_Id: {request_id}")
        print(f'Permission Id: {response.get("id")}')
        ids.append(response.get("id"))

    # pylint: disable=maybe-no-member
    batch = service.new_batch_http_request(callback=callback)
    user_permission = {
        "type": "user",
        "role": "writer",
        "emailAddress": "user@example.com",
    }
    batch.add(
        service.permissions().create(
            fileId=file_id,
            body=user_permission,
            fields="id",
        )
    )
    domain_permission = {
        "type": "domain",
        "role": "reader",
        "domain": "example.com",
    }
    domain_permission["domain"] = real_domain
    batch.add(
        service.permissions().create(
            fileId=file_id,
            body=domain_permission,
            fields="id",
        )
    )
    batch.execute()

  except HttpError as error:
    print(f"An error occurred: {error}")
    ids = None

  return ids


if __name__ == "__main__":
  share_file(
      real_file_id="1dUiRSoAQKkM3a4nTPeNQWgiuau1KdQ_l",
      real_user="gduser1@workspacesamples.dev",
      real_domain="workspacesamples.dev",
  )

Node.js

drive/snippets/drive_v3/file_snippets/share_file.js
/**
 * 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
<?php
use Google\Client;
use Google\Service\Drive;
function shareFile()
{
    try {
        $client = new Client();
        $client->useApplicationDefaultCredentials();
        $client->addScope(Drive::DRIVE);
        $driveService = new Drive($client);
        $realFileId = readline("Enter File Id: ");
        $realUser = readline("Enter user email address: ");
        $realDomain = readline("Enter domain name: ");
        $ids = array();
            $fileId = '1sTWaJ_j7PkjzaBWtNc3IzovK5hQf21FbOw9yLeeLPNQ';
            $fileId = $realFileId;
            $driveService->getClient()->setUseBatch(true);
            try {
                $batch = $driveService->createBatch();

                $userPermission = new Drive\Permission(array(
                    'type' => 'user',
                    'role' => 'writer',
                    'emailAddress' => 'user@example.com'
                ));
                $userPermission['emailAddress'] = $realUser;
                $request = $driveService->permissions->create(
                    $fileId, $userPermission, array('fields' => 'id'));
                $batch->add($request, 'user');
                $domainPermission = new Drive\Permission(array(
                    'type' => 'domain',
                    'role' => 'reader',
                    'domain' => 'example.com'
                ));
                $userPermission['domain'] = $realDomain;
                $request = $driveService->permissions->create(
                    $fileId, $domainPermission, array('fields' => 'id'));
                $batch->add($request, 'domain');
                $results = $batch->execute();

                foreach ($results as $result) {
                    if ($result instanceof Google_Service_Exception) {
                        // Handle error
                        printf($result);
                    } else {
                        printf("Permission ID: %s\n", $result->id);
                        array_push($ids, $result->id);
                    }
                }
            } finally {
                $driveService->getClient()->setUseBatch(false);
            }
            return $ids;
    } catch(Exception $e) {
        echo "Error Message: ".$e;
    }

}

.NET

drive/snippets/drive_v3/DriveV3Snippets/ShareFile.cs
using Google.Apis.Auth.OAuth2;
using Google.Apis.Drive.v3;
using Google.Apis.Drive.v3.Data;
using Google.Apis.Requests;
using Google.Apis.Services;

namespace DriveV3Snippets
{
    // Class to demonstrate use-case of Drive modify permissions.
    public class ShareFile
    {
        /// <summary>
        /// Batch permission modification.
        /// </summary>
        /// <param name="realFileId">File id.</param>
        /// <param name="realUser">User id.</param>
        /// <param name="realDomain">Domain id.</param>
        /// <returns>list of modified permissions, null otherwise.</returns>
        public static IList<String> DriveShareFile(string realFileId, string realUser, string realDomain)
        {
            try
            {
                /* Load pre-authorized user credentials from the environment.
                 TODO(developer) - See https://developers.google.com/identity for
                 guides on implementing OAuth2 for your application. */
                GoogleCredential credential = GoogleCredential.GetApplicationDefault()
                    .CreateScoped(DriveService.Scope.Drive);

                // Create Drive API service.
                var service = new DriveService(new BaseClientService.Initializer
                {
                    HttpClientInitializer = credential,
                    ApplicationName = "Drive API Snippets"
                });

                var ids = new List<String>();
                var batch = new BatchRequest(service);
                BatchRequest.OnResponse<Permission> callback = delegate(
                    Permission permission,
                    RequestError error,
                    int index,
                    HttpResponseMessage message)
                {
                    if (error != null)
                    {
                        // Handle error
                        Console.WriteLine(error.Message);
                    }
                    else
                    {
                        Console.WriteLine("Permission ID: " + permission.Id);
                    }
                };
                Permission userPermission = new Permission()
                {
                    Type = "user",
                    Role = "writer",
                    EmailAddress = realUser
                };

                var request = service.Permissions.Create(userPermission, realFileId);
                request.Fields = "id";
                batch.Queue(request, callback);

                Permission domainPermission = new Permission()
                {
                    Type = "domain",
                    Role = "reader",
                    Domain = realDomain
                };
                request = service.Permissions.Create(domainPermission, realFileId);
                request.Fields = "id";
                batch.Queue(request, callback);
                var task = batch.ExecuteAsync();
                task.Wait();
                return ids;
            }
            catch (Exception e)
            {
                // TODO(developer) - handle error appropriately
                if (e is AggregateException)
                {
                    Console.WriteLine("Credential Not found");
                }
                else
                {
                    throw;
                }
            }
            return null;
        }
    }
}

ลบสิทธิ์

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

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

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

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

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

คำขอ

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

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

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

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

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

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

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

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

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