@manyos/smileconnect-api 1.28.0

package/controller/orgdataController.js

@@ -0,0 +1,440 @@
+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} = require('../util/paramHelper');
+const searchUtil = require('../util/searchUtil');
+const CONSTANTS = require('../util/constants');
+const relationUtil = require('../util/relationUtil');
+
+const orgDataCache = new CacheService(process.env.CACHETTL_ORGDATA || 3600); // Create a new cache service instance
+
+function queryPersons(clientConfig, query, mapping, customFields, customOptions, includeString) {
+    const includeArray = getIncludeArray(includeString);
+    let fields = clientConfig.person.fields;
+
+    //check for customFields
+    if (customFields !== null && customFields !== undefined) {
+        fields = customFields;
+    }
+
+    log.debug('fields', fields, customFields);
+    log.debug('customOptions', customOptions);
+    const options = {
+        ...clientConfig.options, ...customOptions
+    };
+
+    log.debug('use joined options', options);
+
+    const key = clientConfig.person.basequery + fields + query + JSON.stringify(options) + includeArray;
+    log.debug('Cachekey is ', key);
+    if (mapping == null || mapping == undefined) {
+        mapping = config.getMapping('person');
+    }
+    log.debug('mapping', mapping);
+
+    return orgDataCache.get(key, async function () {
+        const result = await arquery.executeARQuery('CTM:People', clientConfig.person.basequery || null, query, fields, customOptions);
+        const persons = [];
+        const globalRelationObjects = relationUtil.prepareGlobalRelationObject();
+        if (result && result.data && result.data.length) {
+            let x = 0;
+            for (x=0; x< result.data.length; x++) {
+                const person = await handlePerson(result.data[x], mapping, clientConfig, includeArray, globalRelationObjects);
+                persons.push(person)
+            }
+        }
+        log.debug('persons', persons);
+        return {
+            "data": persons,
+            "included": globalRelationObjects
+        };
+        });
+}
+
+async function handlePerson(person, mapping, clientConfig, includeArray, globalRelationObjects) {
+    mapping.forEach(function (mappingEntry) {
+        try {
+            Object.defineProperty(person, mappingEntry.newName, Object.getOwnPropertyDescriptor(person, mappingEntry.oldName));
+            delete person[mappingEntry.oldName];
+        } catch (e) {
+            //ignore missing mapping
+        }
+    });
+    //delete element['Entry ID'];
+    if (includeArray.includes('groupMembership')) {
+        log.debug('Read GroupMembership');
+        const groups = await getPersonGroups(clientConfig, person.id);
+        person.supportGroups = groups || [];
+        person.supportGroups.forEach(supportGroup => {
+            globalRelationObjects.supportgroups.add(supportGroup.supportGroupId);
+        });
+        log.debug('gr', groups);
+    }
+    return person;
+}
+
+function querySupportGroups(clientConfig, query, mapping, customFields, customOptions, includeString) {
+    const includeArray = getIncludeArray(includeString);
+    let fields = clientConfig.supportGroup.fields;
+
+    //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 = clientConfig.supportGroup.basequery + fields + query + JSON.stringify(options) + includeArray;
+    log.debug('Cachekey is ', key);
+    if (mapping == null || mapping == undefined) {
+        mapping = config.getMapping('supportGroup');
+    }
+    log.debug('mapping', mapping);
+
+    return orgDataCache.get(key, async function () {
+        const result = await arquery.executeARQuery(CONSTANTS.FORM_SUPPORTGROUP, clientConfig.supportGroup.basequery || null, query, fields, customOptions);
+        const supportGroups = [];
+        const globalRelationObjects = relationUtil.prepareGlobalRelationObject();
+        if (result && result.data && result.data.length) {
+            let x = 0;
+            for (x=0; x< result.data.length; x++) {
+                const supportGroup = await handleSupportGroup(result.data[x], mapping, clientConfig, includeArray, globalRelationObjects);
+                supportGroups.push(supportGroup)
+            }
+        }
+        log.debug('persons', supportGroups);
+        return {
+            "data": supportGroups,
+            "included": globalRelationObjects
+        };
+    });
+}
+
+async function handleSupportGroup(supportGroup, mapping, clientConfig, includeArray, globalRelationObjects) {
+    mapping.forEach(function (mappingEntry) {
+        try {
+            Object.defineProperty(supportGroup, mappingEntry.newName, Object.getOwnPropertyDescriptor(supportGroup, mappingEntry.oldName));
+            delete supportGroup[mappingEntry.oldName];
+        } catch (e) {
+            //ignore missing mapping
+        }
+    });
+    //delete element['Entry ID'];
+    if (includeArray.includes('personRelations')) {
+        log.debug('Read personRelations', supportGroup.id);
+        const relations = await getGroupMembers(clientConfig, supportGroup.id);
+        log.debug('Relations', relations);
+        supportGroup.relations = {};
+        supportGroup.relations.personRelations = relations || [];
+    }
+    relationUtil.getRelatedObjectList(supportGroup, includeArray, globalRelationObjects);
+    return supportGroup;
+}
+
+
+function queryOrganisations(clientConfig, query, mapping, customFields, customOptions, includeString) {
+    const includeArray = getIncludeArray(includeString);
+    let fields = clientConfig.organisation.fields;
+
+    //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 = clientConfig.organisation.basequery + fields + query + JSON.stringify(options) + includeArray;
+    log.debug('Cachekey is ', key);
+    if (mapping == null || mapping == undefined) {
+        mapping = config.getMapping('organisation');
+    }
+    log.debug('mapping', mapping);
+
+    return orgDataCache.get(key, async function () {
+        const result = await arquery.executeARQuery(CONSTANTS.FORM_ORGANISATION, clientConfig.organisation.basequery || null, query, fields, customOptions);
+        const organisations = [];
+        const globalRelationObjects = relationUtil.prepareGlobalRelationObject();
+        if (result && result.data && result.data.length) {
+            let x = 0;
+            for (x=0; x< result.data.length; x++) {
+                const organisation = await handleOrganisation(result.data[x], mapping, clientConfig, includeArray, globalRelationObjects);
+                organisations.push(organisation)
+            }
+        }
+        log.debug('persons', organisations);
+        return {
+            "data": organisations,
+            "included": globalRelationObjects
+        };
+    });
+}
+
+async function handleOrganisation(organisation, mapping, clientConfig, includeArray, globalRelationObjects) {
+    mapping.forEach(function (mappingEntry) {
+        try {
+            Object.defineProperty(organisation, mappingEntry.newName, Object.getOwnPropertyDescriptor(organisation, mappingEntry.oldName));
+            delete organisation[mappingEntry.oldName];
+        } catch (e) {
+            //ignore missing mapping
+        }
+    });
+    //delete element['Entry ID'];
+    if (includeArray.includes('personRelations')) {
+        log.debug('Read personRelations', organisation.id);
+        const relations = await getOrgMembers(clientConfig, organisation.company, organisation.organisation, organisation.department);
+        log.debug('Relations', relations);
+        organisation.relations = {};
+        organisation.relations.personRelations = relations || [];
+    }
+    relationUtil.getRelatedObjectList(organisation, includeArray, globalRelationObjects);
+    return organisation;
+}
+
+
+
+function getPersonGroups(clientConfig, personId) {
+    const query = `'Person ID'=\"${personId}\" AND 'Status-SGP' = \"Enabled\" AND 'Status-SGA' = \"Enabled\"`;
+    return orgDataCache.get(query, function () {
+        return new Promise((resolve, reject) => {
+            arquery.executeARQuery('CTM:Support Group Assoc LookUp',  null, query, 'Default, Assignment Availability, Support Group ID', clientConfig.options)
+                .then(function (result) {
+                    const data = result.data.map(entry => {
+                        const newEntry = {};
+                        newEntry.supportGroupId = entry['Support Group ID'];
+                        newEntry.isDefault = entry['Default'];
+                        newEntry.assignmentAvailability = entry['Assignment Availability'];
+                        return newEntry;
+                    });
+                    const rolePromises = [];
+
+                    data.forEach (record => {
+                        rolePromises.push(
+                            getFunctionalRoles(clientConfig, personId, record.supportGroupId).then(rolesResult => {
+                                record.roles = rolesResult;
+                            })
+                        );
+                    });
+                    Promise.all(rolePromises).then(function() {
+                        resolve(data || {});
+                    });
+
+                })
+                .catch(function (reason) {
+                    log.error(reason);
+                    reject(reason);
+                })
+        });
+    });
+}
+
+function getGroupMembers(clientConfig, supportGroupId) {
+
+    const query = `'Support Group ID'=\"${supportGroupId}\" AND 'Status-SGA' = \"Enabled\"`;
+    return orgDataCache.get(query, async function () {
+        const result = await arquery.executeARQuery('CTM:Support Group Assoc LookUp',  null, query, 'Default, Assignment Availability, Person ID', clientConfig.options);
+        const data = result.data.map(entry => {
+            const newEntry = {};
+            newEntry.id = entry['Person ID'];
+            newEntry.isDefaultGroup = entry['Default'];
+            newEntry.assignmentAvailability = entry['Assignment Availability'];
+            return newEntry;
+        });
+        const rolePromises = [];
+        data.forEach (record => {
+            rolePromises.push(
+                getFunctionalRoles(clientConfig, record.id, supportGroupId).then(rolesResult => {
+                    record.roles = rolesResult;
+                })
+            );
+        });
+        return data;
+    });
+}
+
+function getOrgMembers(clientConfig, company, organisation, department) {
+
+    const query = `'Company'="${company}" AND 'Organization' = "${organisation}" AND 'Department' = "${department}"`;
+    return orgDataCache.get(query, async function () {
+        const result = await arquery.executeARQuery(CONSTANTS.FORM_PEOPLE,  null, query, 'Person ID', clientConfig.options);
+        const data = result.data.map(entry => {
+            const newEntry = {};
+            newEntry.id = entry['Person ID'];
+            return newEntry;
+        });
+        return data;
+    });
+}
+
+function getFunctionalRoles(clientConfig, personId, supportGroupId) {
+    const query = `'Person ID'=\"${personId}\" AND 'Status' = \"Enabled\" AND 'Support Group ID' = \"${supportGroupId}\"`;
+    return orgDataCache.get(query, function () {
+        return new Promise((resolve, reject) => {
+            arquery.executeARQuery('CTM:SupportGroupFunctionalRole',  null, query, 'Functional Role, FunctionalRoleAlias', clientConfig.options)
+                .then(function (result) {
+                    const data = result.data.map(entry => {
+                        return entry['FunctionalRoleAlias'];
+                    });
+                    resolve(data || {});
+                })
+                .catch(function (reason) {
+                    log.error(reason);
+                    reject(reason);
+                })
+        });
+    });
+}
+
+async function getOrganisation(clientConfig, orgId, mapping, include) {
+    const query = `'People Organization ID' = "${orgId}"`;
+    try {
+        const returnValue = await queryOrganisations(clientConfig, query, mapping, null,null, include);
+        const organisation =  returnValue.data[0];
+        return {data: organisation, included: returnValue.included};
+    } catch (error) {
+        throw error;
+    }
+}
+
+async function getSupportGroup(clientConfig, groupId, mapping, include) {
+    const query = `'Support Group ID' = "${groupId}"`;
+    try {
+        const returnValue = await querySupportGroups(clientConfig, query, mapping, null,null, include);
+        const supportGroup =  returnValue.data[0];
+        return {data: supportGroup, included: returnValue.included};
+    } catch (error) {
+        throw error;
+    }
+}
+
+function resolveIncludedOrgData(clientConfig, includedObjects) {
+    return new Promise((resolve, reject) => {
+        if (includedObjects) {
+            let result = {"persons":[], "organisations": [], "supportgroups": []};
+            const queryPromises = [];
+            if (includedObjects.persons) {
+                includedObjects.persons.forEach(function (personId) {
+                    log.debug('searchPeople', personId);
+                    queryPromises.push(
+                        getPerson(clientConfig, personId).then(function (personData) {
+                            log.debug('persData', {id:personId, data: personData});
+                            result.persons.push(personData);
+                        })
+                    );
+                })
+            }
+            if (includedObjects.organisations) {
+                includedObjects.organisations.forEach(function (orgId) {
+                    log.debug('searchOrganisation', orgId);
+                    queryPromises.push(
+                        getOrganisation(clientConfig, orgId).then(function (orgData) {
+                            log.debug('orgData', {id:orgId, data: orgData});
+                            result.organisations.push(orgData);
+                        })
+                    );
+                })
+            }
+            if (includedObjects.supportgroups) {
+                includedObjects.supportgroups.forEach(function (groupId) {
+                    log.debug('searchSupportGroup', groupId);
+                    queryPromises.push(
+                        getSupportGroup(clientConfig, groupId).then(function (groupData) {
+                            //todo check for empty groups isEmpty(groupData)
+                            if (groupData != null && groupData != undefined) {
+                                log.debug('groupData', {id:groupId, data: groupData});
+                                result.supportgroups.push(groupData);
+                            }
+                        })
+                    );
+                })
+            }
+
+            Promise.all(queryPromises).then(function() {
+                resolve(result);
+            });
+        }
+    });
+}
+
+async function getPersons(config, mapping, include, customOptions) {
+    const query = `1=1`;
+    const returnValue = await queryPersons(config, query, mapping, null, customOptions, include);
+    return {data: returnValue.data};
+}
+
+async function getSupportGroups(config, mapping, include, customOptions) {
+    const query = `1=1`;
+    const returnValue = await querySupportGroups(config, query, mapping, null, customOptions, include);
+    return returnValue;
+}
+
+async function getOrganisations(config, mapping, include, customOptions) {
+    const query = `1=1`;
+    const returnValue = await queryOrganisations(config, query, mapping, null, customOptions, include);
+    return returnValue;
+}
+
+async function getPerson(config, personId, isLoginId, mapping, include) {
+    let query = '';
+    if (isLoginId === true) {
+        query = `'Remedy Login ID'=\"${personId}\"`;
+    } else {
+        query = `'Person ID'=\"${personId}\"`;
+    }
+    try {
+        const returnValue = await queryPersons(config, query, mapping, null,null, include);
+        const person =  returnValue.data[0];
+        return {data: person, included: returnValue.included};
+    } catch (error) {
+        throw error;
+    }
+}
+
+async function searchPerson(clientConfig, searchString, fields, options, include) {
+    const mapping = config.getMapping('person');
+    const mappedString = searchUtil.applyMapping(searchString, mapping);
+    const customFields = searchUtil.getCustomFields(clientConfig.person.fields, mapping, fields);
+    options.sort = searchUtil.applySortMapping(options.sort, mapping);
+    return await queryPersons(clientConfig, mappedString, null, customFields, options, include);
+}
+
+async function searchSupportGroup(clientConfig, searchString, fields, options, include) {
+    const mapping = config.getMapping('supportGroup');
+    const mappedString = searchUtil.applyMapping(searchString, mapping);
+    const customFields = searchUtil.getCustomFields(clientConfig.supportGroup.fields, mapping, fields);
+    options.sort = searchUtil.applySortMapping(options.sort, mapping);
+    return await querySupportGroups(clientConfig, mappedString, null, customFields, options, include);
+}
+
+async function searchOrganisations(clientConfig, searchString, fields, options, include) {
+    const mapping = config.getMapping('organisation');
+    const mappedString = searchUtil.applyMapping(searchString, mapping);
+    const customFields = searchUtil.getCustomFields(clientConfig.organisation.fields, mapping, fields);
+    options.sort = searchUtil.applySortMapping(options.sort, mapping);
+    return await queryOrganisations(clientConfig, mappedString, null, customFields, options, include);
+}
+
+module.exports = {
+    getPerson,
+    getPersons,
+    searchPerson,
+    getOrganisation,
+    getOrganisations,
+    searchOrganisations,
+    getSupportGroup,
+    getSupportGroups,
+    searchSupportGroup,
+    resolveIncludedOrgData
+};

