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

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)

La méthode getProcesses récupère la liste des Processes disponibles.Renvoie une Promesse à un Array d'objets RobotProcess.Si le robot est connecté à Orchestrator, il récupère les Processes de l'environnement et du dossier dont le robot fait partie.Sinon, les Processes 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 retourne une Promesse à un Object de type InstallProcessResult qui contient un Array d'objets 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)
}

Remarque :

Dans TypeScript, la méthode install d'un Object RobotProcess 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. Il retourne une Promesse à un objet de type JobResult qui contient les arguments de sortie.

La méthode createJob crée une tâche de robot à l'aide de l'ID du processus.Elle peut éventuellement recevoir les arguments d'entrée de la tâche.Il retourne 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 à l'aide du 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é 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

L'événement workflow-eventest déclenché pendant l'exécution de la tâche chaque fois qu'une activité qui envoie un événement de workflow est exécutée.Il s'agit du support pour la mise en œuvre de résultats partiels à l'aide de l'activité Envoyer des résultats intermédiaires. Le gestionnaire d'événements contient un argument de 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)

La méthode start de l'objet RobotProcess est utilisée pour démarrer un processus en lui transmettant des arguments d'entrée si disponibles.

Il retourne un Object 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;
}