@kogeet/scapin-core-agent 0.1.0

package/bin/core/app.sagent.d.ts

@@ -0,0 +1,6 @@
+export default class AppSagent {
+    private EntryPoints;
+    listen(): void;
+    use(libName: string, entryPoints: Map<string, CallableFunction>): void;
+    getStepFunction(lib: string, fn: string): CallableFunction | null;
+}

package/bin/core/app.sagent.js

@@ -0,0 +1,30 @@
+import wSocketIo from "./wsocket.io.js";
+import { report } from "../index.js";
+export default class AppSagent {
+    EntryPoints = new Map();
+    listen() {
+        wSocketIo.start();
+    }
+    use(libName, entryPoints) {
+        this.EntryPoints.set(libName, entryPoints);
+    }
+    getStepFunction(lib, fn) {
+        const library = this.EntryPoints.get(lib);
+        if (library) {
+            const stepFct = library.get(fn);
+            if (stepFct) {
+                return stepFct;
+            }
+            else {
+                // erreur : la fonction n'existe pas. Vérifier l'orthographe du nom
+                report.error(`The function '${fn}' does not exist. Check the spelling of the name`);
+                return null;
+            }
+        }
+        else {
+            // erreur : librairie n'existe pas. Vérifier l'orthographe du nom
+            report.error(`The library '${lib}' does not exist. Check the spelling of the name`);
+            return null;
+        }
+    }
+}

package/bin/core/context.d.ts

@@ -0,0 +1,15 @@
+import { RunParamModel } from '../models/run.model.js';
+import { varType } from '../models/parameter.model.js';
+/**
+ * La classe **Context** stocke les variables utilisées lors du test
+ */
+export default class Context {
+    idxStep: number;
+    private variables;
+    getVariable(varname: string): varType;
+    setVariable(varname: string, value: varType): void;
+    loadVariable(params: RunParamModel[]): void;
+    valorize(param: RunParamModel): void;
+    dump(): [string, varType][];
+    resetVariables(): void;
+}

package/bin/core/context.js

@@ -0,0 +1,53 @@
+import { enumParamType } from '../models/parameter.model.js';
+/**
+ * La classe **Context** stocke les variables utilisées lors du test
+ */
+export default class Context {
+    idxStep = -1;
+    variables = new Map();
+    getVariable(varname) {
+        return this.variables.get(varname);
+    }
+    setVariable(varname, value) {
+        if (varname && varname.length) {
+            this.variables.set(varname, value);
+        }
+    }
+    loadVariable(params) {
+        const regex = /\$\w+/g;
+        params.forEach((p) => {
+            if (p && p.value && typeof p.value === 'string') {
+                const found = p.value.match(regex);
+                if (found) {
+                    found.forEach((name) => {
+                        if (!this.variables.has(name)) {
+                            this.variables.set(name, undefined);
+                        }
+                    });
+                }
+            }
+        });
+    }
+    valorize(param) {
+        // console.log('Valorize input :', param)
+        const quot = param.type === enumParamType.textdata || param.type === enumParamType.options ? '"' : '';
+        if (param.type !== enumParamType.receipt && param.value && typeof param.value === 'string') {
+            const found = param.value.match(/\$\w+/g);
+            if (found) {
+                found.forEach((vname) => {
+                    if (this.variables.has(vname)) {
+                        const vvalue = this.variables.get(vname);
+                        param.value = param.value.replace(vname, quot + vvalue + quot);
+                    }
+                });
+            }
+        }
+        // console.log('Valorize output :', param)
+    }
+    dump() {
+        return [...this.variables.entries()];
+    }
+    resetVariables() {
+        this.variables.clear();
+    }
+}

package/bin/core/jison.parser.d.ts

@@ -0,0 +1,15 @@
+import { enumParamType } from '../models/parameter.model.js';
+export declare class JisonParser {
+    error: string | null;
+    result: never | null;
+    private jparser;
+    constructor(grammar: unknown);
+    exec(exp: string): boolean | string;
+    static builder(type: enumParamType, options: string[]): JisonParser | null;
+}
+export declare class JisonSolver {
+    private jparser;
+    constructor(grammar: unknown);
+    exec(exp: string): string | null;
+    static builder(type: enumParamType, options: string[]): JisonSolver | null;
+}

package/bin/core/jison.parser.js

