@manyos/smileconnect-api 1.28.0

package/controller/scriptController.js

@@ -0,0 +1,213 @@
+const path = require('path');
+const log = require('@manyos/logger').setupLog('SMILEcatalog_' + path.basename(__filename));
+
+const fs = require('fs');
+
+const basePath = 'conf';
+const basePathGlobalScripts = basePath + '/scripts';
+
+require('dotenv').config();
+const {NodeVM} = require('vm2');
+
+//const adapter = require('../util/adapter').getAdapter();
+
+function recFindByExt(base,ext,files,result) {
+    const isRoot = (files == undefined);
+    files = files || fs.readdirSync(base)
+    result = result || []
+
+    files.forEach(
+        function (file) {
+            const newbase = path.join(base,file)
+
+            if ( fs.statSync(newbase).isDirectory() ) {
+                result = recFindByExt(newbase,ext,fs.readdirSync(newbase),result)
+            }
+            else {
+                if ( file.substr(-1*(ext.length+1)) == '.' + ext ) {
+                    result.push(newbase)
+                }
+            }
+        }
+    )
+    //only in root
+    if (isRoot) {
+        result = result.map(item => item.replace(base, ''));
+    }
+    return result
+}
+
+async function executeScriptInternal(scriptId, requestData, params, executedByScript) {
+
+    const code = await getGlobalScript(scriptId);
+
+    if (code == undefined || !code) {
+        throw (`Script ${scriptId} does not exist!`);
+    }
+
+    return executeCode(code, requestData, params, null, executedByScript);
+}
+
+async function executeScript(scriptId, requestData, params) {
+    return executeScriptInternal(scriptId, requestData, params, false)
+}
+
+async function executeCode(code, requestData, params, logStream, executedByScript) {
+    //todo should only be added once
+    /*if (logStream) {
+        log.addStream(logStream);
+    }*/
+
+    //try to set user data for sandbox
+
+    async function executeScriptByScript(scriptId, requestData, params) {
+        return executeScriptInternal(scriptId, requestData, params, true)
+    }
+
+    const sandbox = {
+        requestData,
+        params,
+        log,
+        script:executeScriptByScript,
+        env: {}//process.env
+    };
+
+    sandbox.executedByScript = executedByScript === true;
+
+    const vm = new NodeVM({
+        require: {
+            external: true
+        },
+        sandbox: sandbox,
+        wrapper: "none"
+    });
+
+    log.debug('Create vm with sandbox', sandbox);
+
+    log.debug('run Script', code);
+
+    //todo Add timeout
+    try {
+        const result = await vm.run(
+            `return new Promise(async function(resolve, reject) {try {${code}} catch (error) {reject(error);}});`,
+            'vm.js');
+        log.debug('script ended', result);
+        return result;
+    } catch (e) {
+        throw e;
+    }
+}
+
+async function getGlobalScript(scriptId) {
+    const fileName = basePathGlobalScripts + `/${scriptId}.js`;
+    return readScriptFromFile(fileName);
+}
+
+async function setGlobalScript(scriptId, code) {
+    return setScript(basePathGlobalScripts, scriptId, code);
+}
+
+async function setScript(dir, scriptId, code) {
+    //create folder first
+    log.debug('Create dir', dir);
+    if (!fs.existsSync(dir)){
+        fs.mkdirSync(dir);
+    }
+    //create subfolders
+    const scriptIdSplit = scriptId.split('/');
+    if (scriptIdSplit && scriptIdSplit.length > 1) {
+        let subDirName = dir;
+        for (x=0; x<scriptIdSplit.length -1; x++) {
+            subDirName = subDirName + '/' + scriptIdSplit[x];
+            if (!fs.existsSync(subDirName)){
+                fs.mkdirSync(subDirName);
+            }
+        }
+    }
+
+    //create file
+    const fileName = `${dir}/${scriptId}.js`;
+    log.debug('Write file', fileName);
+    return new Promise((res, rej) => {
+        fs.writeFile(fileName, code, (err) => {
+            if (err) {
+                rej(err);
+            }
+            log.debug(`script written: ${fileName}`);
+            res(true);
+        });
+    });
+}
+
+async function deleteScript(dir, scriptId) {
+    return new Promise((res, rej) => {
+        fs.unlink(`${dir}/${scriptId}.js`, (err) => {
+            if (err) {
+                rej(err);
+            }
+            log.debug(`script removed: ${dir}/${scriptId}`);
+            res({
+                id: scriptId,
+                status: "deleted"
+            });
+        });
+    });
+}
+
+async function deleteGlobalScript(scriptId) {
+    return deleteScript(basePathGlobalScripts, scriptId);
+}
+
+async function readScriptFromFile(fileName) {
+    log.debug('Read file', fileName);
+    const script = fs.readFileSync(fileName,{encoding: 'utf8'});
+    log.debug('found script', script);
+    return script;
+}
+
+async function getScripts(pathName, catalogType, catalogId) {
+    const files = recFindByExt(pathName,'js')
+    const scriptNames = files.map(file => file.substr(0, file.length-3));
+    log.debug(scriptNames);
+    const scripts = [];
+    for (let x=0; x<scriptNames.length; x++) {
+        if (!catalogType) {
+            const script = {
+                id: scriptNames[x],
+                code: await getGlobalScript(scriptNames[x])
+            };
+            scripts.push(script);
+        } else {
+            const script = {
+                id: scriptNames[x],
+                code: await getCatalogScript(catalogType, catalogId, scriptNames[x])
+            };
+            scripts.push(script);
+        }
+    }
+    return scripts;
+}
+
+async function getGlobalScripts() {
+    const path = `${basePathGlobalScripts}/`;
+    return getScripts(path);
+}
+
+async function runScripts(scripts, data) {
+    try {
+        for (let x = 0; x < scripts.length; x++) {
+            await executeScript(scripts[x], data);
+        }
+    } catch (error) {
+        throw error;
+    }
+}
+
+module.exports = {
+    executeScript,
+    getGlobalScript,
+    getGlobalScripts,
+    setGlobalScript,
+    deleteGlobalScript,
+    runScripts
+};

