שיתוף קבצים, תיקיות ואחסון

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

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

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

יש חמישה סוגים שונים של תרחישים לשיתוף:

  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. רק משתמשים וקבוצות יכולים להצטרף לתיקיות באחסון שיתופי.

הגדרת תאריך תפוגה כדי להגביל את הגישה לקובץ

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

כדי להגדיר את תאריך התפוגה:

השדה expirationTime מציין מתי יפוג תוקף ההרשאה באמצעות RFC 3339 תאריך-שעה. יש הגבלות על מועדי התפוגה:

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

מידע נוסף על תאריך התפוגה זמין במאמרים הבאים:

הפצת הרשאות

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

לעומת זאת, אם קובץ יורש את התפקיד role=writer מתיקייה, והוא מועבר לתיקייה אחרת שמספקת את התפקיד 'קורא', הקובץ יורש עכשיו את התפקיד role=reader.

אי אפשר להסיר הרשאות שעברו בירושה מקובץ או מתיקייה באחסון שיתופי. במקום זאת, צריך לשנות את ההרשאות האלה ברמת ההורה הישיר או העקיף שממנו הן עוברות בירושה. אפשר להסיר הרשאות שעברו בירושה מפריטים בקטע 'האחסון שלי' או 'קבצים ששותפו איתי'.

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

יכולות

המשאב permissions לא קובע בסופו של דבר את היכולת של המשתמש הנוכחי לבצע פעולות בקובץ או בתיקייה. במקום זאת, המשאב files מכיל אוסף של שדות capabilities בוליאניים שמשמשים לציון אם אפשר לבצע פעולה בקובץ או בתיקייה. Google Drive API מגדיר את השדות האלה על סמך משאב ההרשאות של המשתמש הנוכחי שמשויך לקובץ או לתיקייה.

לדוגמה, כשאלכס נכנס לאפליקציה ומנסה לשתף קובץ, המערכת בודקת את ההרשאות של אלכס בקובץ. אם התפקיד מאפשר להם לשתף קובץ, השדה capabilities שקשור לקובץ, כמו canShare, ימולא ביחס לתפקיד. אם אלכס רוצה לשתף את הקובץ, האפליקציה בודקת את capabilities כדי לוודא ש-canShare מוגדר ל-true.

דוגמה לאחזור הקובץ capabilities מופיעה במאמר אימות ההרשאות של משתמשים.

יצירת הרשאה

שני השדות הבאים נדרשים כשיוצרים הרשאה:

  • 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 Admin, נכנסים לתפריט > ספרייה > קהלים יעד.

    לדף 'קהלי יעד'

    כדי לבצע את המשימה הזו, עליכם להיות מחוברים באמצעות חשבון שיש לו הרשאות סופר-אדמין.

  2. ברשימת קהלים היעד, לוחצים על שם קהל היעד. במאמר יצירת קהל יעד מוסבר איך יוצרים קהל יעד.

  3. מעתיקים את המזהה הייחודי מכתובת ה-URL של קהל היעד: https://admin.google.com/ac/targetaudiences/ID.

  4. יוצרים הרשאה באמצעות type=domain ומגדירים את השדה domain לערך ID.audience.googledomains.com.

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

אחזור כל ההרשאות לקובץ, לתיקייה או לאחסון שיתופי

כדי לאחזר את כל ההרשאות לקובץ, לתיקייה או לאחסון שיתופי, משתמשים ב-method 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"
    }
  ]
}

אימות הרשאות המשתמשים

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

מידע נוסף על capabilities זמין בקטע יכולות.

כדי לבדוק את היכולות, צריך להפעיל את השיטה 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,
    "canChangeSecurityUpdateEnabled": false,
    "canComment": true,
    "canCopy": true,
    "canDelete": true,
    "canDownload": true,
    "canEdit": true,
    "canListChildren": false,
    "canModifyContent": true,
    "canModifyContentRestriction": true,
    "canModifyLabels": true,
    "canMoveChildrenWithinDrive": false,
    "canMoveItemOutOfDrive": true,
    "canMoveItemWithinDrive": true,
    "canReadLabels": true,
    "canReadRevisions": true,
    "canRemoveChildren": false,
    "canRemoveMyDriveParent": true,
    "canRename": true,
    "canShare": true,
    "canTrash": true,
    "canUntrash": true
  }
}

איך בודקים מהו מקור התפקיד של קבצים ותיקיות באחסון שיתופי

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

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

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

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

