bpmn-client 1.2.1 → 1.3.8

package/monitor.js

@@ -0,0 +1,91 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require("./");
+console.log("Testing BPMNClient");
+const dotenv = require('dotenv');
+const res = dotenv.config();
+console.log(res);
+monitor();
+function monitor() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const server = new _1.BPMNClient(process.env.HOST, process.env.PORT, process.env.API_KEY);
+        console.log('running monitor');
+        for (var i = 0; i < 1000; i++) {
+            yield checkStatus(server);
+            yield delay(15000, 'test');
+        }
+    });
+}
+function checkStatus(server, reason = '') {
+    return __awaiter(this, void 0, void 0, function* () {
+        var list = yield server.engine.status();
+        var insT = 0, insR = 0, itmT = 0, itmR = 0, tokT = 0, tokR = 0;
+        for (var i = 0; i < list.length; i++) {
+            var exec = list[i];
+            var dInstance = null;
+            insT++;
+            tokT += exec.instance.tokens.length;
+            if (exec.instance.status == 'running')
+                insR++;
+            var started = dateDiff(exec.instance.startedAt);
+            var ended = dateDiff(exec.instance.endedAt);
+            var msg = ` Instance for '${exec.instance.name}'  Status: ${exec.status} Started At ${started} Ended ${ended} items: ${exec.instance.items.length}`;
+            try {
+                dInstance = yield server.datastore.findInstances({ id: exec.instance.id }, {});
+                //console.log(reason+' logs:',exec.instance.logs.length, dInstance.logs.length,dInstance.data.caseId);
+                if (dInstance.length > 0)
+                    msg += ' items:' + dInstance[0].items.length;
+            }
+            catch (exc) {
+                msg += ' no instance' + exc.toString();
+            }
+            console.log(msg);
+        }
+        console.log(`${reason} ->Instances: Total: ${insT} Running: ${insR}`); // Tokens: ${tokT} `);
+    });
+}
+function delay(time, result) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise(function (resolve) {
+            setTimeout(function () {
+                resolve(result);
+            }, time);
+        });
+    });
+}
+function dateDiff(dateStr) {
+    var endDate = new Date();
+    var startTime = new Date(dateStr);
+    var time1 = endDate.getTime();
+    var time2 = startTime;
+    var seconds = Math.abs(time1 - time2) / 1000;
+    // get total seconds between the times
+    var delta = seconds; //Math.abs(date_future - date_now) / 1000;
+    // calculate (and subtract) whole days
+    var days = Math.floor(delta / 86400);
+    delta -= days * 86400;
+    // calculate (and subtract) whole hours
+    var hours = Math.floor(delta / 3600) % 24;
+    delta -= hours * 3600;
+    // calculate (and subtract) whole minutes
+    var minutes = Math.floor(delta / 60) % 60;
+    delta -= minutes * 60;
+    // what's left is seconds
+    var seconds = Math.floor(delta % 60); // in theory the modulus is not required
+    if (days > 0)
+        return (days + " days");
+    if (hours > 0)
+        return (hours + " hours");
+    if (minutes > 0)
+        return (minutes + " minutes");
+    return (seconds + " seconds");
+}

package/monitor.ts

