@manyos/smileconnect-api 1.28.0

package/controller/ticketController.js

@@ -0,0 +1,329 @@
+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 searchUtil = require('../util/searchUtil');
+const {getIncludeArray, applyMapping} = require('../util/paramHelper');
+const relationUtil = require('../util/relationUtil');
+const ticketCIRelationController = require('./ticketCIRelationController');
+const scriptController = require('./scriptController');
+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) {
+    let query = '1=1';
+    return queryTickets(ticketConfig, config, query, null, null, customOptions, includeString);
+}
+
+async function createTicket(ticketConfig, clientConfig, data) {
+    const scripts = clientConfig[ticketConfig.requestType].scripts.POST;
+
+    //run preScripts
+    if (scripts && scripts.preMapping) {
+        await scriptController.runScripts(scripts.preMapping, data);
+    }
+
+    const requestType = ticketConfig.requestType;
+    const newRequestType = 'new' + requestType.charAt(0).toUpperCase() + requestType.slice(1);
+
+    const mapping = config.getMapping(newRequestType);
+    log.debug('mapping', mapping);
+
+    const fields = mappingUtil.getFieldsForCreate(config.getMapping(requestType), mapping, clientConfig[requestType].fields)
+
+    data = mappingUtil.applyMapping2Remedy(data, mapping, clientConfig[ticketConfig.requestType].constants, fields);
+
+    //run postScripts
+    if (scripts && scripts.postMapping) {
+        await scriptController.runScripts(scripts.postMapping, data);
+    }
+
+    const result = await arquery.createEntry(ticketConfig.forms.new, data, clientConfig.options)
+
+    log.debug('TicketCreateResult', result.data);
+    const ticketCreateId = Object.values(result)[0];
+    //Find change id
+    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});
+    }
+
+    //run afterExecution
+    if (scripts && scripts.afterExecution) {
+        await scriptController.runScripts(scripts.afterExecution, data);
+    }
+    return resultInterfaceCreate;
+}
+
+function queryTickets(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.requestType].fields;
+    const baseQuery = clientConfig[ticketConfig.requestType].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.requestType);
+    }
+    log.debug('mapping', mapping);
+
+    return ticketCache.get(key, async function () {
+        const result = await arquery.executeARQuery(ticketConfig.forms.regular, 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 handleTicket(ticketConfig, result.data[x], mapping, clientConfig, includeArray, globalRelationObjects);
+                tickets.push(ticket);
+            }
+        }
+        log.debug('tickets', tickets);
+        return {
+            "data": tickets,
+            "included": globalRelationObjects
+        };
+    });
+}
+
+async function handleTicket(ticketConfig, ticket, mapping, clientConfig, includeArray, globalRelationObjects) {
+    const allScripts = clientConfig[ticketConfig.requestType].scripts;
+    let scripts = [];
+    if (allScripts) {
+        scripts = allScripts.GET || [];
+    }
+
+    const requestType = ticketConfig.requestType;
+    if (requestType === 'incident') {
+        checkFieldsIncident(ticket, globalRelationObjects);
+    } else if (requestType === 'change') {
+        checkFieldsChange(ticket, globalRelationObjects);
+    } else if (requestType === 'problem') {
+        checkFieldsProblem(ticket, globalRelationObjects);
+    } else if (requestType === 'workOrder') {
+        checkFieldsWorkOrder(ticket, globalRelationObjects);
+    }
+
+    //run preScripts
+    if (scripts && scripts.preMapping) {
+        const preScripts = scripts.preMapping;
+        try {
+            for (let x = 0; x < preScripts.length; x++) {
+                const result = await scriptController.executeScript(preScripts[x], ticket);
+            }
+        } catch (error) {
+            throw error;
+        }
+    }
+
+    applyMapping(ticket, mapping, ticketConfig.requestIdField);
+
+    ticket.relations = {};
+    if (includeArray.includes('ciRelations')) {
+        const relations = await ticketCIRelationController.getTicketCIRelations(ticket.id);
+        ticket.relations.ciRelations = relations;
+    }
+    if (includeArray.includes('ticketRelations')) {
+        const relations = await ticketCIRelationController.getTicket2TicketRelations(ticketConfig, ticket.id);
+        ticket.relations.ticketRelations = relations;
+    }
+    relationUtil.getRelatedObjectList(ticket, includeArray, globalRelationObjects);
+    //run postScripts
+    if (scripts && scripts.postMapping) {
+        const postScripts = scripts.postMapping;
+        try {
+            for (let x = 0; x < postScripts.length; x++) {
+                const result = await scriptController.executeScript(postScripts[x], ticket);
+            }
+        } catch (error) {
+            throw error;
+        }
+    }
+    return ticket;
+}
+
+function checkFieldsIncident(incident, globalRelationObjects) {
+    //check for included objects
+    const customerId = incident['Person ID'];
+    if (customerId != null && customerId !== undefined)
+        globalRelationObjects.persons.add(customerId);
+
+    const contactId = incident['Direct Contact Person ID'];
+    if (contactId != null && contactId !== undefined)
+        globalRelationObjects.persons.add(contactId);
+
+    const requestorId = incident['Requested By Person ID'];
+    if (requestorId != null && requestorId !== undefined)
+        globalRelationObjects.persons.add(requestorId);
+
+    const supportGroupId = incident['Assigned Group ID'];
+    if (supportGroupId != null && supportGroupId !== undefined)
+        globalRelationObjects.supportgroups.add(supportGroupId);
+
+    const ownerGroup = incident['Owner Group ID'];
+    if (ownerGroup != null && ownerGroup !== undefined)
+        globalRelationObjects.supportgroups.add(ownerGroup);
+
+    const vendorGroupId = incident['Vendor Group ID'];
+    if (vendorGroupId != null && vendorGroupId !== undefined)
+        globalRelationObjects.supportgroups.add(vendorGroupId);
+}
+
+function checkFieldsWorkOrder(workOrder, globalRelationObjects) {
+    const customerId = workOrder['Customer Person ID'];
+    if (customerId != null && customerId !== undefined)
+        globalRelationObjects.persons.add(customerId);
+
+    const requestorId = workOrder['Requested By Person ID'];
+    if (requestorId != null && requestorId !== undefined)
+        globalRelationObjects.persons.add(requestorId);
+
+    const supportGroupId = workOrder['Support Group ID'];
+    if (supportGroupId != null && supportGroupId !== undefined)
+        globalRelationObjects.supportgroups.add(supportGroupId);
+
+    const supportGroupId2 = workOrder['Support Group ID 2'];
+    if (supportGroupId2 != null && supportGroupId2 !== undefined)
+        globalRelationObjects.supportgroups.add(supportGroupId2);
+}
+
+function checkFieldsChange(change, globalRelationObjects) {
+    //check for included objects
+    const customerId = change['Customer Person ID'];
+    if (customerId != null && customerId !== undefined)
+        globalRelationObjects.persons.add(customerId);
+
+    const requestorId = change['Requested By Person ID'];
+    if (requestorId != null && requestorId !== undefined)
+        globalRelationObjects.persons.add(requestorId);
+
+    const supportGroupId = change['Support Group ID'];
+    if (supportGroupId != null && supportGroupId !== undefined)
+        globalRelationObjects.supportgroups.add(supportGroupId);
+
+    const supportGroupId2 = change['Support Group ID 2'];
+    if (supportGroupId2 != null && supportGroupId2 !== undefined)
+        globalRelationObjects.supportgroups.add(supportGroupId2);
+}
+
+function checkFieldsProblem(problem, globalRelationObjects) {
+    const customerId = problem['Person ID'];
+    if (customerId != null && customerId !== undefined)
+        globalRelationObjects.persons.add(customerId);
+
+    const contactId = problem['Direct Contact Person ID'];
+    if (contactId != null && contactId !== undefined)
+        globalRelationObjects.persons.add(contactId);
+
+    const requestorId = problem['Requested By Person ID'];
+    if (requestorId != null && requestorId !== undefined)
+        globalRelationObjects.persons.add(requestorId);
+
+    const supportGroupId = problem['Assigned Group ID'];
+    if (supportGroupId != null && supportGroupId !== undefined)
+        globalRelationObjects.supportgroups.add(supportGroupId);
+
+    const ownerGroup = problem['Owner Group ID'];
+    if (ownerGroup != null && ownerGroup !== undefined)
+        globalRelationObjects.supportgroups.add(ownerGroup);
+
+    const vendorGroupId = problem['Vendor Group ID'];
+    if (vendorGroupId != null && vendorGroupId !== undefined)
+        globalRelationObjects.supportgroups.add(vendorGroupId);
+}
+
+
+async function getTicket(ticketConfig, config, id, mapping, includeString) {
+    let query = '1=2';
+    const requestType = ticketConfig.requestType;
+    if (requestType === 'incident') {
+        query = `'Incident Number'=\"${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 queryTickets(ticketConfig, config, query, mapping, null, null, includeString);
+    const ticket =  returnValue.data[0];
+    return {data: ticket, included: returnValue.included};
+}
+
+async function updateTicket(ticketConfig, clientConfig, id, ticketData) {
+    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);
+    }
+
+    log.debug(clientConfig[ticketConfig.requestType]);
+    const myClientConfig = {};
+    myClientConfig[ticketConfig.requestType] = {baseQuery: clientConfig[ticketConfig.requestType].baseQuery, fields: [1]};
+    const myMapping = [{"oldName":ticketConfig.requestIdField, "newName" :  "internalId"}];
+    const ticket = await getTicket(ticketConfig, myClientConfig, id, myMapping);
+    log.debug('Ticket to Update', ticket);
+    const mapping = config.getMapping(ticketConfig.requestType);
+
+    //Constants work only on new.
+    ticketData = mappingUtil.applyMapping2Remedy(ticketData, mapping, undefined, fields);
+
+    //run postMapping
+    if (scripts && scripts.postMapping) {
+        await scriptController.runScripts(scripts.postMapping, ticketData);
+    }
+
+    const update = await arquery.updateEntry(ticketConfig.forms.regular, ticket.data.internalId, ticketData);
+
+    //run afterExecution
+    if (scripts && scripts.afterExecution) {
+        await scriptController.runScripts(scripts.afterExecution, ticketData);
+    }
+
+    return update;
+}
+
+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 = {
+    getTicket,
+    getTickets,
+    createTicket,
+    updateTicket,
+    searchTicket
+};

package/controller/ticketWorkLogController.js

@@ -0,0 +1,195 @@
+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 searchUtil = require('../util/searchUtil');
+const {applyMapping} = require('../util/paramHelper');
+const mappingUtil = require('../util/mappingUtil');
+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) {
+    const scripts = clientConfig[ticketConfig.requestTypeWorkLog].scripts.POST;
+    const mapping = config.getMapping(ticketConfig.requestTypeWorkLog);
+    const fields = clientConfig[ticketConfig.requestTypeWorkLog].fields;
+
+    log.debug('mapping', mapping);
+    let data = {
+        "summary" : summary,
+        "text" : text
+    };
+    const requestType = ticketConfig.requestType;
+    if (requestType === 'incident') {
+        data[searchUtil.mapFieldNameReverse('Incident Number', mapping)] = ticketId;
+        data[searchUtil.mapFieldNameReverse('Incident Entry ID', mapping)] = ticketId;
+        fields.push(
+            'Incident Number',
+            'Incident Entry ID'
+        )
+    } else if (requestType === 'workOrder') {
+        data[searchUtil.mapFieldNameReverse('Work Order ID', mapping)] = ticketId;
+        data[searchUtil.mapFieldNameReverse('WorkOrder_EntryID', mapping)] = ticketId;
+        fields.push(
+            'Work Order ID',
+            'WorkOrder_EntryID'
+        )
+    } else if (requestType === 'change') {
+        data[searchUtil.mapFieldNameReverse('Infrastructure Change ID', mapping)] = ticketId;
+        data[searchUtil.mapFieldNameReverse('Infra. Change Entry ID', mapping)] = ticketId;
+        fields.push(
+            'Infrastructure Change ID',
+            'Infra. Change Entry ID'
+        )
+    } else if (requestType === 'problem') {
+        data[searchUtil.mapFieldNameReverse('Problem Investigation ID', mapping)] = ticketId;
+        data[searchUtil.mapFieldNameReverse('Problem Investigation Entry ID', mapping)] = ticketId;
+        fields.push(
+            'Problem Investigation ID',
+            'Problem Investigation Entry ID'
+        )
+    }
+
+    const clientConstants = clientConfig[ticketConfig.requestTypeWorkLog].constants;
+    if (isPublic == true) {
+        clientConstants.push({"name": "View Access", "value" : "Public"});
+    } else {
+        clientConstants.push({"name": "View Access", "value" : "Internal"});
+    }
+
+    //run preScripts
+    if (scripts && scripts.preMapping) {
+        await scriptController.runScripts(scripts.preMapping, data);
+    }
+
+    data = mappingUtil.applyMapping2Remedy(data, mapping, clientConstants, fields);
+
+    //run postScripts
+    if (scripts && scripts.postMapping) {
+        await scriptController.runScripts(scripts.postMapping, data);
+    }
+
+    const result = arquery.createEntry(ticketConfig.forms.workLog, data, clientConfig.options)
+
+    //run afterExecution
+    if (scripts && scripts.afterExecution) {
+        await scriptController.runScripts(scripts.afterExecution, data);
+    }
+
+    return result;
+}
+
+function setWorklogAttachment(ticketConfig, clientConfig, worklogId, file, attachmentId) {
+    const fieldId = getAttachmentFieldId(attachmentId);
+    return arquery.setAttachment(ticketConfig.forms.workLog, worklogId, fieldId, file);
+}
+
+function getWorklogAttachment(ticketConfig, clientConfig, worklogId, attachmentId) {
+    const fieldId = getAttachmentFieldId(attachmentId);
+    return arquery.getAttachment(ticketConfig.forms.workLog, worklogId, fieldId);
+}
+
+function getAttachmentFieldId(attachmentId) {
+    let attachmentFieldId = 1000000351;
+    if (attachmentId == 2) {
+        attachmentFieldId = 1000000352;
+    } else if (attachmentId == 3) {
+        attachmentFieldId = 1000000353;
+    }
+    log.debug('AttachmentFieldId', attachmentFieldId);
+    return attachmentFieldId;
+}
+
+async function getWorklogs(ticketConfig, clientConfig, ticketId, mapping) {
+    let query = '1=2';
+    const requestType = ticketConfig.requestType;
+    if (requestType === 'incident') {
+        query = `'Incident Number'=\"${ticketId}\"`;
+    } else if (requestType === 'change') {
+        query = `'Infrastructure Change ID'=\"${ticketId}\"`;
+    } else if (requestType === 'problem') {
+        query = `'Problem Investigation ID'=\"${ticketId}\"`;
+    } else if (requestType === 'workOrder') {
+        query = `'Work Order ID'=\"${ticketId}\"`;
+    }
+    const returnValue = await queryWorklogs(ticketConfig, clientConfig, query, mapping);
+    return {data: returnValue.data};
+}
+
+async function getWorklog(ticketConfig, clientConfig, ticketId, worklogId, mapping) {
+    let query = '1=2';
+    const requestType = ticketConfig.requestType;
+    if (requestType === 'incident') {
+        query = `'Incident Number'=\"${ticketId}\" AND '1' = \"${worklogId}\"`;
+    } else if (requestType === 'change') {
+        query = `'Infrastructure Change ID'=\"${ticketId}\" AND '1' = \"${worklogId}\"`;
+    } else if (requestType === 'problem') {
+        query = `'Problem Investigation ID'=\"${ticketId}\" AND '1' = \"${worklogId}\"`;
+    } else if (requestType === 'workOrder') {
+        query = `'Work Order ID'=\"${ticketId}\" AND '1' = \"${worklogId}\"`;
+    }
+    const returnValue = await queryWorklogs(ticketConfig, clientConfig, query, mapping);
+    const urls = {
+        "attachmentUrl":
+            `${ticketConfig.baseURI}/${ticketId}/worklogs/${worklogId}/attachments/1`
+        ,
+        "attachmentUrl2":
+            `${ticketConfig.baseURI}/${ticketId}/worklogs/${worklogId}/attachments/2`
+        ,
+        "attachmentUrl3":
+            `${ticketConfig.baseURI}/${ticketId}/worklogs/${worklogId}/attachments/3`
+        ,
+        "self":
+            `${ticketConfig.baseURI}/${ticketId}/worklogs/${worklogId}`
+    };
+    return {data: returnValue.data[0], urls};
+}
+
+async function queryWorklogs(ticketConfig, clientConfig, query, mapping) {
+    const baseQuery = clientConfig[ticketConfig.requestTypeWorkLog].basequery;
+    const fields = clientConfig[ticketConfig.requestTypeWorkLog].fields;
+    const key = 'worklog' + baseQuery + fields.toString() + query;
+    const scripts = clientConfig[ticketConfig.requestTypeWorkLog].scripts.GET;
+
+    log.debug('Cachekey is ', key);
+
+    if (mapping == null || mapping == undefined) {
+        mapping = config.getMapping(ticketConfig.requestTypeWorkLog);
+    }
+    log.debug('mapping', mapping);
+    log.debug('fields', fields);
+
+    return ticketCache.get(key, async function () {
+        const result = await arquery.executeARQuery(ticketConfig.forms.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, data);
+                }
+                applyMapping(element, mapping, 'Entry ID');
+                //run postScripts
+                if (scripts && scripts.postMapping) {
+                    await scriptController.runScripts(scripts.postMapping, data);
+                }
+            }
+            return {
+                "data": result.data
+            };
+        } else {
+            return {"data":[]};
+        }
+    });
+}
+
+module.exports = {
+    createWorklog,
+    getWorklog,
+    getWorklogs,
+    getWorklogAttachment,
+    setWorklogAttachment
+};

