Compartilhar arquivos, pastas e drives

Todos os arquivos, pastas e drives compartilhados do Google Drive associados permissions. Cada recurso identifica a permissão de um type específico (usuário, grupo, domínio, qualquer pessoa) e role, como "comentador" ou "leitor". Por exemplo, um arquivo pode ter um permissão que concede acesso somente leitura a um usuário específico (type=user) (role=reader) enquanto outra permissão concede participantes de um grupo específico (type=group) a capacidade de adicionar comentários a um arquivo (role=commenter).

Para uma lista completa dos papéis e das operações permitidas em cada um deles, consulte Funções e do Cloud Storage.

Situações de compartilhamento de recursos do Drive

Há cinco tipos diferentes de cenários de compartilhamento:

1. Para compartilhar um arquivo no Meu Drive, o usuário precisa ter o role=writer ou role=owner.

   • Se o valor booleano writersCanShare estiver definido como False para o arquivo, o usuário precisará ter role=owner.

   • Se o usuário com role=writer tiver acesso temporário regido por uma data e hora de expiração, não será possível compartilhar o arquivo. Para mais informações, consulte Definir uma data de expiração para limitar arquivos .

2. Para compartilhar uma pasta no Meu Drive, o usuário precisa ter role=writer ou role=owner.

   • Se o valor booleano writersCanShare for definido como False para o arquivo, o usuário precisa ter role=owner, que é mais permissiva.

   • O acesso temporário (regido por data e hora de validade) não é permitido nas pastas do Meu Drive com role=writer. Para mais informações, consulte Defina uma data de validade para limitar o acesso a arquivos.

3. Para compartilhar um arquivo em um drive compartilhado, o usuário precisa ter o role=writer, role=fileOrganizer ou role=organizer.

   • A configuração writersCanShare não se aplica aos itens nos drives compartilhados. Ele é tratado como se estivesse sempre definido como True.

4. Para compartilhar uma pasta em um drive compartilhado, o usuário precisa ter o role=organizer.

   • Se a restrição sharingFoldersRequiresOrganizerPermission em um drive compartilhado estiver definido como False, os usuários com role=fileOrganizer poderão compartilhar pastas nesse drive compartilhado.

5. Para gerenciar a associação ao drive compartilhado, o usuário precisa ter o domínio role=organizer. Somente os usuários e grupos podem participar de drives compartilhados.

Definir uma data de validade para limitar o acesso a arquivos

Ao trabalhar com pessoas em um projeto sensível, talvez você queira restringir o acesso deles a determinados arquivos no Drive após um período tempo de resposta. Nos arquivos em "Meu Drive", você pode definir uma data de validade como para limitar ou remover o acesso ao arquivo.

Para definir a data de validade:

• Usar o permissions.create e defina o método permissions.expirationTime (junto com os outros campos obrigatórios). Para mais informações, consulte Criar uma permissão.
• Usar o permissions.update e defina o campo permissions.expirationTime (junto com o outro método campos obrigatórios). Para mais informações, consulte Alterar do Cloud Storage.

O campo expirationTime indica quando a permissão expira usando RFC 3339 data-hora , Os tempos de expiração têm as seguintes restrições:

• Elas só podem ser definidas com base nas permissões do usuário e do grupo.
• O horário precisa estar no futuro.
• O horário não pode ser mais de um ano à frente.

Para mais informações sobre a data de validade, consulte os seguintes artigos:

• Definir a data de expiração do acesso a um arquivo
• Adicionar uma data de validade ,

Propagação da permissão

As listas de permissões para uma pasta são propagadas para baixo, e todos os arquivos secundários e as pastas herdam permissões da pasta pai. Sempre que as permissões ou o alteração, a propagação ocorre recursivamente por todos os do Google Cloud. Por exemplo, se um arquivo existe em uma pasta que é movida dentro de outra pasta, as permissões da nova pasta serão propagadas para o arquivo. Se a nova pasta conceder ao usuário do arquivo um novo papel, como "gravador", substitui a antiga.

Por outro lado, se um arquivo herdar role=writer de uma pasta e for movido para outra pasta que oferece uma função de "leitor" papel, o arquivo passa a herdar role=reader.

Não é possível remover permissões herdadas de um arquivo ou de uma pasta em um drive compartilhado. Em vez disso, essas permissões precisam ser ajustadas no pai direto ou indireto da que foram herdados. As permissões herdadas podem ser removidas dos itens em "Meu Drive" ou em "Compartilhados comigo".

