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 renvoie l'instance d'IRobotSDK, 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 et missing-components .

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

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

Récupérer les processus (Get Processes)

La méthode getProcesses récupère la liste des processus disponibles. Renvoie une promesse à un tableau d'objets ProcessusRobot . Si le Robot est connecté à Orchestrator, il récupère les processus de l'environnement et du dossier dont le Robot fait partie. Sinon, les processus locaux sont récupérés.

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.

La méthode installProcess installe un processus et renvoie une Promesse à un objet de type RésultatProcessusInstallation, qui contient un tableau d'objets SchémaArgumentEntrée.

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 : dans TypeScript, la méthode install d'un objet ProcessusRobot peut être utilisée pour installer un processus.

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)

La méthode startJob reçoit un Job déjà créé et le démarre. Elle renvoie une promesse à un objet de type RésultatTâche, qui contient les arguments de sortie.

La méthode createJob crée une tâche Robot en utilisant l'ID du processus. Il peut éventuellement recevoir les arguments d'entrée de la tâche. Elle renvoie un objet Tâche .

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 : dans TypeScript, une tâche peut être créée via le constructeur de classe Tâche.

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é État du rapport 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

L'événement workflow-event est déclenché lors de l'exécution de la tâche chaque fois qu'une activité qui envoie un événement de workflow est exécutée. C’est le support permettant de mettre en œuvre les résultats partiels à l’aide de l’activité Envoyer des résultats intermédiaires . Le gestionnaire d'événements a un argument de type DonnéesÉvénementWorkflow.

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)

La méthode start de l'objet ProcessusRobot est utilisée pour démarrer un processus en lui transmettant des arguments d’entrée, s'ils sont disponibles.

Elle renvoie un objet de 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;
}