@@ -0,0 +1,82 @@
+import { enumParamType } from '../models/parameter.model.js';
+import { variableGrammar } from '../jison/variable.grammar.js';
+import { logicalGrammar } from '../jison/logical.grammar.js';
+import { stringGrammar } from '../jison/string.grammar.js';
+import { calcGrammar } from '../jison/calc.grammar.js';
+import { datetimeGrammar } from '../jison/datetime.grammar.js';
+import { optionGrammar } from '../jison/option.grammar.js';
+import pkg from "jison";
+const { Parser } = pkg;
+export class JisonParser {
+    error = null;
+    result = null;
+    jparser;
+    constructor(grammar) {
+        this.jparser = new Parser(grammar);
+    }
+    exec(exp) {
+        try {
+            this.jparser.parse(exp);
+            return true;
+        }
+        catch (e) {
+            const m = e.message.split('\n');
+            if (m.length >= 2 && m[2].match(/^-*\^$/)) {
+                const pos = m[2].length;
+                return pos > exp.length
+                    ? 'Expression incomplete'
+                    : `Syntax error near character '${exp.charAt(pos - 1)}' at position ${pos}`;
+            }
+            else {
+                return e.message;
+            }
+        }
+    }
+    static builder(type, options) {
+        const grammar = typeGrammar(type, false, options);
+        try {
+            return new JisonParser(grammar);
+        }
+        catch (e) {
+            return null;
+        }
+    }
+}
+export class JisonSolver {
+    jparser;
+    constructor(grammar) {
+        this.jparser = new Parser(grammar);
+    }
+    exec(exp) {
+        try {
+            const ret = this.jparser.parse(exp);
+            console.log(`Solve expression '${exp}' :`, ret);
+            return ret ? ret : null;
+        }
+        catch (e) {
+            const msg = e.message;
+            console.log(`Solve erreur expression '${exp}' :`, msg);
+            const errs = msg.split('\n');
+            throw errs.length > 1 ? errs[1] : errs[0];
+        }
+    }
+    static builder(type, options) {
+        const grammar = typeGrammar(type, true, options);
+        try {
+            return new JisonSolver(grammar);
+        }
+        catch (e) {
+            return null;
+        }
+    }
+}
+function typeGrammar(type, solve = false, options = []) {
+    switch (type) {
+        case enumParamType.receipt: return variableGrammar;
+        case enumParamType.booldata: return logicalGrammar(solve);
+        case enumParamType.textdata: return stringGrammar(solve);
+        case enumParamType.numbdata: return calcGrammar(solve);
+        case enumParamType.datetime: return datetimeGrammar(solve);
+        case enumParamType.options: return optionGrammar(solve, options);
+    }
+}

package/bin/core/report.d.ts

@@ -0,0 +1,20 @@
+import StepContext from './step.context.js';
+export default class Report {
+    private oneStepLog;
+    private start;
+    private stepPos;
+    private oneStepReport;
+    private flagStopOnError;
+    stepStart(pos: number): void;
+    stepEnd(pass: boolean): void;
+    info(message: string): void;
+    warning(message: string): void;
+    error(message: string): void;
+    getJsonStepReport(stepCtx: StepContext | null): string;
+    getStepStatus(): number;
+    CountOneStepLog(): number;
+    setStopOnError(state: boolean): void;
+    getStopOnError(): boolean;
+    clearStepLog(): void;
+    private log;
+}

package/bin/core/report.js

@@ -0,0 +1,83 @@
+import { logLevel, stepStatus } from '../models/run.model.js';
+import { context } from "../index.js";
+export default class Report {
+    oneStepLog = [];
+    start = 0;
+    stepPos = -1;
+    oneStepReport = null;
+    flagStopOnError = false;
+    stepStart(pos) {
+        this.oneStepLog = [];
+        this.start = Date.now();
+        this.stepPos = pos;
+        console.log(`----------------- step #${pos} ------------------------`);
+    }
+    stepEnd(pass) {
+        let hasCancelMessage = false;
+        this.oneStepLog.forEach(l => {
+            if (l.level !== logLevel.info) {
+                hasCancelMessage = true;
+            }
+        });
+        const status = hasCancelMessage ? stepStatus.cancel : (pass ? stepStatus.pass : stepStatus.fail);
+        this.oneStepReport = {
+            pos: this.stepPos,
+            runtime: Date.now() - this.start,
+            status,
+            messages: this.oneStepLog
+        };
+        const r = this.oneStepReport;
+        console.log(`status='${stepStatus.toString(r.status)}' runtime=${r.runtime}, ${r.messages && r.messages.length ? r.messages.length + ' messages' : 'no message'}`);
+        if (r.messages) {
+            for (const msg of r.messages) {
+                console.log(` => ${logLevel.toString(msg.level)} : ${msg.message}`);
+            }
+        }
+        console.log('-------------------------------------------------');
+    }
+    info(message) {
+        this.log(logLevel.info, message);
+    }
+    warning(message) {
+        this.log(logLevel.warning, message);
+    }
+    error(message) {
+        this.log(logLevel.error, message);
+    }
+    getJsonStepReport(stepCtx) {
+        try {
+            return JSON.stringify({
+                ctx: context.dump(),
+                logs: this.oneStepReport,
+                params: stepCtx ? stepCtx.getAllParams() : [],
+                flagStop: this.flagStopOnError
+            });
+        }
+        catch (e) {
+            return '{}';
+        }
+    }
+    getStepStatus() {
+        return this.oneStepReport && this.oneStepReport.status ? this.oneStepReport.status : 0;
+    }
+    CountOneStepLog() {
+        return this.oneStepLog.length;
+    }
+    setStopOnError(state) {
+        this.flagStopOnError = state;
+    }
+    getStopOnError() {
+        return this.flagStopOnError;
+    }
+    clearStepLog() {
+        this.oneStepLog = [];
+    }
+    log(level, message) {
+        const log = {
+            pos: this.stepPos,
+            level,
+            message
+        };
+        this.oneStepLog.push(log);
+    }
+}

