Cómo compartir archivos, carpetas y unidades

Todos los archivos, las carpetas y las unidades compartidas de Google Drive tienen permissions. Cada recurso Identifica el permiso para un type específico (usuario, grupo, dominio, cualquiera) y role, como "comentarista" o "lector". Por ejemplo, un archivo puede tener una permiso que otorga acceso de solo lectura a un usuario específico (type=user) (role=reader), mientras que otro permiso otorga a los miembros de un grupo específico (type=group) la capacidad de agregar comentarios a un archivo (role=commenter).

Para obtener una lista completa de los roles y las operaciones que permite cada uno, consulta Roles y permisos.

Situaciones para compartir recursos de Drive

Hay cinco tipos diferentes de situaciones de uso compartido:

1. Para compartir un archivo en Mi unidad, el usuario debe tener role=writer o role=owner.

   • Si el valor booleano writersCanShare se configura como False para el archivo, el usuario debe tener role=owner.

   • Si el usuario con role=writer tiene acceso temporal regido por un fecha y hora de vencimiento, no podrá compartir el archivo. Para ver más consulta Establece una fecha de vencimiento para limitar acceso.

2. Para compartir una carpeta en Mi unidad, el usuario debe tener role=writer o role=owner.

   • Si el valor booleano writersCanShare se establece en False para el archivo, el usuario debe tener el elemento role=owner más permisivo.

   • No se permite el acceso temporal (controlado por una fecha y hora de vencimiento). en carpetas de Mi unidad con role=writer. Para ver más información, consulta Establece una fecha de vencimiento para limitar el acceso a los archivos.

3. Para compartir un archivo en una unidad compartida, el usuario debe tener role=writer, role=fileOrganizer o role=organizer.

   • El parámetro de configuración writersCanShare no se aplica a los elementos de las unidades compartidas. Se trata como si siempre estuviera configurada en True.

4. Para compartir una carpeta en una unidad compartida, el usuario debe tener role=organizer.

   • Si la restricción sharingFoldersRequiresOrganizerPermission en un La unidad compartida se estableció en False, los usuarios con role=fileOrganizer pueden compartir carpetas en esa unidad.

5. Para administrar la membresía de las unidades compartidas, el usuario debe tener role=organizer. Solo los usuarios y grupos pueden ser miembros de unidades compartidas.

Establece una fecha de vencimiento para limitar el acceso a los archivos

Cuando trabajes con personas en un proyecto delicado, es posible que desees restringir su acceso a ciertos archivos en Drive después de un tiempo. Para los archivos en Mi unidad, puedes establecer una fecha de vencimiento para limitar o quitar el acceso a ese archivo.

Para establecer la fecha de vencimiento, sigue estos pasos:

• Usa la permissions.create. y establece la permissions.expirationTime (junto con otros campos obligatorios). Para obtener más información, consulta Crea un permiso.
• Usa la permissions.update. y establece el campo permissions.expirationTime (junto con las otras campos obligatorios). Para obtener más información, consulta Cambia permisos.

El campo expirationTime indica cuándo vence el permiso mediante RFC 3339. fecha-hora de Google Cloud. Las fechas de vencimiento tienen las siguientes restricciones:

• Solo se pueden configurar en los permisos de usuario y grupo.
• La hora debe ser futura.
• El tiempo no puede ser superior a un año en el futuro.

Para obtener más información sobre la fecha de vencimiento, consulta los siguientes artículos:

• Cómo establecer una fecha de vencimiento para acceder a un archivo
• Agrega una fecha de vencimiento de Google Cloud.

Propagación de permisos

Las listas de permisos de una carpeta se propagan hacia abajo, y todos los archivos secundarios y heredan los permisos del elemento superior. Siempre que los permisos se modifica la jerarquía, la propagación ocurre de manera recursiva a través de todas individuales. Por ejemplo, si un archivo existe en una carpeta y esta se mueve, dentro de otra carpeta, los permisos de la carpeta nueva se propagan al archivo. Si la carpeta nueva otorga al usuario del archivo un nuevo rol, como “escritor”, it anula su rol anterior.

Por el contrario, si un archivo hereda role=writer de una carpeta y se mueve a otra carpeta que proporciona un "lector" el archivo ahora hereda role=reader

No se pueden quitar los permisos heredados de un archivo o una carpeta en una unidad compartida. En cambio, estos permisos deben ajustarse en el publicador superior directo o indirecto de que se heredaron. Los permisos heredados se pueden quitar de los elementos en "Mi unidad" o "Compartidos conmigo".

