@lcap/nasl 3.6.0-beta.1 → 3.7.0-beta.1

package/src/concepts/CapsulesSetter__.ts

@@ -0,0 +1,254 @@
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 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 SetterOption from './SetterOption__';
+import BaseSetter from './BaseSetter__';
+
+/**
+ * 胶囊设置器
+ */
+@concept('胶囊设置器')
+export class CapsulesSetter extends BaseSetter {
+  /** 类名 */
+  static readonly ConceptName: string = 'CapsulesSetter';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseSetter', 'BaseNode'];
+
+  /**
+   * 产品概念
+   */
+  @property('concept')
+  // @ts-ignore
+  readonly concept!: 'CapsulesSetter';
+  /**
+   * 枚举选项列表
+   */
+  @property({
+    objectRef: 'SetterOption',
+    isArray: true,
+    defaultValue: [],
+  })
+  options: Array<SetterOption> = [];
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<CapsulesSetter>) {
+    source = Object.assign({}, CapsulesSetter.getDefaultOptions(), source);
+    super(source);
+    super.subConstructor(source);
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): CapsulesSetter {
+    return super.from(source, parentNode, parentKey) as CapsulesSetter;
+  }
+
+  getSetterOptionExistingNames(excludedList: Array<SetterOption> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.options as SetterOption[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+  getSetterOptionUniqueName(name = 'setterOption1') {
+    return utils.unique(name, this.getSetterOptionExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入设置器枚举选项
+   * @internal
+   * @param name 设置器枚举选项名称，如果不填会自动生成一个唯一名称
+   */
+  _insertSetterOptionAt(name: string, index: number): SetterOption;
+
+  /**
+   * 插入设置器枚举选项
+   * @internal
+   * @param setterOptionOptions 设置器枚举选项参数
+   */
+  _insertSetterOptionAt(setterOptionOptions: Partial<SetterOption>, index: number): SetterOption;
+
+  /**
+   * 插入设置器枚举选项
+   * @internal
+   * @param setterOption 已有的设置器枚举选项实例
+   */
+  _insertSetterOptionAt(setterOption: SetterOption, index: number): SetterOption;
+
+  _insertSetterOptionAt(options: string | Partial<SetterOption> | SetterOption, index: number) {
+    const setterOptionOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'options' };
+    const SetterOption = getConceptConstructor('SetterOption');
+    let setterOption: SetterOption;
+    if (!options) {
+      setterOption = SetterOption.from(
+        {
+          ...setterOptionOptions,
+          name: this.getSetterOptionUniqueName(),
+        },
+        this,
+        'options',
+      );
+    } else if (typeof options === 'string') {
+      setterOption = SetterOption.from(
+        {
+          ...setterOptionOptions,
+          name: options,
+        },
+        this,
+        'options',
+      );
+    } else if (asserts.isSetterOption(options)) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      setterOption = options;
+      Object.assign(setterOption, relationOptions);
+    } else {
+      setterOption = SetterOption.from(
+        {
+          ...setterOptionOptions,
+          ...options,
+        },
+        this,
+        'options',
+      );
+    }
+    this.options.splice(index, 0, setterOption);
+    return setterOption;
+  }
+
+  /**
+   * 插入设置器枚举选项
+   * @param name 设置器枚举选项名称，如果不填会自动生成一个唯一名称
+   */
+  insertSetterOptionAt(name: string, index: number): SetterOption;
+
+  /**
+   * 插入设置器枚举选项
+   * @param setterOptionOptions 设置器枚举选项参数
+   */
+  insertSetterOptionAt(setterOptionOptions: Partial<SetterOption>, index: number): SetterOption;
+
+  /**
+   * 插入设置器枚举选项
+   * @param setterOption 已有的设置器枚举选项实例
+   */
+  insertSetterOptionAt(setterOption: SetterOption, index: number): SetterOption;
+
+  insertSetterOptionAt(options: string | Partial<SetterOption> | SetterOption, index: number) {
+    const node = this._insertSetterOptionAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'options',
+    });
+    return node;
+  }
+
+  /**
+   * 添加设置器枚举选项
+   * @internal
+   * @param name 设置器枚举选项名称，如果不填会自动生成一个唯一名称
+   */
+  _addSetterOption(name?: string): SetterOption;
+
+  /**
+   * 添加设置器枚举选项
+   * @internal
+   * @param setterOptionOptions 设置器枚举选项参数
+   */
+  _addSetterOption(setterOptionOptions: Partial<SetterOption>): SetterOption;
+
+  /**
+   * 添加设置器枚举选项
+   * @internal
+   * @param setterOption 已有的设置器枚举选项实例
+   */
+  _addSetterOption(setterOption: SetterOption): SetterOption;
+
+  _addSetterOption(options?: string | Partial<SetterOption> | SetterOption) {
+    const index = this.options.length;
+    return this._insertSetterOptionAt(options as any, index);
+  }
+
+  /**
+   * 添加设置器枚举选项
+   * @internal
+   * @param name 设置器枚举选项名称，如果不填会自动生成一个唯一名称
+   */
+  addSetterOption(name?: string): SetterOption;
+
+  /**
+   * 添加设置器枚举选项
+   * @param setterOptionOptions 设置器枚举选项参数
+   */
+  addSetterOption(setterOptionOptions: Partial<SetterOption>): SetterOption;
+
+  /**
+   * 添加设置器枚举选项
+   * @param setterOption 已有的设置器枚举选项实例
+   */
+  addSetterOption(setterOption: SetterOption): SetterOption;
+
+  addSetterOption(options?: string | Partial<SetterOption> | SetterOption) {
+    const node = this._addSetterOption(options as any);
+    const index = this.options.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'options',
+    });
+    return node;
+  }
+
+  /**
+   * 删除设置器枚举选项
+   * @param name 设置器枚举选项名称
+   */
+  removeSetterOption(name: string): void;
+
+  /**
+   * 删除设置器枚举选项
+   * @param setterOption 已有的设置器枚举选项实例
+   */
+  removeSetterOption(setterOption: SetterOption): void;
+
+  removeSetterOption(options: string | SetterOption) {
+    let setterOption: SetterOption;
+    if (typeof options === 'string') {
+      setterOption = (this.options as SetterOption[]).find((item) => item.name === options);
+      if (!setterOption) {
+        throw new Error('找不到设置器枚举选项 ' + options);
+      }
+    } else {
+      setterOption = options;
+    }
+    return setterOption.delete();
+  }
+
+  //================================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //================================================================================
+
+  //================================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //================================================================================
+}
+
+export default CapsulesSetter;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================

