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

package/server/engine/task/sleep.ts

@@ -0,0 +1,34 @@
+import { sleep } from '@things-factory/utils'
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function Sleep(step: InputStep, { logger }: Context) {
+  var {
+    params: { duration }
+  } = step
+
+  logger.info(`sleep ${duration}ms`)
+
+  if (duration) {
+    await sleep(duration)
+  }
+
+  return {
+    data: duration
+  }
+}
+
+Sleep.parameterSpec = [
+  {
+    type: 'number',
+    name: 'duration',
+    placeholder: 'milli-seconds',
+    label: 'duration'
+  }
+]
+
+Sleep.connectorFree = true
+Sleep.help = 'integration/task/sleep'
+
+TaskRegistry.registerTaskHandler('sleep', Sleep)

package/server/engine/task/socket-listener.ts

@@ -0,0 +1,96 @@
+import { sleep } from '@things-factory/utils'
+import { TaskRegistry } from '../task-registry'
+import { ConnectionManager } from '../connection-manager'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+function convertDataFormat(data, format) {
+  try {
+    if (format == 'json') {
+      return JSON.parse(data)
+    } else if (format == 'csv') {
+      return data.split(',')
+    }
+  } catch (e) {
+    return data.toString()
+  }
+
+  return data
+}
+
+async function SocketListener(step: InputStep, context: Context) {
+  //get connection data
+  const {
+    connection: connectionName,
+    params: { dataFormat = 'JSON' },
+    name
+  } = step
+
+  const { domain, logger, closures, __socket_listener } = context
+  logger.info('\r\n')
+  if (!__socket_listener) {
+    context.__socket_listener = {}
+  }
+
+  // get socket information from connection
+  var connection = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
+  if (!connection) {
+    throw new Error(`connector '${connectionName}' is not established.`)
+  }
+
+  /*
+   * 1. listner list에서 listner를 찾는다. 없으면, 생성한다.
+   */
+  if (!context.__socket_listener[name]) {
+    try {
+      var MESSAGES = []
+      context.__socket_listener[name] = async () => {
+        while (MESSAGES.length == 0) {
+          await sleep(100)
+        }
+        var message = MESSAGES.shift()
+        return {
+          message
+        }
+      }
+
+      await connection.addListener('socket-message-arrive', async message => {
+        logger.info(message.toString())
+        MESSAGES.push(convertDataFormat(message.toString(), dataFormat))
+      })
+    } catch (e) {
+      logger.error(e)
+    }
+  }
+
+  var { message } = await context.__socket_listener[name]()
+
+  return {
+    data: message
+  }
+}
+
+SocketListener.parameterSpec = [
+  {
+    type: 'select',
+    label: 'data-format',
+    name: 'dataFormat',
+    property: {
+      options: [
+        {
+          display: 'CSV',
+          value: 'csv'
+        },
+        {
+          display: 'JSON',
+          value: 'json'
+        },
+        {
+          display: 'String',
+          value: 'string'
+        }
+      ]
+    }
+  }
+]
+TaskRegistry.registerTaskHandler('socket-listener', SocketListener)

package/server/engine/task/state-group-read.ts

@@ -0,0 +1,69 @@
+import gql from 'graphql-tag'
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function StateGroupRead(step: InputStep, { logger, publish, data, domain, user, client }: Context) {
+  var {
+    params: { group }
+  } = step
+
+  if (!group) {
+    throw Error(`group should be defined: group - '${group}'`)
+  }
+
+  var { data: queryResult, errors } = await client.query({
+    query: gql`
+      query ($filters: [Filter!]) {
+        stateRegisters(filters: $filters) {
+          items {
+            name
+            state
+          }
+        }
+      }
+    `,
+    variables: {
+      filters: [
+        {
+          name: 'group',
+          operator: 'eq',
+          value: group
+        }
+      ]
+    },
+    context: {
+      state: {
+        domain,
+        user
+      }
+    }
+  })
+
+  if (errors) {
+    errors.forEach(error => {
+      logger.error('GraphQL Error: %s', error)
+    })
+  }
+
+  return {
+    data: queryResult?.stateRegisters?.items.reduce((status, item) => {
+      const { name, state } = item
+      status[name] = state
+      return status
+    }, {})
+  }
+}
+
+StateGroupRead.parameterSpec = [
+  {
+    type: 'string',
+    name: 'group',
+    label: 'group'
+  }
+]
+
+StateGroupRead.connectorFree = true
+StateGroupRead.help = 'integration/task/state-group-read'
+
+TaskRegistry.registerTaskHandler('state-group-read', StateGroupRead)