Inversamente, as permissões herdadas podem ser substituídas em um arquivo ou uma pasta em "Meus" Google Drive. Portanto, se um arquivo herdar role=writer de uma pasta do Google Drive, você pode definir role=reader no arquivo para diminuir nível de permissão.

Recursos

O recurso Permissions não precisa determinar a capacidade do usuário atual de executar ações em um arquivo ou uma pasta. Em vez disso, um recurso Files contém uma coleção de Campos booleanos capabilities usados para indicar se uma ação pode ser executada em um arquivo ou uma pasta. A API Google Drive define esses campos com base o recurso de permissões do usuário atual associado ao arquivo ou à pasta.

Por exemplo, quando Alex faz login no app e tenta compartilhar um arquivo, a função dele é verificado quanto a permissões no arquivo. Se a função permitir que eles compartilhem um arquivo, os capabilities relacionados ao arquivo, como canShare, são preenchidos em relação à função. Se ele quiser compartilhar o arquivo, o app vai verificar capabilities para garantir que canShare seja definido como true.

Para um exemplo de recuperação do arquivo capabilities, consulte Verificar usuário do Google Cloud.

Criar uma permissão

Os dois campos a seguir são necessários ao criar uma permissão:

• type: o type identifica o escopo da permissão (user, group, domain ou anyone). Uma permissão com type=user se aplica a um usuário específico, enquanto uma permissão com type=domain se aplica a todos em um domínio específico.

• role: o campo role identifica as operações que o type pode realizar. Por exemplo, uma permissão com type=user e role=reader concede um usuário específico somente leitura ao arquivo ou à pasta. Ou uma permissão com type=domain e role=commenter permite que todos no domínio adicionem comentários a um arquivo. Para uma lista completa de funções e as operações permitidas para cada uma delas, consulte Funções e do Cloud Storage.

Ao criar uma permissão em que type=user ou type=group, você também precisa forneça um emailAddress para emparelhar o usuário ou grupo específico à permissão.

Ao criar uma permissão em que type=domain, você também precisa fornecer um domain para vincular um domínio específico à permissão.

Para criar uma permissão, faça o seguinte:

1. Usar o método permissions.create com o fileId do arquivo ou da pasta associada.
2. No corpo da solicitação, especifique type e role.
3. Se for type=user ou type=group, forneça um emailAddress. Se for type=domain, forneça um 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"
}

Usar públicos-alvo

Públicos-alvo são grupos de pessoas, como departamentos ou equipes, que você pode recomendam para os usuários compartilharem itens. Você pode incentivar os usuários a compartilhar itens para um público mais específico ou limitado, e não todo o seu organização. Os públicos-alvo ajudam a melhorar a segurança e a privacidade seus dados e facilitar o compartilhamento adequado pelos usuários. Para mais informações, consulte Sobre a segmentação públicos-alvo ,

Para usar públicos-alvo:

1. No Google Admin Console, acesse Menu menu > Diretório > Públicos-alvo.

   Acessar "Públicos-alvo"

   Para essa tarefa, você precisa fazer login usando uma conta com privilégios de superadministrador.

2. Na lista de públicos-alvo, clique no nome do público-alvo. Para criar um público-alvo, consulte Criar um público-alvo público-alvo

3. Copie o ID exclusivo do URL do público-alvo: https://admin.google.com/ac/targetaudiences/ID.

4. Crie uma permissão com type=domain e defina o campo domain como ID.audience.googledomains.com.

Para conferir como os usuários interagem com os públicos-alvo, acesse Experiência do usuário para o link compartilhamento ,

Recuperar todas as permissões de um arquivo, uma pasta ou um drive compartilhado

Use o método permissions.list para recuperam todas as permissões de um arquivo, uma pasta ou um drive compartilhado;

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

Verificar as permissões do usuário

Ao abrir um arquivo, o app verifica os recursos dele e faz a renderização interface para refletir as permissões do usuário atual. Por exemplo, se o usuário não tiver um recurso canComment no arquivo, a capacidade de comentar precisa ser desativado na interface.

Para mais informações sobre capabilities, consulte a seção Capabilities acima.

Para verificar os recursos, chame files.get com fileId e o parâmetro fields definidos para o campo capabilities. Para Para mais informações sobre como retornar campos usando o parâmetro fields, consulte Retornar campos específicos para um arquivo.

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

