@things-factory/integration-base 8.0.0-beta.8 → 8.0.0

package/server/engine/task/mqtt-subscribe.ts

@@ -0,0 +1,139 @@
+import mqtt from 'async-mqtt'
+
+import { TaskRegistry } from '../task-registry'
+import { ConnectionManager } from '../connection-manager'
+import { sleep } from '@things-factory/utils'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+function convertDataFormat(data, format) {
+  if (format == 'json') {
+    return JSON.parse(data)
+  } else {
+    return data.toString()
+  }
+}
+
+async function MqttSubscribe(step: InputStep, context: Context) {
+  const {
+    connection: connectionName,
+    params: { topic, dataFormat },
+    name
+  } = step
+
+  const { domain, logger, closures, __mqtt_subscriber } = context
+  if (!__mqtt_subscriber) {
+    context.__mqtt_subscriber = {}
+  }
+
+  const {
+    connection: {
+      endpoint: uri,
+      params: { user, password }
+    }
+  } = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
+
+  if (!topic) {
+    throw Error(`topic is not found for ${connectionName}`)
+  }
+
+  /*
+   * 1. subscriber list에서 subscriber를 찾는다. 없으면, 생성한다.
+   * 2. client.once(...)로 메시지를 취한다.
+   *
+   * TODO 동일 브로커의 다중 subscribe 태스크에 대해서 완벽한 지원을 해야한다.
+   * - 현재는 여러 태스크가 동일 topic을 subscribe 하는 경우에 정상동작하지 않을 것이다.
+   */
+  if (!context.__mqtt_subscriber[name]) {
+    try {
+      var broker = null
+      if (user && password) {
+        broker = await mqtt.connectAsync(uri, { username: user, password: password })
+      } else {
+        broker = await mqtt.connectAsync(uri)
+      }
+
+      logger.info(`mqtt-connector connection(${connectionName}:${uri}) is connected`)
+
+      await broker.subscribe(topic)
+      logger.info(`success subscribing topic '${topic}'`)
+
+      var TOPIC
+      var MESSAGE
+
+      context.__mqtt_subscriber[name] = async () => {
+        while (!MESSAGE) {
+          await sleep(100)
+        }
+
+        var topic = TOPIC
+        var message = MESSAGE
+
+        TOPIC = null
+        MESSAGE = null
+
+        return {
+          topic,
+          message
+        }
+      }
+
+      broker.on('message', async (messageTopic, message) => {
+        if (topic !== messageTopic) {
+          return
+        }
+
+        TOPIC = topic
+        MESSAGE = convertDataFormat(message, dataFormat)
+
+        // logger.info(`mqtt-subscribe :\n'${message.toString()}'`)
+      })
+
+      closures.push(async () => {
+        try {
+          broker && (await broker.end())
+          logger.info(`mqtt-connector connection(${connectionName}:${uri}) is disconnected`)
+        } catch (e) {
+          logger.error(e)
+        }
+      })
+    } catch (e) {
+      logger.error(e)
+    }
+  }
+
+  var { message } = await context.__mqtt_subscriber[name]()
+
+  return {
+    data: message
+  }
+}
+
+MqttSubscribe.parameterSpec = [
+  {
+    type: 'string',
+    name: 'topic',
+    label: 'topic'
+  },
+  {
+    type: 'select',
+    label: 'data-format',
+    name: 'dataFormat',
+    property: {
+      options: [
+        {
+          display: 'Plain Text',
+          value: 'text'
+        },
+        {
+          display: 'JSON',
+          value: 'json'
+        }
+      ]
+    }
+  }
+]
+
+MqttSubscribe.help = 'integration/task/mqtt-subscribe'
+
+TaskRegistry.registerTaskHandler('mqtt-subscribe', MqttSubscribe)

package/server/engine/task/mssql-procedure.ts