package/server/engine/task/state-read.ts

@@ -0,0 +1,56 @@
+import gql from 'graphql-tag'
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function StateRead(step: InputStep, { logger, publish, data, domain, user, client }: Context) {
+  var {
+    params: { name }
+  } = step
+
+  if (!name) {
+    throw Error(`name should be defined: name - '${name}'`)
+  }
+
+  var { data: queryResult, errors } = await client.query({
+    query: gql`
+      query ($name: String!) {
+        stateRegisterByName(name: $name) {
+          state
+        }
+      }
+    `,
+    variables: {
+      name
+    },
+    context: {
+      state: {
+        domain,
+        user
+      }
+    }
+  })
+
+  if (errors) {
+    errors.forEach(error => {
+      logger.error('GraphQL Error: %s', error)
+    })
+  }
+
+  return {
+    data: queryResult?.stateRegisterByName?.state
+  }
+}
+
+StateRead.parameterSpec = [
+  {
+    type: 'string',
+    name: 'name',
+    label: 'name'
+  }
+]
+
+StateRead.connectorFree = true
+StateRead.help = 'integration/task/state-read'
+
+TaskRegistry.registerTaskHandler('state-read', StateRead)

package/server/engine/task/state-write.ts

@@ -0,0 +1,65 @@
+import gql from 'graphql-tag'
+import { access } from '@things-factory/utils'
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function StateWrite(step: InputStep, { logger, publish, data, domain, user, client }: Context) {
+  var {
+    params: { name, accessor }
+  } = step
+
+  if (!name || !accessor) {
+    throw Error(`name and accessor should be defined: name - '${name}', accessor - '${accessor}'`)
+  }
+
+  var state = access(accessor, data)
+
+  var { data: mutateResult, errors } = await client.mutate({
+    mutation: gql`
+      mutation ($state: Object!, $name: String!) {
+        updateStateRegisterByName(state: $state, name: $name) {
+          state
+        }
+      }
+    `,
+    variables: {
+      name,
+      state
+    },
+    context: {
+      state: {
+        domain,
+        user
+      }
+    }
+  })
+
+  if (errors) {
+    errors.forEach(error => {
+      logger.error('GraphQL Error: %s', error)
+    })
+  }
+
+  return {
+    data: mutateResult?.updateStateRegisterByName?.state
+  }
+}
+
+StateWrite.parameterSpec = [
+  {
+    type: 'string',
+    name: 'name',
+    label: 'name'
+  },
+  {
+    type: 'scenario-step-input',
+    name: 'accessor',
+    label: 'accessor'
+  }
+]
+
+StateWrite.connectorFree = true
+StateWrite.help = 'integration/task/state-write'
+
+TaskRegistry.registerTaskHandler('state-write', StateWrite)

package/server/engine/task/stop-scenario.ts

@@ -0,0 +1,44 @@
+import { getRepository } from '@things-factory/shell'
+
+import { Scenario } from '../../service/scenario/scenario'
+import { ScenarioEngine } from '../../engine'
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function StopScenario(step: InputStep, context: Context) {
+  var { logger, domain } = context
+  var {
+    params: { scenario }
+  } = step
+
+  // find the name of the input scenario
+  var foundScenario = await getRepository(Scenario).findOne({
+    where: {
+      id: scenario
+    },
+    relations: ['steps', 'domain']
+  })
+
+  await ScenarioEngine.unload(domain, foundScenario?.name)
+  logger.info(`Scenario '${foundScenario?.name}' is about to be stopped.`)
+
+  return {
+    data: foundScenario?.name
+  }
+}
+
+StopScenario.parameterSpec = [
+  {
+    type: 'entity-selector',
+    name: 'scenario',
+    label: 'scenario',
+    property: {
+      queryName: 'scenarios'
+    }
+  }
+]
+
+StopScenario.connectorFree = true
+
+TaskRegistry.registerTaskHandler('scenario-stop', StopScenario)