הצגת רשימה של הצעות גישה בהמתנה וטיפול בהן

הצעת גישה היא הצעה של מבקש לאישור כדי להעניק לנמען גישה לפריט ב-Drive.

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

באמצעות Drive API תוכלו להשתמש במשאב accessproposals כדי להציג ולטפל בבקשות גישה בהמתנה. השיטות של המשאב accessproposals פועלות על קבצים, תיקיות, הקבצים באחסון שיתופי, אבל לא על האחסון השיתופי.

המונחים הבאים ספציפיים להצעות גישה:

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

הצגת רשימה של הצעות גישה בהמתנה

כדי להציג את כל הצעות הגישה הממתינות לפריט ב-Drive, קוראים ל-method list() במשאב accessproposals וכוללים את פרמטר הנתיב fileId.

רק גורמים מורשים לאישור בקשות בקובץ יכולים לראות את הבקשות בהמתנה בקובץ. גורם מאשר הוא משתמש עם היכולת can_approve_access_proposals בקובץ. אם מבצע הבקשה לא הוא המאשר, המערכת מחזירה רשימה ריקה. מידע נוסף על capabilities זמין בקטע יכולות.

גוף התגובה מורכב מאובייקט AccessProposal שמייצג רשימה של הצעות גישה ללא פתרון בקובץ.

האובייקט AccessProposal כולל מידע על כל הצעה, כמו מבקש ההצעה, הנמען וההודעה שהמבקש הוסיף. הוא כולל גם אובייקט AccessProposalRoleAndView שמקבץ את ה-role שהמגיש הציע עם view. מכיוון ש-role הוא שדה חוזר, יכולים להיות כמה ערכים לכל הצעה. לדוגמה, הצעה יכולה לכלול אובייקט AccessProposalRoleAndView של role=reader ו-view=published, וגם אובייקט AccessProposalRoleAndView נוסף עם הערך role=writer בלבד. למידע נוסף ראו תצוגות

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

  • pageToken: אסימון דף, שהתקבל משיחת רשימה קודמת. צריך לספק את האסימון הזה כדי לאחזר את הדף הבא.

  • pageSize: המספר המרבי של הצעות גישה שניתן להחזיר בכל דף.

טיפול בהצעות גישה ממתינות

כדי לטפל בכל בקשות הגישה בהמתנה לפריט ב-Drive, צריך לבצע קריאה ל-method‏ resolve() במשאב accessproposals ולכלול את הפרמטרים של הנתיב fileId ו-proposalId.

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

השיטה resolve() כוללת גם את פרמטרי השאילתה האופציונליים role ו-view. התפקידים הנתמכים היחידים הם writer,‏ commenter ו-reader. אם לא מציינים את התפקיד, ברירת המחדל היא reader. פרמטר אופציונלי נוסף של שאילתה, send_notification, מאפשר לשלוח למגיש הבקשה התראה באימייל כשההצעה מתקבלת או נדחתה.

בדומה ל-method‏ list(), למשתמשים שמאשרים את ההצעה צריכה להיות היכולת can_approve_access_proposals בקובץ. מידע נוסף על capabilities זמין בקטע יכולות.

ההצעות נפתרות לפי אותם דפוסים שמפורטים בקטע תרחישי שיתוף של משאבים ב-Drive. אם יש כמה הצעות לאותו משתמש, אבל עם תפקידים שונים, חל הכלל הבא:

  • אם הצעה אחת תאושר והצעה שנייה תידחה, התפקיד שאושר יחול על הפריט ב-Drive.
  • אם שתי ההצעות יאושרו בו-זמנית, תיושם ההצעה עם ההרשאה הגבוהה יותר (לדוגמה, role=writer לעומת role=reader). הצעת הגישה השנייה תוסר מהפריט.

אחרי ששולחים הצעה ל-method resolve(), פעולת השיתוף הושלמה. הערך של AccessProposal לא מוחזר יותר דרך השיטה list(). אחרי שההצעה תאושר, המשתמש יצטרך להשתמש באוסף permissions כדי לעדכן את ההרשאות בקובץ או בתיקייה. מידע נוסף זמין בקטע שינוי ההרשאות.

ביטול הגישה לקובץ או לתיקייה

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

בפריטים בתיקייה 'האחסון שלי', אפשר למחוק הרשאה שעברה בירושה. מחיקה של הרשאה שעברה בירושה מבטלת את הגישה לפריט ולפריטי הצאצא, אם יש כאלה.

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

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