@@ -0,0 +1,128 @@
+import { logger } from '@things-factory/env'
+import { access } from '@things-factory/utils'
+import { ConnectionManager } from '../connection-manager'
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+import 'ses'
+
+try {
+  var mssql = require('mssql')
+} catch (err) {
+  logger.error('mssql module loading failed', err)
+}
+
+type ProcedureParameterType = {
+  name: string
+  dir: string
+  type: string
+  val?: any
+  accessor?: string
+  maxSize?: number
+}
+
+type ValueType = {
+  code?: string
+  procedure?: string
+  parameters?: ProcedureParameterType[]
+}
+
+const DIR = {
+  In: 'in',
+  Out: 'out',
+  Inout: 'inout' /* 초기값이 있는 out 파라미터 */
+}
+
+const NUMBER_TYPES = [
+  'TINYINT',
+  'SMALLINT',
+  'INT',
+  'BIGINT',
+  'FLOAT',
+  'READ',
+  'DECIMAL',
+  'NUMERIC',
+  'MONEY',
+  'SMALLMONEY'
+]
+
+const DATE_TYPES = ['DATE', 'TIME', 'DATETIME', 'SMALLDATETIME', 'DATETIME2']
+const PARAMETERIZED_STRINGS = ['NCHAR', 'NVARCHAR', 'NTEXT', 'DECIMAL', 'NUMERIC']
+
+async function MssqlProcedure(step: InputStep, context: Context) {
+  var { domain, user, data, variables, lng } = context
+  var { connection: connectionName, params } = step
+
+  var { code = '', procedure = '', parameters = [] } = params.parameters as ValueType
+
+  var dbconnection = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
+
+  if (!code) {
+    throw 'procedure code not defined'
+  }
+
+  const compartment = new Compartment({
+    domain,
+    user,
+    lng,
+    data,
+    variables,
+    console
+  })
+
+  let evalCode
+  try {
+    evalCode = compartment.evaluate('`' + code + '`')
+  } catch (err) {
+    throw new Error(`Failed to evaluate code: ${err.message}`)
+  }
+
+  code = evalCode
+
+  const procedureParameters =
+    parameters &&
+    parameters.reduce((sum, { name, val, dir, type, accessor, maxSize }) => {
+      sum[name] = {
+        dir: DIR[dir],
+        type
+      }
+
+      const calculated = accessor ? access(accessor, data) || val : val
+
+      if (calculated !== undefined) {
+        sum[name].val = NUMBER_TYPES.includes(type)
+          ? Number(calculated)
+          : DATE_TYPES.includes(type)
+            ? new Date(calculated)
+            : String(calculated)
+      }
+
+      if ((dir == DIR.In || dir == DIR.Inout) && maxSize > 0 && type == 'String') {
+        sum[name].type = mssql?.VarChar(maxSize)
+        sum[name].maxSize = maxSize
+      }
+
+      return sum
+    }, {})
+
+  const result = await dbconnection.execute(procedure, procedureParameters)
+
+  return {
+    data: result
+  }
+}
+
+MssqlProcedure.parameterSpec = [
+  {
+    type: 'procedure-parameters',
+    name: 'parameters',
+    label: '',
+    property: {
+      dbtype: 'mssql'
+    }
+  }
+]
+
+MssqlProcedure.help = 'integration/task/mssql-procedure'
+
+TaskRegistry.registerTaskHandler('mssql-procedure', MssqlProcedure)

package/server/engine/task/oracle-procedure.ts

@@ -0,0 +1,124 @@
+import { logger } from '@things-factory/env'
+import { access } from '@things-factory/utils'
+import { ConnectionManager } from '../connection-manager'
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+import 'ses'
+
+try {
+  var oracledb = require('oracledb')
+} catch (err) {
+  logger.error('oracledb module loading failed', err)
+}
+
+type ProcedureParameterType = {
+  name: string
+  dir: string
+  type: string
+  val?: any
+  accessor?: string
+  maxSize?: number
+}
+
+type ValueType = {
+  code?: string
+  procedure?: string
+  parameters?: ProcedureParameterType[]
+}
+
+const TYPES = {
+  Number: oracledb?.NUMBER,
+  String: oracledb?.STRING,
+  Date: oracledb?.DATE,
+  Buffer: oracledb?.BUFFER,
+  Blob: oracledb?.BLOB,
+  Clob: oracledb?.CLOB,
+  Cursor: oracledb?.CURSOR
+}
+
+const DIR = {
+  In: oracledb?.BIND_IN,
+  Inout: oracledb?.BIND_INOUT,
+  Out: oracledb?.BIND_OUT
+}
+
+async function OracleProcedure(step: InputStep, context: Context) {
+  var { domain, user, data, variables, lng } = context
+  var { connection: connectionName, params } = step
+
+  var { code = '', parameters = [] } = params.parameters as ValueType
+
+  var dbconnection = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
+
+  if (!code) {
+    throw 'procedure code not defined'
+  }
+
+  const compartment = new Compartment({
+    domain,
+    user,
+    lng,
+    data,
+    variables,
+    console
+  })
+
+  let evalCode
+  try {
+    evalCode = compartment.evaluate('`' + code + '`')
+  } catch (err) {
+    throw new Error(`Failed to evaluate code: ${err.message}`)
+  }
+
+  code = evalCode
+
+  const procedureParameters =
+    parameters &&
+    parameters.reduce((sum, { name, val, dir, type, accessor, maxSize }) => {
+      sum[name] = {
+        dir: DIR[dir],
+        type: TYPES[type]
+      }
+
+      const calculated = accessor ? access(accessor, data) || val : val
+
+      if (calculated !== undefined) {
+        sum[name].val =
+          type === 'Date'
+            ? new Date(calculated)
+            : type == 'Number'
+              ? Number(calculated)
+              : type == 'String'
+                ? String(calculated)
+                : calculated
+      }
+
+      if (maxSize) {
+        sum[name].maxSize = maxSize
+      }
+
+      return sum
+    }, {})
+
+  const result = await dbconnection.execute(code, procedureParameters)
+
+  return {
+    data: result
+  }
+}
+
+OracleProcedure.parameterSpec = [
+  {
+    type: 'procedure-parameters',
+    name: 'parameters',
+    label: '',
+    property: {
+      dbtype: 'oracle'
+    }
+  }
+]
+
+OracleProcedure.help = 'integration/task/oracle-procedure'
+
+TaskRegistry.registerTaskHandler('oracle-procedure', OracleProcedure)