package/server/engine/task/sub-scenario.ts

@@ -0,0 +1,57 @@
+import { getRepository } from '@things-factory/shell'
+import { access, deepClone } from '@things-factory/utils'
+
+import { Scenario } from '../../service/scenario/scenario'
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function SubScenario(step: InputStep, context: Context) {
+  var { logger, load, data } = context
+  var {
+    params: { scenario, variables }
+  } = step
+
+  var subscenario = await getRepository(Scenario).findOne({
+    where: {
+      id: scenario
+    },
+    relations: ['steps', 'domain']
+  })
+
+  logger.info(`Sub Scenario '${subscenario.name}' Started.`)
+  var subContext = await load(step, subscenario, {
+    ...context,
+    data: {},
+    /* 
+      FIXME variables 설정이 안된 경우에 subscenario의 variables는 undefined가 되는 것이 맞겠지만, 
+      하위 호환성 유지를 위해서 부모의 variables를 사용함 
+    */
+    variables: variables ? deepClone(access(variables, data)) : context.variables
+  })
+  logger.info(`Sub Scenario '${subscenario.name}' done.`)
+
+  return {
+    data: subContext.data
+  }
+}
+
+SubScenario.parameterSpec = [
+  {
+    type: 'entity-selector',
+    name: 'scenario',
+    label: 'scenario',
+    property: {
+      queryName: 'scenarios'
+    }
+  },
+  {
+    type: 'scenario-step-input',
+    name: 'variables',
+    label: 'variables'
+  }
+]
+
+SubScenario.connectorFree = true
+
+TaskRegistry.registerTaskHandler('scenario', SubScenario)

package/server/engine/task/switch-goto.ts

@@ -0,0 +1,43 @@
+import { access } from '@things-factory/utils'
+
+import { TaskRegistry } from '../task-registry'
+
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function SwitchGoTo(step: InputStep, { logger, data }: Context) {
+  var {
+    params: { accessor, cases }
+  } = step
+
+  var value = access(accessor, data)
+
+  var next = cases[value] || cases['default']
+
+  logger.info(`switch to next '${next}' by value '${value}' .`)
+
+  return {
+    next
+  }
+}
+
+SwitchGoTo.parameterSpec = [
+  {
+    type: 'scenario-step-input',
+    name: 'accessor',
+    label: 'accessor'
+  },
+  {
+    type: 'map',
+    name: 'cases',
+    label: 'cases',
+    property: {
+      valuetype: 'scenario-step-input'
+    }
+  }
+]
+
+SwitchGoTo.connectorFree = true
+
+TaskRegistry.registerTaskHandler('switch', SwitchGoTo)
+TaskRegistry.registerTaskHandler('switch-goto', SwitchGoTo)

package/server/engine/task/switch-range-goto.ts

@@ -0,0 +1,53 @@
+import { access } from '@things-factory/utils'
+
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function SwitchRangeGoTo(step: InputStep, { logger, data }: Context) {
+  var {
+    params: { accessor, cases }
+  } = step
+
+  var value = Number(access(accessor, data))
+
+  var range =
+    Object.keys(cases).find(key => {
+      if (key == 'default') {
+        return
+      }
+
+      var [from, to] = key.split('~')
+
+      return Number(from) <= value && Number(to) > value
+    }) || 'default'
+
+  var next = cases[range]
+
+  logger.info(`switch-range to next '${next}' by value '${value}' .`)
+
+  return {
+    next
+  }
+}
+
+SwitchRangeGoTo.parameterSpec = [
+  {
+    type: 'scenario-step-input',
+    name: 'accessor',
+    label: 'accessor'
+  },
+  {
+    type: 'range',
+    name: 'cases',
+    label: 'cases',
+    property: {
+      valuetype: 'scenario-step-input'
+    }
+  }
+]
+
+SwitchRangeGoTo.connectorFree = true
+
+TaskRegistry.registerTaskHandler('switch-range', SwitchRangeGoTo)
+TaskRegistry.registerTaskHandler('switch-range-goto', SwitchRangeGoTo)