Determinar a origem da função nos arquivos dos drives compartilhados e pastas

Para alterar o papel em um arquivo ou uma pasta, você precisa saber a origem do papel. Nos drives compartilhados, a origem de um papel pode ser baseada na associação ao no drive, no papel em uma pasta ou em um arquivo.

Para determinar a origem do papel de um drive compartilhado ou itens desse drive dirigir, chame permissions.get com o fileId, o permissionId e o parâmetro fields definidos como permissionDetails. Para encontrar o permissionId, use permissions.list pelo fileId. Para buscar o campo permissionDetails na solicitação permissions.list, definir a fields como permissions/permissionDetails.

Esse campo enumera todas as permissões de arquivo herdadas e diretas do usuário. grupo ou domínio.

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

Alterar permissões

Para mudar as permissões de um arquivo ou uma pasta, mude a função atribuída:

1. Chame permissions.update com o permissionId da permissão para mudar e o fileId para o arquivo, pasta ou drive compartilhado associado. Para encontrar o permissionId, use permissions.list pelo fileId.

2. Na solicitação, identifique o novo role.

Você pode conceder permissões em pastas ou arquivos específicos em um drive compartilhado, até mesmo se o usuário ou grupo já for membro. Por exemplo, Alex tem role=commenter como parte da associação a um drive compartilhado. No entanto, seu app pode conceder permissão role=writer para um arquivo em um drive compartilhado. Nesse caso, como a nova função mais permissivo do que o papel concedido pela associação, o novo se torna o papel efetivo do arquivo ou da pasta.

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

Revogar acesso a um arquivo ou uma pasta

Para revogar o acesso a um arquivo ou pasta, chame delete com a fileId e o permissionId para excluir a permissão.

Para os itens em "Meu Drive", é possível excluir um modelo permissão. Excluir uma permissão herdada revoga o acesso ao item e itens secundários, se houver.

Para itens em um drive compartilhado, as permissões herdadas não podem ser revogadas. Atualizar ou revogue a permissão no arquivo ou na pasta principal.

A operação delete também é usada para excluir permissões aplicadas diretamente a uma de um drive compartilhado.

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

Transferir a propriedade de arquivos para outra conta do Google Workspace na mesma organização

Propriedade de arquivos em "Meu Drive" podem ser transferidos de uma conta do Google Workspace para outra conta na mesma organização. Uma organização proprietária de um Drive é o proprietário dos arquivos. Portanto, as transferências de propriedade não são compatíveis para arquivos e pastas nos drives compartilhados. Os organizadores de um drive compartilhado podem mover itens desse drive compartilhado para seu próprio "Meu Drive" quais transfere a propriedade a ele.

Para transferir a propriedade de um arquivo de "Meu Drive", siga um destes procedimentos: seguintes:

• Criar uma permissão de arquivo que concede a um usuário específico (type=user) acesso de proprietário (role=owner).

• Atualizar a permissão de um arquivo existente com role=owner e transferir a propriedade para o usuário especificado (transferOwnership=true).

Transferir a propriedade de arquivos de uma conta pessoal para outra

A propriedade dos arquivos pode ser transferida de uma conta pessoal para outra. No entanto, o Drive não transfere a propriedade de um arquivo entre duas consumidor contas até que o novo proprietário em potencial concorde explicitamente com a transferência. Para transferir a propriedade do arquivo de uma conta pessoal para outra:

1. O proprietário atual inicia uma transferência de propriedade criando ou atualizando a permissão de arquivo do novo proprietário em potencial. A permissão precisa incluir estas configurações: role=writer, type=user e pendingOwner=true. Se o o novo proprietário está criando uma permissão para o proprietário em potencial, um e-mail é enviada para o novo proprietário em potencial indicando que ele sendo solicitado a assumir a propriedade do arquivo.

2. O novo proprietário aceita a solicitação de transferência de propriedade criando ou atualizando a permissão dos arquivos. A permissão precisa incluir estas configurações: role=owner e transferOwnership=true. Se o novo proprietário estiver criando um nova permissão, uma notificação por e-mail será enviada para o proprietário anterior indicando que a propriedade foi transferida.

Quando um arquivo é transferido, a função do proprietário anterior é rebaixada para writer.

Alterar várias permissões com solicitações em lote

É altamente recomendável usar solicitações em lote para modificar vários permissões.

O exemplo a seguir mostra como realizar uma modificação de permissão em lote com uma biblioteca de cliente.

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