bpmn-client 1.3.27 → 1.4.0

package/.env

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmn-client",
-  "version": "1.3.27",
+  "version": "1.4.0",
   "license": "MIT",
   "scripts": {
     "build": "tsc --build",

package/src/BPMNClient.js

@@ -88,9 +88,9 @@ class ClientEngine {
     constructor(client) {
         this.client = client;
     }
-    start(name, data = {}, startNodeId = null, options = {}) {
+    start(name, data = {}, startNodeId = null, userId = null, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield this.client.post('engine/start', { name, data, startNodeId, options });
+            const ret = yield this.client.post('engine/start', { name, data, startNodeId, userId, options });
             if (ret['errors']) {
                 console.log(ret['errors']);
                 throw new Error(ret['errors']);
@@ -99,9 +99,20 @@ class ClientEngine {
             return instance;
         });
     }
-    invoke(query, data) {
+    invoke(query, data, userId = null) {
         return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield this.client.put('engine/invoke', { query, data });
+            const ret = yield this.client.put('engine/invoke', { query, data, userId });
+            if (ret['errors']) {
+                console.log(ret['errors']);
+                throw new Error(ret['errors']);
+            }
+            const instance = ret['instance'];
+            return instance;
+        });
+    }
+    assign(query, data, userId = null, assignment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ret = yield this.client.put('engine/assign', { query, data, userId, assignment });
             if (ret['errors']) {
                 console.log(ret['errors']);
                 throw new Error(ret['errors']);

package/src/BPMNClient.ts

@@ -94,9 +94,9 @@ class ClientEngine {
     constructor(client) {
         this.client = client;
     }
-    async start(name, data = {}, startNodeId = null, options = {}): Promise<IInstanceData> {
+    async start(name, data = {}, startNodeId = null,  userId= null,options = {}): Promise<IInstanceData> {
         const ret = await this.client.post('engine/start',
-            { name, data, startNodeId, options });
+            { name, data, startNodeId, userId, options });
         if (ret['errors']) {
             console.log(ret['errors']);
             throw new Error(ret['errors']);
@@ -104,8 +104,17 @@ class ClientEngine {
         const instance = ret as IInstanceData;
         return instance;
     }
-    async invoke(query, data): Promise<IInstanceData> {
-        const ret = await this.client.put('engine/invoke', { query, data });
+    async invoke(query, data, userId= null): Promise<IInstanceData> {
+        const ret = await this.client.put('engine/invoke', { query, data , userId });
+        if (ret['errors']) {
+            console.log(ret['errors']);
+            throw new Error(ret['errors']);
+        }
+        const instance = ret['instance'] as IInstanceData;
+        return instance;
+    }
+    async assign(query, data, userId= null,assignment): Promise<IInstanceData> {
+        const ret = await this.client.put('engine/assign', { query, data , userId,assignment });
         if (ret['errors']) {
             console.log(ret['errors']);
             throw new Error(ret['errors']);

package/src/interfaces/BPMNClient.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/interfaces/BPMNClient.ts

@@ -0,0 +1,29 @@
+import { IInstanceData, IItemData , IDefinitionData} from './DataObjects';
+
+
+export interface IBPMNClient  {
+    engine: IClientEngine;
+    datastore: IClientDatastore;
+    definitions: IClientDefinitions;
+}
+
+export interface IClientEngine {
+     start(name, data , startNodeId ,  userId,options ): Promise<IInstanceData>;
+     invoke(query, data, userId): Promise<IInstanceData> ;
+     assign(query, data, userId,assignment): Promise<IInstanceData>;
+     throwMessage(messageId, data, messageMatchingKey);
+     throwSignal(signalId, data, messageMatchingKey);
+     status();
+}
+export interface IClientDatastore {
+     findItems(query): Promise<IItemData[]>; 
+     findInstances(query): Promise<IInstanceData[]>;
+     deleteInstances(query);
+}
+export interface IClientDefinitions {
+     import(name, pathToBPMN,pathToSVG);
+     list(): Promise<string[]>;
+     delete(name) ;
+     rename(name,newName);
+     load(name): Promise<IDefinitionData>;
+}

package/src/interfaces/DataObjects.ts

@@ -17,10 +17,13 @@ interface IItemData {
     data: any;
     messageId;
     signalId;
-    assignments;
-    authorizations;
-    notifications;
     vars;
+    assignee;
+    candidateGroups;
+    candidateUsers;
+    dueDate;
+    followUpDate;
+    priority;
 }
 interface IInstanceData {
     id;
@@ -36,8 +39,6 @@ interface IInstanceData {
     tokens;
     loops;
     parentItemId;   // used for subProcess Calls
-    involvements;
-    authorizations;
 }
 
 

package/src/interfaces/Enums.js

@@ -65,15 +65,15 @@ var EXECUTION_EVENT;
 /*
  *  possible actions by node
  */
-//   must be same as above
 var NODE_ACTION;
 (function (NODE_ACTION) {
     NODE_ACTION[NODE_ACTION["continue"] = 1] = "continue";
     NODE_ACTION[NODE_ACTION["wait"] = 2] = "wait";
     NODE_ACTION[NODE_ACTION["end"] = 3] = "end";
-    NODE_ACTION[NODE_ACTION["stop"] = 4] = "stop";
-    NODE_ACTION[NODE_ACTION["error"] = 5] = "error";
-    NODE_ACTION[NODE_ACTION["abort"] = 6] = "abort";
+    NODE_ACTION[NODE_ACTION["cancel"] = 4] = "cancel";
+    NODE_ACTION[NODE_ACTION["stop"] = 5] = "stop";
+    NODE_ACTION[NODE_ACTION["error"] = 6] = "error";
+    NODE_ACTION[NODE_ACTION["abort"] = 7] = "abort";
 })(NODE_ACTION || (exports.NODE_ACTION = NODE_ACTION = {}));
 ;
 var ITEM_STATUS;

package/src/interfaces/Enums.ts

@@ -49,8 +49,8 @@ enum EXECUTION_EVENT {
 /*
  *  possible actions by node
  */
-//   must be same as above
-enum NODE_ACTION { continue = 1, wait,  end , stop , error , abort  };
+
+enum NODE_ACTION { continue = 1, wait,  end , cancel, stop , error , abort  };
 
 enum ITEM_STATUS {
     enter = 'enter',

package/test/feature/.env

@@ -1,3 +1,4 @@
 API_KEY=1234
-
-
+HOST=localhost
+PORT=3000
+BASE_URL=api

package/test/feature/car.js

@@ -0,0 +1,123 @@
+const {  BPMNClient } = require("../../src/");
+
+
+
+const API_KEY = '12345';
+const HOST = 'localhost';
+const PORT = '3000';
+//const HOST = 'test.omniworkflow.com';
+//const PORT = '443';
+
+const BASE_URL = 'api';
+
+
+console.log('-------- carServer.js -----------');
+
+const server = new BPMNClient(HOST, PORT, API_KEY);
+
+var caseId = Math.floor(Math.random() * 10000);
+
+let name = 'Buy Used Car';
+let process;
+let response;
+let instanceId;
+let userId='user1';
+
+Feature('Buy Used Car- clean and repair', () => {
+        Scenario('Simple', () => {
+            Given('Start Buy Used Car Process',async () => {
+                response = await server.engine.start(name, {caseId: caseId},null,userId);
+                console.log('**instanceId',  response.id);
+                instanceId = response.id;
+                console.log('data:',response.data);
+                console.log('item',getItem('task_Buy'));
+                
+//                console.log(' after start ', response.instance.caseId);
+            });
+            Then('check for output', () => {
+                expect(response.data.starterUserId).equals(userId);
+                expect(response.data.caseId).equals(caseId);
+                expect(getItem('task_Buy').status).equals('wait');
+             });
+
+            When('assignTask', async () => {
+                const query = {id: instanceId ,"items.elementId": 'task_Buy' };
+                const assignment = {assignee: userId, 
+                    candidateUsers: ['employee1','manager1'],
+                    dueDate :new Date() , priority: 7
+                };
+                response = await server.engine.assign(query,null,userId,assignment);
+
+                const itm=getItem('task_Buy');
+
+                console.log(itm);
+
+                expect(itm.priority).equals(7);
+
+            });
+
+
+
+            When('a process defintion is executed', async () => {
+
+                const data = { needsCleaning: "Yes", needsRepairs: "Yes" };
+                const query ={
+                    id: instanceId ,
+                    "items.elementId": 'task_Buy'
+                };
+//                console.log(query);
+                response= await server.engine.invoke(query ,data );
+            });
+
+            When('engine get', async () => {
+                const query = {id: instanceId };
+
+                response = await server.engine.get(query);
+
+                expect(response.id).equals(instanceId);
+
+            });
+
+
+            Then('check for output to have engine', () => {
+                expect(getItem('task_Buy').status).equals('end');
+            });
+
+            and('Clean it', async () => {
+
+                    const query = {
+                        "data.caseId": caseId ,
+                    "items.elementId": 'task_clean'
+                };
+//                console.log(query);
+                    await server.engine.invoke(query, {});
+            });
+      
+            and('Repair it', async () => {
+                    const query = { id: instanceId ,"items.elementId": 'task_repair'};
+                    response = await server.engine.invoke(query, {});
+            }); 
+            and('Drive it 1', async () => {
+                const query = {
+                    id: instanceId ,
+                    "items.elementId": 'task_Drive'};
+                response=await server.engine.invoke(query, {});
+            });
+
+            and('Case Complete', async () => {
+
+//                console.log(response.instance.status);
+//                console.log(response.execution.status);
+              expect(response.status).equals('end');
+                expect(getItem('task_Drive').status).equals('end');
+
+            });
+
+        });
+
+    });
+
+function getItem(id)
+{
+    return response.items.filter(item => { return item.elementId == id; })[0];
+}

package/test/feature/carServer.js

@@ -11,7 +11,7 @@ const PORT = '3000';
 const BASE_URL = 'api';
 
 
-console.log('-------- car.js -----------');
+console.log('-------- carServer.js -----------');
 
 const server = new BPMNClient(HOST, PORT, API_KEY);
 
@@ -25,10 +25,11 @@ let instanceId;
 Feature('Buy Used Car- clean and repair', () => {
     Scenario('Simple', () => {
         Given('Start Buy Used Car Process', async () => {
-            response = await server.engine.start(name, { caseId: caseId });
+            response = await server.engine.start(name, { caseId: caseId },null, 'remoteUser1');
             instanceId = response.id;
-            console.log('**instanceId', response.id, instanceId);
-            console.log(' after start ', response.data.caseId);
+
+            //console.log('**instanceId', response.id, instanceId);
+            //console.log(' after start ', response.data.caseId);
         });
         Then('check for output', () => {
             expect(response.data.caseId).equals(caseId);
@@ -43,7 +44,7 @@ Feature('Buy Used Car- clean and repair', () => {
                 "items.elementId": 'task_Buy'
             };
             console.log(query);
-            response = await server.engine.invoke(query, data);
+            response = await server.engine.invoke(query, data,'RemoteUser2');
         });
 
         When('engine get', async () => {
@@ -67,7 +68,7 @@ Feature('Buy Used Car- clean and repair', () => {
                 "items.elementId": 'task_clean'
             };
             console.log(query);
-            await server.engine.invoke(query, {});
+            await server.engine.invoke(query, {},'remoteUser3');
         });
 
         and('Repair it', async () => {
@@ -79,7 +80,7 @@ Feature('Buy Used Car- clean and repair', () => {
                 id: instanceId,
                 "items.elementId": 'task_Drive'
             };
-            response = await server.engine.invoke(query, {});
+            response = await server.engine.invoke(query, {},'remote_user4');
         });
 
         and('Case Complete', async () => {