node-red-contrib-agilite/adhoc/adhoc.js

Node-RED nodes to integrate with Agilit-e cloud or Agilit-e on-prem

const Agilite = require('agilite').default
const TypeDetect = require('agilite-utils/dist/type-detect').default
const EnumsTypeDetect = require('agilite-utils/dist/enums-type-detect').default
const AgiliteUtils = require('agilite-utils').default

module.exports = function (RED) {
  function Adhoc(config) {
    RED.nodes.createNode(this, config)

    const node = this
    const field = config.field || 'payload'
    const fieldType = config.fieldType || 'msg'

    node.status({
      fill: 'blue',
      text: 'ready',
      shape: 'ring'
    })

    this.on('input', async msg => {
      const serverConfig = RED.nodes.getNode(config.server)
      const failFlow = config.failFlow
      const apiServerUrl = serverConfig.server
      const fullName = config.fullName

      let agilite = null
      let apiKey = null
      let logProfileKey = null
      let dateTimeValue = config.dateTimeValue
      let formatKey = config.formatKey
      let recordId = config.recordId
      let action = null
      let data = msg.payload
      let apiKeyValue = config.apiKey
      let errorMessage = null
      let result = null

      msg.agilite = msg.agilite || {}

      const submitResponse = response => {
        switch (fieldType) {
          case 'msg':
            RED.util.setMessageProperty(msg, field, response.data)
            break
          case 'flow':
            node.context().flow.set(field, response.data)
            break
          case 'global':
            node.context().global.set(field, response.data)
            break
        }

        node.status({
          fill: 'green',
          text: 'Success',
          shape: 'ring'
        })

        msg.agilite.success = true
        msg.agilite.errorMessage = ''

        node.send(msg)
      }

      const submitError = error => {
        errorMessage = null

        if (error.response && error.response.data.errorMessage) {
          errorMessage = error.response.data.errorMessage
        } else if (error.message) {
          errorMessage = error.message
        } else {
          errorMessage = error
        }

        node.status({
          fill: 'red',
          text: 'Error',
          shape: 'ring'
        })

        msg.agilite.success = false
        msg.agilite.errorMessage = errorMessage

        if (failFlow) {
          node.error(errorMessage, msg)
        } else {
          node.send(msg)
        }
      }

      try {
        // Check if there's an Agilit-e object in MSG
        if (TypeDetect(msg.agilite) !== EnumsTypeDetect.OBJECT) msg.agilite = {}

        // Set Log Profile Key and API Key
        logProfileKey = msg.agilite.logProfileKey || ''
        apiKey = msg.agilite.apiKey || serverConfig.credentials.apiKey

        // Check if there's valid data to pass
        switch (config.actionType) {
          case '1': // Encode XML
          case '6': // Decode XML
          case '7': // XML to JS
          case '2': // Convert HTML to JSON
            // Make sure data is a string
            if (TypeDetect(data) !== EnumsTypeDetect.STRING) data = ''
            break
          case '8': // JS to XML
          case '3': // Generate PDF
            // Make sure data is a object
            if (TypeDetect(data) !== EnumsTypeDetect.OBJECT) data = {}
            break
          case '9': // Json Diff
            break
          case '10': // Generate Username
            // Make sure data is an Array
            if (TypeDetect(data) !== EnumsTypeDetect.ARRAY) data = []
            if (fullName === '') errorMessage = "Please provide a 'Full Name' in the node interface"
            break
          case '11': // Generate OCR
            if (recordId === '') errorMessage = "Please provide a 'Record ID'"
            break
          case '12': // Authenticate Token
            if (!apiKeyValue) errorMessage = 'Please provide an API Key'
            break
          default: // get request
        }

        // We need a token, key and data to proceed
        if (!apiKey) {
          errorMessage = 'No valid API Key Provided. Please authenticate with Agilit-e first'
        } else if (!apiServerUrl) {
          errorMessage = 'No Server URL Provided'
        }

        if (errorMessage) submitError(errorMessage)

        agilite = new Agilite({ apiServerUrl, apiKey })

        dateTimeValue = AgiliteUtils.compileTemplate(dateTimeValue, msg)
        formatKey = AgiliteUtils.compileTemplate(formatKey, msg)
        recordId = AgiliteUtils.compileTemplate(recordId, msg)
        apiKeyValue = AgiliteUtils.compileTemplate(apiKeyValue, msg)

        switch (config.actionType) {
          case '1': // Encode XML
            action = 'encodeXML'
            break
          case '2': // Convert HTML to JSON
            action = 'html2json'
            break
          case '3': // Generate PDF
            action = 'generatePDF'
            break
          case '4': // Generate UUID
            action = 'generateUUID'
            break
          case '5': // Format Dated/Time Value
            action = 'formatDateTime'
            break
          case '6': // Decode XML
            action = 'decodeXML'
            break
          case '7': // XML to JS
            action = 'XMLToJS'
            break
          case '8': // JS to XML
            action = 'JSToXML'
            break
          case '9': // JSON Diff
            action = 'jsonDiff'
            break
        }

        node.status({
          fill: 'yellow',
          text: 'Running',
          shape: 'ring'
        })

        switch (config.actionType) {
          case '10': // Generate Username
            result = await agilite.Utils.generateUsername(fullName, data, logProfileKey)
            break
          case '11': // Generate OCR
            result = await agilite.Utils.generateOCR(recordId, logProfileKey)
            break
          case '12': // Authenticate Token
            result = await agilite.authenticateToken(apiKeyValue)
            break
          default:
            result = await agilite.Utils[action](action !== 'formatDateTime' ? data : dateTimeValue, formatKey, logProfileKey)
        }

        submitResponse(result)
      } catch (e) {
        submitError(e)
      }
    })
  }

  RED.nodes.registerType('adhoc', Adhoc)
}