package/controller/taskController.js

@@ -0,0 +1,368 @@
+require('dotenv').config();
+const path = require('path');
+const log = require('@manyos/logger').setupLog('SMILEconnect_' + path.basename(__filename));
+const arquery = require('../util/arquery');
+const CacheService = require ('../util/cache.service');
+const config = require('../util/config');
+const CONSTANTS = require('../util/constants');
+const relationUtil = require('../util/relationUtil');
+const mappingUtil = require('../util/mappingUtil');
+const scriptController = require('./scriptController');
+
+const taskCache = new CacheService(process.env.CACHETTL_TASK || 0); // Create a new cache service instance
+
+function getTasks(config, category) {
+    let query = '1=1';
+    if (category)
+        query = `'Category' = \"${category}\"`;
+    return queryTasks(config, query);
+}
+
+function getTasksByRootRequest(config, rootRequestId, rootRequestForm) {
+    const query = `'RootRequestID' = \"${rootRequestId}\" AND 'RootRequestFormName' = \"${rootRequestForm}\"`;
+    return queryTasks(config, query);
+}
+
+async function createTask(clientConfig, rootForm, rootRequestId, taskData, createTaskFlow) {
+    const scripts = clientConfig.task.scripts.POST;
+    const fields = clientConfig.task.fields;
+
+    log.debug('data', taskData);
+    let subQuery = "'1' = \"rootRequestId\"";
+    if (rootForm === CONSTANTS.FORM_WORKORDER) {
+        subQuery = `'Work Order ID'=\"${rootRequestId}\"`;
+    } else if (rootForm === CONSTANTS.FORM_INCIDENT) {
+        subQuery = `'Incident Number'=\"${rootRequestId}\"`;
+    } else if (rootForm === CONSTANTS.FORM_PROBLEM) {
+    subQuery = `'Problem Investigation ID'=\"${rootRequestId}\"`;
+    } else if (rootForm === CONSTANTS.FORM_CHANGE) {
+        subQuery = `'Infrastructure Change ID'=\"${rootRequestId}\"`;
+    }
+    //Read instanceId from Root request
+
+    const rootRequest = await arquery.executeARQuery(rootForm, null, subQuery, "InstanceId", clientConfig.options)
+    log.debug('found RootRequest', rootRequest);
+    if (rootRequest.data && Array.isArray(rootRequest.data)) {
+        let allTask = [];
+        if (Array.isArray(taskData)) {
+            allTask = taskData;
+        } else {
+            allTask.push(taskData);
+        }
+
+        const mapping = config.getMapping('newTask');
+        //add required data
+
+        const allTaskFinal = [];
+        allTask.forEach(thisTask => {
+            thisTask.TaskName = thisTask.summary;
+            thisTask.TaskType = 2000;
+            thisTask.Status = 1000;
+            thisTask.RootRequestFormName = rootForm;
+            thisTask.RootRequestMode = "1";
+            thisTask.RootRequestName = rootRequestId;
+            thisTask.RootRequestInstanceId = rootRequest.data[0]['InstanceId'];
+            thisTask.sequence = thisTask.sequence || "1";
+            allTaskFinal.push(thisTask);
+        });
+
+        fields.push('TaskName', 'RootRequestInstanceId', 'TaskType', 'Status', 'RootRequestFormName', 'RootRequestMode', 'RootRequestName', 'sequence')
+
+        //run preScripts
+        if (scripts && scripts.preMapping) {
+            await scriptController.runScripts(scripts.preMapping, taskData);
+        }
+
+        taskData = mappingUtil.applyMapping2Remedy(taskData, mapping, clientConfig.task.constants, fields);
+
+        //run postScripts
+        if (scripts && scripts.postMapping) {
+            await scriptController.runScripts(scripts.postMapping, taskData);
+        }
+
+        const taskResult = await arquery.createEntry('TMS:Task', taskData, clientConfig.options)
+
+        //run afterExecution
+        if (scripts && scripts.afterExecution) {
+            await scriptController.runScripts(scripts.afterExecution, data);
+        }
+
+        log.debug('Create Task Result', taskResult);
+        let flowBuilderRequest = {
+            "RootRequestFormName" : rootForm,
+            "RootRequestName" : rootRequestId,
+            "RootRequestInstanceId" : rootRequest.data[0]['InstanceId'],
+            "zTmpInternalCommand" : "CREATE",
+            "Parent Type" : "0",
+            "ParentID" : rootRequest.data[0]['InstanceId'],
+            "Parent Name" : rootRequestId
+        };
+        log.debug('createFlow', createTaskFlow === true);
+        if (createTaskFlow != null && createTaskFlow === true ) {
+            const mappingflow = config.getMapping('flowBuilder');
+
+            flowBuilderRequest = mappingUtil.applyMapping2Remedy(flowBuilderRequest, mappingflow, clientConfig.flowBuilder.constants);
+
+            const taskFlowResult = await arquery.createEntry('TMS:FlowBuilder', flowBuilderRequest, clientConfig.options)
+            log.debug('TaskFlowBuilder Result', taskFlowResult);
+            return taskResult;
+        } else {
+            log.debug('Task flow update not requested');
+            return taskResult;
+        }
+    }
+}
+
+async function createWorklog(clientConfig, taskId, summary, text, attachment) {
+    const task = await getTask(clientConfig,taskId)
+    const fields = clientConfig.taskWorklog.fields;
+
+    const taskInstanceId = task.instanceId;
+
+    const scripts = clientConfig.taskWorklog.scripts.POST;
+
+    const mapping = config.getMapping('taskWorklog');
+
+    log.debug('mapping', mapping);
+    let data = {
+        "Secure Log" : "Yes",
+        "summary" : summary,
+        "text" : text,
+        "TaskOrTaskGroupID" : taskId,
+        "TaskOrTaskGroupInstanceId" : taskInstanceId
+    };
+
+    fields.push(
+        'Secure Log',
+        'TaskOrTaskGroupID',
+        'TaskOrTaskGroupInstanceId'
+    );
+
+    //run preScripts
+    if (scripts && scripts.preMapping) {
+        await scriptController.runScripts(scripts.preMapping, data);
+    }
+
+    data = mappingUtil.applyMapping2Remedy(data, mapping, clientConfig.taskWorklog.constants, fields);
+
+    //run postScripts
+    if (scripts && scripts.postMapping) {
+        await scriptController.runScripts(scripts.postMapping, data);
+    }
+
+    const result = await arquery.createEntry('TMS:WorkInfo', data, clientConfig.options)
+
+    //run afterExecution
+    if (scripts && scripts.afterExecution) {
+        await scriptController.runScripts(scripts.afterExecution, data);
+    }
+
+    return(result);
+    //todo add attachment handling
+}
+
+function queryTasks(clientConfig, query) {
+    const scripts = clientConfig.task.scripts.GET;
+
+    const key = clientConfig.task.basequery + clientConfig.task.fields.toString() + query;
+    log.debug('Cachekey is', key);
+
+    const mapping = config.getMapping('task');
+    log.debug('mapping', mapping);
+
+    return taskCache.get(key, async function () {
+        const result = await arquery.executeARQuery('TMS:Task', clientConfig.task.basequery || null, query, clientConfig.task.fields.toString() || '1', clientConfig.options)
+        const globalRelationObjects = relationUtil.prepareGlobalRelationObject();
+        if (result.data && Array.isArray(result.data)) {
+            let x;
+            for (x=0; x< result.data.length; x++) {
+                const element = result.data[x];
+                //check for included objects
+                const customerId = element['Customer Person ID'];
+                if (customerId != null && customerId !== undefined)
+                    globalRelationObjects.persons.add(customerId);
+
+                const supportGroupId = element['Support Group ID'];
+                if (supportGroupId != null && supportGroupId !== undefined)
+                    globalRelationObjects.supportgroups.add(supportGroupId);
+
+                const supportGroupId2 = element['Support Group ID 2'];
+                if (supportGroupId2 != null && supportGroupId2 !== undefined)
+                    globalRelationObjects.supportgroups.add(supportGroupId2);
+
+                const requestorId = element['Requested By Person ID'];
+                if (requestorId != null && requestorId !== undefined)
+                    globalRelationObjects.supportgroups.add(requestorId);
+
+                //run preScripts
+                if (scripts && scripts.preMapping) {
+                    await scriptController.runScripts(scripts.preMapping, element);
+                }
+
+                //Apply mapping
+                mapping.forEach(function (mappingEntry) {
+                    try {
+                        Object.defineProperty(element, mappingEntry.newName, Object.getOwnPropertyDescriptor(element, mappingEntry.oldName));
+                        delete element[mappingEntry.oldName];
+                    } catch (e) {
+                        //ignore missing mapping
+                    }
+                });
+                delete element['Request ID'];
+
+                //run preScripts
+                if (scripts && scripts.postMapping) {
+                    await scriptController.runScripts(scripts.postMapping, element);
+                }
+            }
+            return ({
+                "data": result.data,
+                "included": {
+                    "persons": Array.from(globalRelationObjects.persons),
+                    "organisations": Array.from(globalRelationObjects.organisations),
+                    "supportgroups": Array.from(globalRelationObjects.supportgroups)
+                }});
+        }
+        else {
+            return ({"data":[]});
+        }
+    })
+}
+
+async function queryWorklogs(clientConfig, query, mapping) {
+
+    const scripts = clientConfig.taskWorklog.scripts.GET;
+
+    const fields = clientConfig.taskWorklog.fields;
+    const basequery = clientConfig.taskWorklog.basequery;
+    const key = 'worklog' + basequery + fields.toString() + query;
+    log.debug('Cachekey is ', key);
+    if (mapping == null || mapping == undefined) {
+        mapping = config.getMapping('taskWorklog');
+    }
+    log.debug('mapping', mapping);
+    log.debug('fields', fields);
+
+    return taskCache.get(key, async function () {
+        const result = await arquery.executeARQuery(CONSTANTS.FORM_TASK_WORKLOG, basequery || null, query, fields.toString() || '1', clientConfig.options)
+        if (result.data && Array.isArray(result.data)) {
+            let x;
+            for (x=0; x< result.data.length; x++) {
+                const element = result.data[x];
+
+                //run preScripts
+                if (scripts && scripts.preMapping) {
+                    await scriptController.runScripts(scripts.preMapping, element);
+                }
+
+                //Apply mapping
+                mapping.forEach(function (mappingEntry) {
+                    try {
+                        Object.defineProperty(element, mappingEntry.newName, Object.getOwnPropertyDescriptor(element, mappingEntry.oldName));
+                        delete element[mappingEntry.oldName];
+                    } catch (e) {
+                        //ignore missing mapping
+                    }
+                });
+                //delete element['Entry ID'];
+
+                //run postScripts
+                if (scripts && scripts.postMapping) {
+                    await scriptController.runScripts(scripts.postMapping, element);
+                }
+            }
+            return {
+                "data": result.data
+            };
+        } else {
+            return {"data":[]};
+        }
+    });
+}
+
+async function getTask(clientConfig, id) {
+    const query = `'Task ID'=\"${id}\"`;
+    const tasks = await queryTasks(clientConfig, query);
+    return tasks.data[0];
+}
+
+async function getTaskByRootRequest(config, rootRequestId, taskId) {
+    const query = `'Task ID'=\"${taskId}\" AND 'RootRequestID' = \"${rootRequestId}\"`;
+    const returnValue = await queryTasks(config, query);
+    const task =  returnValue.data[0];
+    return {data: task, included: returnValue.included};
+}
+
+function getTaskWorklogs(config, taskId) {
+    const query = `'TaskOrTaskGroupID'=\"${taskId}\"`;
+    return queryWorklogs(config, query);
+}
+
+async function getTaskWorklog(config, taskId, worklogId) {
+    const query = `'TaskOrTaskGroupID'=\"${taskId}\" AND 'Work Info ID'=\"${worklogId}\"`;
+    const returnValue =  await queryWorklogs(config, query);
+    log.debug ('rtn', returnValue);
+    const worklog =  returnValue.data[0];
+    return {data: worklog, included: returnValue.included};
+}
+
+async function updateTask(clientConfig, id, taskData) {
+    const mapping = config.getMapping('task');
+    const taskConstants = clientConfig.task.constants;
+    const scripts = clientConfig.task.scripts.PUT;
+    const fields = clientConfig.task.fields;
+
+    //run preScripts
+    if (scripts && scripts.preMapping) {
+        await scriptController.runScripts(scripts.preMapping, taskData);
+    }
+
+    taskData = mappingUtil.applyMapping2Remedy(taskData, mapping, taskConstants, fields);
+
+    //run postScripts
+    if (scripts && scripts.postMapping) {
+        await scriptController.runScripts(scripts.postMapping, taskData);
+    }
+
+    const result = await arquery.updateEntry('TMS:Task', id, taskData);
+
+    //run afterExecution
+    if (scripts && scripts.afterExecution) {
+        await scriptController.runScripts(scripts.afterExecution, taskData);
+    }
+    return result;
+}
+
+function setWorklogAttachment(clientConfig, worklogId, file, attachmentId) {
+    const fieldId = getAttachmentFieldId(attachmentId);
+    return arquery.setAttachment(CONSTANTS.FORM_TASK_WORKLOG, worklogId, fieldId, file);
+}
+
+function getWorklogAttachment(clientConfig, worklogId, attachmentId) {
+    const fieldId = getAttachmentFieldId(attachmentId);
+    return arquery.getAttachment(CONSTANTS.FORM_TASK_WORKLOG, worklogId, fieldId);
+}
+
+function getAttachmentFieldId(attachmentId) {
+    let attachmentFieldId = 10001831;
+    if (attachmentId == 2) {
+        attachmentFieldId = 10001832;
+    } else if (attachmentId == 3) {
+        attachmentFieldId = 10001833;
+    }
+    log.debug('AttachmentFieldId', attachmentFieldId);
+    return attachmentFieldId;
+}
+
+module.exports = {
+    getTaskByRootRequest,
+    getTasks,
+    getTaskWorklogs,
+    getTaskWorklog,
+    updateTask,
+    createTask,
+    getTasksByRootRequest,
+    createWorklog,
+    setWorklogAttachment,
+    getWorklogAttachment
+};