@@ -0,0 +1,100 @@
+import { BPMNClient } from './';
+
+
+console.log("Testing BPMNClient");
+const dotenv = require('dotenv');
+const res = dotenv.config();
+
+console.log(res);
+monitor();
+
+async function monitor() {
+
+    const server = new BPMNClient(process.env.HOST, process.env.PORT, process.env.API_KEY);
+
+    console.log('running monitor');
+    for (var i = 0; i < 1000; i++) {
+        await checkStatus(server);
+        await delay(15000, 'test');
+    }
+
+
+}
+async function checkStatus(server, reason = '') {
+
+
+    var list = await server.engine.status();
+
+    var insT = 0, insR = 0, itmT = 0, itmR = 0, tokT = 0, tokR = 0;
+    for (var i = 0; i < list.length; i++) {
+        var exec = list[i];
+        var dInstance = null;
+        insT++;
+        tokT += exec.instance.tokens.length;
+        if (exec.instance.status == 'running') insR++;
+        var started = dateDiff(exec.instance.startedAt);
+        var ended = dateDiff(exec.instance.endedAt);
+
+
+        var msg = ` Instance for '${exec.instance.name}'  Status: ${exec.status} Started At ${started} Ended ${ended} items: ${exec.instance.items.length}`;
+        try {
+            dInstance = await server.datastore.findInstances({ id: exec.instance.id }, {});
+            //console.log(reason+' logs:',exec.instance.logs.length, dInstance.logs.length,dInstance.data.caseId);
+            if (dInstance.length > 0)
+                msg += ' items:' + dInstance[0].items.length;
+        }
+        catch (exc) {
+            msg += ' no instance' + exc.toString();
+        }
+        console.log(msg);
+
+    }
+    console.log(`${reason} ->Instances: Total: ${insT} Running: ${insR}`);// Tokens: ${tokT} `);
+}
+
+async function delay(time, result) {
+    return new Promise(function (resolve) {
+        setTimeout(function () {
+            resolve(result);
+        }, time);
+    });
+}
+
+
+
+
+function dateDiff(dateStr) {
+
+    var endDate = new Date();
+    var startTime = new Date(dateStr);
+    var time1 = endDate.getTime();
+    var time2 = startTime as unknown as number;
+
+    var seconds = Math.abs(time1 - time2) / 1000;
+
+
+    // get total seconds between the times
+    var delta = seconds; //Math.abs(date_future - date_now) / 1000;
+
+    // calculate (and subtract) whole days
+    var days = Math.floor(delta / 86400);
+    delta -= days * 86400;
+
+    // calculate (and subtract) whole hours
+    var hours = Math.floor(delta / 3600) % 24;
+    delta -= hours * 3600;
+
+    // calculate (and subtract) whole minutes
+    var minutes = Math.floor(delta / 60) % 60;
+    delta -= minutes * 60;
+
+    // what's left is seconds
+    var seconds = Math.floor(delta % 60);  // in theory the modulus is not required
+    if (days > 0)
+        return (days + " days");
+    if (hours > 0)
+        return (hours + " hours");
+    if (minutes > 0)
+        return (minutes + " minutes");
+    return (seconds + " seconds");
+}

package/package.json

