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

ทุกไฟล์ โฟลเดอร์ และไดรฟ์ที่แชร์ของ Google ไดรฟ์จะมีทรัพยากรสิทธิ์ที่เชื่อมโยงอยู่ ทรัพยากรแต่ละรายการจะระบุสิทธิ์สําหรับ type (ผู้ใช้ กลุ่ม โดเมน ทุกคน) และ role ที่เจาะจง เช่น "ผู้แสดงความคิดเห็น" หรือ "ผู้อ่าน" เช่น ไฟล์อาจมีสิทธิ์ ให้สิทธิ์การเข้าถึงระดับอ่านอย่างเดียว (type=user) แก่ผู้ใช้บางราย (role=reader) ส่วนสิทธิ์อีกรายการหนึ่งอนุญาตให้ผู้ใช้ในบางกลุ่ม (type=group) แสดงความคิดเห็นในไฟล์ (role=commenter) ได้

โปรดดูรายการบทบาทและการทํางานทั้งหมดที่แต่ละบทบาทอนุญาตในบทบาท

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

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

  1. หากต้องการแชร์ไฟล์ในไดรฟ์ของฉัน ผู้ใช้ต้องมี role=writer ขึ้นไป

    • หากตั้งค่าบูลีน writersCanShare ไว้ที่ False สําหรับไฟล์ ผู้ใช้ต้องมี role=owner

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

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

  2. หากต้องการแชร์โฟลเดอร์ในไดรฟ์ของฉัน ผู้ใช้ต้องมี role=writer ขึ้นไป

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

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

  3. หากต้องการแชร์ไฟล์ในไดรฟ์ที่แชร์ ผู้ใช้ต้องมีขนาดไม่เกิน role=writer

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

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

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

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

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

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

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

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

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

ความสามารถ

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

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

สร้างสิทธิ์

การสร้างสิทธิ์เป็นช่องที่ต้องกรอก 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

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

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

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

  1. ลงชื่อเข้าใช้ คอนโซลผู้ดูแลระบบของ Google

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

  2. ไปที่เมนู > ไดเรกทอรี > กลุ่มเป้าหมาย

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

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

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

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

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

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

ยืนยันสิทธิ์ของผู้ใช้

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

หากต้องการตรวจสอบความสามารถ ให้เรียกใช้ files.get ที่มีพารามิเตอร์ fileId และ fields ซึ่งตั้งค่าเป็นช่อง capabilities

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

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

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

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

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

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

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

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

  2. ในคําขอ ให้ระบุ role ใหม่

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

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

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

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

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

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

โอนการเป็นเจ้าของไฟล์ไปยังบัญชี 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
from __future__ import print_function

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