@lcap/nasl 1.0.2 → 2.12.0

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: [
@@ -748,5 +771,261 @@ export default new Namespace({
                 }),
             ],
         }),
+        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'),
+                }),
+            ],
+        }),
+        // new Function({
+        //     name: 'CreatePageOf',
+        //     description: '将List<T>集合转换为分页集合PageOf<T>',
+        //     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'),
+        //         }),
+        //         new Param({
+        //             name: 'total',
+        //             typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+        //         }),
+        //     ],
+        //     returns: [
+        //         new Return({
+        //             typeAnnotation: TypeAnnotation.createPrimitive('PageOf', {
+        //                 typeArguments: [TypeAnnotation.createTypeParam('T')],
+        //             }),
+        //         }),
+        //     ],
+        // }),
     ],
 });

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

@@ -16,6 +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/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/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) {

package/src/server/getLogics.ts

@@ -24,8 +24,8 @@ function iterator(tree: FakeNode | FakeProcessNode, searchContent: string, fakeN
         if (tree.children) {
             tree.children.forEach((c) => {
                 const childFakeNode = {};
-                if(c.title?.toLowerCase().includes(searchContent) || c.name?.toLowerCase().includes(searchContent))
-                    fakeNode.children.push({...c});
+                if (c.title?.toLowerCase().includes(searchContent) || c.name?.toLowerCase().includes(searchContent))
+                    fakeNode.children.push({ ...c });
                 else if (iterator(c, searchContent, childFakeNode)) {
                     fakeNode.children.push(childFakeNode);
                 }
@@ -63,7 +63,15 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
         const result = [];
 
         if (needAllLogic) {
-            const nc = app.entities.map((entity) => entity.ns);
+            const nc: Namespace[] = [];
+            if (Array.isArray(app.dataSources)) {
+                app.dataSources.forEach((dataSource) => {
+                    if (Array.isArray(dataSource.entities)) {
+                        const list = dataSource.entities.map((entity) => entity.ns);
+                        nc.push(...list);
+                    }
+                });
+            }
             nc.map((item) => {
                 item.logics = item.logics.filter((logic) => !logic.name.startsWith('import'));
                 item.expanded = true;
@@ -120,12 +128,18 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
             });
             tree.expanded = true;
             result.push(tree);
-
             const systemTree = new Namespace({
                 name: 'category',
                 path: `nasl`,
                 title: '系统逻辑',
                 children: [
+                    new Namespace({
+                        name: 'category',
+                        path: `process`,
+                        title: '流程逻辑',
+                        logics: stdlibNamespace.findChild('process').logics,
+                        expanded: true,
+                    }),
                     new Namespace({
                         name: 'category',
                         path: `browser`,
@@ -150,6 +164,8 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                 ],
                 expanded: true,
             });
+            if (!app.processes.length)
+                systemTree.children.shift();
 
             systemTree.expanded = true;
             systemTree.children.forEach((child) => (child.expanded = true));
@@ -161,6 +177,13 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                 path: `nasl`,
                 title: '系统逻辑',
                 children: [
+                    new Namespace({
+                        name: 'category',
+                        path: `process`,
+                        title: '流程逻辑',
+                        logics: stdlibNamespace.findChild('process').logics,
+                        expanded: true,
+                    }),
                     new Namespace({
                         name: 'category',
                         path: `configuration`,
@@ -171,6 +194,8 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                 ],
                 expanded: true,
             });
+            if (!app.processes.length)
+                systemTree.children.shift();
 
             systemTree.expanded = true;
             systemTree.children.forEach((child) => (child.expanded = true));

package/src/server/getMemberIdentifier.ts

@@ -76,6 +76,10 @@ function createType2Annotation(type: string): TypeAnnotation {
             typeAnnotation = TypeAnnotation.createReference(types[types.length - 1], {
                 typeNamespace: 'nasl.ui',
             });
+        } else if (type.startsWith('nasl.process')) {
+            typeAnnotation = TypeAnnotation.createReference(types[types.length - 1], {
+                typeNamespace: 'nasl.process',
+            });
         } else if (type.startsWith('nasl.collection')) {
             typeAnnotation = TypeAnnotation.createGeneric(types[types.length - 1], {
                 typeNamespace: 'nasl.collection',