package/bin/core/runstep.d.ts

@@ -0,0 +1,10 @@
+import StepContext from './step.context.js';
+export default class RunStep {
+    /**
+     * Execute a step
+     * @param stepCtx
+     * @param lib
+     * @param fn
+     */
+    run(stepCtx: StepContext, lib: string, fn: string): Promise<boolean>;
+}

package/bin/core/runstep.js

@@ -0,0 +1,23 @@
+import { report, sagent } from "../index.js";
+export default class RunStep {
+    /**
+     * Execute a step
+     * @param stepCtx
+     * @param lib
+     * @param fn
+     */
+    async run(stepCtx, lib, fn) {
+        let retour = false;
+        const fct = sagent.getStepFunction(lib, fn);
+        if (fct) {
+            try {
+                retour = await fct(stepCtx);
+            }
+            catch (e) {
+                // erreur d'exécution de la fonction => codage
+                report.error(`Function execution error : ${e.message}`);
+            }
+        }
+        return retour;
+    }
+}

package/bin/core/runsteps.d.ts

@@ -0,0 +1,8 @@
+import { RunDataStepModel } from '../models/run.model.js';
+export declare class RunSteps {
+    private runstep;
+    private stepCtx;
+    stop: boolean;
+    run(data: RunDataStepModel[] | RunDataStepModel | undefined): Promise<void>;
+    private runAStep;
+}

package/bin/core/runsteps.js

@@ -0,0 +1,47 @@
+import RunStep from './runstep.js';
+import StepContext from './step.context.js';
+import wSocketIo from './wsocket.io.js';
+import { context, report } from "../index.js";
+export class RunSteps {
+    runstep;
+    stepCtx = null;
+    stop = false;
+    async run(data) {
+        this.runstep = new RunStep();
+        if (data) {
+            const rundata = !Array.isArray(data) ? [data] : data;
+            context.resetVariables();
+            for (const step of rundata) {
+                await this.runAStep(step);
+                // suppression de la prise en compte du stop si erreur parce qu'il fait bugger l'automatisation des campagnes
+                // if (stopIfError) {
+                //   break
+                // }
+                if (this.stop) {
+                    break;
+                }
+            }
+            wSocketIo.end();
+        }
+        else {
+            report.error('No steps data found');
+            wSocketIo.end();
+        }
+    }
+    async runAStep(step) {
+        let stepResult;
+        report.stepStart(step.pos);
+        try {
+            this.stepCtx = new StepContext(step);
+            stepResult = await this.runstep.run(this.stepCtx, step.lib, step.fn);
+        }
+        catch (e) {
+            report.warning('Unexpected error : ' + e.message);
+            stepResult = false;
+        }
+        report.stepEnd(stepResult);
+        // wsServer.send(report.getJsonStepReport(this.ctx, this.stepCtx))
+        wSocketIo.report(report.getJsonStepReport(this.stepCtx), report.getStepStatus());
+        return report.getStopOnError();
+    }
+}

package/bin/core/step.context.d.ts

@@ -0,0 +1,23 @@
+import { RunDataStepModel, RunParamModel } from '../models/run.model.js';
+import { varType } from '../models/parameter.model.js';
+/**
+ * La classe **StepContext** gère les paramètres.
+ *
+ * Il y a 2 types de paramètres.
+ * - les paramètres des étapes de test. Ils sont représentés par la propriété params.
+ * - les paramètres de configuration des accessoires et les clés de mapping. Ils sont représentés par la propriété config
+ */
+export default class StepContext {
+    istoy: boolean;
+    private readonly params;
+    private readonly config;
+    readonly toolid: string | null;
+    constructor(step: RunDataStepModel);
+    getAllParams(): RunParamModel[];
+    getAllConfigs(): RunParamModel[];
+    getParam(key: string, defaut?: varType): varType;
+    getStringParam(key: string, defaut?: string | undefined): string;
+    getConfig(key: string, defaut?: varType): varType;
+    private get;
+    private solveParams;
+}