package/server/engine/task/switch-range-scenario.ts

@@ -0,0 +1,79 @@
+import { getRepository } from '@things-factory/shell'
+import { access, deepClone } from '@things-factory/utils'
+
+import { Scenario } from '../../service/scenario/scenario'
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function SwitchRangeScenario(step: InputStep, context: Context) {
+  var { logger, data, load } = context
+  var {
+    params: { accessor, cases, variables }
+  } = step
+
+  var value = Number(access(accessor, data))
+
+  var range =
+    Object.keys(cases).find(key => {
+      if (key == 'default') {
+        return
+      }
+
+      var [from, to] = key.split('~')
+
+      return Number(from) <= value && Number(to) > value
+    }) || 'default'
+
+  var scenarioName = cases[range]
+
+  logger.info(`switch-range to scenario '${scenarioName}' by value '${value}' .`)
+
+  var subscenario = await getRepository(Scenario).findOne({
+    where: {
+      name: scenarioName
+    },
+    relations: ['steps', 'domain']
+  })
+
+  logger.info(`Sub Scenario '${subscenario.name}' started.`)
+  var subContext = await load(step, subscenario, {
+    ...context,
+    data: {},
+    /* 
+      FIXME variables 설정이 안된 경우에 subscenario의 variables는 undefined가 되는 것이 맞겠지만, 
+      하위 호환성 유지를 위해서 부모의 variables를 사용함 
+    */
+    variables: variables ? deepClone(access(variables, data)) : context.variables
+  })
+  logger.info(`Sub Scenario '${subscenario.name}' done.`)
+
+  return {
+    data: subContext.data
+  }
+}
+
+SwitchRangeScenario.parameterSpec = [
+  {
+    type: 'scenario-step-input',
+    name: 'accessor',
+    label: 'accessor'
+  },
+  {
+    type: 'range',
+    name: 'cases',
+    label: 'cases',
+    property: {
+      valuetype: 'scenario-input'
+    }
+  },
+  {
+    type: 'scenario-step-input',
+    name: 'variables',
+    label: 'variables'
+  }
+]
+
+SwitchRangeScenario.connectorFree = true
+
+TaskRegistry.registerTaskHandler('switch-range-scenario', SwitchRangeScenario)

package/server/engine/task/switch-range-set.ts

@@ -0,0 +1,48 @@
+import { access } from '@things-factory/utils'
+import { TaskRegistry } from '../task-registry'
+import { InputStep } from '../../service/step/step-type'
+import { Context } from '../types'
+
+async function SwitchRangeSet(step: InputStep, { logger, data }: Context) {
+  var {
+    params: { accessor, cases }
+  } = step
+
+  var value = Number(access(accessor, data))
+
+  var range =
+    Object.keys(cases).find(key => {
+      if (key == 'default') {
+        return
+      }
+
+      var [from, to] = key.split('~')
+
+      return Number(from) <= value && Number(to) > value
+    }) || 'default'
+
+  var data = cases[range]
+
+  logger.info(`switch-range to data '${data}' by value '${value}' .`)
+
+  return {
+    data
+  }
+}
+
+SwitchRangeSet.parameterSpec = [
+  {
+    type: 'scenario-step-input',
+    name: 'accessor',
+    label: 'accessor'
+  },
+  {
+    type: 'range',
+    name: 'cases',
+    label: 'cases'
+  }
+]
+
+SwitchRangeSet.connectorFree = true
+
+TaskRegistry.registerTaskHandler('switch-range-set', SwitchRangeSet)