Condividere file, cartelle e Drive

A ogni file, cartella e Drive condiviso di Google Drive sono associate risorse permissions. Ogni risorsa identifica l'autorizzazione per un type (user, group, domain, anyone) e un role (owner, organizer, fileOrganizer, writer, commenter, reader) specifici. Ad esempio, un file potrebbe avere un'autorizzazione che concede a un utente specifico (type=user) l'accesso di sola lettura (role=reader), mentre un'altra autorizzazione concede ai membri di un gruppo specifico (type=group) la possibilità di aggiungere commenti a un file (role=commenter).

Per un elenco completo dei ruoli e delle operazioni consentite da ciascuno, consulta Ruoli e autorizzazioni.

Scenari per la condivisione delle risorse di Drive

Esistono cinque diversi tipi di scenari di condivisione:

1. Per condividere un file in Il mio Drive, l'utente deve disporre del ruolo role=writer o role=owner.

   • Se il valore booleano writersCanShare è impostato su false per il file, l'utente deve avere role=owner.

   • Se l'utente con role=writer ha accesso temporaneo regolato da una data e un'ora di scadenza, non può condividere il file. Per ulteriori informazioni, vedi Impostare una data di scadenza per limitare l'accesso ai file.

2. Per condividere una cartella in Il mio Drive, l'utente deve avererole=writer o role=owner.

   • Se il valore booleano writersCanShare è impostato su false per il file, l'utente deve disporre del valore role=owner più permissivo.

   • L'accesso temporaneo (regolato da una data e un'ora di scadenza) non è consentito alle cartelle di Il mio Drive con role=writer. Per maggiori informazioni, consulta Impostare una data di scadenza per limitare l'accesso ai file.

3. Per condividere un file in un Drive condiviso, l'utente deve avere role=writer, role=fileOrganizer o role=organizer.

   • L'impostazione writersCanShare non si applica agli elementi dei Drive condivisi. Viene considerato come se fosse sempre impostato su true.

4. Per condividere una cartella su un Drive condiviso, l'utente deve avere role=organizer.

   • Se la limitazione sharingFoldersRequiresOrganizerPermission su un Drive condiviso è impostata su false, gli utenti con role=fileOrganizer possono condividere le cartelle al suo interno.

5. Per gestire l'appartenenza a un Drive condiviso, l'utente deve disporre del ruolo role=organizer. Solo gli utenti e i gruppi possono essere membri dei Drive condivisi.

Impostare una data di scadenza per limitare l'accesso ai file

Quando collabori con altre persone a un progetto sensibile, potresti voler limitare il loro accesso a determinati file su Drive dopo un determinato periodo di tempo. Puoi farlo impostando una data di scadenza per limitare o rimuovere l'accesso a un file specifico su Il mio Drive.

Per impostare la data di scadenza:

• Utilizza il metodo create() sulla risorsa permissions e imposta il campo expirationTime insieme agli altri campi obbligatori. Per ulteriori informazioni, consulta la sezione Creare un'autorizzazione.

• Utilizza il metodo update() sulla risorsa permissions e imposta il campo expirationTime (insieme agli altri campi obbligatori). Per maggiori informazioni, consulta la sezione Modificare le autorizzazioni.

Il campo expirationTime indica la data di scadenza dell'autorizzazione utilizzando il formato RFC 3339 data-ora. Le date di scadenza sono soggette alle seguenti restrizioni:

• Possono essere impostate solo sulle autorizzazioni utente e gruppo.
• L'ora deve essere nel futuro.
• L'ora non può essere successiva a quella corrente di più di un anno.

Per ulteriori informazioni sulla data di scadenza, consulta i seguenti articoli:

• Impostare una data di scadenza per l'accesso ai file
• Aggiungere una data di scadenza

Propagazione delle autorizzazioni

