Cómo compartir archivos, carpetas y unidades

Cada archivo, carpeta y unidad compartida de Google Drive tiene recursos permissions asociados. Cada recurso identifica el permiso para un type específico (user, group, domain, anyone) y un role (owner, organizer, fileOrganizer, writer, commenter, reader). Por ejemplo, un archivo puede tener un permiso que le otorga a un usuario específico (type=user) acceso de solo lectura (role=reader), mientras que otro permiso les 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 permitidas por cada uno, consulta Roles y permisos.

Cómo funcionan los permisos

Las listas de permisos de una carpeta se propagan hacia abajo. Todos los archivos y las carpetas secundarios heredan los permisos de la carpeta superior. Cada vez que se cambian los permisos o la jerarquía, la propagación se produce de forma recursiva en todas las carpetas anidadas. Por ejemplo, si un archivo existe en una carpeta y, luego, esa carpeta se mueve dentro de otra, los permisos de la carpeta nueva se propagan al archivo. Si la carpeta nueva otorga al usuario del archivo un rol nuevo, como "escritor", se 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 rol de "lector", el archivo ahora hereda role=reader.

Los permisos heredados no se pueden quitar de un archivo o una carpeta en una unidad compartida. En su lugar, estos permisos se deben ajustar en el recurso superior directo o indirecto del 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 una carpeta de Mi Drive. Por lo tanto, si un archivo hereda role=writer de una carpeta de Mi Drive, puedes establecer role=reader en el archivo para reducir su nivel de permisos.

No se admiten operaciones de permisos simultáneas en el mismo archivo. Solo se aplica la última actualización.

Comprende las capacidades de los archivos

En última instancia, el recurso permissions no determina la capacidad del usuario actual para realizar acciones en un archivo o una carpeta. En su lugar, el recurso files contiene una colección de campos booleanos capabilities que se usan para indicar si se puede realizar una acción en un archivo o una carpeta. La API de Google Drive establece estos campos según el recurso permissions del usuario actual asociado al archivo o la carpeta.

Por ejemplo, cuando Alex accede a tu app y trata de compartir un archivo, se verifica el rol de Alex para determinar si tiene permisos sobre el archivo. Si el rol permite compartir un archivo, los capabilities relacionados con el archivo, como canShare, se configuran en relación con el rol. Si Alex quiere compartir el archivo, tu app verifica el capabilities para asegurarse de que canShare esté configurado como true.

Obtén las capacidades de los archivos

Cuando tu app abre un archivo, debe verificar sus capacidades y renderizar la IU para reflejar los permisos del usuario actual. Por ejemplo, si el usuario no tiene la capacidad canComment en el archivo, la capacidad de comentar debe inhabilitarse en la IU.

Para verificar las capacidades, llama al método get en el recurso files con el parámetro de ruta de acceso fileId y el parámetro fields configurado en el campo capabilities. Para obtener más información sobre cómo devolver campos con el parámetro fields, consulta Cómo devolver campos específicos.

En el siguiente ejemplo de código, se muestra cómo verificar los permisos del usuario. La respuesta devuelve una lista de las capacidades que el usuario tiene en el archivo. Cada capacidad corresponde a una acción detallada que puede realizar un usuario. Algunos campos solo se completan para los elementos de unidades compartidas.

Solicitud

GET https://www.googleapis.com/drive/v3/files/FILE_ID?fields=capabilities

Respuesta

