Dosya, klasör ve sürücü paylaşma

Her Google Drive dosyası, klasörü ve ortak Drive'ın ilişkili permissions kaynakları vardır. Her kaynak, belirli bir type (user, group, domain, anyone) ve role (owner, organizer, fileOrganizer, writer, commenter, reader) için izin tanımlar. Örneğin, bir dosyada belirli bir kullanıcıya (type=user) salt okuma erişimi (role=reader) veren bir izin olabilirken başka bir izin, belirli bir grubun üyelerine (type=group) dosyaya yorum ekleme olanağı (role=commenter) verebilir.

Rollerin ve her birinin izin verdiği işlemlerin tam listesi için Roller ve izinler başlıklı makaleyi inceleyin.

Drive kaynaklarını paylaşma senaryoları

Beş farklı paylaşım senaryosu vardır:

1. Drive'ım'da dosya paylaşmak için kullanıcının role=writer veya role=owner iznine sahip olması gerekir.

   • writersCanShare Boole değeri dosya için false olarak ayarlanırsa kullanıcının role=owner değerine sahip olması gerekir.

   • role=writer erişimi olan kullanıcı, son kullanma tarihi ve saatine tabi geçici erişime sahipse dosyayı paylaşamaz. Daha fazla bilgi edinmek için Dosya erişimini sınırlamak için son kullanma tarihi belirleme bölümüne bakın.

2. Drive'ım bölümünde bir klasörü paylaşmak için kullanıcının role=writer veya role=owner erişimine sahip olması gerekir.

   • Dosya için writersCanShare boole değeri false olarak ayarlanmışsa kullanıcının daha izin verici role=owner değerine sahip olması gerekir.

   • role=writer ile Drive'ım klasörlerinde geçici erişime (geçerlilik bitiş tarihi ve saati vardır) izin verilmez. Daha fazla bilgi için Dosya erişimini sınırlamak için son kullanma tarihi belirleme başlıklı makaleyi inceleyin.

3. Ortak Drive'da dosya paylaşabilmek için kullanıcının role=writer, role=fileOrganizer veya role=organizer kullanması gerekir.

   • writersCanShare ayarı, ortak Drive'lardaki öğeler için geçerli değildir. Her zaman true olarak ayarlanmış gibi değerlendirilir.

4. Ortak Drive'daki bir klasörü paylaşmak için kullanıcının role=organizer erişimine sahip olması gerekir.

   • Ortak Drive'daki sharingFoldersRequiresOrganizerPermission kısıtlaması false olarak ayarlanmışsa role=fileOrganizer izni olan kullanıcılar bu ortak Drive'daki klasörleri paylaşabilir.

5. Ortak Drive üyeliğini yönetmek için kullanıcının role=organizer erişimine sahip olması gerekir. Yalnızca kullanıcılar ve gruplar ortak Drive'lara üye olabilir.

Dosya erişimini sınırlandırmak için son kullanma tarihi belirleme

Hassas bir projede kullanıcılarla çalışıyorsanız belirli bir süre sonra bu kullanıcıların Drive'daki belirli dosyalara erişimini kısıtlamak isteyebilirsiniz. Drive'ım bölümündeki dosyalara erişimi sınırlamak veya kaldırmak için son kullanma tarihi belirleyebilirsiniz.

Son kullanma tarihini ayarlamak için:

• permissions kaynağında create() yöntemini kullanın ve expirationTime alanını (gerekli diğer alanlarla birlikte) ayarlayın. Daha fazla bilgi için İzin oluşturma başlıklı makaleyi inceleyin.

• permissions kaynağında update() yöntemini kullanın ve expirationTime alanını (gerekli diğer alanlarla birlikte) ayarlayın. Daha fazla bilgi için İzinleri değiştirme başlıklı makaleyi inceleyin.

expirationTime alanı, RFC 3339 tarih-saat kullanılarak iznin süresinin ne zaman dolacağını belirtir. Süre sonu süreleri aşağıdaki kısıtlamalara tabidir:

• Yalnızca kullanıcı ve grup izinlerinde ayarlanabilir.
• Zaman gelecekte olmalıdır.
• Zaman, en fazla bir yıl sonrası olabilir.

Süre sonu tarihi hakkında daha fazla bilgi için aşağıdaki makaleleri inceleyin:

• Dosya erişimi için son kullanma tarihi belirleme
• Geçerlilik bitiş tarihi ekleme

İzin yayılımı