package/server/engine/task/pick-pending-scenario.ts

@@ -0,0 +1,80 @@
+import { getRepository } from '@things-factory/shell'
+import { sleep } from '@things-factory/utils'
+
+import { Scenario } from '../../service/scenario/scenario'
+import { ScenarioEngine } from '../scenario-engine'
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+const debug = require('debug')('things-factory:integration-base:pick-pending-scenario')
+
+async function PickPendingScenario(step: InputStep, context: Context) {
+  var { logger, load, domain } = context
+  var { params } = step
+  var { tag = '', waitFor = -1 } = params || {}
+
+  waitFor = Number(waitFor) || -1
+  const till = Date.now() + waitFor
+
+  const pendingQueue = ScenarioEngine.getPendingQueue(domain)
+
+  // long-term task need to check state whether this scenario is still going.
+  while (true && context.checkState()) {
+    var { stuff } = pendingQueue.pick(tag) || {}
+    if (stuff) {
+      break
+    }
+
+    let toTill = waitFor == -1 ? 1000 : till - Date.now()
+    if (toTill <= 0) {
+      return {}
+    }
+
+    await sleep(Math.min(1000, toTill))
+  }
+
+  if (!stuff) {
+    return
+  }
+
+  var { scenario, variables } = stuff
+
+  var subscenario = await getRepository(Scenario).findOne({
+    where: {
+      id: scenario
+    },
+    relations: ['steps', 'domain']
+  })
+
+  logger.info(`Scenario '${subscenario.name}' Started.`)
+  var subContext = await load(step, subscenario, {
+    ...context,
+    data: {},
+    variables
+  })
+  logger.info(`Scenario '${subscenario.name}' done.`)
+
+  return {
+    data: subContext.data
+  }
+}
+
+PickPendingScenario.parameterSpec = [
+  {
+    type: 'string',
+    name: 'tag',
+    label: 'tag'
+  },
+  {
+    type: 'number',
+    name: 'waitFor',
+    label: 'wait-for',
+    placeHolder: 'milli-seconds'
+  }
+]
+
+PickPendingScenario.connectorFree = true
+PickPendingScenario.help = 'integration/task/pick-pending-scenario'
+
+TaskRegistry.registerTaskHandler('pick-pending-scenario', PickPendingScenario)

package/server/engine/task/publish.ts

@@ -0,0 +1,40 @@
+import { access } from '@things-factory/utils'
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function Publish(step: InputStep, { logger, publish, data }: Context) {
+  var {
+    params: { tag, accessor }
+  } = step
+
+  if (!tag || !accessor) {
+    throw Error(`tag and accessor should be defined: tag - '${tag}', accessor - '${accessor}'`)
+  }
+
+  var value = access(accessor, data)
+
+  publish(tag, value)
+
+  return {
+    data: value
+  }
+}
+
+Publish.parameterSpec = [
+  {
+    type: 'string',
+    name: 'tag',
+    label: 'tag'
+  },
+  {
+    type: 'scenario-step-input',
+    name: 'accessor',
+    label: 'accessor'
+  }
+]
+
+Publish.connectorFree = true
+Publish.help = 'integration/task/publish'
+
+TaskRegistry.registerTaskHandler('publish', Publish)

package/server/engine/task/random.ts

