@lcap/nasl 2.20.1-beta.2 → 2.21.0-beta.2

package/src/templator/genEditTableBlock.ts

@@ -1,8 +1,8 @@
 import * as utils from '../utils';
-import { Entity, EntityProperty, DataSource } from '../concepts';
+import { Entity, EntityProperty, DataSource, Enum } from '../concepts';
 import {
     filterProperty, NameGroup, getFirstDisplayedProperty, getParamFromLogic,
-    genCallComponentLogic, genMemberExpression, genLogicParam,
+    genCallComponentLogic, genMemberExpression, genLogicParam, genEnumSelectBlock,
 } from '.';
 import { NaslUITypeAnnotation, NaslLogicItem, NaslNode } from './utils';
 
@@ -35,6 +35,7 @@ export function genEditTableColumnTemplate(entity: Entity, property: EntityPrope
         let formItem = '';
 
         const propertyTypeName = property.typeAnnotation.typeName;
+        const propertyTypeNamespace = property.typeAnnotation.typeNamespace;
         if (property.relationEntity && selectNameGroupMap) {
             // 有外键关联
             const relationEntity = dataSource?.findEntityByName(property.relationEntity);
@@ -79,9 +80,23 @@ export function genEditTableColumnTemplate(entity: Entity, property: EntityPrope
         } else if (propertyTypeName === 'DateTime') {
             formItem = `<u-date-time-picker clearable :date.sync="${valueExpression}" placeholder="请输入${label}" append-to="body" :autofocus="true" :opened="true" @blur="${nameGroup.viewLogicBlurUpdate}"></u-date-time-picker>`;
         } else {
-            formItem = `<u-validator placement="bottom" display="appear" @blur-valid="${nameGroup.viewLogicBlurUpdate}" style="width:100%" append-to="body">
-                <u-input :value.sync="${valueExpression}" placeholder="请输入${label}" :autofocus="true" size="full"></u-input>
-            </u-validator>`;
+            const namespaceArr = propertyTypeNamespace.split('.');
+            const type = namespaceArr.pop();
+            if (type === 'enums') {
+                const enumeration = dataSource.app.findNodeByCompleteName(propertyTypeNamespace + '.' + propertyTypeName) as Enum;
+                const namespace = enumeration?.getNamespace() || '';
+                const name = enumeration?.name || '';
+                const enumTypeAnnotationStr = `__enumTypeAnnotation_${namespace}.${name}`;
+                formItem += `<u-select clearable 
+                :data-source="$utils.EnumToList('${enumTypeAnnotationStr}')"
+                :value.sync="${valueExpression}" placeholder="请输入${label}"
+                :autofocus="true" :opened="true" append-to="body" @blur="${nameGroup.viewLogicBlurUpdate}" @select="${nameGroup.viewLogicBlurUpdate}">
+                </u-select>`;
+            } else {
+                formItem = `<u-validator placement="bottom" display="appear" @blur-valid="${nameGroup.viewLogicBlurUpdate}" style="width:100%" append-to="body">
+                    <u-input :value.sync="${valueExpression}" placeholder="请输入${label}" :autofocus="true" size="full"></u-input>
+                </u-validator>`;
+            }
         }
         return `<template #editcell="current">
             <u-linear-layout gap="small">
@@ -111,7 +126,7 @@ export function genEditTableTemplate(entity: Entity, nameGroup: NameGroup, selec
 
     return `<u-table-view ref="${nameGroup.viewElementMainView}" :data-source="${nameGroup.viewLogicLoad}" data-schema="${nameGroup.structure}"
         value-field="${nameGroup.viewVariableEntity}.id"
-        :pageable="true" :remote-paging="true" :show-sizer="true" :default-column-width="300" editable>
+        :pagination="true" :show-sizer="true" :default-column-width="300" editable>
     <u-table-view-column type="index" width="60"><template #title><u-text text="序号"></u-text></template><template #cell="current"></template></u-table-view-column>
 
     ${properties.map((property) => genEditTableColumnTemplate(entity, property, nameGroup, selectNameGroupMap) + '\n').join('')}
@@ -217,9 +232,20 @@ export function genEditTableRemoveLogic(entity: Entity, nameGroup: NameGroup) {
 }
 
 export function genBlurUpdateLogic(entity: Entity, nameGroup: NameGroup) {
-    const lowerEntityName = utils.firstLowerCase(entity.name);
-    const ns = entity.ns;
-    const updateLogic = ns?.logics?.find((logic) => logic.name === `update`);
+    const callLogics = [];
+    if (entity.concept === 'Entity') {
+        const lowerEntityName = utils.firstLowerCase(entity.name);
+        const ns = entity.ns;
+        const updateLogic = ns?.logics?.find((logic) => logic.name === `update`);
+        const valuePrefixExpression = nameGroup.valuePrefixExpression ? nameGroup.valuePrefixExpression : `current.item.${lowerEntityName}`;
+        callLogics.push(NaslLogicItem.CallLogic({
+            calleeNamespace: updateLogic.getNamespace(),
+            calleeName: updateLogic.name,
+            arguments: [
+                genLogicParam(`${updateLogic.params[0].name}`, valuePrefixExpression),
+            ],
+        }));
+    }
     return NaslNode.Logic({
         name: nameGroup.viewLogicBlurUpdate,
         params: [
@@ -227,21 +253,22 @@ export function genBlurUpdateLogic(entity: Entity, nameGroup: NameGroup) {
         returns: [] as Array<any>,
         body: [
             NaslLogicItem.Start,
-            NaslLogicItem.Assignment({
-                left: genMemberExpression(`current.item.editing`, ['', '', `${nameGroup.structure}.editing`]),
-                right: NaslLogicItem.StringLiteral({
-                    value: '',
-                }),
-            }),
-            NaslLogicItem.CallLogic({
-                calleeNamespace: updateLogic.getNamespace(),
-                calleeName: updateLogic.name,
-                arguments: [
-                    genLogicParam(`${updateLogic.params[0].name}`, `current.item.${lowerEntityName}`),
-                ],
-            }),
+            genCallComponentLogic(nameGroup.viewElementMainView, 'resetEdit', [
+                NaslLogicItem.Argument({
+                    keyword: 'item',
+                    expression: NaslLogicItem.MemberExpression({
+                        object: NaslLogicItem.Identifier({
+                            name: 'current',
+                        }),
+                        property: NaslLogicItem.Identifier({
+                            name: 'item',
+                        }),
+                    }),
+                })]),
+            ...callLogics,
             NaslLogicItem.End,
         ],
         playground: [] as Array<any>,
     });
 }
+

package/src/templator/genQueryComponent.ts

@@ -166,11 +166,11 @@ export function genQueryLogic(allEntities: Array<Entity>, nameGroup: NameGroup,
         params: [
             NaslNode.Param({
                 name: 'page',
-                typeAnnotation: NaslCoreTypeAnnotation.Integer,
+                typeAnnotation: NaslCoreTypeAnnotation.Long,
             }),
             NaslNode.Param({
                 name: 'size',
-                typeAnnotation: NaslCoreTypeAnnotation.Integer,
+                typeAnnotation: NaslCoreTypeAnnotation.Long,
             }),
         ],
         returns: [
@@ -276,10 +276,10 @@ export async function joinEntity(callQueryComponent: CallQueryComponent, entity:
             typeName: entity.name,
         }),
     }), recordStructure, 'properties');
-    
-    if(recordStructure instanceof Structure)
+
+    if (recordStructure instanceof Structure)
         recordStructure.addProperty(structureProperty);
-    else if(recordStructure instanceof TypeAnnotation)
+    else if (recordStructure instanceof TypeAnnotation)
         recordStructure.properties.push(structureProperty);
 
     const newJoinPartLogicItem = QueryJoinExpression.from(queryJoinExpression, callQueryComponent, 'joinParts');

package/src/templator/genSelectBlock.ts

@@ -1,7 +1,7 @@
 import { config } from '../config';
 import * as utils from '../utils';
 import { App, Module, Namespace, Entity, EntityProperty, View, DataSource, ViewElement } from '../concepts';
-import { NameGroup, genUniqueQueryNameGroup, getFirstDisplayedProperty, genQueryLogic, genLogicParam } from '.';
+import { NameGroup, genUniqueQueryNameGroup, getFirstDisplayedProperty, genQueryLogic, genLogicParam, genCallComponentLogic } from '.';
 import {
     NaslUITypeAnnotation, NaslCollectionTypeAnnotation, NaslLogicItem,
     NaslTypeAnnotation, NaslNode,
@@ -116,3 +116,180 @@ export function genSelectBlock(entity: Entity, oldNode: ViewElement) {
 }
 
 export default genSelectBlock;
+
+export function genSelectFooterBlock(entity?: Entity, nameGroup?: NameGroup, view?: View) {
+    return `<template>
+    <template #renderFooter>
+    <u-grid-layout>
+    <u-grid-layout-row :repeat="24" alignment="center" gap="small">
+        <u-grid-layout-column :span="16">
+            <u-input placeholder="请输入" :value.sync="${nameGroup.itemInputVariableName}"></u-input>
+        </u-grid-layout-column>
+        <u-grid-layout-column :span="8">
+            <u-button style=" --custom-start: auto; min-width:auto;width:100%;padding:0;" color="default" icon="add" text="添加" @click="${nameGroup.viewLogicAddItem}"></u-button>
+        </u-grid-layout-column>
+    </u-grid-layout-row>
+</u-grid-layout>
+</template>
+
+<definition>
+{
+    "viewVariables": [
+        {
+            "concept": "Variable",
+            "name": "${nameGroup.itemInputVariableName}",
+            "typeAnnotation": ${JSON.stringify({
+        concept: 'TypeAnnotation',
+        typeKind: 'primitive',
+        typeName: 'String',
+        typeNamespace: 'nasl.core',
+    })}
+        }
+    ],
+    "viewLogics": [
+        ${JSON.stringify(genSelectItemAddLogic(entity, nameGroup, view))}
+    ]
+}
+</definition>
+`;
+}
+
+export function genSelectItemAddLogic(entity: Entity, nameGroup: NameGroup, view?: View) {
+    const callLogics = [];
+    const variableName = 'variable1';
+    if (entity && entity.concept === 'Entity') {
+        const ns = entity.ns;
+        const createLogic = ns?.logics?.find((logic) => logic.name === `create`);
+        const itemExpression = genLogicParam(`item`, `${variableName}.${nameGroup.textField}`);
+        callLogics.push(NaslLogicItem.Assignment({
+            left: NaslLogicItem.Identifier({
+                name: variableName,
+            }),
+            right: {
+                concept: 'CallFunction',
+                name: '',
+                label: '调用逻辑',
+                kind: 'Expression',
+                calleeNamespace: 'nasl.util',
+                calleeName: 'New',
+                arguments: [],
+                typeArguments: [
+                    {
+                        concept: 'TypeAnnotation',
+                        typeKind: 'reference',
+                        typeNamespace: entity.getNamespace(),
+                        typeName: entity.name,
+                    },
+                ],
+            },
+        }));
+        callLogics.push(NaslLogicItem.Assignment({
+            left: itemExpression.expression,
+            right: NaslLogicItem.Identifier({
+                name: view.getVariableUniqueName('itemInputVariable'),
+            }),
+        }));
+        callLogics.push(NaslLogicItem.Assignment({
+            left: NaslLogicItem.Identifier({
+                name: variableName,
+            }),
+            right: NaslLogicItem.CallLogic({
+                calleeNamespace: createLogic.getNamespace(),
+                calleeName: createLogic.name,
+                arguments: [
+                    genLogicParam(`${createLogic.params[0].name}`, variableName),
+                ],
+            }),
+        }));
+        if (nameGroup.prefixField) {
+            callLogics.push(NaslLogicItem.Assignment({
+                left: NaslLogicItem.Identifier({
+                    name: 'variable2',
+                }),
+                right: {
+                    concept: 'NewComposite',
+                    name: '',
+                    typeAnnotation: {
+                        concept: 'TypeAnnotation',
+                        name: '',
+                        typeKind: 'anonymousStructure',
+                        typeArguments: null,
+                        returnType: null,
+                        properties: [
+                            {
+                                concept: 'StructureProperty',
+                                name: 'entity1',
+                            },
+                        ],
+                    },
+                    properties: [
+                        {
+                            concept: 'Identifier',
+                            name: 'entity1',
+
+                        },
+                    ],
+                    rights: [
+                        {
+                            concept: 'SelectMembers',
+
+                            hideMembers: false,
+                            expression: {
+                                concept: 'Identifier',
+                                name: 'variable1',
+
+                            },
+                            members: [],
+                        },
+                    ],
+                    assignmentLines: [
+                        {
+                            concept: 'AssignmentLine',
+                            name: '',
+                            leftIndex: [
+                                0,
+                                0,
+                            ],
+                            rightIndex: [
+                                0,
+                            ],
+                        },
+                    ],
+                    hideProperties: false,
+                    hideDefaults: false,
+                    autoConnection: true,
+                },
+            }));
+        }
+    }
+    return NaslNode.Logic({
+        name: nameGroup.viewLogicAddItem,
+        params: [
+        ],
+        variables: [
+            NaslNode.Variable({
+                name: variableName,
+                typeAnnotation: null,
+            }),
+            NaslNode.Variable({
+                name: 'variable2',
+                typeAnnotation: null,
+            }),
+        ],
+        returns: [] as Array<any>,
+        body: [
+            NaslLogicItem.Start,
+            ...callLogics,
+            genCallComponentLogic(nameGroup.viewElementMainView, 'addItem', [
+                NaslLogicItem.Argument({
+                    keyword: 'item',
+                    expression: NaslLogicItem.Identifier({
+                        name: nameGroup.prefixField ? 'variable2' : variableName,
+                    }),
+                })]),
+            NaslLogicItem.End,
+        ],
+        playground: [] as Array<any>,
+    });
+}
+

package/src/templator/genTableBlock.ts

@@ -63,7 +63,7 @@ export function genTableTemplate(entity: Entity, nameGroup: NameGroup, modifyabl
 
     return `<u-table-view ref="${nameGroup.viewElementMainView}" :data-source="${nameGroup.viewLogicLoad}" data-schema="${nameGroup.structure}"
         value-field="${nameGroup.viewVariableEntity}.id"
-        :pageable="true" :remote-paging="true" :show-sizer="true">
+        :pagination="true" :show-sizer="true">
     <u-table-view-column type="index" width="60"><template #title><u-text text="序号"></u-text></template><template #cell="current"></template></u-table-view-column>
 
     ${properties.map((property) => genTableColumnTemplate(property, currentName) + '\n').join('')}
@@ -258,7 +258,7 @@ export function genTableColumnBlock(property: EntityProperty, oldNode: ViewEleme
 
     return `
 <template>
-    <u-table-view ref="${nameGroup.viewElementMainView}" :data-source="${nameGroup.viewLogicLoad}" :pageable="true" :remote-paging="true" :show-sizer="true" data-schema="${nameGroup.structure}">
+    <u-table-view ref="${nameGroup.viewElementMainView}" :data-source="${nameGroup.viewLogicLoad}" :pagination="true" :show-sizer="true" data-schema="${nameGroup.structure}">
         ${properties.map((property) => genTableColumnTemplate(property) + '\n').join('')}
     </u-table-view>
 </template>

package/src/templator/utils.ts

@@ -189,17 +189,17 @@ function genNaslUIGenericTypeAnnotation(typeName: string) {
 
 export const NaslCoreTypeAnnotation = {
     Boolean: genNaslCoreTypeAnnotation('Boolean'),
-    Integer: genNaslCoreTypeAnnotation('Integer', 'Integer 整数'),
-    Double: genNaslCoreTypeAnnotation('Double'),
+    // Integer: genNaslCoreTypeAnnotation('Integer', 'Integer 整数'),
+    // Double: genNaslCoreTypeAnnotation('Double'),
     Decimal: genNaslCoreTypeAnnotation('Decimal'),
-    Long: genNaslCoreTypeAnnotation('Long', 'Long 长整数'),
-    String: genNaslCoreTypeAnnotation('String', 'String 字符串'),
-    Text: genNaslCoreTypeAnnotation('Text'),
+    Long: genNaslCoreTypeAnnotation('Long', ' Integer 整数'),
+    String: genNaslCoreTypeAnnotation('String', 'String 文本'),
+    // Text: genNaslCoreTypeAnnotation('Text'),
     Binary: genNaslCoreTypeAnnotation('Binary'),
     Date: genNaslCoreTypeAnnotation('Date'),
     Time: genNaslCoreTypeAnnotation('Time'),
     DateTime: genNaslCoreTypeAnnotation('DateTime'),
-    Email: genNaslCoreTypeAnnotation('Email'),
+    // Email: genNaslCoreTypeAnnotation('Email'),
 };
 
 export const NaslUITypeAnnotation = {
@@ -262,7 +262,7 @@ export const NaslTypeAnnotation = {
                 concept: 'TypeAnnotation',
                 typeKind: 'primitive',
                 typeNamespace: 'nasl.core',
-                typeName: 'Integer',
+                typeName: 'Long',
             },
         }],
     }),

package/ts-worker/lib/Messager.js

@@ -138,6 +138,7 @@ class Messager {
      * @override
      */
     onMessageReceived(e) {
+        console.log('onMessageReceived: ', e);
         if (!e.data)
             return;
         this.onDataReceived(e.data);
@@ -147,6 +148,7 @@ class Messager {
      * @override
      */
     onDataReceived(data) {
+        console.log('onDataReceived: ', data);
         if (data.protocol !== this.options.protocol)
             return;
         if (data.type === 'response') {
@@ -158,15 +160,18 @@ class Messager {
         }
         if (data.command) {
             const func = this.options.context[data.command];
+            console.log('func: ', this.options.context, func);
             if (!func)
                 // 函数不存在时不 response
                 return;
 
             let res;
-            if (typeof func === 'function')
+            if (typeof func === 'function') {
                 res = func.call(this.options.context, ...data.args, data.id);
-            else
+            } else {
                 res = func;
+            }
+
             if (data.type === 'request') {
                 return Promise.resolve(res)
                     .then((result) => {

package/ts-worker/src/index.js

@@ -141,6 +141,7 @@ const context = {
     },
     // 在初始化之前添加文件
     addFile(file) {
+        console.log('ts-worker addFile');
         this.system.writeFile(file.file, file.fileContent);
     },
     /**