@manyos/smileconnect-api 1.38.1 → 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
     };
@@ -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;
 }

package/controller/ticketController.js

@@ -14,12 +14,12 @@ const mappingUtil = require('../util/mappingUtil');
 
 const ticketCache = new CacheService(process.env.CACHETTL_TICKETS || 1); // Create a new cache service instance
 
-function getTickets(ticketConfig, config, includeString, customOptions) {
+function getTickets(ticketConfig, config, includeString, customOptions, globalScriptParams) {
     let query = '1=1';
-    return queryTickets(ticketConfig, config, query, null, null, customOptions, includeString);
+    return queryTickets(ticketConfig, config, query, null, null, customOptions, includeString, globalScriptParams);
 }
 
-async function createTicket(ticketConfig, clientConfig, data) {
+async function createTicket(ticketConfig, clientConfig, data, globalScriptParams) {
     const scripts = clientConfig[ticketConfig.requestType].scripts.POST;
 
     //run preScripts
@@ -39,7 +39,7 @@ async function createTicket(ticketConfig, 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(ticketConfig.forms.new, data, clientConfig.options)
@@ -50,12 +50,6 @@ async function createTicket(ticketConfig, clientConfig, data) {
     const resultInterfaceCreate = await arquery.executeARQuery(ticketConfig.forms.new, null, "'1'=\"" + ticketCreateId + "\"", ticketConfig.ticketIdField, clientConfig.options)
     if (resultInterfaceCreate.data && Array.isArray(resultInterfaceCreate.data) && resultInterfaceCreate.data.length && resultInterfaceCreate.data[0][ticketConfig.ticketIdField]) {
         const ticketId = resultInterfaceCreate.data[0][ticketConfig.ticketIdField];
-        //todo fix create worklog
-        /*createWorklog(clientConfig, ticketId, 'Created', 'Incident ' + CONSTANTS.TEXT_CREATED_BY, false).then(function (worklogResult) {
-            log.debug('Worklog', worklogResult);
-        }).catch(function (error) {
-            log.error('HPD:Worklog creation error', error)
-        });*/
     } else {
         log.error('Cannot create Ticket', resultInterfaceCreate);
         throw({message: 'Cannot create Ticket', details : resultInterfaceCreate});
@@ -63,12 +57,12 @@ async function createTicket(ticketConfig, 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 resultInterfaceCreate;
 }
 
-function queryTickets(ticketConfig, clientConfig, query, mapping, customFields, customOptions, includeString) {
+function queryTickets(ticketConfig, clientConfig, query, mapping, customFields, customOptions, includeString, globalScriptParams) {
     log.debug('config', ticketConfig);
     const includeArray = getIncludeArray(includeString);
     log.debug('ticketConfig.requestType', ticketConfig.requestType);
@@ -101,7 +95,7 @@ function queryTickets(ticketConfig, clientConfig, query, mapping, customFields,
         if (result && result.data && result.data.length) {
             let x = 0;
             for (x=0; x< result.data.length; x++) {
-                const ticket = await handleTicket(ticketConfig, result.data[x], mapping, clientConfig, includeArray, globalRelationObjects);
+                const ticket = await handleTicket(ticketConfig, result.data[x], mapping, clientConfig, includeArray, globalRelationObjects, globalScriptParams);
                 tickets.push(ticket);
             }
         }
@@ -113,7 +107,7 @@ function queryTickets(ticketConfig, clientConfig, query, mapping, customFields,
     });
 }
 
-async function handleTicket(ticketConfig, ticket, mapping, clientConfig, includeArray, globalRelationObjects) {
+async function handleTicket(ticketConfig, ticket, mapping, clientConfig, includeArray, globalRelationObjects, globalScriptParams) {
     const allScripts = clientConfig[ticketConfig.requestType].scripts;
     let scripts = [];
     if (allScripts) {
@@ -136,7 +130,7 @@ async function handleTicket(ticketConfig, ticket, mapping, clientConfig, include
         const preScripts = scripts.preMapping;
         try {
             for (let x = 0; x < preScripts.length; x++) {
-                const result = await scriptController.executeScript(preScripts[x], ticket, null, clientConfig.clientId);
+                const result = await scriptController.executeScript(preScripts[x], ticket, null, clientConfig.clientId, globalScriptParams);
             }
         } catch (error) {
             throw error;
@@ -160,7 +154,7 @@ async function handleTicket(ticketConfig, ticket, mapping, clientConfig, include
         const postScripts = scripts.postMapping;
         try {
             for (let x = 0; x < postScripts.length; x++) {
-                const result = await scriptController.executeScript(postScripts[x], ticket, null, clientConfig.clientId);
+                const result = await scriptController.executeScript(postScripts[x], ticket, null, clientConfig.clientId, globalScriptParams);
             }
         } catch (error) {
             throw error;
@@ -260,7 +254,7 @@ function checkFieldsProblem(problem, globalRelationObjects) {
 }
 
 
-async function getTicket(ticketConfig, config, id, mapping, includeString) {
+async function getTicket(ticketConfig, config, id, mapping, includeString, globalScriptParams) {
     let query = '1=2';
     const requestType = ticketConfig.requestType;
     if (requestType === 'incident') {
@@ -272,18 +266,18 @@ async function getTicket(ticketConfig, config, id, mapping, includeString) {
     } else if (requestType === 'workOrder') {
         query = `'Work Order ID'=\"${id}\"`;
     }
-    const returnValue = await queryTickets(ticketConfig, config, query, mapping, null, null, includeString);
+    const returnValue = await queryTickets(ticketConfig, config, query, mapping, null, null, includeString, globalScriptParams);
     const ticket =  returnValue.data[0];
     return {data: ticket, included: returnValue.included};
 }
 
-async function updateTicket(ticketConfig, clientConfig, id, ticketData) {
+async function updateTicket(ticketConfig, clientConfig, id, ticketData, globalScriptParams) {
     const scripts = clientConfig[ticketConfig.requestType].scripts.PUT;
     const fields = clientConfig[ticketConfig.requestType].fields
 
     //run preScripts
     if (scripts && scripts.preMapping) {
-        await scriptController.runScripts(scripts.preMapping, ticketData, clientConfig.clientId);
+        await scriptController.runScripts(scripts.preMapping, ticketData, clientConfig.clientId, globalScriptParams);
     }
 
     log.debug(clientConfig[ticketConfig.requestType]);
@@ -298,10 +292,10 @@ async function updateTicket(ticketConfig, clientConfig, id, ticketData) {
 
     //run postMapping
     if (scripts && scripts.postMapping) {
-        await scriptController.runScripts(scripts.postMapping, ticketData, clientConfig.clientId);
+        await scriptController.runScripts(scripts.postMapping, ticketData, clientConfig.clientId, globalScriptParams);
     }
 
-    const ticket = await getTicket(ticketConfig, myClientConfig, id, myMapping);
+    const ticket = await getTicket(ticketConfig, myClientConfig, id, myMapping, undefined, globalScriptParams);
     log.debug('Ticket to Update', ticket);
     //todo Abfangen wenn getTicket nichts liefert.
     const update = await arquery.updateEntry(ticketConfig.forms.regular, ticket.data.internalId, ticketData);
@@ -314,12 +308,12 @@ async function updateTicket(ticketConfig, clientConfig, id, ticketData) {
     return update;
 }
 
-function searchTicket(ticketConfig, clientConfig, searchString, fields, options, includeString) {
+function searchTicket(ticketConfig, clientConfig, searchString, fields, options, includeString, globalScriptParams) {
     const mapping = config.getMapping(ticketConfig.requestType);
     const mappedString = searchUtil.applyMapping(searchString, mapping);
     const customFields = searchUtil.getCustomFields(clientConfig[ticketConfig.requestType].fields, mapping, fields);
     options.sort = searchUtil.applySortMapping(options.sort, mapping);
-    return queryTickets(ticketConfig, clientConfig, mappedString, null, customFields, options, includeString);
+    return queryTickets(ticketConfig, clientConfig, mappedString, null, customFields, options, includeString, globalScriptParams);
 }
 
 module.exports = {

package/controller/ticketWorkLogController.js

@@ -11,7 +11,7 @@ const scriptController = require('./scriptController');
 
 const ticketCache = new CacheService(process.env.CACHETTL_TICKETS || 1); // Create a new cache service instance
 
-async function createWorklog(ticketConfig, clientConfig, ticketId, summary, text, isPublic) {
+async function createWorklog(ticketConfig, clientConfig, ticketId, summary, text, isPublic, globalScriptParams) {
     const scripts = clientConfig[ticketConfig.requestTypeWorkLog].scripts.POST;
     const mapping = config.getMapping(ticketConfig.requestTypeWorkLog);
     const fields = clientConfig[ticketConfig.requestTypeWorkLog].fields;
@@ -61,21 +61,21 @@ async function createWorklog(ticketConfig, clientConfig, ticketId, summary, text
 
     //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, clientConstants, 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 = arquery.createEntry(ticketConfig.forms.workLog, 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;
@@ -102,7 +102,7 @@ function getAttachmentFieldId(attachmentId) {
     return attachmentFieldId;
 }
 
-async function getWorklogs(ticketConfig, clientConfig, ticketId, mapping) {
+async function getWorklogs(ticketConfig, clientConfig, ticketId, mapping, globalScriptParams) {
     let query = '1=2';
     const requestType = ticketConfig.requestType;
     if (requestType === 'incident') {
@@ -114,11 +114,11 @@ async function getWorklogs(ticketConfig, clientConfig, ticketId, mapping) {
     } else if (requestType === 'workOrder') {
         query = `'Work Order ID'=\"${ticketId}\"`;
     }
-    const returnValue = await queryWorklogs(ticketConfig, clientConfig, query, mapping);
+    const returnValue = await queryWorklogs(ticketConfig, clientConfig, query, mapping, globalScriptParams);
     return {data: returnValue.data};
 }
 
-async function getWorklog(ticketConfig, clientConfig, ticketId, worklogId, mapping) {
+async function getWorklog(ticketConfig, clientConfig, ticketId, worklogId, mapping, globalScriptParams) {
     let query = '1=2';
     const requestType = ticketConfig.requestType;
     if (requestType === 'incident') {
@@ -130,7 +130,7 @@ async function getWorklog(ticketConfig, clientConfig, ticketId, worklogId, mappi
     } else if (requestType === 'workOrder') {
         query = `'Work Order ID'=\"${ticketId}\" AND '1' = \"${worklogId}\"`;
     }
-    const returnValue = await queryWorklogs(ticketConfig, clientConfig, query, mapping);
+    const returnValue = await queryWorklogs(ticketConfig, clientConfig, query, mapping, globalScriptParams);
     const urls = {
         "attachmentUrl":
             `${ticketConfig.baseURI}/${ticketId}/worklogs/${worklogId}/attachments/1`
@@ -147,7 +147,7 @@ async function getWorklog(ticketConfig, clientConfig, ticketId, worklogId, mappi
     return {data: returnValue.data[0], urls};
 }
 
-async function queryWorklogs(ticketConfig, clientConfig, query, mapping) {
+async function queryWorklogs(ticketConfig, clientConfig, query, mapping, globalScriptParams) {
     const baseQuery = clientConfig[ticketConfig.requestTypeWorkLog].basequery;
     const fields = clientConfig[ticketConfig.requestTypeWorkLog].fields;
     const key = 'worklog' + baseQuery + fields.toString() + query;
@@ -169,12 +169,12 @@ async function queryWorklogs(ticketConfig, clientConfig, query, mapping) {
                 const element = result.data[x];
                 //run preScripts
                 if (scripts && scripts.preMapping) {
-                    await scriptController.runScripts(scripts.preMapping, result.data, clientConfig.clientId);
+                    await scriptController.runScripts(scripts.preMapping, result.data, clientConfig.clientId, globalScriptParams);
                 }
                 applyMapping(element, mapping, 'Entry ID');
                 //run postScripts
                 if (scripts && scripts.postMapping) {
-                    await scriptController.runScripts(scripts.postMapping, result.data, clientConfig.clientId);
+                    await scriptController.runScripts(scripts.postMapping, result.data, clientConfig.clientId, globalScriptParams);
                 }
             }
             return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manyos/smileconnect-api",
-  "version": "1.38.1",
+  "version": "1.39.0",
   "description": "A proxy and abstraction layer for BMCs IT Service Management Suite",
   "main": "app.js",
   "scripts": {

package/routes/cmdbObjectRoutes.js

@@ -59,7 +59,7 @@ module.exports = (function () {
             if (!valResult.isEmpty()) {
                 next(valResult.array());
             } else {
-                cmdbobjects.searchCmdbObject(req.user.config, req.body.searchString, req.body.fields, options, includeString).then(function (result) {
+                cmdbobjects.searchCmdbObject(req.user.config, req.body.searchString, req.body.fields, options, includeString, req.globalScriptParams).then(function (result) {
                     log.debug('result', result);
                     req.includeObjectsList = result.included;
                     req.result = {data:result.data || []};
@@ -94,7 +94,7 @@ module.exports = (function () {
             options.offset = Number.parseInt(offset);
         }
 
-        cmdbobjects.getCmdbObjects(req.user.config, category, ciIds, includeString, options).then(function (result) {
+        cmdbobjects.getCmdbObjects(req.user.config, category, ciIds, includeString, options, req.globalScriptParams).then(function (result) {
             log.debug('result', result);
             req.includeObjectsList = result.included;
             req.result = {data:result.data || []};
@@ -115,7 +115,7 @@ module.exports = (function () {
                 CONSTANTS.FORM_ASSET,
                 id
             );
-            cmdbobjects.getCmdbObject(req.user.config, id, includeString).then(function (result) {
+            cmdbobjects.getCmdbObject(req.user.config, id, includeString, undefined, req.globalScriptParams).then(function (result) {
                 log.debug('result', result);
                 req.includeObjectsList = result.included;
                 req.result = {data:result.data || {}};
@@ -183,8 +183,8 @@ module.exports = (function () {
                 const ci = req.body.data;
                 const hasAccess = await cmdbobjects.hasAccess(req.user.config, id);
                 if (hasAccess) {
-                    const result = await cmdbobjects.updateCmdbObject(req.ticketConfig, req.user.config, id, req.body.data, classId);
-                    const ci = await cmdbobjects.getCmdbObject(req.user.config, id, includeString);
+                    const result = await cmdbobjects.updateCmdbObject(req.ticketConfig, req.user.config, id, req.body.data, classId, req.globalScriptParams);
+                    const ci = await cmdbobjects.getCmdbObject(req.user.config, id, includeString, undefined, req.globalScriptParams);
                     req.result = ci;
                     next();
                 } else {
@@ -214,8 +214,8 @@ module.exports = (function () {
             //const clientConfig = config.getClientConfig(clientId);
             const result = [];
             try {
-                const ciInstanceId = await cmdbobjects.createCmdbObject(req.ticketConfig, req.user.config, classId, req.body.data);
-                const ci = await cmdbobjects.getCmdbObject(req.user.config, ciInstanceId, includeString);
+                const ciInstanceId = await cmdbobjects.createCmdbObject(req.ticketConfig, req.user.config, classId, req.body.data, req.globalScriptParams);
+                const ci = await cmdbobjects.getCmdbObject(req.user.config, ciInstanceId, includeString, undefined, req.globalScriptParams);
                 req.result = ci;
                 next();
             } catch (e) {

package/routes/customFormRoutes.js

@@ -33,7 +33,7 @@ module.exports = (function() {
             options.offset = Number.parseInt(offset);
         }
 
-        customFormController.getRecords(req.formConfig, req.user.config, includeString, options).then(function (result) {
+        customFormController.getRecords(req.formConfig, req.user.config, includeString, options, globalScriptParams).then(function (result) {
             log.debug('result', result);
             req.result = {data:result.data};
             next();
@@ -59,7 +59,7 @@ module.exports = (function() {
             req.errorStatus = 422;
             next(errors.array());
         } else {
-            customFormController.createRecord(req.formConfig, req.user.config, req.body.data).then(async function (createResult) {
+            customFormController.createRecord(req.formConfig, req.user.config, req.body.data, globalScriptParams).then(async function (createResult) {
                 const recordId = createResult;
                 eventLog.setTicketId(req, recordId);
                 req.eventData.ticketNumber = recordId;
@@ -104,7 +104,7 @@ module.exports = (function() {
         if (!valResult.isEmpty()) {
             next(valResult.array());
         } else {
-            customFormController.searchRecords(req.formConfig, req.user.config, req.body.searchString, req.body.fields, options, includeString).then(function (result) {
+            customFormController.searchRecords(req.formConfig, req.user.config, req.body.searchString, req.body.fields, options, includeString, globalScriptParams).then(function (result) {
                 log.debug('result', result);
                 req.result = {data:result.data};
                 next();
@@ -130,7 +130,7 @@ module.exports = (function() {
     });
 
     function getRecord(req, res, next, clientConfig, id, mapping, includeString) {
-        customFormController.getRecord(req.formConfig, clientConfig, id, mapping, includeString).then(function (result) {
+        customFormController.getRecord(req.formConfig, clientConfig, id, mapping, includeString, globalScriptParams).then(function (result) {
             log.debug('result', result);
             req.includeObjectsList = result.included;
             req.result = {data:result.data || {}};
@@ -160,7 +160,7 @@ module.exports = (function() {
             req.errorStatus = 422;
             next(errors.array());
         } else {
-            customFormController.updateRecord(req.formConfig, req.user.config, id, req.body.data)
+            customFormController.updateRecord(req.formConfig, req.user.config, id, req.body.data, globalScriptParams)
                 .then(async function (updateResult) {
                     getRecord(req, res, next, req.user.config, id, null, includeString);
                 }).catch(function (reason) {

package/routes/taskRoutes.js

@@ -24,7 +24,7 @@ module.exports = (function () {
             id
         );
 
-        const result = await task.getTasksByRootRequest(req.user.config, id, req.parentForm);
+        const result = await task.getTasksByRootRequest(req.user.config, id, req.parentForm, req.globalScriptParams);
         req.includeObjectsList = result.included;
         req.result = {data:result.data || {}};
 
@@ -50,7 +50,7 @@ module.exports = (function () {
             if (req.query.createTaskFlow && req.query.createTaskFlow.toLowerCase() === 'false') {
                 createTaskFlow = false;
             }
-            task.createTask(req.user.config, req.parentForm, req.parentId, req.body.data, createTaskFlow).then(async function (createResult) {
+            task.createTask(req.user.config, req.parentForm, req.parentId, req.body.data, createTaskFlow, req.globalScriptParams).then(async function (createResult) {
                 log.debug('createResult', createResult);
                 const resultKeys = Object.keys(createResult);
                 let taskResult = {};
@@ -59,7 +59,7 @@ module.exports = (function () {
                     let x=0;
                     for (x=0; x<resultKeys.length; x++) {
                         const taskId = createResult[resultKeys[x]];
-                        const result = await task.getTaskByRootRequest(req.user.config, req.parentId, taskId);
+                        const result = await task.getTaskByRootRequest(req.user.config, req.parentId, taskId, req.globalScriptParams);
                         taskResult.push(result.data);
                     }
                     //todo fix included objects
@@ -68,7 +68,7 @@ module.exports = (function () {
                     next();
                 } else {
                     const taskId = createResult['0'];
-                    task.getTaskByRootRequest(req.user.config, req.parentId, taskId).then(function (result) {
+                    task.getTaskByRootRequest(req.user.config, req.parentId, taskId, req.globalScriptParams).then(function (result) {
                         req.includeObjectsList = result.included;
                         req.result = {data:result.data || {}};
                         next();
@@ -95,7 +95,7 @@ module.exports = (function () {
             taskId
         );
 
-        const result = await task.getTaskByRootRequest(req.user.config, parentId, taskId);
+        const result = await task.getTaskByRootRequest(req.user.config, parentId, taskId, req.globalScriptParams);
         req.includeObjectsList = result.included;
         req.result = {data:result.data || {}};
         next();
@@ -118,8 +118,8 @@ module.exports = (function () {
             req.errorStatus = 422;
             next(errors.array());
         } else {
-            task.updateTask(req.user.config, taskId, req.body.data).then(function (updateResult) {
-                task.getTaskByRootRequest(req.user.config, req.parentId, taskId).then(function (result) {
+            task.updateTask(req.user.config, taskId, req.body.data, req.globalScriptParams).then(function (updateResult) {
+                task.getTaskByRootRequest(req.user.config, req.parentId, taskId, req.globalScriptParams).then(function (result) {
                     req.includeObjectsList = result.included;
                     req.result = {data:result.data || {}};
                     next();
@@ -144,7 +144,7 @@ module.exports = (function () {
             taskId
         );
 
-        const result = await task.getTaskWorklogs(req.user.config, taskId);
+        const result = await task.getTaskWorklogs(req.user.config, taskId, req.globalScriptParams);
         req.includeObjectsList = result.included;
         req.result = {data:result.data || {}};
         next();
@@ -173,10 +173,10 @@ module.exports = (function () {
             req.errorStatus = 422;
             next(errors.array());
         } else {
-            task.createWorklog(req.user.config, taskId, req.body.data.summary, req.body.data.text)
+            task.createWorklog(req.user.config, taskId, req.body.data.summary, req.body.data.text, undefined, req.globalScriptParams)
                 .then(createResult => {
                     const worklogId = createResult['0'];
-                    task.getTaskWorklog(req.user.config, taskId, worklogId).then(result => {
+                    task.getTaskWorklog(req.user.config, taskId, worklogId, req.globalScriptParams).then(result => {
                         const urls = {
                             "attachmentUrl" : `/v1/${req.parentType}/${req.parentId}/tasks/${taskId}/worklogs/${worklogId}/attachments/1`,
                             "attachmentUrl2" : `/v1/${req.parentType}/${req.parentId}/tasks/${taskId}/worklogs/${worklogId}/attachments/2`,
@@ -210,7 +210,7 @@ module.exports = (function () {
             worklogId
         );
 
-        const result = await task.getTaskWorklog(req.user.config, taskId, worklogId);
+        const result = await task.getTaskWorklog(req.user.config, taskId, worklogId, req.globalScriptParams);
         const urls = {
             "attachmentUrl" : `/v1/${req.parentType}/${req.parentId}/tasks/${taskId}/worklogs/${worklogId}/attachments/1`,
             "attachmentUrl2" : `/v1/${req.parentType}/${req.parentId}/tasks/${taskId}/worklogs/${worklogId}/attachments/2`,

package/routes/ticketRoutes.js

@@ -35,7 +35,7 @@ module.exports = (function() {
             options.offset = Number.parseInt(offset);
         }
 
-        ticketController.getTickets(req.ticketConfig, req.user.config, includeString, options).then(function (result) {
+        ticketController.getTickets(req.ticketConfig, req.user.config, includeString, options, req.globalScriptParams).then(function (result) {
             log.debug('result', result);
             req.includeObjectsList = result.included;
             req.result = {data:result.data};
@@ -63,7 +63,7 @@ module.exports = (function() {
             next(errors.array());
         } else {
             const relations = req.body.data.relations;
-            ticketController.createTicket(req.ticketConfig, req.user.config, req.body.data).then(async function (createResult) {
+            ticketController.createTicket(req.ticketConfig, req.user.config, req.body.data, req.globalScriptParams).then(async function (createResult) {
                 const ticketId = createResult.data[0][req.ticketConfig.ticketIdField];
                 eventLog.setTicketId(req, ticketId);
                 req.eventData.ticketNumber = ticketId;
@@ -109,7 +109,7 @@ module.exports = (function() {
         if (!valResult.isEmpty()) {
             next(valResult.array());
         } else {
-            ticketController.searchTicket(req.ticketConfig, req.user.config, req.body.searchString, req.body.fields, options, includeString).then(function (result) {
+            ticketController.searchTicket(req.ticketConfig, req.user.config, req.body.searchString, req.body.fields, options, includeString, req.globalScriptParams).then(function (result) {
                 log.debug('result', result);
                 req.includeObjectsList = result.included;
                 req.result = {data:result.data};
@@ -136,7 +136,7 @@ module.exports = (function() {
     });
 
     function getTicket(req, res, next, clientConfig, id, mapping, includeString) {
-        ticketController.getTicket(req.ticketConfig, clientConfig, id, mapping, includeString).then(function (result) {
+        ticketController.getTicket(req.ticketConfig, clientConfig, id, mapping, includeString, req.globalScriptParams).then(function (result) {
             log.debug('result', result);
             req.includeObjectsList = result.included;
             req.result = {data:result.data || {}};
@@ -167,7 +167,7 @@ module.exports = (function() {
             next(errors.array());
         } else {
             const relations = req.body.data.relations;
-            ticketController.updateTicket(req.ticketConfig, req.user.config, id, req.body.data)
+            ticketController.updateTicket(req.ticketConfig, req.user.config, id, req.body.data, req.globalScriptParams)
                 .then(async function (updateResult) {
                     await ticketCIRelationController.updateRelations(req.ticketConfig, req.user.config, id, relations);
                     getTicket(req, res, next, req.user.config, id, null, includeString);

package/routes/ticketWorkLogRoutes.js

@@ -23,7 +23,7 @@ module.exports = (function() {
                 id
             );
 
-            ticketWorkLogController.getWorklogs(req.ticketConfig, req.user.config, id).then(function (result) {
+            ticketWorkLogController.getWorklogs(req.ticketConfig, req.user.config, id, undefined, req.globalScriptParams).then(function (result) {
                 req.result = {
                     data: result.data
                 };
@@ -45,7 +45,7 @@ module.exports = (function() {
                 null,
                 worklogId
             );
-            ticketWorkLogController.getWorklog(req.ticketConfig, req.user.config, ticketId, worklogId).then(function (result) {
+            ticketWorkLogController.getWorklog(req.ticketConfig, req.user.config, ticketId, worklogId, undefined, req.globalScriptParams).then(function (result) {
                 req.result = result;
                 next();
             }).catch(function (reason) {
@@ -163,12 +163,12 @@ module.exports = (function() {
                 isPublic = true;
             }
 
-            ticketWorkLogController.createWorklog(req.ticketConfig, req.user.config, ticketId, req.body.data.summary, req.body.data.text, isPublic)
+            ticketWorkLogController.createWorklog(req.ticketConfig, req.user.config, ticketId, req.body.data.summary, req.body.data.text, isPublic, req.globalScriptParams)
                 .then(result => {
                     const worklogId = result['0'];
                     req.eventData.ticketNumber2 = worklogId;
                     log.debug('WorkLog created', worklogId);
-                    ticketWorkLogController.getWorklog(req.ticketConfig, req.user.config, ticketId, worklogId).then(worklogResult => {
+                    ticketWorkLogController.getWorklog(req.ticketConfig, req.user.config, ticketId, worklogId, undefined, req.globalScriptParams).then(worklogResult => {
                         req.result = worklogResult;
                         next();
                     });