@manyos/smileconnect-api 1.28.0

package/util/responsehandler.js

@@ -0,0 +1,92 @@
+const path = require('path');
+const log = require('@manyos/logger').setupLog('SMILEconnect_' + path.basename(__filename));
+const eventLog = require('../controller/eventLogController');
+
+const VERSION = process.env.version;
+
+function logRequest (req, res, next) {
+    let user = 'unauthorized';
+    if (req.user) {
+        user = req.user.id;
+    }
+    log.info ({
+        user: user,
+        method: req.method,
+        url: req.url,
+        smileId: req.smileId,
+        rateLimit: req.rateLimit
+    });
+    //log.info({req: req});
+    next();
+}
+
+function logErrors(err, req, res, next) {
+    /*log.error({
+        smileId : req.smileId,
+        error : err.stack || String(err)
+    });*/
+    log.error({err: err}, "oops");
+    //write to eventQueue if provided
+    if (req.eventData) {
+        const eventData = req.eventData;
+        eventLog.createErrorLog(
+            req.id,
+            req.user.azp,
+            eventData.ticketNumber,
+            eventData.schema,
+            eventData.event,
+            req.method + ':' + req.url,
+            JSON.stringify(err, null, 2) || String(err),
+            eventData.jsonData,
+            eventData.ticketNumber2);
+    }
+
+    next(err);
+}
+
+function errorHandler(err, req, res, next) {
+    const errorStack = err.stack;
+    const errorStatus = err.status || req.errorStatus || 500;
+    if (errorStatus == 401) {
+        res.status(errorStatus).json({"error": "You are not authorized for this request.", stackTrace: errorStack});
+    } else if (typeof errorStack === "string") {
+        res.status(errorStatus).json({"error": "Ooops. Something unexpected just happened.", "stackTrace":errorStack});
+    } else {
+        res.status(errorStatus).json({"error": err});
+    }
+}
+
+//createSuccessLog(client, ticketNumber, schemaName, eventName, url, jsonData) {
+function eventQueueHandler(req, res, next) {
+    //add version to header as debug info
+    res.setHeader('x-smileconnect-version', VERSION || '0.0.0');
+    log.debug({req:req}, 'start');
+    //write to eventQueue if provided
+    if (req.eventData) {
+        const eventData = req.eventData;
+        eventLog.createSuccessLog(
+            req.id,
+            req.user.azp,
+            eventData.ticketNumber,
+            eventData.schema,
+            eventData.event,
+            req.method + ':' + req.url,
+            eventData.jsonData,
+            eventData.ticketNumber2).then( success => {
+                if (req.downloadResult) {
+                    res.set('Content-disposition', 'attachment; filename=' + req.downloadResult.fileName);
+                    res.status(200).send(req.downloadResult.data);
+                } else {
+                    res.status(req.responseStatus || 200).json(req.result)
+                }
+            }).catch(error => {
+                next(error);
+            });
+    } else {
+        next();
+    }
+}
+
+module.exports = {
+    logErrors, errorHandler, eventQueueHandler, logRequest
+};

package/util/schemas/clientConfigSchema.js