Gli elenchi di autorizzazioni per una cartella si propagano verso il basso e tutti i file e le cartelle secondari ereditano le autorizzazioni dalla cartella principale. Ogni volta che le autorizzazioni o la gerarchia vengono modificate, la propagazione avviene in modo ricorsivo in tutte le cartelle nidificate. Ad esempio, se un file esiste in una cartella che viene poi spostata all'interno di un'altra cartella, le autorizzazioni per la nuova cartella si propagano al file. Se la nuova cartella concede all'utente del file un nuovo ruolo, ad esempio "autore", il nuovo ruolo overriderà il vecchio.

Al contrario, se un file eredita role=writer da una cartella e viene spostato in un'altra cartella che fornisce il ruolo "Lettore", il file eredita role=reader.

Le autorizzazioni ereditate non possono essere rimosse da un file o una cartella in un Drive condiviso. Queste autorizzazioni devono invece essere regolate sull'elemento principale diretto o indiretto da cui sono state ereditate. Le autorizzazioni ereditate possono essere rimosse dagli elementi in "Il mio Drive" o "Condivisi con me".

Al contrario, le autorizzazioni ereditate possono essere sostituite su un file o una cartella in Il mio drive. Pertanto, se un file eredita role=writer da una cartella Il mio Drive, puoi impostare role=reader sul file per abbassarne il livello di autorizzazione.

Funzionalità

La risorsa permissions non determina in ultima analisi la capacità dell'utente corrente di eseguire azioni su un file o una cartella. La risorsa files contiene invece una raccolta di campi capabilities booleani utilizzati per indicare se è possibile eseguire un'azione su un file o una cartella. L'API Google Drive imposta questi campi in base alla risorsa di autorizzazioni dell'utente corrente associata al file o alla cartella.

Ad esempio, quando Alex accede alla tua app e tenta di condividere un file, viene controllato se il suo ruolo ha autorizzazioni per il file. Se il ruolo consente di condividere un file, i capabilities relativi al file, ad esempio canShare, vengono compilati in relazione al ruolo. Se Alex vuole condividere il file, la tua app controlla il valore di capabilities per assicurarsi che canShare sia impostato su true.

Per un esempio di recupero del file capabilities, consulta Verificare le autorizzazioni dell'utente.

Creare un'autorizzazione

Per la creazione di un'autorizzazione sono necessari i due campi seguenti:

• type: il carattere type identifica l'ambito della autorizzazione (user, group, domain o anyone). Un'autorizzazione con type=user si applica a un utente specifico, mentre un'autorizzazione con type=domain si applica a tutti gli utenti di un dominio specifico.

• role: il campo role identifica le operazioni che type può eseguire. Ad esempio, un'autorizzazione con type=user e role=reader concede a un utente specifico l'accesso di sola lettura al file o alla cartella. In alternativa, un'autorizzazione con type=domain e role=commenter consente a tutti gli utenti del dominio di aggiungere commenti a un file. Per un elenco completo dei ruoli e delle operazioni consentite da ciascuno, consulta Ruoli e autorizzazioni.

Quando crei un'autorizzazione in cui type=user o type=group, devi anche fornire un emailAddress per associare l'utente o il gruppo specifico all'autorizzazione.

Quando crei un'autorizzazione in cui type=domain, devi anche fornire un valore domain per associare un dominio specifico all'autorizzazione.

Per creare un'autorizzazione:

1. Utilizza il metodo create() con il parametro di percorso fileId per il file o la cartella associato.
2. Nel corpo della richiesta, specifica type e role.
3. Se type=user o type=group, fornisci un emailAddress. Se type=domain, fornisci 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"
}

Utilizzare i segmenti di pubblico di destinazione

I segmenti di pubblico di destinazione sono gruppi di persone, ad esempio reparti o team, che puoi consigliare agli utenti per la condivisione dei propri elementi. Puoi incoraggiare gli utenti a condividere gli elementi con un pubblico più specifico o circoscritto anziché con l'intera organizzazione. I segmenti di pubblico di destinazione possono aiutarti a migliorare la sicurezza e la privacy dei tuoi dati e semplificare la condivisione da parte degli utenti in modo appropriato. Per saperne di più, consulta Informazioni sui segmenti di pubblico di destinazione.

