@manyos/smileconnect-api 1.28.0

package/util/config.js

@@ -0,0 +1,361 @@
+const fs = require('fs');
+const path = require('path');
+const log = require('@manyos/logger').setupLog('SMILEconnect_' + path.basename(__filename));
+
+const clientConfigFile = 'conf/clients.json';
+const arquery = require('../util/arquery');
+const CacheService = require ('../util/cache.service');
+
+const CONSTANTS = require('./constants');
+
+const configCache = new CacheService(process.env.CACHETTL_CONFIG || 3600); // Create a new cache service instance
+
+const clientConfigItemTemplate = {
+    "basequery": "1=2",
+    "fields": [],
+    "constants": []
+};
+
+function getClients() {
+    log.debug('start to read config from file', clientConfigFile);
+    let rawdata = fs.readFileSync(clientConfigFile);
+    return JSON.parse(rawdata);
+}
+
+function getClientConfig(clientName) {
+    log.debug('get clientconfig for', clientName);
+    const config = getClients();
+    const client = config.find(function(element) {
+        return element.name === clientName;
+    });
+    if (client !== null && client !== undefined) {
+        return client.config;
+    } else {
+        return {}
+        //TODO implement only for NON-Admin
+        //throw ('Client ' + clientName + ' not found in configuration.');
+    }
+}
+
+function getClient(client) {
+    log.debug('get clientconfig for', client);
+    const config = getClients();
+    return config.find(function(element) {
+        return element.name === client;
+    });
+}
+
+function getMapping(objectType) {
+    const configFile = 'conf/mapping.json';
+    log.debug('start to read config from file', configFile);
+    let rawdata = fs.readFileSync(configFile);
+    return JSON.parse(rawdata)[objectType] || [];
+}
+
+function getMappings() {
+    const configFile = 'conf/mapping.json';
+    log.debug('start to read config from file', configFile);
+    let rawdata = fs.readFileSync(configFile);
+    return JSON.parse(rawdata) || {};
+}
+
+function setMapping(objectType, mapping) {
+    const configFile = 'conf/mapping.json';
+    log.debug('start to update config from file', configFile);
+    log.debug('set mapping data', objectType, mapping);
+    const data = JSON.parse(fs.readFileSync(configFile)) || {};
+    data[objectType] = mapping;
+    fs.writeFileSync(configFile, JSON.stringify(data, null, 2));
+    return true
+}
+
+function setMappings(mapping) {
+    const configFile = 'conf/mapping.json';
+    log.debug('start to update config from file', configFile);
+    log.debug('set mapping data', mapping);
+    fs.writeFileSync(configFile, JSON.stringify(mapping, null, 2));
+    return true
+}
+
+function setClient(clientName, clientConfig) {
+    log.debug('start to update config in file', clientConfigFile);
+    log.debug('set client data', clientName, clientConfig);
+    let config = JSON.parse(fs.readFileSync(clientConfigFile)) || {};
+    config = config.filter(function( obj ) {
+        return obj.name !== clientName;
+    });
+    config.push(clientConfig)
+    log.debug('new config', config);
+    fs.writeFileSync(clientConfigFile, JSON.stringify(config, null, 2));
+    return true
+}
+
+function deleteClient(clientName) {
+    log.debug('start to update config in file', clientConfigFile);
+    log.debug('delete client data', clientName);
+    let config = JSON.parse(fs.readFileSync(clientConfigFile)) || {};
+    config = config.filter(function( obj ) {
+        return obj.name !== clientName;
+    });
+    log.debug('new config', config);
+    fs.writeFileSync(clientConfigFile, JSON.stringify(config, null, 2));
+    return true
+}
+
+function getConstants(objectType) {
+    const configFile = 'conf/mapping.json';
+    log.debug('start to read config from file', configFile);
+    try {
+        let rawdata = fs.readFileSync(configFile);
+        return JSON.parse(rawdata)[objectType] || [];
+    } catch (e) {
+        log.error (e);
+        return []
+    }
+}
+
+function checkMapping() {
+    log.info('check mapping');
+    const mappingDefs = [
+        'cmdbobject',
+        'change',
+        'newChange',
+        'changeWorklog',
+        'changeTemplate',
+        'incident',
+        'newIncident',
+        'incidentWorklog',
+        'incidentTemplate',
+        'person',
+        'problem',
+        'newProblem',
+        'problemTemplate',
+        'problemWorklog',
+        'supportGroup',
+        'organisation',
+        'workOrder',
+        'newWorkOrder',
+        'workOrderWorklog',
+        'workOrderTemplate',
+        'task',
+        'newTask',
+        'taskWorklog',
+        'taskTemplate',
+        'flowBuilder'
+    ];
+    const mappings = getMappings() || {};
+    const mappingKeys = Object.keys(mappings);
+    //delete too many
+    mappingKeys.forEach(key=>{
+        if (!mappingDefs.includes(key) && !key.startsWith('cmdbobject_')) {
+            log.info('delete from mapping', key);
+            delete mappings[key];
+        }
+    });
+    //add too less
+    mappingDefs.forEach(mappingDef => {
+        if (!mappingKeys.includes(mappingDef)) {
+            log.info('add to mapping', mappingDef);
+            mappings[mappingDef] = [];
+        }
+    });
+    //save
+    setMappings(mappings);
+    log.info('check mapping done');
+}
+
+function checkClientConfig(client) {
+    const clientKeys = [
+        'cmdbobject',
+        'change',
+        'changeWorklog',
+        'changeTemplate',
+        'incident',
+        'incidentWorklog',
+        'incidentTemplate',
+        'person',
+        'problem',
+        'problemWorklog',
+        'problemTemplate',
+        'supportGroup',
+        'organisation',
+        'workOrder',
+        'workOrderWorklog',
+        'workOrderTemplate',
+        'task',
+        'taskWorklog',
+        'taskTemplate',
+        'flowBuilder'
+    ];
+    log.info('check config for client', client.name);
+    const clientConfig = client.config || {};
+    const clientConfigKeys = Object.keys(clientConfig);
+    //delete too many
+    clientConfigKeys.forEach(key=>{
+        if (!clientKeys.includes(key) && !(key === 'options')) {
+            log.info('delete from clientconfig', key);
+            delete clientConfig[key];
+        } else if (clientKeys.includes(key) && !(key === 'options')) {
+            if (!clientConfig[key].basequery) {
+                clientConfig[key].basequery = '';
+                log.info('add basequery', key);
+            }
+            if (!clientConfig[key].fields) {
+                clientConfig[key].fields = [];
+                log.info('add fields', key);
+            }
+            if (!clientConfig[key].constants) {
+                clientConfig[key].constants = [];
+                log.info('add constants', key);
+            }
+            if (!clientConfig[key].scripts) {
+                clientConfig[key].scripts = {};
+                log.info('add scripts', key);
+            }
+        }
+    });
+    //add too less
+    clientKeys.forEach(clientKey => {
+        if (!clientConfigKeys.includes(clientKey)) {
+            log.info('add to mapping', clientKey);
+            clientConfig[clientKey] = clientConfigItemTemplate;
+        }
+    });
+    client.config = clientConfig;
+    //save
+    setClient(client.name, client);
+    log.info('check config for client done', client.name);
+}
+
+function checkClientConfigs() {
+    log.info('check client configs');
+    const clientConfigs = getClients();
+    clientConfigs.forEach(clientConfig => {
+        checkClientConfig(clientConfig);
+    });
+    log.info('check client configs done');
+}
+
+function checkConfig() {
+    log.info('check config');
+    checkMapping();
+    checkClientConfigs();
+    log.info('check config done');
+}
+
+function getForms() {
+    log.debug('get forms');
+    const key = 'forms';
+    return configCache.get(key, async function () {
+        const result = await arquery.getMetaData();
+        return result;
+    });
+}
+
+function getFields(form) {
+    log.debug('get fields for', form);
+    const key = 'fields/' + form;
+    return configCache.get(key, async function () {
+        const result = await arquery.getMetaData(form);
+        return result;
+    });
+}
+
+const ticketConfig = {
+    "workorders": {
+        "forms": {
+            "regular": CONSTANTS.FORM_WORKORDER,
+            "new": CONSTANTS.FORM_WORKORDER_CREATE,
+            "workLog": CONSTANTS.FORM_WORKORDER_WORKLOG,
+            "assoc": CONSTANTS.FORM_WORKORDER_ASSOC,
+            "template": CONSTANTS.FORM_WORKORDER_TEMPLATE
+        },
+        "requestIdField": "Request ID",
+        "requestType": "workOrder",
+        "ticketIdField": "WorkOrder_ID",
+        "requestTypeWorkLog": "workOrderWorklog",
+        "requestTemplate": "workOrderTemplate",
+        "baseURI": "/v1/workorders",
+        "assocTicketKeyword": "MAINWORKORDER",
+        "assocTicketType": "Work Order",
+        "templateRequestId": "Request ID"
+    },
+    "incidents": {
+        "forms": {
+            "regular": CONSTANTS.FORM_INCIDENT,
+            "new": CONSTANTS.FORM_INCIDENT_CREATE,
+            "workLog": CONSTANTS.FORM_INCIDENT_WORKLOG,
+            "assoc": CONSTANTS.FORM_INCIDENT_ASSOC,
+            "template": CONSTANTS.FORM_INCIDENT_TEMPLATE
+        },
+        "requestIdField": "Entry ID",
+        "requestType": "incident",
+        "ticketIdField": "Incident Number",
+        "requestTypeWorkLog": "incidentWorklog",
+        "requestTemplate": "incidentTemplate",
+        "baseURI": "/v1/incidents",
+        "assocTicketKeyword": "MAINHELPDESK",
+        "assocTicketType":"Incident",
+        "templateRequestId": "HPD Template ID"
+    },
+    "changes": {
+        "forms": {
+            "regular": CONSTANTS.FORM_CHANGE,
+            "new": CONSTANTS.FORM_CHANGE_CREATE,
+            "workLog": CONSTANTS.FORM_CHANGE_WORKLOG,
+            "assoc": CONSTANTS.FORM_CHANGE_ASSOC,
+            "template": CONSTANTS.FORM_CHANGE_TEMPLATE
+        },
+        "requestIdField": "Request ID",
+        "requestType": "change",
+        "ticketIdField": "Infrastructure Change Id",
+        "requestTypeWorkLog": "changeWorklog",
+        "requestTemplate": "changeTemplate",
+        "baseURI": "/v1/changes",
+        "assocTicketKeyword": "MAINCHANGE",
+        "assocTicketType": "Infrastructure Change",
+        "templateRequestId": "CHG Template ID"
+    },
+    "problems": {
+        "forms": {
+            "regular": CONSTANTS.FORM_PROBLEM,
+            "new": CONSTANTS.FORM_PROBLEM_CREATE,
+            "workLog": CONSTANTS.FORM_PROBLEM_WORKLOG,
+            "assoc": CONSTANTS.FORM_PROBLEM_ASSOC,
+            "template": CONSTANTS.FORM_PROBLEM_TEMPLATE
+        },
+        "requestIdField": "Sys-Problem Investigation ID",
+        "requestType": "problem",
+        "ticketIdField": "Problem Investigation ID",
+        "requestTypeWorkLog": "problemWorklog",
+        "requestTemplate": "problemTemplate",
+        "baseURI": "/v1/problems",
+        "assocTicketKeyword": "MAINPROBLEM",
+        "assocTicketType": "Problem Investigation",
+        "templateRequestId": "PBM Template ID"
+    },
+    "tasks": {
+        "forms": {
+            "template": CONSTANTS.FORM_TASK_TEMPLATE
+        },
+        "requestTemplate": "taskTemplate",
+        "templateRequestId": "Template ID"
+    }
+
+};
+
+module.exports = {
+    getClientConfig,
+    getMapping,
+    getClient,
+    getClients,
+    setMapping,
+    getMappings,
+    setClient,
+    deleteClient,
+    setMappings,
+    checkConfig,
+    getForms,
+    getFields,
+    ticketConfig
+};