הצג דוגמה

דוגמת הקוד הבאה מראה איך לבטל גישה על ידי מחיקת permissionId. אם הפעולה בוצעה ללא שגיאות, גוף התגובה יהיה ריק. כדי לוודא שההרשאה הוסרה, משתמשים בשיטה list() במשאב permissions עם פרמטר הנתיב fileId.

שליחת בקשה

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

העברת הבעלות על קבצים לחשבון Google Workspace אחר באותו ארגון

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

כדי להעביר בעלות על קובץ ב'אחסון שלי', מבצעים אחת מהפעולות הבאות:

  • יוצרים הרשאת קובץ שמעניקה למשתמש ספציפי (type=user) הרשאת בעלים (role=owner).

  • עדכון ההרשאה של קובץ קיים באמצעות role=owner והעברת הבעלות למשתמש שצוין (transferOwnership=true).

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

אפשר להעביר את הבעלות על קבצים בין חשבון צרכן אחד לחשבון אחר. עם זאת, Drive לא מעביר את הבעלות על קובץ בין שני חשבונות הצרכנים עד שהבעלים הפוטנציאליים יאשרו במפורש את ההעברה. כדי להעביר בעלות על קובץ מחשבון צרכן אחד לחשבון אחר:

  1. הבעלים הנוכחי מתחיל את העברת הבעלות על ידי יצירה או עדכון של הרשאת הקובץ של הבעלים העתידי. ההרשאה חייבת לכלול את ההגדרות הבאות: role=writer, type=user ו-pendingOwner=true. אם הבעלים הנוכחי יוצר הרשאה לבעלים הפוטנציאלי, תישלח התראה באימייל לבעלים הפוטנציאלי כדי לציין שהוא התבקש לקבל בעלות על הקובץ.

  2. הבעלים העתידי מאשר את בקשת העברת הבעלות על ידי יצירת הרשאת הקובץ שלו או עדכון שלה. ההרשאה חייבת לכלול את ההגדרות הבאות: role=owner ו-transferOwnership=true. אם הבעלים הפוטנציאליים יוצרים הרשאה חדשה, הבעלים הקודמים יקבלו התראה באימייל על כך שהבעלות הועברה.

כשמעבירים קובץ, התפקיד של הבעלים הקודם יורד ל-writer.

שינוי כמה הרשאות באמצעות בקשות באצווה

מומלץ מאוד להשתמש בבקשות באצווה כדי לשנות כמה הרשאות.

בדוגמה הבאה מוצגת שינוי של הרשאות באצווה באמצעות ספריית לקוח.

Java

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

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

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

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

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


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

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

        ids.add(permission.getId());

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

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

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

      domainPermission.setDomain(realDomain);

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

      batch.execute();

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

Python

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


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

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

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

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

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

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

  return ids


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

Node.js

drive/snippets/drive_v3/file_snippets/share_file.js
/**
 * Batch permission modification
 * @param{string} fileId file ID
 * @param{string} targetUserEmail username
 * @param{string} targetDomainName domain
 * @return{list} permission id
 * */
async function shareFile(fileId, targetUserEmail, targetDomainName) {
  const {GoogleAuth} = require('google-auth-library');
  const {google} = require('googleapis');

  // Get credentials and build service
  // TODO (developer) - Use appropriate auth mechanism for your app
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });
  const service = google.drive({version: 'v3', auth});
  const permissionIds = [];

  const permissions = [
    {
      type: 'user',
      role: 'writer',
      emailAddress: targetUserEmail, // 'user@partner.com',
    },
    {
      type: 'domain',
      role: 'writer',
      domain: targetDomainName, // 'example.com',
    },
  ];
  // Note: Client library does not currently support HTTP batch
  // requests. When possible, use batched requests when inserting
  // multiple permissions on the same item. For this sample,
  // permissions are inserted serially.
  for (const permission of permissions) {
    try {
      const result = await service.permissions.create({
        resource: permission,
        fileId: fileId,
        fields: 'id',
      });
      permissionIds.push(result.data.id);
      console.log(`Inserted permission id: ${result.data.id}`);
    } catch (err) {
      // TODO(developer): Handle failed permissions
      console.error(err);
    }
  }
  return permissionIds;
}

PHP

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

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

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

}

‎.NET

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

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

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

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

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

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