Por el contrario, los permisos heredados se pueden anular en un archivo o carpeta en Mi Drive Por lo tanto, si un archivo hereda role=writer de una carpeta de Drive, puedes configurar role=reader en el archivo para que baje la nivel de permiso.

Funciones

El recurso Permissions no determina en última instancia Determinan la capacidad del usuario actual de realizar acciones en un archivo o una carpeta. Un recurso Files contiene una colección de booleanos capabilities que se usan para indicar si una acción puede realizar en un archivo o carpeta. La API de Google Drive establece estos campos según el recurso de permisos del usuario actual asociado con el archivo o la carpeta.

Por ejemplo, cuando Alex accede a tu app y trata de compartir un archivo, el rol de Alex esté verificado los permisos en el archivo. Si el rol les permite compartir un archivo, Se completan los capabilities relacionados con el archivo, como canShare. en relación con el rol. Si Alejandro quiere compartir el archivo, tu app revisa la capabilities para asegurarte de que canShare esté configurado como true

Para ver un ejemplo de cómo recuperar el archivo capabilities, consulta Verificar usuario permisos.

Crea un permiso

Los dos campos siguientes son necesarios cuando se crea un permiso:

• type: type identifica el alcance del permiso (user, group, domain o anyone). Un permiso con type=user se aplica a un usuario específico, mientras que un permiso con type=domain se aplica a todos los usuarios de un dominio específico.

• role: El campo role. identifica las operaciones que puede realizar type. Por ejemplo, un el permiso con type=user y role=reader otorga a un usuario específico acceso de solo lectura al archivo o a la carpeta. O bien, un permiso con type=domain y role=commenter permite que todos los usuarios del dominio agreguen comentarios a un archivo. Para para obtener una lista completa de los roles y las operaciones que permite cada uno, consulta Roles y permisos.

Cuando creas un permiso en el que type=user o type=group, también debes proporciona un emailAddress para vincular el usuario o grupo específico al permiso.

Cuando creas un permiso en el que type=domain, también debes proporcionar un domain para vincular un dominio específico al permiso.

Para crear un permiso, sigue estos pasos:

1. Usa el método permissions.create. con fileId para el archivo o la carpeta asociados.
2. En el cuerpo de la solicitud, especifica type y role.
3. Si es type=user o type=group, proporciona un emailAddress. Si es type=domain, proporciona un 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 usuarios objetivo

Los usuarios objetivo son grupos de personas, como departamentos o equipos, que puedes recomendar para que los usuarios compartan sus artículos con ellos. Puedes alentar a los usuarios a compartir con un público más específico o limitado, en lugar de todo para que se adapten a las necesidades de tu organización. Los usuarios objetivo pueden ayudarte a mejorar la seguridad y privacidad de tus datos y facilitar que los usuarios los compartan de manera apropiada. Para ver más consulta Acerca del objetivo públicos de Google Cloud.

Para utilizar los usuarios objetivo, haz lo siguiente:

1. En la Consola del administrador de Google, ve a Menú menu > Directorio > Usuarios objetivo.

   Ir a Públicos objetivo

   Para realizar esta tarea, debes acceder con una cuenta que tenga privilegios de administrador avanzado.

2. En la lista de usuarios objetivo, haz clic en el nombre del público objetivo. Para crear un público objetivo, consulta Crea un público objetivo público

3. Copia el ID único de la URL del público objetivo: https://admin.google.com/ac/targetaudiences/ID.

4. Crea un permiso con type=domain y establece el campo domain en ID.audience.googledomains.com.

Para ver cómo interactúan los usuarios con los usuarios objetivo, consulta Experiencia del usuario para el vínculo uso compartido de Google Cloud.

Recupera todos los permisos de un archivo, una carpeta o una unidad compartida

Usa el método permissions.list para Recuperar todos los permisos de un archivo, una carpeta o una unidad compartida

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

Verifica los permisos del usuario

Cuando tu app abre un archivo, debe verificar las capacidades de este y renderizarse la IU para reflejar los permisos del usuario actual. Por ejemplo, si el usuario no tiene una función canComment en el archivo, la capacidad de comentar deben inhabilitarse en la IU.

Para obtener más información sobre capabilities, consulta Funciones. sección anterior.

Para verificar las capacidades, llama a files.get con fileId y el parámetro fields establecidos en el campo capabilities. Para más información sobre cómo mostrar campos con el parámetro fields, consulta Muestra campos específicos para un archivo.

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 la fuente del rol de los archivos de unidades compartidas y carpetas