@@ -0,0 +1,180 @@
+const clientConfigSchema = {
+    'data.name': {
+        in: ['body'],
+        isLength: {options: { min: 3 }}
+    },
+    'data.config.incident.basequery': {
+        in: ['body'],
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    },
+    'data.config.incident.constants.*.name': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'name is required'
+        },
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    },
+    'data.config.incident.constants.*.value': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Value is required'
+        },
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    },
+    'data.config.incident.fields': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Fields need to be defined'
+        }
+    },
+    'data.config.incident.fields.*': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Fields need to be defined'
+        },
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    },
+    'data.config.workOrder.basequery': {
+        in: ['body'],
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    },
+    'data.config.workOrder.constants.*.name': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'name is required'
+        },
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    },
+    'data.config.workOrder.constants.*.value': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Value is required'
+        },
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    },
+    'data.config.workOrder.fields': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Fields need to be defined'
+        }
+    },
+    'data.config.workOrder.fields.*': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Fields need to be defined'
+        },
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    },
+    'data.config.change.basequery': {
+        in: ['body'],
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    },
+    'data.config.change.constants.*.name': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'name is required'
+        },
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    },
+    'data.config.change.constants.*.value': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Value is required'
+        },
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    },
+    'data.config.change.fields': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Fields need to be defined'
+        }
+    },
+    'data.config.change.fields.*': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Fields need to be defined'
+        },
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    },
+    'data.config.problem.basequery': {
+        in: ['body'],
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    },
+    'data.config.problem.constants.*.name': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'name is required'
+        },
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    },
+    'data.config.problem.constants.*.value': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Value is required'
+        },
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    },
+    'data.config.problem.fields': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Fields need to be defined'
+        }
+    },
+    'data.config.problem.fields.*': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Fields need to be defined'
+        },
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    }
+    /*Find some samples here,
+    text:  {
+        isString : {
+            errorMessage: 'Needs to be a string'
+        },
+        isAlphanumeric: {
+            errorMessage: 'Needs to be alphanumeric'
+        },
+        isLength: {
+            errorMessage: 'Needs to be between 3 and 30 chars',
+            options: {min: 3, max: 30}
+        },
+        exists: {
+            errorMessage: 'is required'
+        }
+    }*/
+};
+
+module.exports = clientConfigSchema;

package/util/schemas/fieldMappingSchema.js

@@ -0,0 +1,211 @@
+const fieldMappingItemSchema = {
+    'data' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.*.oldName': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        },
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    },
+    'data.*.newName': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        },
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    }
+    /*Find some samples here,
+    text:  {
+        isString : {
+            errorMessage: 'Needs to be a string'
+        },
+        isAlphanumeric: {
+            errorMessage: 'Needs to be alphanumeric'
+        },
+        isLength: {
+            errorMessage: 'Needs to be between 3 and 30 chars',
+            options: {min: 3, max: 30}
+        },
+        exists: {
+            errorMessage: 'is required'
+        }
+    }*/
+};
+
+const validateCMDBDataSchema = {
+    'ciChanges' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'ciChanges.*.ciId': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        },
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    },
+    'ciChanges.*.attributes': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    }
+};
+
+const fieldMappingSchema = {
+    'data' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.cmdbobject' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.person' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.change' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.newChange' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.changeWorklog' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.workOrder' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.newWorkOrder' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.workOrderWorklog' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.incident' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.newIncident' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.incidentWorklog' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.problem' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.newProblem' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.problemWorklog' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.task' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.newTask' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.taskWorklog' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.flowBuilder' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.cmdbobject' : {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        }
+    },
+    'data.*.*.oldName': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        },
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    },
+    'data.*.*.newName': {
+        in: ['body'],
+        exists: {
+            errorMessage: 'Is required'
+        },
+        isString : {
+            errorMessage: 'Needs to be a string'
+        }
+    }
+};
+
+module.exports = {
+    fieldMappingSchema, fieldMappingItemSchema, validateCMDBDataSchema
+};

package/util/searchUtil.js

