Paramètres du SDK

Méthodes et propriétés

Vous pouvez inclure les méthodes et propriétés suivantes dans votre application ou votre page Web personnalisée.

Init

La méthode init est facultative. Elle retourne l'instance IRobotSDK, ce qui vous permet de la stocker en tant que variable pour une utilisation ultérieure.

const robot = UiPathRobot.init();

Paramètres

La propriété settings de type Paramètres vous permet de modifier le numéro de port par défaut et l'intervalle d'interrogation en millisecondes, ou de désactiver l'envoi de données de télémétrie.

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

Sur

La méthode on est utilisée pour attacher des gestionnaires d'événements au SDK.

Les événements SDK disponibles sont consent-prompt, missing-components et open-uipath-protocol.

invite-consentement

Le SDK JavaScript UiPath est livré avec une superposition de consentement intégrée qui s'affiche chaque fois que votre application ou page Web personnalisée doit se connecter au Robot.

Cette superposition de consentement peut être remplacée par un gestionnaire personnalisé.

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

composants-manquants

L'événement missing-components est déclenché lorsque le service Robot JS n'est pas en cours d'exécution. Dans ce cas, le SDK affiche une erreur, qui peut être remplacée avec un gestionnaire personnalisé.

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

open-uipath-protocol

Avant que la demande de consentement ne s'affiche, vous serez peut-être invité à autoriser le navigateur à ouvrir une URL uipath-web dans l'application associée.

Par défaut, RobotJS essaiera automatiquement d'ouvrir cette URL, mais les utilisateurs peuvent remplacer ce comportement en fournissant un gestionnaire d'événement personnalisé.

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

Récupérer les processus (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);
}

Obtenir le schéma des arguments d'entrée (Get Input Arguments Schema)

À l'aide de la propriété inputArgumentsSchema d'un processus installé, vous pouvez récupérer les arguments d'entrée d'un processus. Avant d'utiliser la propriété inputArgumentsSchema, vous devez d'abord installer le processus.

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

Remarque :

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

Démarrer la tâche (Start Job)

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.

Remarque :

À partir de la v2022.10, la liste des processus est actualisée parallèlement à l'exécution du processus. Auparavant, la liste des processus était actualisée avant le démarrage du processus. Cela signifie que lors de l'exécution d'un processus pour lequel une mise à jour est disponible, la tâche pouvait s'exécuter avec l'ancienne version du processus.

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

Remarque :

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

Travail sur

La méthode on de l'objet Job est utilisée pour associer des gestionnaires d'événements à la tâche. Les événements disponibles sont status et workflow-event .

statut

L'événement status est déclenché pendant l'exécution de la tâche chaque fois que le statut de la tâche a changé.

Cet événement est également déclenché chaque fois que l'activité ReportStatus est exécutée.

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

événement-workflow

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

Déclencher le processus (Start Process)

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

Statut du processus activé

La méthode onStatus est utilisée pour attacher un gestionnaire d'événement à l'événement 'status' du Job.

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

Processus sur événement de workflow

La méthode onWorkflowEvent est utilisée pour attacher un gestionnaire d'événement à l'événement 'workflow-event' du Job.

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

Stop Process (Arrêter le processus)

La méthode stopProcess est utilisée pour arrêter un processus robot en cours d'exécution.

Il renvoie une promesse qui est résolue après l’annulation réussie du processus de robot en cours d’exécution.

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

Définitions de modèles

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

Paramètres

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

RobotProcess

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

Résultat du processusinstallation

class InstallProcessResult {
    inputArgumentsSchema: InputArgumentSchema[]
}

SchémaArgumentEntrée

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

Promesse d'emploi

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

Job

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

JobResult

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

DonnéesÉvénement Workflow

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