package/bin/core/step.context.js

@@ -0,0 +1,78 @@
+import { enumParamType } from '../models/parameter.model.js';
+import { JisonSolver } from './jison.parser.js';
+import { context, report } from "../index.js";
+/**
+ * La classe **StepContext** gère les paramètres.
+ *
+ * Il y a 2 types de paramètres.
+ * - les paramètres des étapes de test. Ils sont représentés par la propriété params.
+ * - les paramètres de configuration des accessoires et les clés de mapping. Ils sont représentés par la propriété config
+ */
+export default class StepContext {
+    istoy;
+    params;
+    config;
+    toolid;
+    constructor(step) {
+        this.params = step.parameters;
+        this.config = step.config;
+        this.istoy = step.istoy;
+        this.toolid = step.toolid ? step.toolid : null;
+        // Chargement si nécessaire des variables présentes dans les paramètres
+        context.loadVariable(this.params);
+        // Résolution des expressions
+        this.solveParams();
+    }
+    getAllParams() {
+        return this.params;
+    }
+    getAllConfigs() {
+        return this.config;
+    }
+    getParam(key, defaut = undefined) {
+        return this.get(this.params, key, defaut);
+    }
+    getStringParam(key, defaut = undefined) {
+        return this.getParam(key, defaut);
+    }
+    getConfig(key, defaut = undefined) {
+        return this.get(this.config, key, defaut);
+    }
+    get(P, key, defaut) {
+        const par = P.find((p) => p.key === key);
+        return par && typeof par.value !== 'undefined' ? par.value : defaut;
+    }
+    solveParams() {
+        this.params.map((param) => {
+            context.valorize(param);
+            if (param.value && param.type && param.options) {
+                const solver = JisonSolver.builder(param.type, param.options);
+                if (solver) {
+                    const strSolveVal = solver.exec(param.value);
+                    if (strSolveVal) {
+                        switch (param.type) {
+                            case enumParamType.booldata:
+                                param.value = strSolveVal.toLowerCase() === 'true';
+                                break;
+                            case enumParamType.numbdata:
+                                param.value = parseFloat(strSolveVal);
+                                break;
+                            case enumParamType.datetime:
+                                param.value = Date.parse(strSolveVal);
+                                break;
+                            default:
+                                param.value = strSolveVal;
+                        }
+                    }
+                    else {
+                        param.value = null;
+                    }
+                }
+                else {
+                    report.error(`Impossible to solve expression : ${param.value}`);
+                }
+            }
+            return param;
+        });
+    }
+}

package/bin/core/wsocket.io.d.ts

@@ -0,0 +1,20 @@
+import { Socket } from "socket.io-client";
+declare class WsocketIo {
+    ioClient: Socket | null;
+    private runsteps;
+    private connected;
+    private termId;
+    start(): void;
+    report(message: string, stepStatus: number): void;
+    /**
+     * Fin d'exécution d'un run
+     */
+    end(): void;
+    private onError;
+    private onRundata;
+    private onStatus;
+    private onPing;
+    private onStopRun;
+}
+declare const wSocketIo: WsocketIo;
+export default wSocketIo;

package/bin/core/wsocket.io.js

