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, missing-components e open-uipath-protocol.

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'));

open-uipath-protocol

Antes de exibir a solicitação de consentimento, você pode ser solicitado a permitir que o navegador abra um URL uipath-web no aplicativo associado.

Por padrão, o RobotJS tentará abrir esse URL automaticamente, mas os usuários podem substituir esse comportamento fornecendo um manipulador de eventos personalizado.

const robot = UiPathRobot.init();
robot.on('open-uipath-protocol', (protocolUrl) => console.log('RobotJS protocol URL: ' + protocolUrl));

Get Processes

The getProcesses method retrieves the list of available processes. Returns a Promise to an array of RobotProcess objects. If the Robot is connected to Orchestrator, it retrieves the processes from the environment and folder the Robot is a part of. Otherwise, local processes are retrieved.

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.

The installProcess method installs a process and returns a Promise to an object of type InstallProcessResult, which contains an array of InputArgumentSchema objects.

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:

In TypeScript, the method install of a RobotProcess object can be used to install a process.

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

Iniciar Trabalho

The startJob method receives an already created Job and starts it. It returns a Promise to an object of type JobResult, which contains the output arguments.

The createJob method creates a robot Job using the Process Id. It can optionally receive the job input arguments. It returns a Job object.

Observação:

A partir da v2022.10, a lista de processos é atualizada em paralelo com a execução dos processos. 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:

In TypeScript, a Job can be created by using the Job class constructor.

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

The workflow-event event is raised during the job execution each time an activity that sends a workflow event is executed. It is the support for implementing partial results with the help of send interim results activity. The event handler has an argument of type 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

The method start of the object RobotProcess is used to start a process by passing it input arguments, if available.

It returns an object of type 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;
}