package/controller/relatedObjectsController.js

@@ -0,0 +1,194 @@
+require('dotenv').config();
+const path = require('path');
+const log = require('@manyos/logger').setupLog('SMILEconnect_' + path.basename(__filename));
+const orgdata = require('../controller/orgdataController');
+const cmdbObjectController = require('../controller/cmdbobjectController');
+const ticketCiRelation = require('./ticketCIRelationController');
+
+async function getRelatedObjects(req, res, next) {
+    log.debug('include Data', req.includeArray);
+    log.debug('include Objects', req.includeObjectsList);
+    if (req.result && req.includeObjectsList && req.includeArray) {
+        let result = {};
+        const includedObjects = req.includeObjectsList;
+        const clientConfig = req.user.config;
+
+        if (req.includeArray.includes('persons') && includedObjects.persons) {
+            const persons = [];
+            const personArray = Array.from(includedObjects.persons);
+            let x=0;
+            for (x=0; x < personArray.length; x++) {
+                const personId = personArray[x];
+                log.debug('searchPeople', personId);
+                const result = await orgdata.getPerson(clientConfig, personId);
+                const person = result.data;
+                log.debug('pers', person);
+                if (person) {
+                    persons.push(person);
+                }
+            }
+            result.persons = persons;
+        }
+
+        if (req.includeArray.includes('organisations') && includedObjects.organisations) {
+            const organisations = [];
+            const organisationArray = Array.from(includedObjects.organisations);
+            let x=0;
+            for (x=0; x < organisationArray.length; x++) {
+                const orgId = organisationArray[x];
+                log.debug('searchOrganisation', orgId);
+                const result = await orgdata.getOrganisation(clientConfig, orgId);
+                const org = result.data;
+                if (org) {
+                    organisations.push(org);
+                }
+            }
+            result.organisations = organisations;
+        }
+
+        if (req.includeArray.includes('supportGroups') && includedObjects.supportgroups) {
+            const supportGroups = [];
+            const supportGroupArray = Array.from(includedObjects.supportgroups);
+            let x=0;
+            for (x=0; x < supportGroupArray.length; x++) {
+                const groupId = supportGroupArray[x];
+                log.debug('searchSupportGroup', groupId);
+                const result = await orgdata.getSupportGroup(clientConfig, groupId);
+                const supportGroup = result.data;
+                if (supportGroup) {
+                    supportGroups.push(supportGroup);
+                }
+            }
+            result.supportgroups = supportGroups;
+        }
+
+        if (req.includeArray.includes('cmdbObjects') && includedObjects.cmdbObjects) {
+            const cmdbObjects = [];
+            let x=0;
+            const cmdbObjectArray = Array.from(includedObjects.cmdbObjects);
+            log.debug(cmdbObjectArray);
+            for (x=0; x < cmdbObjectArray.length; x++) {
+                const ciId = cmdbObjectArray[x];
+                log.debug('searchCMDBObject', ciId);
+                const cmdbObject = await cmdbObjectController.getCmdbObject(clientConfig, ciId);
+                if (cmdbObjects !== null && cmdbObjects !== undefined && cmdbObject && cmdbObject.data) {
+                    cmdbObjects.push(cmdbObject.data);
+                }
+            }
+            result.cmdbObjects = cmdbObjects;
+        }
+
+        if (req.includeArray.includes('incidents') && includedObjects.incidents) {
+            const incidents = [];
+            const incidentArray = Array.from(includedObjects.incidents);
+            let x=0;
+            for (x=0; x < incidentArray.length; x++) {
+                const id = incidentArray[x];
+                log.debug('searchIncident', id);
+                const result = await incidentController.getIncident(clientConfig, id);
+                if (result && result.data) {
+                    incidents.push(result.data);
+                }
+            }
+            result.incidents = incidents;
+        }
+
+        if (req.includeArray.includes('workOrders') && includedObjects.workOrders) {
+            const tickets = [];
+            const ticketIdArray = Array.from(includedObjects.workOrders);
+            let x=0;
+            for (x=0; x < ticketIdArray.length; x++) {
+                const id = ticketIdArray[x];
+                log.debug('searchWorkOrder', id);
+                const result = await workOrderController.getWorkOrder(clientConfig, id);
+                if (result && result.data) {
+                    tickets.push(result.data);
+                }
+            }
+            result.workOrders = tickets;
+        }
+
+        if (req.includeArray.includes('problems') && includedObjects.problems) {
+            const tickets = [];
+            const ticketIdArray = Array.from(includedObjects.problems);
+            let x=0;
+            for (x=0; x < ticketIdArray.length; x++) {
+                const id = ticketIdArray[x];
+                log.debug('searchProblem', id);
+                const result = await problemController.getProblem(clientConfig, id);
+                if (result && result.data) {
+                    tickets.push(result.data);
+                }
+            }
+            result.problems = tickets;
+        }
+
+        if (req.includeArray.includes('changes') && includedObjects.changes) {
+            const tickets = [];
+            const ticketIdArray = Array.from(includedObjects.changes);
+            let x=0;
+            for (x=0; x < ticketIdArray.length; x++) {
+                const id = ticketIdArray[x];
+                log.debug('searchChange', id);
+                const result = await changeController.getChange(clientConfig, id);
+                if (result && result.data) {
+                    tickets.push(result.data);
+                }
+            }
+            result.changes = tickets;
+        }
+
+        log.debug('done');
+
+        //backward compatibility
+        if (req.includeObjects || (req.body && req.body.getRelations)) {
+            replaceAllKeys(req.result.data);
+        }
+        req.result.included = result || {};
+        next();
+    } else {
+        if (req.result) {
+            req.result.included = {};
+        }
+        next();
+    }
+}
+
+function replaceAllKeys(objects) {
+    log.debug('replaceKeys in', objects);
+    if (objects !== null && objects !== undefined) {
+        if (Array.isArray(objects)) {
+            objects.forEach(item => {
+                replaceObjectKeys(item);
+            });
+        } else {
+            replaceObjectKeys(objects);
+        }
+    }
+    return objects;
+}
+
+function replaceObjectKeys(item) {
+    if (item.relations !== null && item.relations !== undefined) {
+        log.debug('keys', Object.keys(item.relations));
+        Object.keys(item.relations).forEach(key => {
+            if (key === 'ciRelations') {
+                log.debug ('Rename', key);
+                item.relations.relatedCIs = item.relations[key];
+            } else if (key === 'personRelations') {
+                log.debug ('Rename', key);
+                item.relations.relatedPersons = item.relations[key];
+            } else if (key === 'supportGroupRelations') {
+                log.debug ('Rename', key);
+                item.relations.relatedSupportGroups = item.relations[key];
+            } else if (key === 'organisationRelations') {
+                log.debug ('Rename', key);
+                item.relations.relatedOrganisations = item.relations[key];
+            }
+        });
+    }
+}
+
+module.exports = {
+    getRelatedObjects
+}