@manyos/smileconnect-api 1.28.0

package/controller/ticketCIRelationController.js

@@ -0,0 +1,522 @@
+const path = require('path');
+const log = require('@manyos/logger').setupLog('SMILEconnect_' + path.basename(__filename));
+const CONSTANTS = require('../util/constants');
+const arquery = require('../util/arquery');
+const CacheService = require ('../util/cache.service');
+const {getLinkCI, applyMapping} = require('../util/paramHelper');
+//const cmdbObjectController = require('./cmdbobjectController');
+const {ticketConfig} = require ('../util/config');
+
+const utilCache = new CacheService(process.env.CACHETTL_TICKETCIRELATIONS || 600); // Create a new cache service instance
+
+function getSchemaName(lookupKeyword) {
+    log.debug('Search for SchemaName', lookupKeyword);
+    const query = `'Lookup Keyword'="${lookupKeyword}" AND 'Locale' = $NULL$`;
+    const form = CONSTANTS.FORM_SCHEMA_NAMES;
+    return utilCache.get(form + ':' + query, function () {
+        return new Promise((resolve, reject) => {
+            //TODO: Handle error for CMDB Objects without asset form
+            arquery.executeARQuery(form, null, query, ['Schema Name']).then(queryResponse => {
+                const schemaName = queryResponse.data[0]['Schema Name'];
+                log.debug('Found schemaName', schemaName);
+                resolve(schemaName);
+            }).catch(reason => {
+                reject(reason);
+            });
+        });
+    });
+}
+
+async function getTicketCIRelations(ticketId) {
+    const relations = await getCITicketRelations(null, ticketId);
+    if (relations && Array.isArray(relations)) {
+        let x=0;
+        for (x=0;x<relations.length;x++) {
+            const item = relations[x];
+            delete item['ticketId'];
+            const oppositeType = await getOppositeAssocTypeByType(item.relationType);
+            if (oppositeType) {
+                item.relationType = oppositeType.oppositeType;
+            }
+        }
+    }
+    return relations;
+}
+
+async function getCITicketRelations(ciInstanceId, ticketId) {
+    let ci2ticketOnly = false;
+    if (ticketId === null || ticketId === undefined) {
+        ci2ticketOnly = true;
+    }
+    log.debug('Search for CI', ciInstanceId);
+    let query = '';
+    query = '';
+    if (ciInstanceId !== null && ciInstanceId !== undefined) {
+        const ciData = await getCIData(ciInstanceId);
+        log.debug('found CI', ciData);
+        query = query + `'Request ID02' = "${ciData.ReconciliationIdentity}"`;
+    }
+    if (ticketId != null && ticketId != undefined && ciInstanceId != null && ciInstanceId != undefined) {
+        query = query + ' AND ';
+    }
+    if (ticketId != null && ticketId != undefined) {
+        query = query + `'Request ID01' = "${ticketId}"`;
+    }
+    const form = CONSTANTS.FORM_ASSET_TICKET_ASSOC;
+
+    const result = await arquery.executeARQuery(form, null, query, ['Request ID02', 'Request ID01', 'Association Type01', 'Request Type01', 'Request Description01']);
+    const relations = [];
+    for (const relationData of result.data) {
+        let relation = {};
+        if (ci2ticketOnly) {
+            relation = {
+                ticketId: relationData['Request ID01'],
+                ticketType: relationData['Request Type01'],
+                ticketSummary: relationData['Request Description01'],
+                relationType: relationData['Association Type01']
+            };
+        } else {
+            const ci = await getCiByReconId(relationData['Request ID02']);
+            relation = {
+                ciId: ci['Instance Id'],
+                ciName: ci['Name'],
+                ciClass: ci['Class Id'],
+                ciStatus: ci['AssetLifecycleStatus'],
+                ciReconId: relationData['Request ID02'],
+                relationType: relationData['Association Type01'],
+                link: getLinkCI(ci['Instance Id'])
+            };
+        }
+        relations.push(relation);
+    }
+    return relations;
+}
+
+async function getTicket2TicketRelations(ticketConfig, ticketId) {
+    const form = ticketConfig.forms.assoc;
+    const query = `'Request ID02' = "${ticketId}" AND NOT 'Request Type01' = "Configuration Item"`;
+    const result = await arquery.executeARQuery(form, null, query, ['Request ID02', 'Request ID01', 'Association Type01', 'Request Type01', 'Request Description01']);
+    const relations = [];
+    for (const relationData of result.data) {
+        const relation = {
+            ticketId: relationData['Request ID01'],
+            relationType: relationData['Association Type01'],
+            ticketType: relationData['Request Type01'],
+            ticketSummary: relationData['Request Description01']
+        };
+        relations.push(relation);
+    }
+    return relations;
+}
+
+async function getAssocLookup(ticketForm, relationObject, assocType) {
+    const assocTypes = await getAssocTypesLookup(ticketForm, relationObject);
+    return assocTypes.find(assoc => {
+       return assoc.assocType === assocType;
+    });
+}
+
+async function createTicketCIRelation(ticketConfig, ticketId, ciInstanceId, assocType, ticketSummary) {
+    if (ticketSummary === null || ticketSummary === undefined) {
+        ticketSummary = 'summary';
+    }
+    const ticketForm = ticketConfig.forms.regular;
+    const ticketRelationForm = ticketConfig.forms.assoc;
+    const ticketKeyword = ticketConfig.assocTicketKeyword;
+    const ticketType = ticketConfig.assocTicketType;
+
+    const assocLookup = await getAssocLookup(ticketForm, 'Configuration Item', assocType);
+    if (assocLookup === null || assocLookup === undefined) {
+        throw new Error(`Association Type ${assocType} not found.`);
+    }
+    log.debug('found AssocType', assocLookup);
+    const ciData = await getCIData(ciInstanceId);
+    if (ciData === null || ciData === undefined) {
+        throw new Error(`CI ${ciInstanceId} not found.`);
+    }
+    const schemaName = await getSchemaName(ciData.ClassId);
+    const ticketRelationFormData = {
+        "Form Name01" : schemaName,
+        "Request ID01" : ciData.ReconciliationIdentity,
+        "Request Type01" : 6000,
+        "Form Name02" : ticketForm,
+        "Association Type01": assocLookup.assocCode,
+        "Request Description01": ciData.Name,
+        "Request ID02": ticketId,
+        "Lookup Keyword": ciData.ClassId
+    };
+    const assetRelationFormData = {
+        "Form Name01" : ticketForm,
+        "Request ID01" : ticketId,
+        "Request Type01" : ticketType,
+        "Form Name02" : schemaName,
+        "Lookup Keyword01": ticketKeyword,
+        "Association Type01": assocLookup.oppositeCode,
+        "Request Description01": ticketSummary,
+        "Request ID02": ciData.ReconciliationIdentity,
+        "Lookup Keyword": ciData.ClassId,
+        "Parent_DataSet_ID01": "BMC.ASSET"
+    };
+    log.debug('Create CI Ticket Relation', ticketRelationFormData);
+    //todo: implement impersonate
+    const ticketRelation = await arquery.createEntry(ticketRelationForm, ticketRelationFormData);
+    const assetRelation = await arquery.createEntry(CONSTANTS.FORM_ASSET_TICKET_ASSOC, assetRelationFormData);
+    return {ticketRelation, assetRelation}
+}
+
+async function createTicket2TicketRelation(ticketConfig, ticketId1, ticketConfig2, ticketId2, assocType, ticketSummary) {
+    //todo fix request description
+    if (ticketSummary === null || ticketSummary === undefined) {
+        ticketSummary = 'summary';
+    }
+    const ticketForm = ticketConfig.forms.regular;
+
+    const assocLookup = await getAssocLookup(ticketForm, ticketConfig2.assocTicketType, assocType);
+    if (assocLookup === null || assocLookup === undefined) {
+        throw new Error(`Association Type ${assocType} not found.`);
+    }
+    log.debug('found AssocType', assocLookup);
+    const ticketRelationFormData1 = {
+        "Form Name01" : ticketConfig2.forms.regular,
+        "Request ID01" : ticketId2,
+        "Request Type01" : ticketConfig2.assocTicketType,
+        "Form Name02" : ticketConfig.forms.regular,
+        "Association Type01": assocLookup.assocCode,
+        "Request Description01": ticketSummary,
+        "Request ID02": ticketId1,
+        "Lookup Keyword": ticketConfig2.assocTicketKeyword
+    };
+    const ticketRelationFormData2 = {
+        "Form Name01" : ticketConfig.forms.regular,
+        "Request ID01" : ticketId1,
+        "Request Type01" : ticketConfig.assocTicketType,
+        "Form Name02" : ticketConfig2.forms.regular,
+        "Association Type01": assocLookup.assocCode,
+        "Request Description01": ticketSummary,
+        "Request ID02": ticketId2,
+        "Lookup Keyword": ticketConfig2.assocTicketKeyword
+    };
+
+    //todo: implement impersonate
+    log.debug('Create Ticket 2 Ticket Relation', ticketRelationFormData1, ticketRelationFormData2);
+    const ticketRelation1 = await arquery.createEntry(ticketConfig.forms.assoc, ticketRelationFormData1);
+    const ticketRelation2 = await arquery.createEntry(ticketConfig2.forms.assoc, ticketRelationFormData2);
+    return {ticketRelation1, ticketRelation2}
+}
+
+
+async function deleteTicketCIRelation(ticketConfig, ticketId, ciInstanceId) {
+    const ticketRelationForm = ticketConfig.forms.assoc;
+    const ciData = await getCIData(ciInstanceId);
+    const ticketRelationQuery = `'Request ID02'= "${ticketId}" AND 'Request ID01' = "${ciData.ReconciliationIdentity}"`;
+    const assetRelationQuery = `'Request ID02'= "${ciData.ReconciliationIdentity}" AND 'Request ID01' = "${ticketId}"`;
+    log.debug('Delete Ticket2CI Relation', ticketRelationQuery);
+    log.debug('Delete CI2Ticket Relation', assetRelationQuery);
+    const ticketRelation = await arquery.deleteEntries(ticketRelationForm, '1=1', ticketRelationQuery);
+    const assetRelation = await arquery.deleteEntries(CONSTANTS.FORM_ASSET_TICKET_ASSOC, '1=1', assetRelationQuery);
+    return {ticketRelation, assetRelation}
+}
+
+async function deleteTicket2TicketRelation(ticketConfig1, ticketId1, ticketConfig2, ticketId2) {
+    const ticketRelationQuery1 = `'Request ID02'= "${ticketId1}" AND 'Request ID01' = "${ticketId2}"`;
+    const ticketRelationQuery2 = `'Request ID02'= "${ticketId2}" AND 'Request ID01' = "${ticketId1}"`;
+    log.debug('Delete Ticket2Ticket Relation1', ticketRelationQuery1);
+    log.debug('Delete Ticket2Ticket Relation2', ticketRelationQuery2);
+    const ticketRelation1 = await arquery.deleteEntries(ticketConfig1.forms.assoc, '1=1', ticketRelationQuery1);
+    const ticketRelation2 = await arquery.deleteEntries(ticketConfig2.forms.assoc, '1=1', ticketRelationQuery2);
+    return {ticketRelation1, ticketRelation2}
+}
+
+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);
+                }
+            });
+        }
+
+    }
+}
+
+function getAssocTypes() {
+    log.debug('read assoc type config');
+    let fields = ['Association Type01', 'Selection Code', 'OppositeAssocType', 'OppositeSelectionCode'];
+
+    const form = CONSTANTS.FORM_SYS_ASSOCIATION_TYPES_OPPO;
+
+    const mapping = [
+        {
+            "oldName": "Association Type01",
+            "newName": "assocType"
+        },
+        {
+            "oldName": "Selection Code",
+            "newName": "assocCode"
+        },
+        {
+            "oldName": "OppositeAssocType",
+            "newName": "oppositeType"
+        },
+        {
+            "oldName": "OppositeSelectionCode",
+            "newName": "oppositeCode"
+        }
+    ];
+    log.debug('mapping', mapping);
+
+    return utilCache.get(form, async function () {
+        const result = await arquery.executeARQuery(form, null, '1=1', fields.toString() || '1');
+        if (result && result.data && result.data.length) {
+            let x = 0;
+            for (x = 0; x < result.data.length; x++) {
+                applyMapping(result.data[x],mapping,'Request ID');
+            }
+        }
+        log.debug('result', result.data);
+        return result.data;
+    });
+}
+
+function getAssocTypesLookup(primaryForm, relationObject) {
+    log.debug('read assoc type config');
+    let fields = ['Association Type01', 'Selection Code', 'RequestTypeSelectionCode'];
+
+    const form = CONSTANTS.FORM_SYS_ASSOCIATION_TYPES_LOOKUP;
+
+    const mapping = [
+        {
+            "oldName": "Association Type01",
+            "newName": "assocType"
+        },
+        {
+            "oldName": "Selection Code",
+            "newName": "assocCode"
+        },
+        {
+            "oldName": "RequestTypeSelectionCode",
+            "newName": "requestTypeSelectionCode"
+        }
+    ];
+    log.debug('mapping', mapping);
+
+    const query = `'Locale' = $NULL$ AND 'Status-ATA' = "Enabled" AND 'Status-ATY' = "Enabled" AND 'Status-RTY' = "Enabled" AND 'Form Name02' = "${primaryForm}" AND 'Request Type01' = "${relationObject}"`;
+
+    return utilCache.get(primaryForm,async function () {
+        const result = await arquery.executeARQuery(form, null, query, fields.toString() || '1');
+        if (result && result.data && result.data.length) {
+            let x = 0;
+            for (x = 0; x < result.data.length; x++) {
+                const assocLookup = result.data[x];
+                applyMapping(assocLookup,mapping,'AssociationTypeAssocLookUP ID');
+                const opposite = await getOppositeAssocTypeByCode(assocLookup.assocCode);
+                assocLookup.oppositeCode = opposite.oppositeCode;
+                assocLookup.oppositeType = opposite.oppositeType;
+            }
+        }
+        log.debug('result', result.data);
+        return result.data;
+    });
+}
+
+async function getOppositeAssocTypeByType(assocType) {
+    const assocTypes = await getAssocTypes();
+    return assocTypes.find(assoc => {
+        return assoc.assocType === assocType;
+    });
+}
+
+async function getOppositeAssocTypeByCode(assocCode) {
+    const assocTypes = await getAssocTypes();
+    return assocTypes.find(assoc => {
+        return assoc.assocCode === assocCode;
+    });
+}
+
+function doesCIRelationExists(ticketRelations, newRelation) {
+    const relationFound = ticketRelations.find(relation => {
+        return (relation.ciId === newRelation.ciId &&
+            relation.relationType === newRelation.relationType);
+    });
+    if (relationFound) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+function doesTicketRelationExists(ticketRelations, newRelation) {
+    const relationFound = ticketRelations.find(relation => {
+        return (relation.ticketId === newRelation.ticketId &&
+            relation.relationType === newRelation.relationType);
+    });
+    if (relationFound) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+async function updateRelations(ticketConfig, userConfig, ticketId, relations) {
+    log.debug('Checker', {ticketConfig, userConfig, ticketId, relations});
+    //Cehck CI Relations
+    if (relations && relations.ciRelations && Array.isArray(relations.ciRelations)) {
+        const existingRelations = await getTicketCIRelations(ticketId);
+        log.debug('foundRelations', existingRelations);
+        let x=0;
+        //check for missiong relations
+        if (relations.ciRelations && Array.isArray(relations.ciRelations)) {
+            for (x=0; x<relations.ciRelations.length; x++) {
+                const relation = relations.ciRelations[x];
+                const relationsExists = doesCIRelationExists(existingRelations, relation);
+                log.debug('createRelation, already exists', relation, relationsExists);
+                if (!relationsExists) {
+                    await createTicketCIRelation(ticketConfig, ticketId, relation.ciId, relation.relationType);
+                }
+            }
+        }
+        //check for too many relations
+        if (existingRelations && Array.isArray(existingRelations)) {
+            for (x=0; x<existingRelations.length; x++) {
+                const relation = existingRelations[x];
+                const shouldRelationsExists = doesCIRelationExists(relations.ciRelations, relation);
+                log.debug('deleteRelation, already exists', relation, shouldRelationsExists);
+                if (!shouldRelationsExists) {
+                    await deleteTicketCIRelation(ticketConfig, ticketId, relation.ciId);
+                }
+            }
+        }
+    }
+    //check ticket2ticket relations
+    if (relations && relations.ticketRelations && Array.isArray(relations.ticketRelations)) {
+        const existingRelations = await getTicket2TicketRelations(ticketConfig, ticketId);
+        log.debug('foundRelations', existingRelations);
+        let x=0;
+        //check for missiong relations
+        if (relations.ticketRelations && Array.isArray(relations.ticketRelations)) {
+            for (x=0; x<relations.ticketRelations.length; x++) {
+                const relation = relations.ticketRelations[x];
+                const relationsExists = doesTicketRelationExists(existingRelations, relation);
+                log.debug('createRelation, already exists', relation, relationsExists);
+                if (!relationsExists) {
+                    const ticketConfig2 = getTicketConfigByTicketType(relation.ticketType);
+                    if (ticketConfig2 === null || ticketConfig2 === undefined) {
+                        throw new Error(`TicketConfig for ${relation.ticketType} not found.`);
+                    }
+                    await createTicket2TicketRelation(ticketConfig, ticketId, ticketConfig2, relation.ticketId, relation.relationType);
+                }
+            }
+        }
+
+        //check for too many relations
+        if (existingRelations && Array.isArray(existingRelations)) {
+            for (x=0; x<existingRelations.length; x++) {
+                const relation = existingRelations[x];
+                const shouldRelationsExists = doesTicketRelationExists(relations.ticketRelations, relation);
+                log.debug('deleteRelation, already exists', relation, shouldRelationsExists);
+                if (!shouldRelationsExists) {
+                    const ticketConfig2 = getTicketConfigByTicketType(relation.ticketType);
+                    if (ticketConfig2 === null || ticketConfig2 === undefined) {
+                        throw new Error(`TicketConfig for ${relation.ticketType} not found.`);
+                    }
+                    await deleteTicket2TicketRelation(ticketConfig, ticketId, ticketConfig2, relation.ticketId);
+                }
+            }
+        }
+    }
+}
+
+function getTicketConfigByTicketType(ticketType) {
+    const keys = Object.keys(ticketConfig);
+    let config = null;
+    keys.forEach(key => {
+        const currentConfig = ticketConfig[key];
+        if (currentConfig.assocTicketType === ticketType) {
+            config = currentConfig;
+            return;
+        }
+    });
+    return config;
+}
+
+function getCIData(instanceId) {
+    log.debug('Search for CI', instanceId);
+    //get only CIs with recon
+    const query = `'InstanceId'="${instanceId}" AND 'ReconciliationIdentity' != $NULL$ AND 'ReconciliationIdentity' != "0"`;
+    const form = CONSTANTS.FORM_CMDB_CI_BASE;
+    return utilCache.get(form + ':' + query, function () {
+        return new Promise((resolve, reject) => {
+            arquery.executeARQuery(form, null, query, ['ReconciliationIdentity', 'ClassId', 'Name']).then(queryResponse => {
+                //const schemaName = queryResponse.data[0]['Schema Name'];
+                log.debug('Found ci', queryResponse.data);
+                resolve(queryResponse.data[0]);
+            }).catch(reason => {
+                reject(reason);
+            });
+        });
+    });
+}
+
+async function getCiByReconId(reconId) {
+    log.debug('Search for CI', reconId);
+    //get only CIs with recon
+    const query = `'Reconciliation Identity'="${reconId}" AND 'Data Set Id' = "BMC.ASSET"`;
+    const form = CONSTANTS.FORM_CMDB_AST_BASE;
+    const result = await arquery.executeARQuery(form, null, query, ['InstanceId', 'AssetLifecycleStatus', 'Name', 'Class Id', 'Instance Id']);
+    if (result !== null && result !== undefined && result.data !== undefined) {
+        return result.data[0];
+    } else {
+        return null;
+    }
+}
+
+
+module.exports = {
+    deleteTicketCIRelation,
+    getTicketCIRelations,
+    getCITicketRelations,
+    getTicket2TicketRelations,
+    createTicketCIRelation,
+    updateRelations
+};