package/src/concepts/Comment__.ts

@@ -29,6 +29,13 @@ import LogicItem from './LogicItem__';
 export class Comment extends LogicItem {
   /** 类名 */
   static readonly ConceptName: string = 'Comment';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/CompletionProperty__.ts

@@ -20,6 +20,13 @@ import TypeAnnotation from './TypeAnnotation__';
 export class CompletionProperty extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'CompletionProperty';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
@@ -67,14 +74,6 @@ export class CompletionProperty extends BaseNode {
   })
   typeAnnotation: TypeAnnotation;
 
-  /**
-   * 是否必填
-   */
-  @property({
-    objectRef: '',
-  })
-  required: boolean;
-
   /**
    * 默认值
    */
@@ -145,18 +144,6 @@ export class CompletionProperty extends BaseNode {
     });
   }
 
-  /**
-   * 设置是否必填
-   */
-  setRequired(required: boolean) {
-    const object = {
-      required,
-    };
-    this.update({
-      ...object,
-    });
-  }
-
   /**
    * 设置默认值
    */

package/src/concepts/ConfigGroup__.ts

@@ -21,6 +21,13 @@ import ConfigProperty from './ConfigProperty__';
 export class ConfigGroup extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'ConfigGroup';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/ConfigPropertyValue__.ts

@@ -18,6 +18,13 @@ import BaseNode from '../common/BaseNode';
 export class ConfigPropertyValue extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'ConfigPropertyValue';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/ConfigProperty__.ts

@@ -35,6 +35,13 @@ import ConfigPropertyValue from './ConfigPropertyValue__';
 export class ConfigProperty extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'ConfigProperty';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/Configuration__.ts

@@ -21,6 +21,13 @@ import ConfigGroup from './ConfigGroup__';
 export class Configuration extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'Configuration';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/Connection__.ts

