@manyos/smileconnect-api 1.28.0

package/conf/scripts/p1.js

@@ -0,0 +1,11 @@
+const allowedCats = [
+    "Request",
+    "Failure"
+];
+
+//Validate opsCat1
+if (requestData.opsCat1 && !allowedCats.find(element => element === requestData.opsCat1)) {
+    reject(`opsCat1 ${requestData.opsCat1} not in allowed values ${allowedCats}`);
+}
+requestData.summary = `Da kam an: ${requestData.summary}`
+resolve();

package/conf/scripts/p2.js

@@ -0,0 +1 @@
+resolve();

package/conf/scripts/p3.js

@@ -0,0 +1 @@
+resolve();

package/conf/scripts/p4.js

@@ -0,0 +1,2 @@
+//requestData.horst="da"
+resolve();

package/conf/scripts/script1.js

@@ -0,0 +1,2 @@
+//requestData.Status = "Horstdi";
+resolve();

package/conf/scripts/script2.js

@@ -0,0 +1,2 @@
+//requestData.Status = "Horstdi2";
+resolve();

package/conf/scripts/script3.js

@@ -0,0 +1,2 @@
+//reject('ich mag das nicht')
+resolve()

package/controller/cmdbobjectController.js

@@ -0,0 +1,291 @@
+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} = require('../util/paramHelper');
+const relationUtil = require('../util/relationUtil');
+const ticketCIRelationController = require('../controller/ticketCIRelationController');
+
+const cmdbCache = new CacheService(process.env.CACHETTL_CMDB || 600); // Create a new cache service instance
+const schemaCache = new CacheService(process.env.CACHETTL_SCHEMANAMES || 3600); // Create a new cache service instance
+
+function getCmdbObjects(config, category, ciIds, includeString) {
+    let query = '1=1';
+    if (category)
+        query = `'Category' = \"${category}\"`;
+
+    if (ciIds) {
+        let ciQuery = " AND (";
+        let x = 0;
+        for (x= 0; x<ciIds.length -1; x++) {
+            const ciInstanceId = ciIds[x].trim();
+            ciQuery = ciQuery + "'Instance Id' = \""+ciInstanceId + "\" OR ";
+        }
+        ciQuery = ciQuery + "'Instance Id' = \"" + ciIds[ciIds.length -1].trim() + "\"";
+        query = query + ciQuery + ')';
+        log.error('query', query);
+    }
+    return queryCMDBObject(config, query, null, null, includeString);
+}
+
+function getCIRelations(clientConfig, id) {
+    const query = `('Source.InstanceId'=\"${id}\" OR 'Destination.InstanceId'=\"${id}\")AND('MarkAsDeleted'=$NULL$ OR 'MarkAsDeleted'=\"No\")`;
+    return cmdbCache.get(query, function () {
+        return new Promise((resolve, reject) => {
+            arquery.executeARQuery('BMC.CORE:BMC_BaseRelationship', "'DatasetId'=\"BMC.ASSET\"", query, '490008000,490009000,400079600,Destination.ClassId, Source.ClassId', clientConfig.options)
+                .then(function (result) {
+                    log.debug(result);
+                    //const mapping = [{"oldName":"Model Number", "newName" : "model"}, {"oldName":"Model Number", "newName" : "model"}]
+                    if (result && result.data) {
+                        result.data.forEach(function (element) {
+                            element.ciId = element['Source.InstanceId'];
+                            element.ciClass = element['Source.ClassId'];
+                            element.direction = 'parent';
+                            element.relationClass = element['ClassId'];
+                            if (element['Source.InstanceId'] === id) {
+                                element.ciId = element['Destination.InstanceId'];
+                                element.direction = 'child';
+                                element.ciClass = element['Destination.ClassId'];
+                            }
+                            delete element['RequestId'];
+                            delete element['ClassId'];
+                            delete element['Source.InstanceId'];
+                            delete element['Destination.InstanceId'];
+                            delete element['Source.ClassId'];
+                            delete element['Destination.ClassId'];
+                        });
+                    }
+                    resolve(result.data || []);
+                })
+                .catch(function (reason) {
+                    log.error(reason);
+                    reject(reason);
+                })
+        });
+    });
+}
+
+function getPeopleRelations(clientConfig, reconId, relationType) {
+    const query = `'AssetInstanceId'=\"${reconId}\"`;
+    return cmdbCache.get(query + relationType, function () {
+        return new Promise((resolve, reject) => {
+            arquery.executeARQuery('AST:AssetPeople', `'Request_Type'="${relationType}"`, query, '304327610, 260100006, 260100003, 260100005', clientConfig.options)
+                .then(function (result) {
+                    const relations = [];
+                    if (result && result.data) {
+                        result.data.forEach(function (element) {
+                           if (element['Request_Type'] === 'People') {
+                               relations.push({"id" : element['PeopleGroup Form Entry ID'], "role":element['PersonRole']});
+                           } else if (element['Request_Type'] === 'People Organization') {
+                               relations.push({"id" : element['PeopleGroup Form Entry ID'], "role":element['PersonRole']});
+                           } else if (element['Request_Type'] === 'Support Group') {
+                               relations.push({"id" : element['PeopleGroup Form Entry ID'], "role":element['PersonRole']});
+                           }
+                        });
+                    }
+
+                    log.debug(result);
+                    resolve(relations || []);
+                })
+                .catch(function (reason) {
+                    log.error(reason);
+                    reject(reason);
+                })
+        });
+    });
+}
+
+function getSchemaName(classId) {
+    if (classId) {
+        return schemaCache.get(classId, async function () {
+            const result = await arquery.executeARQuery('SHR:SchemaNames', null, `'Lookup Keyword'="${classId}" AND 'Locale'=$NULL$`, 'Schema Name');
+            log.debug('lookup schema', classId, result);
+            if (result && result.data && Array.isArray(result.data) && result.data.length > 0) {
+                return result.data[0]['Schema Name'];
+            } else {
+                return undefined;
+            }
+        });
+    }
+}
+
+function queryCMDBObject(clientConfig, query, customFields, customOptions, includeString) {
+    let fields = clientConfig.cmdbobject.fields;
+    let deleteClassId = false;
+
+    const includeArray = getIncludeArray(includeString);
+    //check for customFields
+    if (customFields !== null && customFields !== undefined) {
+        fields = customFields;
+    }
+
+    if (!fields.includes('Class Id') && includeArray.includes('classAttributes')) {
+        fields.push('Class Id');
+        deleteClassId = true;
+        log.debug('Add classId');
+    }
+
+    const options = {
+        ...clientConfig.options, ...customOptions
+    };
+
+    log.debug('use joined options', options);
+
+    const key = clientConfig.cmdbobject.basequery + fields.toString() + query + JSON.stringify(options) + includeArray;
+    log.debug('Cachekey is', key);
+
+    const mapping = config.getMapping('cmdbobject');
+    log.debug('mapping', mapping);
+
+    return cmdbCache.get(key, async function () {
+        const result = await arquery.executeARQuery('AST:BaseElement', clientConfig.cmdbobject.basequery || null, query, fields.toString() || '1', options);
+        const globalRelationObjects = relationUtil.prepareGlobalRelationObject();
+        const cmdbObjects = [];
+        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);
+                cmdbObjects.push(cmdbObject);
+            }
+        }
+        log.debug('cahce', cmdbCache.getTtl(key));
+        return {
+            "data": cmdbObjects,
+            "included": globalRelationObjects
+        };
+    });
+}
+
+async function handleCMDBObjectResult(cmdbObject, mapping, clientConfig, includeArray, globalRelationObjects, deleteClassId) {
+    //get class form
+    const classId = cmdbObject['Class Id'];
+    if (deleteClassId === true) {
+        delete cmdbObject['Class Id'];
+    }
+    //Apply mapping
+    mapping.forEach(function (mappingEntry) {
+        try {
+            Object.defineProperty(cmdbObject, mappingEntry.newName, Object.getOwnPropertyDescriptor(cmdbObject, mappingEntry.oldName));
+            delete cmdbObject[mappingEntry.oldName];
+        } catch (e) {
+            //ignore missing mapping
+        }
+    });
+    delete cmdbObject['Request ID'];
+    if (cmdbObject.reconId && cmdbObject.classId && process.env.FEDERATED_BASE_URI) {
+        //create link to smartit
+        cmdbObject.federatedLink = (process.env.FEDERATED_BASE_URI || '') + cmdbObject.reconId + '/' + cmdbObject.classId;
+    }
+
+    cmdbObject.relations = {};
+
+    if (includeArray.includes('ciRelations')) {
+        const relations = await getCIRelations(clientConfig, cmdbObject.id);
+        cmdbObject.relations.ciRelations = relations;
+    }
+    if (includeArray.includes('ticketRelations')) {
+        const relations = await ticketCIRelationController.getCITicketRelations(cmdbObject.id);
+        cmdbObject.relations.ticketRelations = relations;
+    }
+    if (includeArray.includes('personRelations')) {
+        const relations = await getPeopleRelations(clientConfig, cmdbObject.reconId, 'People');
+        cmdbObject.relations.personRelations = relations;
+    }
+
+    if (includeArray.includes('supportGroupRelations')) {
+        const relations = await getPeopleRelations(clientConfig, cmdbObject.reconId, 'Support Group');
+        cmdbObject.relations.supportGroupRelations = relations;
+    }
+
+    if (includeArray.includes('organisationRelations')) {
+        const relations = await getPeopleRelations(clientConfig, cmdbObject.reconId, 'People Organization');
+        cmdbObject.relations.organisationRelations = relations;
+    }
+
+    if (includeArray.includes('classAttributes')) {
+        const classAttributes = await getCMDBObjectClassAttributes(cmdbObject.id,classId, clientConfig);
+        cmdbObject = {
+            ...cmdbObject, ...classAttributes
+        }
+    }
+
+    relationUtil.getRelatedObjectList(cmdbObject, includeArray, globalRelationObjects);
+
+    return cmdbObject;
+}
+
+async function getCMDBObjectClassAttributes(id, classId, clientConfig) {
+    const schemaName = await getSchemaName(classId);
+    const mapping = config.getMapping('cmdbobject_' + schemaName);
+    const fields = clientConfig.cmdbobject['fields_' + schemaName];
+    if (schemaName && fields && mapping) {
+        return cmdbCache.get(id+classId+fields, async function () {
+            const result = await arquery.executeARQuery(schemaName, null, `'179'="${id}"`, fields.toString());
+            log.debug('classAttributes Result', result);
+            if (result && result.data && Array.isArray(result.data)) {
+                const classObject = result.data[0];
+                mapping.forEach(function (mappingEntry) {
+                    try {
+                        Object.defineProperty(classObject, mappingEntry.newName, Object.getOwnPropertyDescriptor(classObject, mappingEntry.oldName));
+                        delete classObject[mappingEntry.oldName];
+                    } catch (e) {
+                        //ignore missing mapping
+                    }
+                });
+                delete classObject['Request ID'];
+                return classObject;
+            }
+        });
+    } else {
+        log.debug('no schemaname nor fieldconfig nor mapping found', {id, classId, schemaName, mapping});
+        return undefined;
+    }
+}
+
+async function getCmdbObject(config, id, includeString) {
+    const query = `'Instance Id'=\"${id}\"`;
+    const returnValue = await queryCMDBObject(config, query, null, null, includeString);
+    log.debug (returnValue);
+    const cmdbObject = returnValue.data[0];
+    return {data: cmdbObject, included: returnValue.included};
+}
+
+async function hasAccess(config, id) {
+    const query = `'Instance Id'=\"${id}\"`;
+    const returnValue = await queryCMDBObject(config, query, ['1']);
+    log.debug ('got', returnValue);
+    return returnValue.data.length === 1;
+}
+
+async function applyMapping(clientConfig, data) {
+    const mapping = config.getMapping('cmdbobject');
+    const mappedRecord = searchUtil.applyMapping2record(data, clientConfig, mapping);
+    return mappedRecord;
+}
+
+function searchCmdbObjectByName(config, name, includeString) {
+    const query = `'Name'LIKE\"%${name}%\"`;
+    return queryCMDBObject(config, query, null, null, includeString);
+}
+
+function searchCmdbObject(clientConfig, searchString, fields, options, includeString) {
+    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);
+}
+
+module.exports = {
+    getCmdbObjects,
+    getCmdbObject,
+    searchCmdbObjectByName,
+    searchCmdbObject,
+    getCIRelations,
+    hasAccess,
+    applyMapping
+};

