@manyos/smileconnect-api 1.52.4 → 1.53.0

package/Dockerfile

@@ -1,7 +1,7 @@
 ### STAGE 1: Build ###
 
 # We label our stage as 'builder'
-FROM node:12.14 as builder
+FROM node:16 as builder
 ARG NPM_TOKEN
 COPY package.json package-lock.json ./
 

package/app.js

@@ -184,8 +184,12 @@ app.use('/v1/health', function (req, res, next) {
 //health check
 app.use('/v1/openapi/:clientId', async function (req, res, next) {
     const clientId = req.params.clientId;
-    const spec = await config.getDesignPackage(clientId)
-    res.json(spec)
+    try {
+        const spec = await config.getDesignPackage(clientId)
+        res.json(spec)
+    } catch (error) {
+        next(error)
+    }
 })
 
 const maxFilesize = process.env.MAX_FILESIZE || 5;

package/docs/releases.md

@@ -2,6 +2,9 @@
 
 ## API 
 
+### 1.53.0 - 17.11.11
+Update NodeJs to v16
+
 ### 1.52.4 - 17.11.11
 Fix issue: Keep invisible ServiceCi Relation in Tickets during CI Relation Update
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manyos/smileconnect-api",
-  "version": "1.52.4",
+  "version": "1.53.0",
   "description": "A proxy and abstraction layer for BMCs IT Service Management Suite",
   "main": "app.js",
   "scripts": {

package/util/config.js

@@ -330,28 +330,34 @@ async function getDesignPackage(clientId) {
     const clientConfig = await getClientConfig(clientId)
     const schemas = {}
     let paths = {}
+
+    //generate docs for normal tickets
     const keys = Object.keys(ticketConfig)
+
     for (let x=0; x<keys.length; x++) {
         const key = keys[x]
         const config = ticketConfig[key]
         const clientObjectConfig = clientConfig[config.requestType]
         if (clientObjectConfig) {
-            {
+            if (clientObjectConfig.fields && clientObjectConfig.fields.length > 0){
                 const mapping = getDeprecatedMappingAsCustom(config.requestType)
-                schemas[config.requestType] = await getObjectSchema(clientObjectConfig, mapping, config.forms.regular)
+                schemas[config.requestType] = await getObjectSchema(clientObjectConfig.fields, mapping, config.forms.regular)
                 paths = {...paths, ... await getPathDef(config.assocTicketType, config.baseURI, config.requestType)}
             }
-            if (config.requestTypeWorkLog) {
+            if (config.requestTypeWorkLog && clientConfig[config.requestTypeWorkLog].fields && clientConfig[config.requestTypeWorkLog].fields.length > 0) {
                 const mapping = getDeprecatedMappingAsCustom(config.requestTypeWorkLog)
-                schemas[config.requestTypeWorkLog] = await getObjectSchema(clientConfig[config.requestTypeWorkLog], mapping, config.forms.workLog)
+                schemas[config.requestTypeWorkLog] = await getObjectSchema(clientConfig[config.requestTypeWorkLog].fields, mapping, config.forms.workLog)
                 paths = {...paths, ... await getPathDef(config.assocTicketType, config.baseURI + '/{ticketId}/worklogs', config.requestTypeWorkLog, true, true)}
             }
-            if (config.requestTemplate) {
+            if (config.requestTemplate && clientConfig[config.requestTemplate].fields  && clientConfig[config.requestTemplate].fields.length > 0) {
                 const mapping = getDeprecatedMappingAsCustom(config.requestTemplate)
-                schemas[config.requestTemplate] = await getObjectSchema(clientConfig[config.requestTemplate], mapping, config.forms.template)
+                schemas[config.requestTemplate] = await getObjectSchema(clientConfig[config.requestTemplate].fields, mapping, config.forms.template)
             }
         }
     }
+
+
+    //generate docs for custom Forms
     const customFormMappings = await getCustomFormMapping()
     const customKeys = Object.keys(customFormMappings)
     for (let x=0; x<customKeys.length; x++) {
@@ -360,14 +366,51 @@ async function getDesignPackage(clientId) {
         const clientObjectConfig = clientConfig[`custom_${formName}`]
         log.debug('key', key, clientObjectConfig)
         if (clientObjectConfig) {
-            schemas[key] = await getObjectSchema(clientObjectConfig, customFormMappings[key].mapping, formName)
+            schemas[key] = await getObjectSchema(clientObjectConfig.fields, customFormMappings[key].mapping, formName)
             paths = {...paths, ... await getPathDef(key, '/v1/customForms/' + key, key)}
         }
     }
+
+
+    //generate docs for cmdb
+    const cmdbMapping = getDeprecatedMappingAsCustom('cmdbobject')
+
+    if (clientConfig.cmdbobject && clientConfig.cmdbobject.fields) {
+        schemas['cmdbobject'] = await getObjectSchema(clientConfig.cmdbobject.fields, cmdbMapping, 'AST:BaseElement')
+
+
+        const cmdbdef = Object.keys(clientConfig.cmdbobject)
+        const classConfigs = cmdbdef.filter(item => item.startsWith('fields_'))
+        const cmdbSchemaList = ['cmdbobject']
+        for (let x=0; x<classConfigs.length; x++) {
+            const classConfig = classConfigs[x]
+            const formName = classConfig.replace('fields_', '')
+            const fields = clientConfig.cmdbobject[classConfig]
+            const classMapping = getDeprecatedMappingAsCustom(`cmdbobject_${formName}`)
+            const classSchema = await getObjectSchema(fields, classMapping, formName)
+            let schemaName = `cmdbobject_${formName}`
+            schemaName = schemaName.replaceAll(':','_')
+            schemaName = schemaName.replaceAll(' ','_')
+            cmdbSchemaList.push(schemaName)
+            schemas[schemaName] = {
+                required: schemas['cmdbobject'].required.concat(classSchema.required),
+                properties: {...schemas['cmdbobject'].properties, ...classSchema.properties}
+            }
+            log.debug('customForm', formName, fields, classMapping, classSchema)
+        }
+
+        paths = {...paths, ... await getPathDef('cmdbobject', '/v1/cmdbobjects', cmdbSchemaList)}
+    }
+
     return {openapi: "3.0.1", info, servers, paths, components: {schemas}}
 }
 
-async function getPathDef(objectName, baseUri, tag, isSubTicket, suppressUpdate, suppressCreate) {
+async function getPathDef(objectName, baseUri, schema, isSubTicket, suppressUpdate, suppressCreate) {
+    let tag = [schema]
+    if (Array.isArray(schema)) {
+        tag = schema
+    }
+
     const ticketIdParam = {
         name: "ticketId",
         description: "id of the parent object to retrieve",
@@ -396,39 +439,39 @@ async function getPathDef(objectName, baseUri, tag, isSubTicket, suppressUpdate,
     pathDef[`${baseUri}/{id}`] = {
         parameters,
         get: {
-            tags: [tag],
+            tags: tag,
             summary: `Get a single ${objectName} object by id`,
             description: "A single object is returned in the data attribute",
             parameters: [],
-            responses: await getApiResponse(tag, true)
+            responses: await getApiResponse(schema, true)
         }
     }
     if (!suppressUpdate) {
         pathDef[`${baseUri}/{id}`].put = {
-            tags: [tag],
+            tags: tag,
                 summary: `Update an object of type ${objectName}`,
                 description: "A single object is returned in the data attribute",
                 parameters: [],
-                responses: await getApiResponse(tag, false)
+                responses: await getApiResponse(schema, false)
         }
     }
 
     pathDef[`${baseUri}`] = {
         get: {
-            tags: [tag],
+            tags: tag,
             summary: `Get a list of object of type ${objectName}`,
             description: "An array ob objects is returned in the data attribute",
             parameters: [],
-            responses: await getApiResponse(tag, false)
+            responses: await getApiResponse(schema, false)
         }
     }
     if (!suppressCreate) {
         pathDef[`${baseUri}`].post = {
-            tags: [tag],
+            tags: tag,
             summary: `Create a new object of type ${objectName}`,
             description: "A single object is returned in the data attribute",
             parameters: [],
-            responses: await getApiResponse(tag, false)
+            responses: await getApiResponse(schema, false)
         }
     }
     if (isSubTicket) {
@@ -438,6 +481,18 @@ async function getPathDef(objectName, baseUri, tag, isSubTicket, suppressUpdate,
 }
 
 async function getApiResponse(schema, single) {
+    let dataValue = {
+        "$ref": `#/components/schemas/${schema}`
+    }
+    if (Array.isArray(schema)) {
+        dataValue = {
+            oneOf: schema.map(item => {
+                return {
+                    "$ref": `#/components/schemas/${item}`
+                }
+            })
+        }
+    }
     responses = {
         "200": {
             description: "successful operation",
@@ -456,24 +511,20 @@ async function getApiResponse(schema, single) {
     if (!single) {
         responses["200"].content["application/json"].schema.properties.data = {
             type: "array",
-            items: {
-                "$ref": `#/components/schemas/${schema}`
-            }
+            items: dataValue
         }
     } else {
-        responses["200"].content["application/json"].schema.properties.data = {
-            "$ref": `#/components/schemas/${schema}`
-        }
+        responses["200"].content["application/json"].schema.properties.data = dataValue
     }
     return responses
 }
 
-async function getObjectSchema(clientObjectConfig, mapping, formName) {
+async function getObjectSchema(clientFields, mapping, formName) {
     const fields = await getFields(formName)
     const required = []
     const properties = {}
-    log.debug('clientObjConf', clientObjectConfig)
-    clientObjectConfig.fields.forEach(field => {
+    log.debug('clientFields', clientFields, mapping, formName)
+    clientFields.forEach(field => {
         const mappedName = mapping[field]
         const fieldDef = {}
         const fieldDetails = fields.find(item => item.name === field)