{
  "capabilities": {
    "canAcceptOwnership": false,
    "canAddChildren": false,
    "canAddMyDriveParent": false,
    "canChangeCopyRequiresWriterPermission": true,
    "canChangeItemDownloadRestriction": true,
    "canChangeSecurityUpdateEnabled": false,
    "canChangeViewersCanCopyContent": true,
    "canComment": true,
    "canCopy": true,
    "canDelete": true,
    "canDisableInheritedPermissions": false,
    "canDownload": true,
    "canEdit": true,
    "canEnableInheritedPermissions": true,
    "canListChildren": false,
    "canModifyContent": true,
    "canModifyContentRestriction": true,
    "canModifyEditorContentRestriction": true,
    "canModifyOwnerContentRestriction": true,
    "canModifyLabels": true,
    "canMoveChildrenWithinDrive": false,
    "canMoveItemIntoTeamDrive": true,
    "canMoveItemOutOfDrive": true,
    "canMoveItemWithinDrive": true,
    "canReadLabels": true,
    "canReadRevisions": true,
    "canRemoveChildren": false,
    "canRemoveContentRestriction": false,
    "canRemoveMyDriveParent": true,
    "canRename": true,
    "canShare": true,
    "canTrash": true,
    "canUntrash": true
  }
}

Situaciones para compartir recursos de Drive

Existen 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.

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

  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 considera como si siempre estuviera establecido en true.

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

    • Si la restricción sharingFoldersRequiresOrganizerPermission de una unidad compartida está configurada como false, los usuarios con role=fileOrganizer pueden compartir carpetas en esa unidad compartida.

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

Usa el parámetro fields

Si deseas especificar los campos que se devolverán en la respuesta, puedes establecer el parámetro del sistema fields con cualquier método del recurso permissions. Si omites el parámetro fields, el servidor devolverá un conjunto predeterminado de campos específicos para el método. Por ejemplo, el método list solo devuelve los campos id, type, kind y role para cada archivo. Para devolver diferentes campos, consulta Cómo devolver campos específicos.

Cómo crear un permiso

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

  • type: El 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 el type. Por ejemplo, un permiso con type=user y role=reader otorga a un usuario específico acceso de solo lectura al archivo o 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 obtener una lista completa de los roles y las operaciones permitidas por cada uno, consulta Roles y permisos.

Cuando creas un permiso en el que type=user o type=group, también debes proporcionar un emailAddress para vincular al usuario o grupo específico con el 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 create en el recurso permissions con el parámetro de ruta de acceso fileId para el archivo o la carpeta asociados.
  2. En el cuerpo de la solicitud, especifica los parámetros type y role.
  3. Si es type=user o type=group, proporciona un emailAddress. Si es type=domain, proporciona un domain.

En el siguiente ejemplo de código, se muestra cómo crear un permiso. La respuesta devuelve una instancia de un recurso permissions, incluido el permissionId asignado.

Solicitud

POST https://www.googleapis.com/drive/v3/files/FILE_ID/permissions
 
{
  "requests": [
    {
        "type": "user",
        "role": "commenter",
        "emailAddress": "alex@altostrat.com"
    }
  ]
}

Respuesta

{
    "kind": "drive#permission",
    "id": "PERMISSION_ID",
    "type": "user",
    "role": "commenter"
}

Cómo usar los públicos objetivo

Los usuarios objetivo son grupos de personas, como departamentos o equipos, que puedes recomendar para que los usuarios compartan sus elementos con ellos. Puedes invitar a los usuarios a compartir elementos con un público más específico o limitado en lugar de toda la organización. Los usuarios objetivo pueden ayudarte a mejorar la seguridad y la privacidad de tus datos, y facilitar que los usuarios compartan contenido de forma adecuada. Para obtener más información, consulta Acerca de los públicos objetivo.

Para usar los públicos objetivo, sigue estos pasos:

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

    Ir a Usuarios objetivo

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

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

  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 públicos objetivo, consulta Experiencia del usuario para el uso compartido de vínculos.

Cómo obtener un permiso

Para obtener un permiso, usa el método get en el recurso permissions con los parámetros de ruta de acceso fileId y permissionId. Si no conoces el ID del permiso, puedes listar todos los permisos con el método list.

En el siguiente ejemplo de código, se muestra cómo obtener un permiso por ID. La respuesta devuelve una instancia de un recurso permissions.

Solicitud

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

Respuesta

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

Enumera todos los permisos