Bir klasörün izin listeleri aşağıya doğru yayılır ve tüm alt dosya ve klasörler izinleri üst klasörden devralır. İzinler veya hiyerarşi değiştirildiğinde, tüm iç içe yerleştirilmiş klasörlerde yinelemeli olarak dağıtım gerçekleşir. Örneğin, bir klasörde bulunan bir dosya başka bir klasöre taşınırsa yeni klasörün izinleri dosyaya uygulanır. Yeni klasör, dosyanın kullanıcısına "yazar" gibi yeni bir rol verirse eski rolü geçersiz kılar.

Buna karşılık, bir dosya bir klasörden role=writer devralır ve "okur" rolü sağlayan başka bir klasöre taşınırsa dosya artık role=reader devralır.

Devralınan izinler, ortak Drive'daki bir dosyadan veya klasörden kaldırılamaz. Bunun yerine, bu izinler devralındıkları doğrudan veya dolaylı üst öğede düzenlenmelidir. Devralınan izinler "Drive'ım" veya "Benimle paylaşılanlar" altındaki öğelerden kaldırılabilir.

Buna karşılık, devralınan izinler Drive'ımdaki bir dosya veya klasörde geçersiz kılınabilir. Dolayısıyla, bir dosya OneDrive klasöründen role=writer izinlerini devralır. Dosyanın izin düzeyini düşürmek için dosyada role=reader ayarını yapabilirsiniz.

İşlemler

permissions kaynağı, mevcut kullanıcının bir dosya veya klasör üzerinde işlem yapma yeteneğini nihai olarak belirlemez. Bunun yerine files kaynağı, bir dosyada veya klasörde işlem yapılıp yapılamayacağını belirtmek için kullanılan bir Boole capabilities alanı koleksiyonu içerir. Google Drive API, bu alanları geçerli kullanıcının dosya veya klasörle ilişkili izin kaynağına göre ayarlar.

Örneğin, Ali uygulamanıza giriş yapıp bir dosya paylaşmaya çalıştığında, Ali'nin rolü dosyada izinler açısından kontrol edilir. Rol, kullanıcının dosya paylaşmasına izin veriyorsa dosyayla ilgili capabilities (ör. canShare) rolle ilgili olarak doldurulur. Ali dosyayı paylaşmak isterse uygulamanız, canShare değerinin true olarak ayarlandığından emin olmak için capabilities değerini kontrol eder.

capabilities dosyasını alma örneği için Kullanıcı izinlerini doğrulama bölümüne bakın.

İzin oluşturma

İzin oluştururken aşağıdaki iki alan gereklidir:

• type: type, iznin kapsamını tanımlar (user, group, domain veya anyone). type=user içeren bir izin belirli bir kullanıcı için, type=domain içeren bir izin ise belirli bir alandaki herkes için geçerlidir.

• role: role alanı, type tarafından gerçekleştirilebilecek işlemleri tanımlar. Örneğin, type=user ve role=reader içeren bir izin, belirli bir kullanıcıya dosyaya veya klasöre salt okuma erişimi verir. type=domain ve role=commenter içeren bir izin ise alandaki herkesin bir dosyaya yorum eklemesine olanak tanır. Rollerin ve her birinin izin verdiği işlemlerin tam listesi için Roller ve izinler başlıklı makaleyi inceleyin.

type=user veya type=group olduğunda bir izin oluşturduğunuzda, belirli kullanıcı veya grubu izne bağlamak için bir emailAddress da sağlamanız gerekir.

type=domain olan bir izin oluşturduğunuzda, izine belirli bir alanı bağlamak için bir domain da sağlamanız gerekir.

İzin oluşturmak için:

1. İlişkilendirilmiş dosya veya klasör için fileId path parametresiyle create() yöntemini kullanın.
2. İsteğin gövdesinde type ve role değerlerini belirtin.
3. type=user veya type=group ise bir emailAddress sağlayın. type=domain ise bir domain sağlayın.

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

Hedef kitleleri kullanma

Hedef kitleler, kullanıcıların öğelerini paylaşmaları için önerebileceğiniz, departmanlar veya ekipler gibi kullanıcı gruplarıdır. Kullanıcıları, öğelerini kuruluşunuzun tamamı yerine daha belirli veya sınırlı kitlelerle paylaşmaya teşvik edebilirsiniz. Hedef kitleler, verilerinizin güvenliğini ve gizliliğini artırmanıza ve kullanıcıların uygun şekilde paylaşım yapmasını kolaylaştırmanıza yardımcı olabilir. Daha fazla bilgi için Hedef kitleler hakkında bölümüne bakın.