package/util/constants.js

@@ -0,0 +1,73 @@
+module.exports = {
+    FORM_INCIDENT: "HPD:Help Desk",
+    FORM_INCIDENT_CREATE: "HPD:IncidentInterface_Create",
+    FORM_INCIDENT_WORKLOG: "HPD:WorkLog",
+    FORM_INCIDENT_ASSOC: "HPD:Associations",
+    FORM_INCIDENT_TEMPLATE: "HPD:Template",
+    FORM_CHANGE: "CHG:Infrastructure Change",
+    FORM_CHANGE_CREATE: "CHG:ChangeInterface_Create",
+    FORM_CHANGE_WORKLOG: "CHG:WorkLog",
+    FORM_CHANGE_ASSOC: "CHG:Associations",
+    FORM_CHANGE_TEMPLATE: "CHG:Template",
+    FORM_ASSET: "AST:BaseElement",
+    FORM_ASSET_TICKET_ASSOC: "AST:CMDB Associations",
+    FORM_TASK: "TMS:Task",
+    FORM_TASK_WORKLOG: "TMS:WorkInfo",
+    FORM_TASK_TEMPLATE: "TMS:TaskTemplate",
+    FORM_WORKORDER: "WOI:WorkOrder",
+    FORM_WORKORDER_CREATE: "WOI:WorkOrderInterface_Create",
+    FORM_WORKORDER_ASSOC: "WOI:Associations",
+    FORM_WORKORDER_WORKLOG: "WOI:WorkInfo",
+    FORM_WORKORDER_TEMPLATE: "WOI:Template",
+    FORM_APC_CLIENTS: "ClientConfig",
+    FORM_APC_MAPPING_FIELDS: "MappingFields",
+    FORM_APC_WEBHOOK: "Webhooks",
+    FORM_APC_FORMS_FIELDS: "FormFields",
+    FORM_APC_FORMS: "Forms",
+    FORM_APC_FORMS_META: "Metadata",
+
+    FORM_PEOPLE: "CTM:People",
+    FORM_SUPPORTGROUP: "CTM:Support Group",
+    FORM_ORGANISATION: "CTM:People Organization",
+
+    FORM_PROBLEM: "PBM:Problem Investigation",
+    FORM_PROBLEM_ASSOC: "PBM:Investigation Associations",
+    FORM_PROBLEM_CREATE: "PBM:ProblemInterface_Create",
+    FORM_PROBLEM_WORKLOG: "PBM:Investigation WorkLog",
+    FORM_PROBLEM_TEMPLATE: "PBM:Template",
+    FORM_SCHEMA_NAMES: "SHR:SchemaNames",
+    FORM_CMDB_CI_BASE: "BMC.CORE:BMC_BaseElement",
+    FORM_CMDB_AST_BASE: "AST:BaseElement",
+
+    FORM_SYS_ASSOCIATION_TYPES_OPPO: "SYS:AssocTypeOpposite",
+    FORM_SYS_ASSOCIATION_TYPES_LOOKUP: "SYS:AssociationTypeAssocLookUp",
+
+    EVENT_BASE_AST: "AST",
+
+    EVENT_BASE_APC: "APC",
+
+    EVENT_BASE_INC: "INC",
+    EVENT_BASE_INC_WORKLOG: "INC_Worklog",
+    EVENT_BASE_INC_WORKLOG_ATTACHTMENT: "INC_Worklog_Attachment",
+
+    EVENT_BASE_CHG: "CHG",
+    EVENT_BASE_CHG_WORKLOG: "CHG_Worklog",
+    EVENT_BASE_CHG_WORKLOG_ATTACHTMENT: "CHG_Worklog_Attachment",
+
+    EVENT_BASE_PBM: "PBM",
+    EVENT_BASE_PBM_WORKLOG: "PBM_Worklog",
+    EVENT_BASE_PBM_WORKLOG_ATTACHTMENT: "PBM_Worklog_Attachment",
+
+    EVENT_BASE_WOI: "WOI",
+
+    EVENT_ACTION_QUERY: 'Query',
+    EVENT_ACTION_CREATE: 'Create',
+    EVENT_ACTION_MODIFY: 'Modify',
+    EVENT_ACTION_SEARCH: 'Search',
+
+    EVENT_BASE_ORG_PEOPLE: "ORG_People",
+    EVENT_BASE_ORG_SUPPORTGROUP: "ORG_SupportGroup",
+    EVENT_BASE_ORG_ORGANISATION: "ORG_Organisation",
+
+    TEXT_CREATED_BY: "created by SMILEconnect."
+}