Para enumerar los permisos de un archivo, una carpeta o una unidad compartida, usa el método list en el recurso permissions con el parámetro de ruta de acceso fileId.

Pasa los siguientes parámetros de consulta para personalizar la paginación o filtrar los permisos:

  • pageSize: Es la cantidad máxima de permisos que se devolverán por página. Si no se configura para los archivos de una unidad compartida, se devuelven como máximo 100 resultados. Si no se configura para los archivos que no están en una unidad compartida, se devuelve la lista completa.

  • pageToken: Es un token de página que se recibió de una llamada a lista anterior. Proporciona este token para recuperar la página siguiente.

  • supportsAllDrives: Indica si la app que realiza la solicitud admite tanto Mi unidad como las unidades compartidas.

  • useDomainAdminAccess: Se establece en true para emitir la solicitud como administrador de dominio. Si el parámetro fileId hace referencia a una unidad compartida y el solicitante es administrador del dominio al que pertenece la unidad compartida. Para obtener más información, consulta Administra unidades compartidas como administrador del dominio.

  • includePermissionsForView: Son los permisos de la vista adicional que se incluirán en la respuesta. Solo se admite published.

En el siguiente ejemplo de código, se muestra cómo obtener todos los permisos. La respuesta devuelve una lista de permisos para un archivo, una carpeta o una unidad compartida.

Solicitud

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

Respuesta

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

Actualizar permisos

Para actualizar los permisos de un archivo o una carpeta, puedes cambiar el rol asignado. Para obtener más información sobre cómo encontrar la fuente del rol, consulta Cómo determinar la fuente del rol.

  1. Llama al método update en el recurso permissions con el parámetro de ruta de acceso fileId establecido en el archivo, la carpeta o la unidad compartida asociados, y el parámetro de ruta de acceso permissionId establecido en el permiso que se cambiará. Para encontrar el permissionId, usa el método list en el recurso permissions con el parámetro de ruta fileId.

  2. En la solicitud, identifica el nuevo role.

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

Puedes aplicar actualizaciones a través de la semántica de parches, lo que significa que puedes realizar modificaciones parciales en un recurso. En tu solicitud, debes establecer de forma explícita los campos que deseas modificar. Los campos que no se incluyan en la solicitud conservarán sus valores existentes. Para obtener más información, consulta Trabaja con recursos parciales.

En el siguiente ejemplo de código, se muestra cómo cambiar los permisos de un archivo o una carpeta de commenter a writer. La respuesta devuelve una instancia de un recurso permissions.

Solicitud

PATCH https://www.googleapis.com/drive/v3/files/FILE_ID/permissions/PERMISSION_ID
 
{
  "requests": [
    {
        "role": "writer"
    }
  ]
}

Respuesta

{
  "kind": "drive#permission",
  "id": "PERMISSION_ID",
  "type": "user",
  "role": "writer"
}

Determina la fuente del rol

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

Para determinar la fuente del rol de una unidad compartida o de los elementos que contiene, llama al método get en el recurso permissions con los parámetros de ruta fileId y permissionId, y el parámetro fields establecido en el campo permissionDetails.

Para encontrar el permissionId, usa el método list en el recurso permissions con el parámetro de ruta fileId. Para recuperar el campo permissionDetails en la solicitud list, establece el parámetro fields en permissions/permissionDetails.

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

En el siguiente ejemplo de código, se muestra cómo determinar la fuente del rol. La respuesta devuelve el permissionDetails de un recurso permissions. El campo inheritedFrom proporciona el ID del elemento del que se hereda el permiso.

Solicitud

GET https://www.googleapis.com/drive/v3/files/FILE_ID/permissions/PERMISSION_ID?fields=permissionDetails&supportsAllDrives=true

Respuesta

{
  "permissionDetails": [
    {
      "permissionType": "member",
      "role": "commenter",
      "inheritedFrom": "INHERITED_FROM_ID",
      "inherited": true
    },
    {
      "permissionType": "file",
      "role": "writer",
      "inherited": false
    }
  ]
}