@@ -0,0 +1,148 @@
+const path = require('path');
+const log = require('@manyos/logger').setupLog('SMILEconnect_' + path.basename(__filename));
+
+function applyMapping(searchString, mapping) {
+    log.debug('Apply mapping on', searchString, mapping);
+    let mappedString = searchString;
+    mapping.forEach(function (mappingEntry) {
+        mappedString = mappedString.replace(new RegExp("'" + mappingEntry.newName + "'", 'g'), "'" + mappingEntry.oldName + "'");
+    });
+    log.debug('Mapped searchString', mappedString);
+    return mappedString;
+}
+
+function applySortMapping(sortOptions, mapping) {
+    log.debug('Apply mapping on', sortOptions, mapping);
+    if (sortOptions == null || sortOptions == undefined) {
+        return sortOptions;
+    }
+    const mappedOptions = {};
+    Object.keys(sortOptions).forEach(key => {
+        mapping.forEach(function (mappingEntry) {
+            if (mappingEntry.newName === key) {
+                mappedOptions[mappingEntry.oldName] = sortOptions[key];
+            }
+        });
+    });
+    log.debug('Mapped sortOptions', mappedOptions);
+    return mappedOptions;
+}
+
+function getCustomFields(clientFields, mapping, requestedFields) {
+    log.debug('get custom fields', requestedFields);
+    log.debug('clientFields fields', clientFields);
+    //return clientFields if null
+    if (requestedFields === null || requestedFields === undefined || !Array.isArray(requestedFields)) {
+        log.debug('no custom fields requested. return clientFields');
+        return clientFields;
+    } else {
+        const customFields = [];
+        const mappedFields = mapFieldNames(requestedFields, mapping);
+        mappedFields.forEach(requestedField => {
+           if (clientFields.includes(requestedField)) {
+               customFields.push(requestedField);
+           }
+        });
+        log.debug('customFields', customFields);
+        return customFields;
+    }
+}
+
+function mapFieldNames(customFields, mapping) {
+    log.debug('Apply field mapping on', customFields, mapping);
+    const mappedFields = [];
+    customFields.forEach(customField => {
+        mapping.forEach(mappingEntry => {
+            if (mappingEntry.newName === customField) {
+                mappedFields.push(mappingEntry.oldName);
+            }
+        });
+    });
+    log.debug('mapped fields', mappedFields);
+    return mappedFields;
+}
+
+function mapFieldName(customField, mapping) {
+    const result = mapFieldNames([customField], mapping);
+    if (result !== null && result !== undefined) {
+        return result[0];
+    } else {
+        return null;
+    }
+}
+
+function mapFieldNamesReverse(customFields, mapping) {
+    log.debug('Apply field mapping on', customFields, mapping);
+    const mappedFields = [];
+    customFields.forEach(customField => {
+        mapping.forEach(mappingEntry => {
+            if (mappingEntry.oldName === customField) {
+                mappedFields.push(mappingEntry.newName);
+            }
+        });
+    });
+    log.debug('mapped fields', mappedFields);
+    return mappedFields;
+}
+
+function mapFieldNameReverse(customField, mapping) {
+    const result = mapFieldNamesReverse([customField], mapping);
+    if (result !== null && result !== undefined) {
+        return result[0];
+    } else {
+        return null;
+    }
+}
+
+function applyMapping2record (myEntry, clientConfig, mapping) {
+    const constants = clientConfig['cmdbobject'].constants;
+    const allowedFields = clientConfig['cmdbobject'].fields;
+    //apply mapping
+    if (mapping != null && mapping != undefined) {
+        Object.keys(myEntry).forEach(function (objectKey) {
+            const found = mapping.find(function(element) {
+                //check if field is included in mapping and if it in accessible field list
+                return (element.newName === objectKey && allowedFields.includes(element.oldName));
+            });
+
+            if (found == null || found=== undefined) {
+                log.debug('delete', objectKey)
+                delete myEntry[objectKey];
+            }
+        });
+        mapping.forEach(function (mappingEntry) {
+            try {
+                Object.defineProperty(myEntry, mappingEntry.oldName, Object.getOwnPropertyDescriptor(myEntry, mappingEntry.newName));
+                //delete mapping only if no self mapping
+                if (!(mappingEntry.newName == mappingEntry.oldName)) {
+                    delete myEntry[mappingEntry.newName];
+                }
+            } catch (e) {
+                //ignore missing mapping
+            }
+        });
+    }
+    //add constant values (defaults)
+    if (constants && Array.isArray(constants) && constants.length) {
+
+        constants.forEach(function (element) {
+            log.debug('add constant', element);
+            try {
+                myEntry[element.name] = element.value;
+            } catch (e) {
+                log.error(e);
+            }
+
+        });
+    }
+    return myEntry;
+}
+
+module.exports = {
+    applyMapping,
+    applySortMapping,
+    getCustomFields,
+    mapFieldName,
+    mapFieldNameReverse,
+    applyMapping2record
+};