@@ -0,0 +1,112 @@
+import { io } from "socket.io-client";
+import { RunSteps } from './runsteps.js';
+import { report } from "../index.js";
+const url = process.env.ScapinServerURL || 'https://scapin.loicg.com';
+const scapinAgentId = process.env.ScapinAgentId;
+class WsocketIo {
+    ioClient = null;
+    runsteps = null;
+    connected = true;
+    termId = '';
+    start() {
+        console.log(`Start websocket url = ${url}, activation key = ${scapinAgentId}`);
+        const t = scapinAgentId ? scapinAgentId.split('/') : '__';
+        if (t.length !== 2) {
+            console.log('/!\\  ScapinAgentId environment variable does not exist or is incorrectly formatted ');
+            console.log('  The good format is :');
+            console.log('     <account>/<terminalKey>');
+            console.log('  with :');
+            console.log('   - <account> Your account identifier ');
+            console.log('   - <terminalKey> The identification key of your terminal ');
+            this.ioClient = null;
+            return;
+        }
+        this.termId = t[1];
+        this.ioClient = io(`${url}`, {
+            autoConnect: true,
+            transports: ['websocket'],
+            path: `/jobrunner/${t[0]}/`,
+            query: { from: 'terminal', termId: this.termId }
+        });
+        if (this.ioClient.disconnected) {
+            // console.log('Terminal closed => connect it')
+            this.ioClient.connect();
+        }
+        this.ioClient.on('connected', (() => {
+            this.connected = true;
+            console.log(`Terminal ${scapinAgentId} is now connected to automation server!`);
+        }));
+        this.ioClient.on('connect_error', this.onError);
+        this.ioClient.on('data', this.onRundata);
+        this.ioClient.on('rundata', this.onRundata);
+        this.ioClient.on('status', this.onStatus);
+        this.ioClient.on('status-ping', this.onPing);
+        this.ioClient.on('stoprun', this.onStopRun);
+        // this.ioClient.on('reconnect_attempt', (n: number) => { console.log(`${n} tentative de reconnexion`)})
+        this.ioClient.on('reconnect', (n) => {
+            console.log(`${n} reconnexion réussies`);
+        });
+        // this.ioClient.on('reconnect_error', (err: Error) => { console.log(`reconnexion error :`, err)})
+        this.ioClient.on('offline', () => {
+            console.log('Db server offline');
+        });
+    }
+    report(message, stepStatus) {
+        if (this.ioClient) {
+            // console.log('emit report & step-status')
+            this.ioClient.emit('report', message);
+            this.ioClient.emit('step-status', stepStatus);
+        }
+    }
+    /**
+     * Fin d'exécution d'un run
+     */
+    end() {
+        if (this.ioClient) {
+            this.ioClient.emit('end');
+        }
+        this.runsteps = null;
+        report.clearStepLog();
+    }
+    onError = (err) => {
+        const msg = err.description ? err.description.message : '';
+        if (this.connected) {
+            if (msg.indexOf('ECONNREFUSED') > 0) {
+                this.connected = false;
+                console.log(`Automation server is currently offline`);
+            }
+            else {
+                console.log('Connection error :', err.message);
+            }
+        }
+    };
+    onRundata = async (stepsdata) => {
+        this.runsteps = new RunSteps();
+        try {
+            await this.runsteps.run(stepsdata);
+        }
+        catch (e) {
+            console.log('Unexpected error : ' + e.message);
+            wSocketIo.end();
+        }
+    };
+    onStatus = () => {
+        if (this.ioClient) {
+            this.ioClient.emit('status', this.runsteps ? 'busy' : 'available');
+        }
+    };
+    onPing = (ack) => {
+        console.log(`onPing termId:${this.termId}`);
+        ack(this.termId);
+    };
+    onStopRun = () => {
+        console.log('onStopRun');
+        if (this.runsteps) {
+            this.runsteps.stop = true;
+        }
+        this.runsteps = null;
+        report.clearStepLog();
+    };
+}
+const wSocketIo = new WsocketIo();
+export default wSocketIo;

package/bin/index.d.ts

@@ -0,0 +1,6 @@
+import AppSagent from "./core/app.sagent.js";
+import Context from "./core/context.js";
+import Report from "./core/report.js";
+export declare const sagent: AppSagent;
+export declare const context: Context;
+export declare const report: Report;

package/bin/index.js

@@ -0,0 +1,7 @@
+import AppSagent from "./core/app.sagent.js";
+import Context from "./core/context.js";
+import Report from "./core/report.js";
+export const sagent = new AppSagent();
+export const context = new Context();
+export const report = new Report;
+// sagent.listen()

package/bin/jison/calc.grammar.d.ts

@@ -0,0 +1,19 @@
+export declare function calcGrammar(solve?: boolean): {
+    lex: {
+        rules: string[][];
+    };
+    operators: string[][];
+    bnf: {
+        expressions: string[][];
+        e: (string | {
+            prec: string;
+        })[][];
+    };
+};
+export declare const xxxGrammar: {
+    lex: {
+        rules: string[][];
+    };
+    operators: never[];
+    bnf: {};
+};

package/bin/jison/calc.grammar.js