Actualiza varios permisos con solicitudes por lotes

Te recomendamos que uses solicitudes por lotes para modificar varios permisos.

A continuación, se muestra un ejemplo de cómo realizar una modificación de permisos por lotes con una biblioteca cliente.

Java

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

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

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

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

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


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

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

        ids.add(permission.getId());

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

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

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

      domainPermission.setDomain(realDomain);

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

      batch.execute();

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

Python

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


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

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

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

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

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

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

  return ids


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

Node.js

drive/snippets/drive_v3/file_snippets/share_file.js
import {GoogleAuth} from 'google-auth-library';
import {google} from 'googleapis';

/**
 * Shares a file with a user and a domain.
 * @param {string} fileId The ID of the file to share.
 * @param {string} targetUserEmail The email address of the user to share with.
 * @param {string} targetDomainName The domain to share with.
 * @return {Promise<Array<string>>} A promise that resolves to an array of permission IDs.
 */
async function shareFile(fileId, targetUserEmail, targetDomainName) {
  // Authenticate with Google and get an authorized client.
  // TODO (developer): Use an appropriate auth mechanism for your app.
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });

  // Create a new Drive API client (v3).
  const service = google.drive({version: 'v3', auth});

  /** @type {Array<string>} */
  const permissionIds = [];

  // The permissions to create.
  const permissions = [
    {
      type: 'user',
      role: 'writer',
      emailAddress: targetUserEmail, // e.g., 'user@partner.com'
    },
    {
      type: 'domain',
      role: 'writer',
      domain: targetDomainName, // e.g., 'example.com'
    },
  ];

  // Iterate through the permissions and create them one by one.
  for (const permission of permissions) {
    const result = await service.permissions.create({
      requestBody: permission,
      fileId,
      fields: 'id',
    });

    if (result.data.id) {
      permissionIds.push(result.data.id);
      console.log(`Inserted permission id: ${result.data.id}`);
    } else {
      throw new Error('Failed to create permission');
    }
  }
  return permissionIds;
}

PHP

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

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

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

}

.NET

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

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

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

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

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

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

Cómo borrar un permiso

Para revocar el acceso a un archivo o una carpeta, llama al método delete en el recurso permissions con los parámetros de ruta de acceso fileId y permissionId establecidos para borrar el permiso.

En el caso de los elementos de "Mi unidad", es posible borrar un permiso heredado. Borrar un permiso heredado revoca el acceso al elemento y a los elementos secundarios, si los hay.

En el caso de los elementos de una unidad compartida, no se pueden revocar los permisos heredados. En su lugar, actualiza o borra el permiso en el archivo o la carpeta principal.

El método delete también se usa para borrar los permisos aplicados directamente a un archivo o una carpeta de la unidad compartida.

En la siguiente muestra de código, se muestra cómo revocar el acceso borrando un objeto permissionId. Si se ejecuta correctamente, el cuerpo de la respuesta es un objeto JSON vacío. Para confirmar que se quitó el permiso, usa el método list en el recurso permissions con el parámetro de ruta de acceso fileId.

Solicitud

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

Cómo establecer una fecha de vencimiento para limitar el acceso a un archivo

Cuando trabajas con personas en un proyecto sensible, es posible que quieras restringir su acceso a ciertos archivos en Drive después de un período. En el caso de los archivos de 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 el método create en el recurso permissions y establece el campo expirationTime (junto con los demás campos obligatorios). Para obtener más información, consulta Crea un permiso.

  • Usa el método update en el recurso permissions y establece el campo expirationTime (junto con los demás campos obligatorios). Para obtener más información, consulta Actualiza permisos.

El campo expirationTime indica cuándo vence el permiso con fecha y hora de RFC 3339. Los tiempos de vencimiento tienen las siguientes restricciones:

  • Solo se pueden configurar en los permisos de usuarios y grupos.
  • La hora debe ser posterior a la actual.
  • La fecha no puede ser posterior a un año a partir de la fecha actual.

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