@things-factory/integration-base 6.1.127 → 6.1.138

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

@@ -1,141 +1,138 @@
 # Oracle 存储过程任务
 
-调用 Oracle 数据库中存储的存储过程的任务、 
-它根据数据类型返回数据列表或特定数据类型的值。
+这个任务涉及调用存储在 Oracle 数据库中的存储过程。根据不同的数据类型，它可以返回数据列表或特定数据类型的值。
 
-### 参数
+## 参数
+
+### 存储过程代码
+
+- 存储过程代码是根据*存储过程名称*和*参数*自动生成的代码，用户无需手动输入。
+- 例如，如果存储过程的名称是*mcs.myproc*，参数是*id*和*out_name*，则应表示如下：
 
-### 过程代码
-  - 存储过程代码是由*存储过程名称*和*参数*自动生成的代码，用户无需输入。
-  - 例如，如果存储过程的名称为 *mcs.myproc*，参数为 *id* 和 *out_name*，那么存储过程代码将如下所示
-    ```文本
-    mcs.myproc(:id, :out_name)；
-    ```
+```text
+mcs.myproc(:id, :out_name);
+```
 
 ### 存储过程名称
-  - 指定存储过程的名称。
-  - 如果存储过程需要用包或用户名分隔，请使用". "分隔。
-  - 例如
-    文本
-    mcs.myproc
-    文本 mcs.myproc
+
+- 指定存储过程的名称。
+- 如果需要按包或用户名称区分存储过程，请使用句点（.）进行分隔。
+- 示例：
+
+```text
+mcs.myproc
+```
 
 ### 参数
-  - 参数由以下元素组成
-    - 参数名称
-    - 输入/输出名称：IN、INOUT、OUT
-    - 参数类型：字符串、数字、日期、光标
-    - 值：如果变量是输入，则是该输入的值。
-    - MaxSize：如果变量是字符串或缓冲区类型，则为变量的最大大小。
+
+- 参数由以下元素组成：
+  - 参数名称
+  - 方向：IN、INOUT、OUT
+  - 数据类型：String、Number、Date、Cursor
+  - 值：对于输入变量，是相应的值
+  - 最大大小：对于数据类型为 String 或 Buffer 的变量，指定变量的最大大小。
 
 #### 参数名称
 
-参数名指定存储过程中使用的参数名称。
-例如
-  ``sql
-  mcs.myproc(:id, :out_name)；
-  ```
-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
-开始
-    SELECT name INTO out_name FROM MCS.FMB_USERS WHERE id = in_id ；
-结束；
+BEGIN
+    SELECT name INTO out_name FROM MCS.FMB_USERS WHERE id = in_id ;
+END;
 ```
 
-请注意，第一个和第二个参数都指定为 VARCHAR2、 
+第一个和第二个参数都是 VARCHAR2 类型。
 
-如果需要调用这些存储过程，必须将参数类型指定为字符串、 
-对于输出，必须指定最大大小。
+在调用这样的存储过程时，应将参数类型指定为 String，并且对于输出，还应指定最大大小。
 
-调用说明示例如下
+以下是如何
 
-[存储过程 example1]（./assets/././././././././assets/images/oracle-procedure-example1.png '存储过程 example1')
+指定的示例：
 
+![procedure example1](./assets/../../../../assets/images/oracle-procedure-example1.png 'procedure example1')
 
-### Accessor [accessor](../concept/data-accessor.md)
+### 访问器
 
