@lcap/nasl 3.7.0-beta.4 → 3.7.0-beta.6

package/src/concepts/App__.ts

@@ -9,6 +9,8 @@ import type Frontend from './Frontend__';
 import type { NaslServer } from '../server/naslServer';
 import { CUSTOM_CONNECTOR_EDITABLE_SUFFIX } from './basics/constants';
 
+// import CallLogic from './CallLogic__';
+
 export interface AssetsInfo {
   js: Array<string>;
   css: Array<string>;
@@ -285,11 +287,21 @@ export class App extends BaseNode {
    * 扩展模块列表
    */
   @property({
-    objectRef: 'Module | Connector',
+    objectRef: 'Module',
+    isArray: true,
+    defaultValue: [],
+  })
+  dependencies: Array<Module> = [];
+
+  /**
+   * 连接器列表
+   */
+  @property({
+    objectRef: 'Connector',
     isArray: true,
     defaultValue: [],
   })
-  dependencies: Array<Module | Connector> = [];
+  connectorDependencies: Array<Connector> = [];
 
   /**
    * 集成
@@ -2069,7 +2081,9 @@ export class App extends BaseNode {
 
   getConnectorExistingNames(excludedList: Array<Connector> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.dependencies as Connector[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    return ((this.connectorDependencies as Connector[]) || [])
+      .filter((item) => !excludedSet.has(item))
+      .map((item) => item.name);
   }
   getConnectorUniqueName(name = 'connector1') {
     return utils.unique(name, this.getConnectorExistingNames(), undefined, false);
@@ -2098,7 +2112,7 @@ export class App extends BaseNode {
 
   _insertConnectorAt(options: string | Partial<Connector> | Connector, index: number) {
     const connectorOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'dependencies' };
+    const relationOptions = { parentNode: this, parentKey: 'connectorDependencies' };
     const Connector = getConceptConstructor('Connector');
     let connector: Connector;
     if (!options) {
@@ -2108,7 +2122,7 @@ export class App extends BaseNode {
           name: this.getConnectorUniqueName(),
         },
         this,
-        'dependencies',
+        'connectorDependencies',
       );
     } else if (typeof options === 'string') {
       connector = Connector.from(
@@ -2117,7 +2131,7 @@ export class App extends BaseNode {
           name: options,
         },
         this,
-        'dependencies',
+        'connectorDependencies',
       );
     } else if (asserts.isConnector(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -2130,10 +2144,10 @@ export class App extends BaseNode {
           ...options,
         },
         this,
-        'dependencies',
+        'connectorDependencies',
       );
     }
-    this.dependencies.splice(index, 0, connector);
+    this.connectorDependencies.splice(index, 0, connector);
     return connector;
   }
 
@@ -2160,7 +2174,7 @@ export class App extends BaseNode {
     node.create({
       index,
       parentNode: this,
-      parentKey: 'dependencies',
+      parentKey: 'connectorDependencies',
     });
     return node;
   }
@@ -2187,7 +2201,7 @@ export class App extends BaseNode {
   _addConnector(connector: Connector): Connector;
 
   _addConnector(options?: string | Partial<Connector> | Connector) {
-    const index = this.dependencies.length;
+    const index = this.connectorDependencies.length;
     return this._insertConnectorAt(options as any, index);
   }
 
@@ -2212,11 +2226,11 @@ export class App extends BaseNode {
 
   addConnector(options?: string | Partial<Connector> | Connector) {
     const node = this._addConnector(options as any);
-    const index = this.dependencies.indexOf(node);
+    const index = this.connectorDependencies.indexOf(node);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'dependencies',
+      parentKey: 'connectorDependencies',
     });
     return node;
   }
@@ -3309,7 +3323,7 @@ export class App extends BaseNode {
   removeConnector(options: string | Connector) {
     let connector: Connector;
     if (typeof options === 'string') {
-      connector = (this.dependencies as Connector[]).find((item) => item.name === options);
+      connector = (this.connectorDependencies as Connector[]).find((item) => item.name === options);
       if (!connector) {
         throw new Error('找不到连接器 ' + options);
       }
@@ -3558,7 +3572,6 @@ export class App extends BaseNode {
 
     return isEmpty(this.composeCache);
   }
-
   /**
    * 获取组合节点
    */
@@ -3761,9 +3774,9 @@ export class App extends BaseNode {
     let completeName = originCompleteName;
     // 是否是来自编辑态的自定义连接器
     const isFromEditableConnector = completeName?.endsWith(CUSTOM_CONNECTOR_EDITABLE_SUFFIX);
+    // 如果是自定义连接器，需要去掉后缀才能查找到符合预期的节点
     if (isFromEditableConnector) {
-      // 为了查找到真实的结构，需要去掉编辑态的后缀
-      completeName = completeName.replace(CUSTOM_CONNECTOR_EDITABLE_SUFFIX, '');
+      completeName = originCompleteName.replace(CUSTOM_CONNECTOR_EDITABLE_SUFFIX, '');
     }
     const nameArr = completeName?.split('.') || [];
     let node: any = this;
@@ -3779,6 +3792,9 @@ export class App extends BaseNode {
       extensions: [...(node?.dependencies || []), ...(node?.integration?.connectors || [])],
       apis: node.interfaceDependencies,
       components: node.componentDependencies,
+      // v3.6 版本引入自定义连接器，前缀统一更新为 conenctor
+      // 在配置自定义连接器时需要同步支持内部数据结构使用，所以这里做扩展
+      connector: [...node.connectorDependencies, ...(node?.integration?.connectors || [])],
     };
     const modules = modulesMap[start];
     if (Array.isArray(modules)) {
@@ -4261,9 +4277,9 @@ export class App extends BaseNode {
   }
 
   /** 获取已经存在的Module title */
-  getModuleExistingTitles(excludedList: Array<Module> = []) {
+  getConnectorExistingTitles(excludedList: Array<Module> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.dependencies as Module[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.title);
+    return ((this.connectorDependencies as Module[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.title);
   }
 
   /** hank */

package/src/concepts/Argument__.ts

@@ -193,6 +193,12 @@ export class Argument extends LogicItem {
     if (isHaveKeyWord) {
       code += `${self.tsKeyword}:`;
     }
+    // 连接器下的鉴权鉴权参数不需要翻译对应的鉴权参数
+    if (self.connector && self.parentKey === 'authArguments') {
+      code += 'null';
+      return code;
+    }
+
     if (self.expression) {
       if ((self.expression as StringLiteral).name === 'ListDistinctByTargetDefaultExpression') {
         code += yield* (self.expression as NewList).toEmbeddedIgnoreTS(shiftState(state, code));

package/src/concepts/AuthLogicForCallInterface__.ts

@@ -25,6 +25,7 @@ import type Return from './Return__';
 import type Variable from './Variable__';
 import type TypeParam from './TypeParam__';
 import type TypeAnnotation from './TypeAnnotation__';
+import { CUSTOM_CONNECTOR_EDITABLE_SUFFIX } from './basics/constants';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -268,6 +269,14 @@ export class AuthLogicForCallInterface extends AuthLogic {
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
   //================================================================================
+  get tsName() {
+    // 来自集成中心，且是连接内部的逻辑，则认为是编辑态的，需要加上后缀
+    if (this.connector && this.integration) {
+      return `${this.name}${CUSTOM_CONNECTOR_EDITABLE_SUFFIX}`;
+    }
+    // 由于Logic name 已经是符合函数预期的，因此不再需要做格式化
+    return this.name;
+  }
 
   @withSourceMapGenerator
   *toEmbeddedTS(state = createCompilerState(), prefix?: string): TranslatorGenerator {
@@ -281,11 +290,11 @@ export class AuthLogicForCallInterface extends AuthLogic {
     let code = '';
     if (!prefix) {
       // T、U分别用来定义 api 入参和返回值
-      code += `export function ${self.name}`;
+      code += `export function ${self.tsName}`;
     } else if (prefix === 'noExport') {
-      code += `function ${self.name}`;
+      code += `function ${self.tsName}`;
     } else if (prefix === 'inObject') {
-      code += `${self.name}`;
+      code += `${self.tsName}`;
     }
     const typeParams = [
       ...(self.typeParams || []),
@@ -307,6 +316,8 @@ export class AuthLogicForCallInterface extends AuthLogic {
       code += '>';
     }
     // 有参数长度 && 鉴权参数
+    // 连接器下的鉴权参数不展示，因此如果在连接器下时，不需要翻译鉴权参数
+    // if (self.authParams.length && !self.connector) {
     if (self.authParams.length) {
       // const params = [...this.authParams, ...this.params];
       const params = [...self.authParams];
@@ -325,7 +336,7 @@ export class AuthLogicForCallInterface extends AuthLogic {
         if (index === 0) {
           code += '{';
         }
-        code += yield* param.toEmbeddedTS(shiftState(state, code), !param.required);
+        code += yield* param.toEmbeddedTS(shiftState(state, code), false, !param.required);
         if (index !== params.length - 1) {
           code += ', ';
         } else {

package/src/concepts/CallAuthInterface__.ts

@@ -13,6 +13,8 @@ import { getNodeByNodeCallee } from '../automate/engine/utils.js';
 import type AuthLogicForCallInterface from './AuthLogicForCallInterface__';
 import type AuthInterface from './AuthInterface__';
 import { CUSTOM_CONNECTOR_EDITABLE_SUFFIX } from './basics/constants';
+import type App from './App__';
+import type Connector from './Connector__';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -257,6 +259,16 @@ export class CallAuthInterface extends CallInterface {
   // 自动生成的代码已结束。下面可以手动编写。
   //================================================================================
 
+  toBrief(): string {
+    if (this.integration && this.connector) {
+      // 编辑态的连接器调用接口还需要展示具体的鉴权方式
+      const node = this.getCallNode(); // AuthInterface
+      const authLogic = node?.authLogic;
+      return `${super.toBrief()}<br /> <span style="color: #AAAAAA">鉴权方式 = </span><span style="color: #FFFFFF">${authLogic}</span>`;
+    }
+    return super.toBrief();
+  }
+
   /**
    *删除所有的 Argument
    */
@@ -421,7 +433,12 @@ export class CallAuthInterface extends CallInterface {
     if (!authLogic) {
       return [];
     }
-    const targetAuthLogic = this.app.authLogicsForCallInterface.find((logic) => logic.name === authLogic);
+    let source: App | Connector = this.app;
+    if (this.connector) {
+      source = this.connector;
+    }
+
+    const targetAuthLogic = source.authLogicsForCallInterface.find((logic) => logic.name === authLogic);
     const logicParam: Param[] = targetAuthLogic?.authParams || [];
     const Arguments: Argument[] = [];
 

package/src/concepts/CallInterface__.ts

@@ -15,7 +15,9 @@ import type InterfaceParam from './InterfaceParam__';
 import type Structure from './Structure__';
 import type Module from './Module__';
 import type AuthInterface from './AuthInterface__';
+import type ConnectorLogic from './ConnectorLogic__';
 import type { MemberExpression } from './MemberExpression__';
+import type AbstractInterface from './AbstractInterface__';
 import type Frontend from './Frontend__';
 import type Connector from './Connector__';
 import { CUSTOM_CONNECTOR_EDITABLE_SUFFIX } from './basics/constants';
@@ -230,6 +232,8 @@ export class CallInterface extends LogicItem {
 
   // 删除调用接口时且接口无引用，删除接口和数据结构
   async deleteCallNode() {
+    // 如果是连接器下面，则不需要自动删除，得用户手动删除
+    if (this.connector) return;
     if (this.calleeKey !== '__IDENTIFIER__' && !this.__authDelete) {
       (this as any).__deleteCallNodeTimer = setTimeout(async () => {
         clearTimeout((this as any).__deleteCallNodeTimer);
@@ -343,13 +347,13 @@ export class CallInterface extends LogicItem {
     const [, _name, , _interfaceName] = calleewholeKey.split('.');
     let _module: Module | Connector;
     // 由于自定义连接器的引入，目前在 集成中心下也存在着一部分接口
-    // 因此，需要额外判断，如果是自定义连接器需要拿 app.dependencies 中的接口或者 app.integration 中connector下面的接口
+    // 因此，需要额外判断，如果是自定义连接器需要拿 app.connectorDependencies 中的接口或者 app.integration 中connector下面的接口
     const isCustomConnector = this.getAncestor('Connector');
     const isInIntegration = this.getAncestor('Integration');
     if (isCustomConnector && isInIntegration) {
       _module = app?.integration?.connectors?.find?.((item) => item.name === _name);
     } else if (isCustomConnector && !isInIntegration) {
-      _module = app?.dependencies?.find?.((item) => item.name === _name);
+      _module = app?.connectorDependencies?.find?.((item) => item.name === _name);
     } else {
       // default
       _module = app?.interfaceDependencies?.find?.((item) => item.name === _name);
@@ -653,20 +657,27 @@ export class CallInterface extends LogicItem {
     let node;
     // 如果是其余app下自定义逻辑
     try {
-      node = getNodeByNodeCallee(this.app, this.calleewholeKey, (key: any, tempPoint: any) => {
-        // 处理 NASL 中未定义的假的节点
-        if (key === tempPoint.name) {
+      // connector 下的需要从当前connector 下获取
+      if (this.connector) {
+        node = this.connector.interfaces?.find((item) => {
+          return this.calleewholeKey.endsWith(item.name);
+        });
+      } else {
+        node = getNodeByNodeCallee(this.app, this.calleewholeKey, (key: any, tempPoint: any) => {
+          // 处理 NASL 中未定义的假的节点
+          if (key === tempPoint.name) {
+            return {
+              tempPoint,
+              state: 1,
+            };
+          }
+          const t = tempPoint[key];
           return {
-            tempPoint,
-            state: 1,
+            tempPoint: t,
+            state: Array.isArray(t) ? 2 : 1,
           };
-        }
-        const t = tempPoint[key];
-        return {
-          tempPoint: t,
-          state: Array.isArray(t) ? 2 : 1,
-        };
-      });
+        });
+      }
     } catch (err) {}
     return node;
   }
@@ -715,13 +726,13 @@ export class CallInterface extends LogicItem {
     const _interfaceName = _arr[3];
     let _module: Module | Connector;
     // 由于自定义连接器的引入，目前在 集成中心下也存在着一部分接口
-    // 因此，需要额外判断，如果是自定义连接器需要拿 app.dependencies 中的接口或者 app.integration 中connector下面的接口
+    // 因此，需要额外判断，如果是自定义连接器需要拿 app.connectorDependencies 中的接口或者 app.integration 中connector下面的接口
     const isCustomConnector = this.getAncestor('Connector');
     const isInIntegration = this.getAncestor('Integration');
     if (isCustomConnector && isInIntegration) {
       _module = this.app?.integration?.connectors?.find?.((item) => item.name === _name);
     } else if (isCustomConnector && !isInIntegration) {
-      _module = this.app?.dependencies?.find?.((item) => item.name === _name);
+      _module = this.app?.connectorDependencies?.find?.((item) => item.name === _name);
     } else {
       // default
       _module = this.app.interfaceDependencies.find((item) => item.name === _name);
@@ -733,8 +744,102 @@ export class CallInterface extends LogicItem {
     };
   }
 
+  reNameInterface(
+    itfData: Partial<AbstractInterface>,
+    newName: string,
+    structureNameMap: Map<string, string>,
+  ): Partial<AbstractInterface> {
+    itfData.name = newName;
+    // 全量更新参数引用数据结构名
+    // 结构体重命名
+    utils.traverse(
+      ({ node }: { node: any }) => {
+        if (node?.concept === 'TypeAnnotation' && node?.typeKind === 'reference') {
+          // typeNamespace 全部统一为当前的连接器
+          node.typeNamespace = `connector.${this.connector.name}.structures`;
+          node.typeName = structureNameMap.get(node.typeName) || node.typeName;
+        }
+      },
+      { node: itfData },
+      {
+        mode: 'anyObject',
+        excludedKeySet: new Set(['parentNode', '_events', 'globalDataMap', 'havingPlayground', 'wherePlayground']),
+      },
+    );
+    return itfData;
+  }
+
+  // 重新命名数据结构
+  reNameStructureAndRetureNamesMap(structuresData: Partial<Structure>[], moduleName: string): Map<string, string> {
+    const nameMap = new Map<string, string>();
+    structuresData.forEach((structureData) => {
+      const { name } = structureData;
+      const newName = this.connector.getStructureUniqueName(`${moduleName}__${name}`);
+      structureData.name = newName;
+      nameMap.set(name, newName);
+    });
+    structuresData.forEach((structureData) => {
+      // 结构体重命名
+      utils.traverse(
+        ({ node }: { node: any }) => {
+          if (node?.concept === 'TypeAnnotation' && node?.typeKind === 'reference') {
+            // typeNamespace 全部统一为当前的连接器
+            node.typeNamespace = `connector.${this.connector.name}.structures`;
+            node.typeName = nameMap.get(node.typeName) || node.typeName;
+          }
+        },
+        { node: structureData },
+        {
+          mode: 'anyObject',
+          excludedKeySet: new Set(['parentNode', '_events', 'globalDataMap', 'havingPlayground', 'wherePlayground']),
+        },
+      );
+    });
+    return nameMap;
+  }
+
+  // 导入接口到连接器
+  createInterfaceInConnector({ moduleData, selectedModule }: { moduleData: Partial<Module>; selectedModule: any }) {
+    if (!this.connector) return;
+    const modelName = moduleData.name;
+    const itfData = moduleData.interfaces[0] as unknown as Partial<Interface>;
+    const structurseData = moduleData.structures;
+    const structureNameMap = this.reNameStructureAndRetureNamesMap(structurseData, modelName);
+    const { devDomain } = selectedModule || {};
+    if (devDomain) {
+      itfData.path = `${devDomain}${itfData.path}`;
+    }
+
+    // modelName__itfName
+    const targetItfName = this.connector.getInterfaceUniqueName(`${modelName}__${itfData.name}`);
+    this.app.emit('collect:start', { actionMsg: '增加接口到连接器' });
+    // 不支持 DUBBO 的接口
+    const Interface = getConceptConstructor('Interface');
+    const newItf = new Interface(this.reNameInterface(itfData, targetItfName, structureNameMap) as Interface);
+
+    structurseData.forEach((structureData) => {
+      this.connector.addStructure(structureData);
+    });
+    this.connector.addInterface(newItf as Interface);
+    this.setCallee(newItf as Interface);
+    this.app.emit('collect:end');
+  }
+
   // 导入接口
   async createOrUpdateInterface({ moduleData, selectedModule }: { moduleData: Partial<Module>; selectedModule: any }) {
+    const connectorLogic = this.getAncestor('ConnectorLogic') as ConnectorLogic;
+    // 如果是pipleline逻辑，需要将当前的接口复制一份到连接器下
+    // 命名规则为： modelName + interfaceName
+    const isInPiple = connectorLogic?.kind === 'pipeline';
+    // 鉴权方式，如果是连接器下面的，也需要 进入下面的逻辑
+    const isInConnector = this.getAncestor('Connector') as Connector;
+    const isInAuthInterface = this.getAncestor('AuthInterface');
+    const isInAuthLogicForCallInterface = this.getAncestor('AuthLogicForCallInterface');
+    if (isInPiple || (isInAuthInterface && isInConnector) || (isInAuthLogicForCallInterface && isInConnector)) {
+      this.createInterfaceInConnector({ moduleData, selectedModule });
+      return;
+    }
+
     const moduleName = moduleData.name;
     const itfData = moduleData.interfaces[0];
     this.app.emit('collect:start', { actionMsg: '调用接口' });

package/src/concepts/CallLogic__.ts

@@ -660,13 +660,20 @@ export class CallLogic extends LogicItem {
       const bindAttr = this.getAncestor('BindAttribute');
 
       if (['data-source', 'dataSource'].includes(bindAttr?.name)) {
-        if (calleeNamespace) {
-          const currentElement = this.getAncestor('ViewElement') as ViewElement;
-          code += `__${currentElement.name}_dataSourceLoad`;
-        } else {
-          // 前端逻辑的calleeNamespace一直为空字符串
-          code += calleeName;
-        }
+        const currentElement = this.getAncestor('ViewElement') as ViewElement;
+          let currentIndex = 0
+          let targetElement = currentElement.parentNode
+          const currentParamList: string[] = []
+          while(asserts.isViewElement(targetElement)) {
+            if (targetElement.tag === 'template' && targetElement.haveScope()) {
+              currentIndex += 1
+            }
+            targetElement = targetElement.parentNode
+          }
+          for (let i = 0; i < currentIndex; i++) {
+            currentParamList.push(`,current${i === 0 ? '' : i}`)
+          }
+          code += `(params)=>__${currentElement.name}_handleDataSourceLoad(params${currentParamList.join('')})`;
         return code;
       }
       if (calleeName === 'jsonSerialize') {

package/src/concepts/Connection__.ts

@@ -339,7 +339,7 @@ export class Connection extends BaseNode {
   /**
    * 获取connector 类型
    */
-  get connector() {
+  get connector(): Connector {
     return getNodeByNodeCallee(this.rootNode, this.namespace) || ({} as Connector);
   }
   getConnectorType(): String {

package/src/concepts/ConnectorLogic__.ts

@@ -0,0 +1,84 @@
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+import { concept, excludedInJSON, property, getConceptConstructor } from '../decorators';
+
+import * as utils from '../utils';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
+import { v4 as uuidv4 } from 'uuid';
+
+import Logic from './Logic__';
+
+/**
+ * 连接器操作逻辑
+ */
+@concept('连接器操作逻辑')
+export class ConnectorLogic extends Logic {
+  /** 类名 */
+  static readonly ConceptName: string = 'ConnectorLogic';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['Logic', 'BaseNode'];
+
+  /**
+   * 产品概念
+   */
+  @property('concept')
+  // @ts-ignore
+  readonly concept!: 'ConnectorLogic';
+  /**
+   * 模式类型
+   */
+  @property({
+    objectRef: '',
+  })
+  kind: 'http' | 'pipeline';
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<ConnectorLogic>) {
+    source = Object.assign({}, ConnectorLogic.getDefaultOptions(), source);
+    super(source);
+    super.subConstructor(source);
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): ConnectorLogic {
+    return super.from(source, parentNode, parentKey) as ConnectorLogic;
+  }
+
+  /**
+   * 设置模式类型
+   */
+  setKind(kind: 'http' | 'pipeline') {
+    const object = {
+      kind,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  //================================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //================================================================================
+
+  //================================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //================================================================================
+}
+
+export default ConnectorLogic;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================