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

ไฟล์ โฟลเดอร์ และไดรฟ์ที่แชร์ทุกรายการใน 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
  • ประเมินใหม่เมื่อย้าย: การย้ายรายการไปยังโฟลเดอร์หลักใหม่จะประเมินใหม่ และใช้สิทธิ์ของโฟลเดอร์หลักใหม่กับรายการและรายการย่อย

ลิงก์ไฟล์และการควบคุมการเข้าถึง

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

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

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

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

แต่ทรัพยากร files จะมีคอลเล็กชันของฟิลด์บูลีน capabilities (เช่น canComment, canShare หรือ canDelete) ที่ Google Drive API คำนวณแบบไดนามิกตามบทบาทของผู้ใช้และการตั้งค่ารายการ

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

เมื่อแสดงผล UI ของแอป ให้ตรวจสอบ files.capabilities แทนที่จะแยกวิเคราะห์ สิทธิ์โดยตรง

  • เรียกใช้เมธอด files.get ด้วย fields=capabilities ดูข้อมูลเพิ่มเติมได้ที่ แสดงผลฟิลด์ที่เฉพาะเจาะจง
  • ใช้ค่าสถานะบูลีนที่ส่งคืนเพื่อเปิดหรือปิดใช้การดำเนินการที่เกี่ยวข้องใน อินเทอร์เฟซของคุณ เช่น ปิดใช้การแสดงความคิดเห็นหาก canComment เป็น false

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

ตารางต่อไปนี้แสดงบทบาทและเงื่อนไขที่จำเป็นสำหรับการแชร์ ทรัพยากรในไดรฟ์ในสถานที่ต่างๆ และรายการประเภทต่างๆ

ตำแหน่ง รายการ บทบาทที่จำเป็น ข้อจำกัดหลัก
ไดรฟ์ของฉัน ไฟล์หรือโฟลเดอร์ owner หรือ writer ต้องใช้ owner หาก writersCanShare=false
การทำให้สิทธิ์การเข้าถึงที่มีวันหมดอายุในโฟลเดอร์ต้องใช้ reader (ดูกำหนดวันที่หมดอายุ)
ไดรฟ์ที่แชร์ ไฟล์ organizer, fileOrganizer หรือ writer ระบบจะถือว่า writersCanShare เป็น true เสมอ
ไดรฟ์ที่แชร์ โฟลเดอร์ organizer fileOrganizer ยังแชร์ได้ด้วยหาก sharingFoldersRequiresOrganizerPermission เป็น false
ไดรฟ์ที่แชร์ การเป็นสมาชิก organizer ใช้กับ user หรือ group เท่านั้น (ไม่ใช่โดเมน)

จัดการสิทธิ์

ตารางต่อไปนี้จะสรุปวิธีการที่ใช้ได้ในแหล่งข้อมูล permissions

วิธีการ ปลายทาง API พารามิเตอร์สำคัญ ข้อมูลอ้างอิง
สร้าง POST https://www.googleapis.com/drive/v3/files/{fileId}/permissions role type emailAddress หรือdomain permissions.create
รับ GET https://www.googleapis.com/drive/v3/files/{fileId}/permissions/{permissionId} fields permissions.get
List GET https://www.googleapis.com/drive/v3/files/{fileId}/permissions pageSize, supportsAllDrives, pageToken permissions.list
อัปเดต PATCH https://www.googleapis.com/drive/v3/files/{fileId}/permissions/{permissionId} role, allowFileDiscovery permissions.update
ลบ DELETE https://www.googleapis.com/drive/v3/files/{fileId}/permissions/{permissionId} supportsAllDrives permissions.delete

สร้างสิทธิ์

หากต้องการแชร์ไฟล์ โฟลเดอร์ หรือไดรฟ์ที่แชร์ ให้เรียกใช้เมธอด create ในแหล่งข้อมูล permissions ด้วย fileId การสร้างสิทธิ์จะเพิ่มรายการ ACL ใหม่ลงในรายการและแสดงผล permissionId ที่กำหนด

