@lcap/nasl 1.0.0 → 2.12.0-beta

package/src/concepts/basics/stdlib/nasl.util.ts

@@ -718,18 +718,281 @@ export default new Namespace({
             ],
         }),
         new Function({
-            name: 'GetProperties',
-            description: '获取应用配置参数',
+            name: 'CreatePageOf',
+            description: '将List<T>集合转换为分页集合PageOf<T>',
             params: [
                 new Param({
-                    name: 'name',
-                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
-                    useComponent: { type: 's-config-select' },
+                    name: 'list',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'page',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+                }),
+                new Param({
+                    name: 'size',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+                }),
+                new Param({
+                    name: 'total',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
                 }),
             ],
             returns: [
                 new Return({
-                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('PageOf', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'ListSort',
+            description: '为集合按规则排序',
+            params: [
+                new Param({
+                    name: 'list',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'by',
+                    defaultExpression: new Function({
+                        name: '',
+                        description: '',
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+                new Param({
+                    name: 'sort',
+                    description: '下拉选择升序、降序',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+                    defaultValue: 'asc',
+                    defaultExpression: new BooleanLiteral({ value: 'true' }),
+                    options: [
+                        { text: 'asc', value: 'true' },
+                        { text: 'desc', value: 'false' },
+                    ],
+                }),
+            ],
+            returns: [],
+        }),
+        new Function({
+            name: 'ListFind',
+            description: '筛选符合条件的第一个项',
+            params: [
+                new Param({
+                    name: 'list',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'by',
+                    defaultExpression: new Function({
+                        name: '',
+                        description: '',
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'ListFindIndex',
+            description: '筛选符合条件的第一个项的索引值',
+            params: [
+                new Param({
+                    name: 'list',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'by',
+                    defaultExpression: new Function({
+                        name: '',
+                        description: '',
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'ListFindAll',
+            description: '筛选符合条件的所有项',
+            params: [
+                new Param({
+                    name: 'list',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'by',
+                    defaultExpression: new Function({
+                        name: '',
+                        description: '',
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'ListReverse',
+            description: '为集合反向排序',
+            params: [
+                new Param({
+                    name: 'list',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+            ],
+            returns: [],
+        }),
+        new Function({
+            name: 'ListDistinct',
+            description: '为集合去除重复项',
+            params: [
+                new Param({
+                    name: 'list',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+            ],
+            returns: [],
+        }),
+        new Function({
+            name: 'ListSlice',
+            description: '将集合按照规则切片，返回切片后的子集合',
+            params: [
+                new Param({
+                    name: 'list',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'start',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+                }),
+                new Param({
+                    name: 'end',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'ListSliceToPageOf',
+            description: '将集合按照规则切片，返回切片后的PageOf集合',
+            params: [
+                new Param({
+                    name: 'list',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'page',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+                }),
+                new Param({
+                    name: 'size',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('PageOf', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'ListAddAll',
+            description: '为集合添加多项内容，并返回集合长度',
+            params: [
+                new Param({
+                    name: 'list',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'addlist',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+                }),
+            ],
+        }),
+        new Function({
+            name: 'New',
+            description: '根据参数选择的类型，返回该参数的实例化对象',
+            typeParams: [
+                new TypeParam({
+                    name: 'T',
+                }),
+            ],
+            params: [
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),

package/src/concepts/basics/stdlib/reference2TypeAnnotationList.ts

@@ -9,7 +9,7 @@ import Enum from '../../Enum__';
 import TypeAnnotation from '../../TypeAnnotation__';
 import { primitiveTypeList } from '../types/coreTypeList';
 
-export function reference2TypeAnnotationList(list: Array<Entity | Structure | Enum>, namespace: string) {
+export function reference2TypeAnnotationList(list: Array<Entity | Structure | Enum> = [], namespace: string) {
     return list.map((item) => {
         if (item instanceof Structure && item.typeParams?.length > 0) {
             return TypeAnnotation.createReference(item.name, {

package/src/concepts/basics/types/index.ts

@@ -18,3 +18,4 @@ primitiveTypeList.forEach((typeAnnotation) => {
 export { collectionStructures, collectionTypeList } from '../stdlib/nasl.collection';
 export { uiStructures, uiTypeList } from '../stdlib/nasl.ui';
 export { interfaceTypeList } from '../stdlib/nasl.interface';
+export { interfaceStructures } from '../stdlib/nasl.interface';

package/src/concepts/index__.ts

@@ -8,6 +8,7 @@ export * from './StructureProperty__';
 export * from './Enum__';
 export * from './EnumItem__';
 export * from './DataElement__';
+export * from './DataSource__';
 export * from './Entity__';
 export * from './EntityProperty__';
 export * from './EntityIndex__';

package/src/enums/KEYWORDS.ts

@@ -130,8 +130,6 @@ export const KEYWORDS = [
     'out',
     'override',
     'package',
-    'param',
-    'params',
     'path',
     'pc',
     'private',
@@ -791,7 +789,6 @@ export const ENTITY_KEYWORDS = [
     'PROTECTED',
     'PUBLIC',
     'PURGE',
-    'Page',
     'Pageable',
     'PaginationUtil',
     'PutMapping',
@@ -914,14 +911,12 @@ export const ENTITY_KEYWORDS = [
     'SHUTDOWN',
     'SIGNAL',
     'SIMILAR',
-    'SIZE',
     'SKIP',
     'SKIP_UNUSABLE_INDEXES',
     'SLOW',
     'SMALLINT',
     'SNAPSHOT',
     'SOME',
-    'SORT',
     'SPATIAL',
     'SPECIFIC',
     'SPECIFICATION',
@@ -1199,8 +1194,4 @@ export const ENTITY_PROPERTY_KEYWORDS = [
     'PUBLIC',
     'STATIC',
     'YIELD',
-    'SIZE',
-    'SORT',
-    'CODE',
-    'PAGE',
 ];

package/src/generator/genBundleFiles.ts

@@ -56,7 +56,13 @@ export async function genBundleFiles(app: App,
     const processes: Process[] = [];
 
     app.views && views.push(...app.views);
-    app.entities && entities.push(...app.entities);
+    if (Array.isArray(app.dataSources)) {
+        app.dataSources.forEach((dataSource) => {
+            if (Array.isArray(dataSource.entities)) {
+                entities.push(...dataSource.entities);
+            }
+        });
+    }
     app.structures && structures.push(...app.structures);
     app.enums && enums.push(...app.enums);
     app.logics && logics.push(...app.logics);
@@ -67,7 +73,6 @@ export async function genBundleFiles(app: App,
 
     modules.forEach((module: Module) => {
         module.views && views.push(...module.views);
-        module.entities && entities.push(...module.entities);
         module.structures && structures.push(...module.structures);
         module.enums && enums.push(...module.enums);
         module.logics && logics.push(...module.logics);
@@ -345,7 +350,7 @@ export async function genBundleFiles(app: App,
 
     if (config.env === 'dev') {
         // 加载资源js
-        const domain = config.lowcodeDomain.slice(5);
+        const domain = config.lowcodeDomain.slice(config.lowcodeDomain.indexOf('.') + 1);
         const targetUrl = `${location.origin}/empty?url=${domain}&appid=${config.appid}`;
         const str = `
        if(!document.querySelector("iframe[name='iframeEmpty']")){

package/src/generator/genMetaData.ts

@@ -1,4 +1,4 @@
-import { App, View, BaseNode, Module, Interface, Entity, Structure, Enum, uiStructures, collectionStructures, Logic, Process } from '../concepts';
+import { App, View, BaseNode, Module, Interface, Entity, Structure, Enum, uiStructures, collectionStructures, Logic, Process, DataSource } from '../concepts';
 
 export function genMetaData(app: App,
     config: {
@@ -12,7 +12,7 @@ export function genMetaData(app: App,
     }) {
     const modules: Module[] = [];
     const views: View[] = [];
-    const entities: Entity[] = [];
+    const dataSources: DataSource[] = [];
     const structures: Structure[] = [];
     const enums: Enum[] = [];
     const logics: Logic[] = [];
@@ -20,7 +20,7 @@ export function genMetaData(app: App,
     const processes: Process[] = [];
 
     const {
-        entities: appEntities = [],
+        dataSources: appDataSources = [],
         structures: appStructures = [],
         enums: appEnums = [],
         logics: appLogics = [],
@@ -28,7 +28,7 @@ export function genMetaData(app: App,
         dependencies: appDependencies = [],
         processes: appProcesses = [],
     } = app || {};
-    entities.push(...appEntities);
+    dataSources.push(...appDataSources);
     structures.push(...appStructures);
     enums.push(...appEnums);
     logics.push(...appLogics);
@@ -42,14 +42,12 @@ export function genMetaData(app: App,
     modules.forEach((module: Module) => {
         const {
             views: moduleViews = [],
-            entities: moduleEntities = [],
             structures: moduleStructures = [],
             enums: moduleEnums = [],
             logics: moduleLogics = [],
             interfaces: moduleInterfaces = [],
         } = module;
         views.push(...moduleViews);
-        entities.push(...moduleEntities);
         structures.push(...moduleStructures);
         enums.push(...moduleEnums);
         logics.push(...moduleLogics);
@@ -93,13 +91,15 @@ export function genMetaData(app: App,
             enumsMap[name] = enumObj;
         });
     }
-    if (Array.isArray(entities)) {
-        dataTypes.push(...entities);
-        entities.forEach((entity) => {
-            const ns = entity.ns;
-            if (Array.isArray(ns?.logics)) {
-                allLogics.push(...ns.logics);
-            }
+    if (Array.isArray(dataSources)) {
+        dataSources.forEach((dataSource)=> {
+            dataSource.entities.forEach((entity) => {
+                dataTypes.push(entity);
+                const ns = entity.ns;
+                if (Array.isArray(ns?.logics)) {
+                    allLogics.push(...ns.logics);
+                }
+            });
         });
     }
     if (Array.isArray(structures)) {

package/src/manager/diagnostic.ts

@@ -10,7 +10,7 @@ import * as tsProtocol from 'typescript/lib/protocol';
 export interface Diagnostic {
     id?: string;
     severity: string;
-    originalDiagnostic: tsProtocol.DiagnosticWithFileName;
+    originalDiagnostic?: tsProtocol.DiagnosticWithFileName;
     message?: string;
     code?: number;
     node?: BaseNode;

package/src/server/createUiTs.ts

@@ -12,6 +12,7 @@ const naslStdlibMap: any = {
     'nasl.langUtil.ts': require('!!raw-loader!../../../file-storage/data/stdlib/nasl.langUtil.ts').default,
     'nasl.annotation.ts': require('!!raw-loader!../../../file-storage/data/stdlib/nasl.annotation.ts').default,
     'nasl.validation.ts': require('!!raw-loader!../../../file-storage/data/stdlib/nasl.validation.ts').default,
+    'nasl.process.ts': require('!!raw-loader!../../../file-storage/data/stdlib/nasl.process.ts').default,
 };
 
 export default function formatUiTs(allComponent: any) {