@@ -34,6 +34,13 @@ import ConfigProperty from './ConfigProperty__';
 export class Connection extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'Connection';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/ConnectorTrigger__.ts

@@ -24,6 +24,13 @@ import TriggerEvent from './TriggerEvent__';
 export class ConnectorTrigger extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'ConnectorTrigger';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/Connector__.ts

@@ -29,6 +29,13 @@ import Module from './Module__';
 export class Connector extends Module {
   /** 类名 */
   static readonly ConceptName: string = 'Connector';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['Module', 'BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/Constant__.ts

@@ -38,6 +38,13 @@ import DefaultValue from './DefaultValue__';
 export class Constant extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'Constant';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/CountersignPolicy__.ts

@@ -19,6 +19,13 @@ import MultiApprovalPolicy from './MultiApprovalPolicy__';
 export class CountersignPolicy extends MultiApprovalPolicy {
   /** 类名 */
   static readonly ConceptName: string = 'CountersignPolicy';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['MultiApprovalPolicy', 'BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/DataSource__.ts

@@ -32,6 +32,13 @@ import Entity from './Entity__';
 export class DataSource extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'DataSource';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/DatabaseTypeAnnotation__.ts

@@ -18,6 +18,13 @@ import BaseNode from '../common/BaseNode';
 export class DatabaseTypeAnnotation extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'DatabaseTypeAnnotation';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/DefaultValue__.ts

@@ -21,6 +21,13 @@ import LogicItem from './LogicItem__';
 export class DefaultValue extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'DefaultValue';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/Destination__.ts

@@ -37,6 +37,13 @@ import LogicItem from './LogicItem__';
 export class Destination extends LogicItem {
   /** 类名 */
   static readonly ConceptName: string = 'Destination';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/End__.ts

@@ -30,6 +30,13 @@ import LogicItem from './LogicItem__';
 export class End extends LogicItem {
   /** 类名 */
   static readonly ConceptName: string = 'End';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/EntityIndex__.ts

@@ -33,6 +33,13 @@ import BaseNode from '../common/BaseNode';
 export class EntityIndex extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'EntityIndex';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/EntityProperty__.ts

@@ -45,6 +45,13 @@ import DefaultValue from './DefaultValue__';
 export class EntityProperty extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'EntityProperty';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
@@ -670,20 +677,19 @@ export class EntityProperty extends BaseNode {
     const databaseTypeMap = this.app?.__databaseTypeMap?.[dataSourceSqlType] || {};
     let { typeKind, typeName, typeNamespace } = this?.typeAnnotation || {};
     let databaseTypeInfo;
-    const items = this.typeAnnotation;
-    if (items?.typeNamespace?.endsWith('.metadataTypes')) {
-      const referenceNode =
-        (this.getAncestor('App') as App).findNodeByCompleteName(items.typeNamespace + '.' + items.typeName)
-          ?.typeAnnotation || {};
+    if (typeNamespace?.endsWith('.metadataTypes')) {
+      const referenceNode = this.app.findNodeByCompleteName(typeNamespace + '.' + typeName)?.typeAnnotation || {};
       typeKind = referenceNode.typeKind;
       typeName = referenceNode.typeName;
       typeNamespace = referenceNode.typeNamespace;
     }
     if (typeNamespace?.endsWith('.enums')) {
-      databaseTypeInfo = databaseTypeMap.enum;
-    } else {
-      databaseTypeInfo = databaseTypeMap[typeKind] || databaseTypeMap[typeName];
+      const referenceNode = this.app.findNodeByCompleteName(typeNamespace + '.' + typeName)?.valueType || {};
+      typeKind = referenceNode.typeKind;
+      typeName = referenceNode.typeName;
+      typeNamespace = referenceNode.typeNamespace;
     }
+    databaseTypeInfo = databaseTypeMap[typeKind] || databaseTypeMap[typeName];
     return databaseTypeInfo;
   }
 

package/src/concepts/Entity__.ts

@@ -37,6 +37,13 @@ import EntityIndex from './EntityIndex__';
 export class Entity extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'Entity';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/EnumItem__.ts

@@ -29,6 +29,13 @@ import BaseNode from '../common/BaseNode';
 export class EnumItem extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'EnumItem';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念