package/util/mappingUtil.js

@@ -0,0 +1,96 @@
+const path = require('path');
+const log = require('@manyos/logger').setupLog('SMILEconnect_' + path.basename(__filename));
+
+function applyMapping2Remedy(entryData, mapping, constants, fields) {
+
+    //todo add array handling
+    if (!Array.isArray(entryData)) {
+        return applyMappingInternal(entryData, mapping, constants, fields);
+    } else {
+        const entries = [];
+        entryData.forEach(entry => {
+            const myMappedEntry = applyMappingInternal(entry, mapping, constants, fields);
+            entries.push(myMappedEntry);
+        })
+        return entries;
+    }
+}
+
+function applyMappingInternal(entryData, mapping, constants, fields) {
+    Object.keys(entryData).forEach(function (objectKey) {
+        const found = mapping.find(function(element) {
+            return element.newName === objectKey;
+        });
+
+        if (found == null || found=== undefined) {
+            log.debug('delete', objectKey)
+            delete entryData[objectKey];
+        }
+    });
+
+    mapping.forEach(function (mappingEntry) {
+        try {
+            Object.defineProperty(entryData, mappingEntry.oldName, Object.getOwnPropertyDescriptor(entryData, mappingEntry.newName));
+            //delete mapping only if no self mapping
+            if (!(mappingEntry.newName == mappingEntry.oldName)) {
+                delete entryData[mappingEntry.newName];
+            }
+        } catch (e) {
+            //ignore missing mapping
+        }
+    });
+    //remove fields if no access
+    log.debug('Check for fields in', fields);
+    if (fields && Array.isArray(fields)) {
+        Object.keys(entryData).forEach(function (objectKey) {
+            const found = fields.find(function(element) {
+                return element === objectKey;
+            });
+            log.debug(`Found ${objectKey} in fields:`, found)
+
+            if (found == null || found=== undefined) {
+                log.debug('delete not accessible field', objectKey)
+                delete entryData[objectKey];
+            }
+        });
+    }
+
+    //add constant values (defaults)
+    if (constants && Array.isArray(constants) && constants.length) {
+
+        constants.forEach(function (element) {
+            log.debug('add constant', element);
+            try {
+                entryData[element.name] = element.value;
+            } catch (e) {
+                log.error(e);
+            }
+        });
+    }
+    return entryData;
+}
+
+//get the allowed fields for a POST Action based on a PUT/GET Action
+function getFieldsForCreate(mapping, mappingNew, clientFields) {
+    const targetList = [];
+    clientFields.forEach(field => {
+        //find field in normal mapping
+        const mapped = mapping.find(element => {
+            return element.oldName === field;
+        });
+        if (mapped) {
+            const mappedNew = mappingNew.find(element => {
+                return element.newName === mapped.newName;
+            });
+            if (mappedNew) {
+                targetList.push(mappedNew.oldName)
+            }
+        }
+    });
+
+    return targetList;
+}
+
+module.exports = {
+    applyMapping2Remedy, getFieldsForCreate
+}

