Especificações do SDK

Métodos e propriedades

Você pode incluir os seguintes métodos e propriedades em seu aplicativo personalizado ou página da web.

Init

O método init é opcional. Ele retorna a Instância IRobotSDK, que habilita você a armazená-la como uma variável para uso posterior.

const robot = UiPathRobot.init();

Configurações

A propriedade settings do tipo Configurações permite que você altere o número da porta padrão, o período do intervalo de pesquisa em milissegundos ou desabilite o envio de dados de telemetria.

const robot = UiPathRobot.init();
robot.settings.portNumber = 1234;
robot.settings.pollTimeInterval = 1000;
robot.settings.disableTelemetry = true;

Ligado

O método on é usado para anexar os gerenciadores de eventos ao SDK.

Os eventos de SDK disponíveis são consent-prompt e missing-components.

consent-prompt

O SDK de JavaScript da UiPath vem com uma sobreposição de consentimento integrada, sempre que seu aplicativo personalizado ou página da web precisar se conectar ao Robô.

Essa sobreposição de consentimento pode ser substituída por um gerenciador personalizado.

const robot = UiPathRobot.init();
robot.on('consent-prompt', consentCode => console.log(consentCode));

missing-components

O evento missing-components é gerado quando o Serviço Robot JS não está em execução. Nesse caso o SDK exibe um erro, que pode ser substituído por um gerenciador personalizado.

const robot = UiPathRobot.init();
robot.on('missing-components', () => console.log('Missing Components'));

Get Processes

O método getProcesses recupera a lista de processos disponíveis. Retorna uma Promise para um Array de objetos RobotProcess. Se o Robô estiver conectado ao Orchestrator, ele irá recuperar os processos do ambiente e da pasta a qual o Robô faz parte. Caso contrário, os processos locais são recuperados.

const robot = UiPathRobot.init();
const processes = await robot.getProcesses();
for(let i=0; i<processes.length; i++){
    console.log(processes[i].name + " (" + processes[i].description + ") - Id=" + processes[i].id);
}

Obter esquema de argumentos de entrada

Usando a propriedade "inputArgumentsSchema" de um processo instalado, você pode recuperar os argumentos de entrada de um processo. Antes de usar a propriedade inputArgumentsSchema, primeiro você precisa instalar o processo.

O método installProcess instala um processo e retorna uma Promise para um objeto do tipo InstallProcessResult, que contém um array de objetos InputArgumentSchema.

const robot = UiPathRobot.init();
const processes = await robot.getProcesses();
const installedProcess = await robot.installProcess(processes[0].id);
for(let i=0; i<installedProcess.inputArgumentsSchema.length; i++){
    console.log("Argument " + i + ":");
    console.log("  name: " + installedProcess.inputArgumentsSchema[i].name)
    console.log("  type: " + installedProcess.inputArgumentsSchema[i].type)
    console.log("  isRequired: " + installedProcess.inputArgumentsSchema[i].isRequired)
    console.log("  hasDefault: " + installedProcess.inputArgumentsSchema[i].hasDefault)
}

Observação: no TypeScript, o método install de um objeto RobotProcess pode ser usado para instalar um processo.

const robot = UiPathRobot.init();
const processes = await robot.getProcesses();
const myProcess = processes.find(p => p.name === "MyProcess");
const installedProcess = await myProcess.install();

Iniciar Trabalho

O método startJob recebe um Job já criado e o inicia. Ele retorna uma Promise para um objeto do tipo JobResult, que contém os argumentos de saída.

O método createJob cria um trabalho de Robot usando o ID do processo. Opcionalmente, ele pode receber os argumentos de entrada do trabalho. Ele retorna um objeto do trabalho.

Observação: a partir da v2022.10, a lista de processos é atualizada em paralelo com a execução do processo, antes disso, a lista de processos era atualizada antes do início do processo.Isso significa que, ao executar um processo para o qual há uma atualização disponível, o trabalho pode ser executado com a versão mais antiga do processo.

robot = UiPathRobot.init();
processes = await robot.getProcesses();
const calculatorProcess = processes.find(p => p.name.includes('Calculator'));
const arguments = {
    "input1" : 23,
    "input2" : 42,
    "operation" : "add"
};
const job = robot.createJob(calculatorProcess.id, arguments);
const result = await robot.startJob(job);
console.log(result.Sum);

Observação: no TypeScript, um trabalho pode ser criado usando o construtor de classe Trabalho.

