@things-factory/integration-base 6.1.129 → 6.1.141

package/helps/integration/task/oracle-procedure.zh.md

@@ -1,61 +1,65 @@
 # Oracle 存储过程任务
 
-这是用于调用存储在 Oracle 数据库中的存储过程的任务，根据不同的数据类型返回数据列表或特定数据类型的值。
+这个任务涉及调用存储在 Oracle 数据库中的存储过程。根据不同的数据类型，它可以返回数据列表或特定数据类型的值。
 
 ## 参数
 
 ### 存储过程代码
 
-- 存储过程代码是根据*存储过程名称*和*参数*自动生成的代码，用户无需单独输入。
-- 如果存储过程名称是*mcs.myproc*，并且具有参数*id*和*out_name*，则表示如下：
-  ```text
-  mcs.myproc(:id, :out_name);
-  ```
+- 存储过程代码是根据*存储过程名称*和*参数*自动生成的代码，用户无需手动输入。
+- 例如，如果存储过程的名称是*mcs.myproc*，参数是*id*和*out_name*，则应表示如下：
+
+```text
+mcs.myproc(:id, :out_name);
+```
 
 ### 存储过程名称
 
 - 指定存储过程的名称。
-- 如果需要按包或用户名进行区分，使用'.'来分隔它们。
-- 例子：
-  ```text
-  mcs.myproc
-  ```
+- 如果需要按包或用户名称区分存储过程，请使用句点（.）进行分隔。
+- 示例：
+
+```text
+mcs.myproc
+```
 
 ### 参数
 
-- 参数包括以下元素：
+- 参数由以下元素组成：
   - 参数名称
-  - 输入/输出规范：IN、INOUT、OUT
-  - 参数类型：String、Number、Date、Cursor
-  - 值：如果变量是输入，则指定该输入的值。
-  - 最大大小：如果变量类型为 String 或 Buffer，则指定变量的最大大小。
+  - 方向：IN、INOUT、OUT
+  - 数据类型：String、Number、Date、Cursor
+  - 值：对于输入变量，是相应的值
+  - 最大大小：对于数据类型为 String 或 Buffer 的变量，指定变量的最大大小。
 
 #### 参数名称
 
-参数名称指定存储过程中使用的参数的名称。在上面的示例中，“id”和“out_name”是参数名称。
+参数名称指定存储过程中使用的参数的名称。在上面的示例中，'id'和'out_name'是参数名称。
 
-### 输入/输出规范
+### 方向
 
-指定变量是输入（IN）还是输出（OUT）。
+指定变量是输入（IN）还是输出（OUT）变量。
 
-### 参数类型
+### 数据类型
 
-指定参数类型。在创建存储过程时，类型应该与创建存储过程时指定的名称完全一致。
+指定参数的数据类型。数据类型应与创建存储过程时命名的数据类型完全一致。
 
-如果存储过程如下实现：
+例如，如果存储过程实现如下：
 
 ```sql
 CREATE OR REPLACE NONEDITIONABLE PROCEDURE myproc (in_id IN VARCHAR2, out_name OUT VARCHAR2) AS
 BEGIN
-    SELECT name INTO out_name FROM
-
- MCS.FMB_USERS WHERE id = in_id;
+    SELECT name INTO out_name FROM MCS.FMB_USERS WHERE id = in_id ;
 END;
 ```
 
-第一个和第二个参数都指定为 VARCHAR2。当调用这样的存储过程时，必须为两者都指定 String 作为参数类型，并且对于输出，还必须指定最大大小。
+第一个和第二个参数都是 VARCHAR2 类型。
 
-以下是参数配置示例：
+在调用这样的存储过程时，应将参数类型指定为 String，并且对于输出，还应指定最大大小。
+
+以下是如何
+
+指定的示例：
 
 ![procedure example1](./assets/../../../../assets/images/oracle-procedure-example1.png 'procedure example1')
 
