שיתוף קבצים, תיקיות ו-Drive

לכל קובץ, תיקייה ואחסון שיתופי ב-Google Drive יש משאבי permissions משויכים. כל משאב מזהה את ההרשאה עבור type ספציפי (user,‏ group,‏ domain,‏ anyone) וrole (owner,‏ organizer,‏ fileOrganizer,‏ writer,‏ commenter,‏ reader). לדוגמה, יכול להיות שלקובץ מסוים יש הרשאה שמעניקה למשתמש ספציפי (type=user) גישה לקריאה בלבד (role=reader), והרשאה אחרת שמעניקה לחברים בקבוצה ספציפית (type=group) את האפשרות להוסיף הערות לקובץ (role=commenter).

רשימה מלאה של התפקידים והפעולות שמותרות בכל אחד מהם מופיעה במאמר תפקידים והרשאות.

איך הרשאות מועברות

ההרשאות מועברות כלפי מטה מתיקיות האב לכל פריטי הצאצא:

  • מועברות בירושה כברירת מחדל: כל הקבצים והתיקיות המשניים מקבלים אוטומטית בירושה הרשאות מהתיקייה הראשית שלהם.
  • אי אפשר לצמצם את ההרשאות בפריטים צאצאים: אי אפשר להסיר או לצמצם הרשאה שהועברה בירושה בפריט צאצא. צריך לבצע את השינויים בתיקיית האם המקורית, או להשתמש בהגדרת הגישה המוגבלת בתיקייה.
  • אפשר להרחיב את ההרשאות בפריטי צאצא: פריט צאצא יכול להעניק תפקיד עם יותר הרשאות, למשל לתת את ההרשאה role=writer בקובץ בתוך תיקייה שבה למשתמש יש את ההרשאה role=reader.
  • הערכה מחדש בהעברה: כשמעבירים פריט לתיקיית הורה חדשה, המערכת מעריכה מחדש את ההרשאות של תיקיית ההורה החדשה ומחילת אותן על הפריט ועל פריטי המשנה שלו.

קישורים לקבצים ובקרת גישה

כשמשתפים קובץ או תיקייה עם משתמש או קבוצה ספציפיים, כתובת ה-URL לגישה לפריט לא משתנה, ולא נוצר קישור ייחודי לכל משתמש. במקום זאת, לפריט יש קישור קבוע יחיד שמבוסס על fileId.

כדי לקבוע את הגישה, מערכת Drive בודקת את רשימת ה-ACL של הפריט. כשמשתמש מנסה לפתוח קישור, מערכת Drive מאמתת את הזהות שלו מול רשימת בקרת הגישה. אם הרשאה מבוטלת או מגיעה לתאריך התפוגה שלה, המשתמש מוסר מרשימת ה-ACL. אם המשתמש ינסה להיכנס שוב לקישור, הגישה ל-Drive תיחסם.

הסבר על היכולות של הקבצים

במשאב permissions מוגדר למי יש גישה (רשימת בקרת הגישה), אבל לא מצוין באופן ישיר אם המשתמש הנוכחי יכול לבצע פעולה ספציפית בממשק המשתמש של האפליקציה.

במקום זאת, המשאב files מכיל אוסף של שדות בוליאניים capabilities (כמו canComment,‏ canShare או canDelete) שממשק Google Drive API מחשב באופן דינמי על סמך התפקיד של המשתמש וההגדרות של הפריט.

קבלת יכולות של קבצים

כשמעבדים את ממשק המשתמש של האפליקציה, צריך לבדוק את files.capabilities במקום לנתח הרשאות ישירות:

  • מבצעים קריאה ל-files.get עם fields=capabilities. מידע נוסף זמין במאמר בנושא החזרת שדות ספציפיים.
  • משתמשים בדגלים הבוליאניים שמוחזרים כדי להפעיל או להשבית פעולות תואמות בממשק. לדוגמה, השבתת התגובות אם canComment הוא false.

תרחישים לשיתוף משאבים ב-Drive

בטבלה הבאה מוצגים התפקידים והתנאים הנדרשים לשיתוף משאבי Drive במיקומים שונים ובסוגי פריטים שונים:

מיקום פריט התפקידים הנדרשים מגבלות על מפתחות
האחסון שלי קובץ או תיקייה 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
רשימה 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 Admin זמינים במאמר מידע על קהלים ממוקדים.

כדי לראות איך המשתמשים מקיימים אינטראקציה עם קהלים מטורגטים, אפשר לעיין במאמר בנושא חוויית המשתמש בשיתוף קישורים.

קבלת הרשאה

