Cómo compartir archivos, carpetas y unidades

Todos los archivos, las carpetas y las unidades compartidas de Google Drive tienen recursos asociados permissions. Cada recurso identifica el permiso para un type específico (user, group, domain, anyone) y role (owner, organizer, fileOrganizer, writer, commenter, reader). Por ejemplo, un archivo puede tener un permiso que otorgue a un usuario específico (type=user) acceso de solo lectura (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 las funciones y las operaciones permitidas por cada una, consulta Funciones y permisos.

Cómo funcionan los permisos

Las listas de permisos de una carpeta se propagan hacia abajo. Todos los archivos y las carpetas secundarias heredan los permisos de la carpeta superior. Cuando 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 una función nueva, como "escritor", se anula su función anterior.

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

Los permisos heredados no se pueden quitar ni reducir en ningún elemento. En cambio, estos permisos se deben ajustar en la carpeta superior de la que provienen, o bien una carpeta de la jerarquía debe habilitar el parámetro de configuración de acceso limitado.

Los permisos heredados se pueden aumentar en un elemento. Si se aumenta un permiso en un elemento secundario, cambiar el permiso de un elemento superior no afecta el permiso del elemento secundario, a menos que el nuevo permiso del elemento superior sea mayor que el del elemento secundario.

No se admiten las 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 cambio, el recurso files contiene una colección de campos capabilities booleanos 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 en función del recurso permissions del usuario actual asociado con el archivo o la carpeta.

Por ejemplo, cuando Alex accede a tu app y trata de compartir un archivo, se verifica su función para obtener permisos en el archivo. Si la función le permite compartir un archivo, las capabilities relacionadas con el archivo, como canShare, se establecen en relación con la función. Si Alex quiere compartir el archivo, tu app verifica las 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 get método 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 mostrar campos con el parámetro fields, consulta Muestra campos específicos.

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

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

Casos de uso para compartir recursos de Drive

Existen cinco tipos diferentes de casos de uso compartido:

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

   • Si el writersCanShare valor booleano está configurado como false para el archivo, el usuario debe tener role=owner.

   • Si el usuario con role=writer tiene acceso temporal regido por una fecha y hora de vencimiento, no puede compartir el archivo. Para obtener más información, consulta Establece una fecha de vencimiento para limitar el acceso a los elementos.

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

   • Si el valor booleano writersCanShare está configurado como false para el archivo, el usuario debe tener el role=owner más permisivo.

   • El acceso temporal (regido por una fecha y hora de vencimiento) solo se permite en carpetas con role=reader. Para obtener más información, consulta consulta Establece una fecha de vencimiento para limitar el acceso a los elementos.

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 configurado como true.

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

   • Si la sharingFoldersRequiresOrganizerPermission restricción en 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 mostrarán en la respuesta, puedes configurar el fields parámetro del sistema con cualquier método del recurso permissions. Si omites el parámetro fields, el servidor muestra un conjunto predeterminado de campos específicos del método. Por ejemplo, el list método muestra solo los campos id, type, kind, y role para cada archivo. Para mostrar diferentes campos, consulta Muestra campos específicos.

Crea 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 las funciones y las operaciones permitidas por cada una, consulta Funciones y permisos.

Cuando creas un permiso en el que type=user o type=group, también debes proporcionar un emailAddress para vincular el usuario o el 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, haz lo siguiente:

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 el type y el role.
3. Si type=user o type=group, proporciona un emailAddress. Si 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"
}

Usa usuarios 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 alentar a los usuarios a compartir elementos con un público más específico o limitado en lugar de con toda tu organización. Los usuarios objetivo pueden ayudarte a mejorar la seguridad y la privacidad de tus datos, y facilitar que los usuarios compartan de forma adecuada. Para obtener más información, consulta Acerca de los usuarios objetivo.

Para usar usuarios objetivo, haz lo siguiente:

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

   Ir a Usuarios objetivo

   Debes acceder con una cuenta que tenga privilegios de administrador avanzado para realizar esta tarea.

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

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

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

Para ver cómo interactúan los usuarios con los usuarios objetivo, consulta Experiencia del usuario para compartir vínculos.

Obtén un permiso

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

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

{
  "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 list método en el permissions recurso con el fileId parámetro de ruta de acceso.

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

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

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

• supportsAllDrives: Indica si la app solicitante admite Mi unidad y las unidades compartidas.

• useDomainAdminAccess: Se establece como 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 administradores de dominio.

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

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

Actualizar permisos

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

1. Llama al update método en el permissions recurso con el fileId parámetro de ruta de acceso configurado en el archivo, la carpeta o la unidad compartida asociados, y el permissionId parámetro de ruta de acceso configurado 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 de acceso 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 es miembro. Por ejemplo, Alex 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 la función nueva es más permisiva que la función otorgada a través de su membresía, el permiso nuevo se convierte en la función efectiva 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. Debes establecer de forma explícita los campos que deseas modificar en tu solicitud. Los campos que no se incluyan en la solicitud conservarán sus valores existentes. Para obtener más información, consulta Cómo trabajar con recursos parciales.

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

{
  "role": "writer"
}

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

Determina la fuente de la función

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

Para determinar la fuente de la función de una unidad compartida o de los elementos dentro de esa unidad, llama al get método en el permissions recurso con los fileId y permissionId parámetros de ruta de acceso, y el fields parámetro configurado en el permissionDetails campo.

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

Este campo enumera todos los permisos de archivo heredados y directos para el usuario, el grupo o el 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
    }
  ]
}

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.

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

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

Borra un permiso

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

No se pueden revocar los permisos heredados. En su lugar, actualiza o borra el permiso en la carpeta superior. Si borras un permiso en una carpeta, también se revoca cualquier acceso equivalente en los elementos secundarios.

Para reducir los permisos en comparación con una carpeta superior, se requiere usar el parámetro de configuración de acceso limitado.

Ten en cuenta que quitar el acceso de un usuario de un elemento superior solo revoca los permisos heredados de la carpeta superior. Si se otorgaron permisos a un usuario directamente en un archivo o una carpeta secundarios, su acceso persiste. Para asegurarte de que todos los elementos secundarios coincidan con los permisos de la carpeta superior, debes identificar y quitar los permisos directos otorgados al usuario en esos elementos secundarios.

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

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

Cuando trabajas con personas en un proyecto sensible, es posible que desees restringir su acceso a ciertos elementos de Drive después de un período. En el caso de los archivos y las carpetas, puedes establecer una fecha de vencimiento para limitar o quitar el acceso a ese elemento.

Para establecer la fecha de vencimiento, haz lo siguiente:

• Usa el create método en el permissions recurso y configura el expirationTime campo (junto con los demás campos obligatorios). Para obtener más información, consulta Crea un permiso.

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

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

• Solo se pueden configurar en los permisos de usuario y grupo.
• La hora debe ser en el futuro.
• La hora no puede ser más de un año en el futuro.
• Solo la función reader es apta para el acceso con vencimiento en una carpeta.

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

• Establece una fecha de vencimiento para el acceso a los archivos
• Agrega una fecha de vencimiento

Temas relacionados

• Administra las propuestas de acceso pendientes
• Administra carpetas con acceso limitado y expansivo
• Cómo transferir la propiedad de un archivo
• Protege el contenido de los archivos
• Accede a archivos de unidades compartidas con vínculos mediante claves de recursos
• Funciones y permisos