@@ -0,0 +1,66 @@
+/* tslint:disable:quotemark trailing-comma */
+export function calcGrammar(solve = false) {
+    const varValue = solve ? 'return null' : '$$ = 0';
+    return {
+        lex: {
+            rules: [
+                // Saute les espaces
+                ['\\s+', '/* skip whitespace */'],
+                ['[0-9]+(?:\\.[0-9]+)?\\b', 'return `NUMBER`'],
+                ['\\$\\w+', 'return `VARIABLE`'],
+                ['\\*', 'return `*`'],
+                ['\\/', 'return `/`'],
+                ['-', 'return `-`'],
+                ['\\+', 'return `+`'],
+                ['\\^', 'return `^`'],
+                ['!', 'return `!`'],
+                ['%', 'return `%`'],
+                ['\\(', 'return `(`'],
+                ['\\)', 'return `)`'],
+                ['PI\\b', 'return `PI`'],
+                ['E\\b', 'return `E`'],
+                ['$', 'return `EOF`'],
+                ['=', 'return `BEGEXP`']
+            ]
+        },
+        operators: [
+            ['left', '+', '-'],
+            ['left', '*', '/'],
+            ['left', '^'],
+            ['right', '!'],
+            ['right', '%'],
+            ['left', 'UMINUS']
+        ],
+        bnf: {
+            expressions: [['BEGEXP e EOF', 'return $2'], ['NUMBER EOF', 'return $1']],
+            e: [
+                ['e + e', '$$ = $1+$3'],
+                ['e - e', '$$ = $1-$3'],
+                ['e * e', '$$ = $1*$3'],
+                ['e / e', '$$ = $1/$3'],
+                ['e ^ e', '$$ = Math.pow($1, $3)'],
+                ['e !', '$$ = (function(n) {if(n==0) return 1; return arguments.callee(n-1) * n})($1)'],
+                ['e - e %', '$$ = $e1-($e1*($e2/100))'],
+                ['e + e %', '$$ = $e1+($e1*($e2/100))'],
+                ['e * e %', '$$ = $e1*($e2/100)'],
+                ['( e % )', '$$ = $2/100'],
+                ['- e', '$$ = -$2', { prec: 'UMINUS' }],
+                ['( e )', '$$ = $2'],
+                ['NUMBER', '$$ = Number(yytext)'],
+                ['VARIABLE', varValue],
+                ['E', '$$ = Math.E'],
+                ['PI', '$$ = Math.PI']
+            ]
+        }
+    };
+}
+export const xxxGrammar = {
+    lex: {
+        rules: [
+            // Saute les espaces
+            ['\\s+', '/* skip whitespace */'],
+        ]
+    },
+    operators: [],
+    bnf: {}
+};

package/bin/jison/datetime.grammar.d.ts

@@ -0,0 +1,10 @@
+export declare function datetimeGrammar(solve: boolean): {
+    lex: {
+        rules: string[][];
+    };
+    operators: never[];
+    bnf: {
+        expressions: string[][];
+        e: string[][];
+    };
+};

package/bin/jison/datetime.grammar.js

@@ -0,0 +1,42 @@
+export function datetimeGrammar(solve) {
+    const varValue = solve ? 'return null' : '$$ = ``';
+    return {
+        lex: {
+            rules: [
+                ['\\s+', '/* skip whitespace */'],
+                ['\\$\\w+', 'return `VARIABLE`'],
+                ['=', 'return `BEGEXP`'],
+                ['"', 'return `QUOT`'],
+                ['\/', 'return `/`'],
+                ['(0?[1-9]|1[012])', 'return `MM`'],
+                ['(0?[1-9]|[12][0-9]|3[01])', 'return `DD`'],
+                ['\\d\{4\}', 'return `YYYY`'],
+                ['NOW|now', 'return `NOW`'],
+                // ['0?[0-9]|[1][0-9]|2[01234]', 'return `HH`'],
+                // ['0?[0-9]|[12345][0-9]', 'return `0-59`'],
+                // ['\-', 'return `-`'],
+                // ['[12]\\d\\d\\d\\-(0?[1-9]|1[012])\\-(0?[1-9]|[12][0-9]|3[01])', 'return USDATE'],
+                // ['[1-9]+[Dd]', 'return `ADD`'],
+                // ['\+', 'return `+`'],
+                ['$', 'return `EOF`']
+            ]
+        },
+        operators: [],
+        bnf: {
+            expressions: [['BEGEXP e EOF', 'return $2']],
+            e: [
+                ['DD / e', '$$ = $1'],
+                ['e / YYYY', '$$ = $3'],
+                ['/ MM /', '$$ = $2'],
+                // ['YYYY - MM - DD', '$$ = new Date($e1, $e2, $e3)'],
+                // ['DD / MM / YYYY', '$$ = new Date($e3, $e2, $e1)'],
+                // ['HH : 0-59 : 0-59', '$$ = new Date(0, 0, 0, $e1, $e2, $e3)'],
+                // ['QUOT MM QUOT', '$$ = 0'],
+                ['NOW', '$$ = Date.now()'],
+                // ['e + ADD', '$$ = ``'],
+                // ['e + ADD', '$$ = {const ret = new Date($e1); return ret.setDate(ret.getDate() + parseInt($e2))}'],
+                ['VARIABLE', varValue]
+            ]
+        }
+    };
+}

package/bin/jison/logical.grammar.d.ts

@@ -0,0 +1,10 @@
+export declare function logicalGrammar(solve: boolean): {
+    lex: {
+        rules: string[][];
+    };
+    operators: string[][];
+    bnf: {
+        expressions: string[][];
+        e: string[][];
+    };
+};

package/bin/jison/logical.grammar.js