robot = UiPathRobot.init();
processes = await robot.getProcesses();
const calculatorProcess = processes.find(p => p.name.includes('Calculator'));
const arguments = {
    "input1" : 23,
    "input2" : 42,
    "operation" : "add"
};
const job = new Job(calculatorProcess.id, arguments);
const result = await robot.startJob(job);
console.log(result.Sum);

Trabalho em Andamento

O método on do objeto Job é usado para anexar gerenciadores de eventos ao trabalho. Os eventos disponíveis são status e workflow-event.

status

O evento status é gerado durante a execução do trabalho cada vez que o status do trabalho tiver mudado.

O evento também é gerado cada vez que a atividade ReportStatus for executada.

const robot = UiPathRobot.init();
const job = robot.createJob('processId');
job.on('status', robotStatus => console.log(robotStatus));
await robot.startJob(job);

workflow-event

O evento workflow-event é gerado durante a execução do trabalho cada vez que uma atividade que envia um evento de fluxo de trabalho é executada. É o suporte para implementar resultados parciais com a ajuda da atividade send interim results. O gerenciador de eventos tem um argumento do tipo WorkflowEventData.

const robot = UiPathRobot.init();
const job = robot.createJob('processId');
job.on('workflow-event', e => console.log(e.name));
await robot.startJob(job);

Iniciar Processo

O método startdo objeto RobotProcess é usado para iniciar um processo passando seus argumentos de entrada, se estiverem disponíveis.

Ele retorna um objeto do tipo JobPromise.

const robot = UiPathRobot.init();
const processes = await robot.getProcesses();
const myProcess = processes.find(p => p.name === "MyProcess");
const arguments = {
    "a" : 41,
    "b" " 27
};
const result = await myProcess.start(arguments);

Processar com status

O método onStatus é usado para anexar um gerenciador de eventos ao evento "status" do trabalho.

const robot = UiPathRobot.init();
const processes = await robot.getProcesses();
const myProcess = processes.find(p => p.name === "MyProcess");
const result = await myProcess.start().onStatus(status => console.log(status));

Processar com evento de fluxo de trabalho

O método onWorkflowEvent é usado para anexar um gerenciador de eventos ao evento "workflow-event" do trabalho.

const robot = UiPathRobot.init();
const processes = await robot.getProcesses();
const myProcess = processes.find(p => p.name === "MyProcess");
const result = await myProcess.start().onWorkflowEvent(e => console.log(e.name));

Parar Processo

O método stopProcess é usado para interromper um processo do Robot em execução.

Retorna uma Promise, que é resolvida com o cancelamento bem-sucedido do processo do Robot em execução.

const robot = UiPathRobot.init();
const processes = await robot.getProcesses();
const myProcess = processes.find(p => p.name === "MyProcess");
const result = await myProcess.start();
await robot.stopProcess(myProcess);

Definições de Modelo

IRobotSDK

interface IRobotSDK {
    settings: Settings;
    getProcesses(): Promise<Array<RobotProcess>>;
    init(): IRobotSDK;
    on(eventName: string, callback: (argument?: any) => void): void;
    startJob(job: Job): Promise<JobResult>;
    stopProcess(process: RobotProcess): Promise<void>;
    installProcess(processId: string): Promise<InstallProcessResult>;
}

Configurações

class Settings {
    portNumber: number;
    pollTimeInterval: number;
    disableTelemetry: boolean;
}

RobotProcess

class RobotProcess {
    id: string;
    name: string;
    description?: string;
    start: (inArguments?: any) => JobPromise;
    install: () => Promise<InstallProcessResult>;
}

InstallProcessResult

class InstallProcessResult {
    inputArgumentsSchema: InputArgumentSchema[]
}

InputArgumentSchema

class InputArgumentSchema {
    name: string;
    type: string;
    isRequired: boolean;
    hasDefault: boolean;
}

JobPromise

class JobPromise {
    onStatus(eventHanlder: (argument?: any) => void): JobPromise;
    onWorkflowEvent(eventHanlder: (argument?: any) => void): JobPromise;
}

Tarefa

class Job {
    processId: string;
    argument?: any;
    jobId: string;
    on(eventName: string, eventHanlder: (argument?: any) => void): void;
}

JobResult

class JobResult {
    [Key: string]: any;
}

WorkflowEventData

class WorkflowEventData {
    name: string;
    payload: string;
}