robot
2023.4
false
Guia do usuário do robô
Last updated 25 de out de 2024

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();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;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.

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'));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);
}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)
}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();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);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);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);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);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);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));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));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);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>;
}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;
}class Settings {
    portNumber: number;
    pollTimeInterval: number;
    disableTelemetry: boolean;
}

RobotProcess

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

InstallProcessResult

class InstallProcessResult {
    inputArgumentsSchema: InputArgumentSchema[]
}class InstallProcessResult {
    inputArgumentsSchema: InputArgumentSchema[]
}

InputArgumentSchema

class InputArgumentSchema {
    name: string;
    type: string;
    isRequired: boolean;
    hasDefault: boolean;
}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;
}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;
}class Job {
    processId: string;
    argument?: any;
    jobId: string;
    on(eventName: string, eventHanlder: (argument?: any) => void): void;
}

JobResult

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

WorkflowEventData

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

Esta página foi útil?

Obtenha a ajuda que você precisa
Aprendendo RPA - Cursos de automação
Fórum da comunidade da Uipath
Uipath Logo White
Confiança e segurança
© 2005-2024 UiPath. Todos os direitos reservados.