Per utilizzare i segmenti di pubblico di destinazione:

1. Nella Console di amministrazione Google, vai a Menu menu > Directory > Segmenti di pubblico di destinazione.

   Vai a Segmenti di pubblico di destinazione

   Per questa attività, devi aver eseguito l'accesso utilizzando un account con privilegi di super amministratore.

2. Nell'elenco Segmenti di pubblico di destinazione, fai clic sul nome del pubblico di destinazione. Per creare un pubblico di destinazione, consulta Creare un pubblico di destinazione

3. Copia l'ID univoco dall'URL del pubblico di destinazione: https://admin.google.com/ac/targetaudiences/ID.

4. Crea un'autorizzazione con type=domain e imposta il campo domain su ID.audience.googledomains.com.

Per visualizzare il modo in cui gli utenti interagiscono con i segmenti di pubblico di destinazione, consulta Esperienza utente per la condivisione tramite link.

Recuperare tutte le autorizzazioni per un file, una cartella o un Drive condiviso

Utilizza il metodo list() nella risorsa permissions per recuperare tutte le autorizzazioni per un file, una cartella o un Drive condiviso.

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

Verificare le autorizzazioni dell'utente

Quando l'app apre un file, deve verificare le relative funzionalità e visualizzare l'interfaccia utente in modo che rifletta le autorizzazioni dell'utente corrente. Ad esempio, se l'utente non dispone di una funzionalità canComment per il file, la possibilità di aggiungere commenti dovrebbe essere disattivata nell'interfaccia utente.

Per ulteriori informazioni su capabilities, consulta la sezione Funzionalità.

Per controllare le funzionalità, chiama il metodo get() nella risorsa files con il parametro fileId path e il parametro fields impostato sul campo capabilities. Per maggiori informazioni sui campi restituiti utilizzando il parametro fields, consulta Restituire campi specifici per un file.

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

Determinare l'origine del ruolo per i file e le cartelle dei Drive condivisi

Per modificare il ruolo di un file o di una cartella, devi conoscere l'origine del ruolo. Per i Drive condivisi, l'origine di un ruolo può essere basata sull'appartenenza al Drive condiviso, sul ruolo in una cartella o sul ruolo in un file.

Per determinare l'origine del ruolo per un Drive condiviso o per gli elementi al suo interno, chiama il metodo get() sulla risorsa permissions con i parametri di percorso fileId e permissionId e il parametro fields impostato sul campo permissionDetails.

Per trovare permissionId, utilizza il metodo list() sulla risorsa permissions con il parametro di percorso fileId. Per recuperare il campo permissionDetails nella richiesta list, imposta il parametro fields su permissions/permissionDetails.

Questo campo elenca tutte le autorizzazioni di file ereditate e dirette per l'utente, il gruppo o il 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
    }
  ]
}

Modifica autorizzazioni

Per modificare le autorizzazioni per un file o una cartella, puoi cambiare il ruolo assegnato:

1. Chiama il metodo update() sulla risorsa permissions con il parametro di percorso permissionId impostato sull'autorizzazione da modificare e il parametro di percorso fileId impostato sul file, sulla cartella o sul Drive condiviso associato. Per trovare permissionId, utilizza il metodo list() sulla risorsa permissions con il parametro di percorso fileId.

2. Nella richiesta, identifica il nuovo role.

Puoi concedere autorizzazioni per singoli file o cartelle in un Drive condiviso anche se l'utente o il gruppo è già un membro. Ad esempio, Alex ha role=commenter come parte della sua appartenenza a un Drive condiviso. Tuttavia, la tua app può concedere ad Alexrole=writer l'accesso a un file in un Drive condiviso. In questo caso, poiché il nuovo ruolo è più permissivo del ruolo concesso tramite l'appartenenza, la nuova autorizzazione diventa il ruolo effettivo per il file o la cartella.

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

Elenca e risolvi le proposte di accesso in attesa

Una proposta di accesso è una proposta di un richiedente a un approvatore per concedere a un destinatario l'accesso a un elemento di Drive.