@@ -0,0 +1,39 @@
+export function logicalGrammar(solve) {
+    const varValue = solve ? 'return null' : '$$ = 0';
+    return {
+        lex: {
+            // startConditions: {
+            //   expression: 'return e',
+            //   value: 'return v'
+            // },
+            rules: [
+                ['\\s+', '/* skip whitespace */'],
+                ['[0-9]+(?:\\.[0-9]+)?\\b', 'return `NUMBER`'],
+                ['\\$\\w+', 'return `VARIABLE`'],
+                ['TRUE|true|FALSE|false', 'return `BOOLEAN`'],
+                ['<=', 'return `INFEQ`'],
+                ['>=', 'return `SUPEQ`'],
+                ['<', 'return `INF`'],
+                ['>', 'return `SUP`'],
+                ['$', 'return `EOF`'],
+                ['=', 'return `BEGEXP`']
+            ]
+        },
+        operators: [
+            ['left', 'INF', 'SUP', 'INFEQ', 'SUPEQ'],
+            ['right', 'BEGEXP']
+        ],
+        bnf: {
+            expressions: [['BEGEXP e EOF', 'return $2'], ['BOOLEAN EOF', 'return $1']],
+            e: [
+                ['NUMBER', '$$ = Number(yytext)'],
+                ['VARIABLE', varValue],
+                ['BOOLEAN', '$$ = yytext === `TRUE` || yytext === `true`'],
+                ['e INF e', '$$ = $1<$3'],
+                ['e SUP e', '$$ = $1 > $3'],
+                ['e SUPEQ e', '$$ = $1 >= $3'],
+                ['e INFEQ e', '$$ = $1 <= $3'],
+            ]
+        }
+    };
+}

package/bin/jison/option.grammar.d.ts

@@ -0,0 +1,10 @@
+export declare function optionGrammar(solve: boolean, options: string[]): {
+    lex: {
+        rules: string[][];
+    };
+    operators: never[];
+    bnf: {
+        expressions: string[][];
+        e: string[][];
+    };
+};

package/bin/jison/option.grammar.js

@@ -0,0 +1,24 @@
+export function optionGrammar(solve, options) {
+    const varValue = solve ? 'return null' : '$$ = ``';
+    const optValue = options.join('|');
+    return {
+        lex: {
+            rules: [
+                ['\\s+', '/* skip whitespace */'],
+                ['\\$\\w+', 'return `VARIABLE`'],
+                ['"', 'return `QUOT`'],
+                [optValue, 'return `OPTION`'],
+                ['$', 'return `EOF`'],
+                ['=', 'return `BEGEXP`']
+            ]
+        },
+        operators: [],
+        bnf: {
+            expressions: [['BEGEXP e EOF', 'return $2'], ['OPTION EOF', 'return $1']],
+            e: [
+                ['QUOT OPTION QUOT', '$$ = $2'],
+                ['VARIABLE', varValue]
+            ]
+        }
+    };
+}

package/bin/jison/string.grammar.d.ts

@@ -0,0 +1,10 @@
+export declare function stringGrammar(solve: boolean): {
+    lex: {
+        rules: string[][];
+    };
+    operators: string[][];
+    bnf: {
+        expressions: string[][];
+        e: string[][];
+    };
+};

package/bin/jison/string.grammar.js

@@ -0,0 +1,31 @@
+/* tslint:disable:trailing-comma */
+export function stringGrammar(solve) {
+    const varVariable = solve ? 'return null' : '$$ = ``';
+    return {
+        lex: {
+            rules: [
+                // Saute les espaces
+                ['\\s+', '/* skip whitespace */'],
+                ['\\$\\w+', 'return `VARIABLE`'],
+                ['_', 'return `SPACE`'],
+                ['"', 'return `QUOT`'],
+                ['\\&', 'return `&`'],
+                ['=', 'return `BEGEXP`'],
+                ['[^"]+', 'return `STRING`'],
+                ['$', 'return `EOF`'],
+            ]
+        },
+        operators: [
+            ['left', '&']
+        ],
+        bnf: {
+            expressions: [['BEGEXP e EOF', 'return $2'], ['STRING EOF', 'return $1']],
+            e: [
+                ['e & e', '$$ = `${$1}${$3}`'],
+                ['QUOT STRING QUOT', '$$ = $2'],
+                ['SPACE', '$$ = ` `'],
+                ['VARIABLE', varVariable]
+            ]
+        }
+    };
+}

package/bin/jison/variable.grammar.d.ts

@@ -0,0 +1,9 @@
+export declare const variableGrammar: {
+    lex: {
+        rules: string[][];
+    };
+    operators: never[];
+    bnf: {
+        expressions: string[][];
+    };
+};

package/bin/jison/variable.grammar.js

@@ -0,0 +1,14 @@
+export const variableGrammar = {
+    lex: {
+        rules: [
+            // Saute les espaces
+            ['\\s+', '/* skip whitespace */'],
+            ['\\$\\w+', 'return `VARIABLE`'],
+            ['$', 'return `EOF`']
+        ]
+    },
+    operators: [],
+    bnf: {
+        expressions: [['VARIABLE EOF', 'return $1']]
+    }
+};