כדי לקבל הרשאה, צריך להפעיל את ה-method ‏get במשאב permissions עם פרמטרים של נתיב fileId ו-permissionId. אם אתם לא יודעים את מזהה ההרשאה, קודם מציגים את כל ההרשאות.

הצגת רשימה של הרשאות

כדי לראות את רשימת ההרשאות של קובץ, תיקייה או אחסון שיתופי, מפעילים את השיטה list במשאב permissions עם פרמטר הנתיב fileId הנדרש.

אפשר לכלול כל אחד מפרמטרים השאילתה האופציונליים הבאים כדי להוסיף מספור עמודים או לסנן את התשובה:

  • ‫pageSize (אופציונלי): המספר המקסימלי של הרשאות שיוחזרו בכל דף. אם לא מגדירים את המגבלה לקבצים באחסון שיתופי, מוחזרות לכל היותר 100 תוצאות. אם לא מציינים את הפרמטר הזה לקבצים שלא נמצאים באחסון שיתופי, כל הרשימה מוחזרת.

  • ‫pageToken (אופציונלי): טוקן של דף מקריאה קודמת של רשימה, כדי לאחזר את הדף הבא.

  • ‫supportsAllDrives (אופציונלי): האם האפליקציה ששולחת את הבקשה תומכת גם ב'האחסון שלי' וגם בתיקיות אחסון שיתופי.

  • ‫useDomainAdminAccess (אופציונלי): מגדירים את הערך true כדי לשלוח את הבקשה כאדמין בדומיין. למבקש תינתן גישה אם הפרמטר fileId מתייחס לאחסון שיתופי והמבקש הוא אדמין בדומיין שאליו שייך האחסון השיתופי. מידע נוסף זמין במאמר בנושא ניהול תיקיות אחסון שיתופי כאדמינים של הדומיין.

  • ‫includePermissionsForView (אופציונלי): הרשאות צפייה נוספות שרוצים לכלול בתגובה. יש תמיכה רק ב-published.

  • ‫fields (אופציונלי): שדות ספציפיים שצריך להחזיר בתגובה. כברירת מחדל, הפונקציה list מחזירה רק את הערכים id,‏ type,‏ kind ו-role. כדי להחזיר שדות נוספים (כמו permissionDetails), צריך לציין אותם באמצעות הפרמטר הזה. מידע נוסף מופיע במאמר בנושא החזרת שדות ספציפיים.

קביעת מקור התפקיד

כדי לשנות את התפקיד בקובץ או בתיקייה, צריך לדעת מה המקור של התפקיד. בתיקיות אחסון שיתופי, המקור של התפקיד יכול להיות חברות באחסון השיתופי, התפקיד בתיקייה או התפקיד בקובץ.

כדי לקבוע את מקור התפקיד בתיקיית אחסון שיתופי או בפריטים בתיקייה, צריך להפעיל את השיטה get במשאב permissions עם פרמטרי הנתיב fileId ו-permissionId, והפרמטר fields מוגדר לשדה permissionDetails.

כדי למצוא את permissionId, משתמשים ב-method ‏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 שמוגדר לקובץ, לתיקייה או לאחסון השיתופי המשויכים, ופרמטר הנתיב permissionId שמוגדר להרשאה לשינוי. כדי למצוא את permissionId, משתמשים ב-method ‏list במשאב permissions עם פרמטר של הנתיב fileId.

  2. בבקשה, מציינים את role החדש.

אתם יכולים להעניק הרשאות לקבצים או לתיקיות ספציפיים באחסון שיתופי, גם אם המשתמש או הקבוצה כבר חברים באחסון השיתופי. לדוגמה, לאלכס יש הרשאת role=commenter כחלק מהחברות שלו באחסון השיתופי. עם זאת, האפליקציה יכולה להעניק לאלכס 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"
}

עדכון של כמה הרשאות באמצעות בקשות אצווה

אין תמיכה בשינויים מקבילים בהרשאות של אותו קובץ, תיקייה או אחסון שיתופי. המגבלה הזו חלה על כל הפעולות שמשנות את ההרשאות (כמו עדכון או מחיקה), בלי קשר לשאלה אם אתם משנים את ההרשאות של אותו נמען או של נמענים שונים, ואם הבקשות מגיעות מאפליקציה אחת או מכמה משתמשים.

מערכת Drive מעריכה ומעדכנת את ההרשאות של פריט כרשימת בקרת גישה (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).
  • השעה חייבת להיות בעתיד, עד שנה קדימה.
  • בתיקיות, גישה זמנית נתמכת רק בתפקיד reader.