package/docs/.gitattributes

@@ -0,0 +1,48 @@
+# Define standard eol format
+
+# Web Files
+*.html text eol=lf
+*.md text eol=lf
+*.css text eol=lf
+*.js text eol=lf
+
+# Jekyll related files
+*.yml text eol=lf
+
+# Git related files
+.gittattributes text eol=lf
+.gitignore text eol=lf
+.gitkeep text eol=lf
+
+# Ruby files
+*.rb text eol=lf
+Gemfile text eol=lf
+Gemfile.lock text eol=lf
+
+# Github specific fies
+LICENCE text eol=lf
+
+# Docker specific files
+Dockerfile text eol=lf
+
+# VSCode files
+*.json text eol=lf
+
+# General multimedia files
+*.jpg binary
+*.jpeg binary
+*.gif binary
+*.png binary
+*.t3x binary
+*.t3d binary
+*.exe binary
+*.data binary
+*.ttf binary
+*.eof binary
+*.eot binary
+*.swf binary
+*.mov binary
+*.mp4 binary
+*.mp3 binary
+*.ogg binary
+*.flv binary

package/docs/404.html

@@ -0,0 +1,13 @@
+---
+layout: default
+title: 404 - Page not found
+permalink: /404.html
+---
+
+<div class="text-center">
+  <h1>Whoops, this page doesn't exist.</h1>
+  <h1>Move along. (404 error)</h1>
+  <br/>
+
+  <img src="{{ 'img/404-southpark.jpg' | relative_url }}" />
+</div>

package/docs/CNAME

@@ -0,0 +1 @@
+smileconnect.manyosdocs.de

package/docs/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem "github-pages", '197', group: :jekyll_plugins
+
+# enable tzinfo-data for local build
+# gem 'tzinfo-data', platforms: [:mingw, :mswin, :x64_mingw]
+gem 'jekyll-paginate'