ในเนื้อหาของคำขอ ให้ระบุช่องต่อไปนี้

  • role: ระดับการเข้าถึง ที่จะให้ (เช่น reader, commenter หรือ writer) ดูรายการทั้งหมดได้ที่บทบาทและสิทธิ์
  • type: ขอบเขต ของผู้รับเงินช่วยเหลือ (user, group, domain หรือ anyone)
  • ตัวระบุผู้รับเงิน (ต้องระบุตาม type)
    • emailAddress: ต้องระบุเมื่อ type เป็น user หรือ group
    • domain ต้องระบุเมื่อ type เป็น domain

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีสร้างสิทธิ์ การตอบกลับจะแสดงผลอินสแตนซ์ของทรัพยากร permissions รวมถึง permissionId ที่กำหนด

คำขอ

POST https://www.googleapis.com/drive/v3/files/FILE_ID/permissions
 
{
  "role": "commenter",
  "type": "user",
  "emailAddress": "alex@altostrat.com"
}

การตอบกลับ

{
  "kind": "drive#permission",
  "id": "PERMISSION_ID",
  "type": "user",
  "role": "commenter"
}

แชร์กับกลุ่มเป้าหมาย

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

หากต้องการแชร์กับกลุ่มเป้าหมาย ให้ตั้งค่า type=domain และตั้งค่า domain เป็น <TARGET_AUDIENCE_ID>.audience.googledomains.com ดูรายละเอียดเกี่ยวกับการค้นหาหรือ สร้างกลุ่มเป้าหมายในคอนโซลผู้ดูแลระบบของ Google ได้ที่หัวข้อเกี่ยวกับกลุ่ม เป้าหมาย

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

รับสิทธิ์

หากต้องการรับสิทธิ์ ให้เรียกใช้เมธอด get ในทรัพยากร permissions โดยใช้พารามิเตอร์เส้นทาง fileId และ permissionId หากไม่ทราบรหัสสิทธิ์ ให้แสดงรายการสิทธิ์ทั้งหมดก่อน

สิทธิ์ในการแสดงรายการ

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

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

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

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

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

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

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

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

คำขอ

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

การตอบกลับ

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

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

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

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

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

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

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

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

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

คำขอ

PATCH https://www.googleapis.com/drive/v3/files/FILE_ID/permissions/PERMISSION_ID
 
{
  "role": "writer"
}

การตอบกลับ

{
  "kind": "drive#permission",
  "id": "PERMISSION_ID",
  "type": "user",
  "role": "writer"
}

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

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

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

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

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

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
import {GoogleAuth} from 'google-auth-library';
import {google} from 'googleapis';

/**
 * Shares a file with a user and a domain.
 * @param {string} fileId The ID of the file to share.
 * @param {string} targetUserEmail The email address of the user to share with.
 * @param {string} targetDomainName The domain to share with.
 * @return {Promise<Array<string>>} A promise that resolves to an array of permission IDs.
 */
async function shareFile(fileId, targetUserEmail, targetDomainName) {
  // Authenticate with Google and get an authorized client.
  // TODO (developer): Use an appropriate auth mechanism for your app.
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });

  // Create a new Drive API client (v3).
  const service = google.drive({version: 'v3', auth});

  /** @type {Array<string>} */
  const permissionIds = [];

  // The permissions to create.
  const permissions = [
    {
      type: 'user',
      role: 'writer',
      emailAddress: targetUserEmail, // e.g., 'user@partner.com'
    },
    {
      type: 'domain',
      role: 'writer',
      domain: targetDomainName, // e.g., 'example.com'
    },
  ];

  // Iterate through the permissions and create them one by one.
  for (const permission of permissions) {
    const result = await service.permissions.create({
      requestBody: permission,
      fileId,
      fields: 'id',
    });

    if (result.data.id) {
      permissionIds.push(result.data.id);
      console.log(`Inserted permission id: ${result.data.id}`);
    } else {
      throw new Error('Failed to create permission');
    }
  }
  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

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

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

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

หากต้องการให้สิทธิ์เข้าถึงไฟล์หรือโฟลเดอร์ชั่วคราว ให้ตั้งค่าฟิลด์ expirationTime (วันที่และเวลาตาม RFC 3339) เมื่อเรียกใช้เมธอด create หรือ update

เวลาหมดอายุมีข้อจำกัดดังนี้

  • ตั้งค่าได้เฉพาะในสิทธิ์ user และ group (ไม่ใช่ domain หรือ anyone)
  • เวลาต้องเป็นเวลาในอนาคต โดยไม่เกิน 1 ปี
  • สำหรับโฟลเดอร์ ระบบจะรองรับการเข้าถึงชั่วคราวเฉพาะบทบาทreader