package/controller/templateController.js

@@ -0,0 +1,97 @@
+require('dotenv').config();
+const path = require('path');
+const log = require('@manyos/logger').setupLog('SMILEconnect_' + path.basename(__filename));
+const arquery = require('../util/arquery');
+const CacheService = require ('../util/cache.service');
+const config = require('../util/config');
+const {getIncludeArray, applyMapping} = require('../util/paramHelper');
+const relationUtil = require('../util/relationUtil');
+
+const templateCache = new CacheService(process.env.CACHETTL_TEMPLATE || 1); // Create a new cache service instance
+
+function getTemplates(ticketConfig, config, includeString, customOptions) {
+    let query = '1=1';
+    return queryTemplates(ticketConfig, config, query, null, null, customOptions, includeString);
+}
+
+function queryTemplates(ticketConfig, clientConfig, query, mapping, customFields, customOptions, includeString) {
+    log.debug('config', ticketConfig);
+    const includeArray = getIncludeArray(includeString);
+    log.debug('ticketConfig.requestType', ticketConfig.requestType);
+    let fields = clientConfig[ticketConfig.requestTemplate].fields;
+
+    log.debug('fieldi', fields);
+    log.debug('else', ticketConfig.requestTemplate);
+    const baseQuery = clientConfig[ticketConfig.requestTemplate].basequery;
+
+    //check for customFields
+    if (customFields !== null && customFields !== undefined) {
+        fields = customFields;
+    }
+
+    log.debug('fields', fields, customFields);
+    const options = {
+        ...clientConfig.options, ...customOptions
+
+    };
+
+    log.debug('use joined options', options);
+
+    const key = baseQuery + fields.toString() + query + JSON.stringify(options) + includeArray;
+    log.debug('Cachekey is ', key);
+    if (mapping == null || mapping == undefined) {
+        mapping = config.getMapping(ticketConfig.requestTemplate);
+    }
+    log.debug('mapping', mapping);
+
+    return templateCache.get(key, async function () {
+        const result = await arquery.executeARQuery(ticketConfig.forms.template, baseQuery || null, query, fields.toString() || '1', options);
+        const globalRelationObjects = relationUtil.prepareGlobalRelationObject();
+        const tickets = [];
+        if (result && result.data && result.data.length) {
+            let x = 0;
+            for (x=0; x< result.data.length; x++) {
+                //const ticket = await handleTemplate(ticketConfig, result.data[x], mapping, clientConfig, includeArray, globalRelationObjects);
+                const ticket = result.data[x];
+                applyMapping(ticket, mapping, ticketConfig.templateRequestId);
+                tickets.push(ticket);
+            }
+        }
+        log.debug('tickets', tickets);
+        return {
+            "data": tickets,
+            "included": globalRelationObjects
+        };
+    });
+}
+
+async function getTemplate(ticketConfig, config, id, mapping, includeString) {
+    let query = `'179'="${id}"`;
+    /*const requestType = ticketConfig.requestType;
+    if (requestType === 'incident') {
+        query = `'HPD Template ID'=\"${id}\"`;
+    } else if (requestType === 'change') {
+        query = `'Infrastructure Change ID'=\"${id}\"`;
+    } else if (requestType === 'problem') {
+        query = `'Problem Investigation ID'=\"${id}\"`;
+    } else if (requestType === 'workOrder') {
+        query = `'Work Order ID'=\"${id}\"`;
+    }*/
+    const returnValue = await queryTemplates(ticketConfig, config, query, mapping, null, null, includeString);
+    const ticket =  returnValue.data[0];
+    return {data: ticket, included: returnValue.included};
+}
+
+/*
+function searchTicket(ticketConfig, clientConfig, searchString, fields, options, includeString) {
+    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);
+}*/
+
+module.exports = {
+    getTemplate,
+    getTemplates
+};