Un approvatore può esaminare e intervenire su tutte le proposte di accesso non risolte nei file di Drive. Ciò significa che puoi velocizzare la procedura di approvazione con una query programmatica per le proposte di accesso e poi risolverle. Inoltre, consente a un approvatore di visualizzare le proposte in forma aggregata.

L'API Drive fornisce la risorsa accessproposals in modo da poter visualizzare e risolvere le proposte di accesso in attesa. I metodi della risorsaaccessproposals funzionano su file, cartelle e file all'interno di un Drive condiviso, ma non sul Drive condiviso.

I seguenti termini sono specifici per le proposte di accesso:

• Richiedente: l'utente che avvia la proposta di accesso a un elemento di Drive.
• Destinatario: l'utente che riceve le autorizzazioni aggiuntive su un file se la proposta di accesso viene concessa. Spesso il destinatario corrisponde all'autore della richiesta, ma non sempre.
• Approvatore: l'utente responsabile dell'approvazione (o del rifiuto) della proposta di accesso. In genere, questo accade perché sono proprietari del documento o hanno la possibilità di condividerlo.

Elenca le proposte di accesso in attesa

Per elencare tutte le proposte di accesso in attesa per un elemento di Drive, chiama il metodo list() sulla risorsa accessproposals e includi il parametro di percorso fileId.

Solo gli approvatori di un file possono elencare le proposte in attesa in un file. Un approvatore è un utente con la funzionalità can_approve_access_proposals per il file. Se il richiedente non è un approvatore, viene restituito un elenco vuoto. Per ulteriori informazioni su capabilities, consulta la sezione Funzionalità.

Il corpo della risposta è costituito da un oggetto AccessProposal che rappresenta un elenco di proposte di accesso irrisolte nel file.

L'oggetto AccessProposal include informazioni su ogni proposta, ad esempio il richiedente, il destinatario e il messaggio aggiunto dal richiedente. Inoltre, include un oggetto AccessProposalRoleAndView che raggruppa il role proposto dal richiedente con un view. Poiché role è un campo ripetuto, potrebbero esistere più valori per ogni proposta. Ad esempio, una proposta potrebbe avere un oggetto AccessProposalRoleAndView di role=reader e view=published, oltre a un altro oggetto AccessProposalRoleAndView con solo il valore role=writer. Per ulteriori informazioni, consulta la sezione Visualizzazioni.

Passa i seguenti parametri di query per personalizzare la paginazione o filtrare le proposte di accesso:

• pageToken: un token di pagina, ricevuto da una precedente chiamata dell'elenco. Fornisci questo token per recuperare la pagina successiva.

• pageSize: il numero massimo di proposte di accesso da restituire per pagina.

Risolvere le proposte di accesso in attesa

Per risolvere tutte le proposte di accesso in attesa su un elemento di Drive, chiama il metodo resolve() sulla risorsa accessproposals e includi i parametri di percorso fileId e proposalId.

Il metodo resolve() include un parametro di query action che indica l'azione da intraprendere in merito alla proposta. L'oggetto Action monitora il cambiamento di stato della proposta, per sapere se è stata accettata o rifiutata.

Il metodo resolve() include anche i parametri di query facoltativi role e view. Gli unici ruoli supportati sono writer, commenter e reader. Se il ruolo non è specificato, il valore predefinito è reader. Un ulteriore parametro di query facoltativo send_notification ti consente di inviare una notifica via email all'autore della richiesta quando la proposta viene accettata o rifiutata.

Come per il metodo list(), gli utenti che risolvono la proposta devono disporre della funzionalità can_approve_access_proposals sul file. Per ulteriori informazioni su capabilities, consulta la sezione Funzionalità.

Le proposte vengono risolte utilizzando gli stessi pattern elencati in Scenari per la condivisione delle risorse di Drive. Se sono presenti più proposte per lo stesso utente, ma con ruoli diversi, si applica quanto segue:

• Se una proposta viene accettata e una viene rifiutata, il ruolo accettato si applica all'elemento di Drive.
• Se entrambe le proposte vengono accettate contemporaneamente, viene applicata la proposta con l'autorizzazione più elevata (ad esempio role=writer rispetto a role=reader). L'altra proposta di accesso viene rimossa dall'articolo.

Dopo aver inviato una proposta al metodo resolve(), l'azione di condivisione è completata. AccessProposal non viene più restituito tramite il metodo list(). Una volta accettata la proposta, l'utente deve utilizzare la raccolta permissions per aggiornare le autorizzazioni su un file o una cartella. Per ulteriori informazioni, consulta la sezione Modificare le autorizzazioni.

Revocare l'accesso a un file o a una cartella

Per revocare l'accesso a un file o a una cartella, chiama il metodo delete() sulla risorsa permissions con i parametri di percorso fileId e permissionId impostati per eliminare l'autorizzazione.

Per gli elementi in "Il mio Drive", è possibile eliminare un'autorizzazione ereditata. L'eliminazione di un'autorizzazione ereditata revoca l'accesso all'elemento e agli elementi secondari, se presenti.

Per gli elementi di un Drive condiviso, le autorizzazioni ereditate non possono essere revocate. Aggiorna o revoca l'autorizzazione per il file o la cartella principale.

Il metodo delete() viene utilizzato anche per eliminare le autorizzazioni applicate direttamente a un file o a una cartella di un Drive condiviso.

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

Trasferire la proprietà di un file a un altro account Google Workspace della stessa organizzazione

La proprietà dei file esistenti in "Il mio Drive" può essere trasferita da un account Google Workspace a un altro account della stessa organizzazione. Un'organizzazione proprietaria di un Drive condiviso è proprietaria dei file al suo interno. Pertanto, i trasferimenti di proprietà non sono supportati per i file e le cartelle dei Drive condivisi. Gli organizzatori di un Drive condiviso possono spostare gli elementi da quel Drive condiviso nel proprio "Il mio Drive", trasferendo così la proprietà a loro.

Per trasferire la proprietà di un file in "Il mio Drive", svolgi una delle seguenti operazioni:

• Crea un'autorizzazione file che conceda a un utente specifico (type=user) l'accesso come proprietario (role=owner).

• Aggiorna l'autorizzazione di un file esistente con role=owner e trasferisci la proprietà all'utente specificato (transferOwnership=true).

Trasferire la proprietà di un file da un account consumer a un altro

La proprietà dei file può essere trasferita da un account consumer a un altro. Tuttavia, Drive non trasferisce la proprietà di un file tra i due account consumer finché il potenziale proprietario non acconsente esplicitamente al trasferimento. Per trasferire la proprietà di un file da un account consumer a un altro:

1. Il proprietario attuale avvia un trasferimento di proprietà creando o aggiornando l'autorizzazione dei file del potenziale proprietario. L'autorizzazione deve includere queste impostazioni: role=writer, type=user e pendingOwner=true. Se il proprietario corrente sta creando un'autorizzazione per il proprietario potenziale, a quest'ultimo viene inviata una notifica via email che lo informa che gli viene chiesto di assumere la proprietà del file.

2. Il potenziale proprietario accetta la richiesta di trasferimento della proprietà creando o aggiornando l'autorizzazione del file. L'autorizzazione deve includere queste impostazioni: role=owner e transferOwnership=true. Se il potenziale proprietario sta creando una nuova autorizzazione, al proprietario precedente viene inviata una notifica via email che lo informa del trasferimento della proprietà.

Quando viene trasferito un file, il ruolo del proprietario precedente viene ridotto a writer.

Modificare più autorizzazioni con richieste batch

Ti consigliamo vivamente di utilizzare le richieste in batch per modificare più autorizzazioni.

Di seguito è riportato un esempio di esecuzione di una modifica collettiva delle autorizzazioni con una libreria client.

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

Argomenti correlati

• Proteggere i contenuti dei file
• Accedere ai file di Drive condivisi tramite link utilizzando le chiavi di risorsa
• Ruoli e autorizzazioni