package/util/paramHelper.js

@@ -0,0 +1,43 @@
+const path = require('path');
+const log = require('@manyos/logger').setupLog('SMILEconnect_' + path.basename(__filename));
+
+function getIncludeArray(includeString) {
+    log.debug('transform includeString', includeString);
+    let includeArray = [];
+    if (includeString !== null && includeString !== undefined) {
+        includeArray = includeString.split(',');
+        includeArray = includeArray.map(item => {
+            return item.trim()
+        });
+    }
+    log.debug('includeArray', includeArray);
+    return includeArray;
+}
+
+function getLinkCI(ciId) {
+    const baseUrl = process.env.BASEURL_LINKS;
+    if (ciId !== null && ciId !== undefined && baseUrl !== null && baseUrl !== undefined) {
+        return baseUrl + '/v1/cmdbobjects/' + ciId;
+    } else {
+        return null;
+    }
+}
+
+function applyMapping(object, mapping, requestIdField) {
+    //Apply mapping
+    mapping.forEach(function (mappingEntry) {
+        try {
+            Object.defineProperty(object, mappingEntry.newName, Object.getOwnPropertyDescriptor(object, mappingEntry.oldName));
+            delete object[mappingEntry.oldName];
+        } catch (e) {
+            //ignore missing mapping
+        }
+    });
+    if (requestIdField) {
+        log.debug('Delete requestIdField', requestIdField);
+        delete object[requestIdField];
+    }
+}
+module.exports = {
+    getIncludeArray, getLinkCI, applyMapping
+};