@@ -63,30 +67,25 @@ END;
 
 配置遵循[JSONATA 文档](http://docs.jsonata.org/overview.html)。
 
-如果指定了“访问器”，则使用此访问器构建的值将用作存储过程的参数。
-
-如果下面的“值”设置是“常量”，那么可以将访问器设置视为“变量”。
-
-访问器配置优先于下面的“值”设置。换句话说，如果设置了“值”，则它将作为存储过程的参数值优先考虑。这是因为当设置访问器时，通常将配置的“值”理解为用于测试目的的值，而不是主要用途的值。
+如果指定了“访问器”，则该访问器生成的值将用作参数值。如果“访问器”操作没有结果，则使用“值（val）”设置。
 
-### 值
+### 值（val）
 
-如果参数是输入（IN），请指定其值。
-直接在此字段中输入“常量”值。
+如果参数是输入（IN），则在此字段中指定值。直接为此字段输入“常数”值。
 
-在上面的示例中，如果指定“id”的输入值为“ID”，则它将设置为 ID 任务的输入值。
+在前面提到的示例中，如果将“ID”指定为“id”参数的输入值，则应将 ID 任务返回的值用作输入值。
 
-此值优先于上面的“访问器”配置。这是因为当设置访问器时，通常将配置的“值”理解为用于测试目的的值，而不是主要用途的值。
+如果“访问器”设置没有结果，将使用“值”中设置的值。
 
 ### 最大大小
 
-如果参数类型为 String 或 Buffer，请指定最大大小。对于其他类型，请忽略此设置。
+对于数据类型为 String 或 Buffer 的参数，指定最大大小。对于其他数据类型，请忽略此设置。
 
 ## 任务结果
 
-过程调用的结果以对象形式返回，其中指定为输出的参数成为返回值的键。
+调用存储过程的结果以对象格式返回，指定为输出的参数名称变为键，其对应的值返回。
 
-例如，在上面介绍的任务的情况下，它返回以下结果值：
+例如，在上述任务中，结果值将如下所示：
 
 ```javascript
 {
@@ -94,9 +93,9 @@ END;
 }
 ```
 
-## 另一个用例（游标）
+## 另一个示例（游标）
 
-### 存储过程创建示例
+### 存储过程实施示例
 
 ```sql
 CREATE OR REPLACE NONEDITIONABLE PROCEDURE PROCEDURE1(out_cursor OUT SYS_REFCURSOR) AS
@@ -108,11 +107,11 @@ BEGIN
 END PROCEDURE1;
 ```
 
-### 存储过程调用示例
+### 调用存储过程示例
 
 ![procedure example2](./assets/../../../../assets/images/oracle-procedure-example2.png 'procedure example2')
 
-### 存储过程任务调用结果
+### 存储过程调用的任务结果
 
 ```javascript
 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/integration-base",
-  "version": "6.1.129",
+  "version": "6.1.141",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -26,12 +26,12 @@
   },
   "dependencies": {
     "@apollo/client": "^3.6.9",
-    "@things-factory/api": "^6.1.129",
-    "@things-factory/auth-base": "^6.1.129",
-    "@things-factory/env": "^6.1.129",
-    "@things-factory/oauth2-client": "^6.1.129",
-    "@things-factory/scheduler-client": "^6.1.129",
-    "@things-factory/shell": "^6.1.129",
+    "@things-factory/api": "^6.1.141",
+    "@things-factory/auth-base": "^6.1.141",
+    "@things-factory/env": "^6.1.141",
+    "@things-factory/oauth2-client": "^6.1.141",
+    "@things-factory/scheduler-client": "^6.1.141",
+    "@things-factory/shell": "^6.1.141",
     "async-mqtt": "^2.5.0",
     "chance": "^1.1.11",
     "cross-fetch": "^3.0.4",
@@ -46,5 +46,5 @@
   "devDependencies": {
     "@types/cron": "^2.0.1"
   },
-  "gitHead": "34348ec14b8648940212758df1945b9321a13593"
+  "gitHead": "e3d3ba0a80acd94b85b4ee881c5e9374fc3ee04d"
 }

package/server/engine/task/database-query.ts

@@ -3,7 +3,7 @@ import { ConnectionManager } from '../connection-manager'
 import { TaskRegistry } from '../task-registry'
 
 async function DatabaseQuery(step, context) {
-  var { domain, data, variables } = context
+  var { domain, user, data, variables } = context
   var {
     connection: connectionName,
     params: { query }
@@ -14,6 +14,7 @@ async function DatabaseQuery(step, context) {
   const vm = new VM({
     sandbox: {
       domain,
+      user,
       data,
       variables
     }

package/server/engine/task/graphql-mutate.ts

@@ -10,11 +10,12 @@ async function GraphqlMutate(step, context) {
   var { connection: connectionName, params: stepOptions } = step
   var { mutation, variables: variablesAccessorMap, headers } = stepOptions || {}
 
-  var { domain, data, variables } = context
+  var { domain, user, data, variables } = context
 
   const vm = new VM({
     sandbox: {
       domain,
+      user,
       data,
       variables
     }

package/server/engine/task/graphql-query.ts

@@ -9,11 +9,12 @@ import { TaskRegistry } from '../task-registry'
 async function GraphqlQuery(step, context) {
   var { connection: connectionName, params: stepOptions } = step
   var { query, variables: variablesAccessorMap, headers } = stepOptions || {}
-  var { domain, data, variables } = context
+  var { domain, user, data, variables } = context
 
   const vm = new VM({
     sandbox: {
       domain,
+      user,
       data,
       variables
     }

package/server/engine/task/http-get.ts

@@ -6,7 +6,7 @@ import { TaskRegistry } from '../task-registry'
 import { ConnectionManager } from '../connection-manager'
 import { substitute } from './utils/substitute'
 
-async function HttpGet(step, { logger, data, domain, variables }) {
+async function HttpGet(step, { logger, data, domain, user, variables }) {
   var { connection: connectionName, params: stepOptions } = step
   var { headers: requestHeaders, searchParams = {}, path } = stepOptions || {}
   var connection = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
@@ -20,6 +20,7 @@ async function HttpGet(step, { logger, data, domain, variables }) {
   const vm = new VM({
     sandbox: {
       domain,
+      user,
       data,
       variables
     }

package/server/engine/task/http-post.ts

@@ -6,7 +6,7 @@ import { TaskRegistry } from '../task-registry'
 import { ConnectionManager } from '../connection-manager'
 import https from 'https'
 
-async function HttpPost(step, { logger, data, domain, variables }) {
+async function HttpPost(step, { logger, data, domain, user, variables }) {
   var { connection: connectionName, params: stepOptions } = step
   var { headers: requestHeaders, contentType, path, accessor } = stepOptions || {}
 
@@ -21,6 +21,7 @@ async function HttpPost(step, { logger, data, domain, variables }) {
   const vm = new VM({
     sandbox: {
       domain,
+      user,
       data,
       variables
     }

package/server/engine/task/local-graphql-mutate.ts

@@ -10,16 +10,19 @@ import { TaskRegistry } from '../task-registry'
 async function LocalGraphqlMutate(step, context) {
   var { params, updaterId } = step
   var { mutation, variables: variablesAccessorMap, headers } = params || {}
-  var { client, domain, data, variables } = context
+  var { client, domain, user, data, variables } = context
 
-  const user = await getRepository(User).findOne({
-    where: { id: updaterId },
-    relations: ['domains']
-  })
+  user =
+    user ||
+    (await getRepository(User).findOne({
+      where: { id: updaterId },
+      relations: ['domains']
+    }))
 
   const vm = new VM({
     sandbox: {
       domain,
+      user,
       data,
       variables
     }

package/server/engine/task/local-graphql-query.ts

@@ -10,16 +10,19 @@ import { TaskRegistry } from '../task-registry'
 async function LocalGraphqlQuery(step, context) {
   var { params, updaterId } = step
   var { query, variables: variablesAccessorMap, headers } = params || {}
-  var { client, domain, data, variables } = context
+  var { client, domain, user, data, variables } = context
 
-  const user = await getRepository(User).findOne({
-    where: { id: updaterId },
-    relations: ['domains']
-  })
+  user =
+    user ||
+    (await getRepository(User).findOne({
+      where: { id: updaterId },
+      relations: ['domains']
+    }))
 
   const vm = new VM({
     sandbox: {
       domain,
+      user,
       data,
       variables
     }

package/server/engine/task/log.ts

@@ -2,7 +2,7 @@ import { access, hasTemplateExpression } from '@things-factory/utils'
 import { VM } from 'vm2'
 import { TaskRegistry } from '../task-registry'
 
-async function Log(step, { logger, data, variables, domain }) {
+async function Log(step, { logger, data, variables, domain, user }) {
   var {
     params: { message, accessor, level = 'info' }
   } = step
@@ -11,6 +11,7 @@ async function Log(step, { logger, data, variables, domain }) {
     const vm = new VM({
       sandbox: {
         domain,
+        user,
         data,
         variables
       }

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

@@ -42,7 +42,7 @@ const DIR = {
 }
 
 async function OracleProcedure(step, context) {
-  var { domain, data, variables } = context
+  var { domain, user, data, variables } = context
   var { connection: connectionName, params } = step
 
   var { code = '', parameters = [] } = params.parameters as ValueType
@@ -52,6 +52,7 @@ async function OracleProcedure(step, context) {
   const vm = new VM({
     sandbox: {
       domain,
+      user,
       data,
       variables
     }
@@ -71,7 +72,7 @@ async function OracleProcedure(step, context) {
         type: TYPES[type]
       }
 
-      const calculated = val !== undefined ? val : accessor ? access(accessor, data) : undefined
+      const calculated = accessor ? access(accessor, data) || val : val
 
       if (calculated !== undefined) {
         sum[name].val =
@@ -108,8 +109,6 @@ async function OracleProcedure(step, context) {
     }
   }
 
-  console.log('taskResult: ', taskResult)
-
   return {
     data: taskResult
   }

package/server/engine/task/script.ts

@@ -6,7 +6,7 @@ async function Script(step, context) {
     params: { script }
   } = step
 
-  const { domain, data, variables } = context
+  const { domain, user, data, variables, logger } = context
 
   const vm = new NodeVM({
     timeout: 5000,
@@ -14,12 +14,13 @@ async function Script(step, context) {
     console: 'inherit',
     sandbox: {
       domain,
+      user,
       data,
       variables
     }
   })
 
-  const result = await vm.run(`return (async () => {\n${script}\n})()`)
+  var result = await vm.run(`return (async () => {\n${script}\n})()`)
 
   return {
     data: result

package/server/engine/types.ts

@@ -12,6 +12,7 @@ export interface Connector {
 
 export type Context = {
   domain: Object
+  user: Object
   logger: any
   publish: Function
   load: Function

package/server/routers/scenario-schedule-callback-router.ts

@@ -18,7 +18,7 @@ scenarioScheduleCallbackRouter.post('/callback-schedule-for-scenario', async (co
   // key: scenario.id,
   // operation: 'start'
 
-  const { domain } = context.state
+  const { domain, user } = context.state
 
   if (!domain) {
     throw new Error('cannot identify the current domain.')
@@ -58,7 +58,11 @@ scenarioScheduleCallbackRouter.post('/callback-schedule-for-scenario', async (co
   // TODO prepare the secure authentication method
   context.state.user = scenario.creator
 
-  ScenarioEngine.load(scenario.name, scenario, context)
+  ScenarioEngine.load(scenario.name, scenario, {
+    domain,
+    user,
+    variables: client.task?.data
+  })
 
   context.status = 200
 })

package/server/service/scenario/scenario-type.ts

@@ -92,7 +92,7 @@ export class Scenario {
 
   async start(instanceName, variables?: any) {
     try {
-      await ScenarioEngine.load(instanceName || this.name, this, { variables })
+      await ScenarioEngine.load(instanceName || this.name, this, { domain: this.domain, user: this.updater, variables })
     } catch (ex) {}
   }
 

package/server/service/scenario-instance/scenario-instance-mutation.ts

@@ -71,7 +71,7 @@ export class ScenarioInstanceMutation {
     @Arg('variables', type => ScalarObject, { nullable: true }) variables: any,
     @Ctx() context: ResolverContext
   ): Promise<ScenarioInstance> {
-    const { domain } = context.state
+    const { domain, user } = context.state
 
     debug('startScenario', instanceName, scenarioName, variables)
 
@@ -86,7 +86,7 @@ export class ScenarioInstanceMutation {
     }
 
     instanceName = instanceName || scenarioName
-    return await ScenarioEngine.load(instanceName, scenario, { domain, variables })
+    return await ScenarioEngine.load(instanceName, scenario, { domain, user, variables })
   }
 
   @Mutation(returns => ScenarioInstance, { nullable: true, description: 'To start new scenario instance' })

package/server/service/scenario-instance/scenario-instance-type.ts

@@ -7,6 +7,7 @@ import util from 'util'
 import { createLogger, format, transports } from 'winston'
 
 import { Domain, pubsub, PubSubLogTransport, ScalarObject } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
 import { sleep } from '@things-factory/utils'
 
 import { TaskRegistry } from '../../engine'
@@ -93,6 +94,9 @@ export class ScenarioInstance {
   @Field({ nullable: true })
   public domain: Domain
 
+  @Field({ nullable: true })
+  public user: User
+
   @Field({ nullable: true })
   public scenarioName: string
 
@@ -149,16 +153,18 @@ export class ScenarioInstance {
   }
 
   constructor(instanceName, { name: scenarioName, steps, domain: scenarioDomain }, context?) {
-    const domain = context?.domain || scenarioDomain
+    const { domain = scenarioDomain, user } = context || {}
 
     this.instanceName = instanceName
     this.scenarioName = scenarioName
     this.steps = orderBy(steps || [], step => step.sequence)
     this.domain = domain
+    this.user = user
     this.disposer = context?.disposer
 
     this.context = {
       domain,
+      user,
       logger:
         context?.logger ||
         createLogger({
@@ -254,6 +260,8 @@ export class ScenarioInstance {
       const message = ex.stack ? ex.stack : ex
       const { scenarioName, domain } = this
 
+      this.context.logger.error(ex.message ? ex.message : ex)
+
       debug('failed to run ', `[ Domain: ${domain.name}, Scenario: ${scenarioName} ]\n`, ex)
       this.setState(
         ScenarioInstanceStatus.HALTED,