Especificaciones de SDK

Métodos y propiedades

Puedes incluir los siguientes métodos y propiedades en tu aplicación o página web personalizada.

Init

El método init es opcional.Devuelve la instancia de IRobotSDK, que te permite almacenarla como variable para uso posterior.

const robot = UiPathRobot.init();

Configuración

La settingspropiedad de Configuración tipo te permite cambiar el número de puerto predeterminado, el intervalo de encuesta en milisegundos, o deshabilitar el envío de datos de telemetría.

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

Activado

El onmétodo se usa para adjuntar controladores de eventos en el SDK.

Los eventos SDK disponibles son consent-promptmissing-componentsy

solicitud de consentimiento

El SDK JavaScript de UiPath viene con una superposición de consentimiento integrada que se muestra cada vez que tu aplicación o página web personalizada necesita conectarse al Robot.

Esta superposición de consentimiento se puede anular con un controlador personalizado.

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

componentes faltantes

El missing-componentsevento se establece cuando el servicio UiPath Robot JS no se está ejecutando. En este caso, el SDK muestra un error, que puede sobreescribirse con un controlador personalizado.

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

open-uipath-protocol

Before being shown the consent prompt you might be asked to allow the browser to open a uipath-web URL in the associated application.

By default, RobotJS will automatically try to open this URL, but users can override this behavior by providing a custom event handler.

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

Obtener procesos

El getProcessesmétodo recupera la lista de procesos disponibles. Devuelve una promesa a matriz de Objetos de RobotProcess. Si el Robot está conectado a Orchestrator, recupera los procesos desde el entorno y carpeta de los cuales forma parte el Robot. De lo contrario, los procesos locales se recuperan.

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

Get Input Arguments Schema

Utilizando la propiedad inputArgumentsSchema de un proceso instalado, puedes recuperar los argumentos de entrada de un proceso. Antes de utilizar la propiedad inputArgumentsSchema , primero debes instalar el proceso.

El installProcessmétodo instala un proceso y devuelve una Pormesa a un objeto de tipo InstallProcessResult, que contiene la matriz 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)
}

Nota: en TypeScript, el método install de un objeto de RobotProcess se puede usar para instalar un proceso.

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

Iniciar trabajo

El startJobmétodo recibe un ya creado Joby lo inicia. Devuelve una promesa a un objeto de tipo JobResult, que contiene los argumentos de salida.

El createJobmétodo crea un trabajo de UiPath Robot utilizando el Id de proceso. Opcionalmente puede recibir los argumentos de entrada del trabajo. Devuelve un objeto de trabajo.

Nota: a partir de la versión 2022.10, la lista de procesos se actualiza paralelamente a la ejecución del proceso. Anteriormente, la lista de procesos se actualizaba antes de que se iniciara el proceso. Esto significa que al ejecutar un proceso para el que existe una actualización disponible, el trabajo puede ejecutarse con la versión anterior del proceso.

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

Nota: en TypeScript se puede crear un trabajo usando el constructor de clase Trabajo.

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

Job On

El onmétodo del Jobobjeto se utiliza para adjuntar los controladores del evento al trabajo . Los eventos disponibles son statusy workflow-event.

estado

El statusevento se establece durante la ejecución del trabajo cada vez que el estado del trabajo ha cambiado.

Este evento también se plantea cada vez que la actividad ReportStatus se ejecuta.

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

Evento de flujo de trabajo

El workflow-eventevento se plantea durante la ejecución del trabajo cada vez que una actividad que envía un evento de flujo de trabajo se ejecuta. Es el soporte para la implementación parcial de resultados con la ayuda de enviar resultados provisionales de la actividad. Un controlador de eventos tiene un argumento de 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 proceso

El método del objeto RobotProcess se utiliza para iniciar un proceso mediante mediante la transmisión startal proceso de argumentos de entrada, si están disponibles.

Devuelve un objeto de 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);

Estado en proceso

El onStatusmétodo se utiliza para adjuntar un controlador de eventos al cambio de «estado» del trabajo.

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

Evento de flujo de trabajo en proceso

El onWorkflowEventmétodo se utiliza para adjuntar un controlador de eventos al evento de «flujo de trabajo» del trabajo.

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

Detener el proceso

El stopProcessmétodo se utiliza para detener un proceso de robot en ejecución.

Devuelve una promesa que se resuelve al cancelar con éxito el proceso del robot en ejecución.

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

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

Configuración

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

Trabajo

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