@lcap/nasl 1.0.2 → 2.12.0

package/src/automate/engine/operators.js

@@ -1,28 +1,76 @@
 import { BaseNode } from '../../common/BaseNode';
 import { getConceptConstructor, getConceptMeta } from '../../decorators/index';
-import { firstUpperCase } from '../../utils/string';
+import { firstUpperCase, unique } from '../../utils/string';
 
 function instanceOfBaseNode(item) {
     return (item instanceof BaseNode);
 }
-const ops = {
+export const ops = {
     _set(item, propertyName, value, callback) {
-        if(instanceOfBaseNode(value)) {
+        if (instanceOfBaseNode(value)) {
             value.parentNode = item;
             value.parentKey = propertyName;
         }
-        if(item[propertyName] !== value) {
+        if (item[propertyName] !== value) {
             item.update({
                 [propertyName]: value,
             });
-            
-            if(instanceOfBaseNode(value) && callback) {
+
+            if (instanceOfBaseNode(value) && callback) {
                 callback(item[propertyName]);
             }
         }
     },
     _push(item, propertyName, value) {
-        if(!item[propertyName]){
+        if (propertyName === 'dataSources' && value.concept === 'DataSource') {
+            // 合并策略
+            const exsitDataSource = item.dataSources.find((d) => d.name === value.name);
+            if (exsitDataSource) {
+                const nameSet = new Set(exsitDataSource.getEntityExistingNames());
+                value.entities.forEach((e) => {
+                    const n = unique(e.name, nameSet, 1, true);
+                    nameSet.add(n);
+                    e.update({
+                        name: n,
+                    });
+                    e.parentNode = exsitDataSource;
+                    exsitDataSource.entities.push(e);
+                    const index = exsitDataSource.entities.length;
+                    e.create({
+                        index,
+                        parentNode: exsitDataSource,
+                        parentKey: 'entities',
+                    });
+                });
+                return;
+            } else {
+                const dataSourceGroup = item.configuration?.getGroup('dataSource');
+                dataSourceGroup.addConfigProperty({
+                    name: value.name,
+                    description: '',
+                    values: [
+                        { env: 'dev', value: '', concept: 'ConfigPropertyValue' },
+                        { env: 'online', value: '', concept: 'ConfigPropertyValue' },
+                    ],
+                });
+            }
+        }
+        if (item.concept === 'App' && propertyName === 'entities' && value.concept === 'Entity') {
+            // 兼容 2.11之前无 datasource 模板
+            const defaultDS = item.dataSources.find((d) => d.name === 'defaultDS');
+            // defaultDS.addEntity(value);
+            value.parentNode = defaultDS;
+            value.parentKey = 'entities';
+            defaultDS.entities.push(value);
+            const index = defaultDS.entities.length;
+            value.create({
+                index,
+                parentNode: defaultDS,
+                parentKey: 'entities',
+            });
+            return;
+        }
+        if (!item[propertyName]) {
             item[propertyName] = [];
         }
         value.parentNode = item;
@@ -39,10 +87,10 @@ const ops = {
         const _ctor = getConceptConstructor(concept);
         const item = new _ctor();
         const { propertyMap } = getConceptMeta(concept);
-        for(const p of propertyMap) {
+        for (const p of propertyMap) {
             const [propertyName] = p;
             const t = item[propertyName];
-            if(Array.isArray(t)) {
+            if (Array.isArray(t)) {
                 ops._set(item, propertyName, []);
             }
         }
@@ -50,14 +98,63 @@ const ops = {
     },
     _addModule(app, name, belongs, data) {
         const ms = app[belongs];
-        const exist = ms.find(m => m.name === name);
-        if(!exist) {
-            app["addModuleIn" + firstUpperCase(belongs)](data);
+        const exist = ms.find((m) => m.name === name);
+        if (!exist) {
+            app['addModuleIn' + firstUpperCase(belongs)](data);
         }
     },
-    _bindRoles(){ 
-        return Array.prototype.map.call(arguments, r => r.name); 
-    }
-}
+    _bindRoles() {
+        return Array.prototype.map.call(arguments, (r) => r.name);
+    },
+};
+//组件模板的导入有些不同
+let handleDatas = [];
+let dynamicNames = {};
+export const ComponentOps = {
+    ...ops,
+    _set(item, propertyName, value, callback) {
+        if (instanceOfBaseNode(value)) {
+            value.parentNode = item;
+            value.parentKey = propertyName;
+        }
+        if (item[propertyName] !== value) {
+            //指view的全局逻辑或全局变量名称修改
+            if (propertyName === 'name' && dynamicNames[item.name]) {
+                dynamicNames[item.name] = value;
+            }
+            item.update({
+                [propertyName]: value,
+            });
+            //有函数或者组件引用了view的全局逻辑或全局变量名称
+            if ((propertyName === 'name' || propertyName === 'calleeName') && dynamicNames[value]
+                && item.parentKey !== 'property' && item.concept !== 'StructureProperty') {
+                handleDatas.push({
+                    item,
+                    propertyName,
+                });
+            }
+
+            if (instanceOfBaseNode(value) && callback) {
+                callback(item[propertyName]);
+            }
+        }
+    },
+    _rename() {
+        handleDatas.forEach(({ item, propertyName }) => {
+            const changeName = item[propertyName];
+            if (dynamicNames[changeName] && changeName !== dynamicNames[changeName])
+                item.update({
+                    [propertyName]: dynamicNames[changeName],
+                });
+        });
+        handleDatas = [];
+        dynamicNames = {};
+    },
+    _startNames(...initialNames) {
+        initialNames.forEach((name) => {
+            dynamicNames[name] = name;
+        });
+    },
+};
 
-export default ops;
+export default ops;

package/src/automate/engine/uniqueName.js

@@ -1,9 +1,12 @@
 import { unique } from '../../utils/string';
-class uniqueName {
+export class uniqueName {
     NamesWeakMap = new Map();
     initAppUniqueNames(app) {
         const NamesWeakMap = this.NamesWeakMap;
-        NamesWeakMap.set('Entity', new Set(app.getEntityExistingNames()));
+        const defaultDS = app.dataSources.find(d => d.name === 'defaultDS');
+        NamesWeakMap.set('defaultDS', new Set(defaultDS.getEntityExistingNames()));
+
+        // NamesWeakMap.set('DataSource', new Set(app.getDataSourceExistingNames()));
         NamesWeakMap.set('Structure', new Set(app.getStructureExistingNames()));
         NamesWeakMap.set('Enum', new Set(app.getEnumExistingNames()));
         NamesWeakMap.set('Logic', new Set(app.getLogicExistingNames()));
@@ -15,22 +18,87 @@ class uniqueName {
     getGenUniqNameFunctionName(item, concept) {
         const p = item.parentNode;
         const NamesWeakMap = this.NamesWeakMap;
-        if(!p) {
+        if (!p) {
+            // 添加至顶层 App 的对象
+            if(concept === 'DataSource') {
+                return item.name;
+            }
+            if(concept === 'Entity') {
+                // Entity 是为了兼容 2.11 及之前的模板
+                concept = 'defaultDS';
+            }
+            const nameSet = NamesWeakMap.get(concept);
+            const n = unique(item.name, nameSet, 1, true);
+            nameSet.add(n);
+            return n;
+        }
+        const f1 = p['get' + concept + 'UniqueName'];
+        const f2 = p['get' + concept + 'ExistingNames'];
+        if (f1 && f2) {
+            const names = f2.call(p);
+            const t = names.filter((n) => n === item.name);
+            if (t.length > 1) {
+                return f1.call(p, item.name);
+            }
+        }
+        return item.name;
+    }
+}
+
+export class componentUniqueName {
+    NamesWeakMap = new Map();
+    view = null;
+    initAppUniqueNames(app, view) {
+        const NamesWeakMap = this.NamesWeakMap;
+        this.view = view;
+        NamesWeakMap.set('DataSource', new Set(app.getDataSourceExistingNames()));
+        NamesWeakMap.set('Structure', new Set(app.getStructureExistingNames()));
+        NamesWeakMap.set('Enum', new Set(app.getEnumExistingNames()));
+        NamesWeakMap.set('Logic', new Set(app.getLogicExistingNames()));
+        NamesWeakMap.set('Interface', new Set(app.getInterfaceExistingNames()));
+        NamesWeakMap.set('View', new Set(app.getViewExistingNames()));
+        NamesWeakMap.set('Process', new Set(app.getProcessExistingNames()));
+        NamesWeakMap.set('Role', new Set(app.getRoleExistingNames()));
+        // .... 这里要补一下 view 下面 variable, logics的名字
+        NamesWeakMap.set('Variable', new Set(view.getVarExistingNames()));
+        NamesWeakMap.set('Logic', new Set(view.getLogicExistingNames()));
+    }
+    getGenUniqNameFunctionName(item, concept) {
+        const p = concept === 'ViewElement' ? this.view : item.parentNode;
+        const NamesWeakMap = this.NamesWeakMap;
+        if (!p) {
             const nameSet = NamesWeakMap.get(concept);
             const n = unique(item.name, nameSet, 1, true);
             nameSet.add(n);
             return n;
         }
-        const f1 = p["get" + concept + "UniqueName"];
-        const f2 = p["get" + concept + "ExistingNames"]
-        if(f1 && f2) {
+        const f1 = p['get' + concept + 'UniqueName'];
+        const f2 = p['get' + concept + 'ExistingNames'];
+        if (f1 && f2) {
             const names = f2.call(p);
-            const t = names.filter(n => n === item.name);
-            if(t.length > 1) {     
+            const t = names.filter((n) => n === item.name);
+            if (t.length > 1) {
+                return f1.call(p, item.name);
+            }
+            if (concept === 'ViewElement' && t.length)
+                return f1.call(p, item.name);
+        }
+        // 逻辑里面的变量也需要再判断
+        if (concept === 'Variable' && f1) {
+            const variables = p.getVarExistingNames();
+            if (Array.isArray(this.view.params)) {
+                variables.push(...this.view.params.map((item) => item.name));
+            }
+            if (Array.isArray(this.view.variables)) {
+                variables.push(...this.view.variables.map((item) => item.name));
+            }
+            const t = variables.filter((n) => n === item.name);
+            if (t.length > 1) {
                 return f1.call(p, item.name);
             }
         }
         return item.name;
     }
 }
-export default uniqueName;
+
+export default uniqueName;

package/src/automate/engine/utils.js

@@ -2,7 +2,7 @@
 //     BaseNode,
 //     Module
 // } from '../../concepts';
-import { BaseNode, uiStructures, collectionStructures, interfaceStructures } from '../../concepts';
+import { BaseNode, uiStructures, collectionStructures, interfaceStructures, processStructures } from '../../concepts';
 import { getConceptMeta } from '../../decorators/index';
 /*
     根据 namespace 字符串来获取 node
@@ -74,12 +74,15 @@ export function getNaslNodeByNodeCallee(namespace, typeName) {
         return collectionStructures.find((item) => item.name === typeName);
     } else if (namespace === 'nasl.interface') {
         return interfaceStructures.find((item) => item.name === typeName);
+    } else if (namespace === 'nasl.process') {
+        return processStructures.find((item) => item.name === typeName);
     }
 }
 export const TRACK_TYPE = {
     PLAIN: 'plain',
     PROPERTY: 'property',
     ARRAY: 'array',
+    ARRAY_NO_FURTHER: 'array_no_further',
     CALLEE: 'callee',
     CALLEE_TEMPLATE: 'callee_template',
     MODULE: 'module',
@@ -118,6 +121,10 @@ function getRelatedProperyName(nspropertyname) {
     return '';
 }
 
+const TRACKING_ONLY_ONE_LAYER = [
+    'DataSource'
+]
+
 const BACKTRACKING_IGNORE_NAMESPACE = [
     'nasl.core',
     '',
@@ -154,7 +161,6 @@ const ROLE_PROPERTY = 'bindRoles';
 
 export function tracking(node, startNode, callback) {
     const { propertyMap } = getConceptMeta(node.concept);
-    // console.log(propertyMap)
     for (const p of propertyMap) {
         // console.log(p)
         const [propertyName, _data] = p;
@@ -166,13 +172,20 @@ export function tracking(node, startNode, callback) {
             }
             continue;
         }
+        const isOnlyOneLayerTracking = TRACKING_ONLY_ONE_LAYER.includes(node.concept);
         const property = node[propertyName];
         if (Array.isArray(property)) {
             if (property.length > 0) {
                 if (property[0] instanceof BaseNode) {
-                    property.forEach((p) => {
-                        callback(TRACK_TYPE.ARRAY, propertyName, p);
-                    });
+                    if (!isOnlyOneLayerTracking) {
+                        property.forEach((p) => {
+                            callback(TRACK_TYPE.ARRAY, propertyName, p);
+                        }); 
+                    } else {
+                        property.forEach((p) => {
+                            callback(TRACK_TYPE.ARRAY_NO_FURTHER, propertyName, p);
+                        }); 
+                    }
                 } else {
                     if (ROLE_PROPERTY === propertyName) {
                         const rootNode = node.rootNode;
@@ -208,7 +221,7 @@ export function tracking(node, startNode, callback) {
 
                     const rootNode = node.rootNode;
                     const ns = node[propertyName];
-                    if (!ns) {
+                    if (!ns || !node[relatedPropertyName]) {
                         callback(TRACK_TYPE.PLAIN, propertyName, property);
                         callback(TRACK_TYPE.PLAIN, relatedPropertyName, node[relatedPropertyName]);
                         break;
@@ -218,71 +231,84 @@ export function tracking(node, startNode, callback) {
                         callback(TRACK_TYPE.PLAIN, propertyName, property);
                         callback(TRACK_TYPE.PLAIN, relatedPropertyName, node[relatedPropertyName]);
                     } else {
-                        const r1 = /app\.(?:entities|processes)\.([^.]+)\.logics/.exec(ns);
-                        const r2 = /app\.processes\.([^.]+)\.elements\.([^.]+)\.logics/.exec(ns);
                         const calleeN = node[relatedPropertyName];
-                        if (r2) {
-                            const nodeName = r2[1];
-                            const subNodename = r2[2];
-                            if (subNodename) {
-                                // 目前只有 userTask
-                                const process = rootNode.processes.find((p) => p.name === nodeName);
-                                if (process) {
-                                    const usertask = process.elements.find((e) => e.name === subNodename);
-                                    if (usertask) {
-                                        callback(TRACK_TYPE.CALLEE_TEMPLATE, propertyName, node[propertyName], {
-                                            rootNode: process,
-                                            metaNodes: [process, usertask],
-                                            nstemplate: `function(meta, meta2){ return "app.processes" + meta.name + ".elements." + meta2.name + ".logics"; }`,
-                                            nametemplate: `function(meta, meta2){ return "complete"; }`,
-                                            relatedPropertyName,
-                                            AppPropertyName: 'processes',
-                                        });
+
+                        const r1 = /app\.processes\.([^.]+)\.logics/.exec(ns);
+                        const r2 = /app\.processes\.([^.]+)\.elements\.([^.]+)\.logics/.exec(ns);
+                        if(r1 || r2) {
+                            // Process 处理
+                            if (r2) {
+                                const nodeName = r2[1];
+                                const subNodename = r2[2];
+                                if (subNodename) {
+                                    // 目前只有 userTask
+                                    const process = rootNode.processes.find((p) => p.name === nodeName);
+                                    if (process) {
+                                        const usertask = process.elements.find((e) => e.name === subNodename);
+                                        if (usertask) {
+                                            callback(TRACK_TYPE.CALLEE_TEMPLATE, propertyName, node[propertyName], {
+                                                rootNode: process,
+                                                metaNodes: [process, usertask],
+                                                nstemplate: `function(meta, meta2){ return "app.processes" + meta.name + ".elements." + meta2.name + ".logics"; }`,
+                                                nametemplate: `function(meta, meta2){ return "complete"; }`,
+                                                relatedPropertyName,
+                                                AppPropertyName: 'processes',
+                                            });
+                                            break;
+                                        }
                                     }
                                 }
+                            } else if (r1){
+                                const nodeName = r1[1];
+                                const process = rootNode.processes.find((p) => p.name === nodeName);
+                                if (/launch/.test(calleeN) && process) {
+                                    // const prefix = /(launch|complete).+/.exec(calleeN)[1];
+                                    callback(TRACK_TYPE.CALLEE_TEMPLATE, propertyName, node[propertyName], {
+                                        rootNode: process,
+                                        metaNodes: [process],
+                                        nstemplate: `function(meta){ return "app.processes" + meta.name + ".logics"; }`,
+                                        nametemplate: `function(){ return "${calleeN}"; }`,
+                                        relatedPropertyName,
+                                        AppPropertyName: 'processes',
+                                    });
+                                    break;
+                                }
                             }
-                        } else if (r1) {
-                            const nodeName = r1[1];
-                            const process = rootNode.processes.find((p) => p.name === nodeName);
-                            if (/launch/.test(calleeN) && process) {
-                                // const prefix = /(launch|complete).+/.exec(calleeN)[1];
-                                callback(TRACK_TYPE.CALLEE_TEMPLATE, propertyName, node[propertyName], {
-                                    rootNode: process,
-                                    metaNodes: [process],
-                                    nstemplate: `function(meta){ return "app.processes" + meta.name + ".logics"; }`,
-                                    nametemplate: `function(){ return "${calleeN}"; }`,
-                                    relatedPropertyName,
-                                    AppPropertyName: 'processes',
-                                });
-                                break;
-                            }
+                        }
 
-                            const entity = rootNode.entities.find((e) => e.name === nodeName);
-                            if (/get|create|update|delete|batchCreate|batchUpdate|batchDelete|import/.test(calleeN) && entity) {
+                        const r3 = /app\.dataSources\.([^.]+)\.entities\.([^.]+)\.logics/.exec(ns);
+                        if(r3) {
+                            const datasourceName = r3[1];
+                            const entityName = r3[2];
+                            
+                            if (/get|create|update|delete|batchCreate|batchUpdate|batchDelete|import/.test(calleeN)) {
                                 // const prefix = /(get|create|update|delete|batchCreate|batchUpdate|batchDelete|import)/.exec(calleeN)[1];
-                                callback(TRACK_TYPE.CALLEE_TEMPLATE, propertyName, node[propertyName], {
-                                    rootNode: entity,
-                                    metaNodes: [entity],
-                                    nstemplate: `function(meta){ return "app.entities." + meta.name + ".logics"; }`,
-                                    nametemplate: `function(){ return "${calleeN}"; }`,
-                                    relatedPropertyName,
-                                    AppPropertyName: 'entities',
-                                });
-                                break;
-                            }
-                        } else {
-                            const nsPath = `${ns}.${calleeN}`;
-                            const calleeNode = getNodeByNodeCallee(rootNode, nsPath);
-                            if (calleeNode) {
-                                backtracking({
-                                    node,
-                                    startNode,
-                                    calleeNode,
-                                    propertyName,
-                                    relatedPropertyName,
-                                }, callback);
+                                const datasource = rootNode.dataSources.find(d => d.name === datasourceName);
+                                if (datasource) {
+                                    const entity = datasource.entities.find((e) => e.name === entityName);
+                                    callback(TRACK_TYPE.CALLEE_TEMPLATE, propertyName, node[propertyName], {
+                                        rootNode: datasource,
+                                        metaNodes: [datasource, entity],
+                                        nstemplate: `function(meta, meta2){ return "app.dataSources." + meta.name + ".entities." + meta2.name + ".logics"; }`,
+                                        nametemplate: `function(){ return "${calleeN}"; }`,
+                                        relatedPropertyName,
+                                        AppPropertyName: 'dataSources',
+                                    });
+                                    break;
+                                }
                             }
                         }
+                        const nsPath = `${ns}.${calleeN}`;
+                        const calleeNode = getNodeByNodeCallee(rootNode, nsPath);
+                        if (calleeNode) {
+                            backtracking({
+                                node,
+                                startNode,
+                                calleeNode,
+                                propertyName,
+                                relatedPropertyName,
+                            }, callback);
+                        }
                     }
                     break;
 
@@ -296,10 +322,11 @@ export function tracking(node, startNode, callback) {
                     callback(TRACK_TYPE.PROPERTY_TEMPLATE, propertyName, property, {
                         getRelatedVar: () => {
                             const queryCom = node.getAncestor('CallQueryComponent');
-                            if (queryCom) {
-                                const entities = node.app.entities;
-                                // entityAsName === entity.name
-                                return entities.find((e) => e.name === property);
+                            const entityNamespace = queryCom?.from?.entityNamespace;
+                            if (queryCom && entityNamespace && property) {
+                                const rootNode = queryCom.rootNode;
+                                const entity = getNodeByNodeCallee(rootNode, `${entityNamespace}.${property}`);
+                                return entity;
                             }
                             return null;
                         },
@@ -361,7 +388,7 @@ export function backtracking({ node, startNode, calleeNode, propertyName, relate
     while (t) {
         const pnode = t.parentNode;
         if (pnode === approot) {
-            AppPropertyName = getAppPropertyName(calleeNode);
+            AppPropertyName = getAppPropertyName(t);
         }
         if (pnode !== approot && pnode !== startNode) {
             t = pnode;