package/bin/models/parameter.model.d.ts

@@ -0,0 +1,20 @@
+export interface DescModel {
+    pos: number;
+    label: string;
+    type: enumParamType;
+    documentation?: string;
+    required: boolean;
+    options?: string[];
+}
+export interface SettingDescModel extends DescModel {
+    tid: string;
+}
+export declare enum enumParamType {
+    booldata = "Boolean",
+    numbdata = "Number",
+    textdata = "Text",
+    datetime = "DateTime",
+    receipt = "Variable",
+    options = "Options"
+}
+export type varType = string | number | boolean | null | undefined;

package/bin/models/parameter.model.js

@@ -0,0 +1,14 @@
+// Modèle de données des paramètres utilisés pour les libraries
+// et pour la configuration des outils
+// Enumération des types de paramètre
+// receipt est spécifique aux paramètres d'action
+// options est spécifique aux paramètres de configuration d'outils (tool's settings)
+export var enumParamType;
+(function (enumParamType) {
+    enumParamType["booldata"] = "Boolean";
+    enumParamType["numbdata"] = "Number";
+    enumParamType["textdata"] = "Text";
+    enumParamType["datetime"] = "DateTime";
+    enumParamType["receipt"] = "Variable";
+    enumParamType["options"] = "Options";
+})(enumParamType || (enumParamType = {}));

package/bin/models/run.model.d.ts

@@ -0,0 +1,56 @@
+import { enumParamType, varType } from './parameter.model.js';
+export interface WsDataMessage {
+    logs: RunReportStep;
+    ctx: [string, varType][];
+    params: RunParamModel[];
+}
+export interface RunDataStepModel {
+    pos: number;
+    istoy: boolean;
+    lib: string;
+    fn: string;
+    parameters: RunParamModel[];
+    config: RunParamModel[];
+    toolid?: string;
+}
+export interface RunParamModel {
+    key: string;
+    value: varType;
+    type?: enumParamType;
+    options?: string[];
+}
+/**
+ * Log information interface
+ * - *pos* : step position or -1 if log message doesn't concern a step
+ * - *level* : 0 = information, 1 = warning, 2 = error
+ * - *message* : message text
+ */
+export interface RunLog {
+    pos: number;
+    level: number;
+    message: string;
+}
+/**
+ * Step execution reporting
+ * - *pos* : step position
+ * - *runtime* : step execution duration
+ * - *status* : 0 = cancel, 1 = pass, 2 = fail
+ */
+export interface RunReportStep {
+    pos?: number;
+    runtime?: number;
+    status?: number;
+    messages?: RunLog[];
+}
+export declare const stepStatus: Readonly<{
+    cancel: 0;
+    pass: 1;
+    fail: 2;
+    toString(n: number | undefined): "cancel" | "pass" | "fail" | "";
+}>;
+export declare const logLevel: Readonly<{
+    info: 0;
+    warning: 1;
+    error: 2;
+    toString(n: number | undefined): "" | "info" | "warning" | "error";
+}>;

package/bin/models/run.model.js

@@ -0,0 +1,26 @@
+export const stepStatus = Object.freeze({
+    cancel: 0,
+    pass: 1,
+    fail: 2,
+    toString(n) {
+        switch (n) {
+            case 0: return 'cancel';
+            case 1: return 'pass';
+            case 2: return 'fail';
+        }
+        return '';
+    },
+});
+export const logLevel = Object.freeze({
+    info: 0,
+    warning: 1,
+    error: 2,
+    toString(n) {
+        switch (n) {
+            case 0: return 'info';
+            case 1: return 'warning';
+            case 2: return 'error';
+        }
+        return '';
+    },
+});

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@kogeet/scapin-core-agent",
+  "version": "0.1.0",
+  "description": "Scapin Core Agent",
+  "author": "Loïc Griveau",
+  "license": "MIT",
+  "main": "bin/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": "^18.17.1"
+  },
+  "np": {
+    "tests": false,
+    "message": "core-agent %s"
+  },
+  "scripts": {
+    "build": "tsc --sourceMap false --declaration true",
+    "sagentprod": "npm run build && node bin/index.js"
+  },
+  "devDependencies": {
+    "@types/node": "^20.8.8",
+    "@typescript-eslint/eslint-plugin": "^6.8.0",
+    "@typescript-eslint/parser": "^6.8.0",
+    "eslint": "^8.51.0",
+    "typescript": "^5.2.2"
+  },
+  "dependencies": {
+    "jison": "^0.4.18",
+    "socket.io-client": "^4.7.2"
+  },
+  "type": "module"
+}