Hedef kitleleri kullanmak için:

1. Google Yönetici Konsolu'nda Menü menu > Dizin > Hedef kitleler'e gidin.

   Hedef kitleler'e gidin

   Bu görev için süper yönetici ayrıcalıklarına sahip bir hesapla oturum açmış olmanız gerekir.

2. Hedef kitleler listesinde hedef kitlenin adını tıklayın. Hedef kitle oluşturmak için Hedef kitle oluşturma bölümüne bakın

3. Hedef kitle URL'sindeki benzersiz kimliği kopyalayın: https://admin.google.com/ac/targetaudiences/ID.

4. type=domain ile izin oluşturun ve domain alanını ID.audience.googledomains.com olarak ayarlayın.

Kullanıcıların hedef kitlelerle nasıl etkileşim kurduğunu görüntülemek için Bağlantı paylaşımı için kullanıcı deneyimi başlıklı makaleyi inceleyin.

Bir dosya, klasör veya ortak Drive için tüm izinleri alma

Bir dosya, klasör veya ortak Drive'la ilgili tüm izinleri almak için permissions kaynağında list() yöntemini kullanın.

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"
    }
  ]
}

Kullanıcı izinlerini doğrulama

Uygulamanız bir dosyayı açarken dosyanın özelliklerini kontrol etmeli ve kullanıcı arayüzünü mevcut kullanıcının izinlerini yansıtacak şekilde oluşturmalıdır. Örneğin, kullanıcının dosyada canComment yetkisi yoksa kullanıcı arayüzünde yorum yapma özelliği devre dışı bırakılmalıdır.

capabilities hakkında daha fazla bilgi için Özellikler bölümüne bakın.

Özellikleri kontrol etmek için fileId yol parametresi ve fields parametresi capabilities alanına ayarlanmış şekilde files kaynağındaki get() yöntemini çağırın. fields parametresini kullanarak alanları döndürme hakkında daha fazla bilgi için Bir dosya için belirli alanları döndürme bölümüne bakın.

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

Ortak Drive dosyaları ve klasörlerinin rol kaynağını belirleme

Bir dosya veya klasördeki rolü değiştirmek için rolün kaynağını bilmeniz gerekir. Ortak Drive'larda rolün kaynağı, ortak Drive'a üyeliğe, klasördeki role veya dosyadaki role bağlı olabilir.

Bir ortak Drive'ın veya bu Drive'daki öğelerin rol kaynağını belirlemek için permissions kaynağındaki get() yöntemini fileId ve permissionId yol parametreleriyle ve fields parametresi permissionDetails alanına ayarlanmış olarak çağırın.

permissionId değerini bulmak için fileId yol parametresini kullanarak permissions kaynağında list() yöntemini kullanın. list isteğinde permissionDetails alanını almak için fields parametresini permissions/permissionDetails olarak ayarlayın.

Bu alan, kullanıcı, grup veya alan için devralınan ve doğrudan tüm dosya izinlerini listeler.

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

İzinleri değiştir

Bir dosya veya klasörün izinlerini değiştirmek için atanan rolü değiştirebilirsiniz:

1. permissionId path parametresi değiştirme izni ve fileId path parametresi ilişkili dosya, klasör veya ortak Drive'a ayarlanmış olarak permissions kaynağında update() yöntemini çağırın. permissionId değerini bulmak için fileId yol parametresini kullanarak permissions kaynağında list() yöntemini kullanın.

2. İstekte yeni role değerini tanımlayın.

Kullanıcı veya grup zaten üye olsa bile ortak Drive'daki dosyalar ya da klasörler için tek tek izin verebilirsiniz. Örneğin, Ali ortak Drive üyeliği kapsamında role=commenter Ancak uygulamanız, Alex'e ortak Drive'daki bir dosya için role=writer izni verebilir. Bu durumda, yeni rol üyelik aracılığıyla verilen rolden daha fazla izin verdiği için yeni izin, dosya veya klasör için etkili rol olur.

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

Beklemedeki erişim tekliflerini listeleme ve çözme

Erişim teklifi, istek sahibinin onaylayana gönderdiği ve bir alıcıya Drive öğesine erişim izni verilmesini isteyen bir tekliftir.