-按照 [JSONATA 文档](http://docs.jsonata.org/overview.html) 进行配置。
+配置遵循[JSONATA 文档](http://docs.jsonata.org/overview.html)。
 
+如果指定了“访问器”，则该访问器生成的值将用作参数值。如果“访问器”操作没有结果，则使用“值（val）”设置。
 
-### 值
+### 值（val）
 
-如果参数是输入（IN），请指定其值。
-不要直接在值中输入常量，而应指定具体的任务名称。
+如果参数是输入（IN），则在此字段中指定值。直接为此字段输入“常数”值。
 
-在上例中，如果 id 的输入值指定为 ID，则指定 ID 任务返回的值作为输入值。
+在前面提到的示例中，如果将“ID”指定为“id”参数的输入值，则应将 ID 任务返回的值用作输入值。
 
+如果“访问器”设置没有结果，将使用“值”中设置的值。
 
 ### 最大大小
 
-如果参数类型为字符串或缓冲区，请指定最大大小。对于其他类型，请不要指定值，并忽略它。
+对于数据类型为 String 或 Buffer 的参数，指定最大大小。对于其他数据类型，请忽略此设置。
 
-### 任务结果
+## 任务结果
 
-存储过程调用的结果以对象的形式返回，指定为输出的参数名称是关键字，并返回值。
+调用存储过程的结果以对象格式返回，指定为输出的参数名称变为键，其对应的值返回。
 
-例如，上面介绍的任务会返回以下结果值。
+例如，在上述任务中，结果值将如下所示：
 
 ```javascript
-}
-  out_name: 'Admin
+{
+  out_name: 'Admin'
 }
 ```
 
+## 另一个示例（游标）
 
-### 其他使用示例（光标）
+### 存储过程实施示例
 
-### 编写存储过程的示例
-
-``sql
-CREATE OR REPLACE NONEDITIONABLE PROCEDURE PROCEDURE1(out_cursor OUT SYS_REFCURSOR) AS 
-开始
-    开始
-        打开 out_cursor FOR
-            SELECT * FROM FARMWEATHER WHERE rownum <= 1000；
-    结束；
-结束过程1；
+```sql
+CREATE OR REPLACE NONEDITIONABLE PROCEDURE PROCEDURE1(out_cursor OUT SYS_REFCURSOR) AS
+BEGIN
+    BEGIN
+        OPEN out_cursor FOR
+            SELECT * FROM FARMWEATHER WHERE rownum <= 1000;
+    END;
+END PROCEDURE1;
 ```
 
-### 调用存储过程的示例
+### 调用存储过程示例
 
-![存储过程 example2](./assets/././././././././assets/images/oracle-procedure-example2.png'存储过程 example2')
+![procedure example2](./assets/../../../../assets/images/oracle-procedure-example2.png 'procedure example2')
 
-### 程序任务调用结果
+### 存储过程调用的任务结果
 
 ```javascript
-{ }
-  "out_cursor"： [].
+{
+  "out_cursor": [
     {
-      "FARMDATE"： "2006-01-07T15:00:00.000Z",
-      "MAXT"： 29.5,
-      "MINT"： 21.8,
-      "WINDSPEED"： 1.6,
-      "FARMHUM": 70： 70.2,
-      "降水量": 0 0
+      "FARMDATE": "2006-01-07T15:00:00.000Z",
+      "MAXT": 29.5,
+      "MINT": 21.8,
+      "WINDSPEED": 1.6,
+      "FARMHUM": 70.2,
+      "PRECIPITATION": 0
     },
     {
-      "FARMDATE"： "2006-01-08T15:00:00.000Z",
-      "MAXT"： 30.1,
-      "MINT"： 21,
-      "WINDSPEED"： 1.6,
-      "FARMHUM": 67： 67.4,
-      "precipitation": 0 0
+      "FARMDATE": "2006-01-08T15:00:00.000Z",
+      "MAXT": 30.1,
+      "MINT": 21,
+      "WINDSPEED": 1.6,
+      "FARMHUM": 67.4,
+      "PRECIPITATION": 0
     },
-    ...
+    ..
   ]
 }
 ```
-
-通过www.DeepL.com/Translator（免费版）翻译

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/integration-base",
-  "version": "6.1.127",
+  "version": "6.1.138",
   "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.127",
-    "@things-factory/auth-base": "^6.1.127",
-    "@things-factory/env": "^6.1.127",
-    "@things-factory/oauth2-client": "^6.1.127",
-    "@things-factory/scheduler-client": "^6.1.127",
-    "@things-factory/shell": "^6.1.127",
+    "@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",
     "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": "1e37585e8021af947ffdf03c11c90754a949a318"
+  "gitHead": "6bcb91fa7d1647f069212383bf0ece8039e742e5"
 }

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,