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

לכל קובץ, תיקייה ואחסון שיתופי ב-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.

   • אם הערך הבוליאני writersCanShare מוגדר ל-false בקובץ, המשתמש צריך להיות בעל role=owner.

   • אם למשתמש עם role=writer יש גישה זמנית שמבוססת על תאריך תפוגה ושעה, הוא לא יוכל לשתף את הקובץ. למידע נוסף, ראו הגדרת תאריך תפוגה כדי להגביל את הגישה לקובץ.

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 אחרי פרק זמן מסוים. לקבצים בתיקייה 'האחסון שלי', אפשר להגדיר תאריך תפוגה כדי להגביל או להסיר את הגישה לקובץ.

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

• משתמשים בשיטה create() במשאב permissions ומגדירים את השדה expirationTime (יחד עם שאר השדות הנדרשים). מידע נוסף זמין במאמר יצירת הרשאה.

• משתמשים בשיטה update() במשאב permissions ומגדירים את השדה expirationTime (יחד עם שאר השדות הנדרשים). מידע נוסף זמין במאמר שינוי ההרשאות.

השדה 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.

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

   כניסה לדף 'משתמשי יעד'

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

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

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

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

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

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

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

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

{
  "kind": "drive#permissionList",
  "permissions": [
    {
      "id": "PERMISSION_ID",
      "type": "user",
      "kind": "drive#permission",
      "role": "commenter"
    }
  ]
}

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

כשהאפליקציה פותחת קובץ, היא צריכה לבדוק את היכולות של הקובץ ולייצר את ממשק המשתמש כך שישקף את ההרשאות של המשתמש הנוכחי. לדוגמה, אם למשתמש אין את היכולת 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
  }
}

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

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

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

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

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

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 עבור קובץ באחסון שיתופי. במקרה כזה, מכיוון שהתפקיד החדש הוא פחות מגביל מהתפקיד שהוקצה דרך החברות בקבוצה, ההרשאה החדשה הופכת לתפקיד בפועל של הקובץ או התיקייה.

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). הצעת הגישה השנייה תוסר מהפריט.

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

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

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

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

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

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

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.

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

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

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

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

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",
  )

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

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

}

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

נושאים קשורים

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