A API Google Apps Script fornece um método scripts.run
que executa remotamente uma função especificada do Apps Script. Use esse método em um aplicativo de chamada para executar uma função em um dos seus projetos de script remotamente e receber uma resposta.
Requisitos
Atenda aos requisitos a seguir para que um aplicativo de chamadas possa usar
o método
scripts.run
. Você precisa fazer o seguinte:
Implantar o projeto de script como um executável de API. É possível implantar, cancelar a implantação e reimplantar projetos conforme necessário.
Fornecer um token OAuth com escopo adequado para a execução. Esse token OAuth precisa abranger todos os escopos usados pelo script, não apenas aqueles usados pela função chamada. Veja a lista completa de escopos de autorização na referência do método.
Verifique se o script e o cliente OAuth2 do aplicativo de chamada compartilham um projeto comum do Google Cloud. O projeto do Cloud precisa ser um projeto padrão do Cloud. Os projetos padrão criados para projetos do Apps Script são insuficientes. É possível usar um projeto novo ou padrão do Cloud.
Ative a API Google Apps Script no projeto do Cloud.
O método scripts.run
O método scripts.run
requer informações de identificação de chave para ser executado:
- O ID do projeto de script.
- O nome da função a ser executada.
- A lista de parâmetros que a função exige (se houver).
Você pode configurar seu script para ser executado no modo de desenvolvimento.
Esse modo é executado com a versão salva mais recente do projeto de script
em vez da versão implantada mais recentemente. Para isso, defina o
booleano devMode
no
corpo da solicitação
como true
. Somente o proprietário do script pode executá-lo no modo de desenvolvimento.
Como processar tipos de dados de parâmetro
O uso do método scripts.run
da API Apps Script geralmente envolve o envio de dados para o Apps Script como parâmetros de função e o recebimento de dados como valores de retorno da função. A API só pode receber e retornar valores com tipos básicos: strings, matrizes, objetos, números e booleanos. Eles
são semelhantes aos tipos básicos do JavaScript. Objetos mais complexos do Apps Script, como Document ou Sheet, não podem ser transmitidos para o projeto do script ou a partir dele pela API.
Quando o aplicativo de chamada é escrito em uma linguagem de tipo elevado, como Java, ele transmite parâmetros como uma lista ou matriz de objetos genéricos correspondentes a esses tipos básicos. Em muitos casos, é possível aplicar conversões
de tipo simples automaticamente. Por exemplo, uma função que usa um parâmetro de número pode receber um objeto Java Double
, Integer
ou Long
como um parâmetro sem processamento extra.
Quando a API retorna a resposta da função, muitas vezes é necessário transmitir o valor retornado para o tipo correto antes que ele possa ser usado. Veja alguns exemplos baseados em Java:
- Os números retornados pela API para um aplicativo Java chegam como objetos
java.math.BigDecimal
e podem precisar ser convertidos para os tiposDoubles
ouint
, conforme necessário. Se a função do Apps Script retornar uma matriz de strings, um aplicativo Java vai lançar a resposta em um objeto
List<String>
:List<String> mylist = (List<String>)(op.getResponse().get("result"));
Se você quiser retornar uma matriz de
Bytes
, talvez seja conveniente codificar a matriz como uma string base64 na função do Apps Script e retornar essa string:return Utilities.base64Encode(myByteArray); // returns a String.
As amostras de código de exemplo abaixo ilustram maneiras de interpretar a resposta da API.
Procedimento geral
Veja a seguir o procedimento geral para usar a API Apps Script para executar funções do Apps Script:
Etapa 1: configurar o projeto comum do Cloud
O script e o aplicativo de chamada precisam compartilhar o mesmo projeto do Cloud. Esse projeto do Cloud pode ser um projeto atual ou um novo projeto criado para essa finalidade. Depois que você tiver um projeto do Cloud, mude seu projeto de script para usá-lo.
Etapa 2: implantar o script como um executável da API
- Abra o projeto do Apps Script com as funções que você quer usar.
- No canto superior direito, clique em Implantar > Nova implantação.
- Na caixa de diálogo aberta, clique em Ativar tipos de implantação
> API executável.
- No menu suspenso "Quem pode acessar", selecione os usuários que têm permissão para chamar as funções do script usando a API Apps Script.
- Clique em Implantar.
Etapa 3: configurar o aplicativo de chamada
O aplicativo de chamada precisa ativar a API Apps Script e estabelecer credenciais OAuth para poder usá-la. Para isso, é preciso ter acesso ao projeto do Cloud.
- Configure o projeto do Cloud que o aplicativo e o script de chamada estão usando. Para isso, siga estas etapas:
- Abra o projeto de script e clique em Visão geral
à esquerda.
- Em Escopos do OAuth do projeto, registre todos os escopos exigidos pelo script.
No código do aplicativo de chamada, gere um token de acesso do OAuth de script para a chamada de API. Esse não é um token que a própria API usa, mas sim o script que precisa ser executado. Ele precisa ser criado usando o ID do cliente do projeto do Cloud e os escopos do script que você registrou.
As bibliotecas de cliente do Google podem ajudar muito na criação desse token e no gerenciamento do OAuth do aplicativo. Geralmente, isso permite que você crie um objeto de "credenciais" de nível superior usando os escopos do script. Consulte os guias de início rápido da API Apps Script para ver exemplos de como criar um objeto de credenciais a partir de uma lista de escopos.
Etapa 4: fazer a solicitação script.run
Depois de configurar o aplicativo de chamada, você pode fazer
chamadas do scripts.run
. Cada chamada de API consiste nas seguintes etapas:
- Crie uma solicitação de API usando o ID do script, o nome da função e todos os parâmetros necessários.
- Faça a chamada
scripts.run
e inclua o token de OAuth do script que você criou no cabeçalho (se estiver usando uma solicitaçãoPOST
básica) ou use um objeto de credenciais criado com os escopos do script. - Aguarde a conclusão da execução do script. Os scripts podem demorar até seis minutos de execução. Portanto, o aplicativo precisa permitir isso.
- Ao terminar, a função do script poderá retornar um valor, que a API retornará ao aplicativo se o valor for compatível.
Veja exemplos de chamadas de API script.run
abaixo.
Exemplos de solicitação de API
Os exemplos a seguir mostram como fazer uma solicitação de execução da API Apps Script em
várias linguagens, chamando uma função do Apps Script para exibir uma lista de
pastas no diretório raiz do usuário. O ID do script do projeto do Apps Script que contém a função executada precisa ser especificado quando indicado com ENTER_YOUR_SCRIPT_ID_HERE
. Os exemplos dependem das bibliotecas de cliente da API do Google para as respectivas linguagens.
Script de destino
A função neste script usa a API Drive.
Você precisa ativar a API Drive no projeto que hospeda o script.
Além disso, os aplicativos de chamada precisam enviar credenciais de OAuth que incluam o seguinte escopo do Drive:
https://www.googleapis.com/auth/drive
Os aplicativos de exemplo aqui usam as bibliotecas de cliente do Google para criar objetos de credencial para OAuth usando esse escopo.
/**
* Return the set of folder names contained in the user's root folder as an
* object (with folder IDs as keys).
* @return {Object} A set of folder names keyed by folder ID.
*/
function getFoldersUnderRoot() {
const root = DriveApp.getRootFolder();
const folders = root.getFolders();
const folderSet = {};
while (folders.hasNext()) {
const folder = folders.next();
folderSet[folder.getId()] = folder.getName();
}
return folderSet;
}
Java
/**
* Create a HttpRequestInitializer from the given one, except set
* the HTTP read timeout to be longer than the default (to allow
* called scripts time to execute).
*
* @param {HttpRequestInitializer} requestInitializer the initializer
* to copy and adjust; typically a Credential object.
* @return an initializer with an extended read timeout.
*/
private static HttpRequestInitializer setHttpTimeout(
final HttpRequestInitializer requestInitializer) {
return new HttpRequestInitializer() {
@Override
public void initialize(HttpRequest httpRequest) throws IOException {
requestInitializer.initialize(httpRequest);
// This allows the API to call (and avoid timing out on)
// functions that take up to 6 minutes to complete (the maximum
// allowed script run time), plus a little overhead.
httpRequest.setReadTimeout(380000);
}
};
}
/**
* Build and return an authorized Script client service.
*
* @param {Credential} credential an authorized Credential object
* @return an authorized Script client service
*/
public static Script getScriptService() throws IOException {
Credential credential = authorize();
return new Script.Builder(
HTTP_TRANSPORT, JSON_FACTORY, setHttpTimeout(credential))
.setApplicationName(APPLICATION_NAME)
.build();
}
/**
* Interpret an error response returned by the API and return a String
* summary.
*
* @param {Operation} op the Operation returning an error response
* @return summary of error response, or null if Operation returned no
* error
*/
public static String getScriptError(Operation op) {
if (op.getError() == null) {
return null;
}
// Extract the first (and only) set of error details and cast as a Map.
// The values of this map are the script's 'errorMessage' and
// 'errorType', and an array of stack trace elements (which also need to
// be cast as Maps).
Map<String, Object> detail = op.getError().getDetails().get(0);
List<Map<String, Object>> stacktrace =
(List<Map<String, Object>>) detail.get("scriptStackTraceElements");
java.lang.StringBuilder sb =
new StringBuilder("\nScript error message: ");
sb.append(detail.get("errorMessage"));
sb.append("\nScript error type: ");
sb.append(detail.get("errorType"));
if (stacktrace != null) {
// There may not be a stacktrace if the script didn't start
// executing.
sb.append("\nScript error stacktrace:");
for (Map<String, Object> elem : stacktrace) {
sb.append("\n ");
sb.append(elem.get("function"));
sb.append(":");
sb.append(elem.get("lineNumber"));
}
}
sb.append("\n");
return sb.toString();
}
public static void main(String[] args) throws IOException {
// ID of the script to call. Acquire this from the Apps Script editor,
// under Publish > Deploy as API executable.
String scriptId = "ENTER_YOUR_SCRIPT_ID_HERE";
Script service = getScriptService();
// Create an execution request object.
ExecutionRequest request = new ExecutionRequest()
.setFunction("getFoldersUnderRoot");
try {
// Make the API request.
Operation op =
service.scripts().run(scriptId, request).execute();
// Print results of request.
if (op.getError() != null) {
// The API executed, but the script returned an error.
System.out.println(getScriptError(op));
} else {
// The result provided by the API needs to be cast into
// the correct type, based upon what types the Apps
// Script function returns. Here, the function returns
// an Apps Script Object with String keys and values,
// so must be cast into a Java Map (folderSet).
Map<String, String> folderSet =
(Map<String, String>) (op.getResponse().get("result"));
if (folderSet.size() == 0) {
System.out.println("No folders returned!");
} else {
System.out.println("Folders under your root folder:");
for (String id : folderSet.keySet()) {
System.out.printf(
"\t%s (%s)\n", folderSet.get(id), id);
}
}
}
} catch (GoogleJsonResponseException e) {
// The API encountered a problem before the script was called.
e.printStackTrace(System.out);
}
}
JavaScript
/**
* Load the API and make an API call. Display the results on the screen.
*/
function callScriptFunction() {
const scriptId = '<ENTER_YOUR_SCRIPT_ID_HERE>';
// Call the Apps Script API run method
// 'scriptId' is the URL parameter that states what script to run
// 'resource' describes the run request body (with the function name
// to execute)
try {
gapi.client.script.scripts.run({
'scriptId': scriptId,
'resource': {
'function': 'getFoldersUnderRoot',
},
}).then(function(resp) {
const result = resp.result;
if (result.error && result.error.status) {
// The API encountered a problem before the script
// started executing.
appendPre('Error calling API:');
appendPre(JSON.stringify(result, null, 2));
} else if (result.error) {
// The API executed, but the script returned an error.
// Extract the first (and only) set of error details.
// The values of this object are the script's 'errorMessage' and
// 'errorType', and an array of stack trace elements.
const error = result.error.details[0];
appendPre('Script error message: ' + error.errorMessage);
if (error.scriptStackTraceElements) {
// There may not be a stacktrace if the script didn't start
// executing.
appendPre('Script error stacktrace:');
for (let i = 0; i < error.scriptStackTraceElements.length; i++) {
const trace = error.scriptStackTraceElements[i];
appendPre('\t' + trace.function + ':' + trace.lineNumber);
}
}
} else {
// The structure of the result will depend upon what the Apps
// Script function returns. Here, the function returns an Apps
// Script Object with String keys and values, and so the result
// is treated as a JavaScript object (folderSet).
const folderSet = result.response.result;
if (Object.keys(folderSet).length == 0) {
appendPre('No folders returned!');
} else {
appendPre('Folders under your root folder:');
Object.keys(folderSet).forEach(function(id) {
appendPre('\t' + folderSet[id] + ' (' + id + ')');
});
}
}
});
} catch (err) {
document.getElementById('content').innerText = err.message;
return;
}
}
Node.js
/**
* Call an Apps Script function to list the folders in the user's root Drive
* folder.
*
*/
async function callAppsScript() {
const scriptId = '1xGOh6wCm7hlIVSVPKm0y_dL-YqetspS5DEVmMzaxd_6AAvI-_u8DSgBT';
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 script = google.script({version: 'v1', auth});
try {
// Make the API request. The request object is included here as 'resource'.
const resp = await script.scripts.run({
auth: auth,
resource: {
function: 'getFoldersUnderRoot',
},
scriptId: scriptId,
});
if (resp.error) {
// The API executed, but the script returned an error.
// Extract the first (and only) set of error details. The values of this
// object are the script's 'errorMessage' and 'errorType', and an array
// of stack trace elements.
const error = resp.error.details[0];
console.log('Script error message: ' + error.errorMessage);
console.log('Script error stacktrace:');
if (error.scriptStackTraceElements) {
// There may not be a stacktrace if the script didn't start executing.
for (let i = 0; i < error.scriptStackTraceElements.length; i++) {
const trace = error.scriptStackTraceElements[i];
console.log('\t%s: %s', trace.function, trace.lineNumber);
}
}
} else {
// The structure of the result will depend upon what the Apps Script
// function returns. Here, the function returns an Apps Script Object
// with String keys and values, and so the result is treated as a
// Node.js object (folderSet).
const folderSet = resp.response.result;
if (Object.keys(folderSet).length == 0) {
console.log('No folders returned!');
} else {
console.log('Folders under your root folder:');
Object.keys(folderSet).forEach(function(id) {
console.log('\t%s (%s)', folderSet[id], id);
});
}
}
} catch (err) {
// TODO(developer) - Handle error
throw err;
}
}
Python
from __future__ import print_function
import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
def main():
"""Runs the sample.
"""
# pylint: disable=maybe-no-member
script_id = '1VFBDoJFy6yb9z7-luOwRv3fCmeNOzILPnR4QVmR0bGJ7gQ3QMPpCW-yt'
creds, _ = google.auth.default()
service = build('script', 'v1', credentials=creds)
# Create an execution request object.
request = {"function": "getFoldersUnderRoot"}
try:
# Make the API request.
response = service.scripts().run(scriptId=script_id,
body=request).execute()
if 'error' in response:
# The API executed, but the script returned an error.
# Extract the first (and only) set of error details. The values of
# this object are the script's 'errorMessage' and 'errorType', and
# a list of stack trace elements.
error = response['error']['details'][0]
print(f"Script error message: {0}.{format(error['errorMessage'])}")
if 'scriptStackTraceElements' in error:
# There may not be a stacktrace if the script didn't start
# executing.
print("Script error stacktrace:")
for trace in error['scriptStackTraceElements']:
print(f"\t{0}: {1}."
f"{format(trace['function'], trace['lineNumber'])}")
else:
# The structure of the result depends upon what the Apps Script
# function returns. Here, the function returns an Apps Script
# Object with String keys and values, and so the result is
# treated as a Python dictionary (folder_set).
folder_set = response['response'].get('result', {})
if not folder_set:
print('No folders returned!')
else:
print('Folders under your root folder:')
for (folder_id, folder) in folder_set.items():
print(f"\t{0} ({1}).{format(folder, folder_id)}")
except HttpError as error:
# The API encountered a problem before the script started executing.
print(f"An error occurred: {error}")
print(error.content)
if __name__ == '__main__':
main()
Limitações
A API Apps Script tem várias limitações:
Um projeto comum do Cloud. O script que está sendo chamado e o aplicativo que fez a chamada precisam compartilhar um projeto do Cloud. O projeto do Cloud precisa ser um projeto do Cloud padrão. Os projetos padrão criados para projetos do Apps Script são insuficientes. O projeto padrão do Cloud pode ser um projeto novo ou existente.
Parâmetros básicos e tipos de retorno. A API não pode transmitir ou retornar objetos específicos do Apps Script (como Documentos, Blobs, Agendas, Arquivos do Drive etc.) para o aplicativo. Somente tipos básicos, como strings, matrizes, objetos, números e booleanos, podem ser transmitidos e retornados.
Escopos do OAuth. A API só pode executar scripts com pelo menos um escopo obrigatório. Isso significa que não é possível usar a API para chamar um script que não exija autorização de um ou mais serviços.
Nenhum acionador.A API não pode criar acionadores do Apps Script.