Onaylayan kullanıcılar, Drive dosyalarındaki çözümlenmemiş tüm erişim tekliflerini inceleyebilir ve bunlarla ilgili işlem yapabilir. Bu sayede, erişim tekliflerini programatik olarak sorgulayıp çözerek onay sürecini hızlandırabilirsiniz. Ayrıca, onaylayanlar tarafından tekliflerin toplu olarak görüntülenmesine olanak tanır.

Drive API, beklemedeki erişim tekliflerini görüntüleyip çözebilmeniz için accessproposals kaynağını sağlar. accessproposals kaynağının yöntemleri, dosyalarda, klasörlerde ve ortak Drive'daki dosyalarda çalışır ancak ortak Drive'da çalışmaz.

Aşağıdaki terimler erişim tekliflerine özeldir:

• İstek sahibi: Bir Drive öğesine erişim teklifini başlatan kullanıcı.
• Alıcı: Erişim teklifi kabul edilirse bir dosyada ek izinleri alan kullanıcı. Alıcı çoğu zaman istek gönderenle aynıdır ancak her zaman aynı değildir.
• Onaylayıcı: Erişim teklifini onaylama (veya reddetme) ile sorumlu kullanıcı. Bunun nedeni genellikle dokümanın sahibi olmaları veya dokümanı paylaşabilmeleridir.

Beklemedeki erişim tekliflerini listeleme

Bir Drive öğesindeki bekleyen tüm erişim tekliflerini listelemek için accessproposals kaynağında list() yöntemini çağırın ve fileId yol parametresini ekleyin.

Yalnızca bir dosyanın onaylayıcıları, dosyada bekleyen teklifleri listeleyebilir. Onaylayan, dosyada can_approve_access_proposals yetkisi olan bir kullanıcıdır. İstekte bulunan kullanıcı onaylayan değilse boş bir liste döndürülür. capabilities hakkında daha fazla bilgi için Özellikler bölümüne bakın.

Yanıt gövdesi, dosyadaki çözümlenmemiş erişim tekliflerinin listesini temsil eden bir AccessProposal nesnesinden oluşur.

AccessProposal nesnesi, her teklifle ilgili istek sahibi, alıcı ve istek sahibinin eklediği mesaj gibi bilgileri içerir. Ayrıca, istekte bulunan kullanıcının önerdiği role öğesini view ile gruplandıran bir AccessProposalRoleAndView nesnesi de içerir. roleTekrarlanan bir alandır. Bu nedenle, her teklif için birden fazla role olabilir. Örneğin, bir teklifte role=reader ve view=published öğeleri içeren bir AccessProposalRoleAndView nesnesinin yanı sıra yalnızca role=writer değerine sahip bir ek AccessProposalRoleAndView nesnesi bulunabilir. Daha fazla bilgi için Görüntüleme sayısı bölümüne bakın.

Erişim tekliflerinin sayfalandırmasını özelleştirmek veya filtrelemek için aşağıdaki sorgu parametrelerini iletin:

• pageToken: Önceki bir liste çağrısından alınan sayfa jetonu. Sonraki sayfayı almak için bu jetonu sağlayın.

• pageSize: Sayfa başına döndürülecek maksimum erişim teklifi sayısı.

Beklemedeki erişim tekliflerini çözüme ulaştırın

Bir Drive öğesindeki bekleyen tüm erişim tekliflerini çözmek için accessproposals kaynağındaki resolve() yöntemini çağırın ve fileId ile proposalId yol parametrelerini ekleyin.

resolve() yöntemi, teklif üzerinde gerçekleştirilecek işlemi gösteren bir action sorgu parametresi içerir. Action nesnesi, teklifin kabul edilip edilmediğini veya reddedilip reddedilmediğini bilmemiz için teklifin durum değişikliğini izler.

resolve() yöntemi, role ve view isteğe bağlı sorgu parametrelerini de içerir. Yalnızca writer, commenter ve reader rolleri desteklenir. Rol belirtilmemişse varsayılan olarak reader olur. send_notification isteğe bağlı ek sorgu parametresi, teklif kabul edildiğinde veya reddedildiğinde istek sahibine e-posta bildirimi göndermenize olanak tanır.

list() yönteminde olduğu gibi, teklifi çözen kullanıcıların dosyada can_approve_access_proposals yeteneğine sahip olması gerekir. capabilities hakkında daha fazla bilgi için Özellikler bölümüne bakın.

Öneriler, Drive kaynaklarını paylaşma senaryoları bölümünde listelenen aynı kalıplar kullanılarak çözülür. Aynı kullanıcı için farklı rollere sahip birden fazla teklif varsa aşağıdakiler geçerlidir:

• Bir teklif kabul edilir ve diğeri reddedilirse kabul edilen rol Drive öğesi için geçerli olur.
• Her iki teklif de aynı anda kabul edilirse daha yüksek izine sahip teklif (örneğin, role=writer yerine role=reader) uygulanır. Diğer erişim teklifi öğeden kaldırılır.

resolve() yöntemine teklif gönderildikten sonra paylaşım işlemi tamamlanır. AccessProposal artık list() yöntemi üzerinden döndürülmemektedir. Teklif kabul edildikten sonra kullanıcı, bir dosya veya klasördeki izinleri güncellemek için permissions koleksiyonunu kullanmalıdır. Daha fazla bilgi için İzinleri değiştirme bölümüne bakın.

Dosya veya klasöre erişimi iptal etme

Bir dosyaya veya klasöre erişimi iptal etmek için permissions kaynağındaki delete() yöntemini fileId ve permissionId yol parametrelerini izni silecek şekilde ayarlayarak çağırın.

"Drive'ım" bölümündeki öğelerde, devralınan izinleri silebilirsiniz. Devralınan bir izin silindiğinde öğeye ve varsa alt öğelere erişim iptal edilir.

Ortak Drive'daki öğeler için devralınan izinler iptal edilemez. Bunun yerine, üst dosya veya klasördeki izni güncelleyin ya da iptal edin.

delete() yöntemi, doğrudan ortak Drive dosyasına veya klasörüne uygulanan izinleri silmek için de kullanılır.

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

Dosya sahipliğini aynı kuruluştaki başka bir Google Workspace hesabına aktarma

"Drive'ım"da bulunan dosyaların sahipliği, bir Google Workspace hesabından aynı kuruluştaki başka bir hesaba aktarılabilir. Ortak Drive'ın sahibi olan kuruluş, bu Drive'daki dosyaların da sahibidir. Bu nedenle, sahiplik aktarımı, ortak Drive'lardaki dosya ve klasörler için desteklenmemektedir. Ortak Drive'ın düzenleyenleri, öğeleri bu ortak Drive'dan kendi "Drive'ım" klasörlerine taşıyabilir. Bu işlem, sahipliği de kendilerine aktarır.

"Drive'ım" bölümündeki bir dosyanın sahipliğini aktarmak için aşağıdakilerden birini yapın:

• Belirli bir kullanıcıya (type=user) sahip erişimi (role=owner) veren bir dosya izni oluşturun.

• Mevcut bir dosyanın iznini role=owner ile güncelleyin ve sahipliğini belirtilen kullanıcıya (transferOwnership=true) aktarın.

Dosya sahipliğini bir tüketici hesabından diğerine aktarma

Dosyaların sahipliği, bir tüketici hesabı arasında diğerine aktarılabilir. Ancak potansiyel sahip aktarıma açıkça izin verene kadar Drive, dosyanın sahipliğini iki tüketici hesabı arasında aktarmaz. Dosya sahipliğini bir tüketici hesabından diğerine aktarmak için:

1. Mevcut sahip, potansiyel sahibin dosya iznini oluşturarak veya güncelleyerek bir sahiplik aktarımı başlatır. İznin şu ayarları içermesi gerekir: role=writer, type=user ve pendingOwner=true. Mevcut sahip, potansiyel sahip için izin oluşturuyorsa potansiyel sahibe, dosyanın sahipliğini üstlenmesinin istendiğini belirten bir e-posta bildirimi gönderilir.

2. Olası sahip, dosya izni oluşturarak veya güncelleyerek sahiplik aktarma isteğini kabul eder. İznin şu ayarları içermesi gerekir: role=owner ve transferOwnership=true. Potansiyel sahip yeni bir izin oluşturuyorsanız sahipliğin aktarıldığını belirten bir e-posta bildirimi önceki sahibe gönderilir.

Bir dosya aktarıldığında önceki sahibin rolü writer olarak düşürülür.

Toplu isteklerle birden fazla izni değiştirme

Birden fazla izni değiştirmek için toplu istek kullanmanızı önemle tavsiye ederiz.

Aşağıda, istemci kitaplığıyla toplu izin değişikliği gerçekleştirme örneği verilmiştir.

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

İlgili konular

• Dosya içeriğini koruma
• Kaynak anahtarları kullanarak bağlantıyla paylaşılan Drive dosyalarına erişme
• Roller ve izinler