package/controller/eventLogController.js

@@ -0,0 +1,78 @@
+require('dotenv').config();
+const path = require('path');
+const log = require('@manyos/logger').setupLog('SMILEconnect_' + path.basename(__filename));
+const arquery = require('../util/arquery');
+const eventForm = 'MYS:SMILEconnect_QueueData';
+
+function createEventLog(smileId, client, ticketNumber, schemaName, eventName, url, status, errorMsg, jsonData, ticketNumber2) {
+    return new Promise((resolve, reject) => {
+        let enable = process.env.EVENTLOG_ENABLE;
+        if (enable != null && enable != undefined && enable.toLowerCase() == 'true') {
+            const data = {
+                "InstanceId" : smileId,
+                "Status" : status,
+                "VendorID" : client,
+                "TicketNumber" : ticketNumber,
+                "TicketNumber2" : ticketNumber2,
+                "SchemaName" : schemaName,
+                "ErrorMsg" : errorMsg,
+                "Direction" : "Inbound",
+                "Event":eventName,
+                "URL":url
+            };
+            if (jsonData != null && jsonData != undefined) {
+                data['JsonValue'] = JSON.stringify(jsonData, null, 2);
+            }
+            arquery.createEntry(eventForm, data).then(function (result) {
+                resolve(result);
+            }).catch(error => {
+                reject(error);
+            });
+        } else {
+            resolve('Eventlog disabled');
+        }
+    });
+}
+
+function createErrorLog(smileId, client, ticketNumber, schemaName, eventName, url, errorMsg, jsonData, ticketNumber2) {
+    return createEventLog(smileId, client, ticketNumber, schemaName, eventName, url, 'Error', errorMsg, jsonData, ticketNumber2);
+}
+
+function createSuccessLog(smileId, client, ticketNumber, schemaName, eventName, url, jsonData, ticketNumber2) {
+    return createEventLog(smileId, client, ticketNumber, schemaName, eventName, url, 'Done', null, jsonData, ticketNumber2);
+}
+
+function setEventData(req, eventName, schemaName, ticketNumber, jsonData, ticketNumber2) {
+    req.eventData = {
+        event: eventName,
+        schema: schemaName,
+        "ticketNumber": ticketNumber,
+        "ticketNumber2": ticketNumber2,
+        "jsonData" : jsonData
+    };
+}
+
+function setEventData(req, eventBase, eventAction, schemaName, ticketNumber, jsonData, ticketNumber2) {
+    req.eventData = {
+        event: eventBase + '_' + eventAction,
+        schema: schemaName,
+        "ticketNumber": ticketNumber,
+        "ticketNumber2": ticketNumber2,
+        "jsonData" : jsonData
+    };
+}
+
+function setTicketId(req, ticketNumber) {
+    if (req.eventData === null || req.eventData === undefined) {
+        req.eventData = {};
+    }
+    req.eventData.ticketNumber = ticketNumber;
+}
+
+module.exports = {
+    createEventLog,
+    createSuccessLog,
+    createErrorLog,
+    setEventData,
+    setTicketId
+};