@lcap/nasl 1.0.1 → 2.12.0-beta.1

package/src/automate/engine/utils.js

@@ -2,7 +2,7 @@
 //     BaseNode,
 //     Module
 // } from '../../concepts';
-import { BaseNode, uiStructures, collectionStructures } from '../../concepts';
+import { BaseNode, uiStructures, collectionStructures, interfaceStructures, processStructures } from '../../concepts';
 import { getConceptMeta } from '../../decorators/index';
 /*
     根据 namespace 字符串来获取 node
@@ -72,12 +72,17 @@ export function getNaslNodeByNodeCallee(namespace, typeName) {
         return uiStructures.find((item) => item.name === typeName);
     } else if (namespace === 'nasl.collection') {
         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',
@@ -101,6 +106,7 @@ const BACKTACKING_PROPERTY = {
     ENTITY_NAMESPACE: 'entityName',
     RELATION_NAMESPACE: 'relationEntity',
 };
+const BACKTRACKING_MODULE_COMPONENT = 'tag'
 function getRelatedProperyName(nspropertyname) {
     switch (nspropertyname) {
         case BACKTACKING_PROPERTY_NS.TYPE_NAMESPACE:
@@ -115,6 +121,10 @@ function getRelatedProperyName(nspropertyname) {
     return '';
 }
 
+const TRACKING_ONLY_ONE_LAYER = [
+    'DataSource'
+]
+
 const BACKTRACKING_IGNORE_NAMESPACE = [
     'nasl.core',
     '',
@@ -151,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;
@@ -163,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;
@@ -205,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;
@@ -215,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;
 
@@ -293,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;
                         },
@@ -304,7 +334,18 @@ export function tracking(node, startNode, callback) {
                     });
 
                     break;
-
+                case BACKTRACKING_MODULE_COMPONENT:
+                    // 条件 break 一定要放到最后
+                    if(node.concept === 'ViewElement'){
+                        const componentDependencies = node.app.componentDependencies;
+                        const tag = node[propertyName];
+                        const dep = componentDependencies.find(c => c.name === tag);
+                        if(dep) {
+                            callback(TRACK_TYPE.PLAIN, propertyName, tag);
+                            callback(TRACK_TYPE.MODULE, undefined, dep);
+                            break;
+                        }
+                    }
                 default:
                     if (property !== undefined) {
                         if (objectRef && property !== null) {
@@ -347,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;