Para cambiar el rol en un archivo o carpeta, debes conocer la fuente del rol. En el caso de las unidades compartidas, el origen de un rol puede basarse en la membresía del en la unidad de disco, el rol en una carpeta o el rol en un archivo.

Para determinar la fuente del rol de una unidad compartida o los elementos de esa Drive, llama a permissions.get con el fileId, permissionId y el parámetro fields establecidos en permissionDetails. Para encontrar el permissionId, usa permissions.list con el fileId Para recupera el campo permissionDetails en la solicitud permissions.list, configura la fields como permissions/permissionDetails.

En este campo se enumeran todos los permisos de archivo heredados y directos del usuario, grupo o dominio.

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

Cambiar permisos

Para cambiar los permisos de un archivo o una carpeta, puedes cambiar el rol asignado:

1. Llama a permissions.update con el permissionId del permiso para cambiar y fileId del permiso el archivo, la carpeta o la unidad compartida asociados. Para encontrar el permissionId, usa permissions.list con el fileId

2. En la solicitud, identifica el role nuevo.

Puedes otorgar permisos a archivos individuales o carpetas de una unidad compartida, incluso si el usuario o el grupo ya es miembro. Por ejemplo, Alejandro tiene role=commenter como parte de su membresía a una unidad compartida. Sin embargo, tu app puede otorgarle a Alex role=writer para un archivo en una unidad compartida. En este caso, como el rol nuevo es más permisivo que el rol otorgado por la membresía, el nuevo el permiso se convierte en el rol efectivo del archivo o la carpeta.

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

Cómo revocar el acceso a un archivo o una carpeta

Para revocar el acceso a un archivo o una carpeta, llama delete por el fileId y el permissionId para borrar el permiso.

Para los elementos de “Mi unidad”, es posible borrar una configuración permiso. Eliminar un permiso heredado revoca el acceso al elemento y elementos secundarios, si los hay.

No se pueden revocar los permisos heredados de los elementos de una unidad compartida. Actualizar o revocar el permiso del archivo o la carpeta superior.

La operación delete también se usa para borrar los permisos que se aplican directamente a un archivo o carpeta de la unidad compartida.

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

Transfiere la propiedad de un archivo a otra cuenta de Google Workspace de la misma organización

Propiedad de los archivos existentes en “Mi unidad” se pueden transferir desde una cuenta de Google Workspace con otra cuenta de la misma organización. Una organización que es propietaria de un Drive es propietario de los archivos que contiene. Por lo tanto, no se admiten las transferencias de propiedad para los archivos y carpetas de las unidades compartidas. Los organizadores de una unidad compartida pueden moverse los elementos de esa unidad compartida y en su propia unidad de “Mi unidad”. cuál les transfiera la propiedad.

Para transferir la propiedad de un archivo de "Mi unidad", realiza una de las siguientes acciones: lo siguiente:

• Crea un archivo de permisos que otorgue un usuario específico. (type=user) acceso de propietario (role=owner).

• Actualiza el permiso de un archivo existente con role=owner y transfiere el archivo la propiedad al usuario especificado (transferOwnership=true).

Transferir la propiedad de los archivos de una cuenta personal a otra

La propiedad de los archivos se puede transferir de una cuenta personal a otra. Sin embargo, Drive no transfiere la propiedad de un archivo entre dos consumidor cuentas hasta que el nuevo propietario potencial dé su consentimiento explícito para la transferencia. Para realizar la transferencia la propiedad de un archivo de una cuenta personal a otra:

1. El propietario actual inicia una transferencia de propiedad mediante la creación o actualización el permiso del archivo del posible nuevo propietario. El permiso debe incluir esta configuración: role=writer, type=user y pendingOwner=true. Si el botón nuevo propietario está creando un permiso para el posible propietario, un correo electrónico se envía una notificación al nuevo propietario potencial para indicar que está a la que se le pide que asuma la propiedad del archivo.

2. El nuevo propietario crea o actualiza la solicitud de transferencia de propiedad para aceptarla su permiso de acceso a archivos. El permiso debe incluir estos parámetros de configuración: role=owner y transferOwnership=true. Si el nuevo propietario crea una permiso nuevo, se enviará una notificación por correo electrónico al propietario anterior que indique que se transfirió la propiedad.

Cuando se transfiere un archivo, el rol del propietario anterior cambia a writer.

Cómo cambiar varios permisos con solicitudes por lotes

Te recomendamos que utilices solicitudes por lotes para modificar varias permisos.

El siguiente es un ejemplo de cómo realizar una modificación de permisos por lotes con un biblioteca 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;
        }
    }
}