@lcap/nasl 1.0.1 → 2.12.0-beta.1

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

@@ -416,6 +416,29 @@ export default new Namespace({
                 }),
             ],
         }),
+        new Function({
+            name: 'AddAll',
+            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: 'Insert',
             description: '为集合指定索引插入项（原索引项依次后推）',
@@ -555,7 +578,7 @@ export default new Namespace({
                 new Param({
                     name: 'digits',
                     typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
-                    description: "保留小数位数",
+                    description: '保留小数位数',
                     defaultValue: '2',
                     defaultExpression: new NumericLiteral({ value: '2' }),
                 }),
@@ -568,7 +591,7 @@ export default new Namespace({
                         { text: 'true', value: 'true' },
                         { text: 'false', value: 'false' },
                     ],
-                    description: "是否显示千分位：true显示，false不显示",
+                    description: '是否显示千分位：true显示，false不显示',
                 }),
             ],
             returns: [
@@ -718,18 +741,258 @@ 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: '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

@@ -16,5 +16,7 @@ primitiveTypeList.forEach((typeAnnotation) => {
 });
 
 export { collectionStructures, collectionTypeList } from '../stdlib/nasl.collection';
+export { processStructures, processTypeList } from '../stdlib/nasl.process';
 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

@@ -789,7 +789,6 @@ export const ENTITY_KEYWORDS = [
     'PROTECTED',
     'PUBLIC',
     'PURGE',
-    'Page',
     'Pageable',
     'PaginationUtil',
     'PutMapping',
@@ -912,14 +911,12 @@ export const ENTITY_KEYWORDS = [
     'SHUTDOWN',
     'SIGNAL',
     'SIMILAR',
-    'SIZE',
     'SKIP',
     'SKIP_UNUSABLE_INDEXES',
     'SLOW',
     'SMALLINT',
     'SNAPSHOT',
     'SOME',
-    'SORT',
     'SPATIAL',
     'SPECIFIC',
     'SPECIFICATION',
@@ -1197,8 +1194,4 @@ export const ENTITY_PROPERTY_KEYWORDS = [
     'PUBLIC',
     'STATIC',
     'YIELD',
-    'SIZE',
-    'SORT',
-    'CODE',
-    'PAGE',
 ];

package/src/generator/genBundleFiles.ts

@@ -1,4 +1,4 @@
-import { App, Module, View, BaseNode, Entity, Structure, Enum, uiStructures, collectionStructures, Logic, Interface, Process } from '../concepts';
+import { App, Module, View, BaseNode, Entity, Structure, Enum, uiStructures, collectionStructures, processStructures, Logic, Interface, Process } from '../concepts';
 import * as utils from '../utils';
 import { genHash, RawOptions } from '.';
 import { compileComponent } from './compileComponent';
@@ -20,8 +20,8 @@ export interface PageOptions {
     hasUserCenter: boolean;
     hasAuth: boolean;
     domainName: string;
-    nuimsDomain: string;
     auth: boolean;
+    subPage: object;
     documentTitle?: string;
     router: {
         notFound: string;
@@ -44,8 +44,12 @@ export async function genBundleFiles(app: App,
         USER_STATIC_URL: string;
         extendedConfig: string;
         lowcodeDomain: string;
+        envLcpDomain: any,
+        envNuimsDomain: any,
         appid: string;
     }) {
+    const fnNuimsDomain = config?.envNuimsDomain?.[config?.env] || config?.nuimsDomain;
+    const fnLowcodeDomain = config?.envLcpDomain?.[config?.env]?.lcpDomain || config?.lowcodeDomain;
     const modules: Module[] = [];
     const views: View[] = [];
     const entities: Entity[] = [];
@@ -56,7 +60,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 +77,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);
@@ -130,8 +139,8 @@ export async function genBundleFiles(app: App,
             hasUserCenter: app.hasUserCenter,
             hasAuth: app.hasAuth,
             domainName: app.name,
-            nuimsDomain: config.nuimsDomain,
             auth: view.auth,
+            subPage: view.children,
             documentTitle: app.documentTitle,
             router: {
                 notFound: '/',
@@ -212,6 +221,14 @@ export async function genBundleFiles(app: App,
         });
     }
 
+    if (Array.isArray(processStructures)) {
+        const namespace = 'nasl.process';
+        processStructures.forEach((node) => {
+            const id = `${namespace}.${node.name}`;
+            dataTypesMap[id] = node;
+        });
+    }
+
     if (Array.isArray(logics)) {
         allLogics.push(...logics);
     }
@@ -247,9 +264,11 @@ export async function genBundleFiles(app: App,
             },
         },
         extendedConfig: config.extendedConfig,
-        lowcodeDomain: config.lowcodeDomain,
+        lowcodeDomain: fnLowcodeDomain,
         tenant: config.tenant,
         env: config.env,
+        nuimsDomain: fnNuimsDomain,
+        envNuimsDomain: config.envNuimsDomain,
         indexName,
     }, null, 4);
 
@@ -336,6 +355,8 @@ export async function genBundleFiles(app: App,
             tenant: data.tenant,
             env: data.env,
             extendedConfig: data.extendedConfig,
+            nuimsDomain: data.nuimsDomain,
+            envNuimsDomain: data.envNuimsDomain,
             envConfig: {
                 lowcodeDomain: data.lowcodeDomain,
             },
@@ -345,7 +366,7 @@ export async function genBundleFiles(app: App,
 
     if (config.env === 'dev') {
         // 加载资源js
-        const domain = config.lowcodeDomain.slice(5);
+        const domain = fnLowcodeDomain.slice(fnLowcodeDomain.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,10 +1,11 @@
-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, processStructures, Logic, Process, DataSource } from '../concepts';
 
 export function genMetaData(app: App,
     config: {
         tenant: string;
         env: string;
         nuimsDomain: string;
+        envNuimsDomain: Object;
         STATIC_URL: string;
         USER_STATIC_URL: string;
         extendedConfig: string;
@@ -12,7 +13,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 +21,7 @@ export function genMetaData(app: App,
     const processes: Process[] = [];
 
     const {
-        entities: appEntities = [],
+        dataSources: appDataSources = [],
         structures: appStructures = [],
         enums: appEnums = [],
         logics: appLogics = [],
@@ -28,7 +29,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 +43,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 +92,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)) {
@@ -127,6 +128,14 @@ export function genMetaData(app: App,
         });
     }
 
+    if (Array.isArray(processStructures)) {
+        const namespace = 'nasl.process';
+        processStructures.forEach((node) => {
+            const id = `${namespace}.${node.name}`;
+            dataTypesMap[id] = node;
+        });
+    }
+
     if (Array.isArray(logics)) {
         allLogics.push(...logics);
     }

package/src/index.ts

@@ -8,5 +8,5 @@ export * as genBlock from './templator';
 export * as utils from './utils';
 export * from './config';
 export * from './eventBus';
-export { loadApp, loadAppSync } from './service/storage/init';
+export { loadApp, loadAppSync, handleApp } from './service/storage/init';
 import './automate/engine';

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) {