package/util/relationUtil.js

@@ -0,0 +1,63 @@
+const path = require('path');
+const log = require('@manyos/logger').setupLog('SMILEconnect_' + path.basename(__filename));
+
+const CONSTANTS = require('../util/constants');
+
+function prepareGlobalRelationObject() {
+    const globalRelationObjects = {
+        "persons":new Set(),
+        "organisations":new Set(),
+        "supportgroups":new Set(),
+        "cmdbObjects":new Set(),
+        "incidents":new Set(),
+        "changes":new Set(),
+        "problems":new Set(),
+        "workOrders":new Set()
+    };
+    return globalRelationObjects;
+}
+
+function getRelatedObjectList(cmdbObject, includeArray, globalRelationObjects) {
+    if (cmdbObject.relations) {
+        if (cmdbObject.relations.personRelations) {
+            cmdbObject.relations.personRelations.forEach(personRelation => {
+                globalRelationObjects.persons.add(personRelation.id);
+            });
+        }
+        if (cmdbObject.relations.supportGroupRelations) {
+            cmdbObject.relations.supportGroupRelations.forEach(personRelation => {
+                globalRelationObjects.supportgroups.add(personRelation.id);
+            });
+        }
+        if (cmdbObject.relations.organisationRelations) {
+            cmdbObject.relations.organisationRelations.forEach(orgRelation => {
+                globalRelationObjects.organisations.add(orgRelation.id);
+            });
+        }
+        if (cmdbObject.relations.ciRelations) {
+            cmdbObject.relations.ciRelations.forEach(ciRelation => {
+                globalRelationObjects.cmdbObjects.add(ciRelation.ciId);
+            });
+        }
+        if (cmdbObject.relations.ticketRelations) {
+            cmdbObject.relations.ticketRelations.forEach(ticketRelation => {
+                if (ticketRelation.ticketType === 'Incident') {
+                    globalRelationObjects.incidents.add(ticketRelation.ticketId);
+                } else if (ticketRelation.ticketType === 'Work Order') {
+                    globalRelationObjects.workOrders.add(ticketRelation.ticketId);
+                } else if (ticketRelation.ticketType === 'Infrastructure Change') {
+                    globalRelationObjects.changes.add(ticketRelation.ticketId);
+                } else if (ticketRelation.ticketType === 'Problem Investigation') {
+                    globalRelationObjects.problems.add(ticketRelation.ticketId);
+                }
+            });
+        }
+
+    }
+}
+
+
+module.exports = {
+    prepareGlobalRelationObject,
+    getRelatedObjectList
+};