@@ -1,17 +1,14 @@
 {
   "name": "bpmn-client",
-  "version": "1.2.1",
+  "version": "1.3.8",
   "license": "MIT",
   "scripts": {
     "build": "tsc --build",
+    "compileRun": "tsc --build && node cli.js",
+    "dev": "nodemon -e ts  --exec \"npm run compileRun\"",
     "clean": "tsc --build --clean",
-    "start": "node app.ts",
-    "test": "mocha -R dot",
-    "posttest": "eslint . --cache && npm run toc",
-    "wintest": "node_modules/.bin/mocha",
-    "start:watch": "tsc-watch --project . --onSuccess \"nodemon ./test.ts\"",
-    "toc": "node scripts/generate-api-toc ./docs/API.md,./docs/Examples.md",
-    "test-md": "node scripts/test-markdown.js ./docs/API.md && node scripts/test-markdown.js ./docs/Examples.md"
+    "start": "node cli.ts",
+    "test": "mocha -exit --config=test\\.mocharc.json"
   },
   "description": "Client API for BPMN-Server webservices",
   "keywords": [

package/src/BPMNClient.js

@@ -19,7 +19,7 @@ class WebService {
         return __awaiter(this, void 0, void 0, function* () {
             var driver = http;
             var body = JSON.stringify(params);
-            console.log(options, params);
+            //        console.log(options, params);
             if (options.port == 443)
                 driver = https;
             let data = '';
@@ -27,7 +27,8 @@ class WebService {
             return new Promise(function (resolve, reject) {
                 try {
                     driver.request(options, function (res) {
-                        console.log('STATUS: ' + res.statusCode);
+                        //                    console.log('STATUS: ' + res.statusCode);
+                        this.response = res;
                         //console.log(res);
                         self.statusCode = res.statusCode;
                         res.setEncoding('utf8');
@@ -35,8 +36,14 @@ class WebService {
                             data += chunk;
                         });
                         res.on('end', () => {
-                            self.result = JSON.parse(data);
-                            resolve(self.result);
+                            try {
+                                self.result = JSON.parse(data);
+                                resolve(self.result);
+                            }
+                            catch (exc) {
+                                console.log(data);
+                                console.log(exc);
+                            }
                         });
                     }).on("error", (err) => {
                         console.log("Error: " + err.message);
@@ -140,9 +147,9 @@ class ClientEngine {
             return instance;
         });
     }
-    throwMessage(messageId, data) {
+    throwMessage(messageId, data = {}, messageMatchingKey = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield this.client.put('engine/throwMessage', { "messageId": messageId, "data": data });
+            const ret = yield this.client.post('engine/throwMessage', { "messageId": messageId, "data": data, messageMatchingKey });
             if (ret['errors']) {
                 console.log(ret['errors']);
                 throw new Error(ret['errors']);
@@ -150,9 +157,9 @@ class ClientEngine {
             return ret;
         });
     }
-    throwSignal(signalId, data) {
+    throwSignal(signalId, data = {}, messageMatchingKey = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield this.client.put('engine/throwSignal', { "signalId": signalId, "data": data });
+            const ret = yield this.client.post('engine/throwSignal', { "signalId": signalId, "data": data, messageMatchingKey });
             if (ret['errors']) {
                 console.log(ret['errors']);
                 throw new Error(ret['errors']);
@@ -171,6 +178,16 @@ class ClientEngine {
             return instance;
         });
     }
+    status() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ret = yield this.client.get('engine/status', {});
+            if (ret['errors']) {
+                console.log(ret['errors']);
+                throw new Error(ret['errors']);
+            }
+            return ret;
+        });
+    }
 }
 exports.ClientEngine = ClientEngine;
 class ClientDatastore {
@@ -201,7 +218,7 @@ class ClientDatastore {
     }
     deleteInstances(query) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.client.del('datastore/delete', query);
+            return yield this.client.del('datastore/deleteInstances', query);
         });
     }
 }

package/src/BPMNClient.ts

@@ -8,13 +8,14 @@ const http = require('http');
 class WebService {
     statusCode;
     result;
+    response;
     constructor() { }
     async invoke(params, options) {
 
         var driver = http;
         var body = JSON.stringify(params);
 
-        console.log(options, params);
+//        console.log(options, params);
         if (options.port == 443)
             driver = https;
 
@@ -24,7 +25,8 @@ class WebService {
             try {
 
                 driver.request(options, function (res) {
-                    console.log('STATUS: ' + res.statusCode);
+//                    console.log('STATUS: ' + res.statusCode);
+                    this.response = res;
                     //console.log(res);
                     self.statusCode = res.statusCode;
                     res.setEncoding('utf8');
@@ -32,9 +34,14 @@ class WebService {
                         data += chunk;
                     });
                     res.on('end', () => {
-                        self.result = JSON.parse(data);
-
-                        resolve(self.result);
+                        try {
+                            self.result = JSON.parse(data);
+                            resolve(self.result);
+                        }
+                        catch (exc) {
+                            console.log(data);
+                            console.log(exc);
+                        }
                     });
 
 
@@ -130,7 +137,7 @@ class ClientEngine {
     constructor(client) {
         this.client = client;
     }
-    async start(name, data = {} , startNodeId = null, options = {}): Promise<IInstanceData> {
+    async start(name, data = {}, startNodeId = null, options = {}): Promise<IInstanceData> {
         const ret = await this.client.post('engine/start',
             { name, data, startNodeId, options });
         if (ret['errors']) {
@@ -150,16 +157,16 @@ class ClientEngine {
         return instance;
     }
 
-    async throwMessage(messageId, data) {
-        const ret = await this.client.put('engine/throwMessage', { "messageId": messageId , "data": data });
+    async throwMessage(messageId, data = {} , messageMatchingKey = {}) {
+        const ret = await this.client.post('engine/throwMessage', { "messageId": messageId, "data": data, messageMatchingKey });
         if (ret['errors']) {
             console.log(ret['errors']);
             throw new Error(ret['errors']);
         }
         return ret;
     }
-    async throwSignal(signalId, data) {
-        const ret = await this.client.put('engine/throwSignal', { "signalId": signalId, "data": data });
+    async throwSignal(signalId, data = {} , messageMatchingKey = {}) {
+        const ret = await this.client.post('engine/throwSignal', { "signalId": signalId, "data": data, messageMatchingKey });
         if (ret['errors']) {
             console.log(ret['errors']);
             throw new Error(ret['errors']);
@@ -176,6 +183,14 @@ class ClientEngine {
         const instance = ret['instance'] as IInstanceData;
         return instance;
     }
+    async status() {
+        const ret = await this.client.get('engine/status', {});
+        if (ret['errors']) {
+            console.log(ret['errors']);
+            throw new Error(ret['errors']);
+        }
+        return ret;
+    }
 }
 class ClientDatastore {
     private client: BPMNClient;
@@ -203,7 +218,7 @@ class ClientDatastore {
         return instances;
     }
     async deleteInstances(query) {
-        return await this.client.del('datastore/delete', query);
+        return await this.client.del('datastore/deleteInstances', query);
     }
 }
 class ClientDefinitions {

package/test/.mocharc.json

@@ -0,0 +1,12 @@
+{
+  "diff": true,
+  "extension": [ "js" ],
+  "package": "package.json",
+  "reporter": "spec",
+  "slow": 1500,
+  "timeout": 50000,
+  "recursive": true,
+  "file": [ "test/helpers/setup.js" ],
+  "ui": "mocha-cakes-2",
+  "watch-files": [ "test/feature/*.js" ]
+}

package/test/feature/.env

@@ -1,5 +1,3 @@
 API_KEY=1234
-MONGO_DB_URL=mongodb://localhost:27017?retryWrites=true&w=majority
-MONGO_DB_NAME=bpmn
-SENDGRID_API_KEY=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
+
 

package/test/feature/carServer.js

@@ -3,10 +3,10 @@ const {  BPMNClient } = require("../../src/");
 
 
 const API_KEY = '12345';
-//const HOST = 'localhost';
-//const PORT = '3000';
-const HOST = 'test.omniworkflow.com';
-const PORT = '443';
+const HOST = 'localhost';
+const PORT = '3000';
+//const HOST = 'test.omniworkflow.com';
+//const PORT = '443';
 
 const BASE_URL = 'api';
 
@@ -89,6 +89,11 @@ Feature('Buy Used Car- clean and repair', () => {
 
         });
 
+        and('find engine status', async () => {
+
+            var insts = await server.engine.status();
+ 
+        });
 
         // 
         and('find instances', async () => {

package/test.env

@@ -0,0 +1,4 @@
+API_KEY=12345
+HOST=test.omniworkflow.com
+PORT=443
+BASE_URL=api

package/test.js

@@ -13,12 +13,42 @@ const _1 = require("./");
 console.log("Testing BPMNClient");
 const dotenv = require('dotenv');
 const res = dotenv.config();
-console.log(res);
-test();
+const server = new _1.BPMNClient(process.env.HOST, process.env.PORT, process.env.API_KEY);
+testMessage();
+function displayInstance(instanceId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let insts = yield server.datastore.findInstances({ id: instanceId });
+        for (var i = 0; i < insts.length; i++) {
+            let inst = insts[i];
+            var items = inst.items;
+            console.log(`name: ${inst.name} status: ${inst.status}	instanceId:	${inst.id}
+	startedAt: ${inst.startedAt} endedAt ${inst.endedAt}`, 'data:', inst.data);
+            for (var j = 0; j < items.length; j++) {
+                let item = items[j];
+                console.log(`element: ${item.elementId} status: ${item.status}	id:	${item.id}`);
+            }
+        }
+    });
+}
+function testMessage() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const messageId = 'Message-104';
+        let messageData = {};
+        console.log('calling');
+        let response = yield server.engine.throwMessage(messageId, messageData);
+        if (response['id'])
+            return yield displayInstance(response['id']);
+        else
+            return null;
+    });
+}
 function test() {
     return __awaiter(this, void 0, void 0, function* () {
         const server = new _1.BPMNClient(process.env.HOST, process.env.PORT, process.env.API_KEY);
         const caseId = 3040;
+        var delResp = yield server.datastore.deleteInstances({ name: 'Buy Used Car' });
+        //console.log(delResp);
+        //return;
         var defs = yield server.definitions.list();
         console.log(defs);
         var def = yield server.definitions.load('Buy Used Car');
@@ -39,6 +69,10 @@ function test() {
         catch (exc) {
             console.log(exc);
         }
+        var items = yield server.datastore.findItems({ "items.status": "end", "items.elementId": "task_Buy" });
+        items.forEach(item => {
+            console.log('item: id==>' + item.elementId, item.type, item.name, 'status==>', item.status);
+        });
         var insts = yield server.datastore.findInstances({ data: { caseId: caseId } });
         insts.forEach(inst => {
             console.log('Inst for CaseId id==>' + inst.id, inst.name, inst.data.caseId, 'status==>', inst.status);
@@ -62,3 +96,12 @@ function test() {
         });
     });
 }
+function delay(time, result) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise(function (resolve) {
+            setTimeout(function () {
+                resolve(result);
+            }, time);
+        });
+    });
+}

package/test.ts

@@ -5,15 +5,51 @@ console.log("Testing BPMNClient");
 const dotenv = require('dotenv');
 const res = dotenv.config();
 
-console.log(res);
-test();
+const server = new BPMNClient(process.env.HOST, process.env.PORT, process.env.API_KEY);
+
+testMessage();
+
+async function displayInstance(instanceId) {
+
+    let insts = await server.datastore.findInstances({ id: instanceId })
+
+    for (var i = 0; i < insts.length; i++) {
+        let inst = insts[i];
+        var items = inst.items;
+        console.log(`name: ${inst.name} status: ${inst.status}	instanceId:	${inst.id}
+	startedAt: ${inst.startedAt} endedAt ${inst.endedAt}`, 'data:', inst.data);
+        for (var j = 0; j < items.length; j++) {
+            let item = items[j];
+            console.log(`element: ${item.elementId} status: ${item.status}	id:	${item.id}`);
+        }
+    }
+}
+
+
+async function testMessage() {
+    const messageId = 'Message-104';
+
+    let messageData = {};
+
+    console.log('calling');
+    let response = await server.engine.throwMessage(messageId, messageData);
+    if (response['id'])
+        return await displayInstance(response['id']);
+    else
+        return null;
+}
+
 
 async function test() {
 
-    const server= new BPMNClient(process.env.HOST, process.env.PORT, process.env.API_KEY);
+    const server = new BPMNClient(process.env.HOST, process.env.PORT, process.env.API_KEY);
 
     const caseId = 3040;
 
+
+    var delResp = await server.datastore.deleteInstances({ name: 'Buy Used Car' });
+    //console.log(delResp);
+    //return;
     var defs = await server.definitions.list();
 
     console.log(defs);
@@ -61,6 +97,16 @@ async function test() {
 
 
 
+
+    var items = await server.datastore.findItems({ "items.status": "end", "items.elementId": "task_Buy" });
+
+
+    items.forEach(item => {
+        console.log('item: id==>' + item.elementId, item.type, item.name, 'status==>', item.status);
+    });
+
+
+
     var insts = await server.datastore.findInstances({ data: { caseId: caseId } });
 
     insts.forEach(inst => {
@@ -94,7 +140,14 @@ async function test() {
     items.forEach(item => {
         console.log('item: id==>' + item.elementId, item.type, item.name, 'status==>', item.status);
     });
+}
 
+async function delay(time, result) {
+    return new Promise(function (resolve) {
+        setTimeout(function () {
+            resolve(result);
+        }, time);
+    });
 }