@manyos/smileconnect-api 1.38.0 → 1.39.0

package/app.js

@@ -233,6 +233,15 @@ app.get('/debug', function (req, res, next) {
 //global authentication
 app.use(passport.authenticate('jwt', {session: false}), responseHandler.logRequest);
 
+//set globalscript params
+app.use(function (req, res, next) {
+    req.globalScriptParams = {
+        query: req.query,
+        params: req.params
+    }
+    next()
+});
+
 // setup routes
 
 app.use('/v1/cmdbobjects', function(req, res, next) {

package/conf/clients.json

@@ -400,8 +400,7 @@
         "scripts": {
           "GET": {
             "preMapping": [
-              "script1",
-              "script2"
+              "checkGlobalParams"
             ],
             "postMapping": [
               "p2"

package/conf/scripts/checkGlobalParams.js

@@ -0,0 +1,3 @@
+//requestData.Name = "Horstdidü";
+requestData.globalScriptParams = globalScriptParams
+resolve();

package/controller/cmdbobjectController.js

@@ -21,7 +21,7 @@ function getRandomId() {
     return v4();
 }
 
-function getCmdbObjects(config, category, ciIds, includeString, options) {
+function getCmdbObjects(config, category, ciIds, includeString, options, globalScriptParams) {
     let query = '1=1';
     if (category)
         query = `'Category' = \"${category}\"`;
@@ -37,7 +37,7 @@ function getCmdbObjects(config, category, ciIds, includeString, options) {
         query = query + ciQuery + ')';
         log.error('query', query);
     }
-    return queryCMDBObject(config, query, null, options, includeString);
+    return queryCMDBObject(config, query, null, options, includeString, undefined, globalScriptParams);
 }
 
 function getCIRelations(clientConfig, id) {
@@ -121,7 +121,7 @@ function getSchemaName(classId) {
     }
 }
 
-function queryCMDBObject(clientConfig, query, customFields, customOptions, includeString, mapping) {
+function queryCMDBObject(clientConfig, query, customFields, customOptions, includeString, mapping, globalScriptParams) {
     let fields = clientConfig.cmdbobject.fields;
     let deleteClassId = false;
 
@@ -158,7 +158,7 @@ function queryCMDBObject(clientConfig, query, customFields, customOptions, inclu
         if (result && result.data && result.data.length) {
             let x = 0;
             for (x=0; x< result.data.length; x++) {
-                const cmdbObject = await handleCMDBObjectResult(result.data[x], mapping, clientConfig, includeArray, globalRelationObjects, deleteClassId);
+                const cmdbObject = await handleCMDBObjectResult(result.data[x], mapping, clientConfig, includeArray, globalRelationObjects, deleteClassId, globalScriptParams);
                 cmdbObjects.push(cmdbObject);
             }
         }
@@ -170,7 +170,7 @@ function queryCMDBObject(clientConfig, query, customFields, customOptions, inclu
     });
 }
 
-async function handleCMDBObjectResult(cmdbObject, mapping, clientConfig, includeArray, globalRelationObjects, deleteClassId) {
+async function handleCMDBObjectResult(cmdbObject, mapping, clientConfig, includeArray, globalRelationObjects, deleteClassId, globalScriptParams) {
     //get class form
     const classId = cmdbObject['Class Id'];
     if (deleteClassId === true) {
@@ -182,7 +182,7 @@ async function handleCMDBObjectResult(cmdbObject, mapping, clientConfig, include
 
     //run preScripts
     if (scripts && scripts.preMapping) {
-        await scriptController.runScripts(scripts.preMapping, cmdbObject, clientConfig.clientId);
+        await scriptController.runScripts(scripts.preMapping, cmdbObject, clientConfig.clientId, globalScriptParams);
     }
 
     //Apply mapping
@@ -236,7 +236,7 @@ async function handleCMDBObjectResult(cmdbObject, mapping, clientConfig, include
 
     //run preScripts
     if (scripts && scripts.postMapping) {
-        await scriptController.runScripts(scripts.postMapping, cmdbObject, clientConfig.clientId);
+        await scriptController.runScripts(scripts.postMapping, cmdbObject, clientConfig.clientId, globalScriptParams);
     }
 
     return cmdbObject;
@@ -272,9 +272,9 @@ async function getCMDBObjectClassAttributes(id, classId, clientConfig, mapping)
     }
 }
 
-async function getCmdbObject(config, id, includeString, mapping) {
+async function getCmdbObject(config, id, includeString, mapping, globalScriptParams) {
     const query = `'Instance Id'=\"${id}\"`;
-    const returnValue = await queryCMDBObject(config, query, null, null, includeString, mapping);
+    const returnValue = await queryCMDBObject(config, query, null, null, includeString, mapping, globalScriptParams);
     log.debug (returnValue);
     const cmdbObject = returnValue.data[0];
     return {data: cmdbObject, included: returnValue.included};
@@ -293,20 +293,20 @@ async function applyMapping(clientConfig, data) {
     return mappedRecord;
 }
 
-function searchCmdbObjectByName(config, name, includeString) {
+function searchCmdbObjectByName(config, name, includeString, globalScriptParams) {
     const query = `'Name'LIKE\"%${name}%\"`;
-    return queryCMDBObject(config, query, null, null, includeString);
+    return queryCMDBObject(config, query, null, null, includeString, globalScriptParams);
 }
 
-function searchCmdbObject(clientConfig, searchString, fields, options, includeString) {
+function searchCmdbObject(clientConfig, searchString, fields, options, includeString, globalScriptParams) {
     const mapping = config.getMapping(CMDBOBJECT);
     const mappedString = searchUtil.applyMapping(searchString, mapping);
     const customFields = searchUtil.getCustomFields(clientConfig.cmdbobject.fields, mapping, fields);
     options.sort = searchUtil.applySortMapping(options.sort, mapping);
-    return queryCMDBObject(clientConfig, mappedString, customFields, options, includeString);
+    return queryCMDBObject(clientConfig, mappedString, customFields, options, includeString, undefined, globalScriptParams);
 }
 
-async function updateCmdbObject(ticketConfig, clientConfig, id, ciData, classId) {
+async function updateCmdbObject(ticketConfig, clientConfig, id, ciData, classId, globalScriptParams) {
     const formName = classId || 'AST:BaseElement';
 
     const scripts = clientConfig[CMDBOBJECT].scripts.PUT;
@@ -314,7 +314,7 @@ async function updateCmdbObject(ticketConfig, clientConfig, id, ciData, classId)
 
     //run preScripts
     if (scripts && scripts.preMapping) {
-        await scriptController.runScripts(scripts.preMapping, ciData, clientConfig.clientId);
+        await scriptController.runScripts(scripts.preMapping, ciData, clientConfig.clientId, globalScriptParams);
     }
 
     const myClientConfig = {};
@@ -338,14 +338,14 @@ async function updateCmdbObject(ticketConfig, clientConfig, id, ciData, classId)
 
     //run postMapping
     if (scripts && scripts.postMapping) {
-        await scriptController.runScripts(scripts.postMapping, ciData, clientConfig.clientId);
+        await scriptController.runScripts(scripts.postMapping, ciData, clientConfig.clientId, globalScriptParams);
     }
 
     const update = await arquery.updateEntry(formName, ci['Request ID'], ciData);
 
     //run afterExecution
     if (scripts && scripts.afterExecution) {
-        await scriptController.runScripts(scripts.afterExecution, ciData, clientConfig.clientId);
+        await scriptController.runScripts(scripts.afterExecution, ciData, clientConfig.clientId, globalScriptParams);
     }
 
     return update;
@@ -371,7 +371,7 @@ function getClassMapping(classId) {
     return mappings;
 }
 
-async function createCmdbObject(assetConfig, clientConfig, classId, ciData) {
+async function createCmdbObject(assetConfig, clientConfig, classId, ciData, globalScriptParams) {
     const reconId = getRandomId();
     const instanceId = getRandomId();
 
@@ -380,7 +380,7 @@ async function createCmdbObject(assetConfig, clientConfig, classId, ciData) {
 
     //run preScripts
     if (scripts && scripts.preMapping) {
-        await scriptController.runScripts(scripts.preMapping, ciData, clientConfig.clientId);
+        await scriptController.runScripts(scripts.preMapping, ciData, clientConfig.clientId, globalScriptParams);
     }
 
     const mapping = getClassMapping(classId);
@@ -392,7 +392,7 @@ async function createCmdbObject(assetConfig, clientConfig, classId, ciData) {
 
     //run postMapping
     if (scripts && scripts.postMapping) {
-        await scriptController.runScripts(scripts.postMapping, ciData, clientConfig.clientId);
+        await scriptController.runScripts(scripts.postMapping, ciData, clientConfig.clientId, globalScriptParams);
     }
 
     ciData['Data Set Id'] = "BMC.ASSET"
@@ -403,7 +403,7 @@ async function createCmdbObject(assetConfig, clientConfig, classId, ciData) {
 
     //run afterExecution
     if (scripts && scripts.afterExecution) {
-        await scriptController.runScripts(scripts.afterExecution, ciData, clientConfig.clientId);
+        await scriptController.runScripts(scripts.afterExecution, ciData, clientConfig.clientId, globalScriptParams);
     }
 
     return instanceId;

package/controller/customFormController.js

@@ -12,12 +12,12 @@ const mappingUtil = require('../util/mappingUtil');
 
 const ticketCache = new CacheService(process.env.CACHETTL_TICKETS || 1); // Create a new cache service instance
 
-function getRecords(formConfig, clientConfig, includeString, customOptions) {
+function getRecords(formConfig, clientConfig, includeString, customOptions, globalScriptParams) {
     let query = '1=1';
-    return queryRecords(formConfig, clientConfig, query, null, null, customOptions, includeString);
+    return queryRecords(formConfig, clientConfig, query, null, null, customOptions, includeString, globalScriptParams);
 }
 
-async function createRecord(formConfig, clientConfig, data) {
+async function createRecord(formConfig, clientConfig, data, globalScriptParams) {
     const allScripts = clientConfig[formConfig.configName].scripts;
     let scripts
     if (allScripts) {
@@ -26,7 +26,7 @@ async function createRecord(formConfig, clientConfig, data) {
 
     //run preScripts
     if (scripts && scripts.preMapping) {
-        await scriptController.runScripts(scripts.preMapping, data, clientConfig.clientId);
+        await scriptController.runScripts(scripts.preMapping, data, clientConfig.clientId, globalScriptParams);
     }
 
     const requestType = formConfig.requestType;
@@ -40,7 +40,7 @@ async function createRecord(formConfig, clientConfig, data) {
 
     //run postScripts
     if (scripts && scripts.postMapping) {
-        await scriptController.runScripts(scripts.postMapping, data, clientConfig.clientId);
+        await scriptController.runScripts(scripts.postMapping, data, clientConfig.clientId, globalScriptParams);
     }
 
     const result = await arquery.createEntry(formConfig.formName, data, clientConfig.options)
@@ -58,12 +58,12 @@ async function createRecord(formConfig, clientConfig, data) {
 
     //run afterExecution
     if (scripts && scripts.afterExecution) {
-        await scriptController.runScripts(scripts.afterExecution, data, clientConfig.clientId);
+        await scriptController.runScripts(scripts.afterExecution, data, clientConfig.clientId, globalScriptParams);
     }
     return recordCreateId;
 }
 
-function queryRecords(formConfig, clientConfig, query, mapping, customFields, customOptions, includeString) {
+function queryRecords(formConfig, clientConfig, query, mapping, customFields, customOptions, includeString, globalScriptParams) {
     const includeArray = getIncludeArray(includeString);
     log.debug('Get config for', formConfig.configName)
     let fields = clientConfig[formConfig.configName].fields;
@@ -94,7 +94,7 @@ function queryRecords(formConfig, clientConfig, query, mapping, customFields, cu
         if (result && result.data && result.data.length) {
             let x = 0;
             for (x=0; x< result.data.length; x++) {
-                const ticket = await handleRecord(formConfig, result.data[x], mapping, clientConfig, includeArray);
+                const ticket = await handleRecord(formConfig, result.data[x], mapping, clientConfig, includeArray, globalScriptParams);
                 records.push(ticket);
             }
         }
@@ -105,7 +105,7 @@ function queryRecords(formConfig, clientConfig, query, mapping, customFields, cu
     });
 }
 
-async function handleRecord(formConfig, record, mapping, clientConfig, includeArray, globalRelationObjects) {
+async function handleRecord(formConfig, record, mapping, clientConfig, includeArray, globalScriptParams) {
     const allScripts = clientConfig[formConfig.configName].scripts;
     let scripts = [];
     if (allScripts) {
@@ -117,7 +117,7 @@ async function handleRecord(formConfig, record, mapping, clientConfig, includeAr
         const preScripts = scripts.preMapping;
         try {
             for (let x = 0; x < preScripts.length; x++) {
-                const result = await scriptController.executeScript(preScripts[x], record, null, clientConfig.clientId);
+                const result = await scriptController.executeScript(preScripts[x], record, null, clientConfig.clientId, globalScriptParams);
             }
         } catch (error) {
             throw error;
@@ -131,7 +131,7 @@ async function handleRecord(formConfig, record, mapping, clientConfig, includeAr
         const postScripts = scripts.postMapping;
         try {
             for (let x = 0; x < postScripts.length; x++) {
-                const result = await scriptController.executeScript(postScripts[x], record, null, clientConfig.clientId);
+                const result = await scriptController.executeScript(postScripts[x], record, null, clientConfig.clientId, globalScriptParams);
             }
         } catch (error) {
             throw error;
@@ -140,14 +140,14 @@ async function handleRecord(formConfig, record, mapping, clientConfig, includeAr
     return record;
 }
 
-async function getRecord(formConfig, clientConfig, id, mapping, includeString) {
+async function getRecord(formConfig, clientConfig, id, mapping, includeString, globalScriptParams) {
     const query = `'1'=\"${id}\"`;
-    const returnValue = await queryRecords(formConfig, clientConfig, query, mapping, null, null, includeString);
+    const returnValue = await queryRecords(formConfig, clientConfig, query, mapping, null, null, includeString, globalScriptParams);
     const record =  returnValue.data[0];
     return {data: record};
 }
 
-async function updateRecord(formConfig, clientConfig, id, recordData) {
+async function updateRecord(formConfig, clientConfig, id, recordData, globalScriptParams) {
     const allScripts = clientConfig[formConfig.configName].scripts;
     let scripts
     if (allScripts) {
@@ -157,7 +157,7 @@ async function updateRecord(formConfig, clientConfig, id, recordData) {
 
     //run preScripts
     if (scripts && scripts.preMapping) {
-        await scriptController.runScripts(scripts.preMapping, recordData, clientConfig.clientId);
+        await scriptController.runScripts(scripts.preMapping, recordData, clientConfig.clientId, globalScriptParams);
     }
 
     const mapping = config.getMapping(formConfig.configName);
@@ -166,25 +166,25 @@ async function updateRecord(formConfig, clientConfig, id, recordData) {
 
     //run postMapping
     if (scripts && scripts.postMapping) {
-        await scriptController.runScripts(scripts.postMapping, recordData, clientConfig.clientId);
+        await scriptController.runScripts(scripts.postMapping, recordData, clientConfig.clientId, globalScriptParams);
     }
 
     const update = await arquery.updateEntry(formConfig.formName, id, recordData);
 
     //run afterExecution
     if (scripts && scripts.afterExecution) {
-        await scriptController.runScripts(scripts.afterExecution, recordData, clientConfig.clientId);
+        await scriptController.runScripts(scripts.afterExecution, recordData, clientConfig.clientId, globalScriptParams);
     }
 
     return update;
 }
 
-function searchRecords(formConfig, clientConfig, searchString, fields, options, includeString) {
+function searchRecords(formConfig, clientConfig, searchString, fields, options, includeString, globalScriptParams) {
     const mapping = config.getMapping(formConfig.configName);
     const mappedString = searchUtil.applyMapping(searchString, mapping);
     const customFields = searchUtil.getCustomFields(clientConfig[formConfig.configName].fields, mapping, fields);
     options.sort = searchUtil.applySortMapping(options.sort, mapping);
-    return queryRecords(formConfig, clientConfig, mappedString, null, customFields, options, includeString);
+    return queryRecords(formConfig, clientConfig, mappedString, null, customFields, options, includeString, globalScriptParams);
 }
 
 module.exports = {

package/controller/relatedObjectsController.js

@@ -72,7 +72,7 @@ async function getRelatedObjects(req, res, next) {
             for (x=0; x < cmdbObjectArray.length; x++) {
                 const ciId = cmdbObjectArray[x];
                 log.debug('searchCMDBObject', ciId);
-                const cmdbObject = await cmdbObjectController.getCmdbObject(clientConfig, ciId);
+                const cmdbObject = await cmdbObjectController.getCmdbObject(clientConfig, ciId, undefined, undefined, req.globalScriptParams);
                 if (cmdbObjects !== null && cmdbObjects !== undefined && cmdbObject && cmdbObject.data) {
                     cmdbObjects.push(cmdbObject.data);
                 }
@@ -88,7 +88,7 @@ async function getRelatedObjects(req, res, next) {
                 const id = incidentArray[x];
                 log.debug('searchIncident', id);
                 const ticketConfig = config.ticketConfig["incidents"];
-                const result = await ticketController.getTicket(ticketConfig, clientConfig, id);
+                const result = await ticketController.getTicket(ticketConfig, clientConfig, id, undefined, undefined, req.globalScriptParams);
                 if (result && result.data) {
                     incidents.push(result.data);
                 }
@@ -104,7 +104,7 @@ async function getRelatedObjects(req, res, next) {
                 const id = ticketIdArray[x];
                 log.debug('searchWorkOrder', id);
                 const ticketConfig = config.ticketConfig["workorders"];
-                const result = await ticketController.getTicket(ticketConfig, clientConfig, id);
+                const result = await ticketController.getTicket(ticketConfig, clientConfig, id, undefined, undefined, req.globalScriptParams)
                 if (result && result.data) {
                     tickets.push(result.data);
                 }
@@ -120,7 +120,7 @@ async function getRelatedObjects(req, res, next) {
                 const id = ticketIdArray[x];
                 log.debug('searchProblem', id);
                 const ticketConfig = config.ticketConfig["problems"];
-                const result = await ticketController.getTicket(ticketConfig, clientConfig, id);
+                const result = await ticketController.getTicket(ticketConfig, clientConfig, id, undefined, undefined, req.globalScriptParams)
                 if (result && result.data) {
                     tickets.push(result.data);
                 }
@@ -136,7 +136,7 @@ async function getRelatedObjects(req, res, next) {
                 const id = ticketIdArray[x];
                 log.debug('searchChange', id);
                 const ticketConfig = config.ticketConfig["changes"];
-                const result = await ticketController.getTicket(ticketConfig, clientConfig, id);
+                const result = await ticketController.getTicket(ticketConfig, clientConfig, id, undefined, undefined, req.globalScriptParams)
                 if (result && result.data) {
                     tickets.push(result.data);
                 }

package/controller/scriptController.js

@@ -45,7 +45,7 @@ function recFindByExt(base,ext,files,result) {
     return result
 }
 
-async function executeScriptInternal(scriptId, requestData, params, executedByScript, clientId) {
+async function executeScriptInternal(scriptId, requestData, params, executedByScript, clientId, globalScriptParams) {
 
     const code = await getGlobalScript(scriptId);
 
@@ -53,14 +53,14 @@ async function executeScriptInternal(scriptId, requestData, params, executedBySc
         throw (`Script ${scriptId} does not exist!`);
     }
 
-    return executeCode(code, requestData, params, null, executedByScript, clientId, scriptId);
+    return executeCode(code, requestData, params, null, executedByScript, clientId, scriptId, globalScriptParams);
 }
 
-async function executeScript(scriptId, requestData, params, clientId) {
-    return executeScriptInternal(scriptId, requestData, params, false, clientId)
+async function executeScript(scriptId, requestData, params, clientId, globalScriptParams) {
+    return executeScriptInternal(scriptId, requestData, params, false, clientId, globalScriptParams)
 }
 
-async function executeCode(code, requestData, params, logStream, executedByScript, clientId, scriptId) {
+async function executeCode(code, requestData, params, logStream, executedByScript, clientId, scriptId, globalScriptParams) {
     const log = require('@manyos/logger').setupLog('SMILEcatalog_Script_' + scriptId);
     //todo should only be added once
     /*if (logStream) {
@@ -70,7 +70,7 @@ async function executeCode(code, requestData, params, logStream, executedByScrip
     //try to set user data for sandbox
 
     async function executeScriptByScript(scriptId, requestData, params) {
-        return executeScriptInternal(scriptId, requestData, params, true, clientId)
+        return executeScriptInternal(scriptId, requestData, params, true, clientId, globalScriptParams)
     }
 
     const sandbox = {
@@ -80,6 +80,7 @@ async function executeCode(code, requestData, params, logStream, executedByScrip
         log,
         clientId,
         script:executeScriptByScript,
+        globalScriptParams,
         env: process.env,
         fetch:fetch
     };
@@ -102,7 +103,7 @@ async function executeCode(code, requestData, params, logStream, executedByScrip
     try {
         const result = await vm.run(
             `return new Promise(async function(resolve, reject) {try {${code}} catch (error) {reject(error);}});`,
-            'vm.js');
+            scriptId || 'vm.js');
         log.debug('script ended', result);
         return result;
     } catch (e) {
@@ -245,10 +246,10 @@ async function getGlobalScripts() {
     return getScripts(path);
 }
 
-async function runScripts(scripts, data, clientId) {
+async function runScripts(scripts, data, clientId, globalScriptParams) {
     try {
         for (let x = 0; x < scripts.length; x++) {
-            await executeScript(scripts[x], data, undefined, clientId);
+            await executeScript(scripts[x], data, undefined, clientId, globalScriptParams);
         }
     } catch (error) {
         throw error;

package/controller/taskController.js

@@ -11,19 +11,19 @@ const scriptController = require('./scriptController');
 
 const taskCache = new CacheService(process.env.CACHETTL_TASK || 0); // Create a new cache service instance
 
-function getTasks(config, category) {
+function getTasks(config, category, globalScriptParams) {
     let query = '1=1';
     if (category)
         query = `'Category' = \"${category}\"`;
-    return queryTasks(config, query);
+    return queryTasks(config, query, globalScriptParams);
 }
 
-function getTasksByRootRequest(config, rootRequestId, rootRequestForm) {
+function getTasksByRootRequest(config, rootRequestId, rootRequestForm, globalScriptParams) {
     const query = `'RootRequestID' = \"${rootRequestId}\" AND 'RootRequestFormName' = \"${rootRequestForm}\"`;
-    return queryTasks(config, query);
+    return queryTasks(config, query, globalScriptParams);
 }
 
-async function createTask(clientConfig, rootForm, rootRequestId, taskData, createTaskFlow) {
+async function createTask(clientConfig, rootForm, rootRequestId, taskData, createTaskFlow, globalScriptParams) {
     const scripts = clientConfig.task.scripts.POST;
     const fields = clientConfig.task.fields;
 
@@ -70,21 +70,21 @@ async function createTask(clientConfig, rootForm, rootRequestId, taskData, creat
 
         //run preScripts
         if (scripts && scripts.preMapping) {
-            await scriptController.runScripts(scripts.preMapping, taskData, clientConfig.clientId);
+            await scriptController.runScripts(scripts.preMapping, taskData, clientConfig.clientId, globalScriptParams);
         }
 
         taskData = mappingUtil.applyMapping2Remedy(taskData, mapping, clientConfig.task.constants, fields);
 
         //run postScripts
         if (scripts && scripts.postMapping) {
-            await scriptController.runScripts(scripts.postMapping, taskData, clientConfig.clientId);
+            await scriptController.runScripts(scripts.postMapping, taskData, clientConfig.clientId, globalScriptParams);
         }
 
         const taskResult = await arquery.createEntry('TMS:Task', taskData, clientConfig.options)
 
         //run afterExecution
         if (scripts && scripts.afterExecution) {
-            await scriptController.runScripts(scripts.afterExecution, data, clientConfig.clientId);
+            await scriptController.runScripts(scripts.afterExecution, data, clientConfig.clientId, globalScriptParams);
         }
 
         log.debug('Create Task Result', taskResult);
@@ -113,7 +113,7 @@ async function createTask(clientConfig, rootForm, rootRequestId, taskData, creat
     }
 }
 //Todo make dynamic
-async function createWorklog(clientConfig, taskId, summary, text, attachment) {
+async function createWorklog(clientConfig, taskId, summary, text, attachment, globalScriptParams) {
     const task = await getTask(clientConfig,taskId)
     const fields = clientConfig.taskWorklog.fields;
 
@@ -140,28 +140,28 @@ async function createWorklog(clientConfig, taskId, summary, text, attachment) {
 
     //run preScripts
     if (scripts && scripts.preMapping) {
-        await scriptController.runScripts(scripts.preMapping, data, clientConfig.clientId);
+        await scriptController.runScripts(scripts.preMapping, data, clientConfig.clientId, globalScriptParams);
     }
 
     data = mappingUtil.applyMapping2Remedy(data, mapping, clientConfig.taskWorklog.constants, fields);
 
     //run postScripts
     if (scripts && scripts.postMapping) {
-        await scriptController.runScripts(scripts.postMapping, data, clientConfig.clientId);
+        await scriptController.runScripts(scripts.postMapping, data, clientConfig.clientId, globalScriptParams);
     }
 
     const result = await arquery.createEntry('TMS:WorkInfo', data, clientConfig.options)
 
     //run afterExecution
     if (scripts && scripts.afterExecution) {
-        await scriptController.runScripts(scripts.afterExecution, data, clientConfig.clientId);
+        await scriptController.runScripts(scripts.afterExecution, data, clientConfig.clientId, globalScriptParams);
     }
 
     return(result);
     //todo add attachment handling
 }
 
-function queryTasks(clientConfig, query) {
+function queryTasks(clientConfig, query, globalScriptParams) {
     const scripts = clientConfig.task.scripts.GET;
 
     const key = clientConfig.task.basequery + clientConfig.task.fields.toString() + query;
@@ -196,7 +196,7 @@ function queryTasks(clientConfig, query) {
 
                 //run preScripts
                 if (scripts && scripts.preMapping) {
-                    await scriptController.runScripts(scripts.preMapping, element, clientConfig.clientId);
+                    await scriptController.runScripts(scripts.preMapping, element, clientConfig.clientId, globalScriptParams);
                 }
 
                 //Apply mapping
@@ -212,7 +212,7 @@ function queryTasks(clientConfig, query) {
 
                 //run preScripts
                 if (scripts && scripts.postMapping) {
-                    await scriptController.runScripts(scripts.postMapping, element, clientConfig.clientId);
+                    await scriptController.runScripts(scripts.postMapping, element, clientConfig.clientId, globalScriptParams);
                 }
             }
             return ({
@@ -229,7 +229,7 @@ function queryTasks(clientConfig, query) {
     })
 }
 
-async function queryWorklogs(clientConfig, query, mapping) {
+async function queryWorklogs(clientConfig, query, mapping, globalScriptParams) {
 
     const scripts = clientConfig.taskWorklog.scripts.GET;
 
@@ -252,7 +252,7 @@ async function queryWorklogs(clientConfig, query, mapping) {
 
                 //run preScripts
                 if (scripts && scripts.preMapping) {
-                    await scriptController.runScripts(scripts.preMapping, element, clientConfig.clientId);
+                    await scriptController.runScripts(scripts.preMapping, element, clientConfig.clientId, globalScriptParams);
                 }
 
                 //Apply mapping
@@ -268,7 +268,7 @@ async function queryWorklogs(clientConfig, query, mapping) {
 
                 //run postScripts
                 if (scripts && scripts.postMapping) {
-                    await scriptController.runScripts(scripts.postMapping, element, clientConfig.clientId);
+                    await scriptController.runScripts(scripts.postMapping, element, clientConfig.clientId, globalScriptParams);
                 }
             }
             return {
@@ -280,33 +280,34 @@ async function queryWorklogs(clientConfig, query, mapping) {
     });
 }
 
-async function getTask(clientConfig, id) {
+async function getTask(clientConfig, id, globalScriptParams) {
     const query = `'Task ID'=\"${id}\"`;
-    const tasks = await queryTasks(clientConfig, query);
+    const tasks = await queryTasks(clientConfig, query, globalScriptParams);
     return tasks.data[0];
 }
 
-async function getTaskByRootRequest(config, rootRequestId, taskId) {
+async function getTaskByRootRequest(config, rootRequestId, taskId, globalScriptParams) {
     const query = `'Task ID'=\"${taskId}\" AND 'RootRequestID' = \"${rootRequestId}\"`;
-    const returnValue = await queryTasks(config, query);
+    const returnValue = await queryTasks(config, query, globalScriptParams);
     const task =  returnValue.data[0];
     return {data: task, included: returnValue.included};
 }
 
-function getTaskWorklogs(config, taskId) {
+function getTaskWorklogs(config, taskId, globalScriptParams) {
     const query = `'TaskOrTaskGroupID'=\"${taskId}\"`;
-    return queryWorklogs(config, query);
+    return queryWorklogs(config, query, undefined, globalScriptParams);
 }
 
-async function getTaskWorklog(config, taskId, worklogId) {
+//todo add scripts an
+async function getTaskWorklog(config, taskId, worklogId, globalScriptParams) {
     const query = `'TaskOrTaskGroupID'=\"${taskId}\" AND 'Work Info ID'=\"${worklogId}\"`;
-    const returnValue =  await queryWorklogs(config, query);
+    const returnValue =  await queryWorklogs(config, query, undefined, globalScriptParams);
     log.debug ('rtn', returnValue);
     const worklog =  returnValue.data[0];
     return {data: worklog, included: returnValue.included};
 }
 
-async function updateTask(clientConfig, id, taskData) {
+async function updateTask(clientConfig, id, taskData, globalScriptParams) {
     const mapping = config.getMapping('task');
     const taskConstants = clientConfig.task.constants;
     const scripts = clientConfig.task.scripts.PUT;
@@ -314,21 +315,21 @@ async function updateTask(clientConfig, id, taskData) {
 
     //run preScripts
     if (scripts && scripts.preMapping) {
-        await scriptController.runScripts(scripts.preMapping, taskData, clientConfig.clientId);
+        await scriptController.runScripts(scripts.preMapping, taskData, clientConfig.clientId, globalScriptParams);
     }
 
     taskData = mappingUtil.applyMapping2Remedy(taskData, mapping, taskConstants, fields);
 
     //run postScripts
     if (scripts && scripts.postMapping) {
-        await scriptController.runScripts(scripts.postMapping, taskData, clientConfig.clientId);
+        await scriptController.runScripts(scripts.postMapping, taskData, clientConfig.clientId, globalScriptParams);
     }
 
     const result = await arquery.updateEntry('TMS:Task', id, taskData);
 
     //run afterExecution
     if (scripts && scripts.afterExecution) {
-        await scriptController.runScripts(scripts.afterExecution, taskData, clientConfig.clientId);
+        await scriptController.runScripts(scripts.afterExecution, taskData, clientConfig.clientId, globalScriptParams);
     }
     return result;
 }