@@ -0,0 +1,53 @@
+import { TaskRegistry } from '../task-registry'
+import Chance from 'chance'
+
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+const formats = [
+  'bool,character,floating,integer,letter,natural,string',
+  'paragraph,sentence,syllable,word',
+  'age,birthday,cf,cpf,first,gender,last,name,prefix,ssn,suffix',
+  'android_id,apple_token,bb_pin,wp7_anid,wp8_anid2,avatar,color',
+  'company,domain,email,fbid,google_analytics,hashtag,ip,ipv6,klout,profession,tld,twitter,url',
+  'address,altitude,areacode,city,coordinates,country,depth,geohash,latitude,longitude,phone,postal,province,state,street,zip',
+  'ampm,date,hammertime,hour,millisecond,minute,month,second,timestamp,timezone,weekday,year',
+  'cc,cc_type,currency,currency_pair,dollar,euro,exp,exp_month,exp_year',
+  'coin,d4,d6,d8,d10,d12,d20,d30,d100,guid,hash'
+]
+  .join(',')
+  .split(',')
+
+async function Random(step: InputStep, { logger, publish, data }: Context) {
+  var {
+    params: { format = 'integer', count = 1 }
+  } = step
+
+  const chance = new Chance()
+
+  return {
+    data: chance.n(chance[format], count)
+  }
+}
+
+Random.parameterSpec = [
+  {
+    type: 'select',
+    label: 'format',
+    name: 'format',
+    property: {
+      options: formats.map(format => ({ display: format, value: format }))
+    }
+  },
+  {
+    type: 'number',
+    label: 'count',
+    name: 'count',
+    placeholder: '1'
+  }
+]
+
+Random.connectorFree = true
+Random.help = 'integration/task/random'
+
+TaskRegistry.registerTaskHandler('random', Random)

package/server/engine/task/reset-pending-queue.ts

@@ -0,0 +1,17 @@
+import { TaskRegistry } from '../task-registry'
+import { ScenarioEngine } from '../scenario-engine'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function ResetPendingScenario(step: InputStep, { domain }: Context) {
+  const pendingQueue = ScenarioEngine.getPendingQueue(domain)
+  pendingQueue.reset()
+
+  return {}
+}
+
+ResetPendingScenario.parameterSpec = []
+
+ResetPendingScenario.connectorFree = true
+
+TaskRegistry.registerTaskHandler('reset-pending-scenario', ResetPendingScenario)

package/server/engine/task/script.ts

@@ -0,0 +1,63 @@
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+import 'ses'
+
+async function Script(step: InputStep, context: Context) {
+  const {
+    params: { script }
+  } = step
+
+  const { domain, user, data, variables, lng, logger } = context
+
+  const compartment = new Compartment({
+    domain,
+    user,
+    data,
+    variables,
+    logger,
+    lng,
+    console,
+    Math,
+    JSON,
+    Date,
+    setTimeout,
+    setInterval,
+    clearTimeout,
+    clearInterval
+  })
+
+  const scriptSource = `
+    (async () => {
+      ${script}
+    })();
+  `
+
+  try {
+    return {
+      data: await compartment.evaluate(scriptSource)
+    }
+  } catch (err) {
+    throw new Error(`Script execution failed: ${err.message}`)
+  }
+}
+
+Script.parameterSpec = [
+  {
+    type: 'textarea',
+    name: 'script',
+    label: 'script',
+    property: {
+      language: 'javascript',
+      showLineNumbers: true
+    },
+    styles: {
+      flex: '1'
+    }
+  }
+]
+
+Script.connectorFree = true
+Script.help = 'integration/task/script'
+
+TaskRegistry.registerTaskHandler('script', Script)

package/server/engine/task/set-domain.ts

@@ -0,0 +1,37 @@
+import { TaskRegistry } from '../task-registry'
+import { Domain, getRepository } from '@things-factory/shell'
+
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function SetDomain(step: InputStep, context: Context) {
+  var {
+    params: { subdomain }
+  } = step
+
+  var { logger, domain } = context || {}
+
+  logger.info(`domain => ${subdomain}`)
+
+  if (subdomain) {
+    context.domain = (await getRepository(Domain).findOneBy({ subdomain })) || domain
+  }
+
+  return {
+    data: domain.subdomain // previous domain
+  }
+}
+
+SetDomain.parameterSpec = [
+  {
+    type: 'string',
+    name: 'subdomain',
+    placeholder: 'subdomain',
+    label: 'subdomain'
+  }
+]
+
+SetDomain.connectorFree = true
+SetDomain.help = 'integration/task/set-domain'
+
+TaskRegistry.registerTaskHandler('set-domain', SetDomain)