@lcap/nasl 0.3.9 → 0.3.10-beta

package/src/types/logic/Logic.ts

@@ -1,10 +1,44 @@
 import { immutable, excludedInJSON, circular, action } from '../decorators';
 import { config, history, utils, Vertex, LEVEL_ENUM, Interface, Param, Return, Variable, vertexsMap, typeCheck, ProcessComponent, ProcessInterface, Process, ActionOptions } from '..';
 import { logicService, paramService } from '../../service/logic';
+import { sourceMapService } from '../../service/debugger/debugger';
 import View from '../page/View';
 import { ExpressionNode, LogicItem, LogicNode } from './LogicItem';
 import { convert2SchemaType } from '../data/dataTypeUtils';
 import { isPlainObject, throttle } from 'lodash';
+interface sourceMapObj {
+    node: LogicItem,
+    classIdentify: string,
+    from: number,
+    lineFrom: number,
+    end: number
+    vertexId: string,
+    logicId: string,
+}
+import { refreshInterfaces, refreshView, refreshPages } from '../cache';
+import { BusinessCode } from '../enum';
+
+export function catchFn(logic: Logic) {
+    return async (err: any) => {
+        const code = err?.code;
+        if([BusinessCode.ElementExist, BusinessCode.ElementNotExist].includes(code)) {
+            if(logic.interface) {
+                await refreshInterfaces();
+            } else if(logic.view) {
+                await refreshView(logic.view);
+            }
+        } else if(code === BusinessCode.ParentElementNotExist) {  // 父节点不存在。视图添加逻辑，发现视图不存在
+            if(logic.view) {
+                await refreshPages();
+            }
+        } else
+            config.defaultApp?.emit('saved', err);
+
+        config.defaultApp?.history.load();
+
+        throw err;
+    }
+}
 
 /**
  * 逻辑类
@@ -115,6 +149,10 @@ export class Logic extends Vertex {
      */
     @excludedInJSON()
     public contentPromise: Promise<any> = undefined;
+    @excludedInJSON()
+    public sourceMap: {
+        [id: string]: Partial<sourceMapObj>
+    } = {};
     /**
      * 树组件的子节点字段
      */
@@ -123,6 +161,19 @@ export class Logic extends Vertex {
     /**
      * @param source 需要合并的部分参数
      */
+    /**
+     * 逻辑配置的cron表达式
+     */
+    @immutable()
+    public cron: string = undefined;
+    /**
+     * 定时类型，当前只能是cronTrigger
+     */
+    @immutable()
+    public triggerType: string = undefined;
+    /**
+     * 定时任务
+     */
     constructor(source?: Partial<Logic>) {
         super();
         source && this.assign(source);
@@ -152,7 +203,7 @@ export class Logic extends Vertex {
                 operationDesc: actionOptions?.actionDesc || `添加逻辑"${this.name}"`,
             },
             body,
-        });
+        }).catch(catchFn(this));
         this.deepPick(result, ['id']);
         this.pick(result, ['playgroundId']);
         this.assign({ body: result.body.map((logicNode) => LogicNode.from(logicNode, this, null)) });
@@ -180,9 +231,8 @@ export class Logic extends Vertex {
      */
     @action('删除逻辑')
     async delete(none?: void, actionOptions?: ActionOptions) {
-        config.defaultApp?.emit('saving');
-
         if (this.id) {
+            config.defaultApp?.emit('saving');
             const body = this.toPlainJSON();
             if (this.view) {
                 body.moduleId = this.view.id;
@@ -191,19 +241,15 @@ export class Logic extends Vertex {
                 body.moduleId = this.interface.service.id;
                 body.moduleType = 'microService';
             }
-            try {
-                await logicService.delete({
-                    headers: {
-                        appId: config.defaultApp?.id,
-                        operationAction: actionOptions?.actionName || 'Logic.delete',
-                        operationDesc: actionOptions?.actionDesc || `删除逻辑"${this.name}"`,
-                    },
-                    body,
-                });
-            } catch (err) {
-                await config.defaultApp?.history.load();
-                throw err;
-            }
+
+            await logicService.delete({
+                headers: {
+                    appId: config.defaultApp?.id,
+                    operationAction: actionOptions?.actionName || 'Logic.delete',
+                    operationDesc: actionOptions?.actionDesc || `删除逻辑"${this.name}"`,
+                },
+                body,
+            }).catch(catchFn(this));
 
             if (this.view) {
                 const { logics } = this.view.$def;
@@ -249,7 +295,7 @@ export class Logic extends Vertex {
                 operationDesc: actionOptions?.actionDesc || `修改逻辑"${this.name}"`,
             },
             body,
-        });
+        }).catch(catchFn(this));
 
         await then?.();
         await config.defaultApp?.history.load();
@@ -305,17 +351,16 @@ export class Logic extends Vertex {
             return this.contentPromise;
 
         return this.contentPromise = (async () => {
-            try {
-                const result = await logicService.loadDetail({
-                    query: {
-                        moduleId: this.moduleId,
-                        moduleType: this.moduleType,
-                        id: this.id,
-                    },
-                });
-                const newLogic = Logic.from(result, this.interface || this.view || this.processComponent, this);
-                this.assign(newLogic);
-            } catch (err) {}
+            const result = await logicService.loadDetail({
+                query: {
+                    moduleId: this.moduleId,
+                    moduleType: this.moduleType,
+                    id: this.id,
+                },
+                config: { noErrorTip: true },
+            }).catch(catchFn(this));
+            const newLogic = Logic.from(result, this.interface || this.view || this.processComponent, this);
+            this.assign(newLogic);
             return this;
         })().finally(() => this.contentPromise = undefined);
     }
@@ -387,6 +432,16 @@ export class Logic extends Vertex {
 
         return result as LogicItem;
     }
+    // async loadSourceMap() {
+    //     if (!logic.view) {
+    //         const result = await sourceMapService.getSourceMap({
+    //             query: {
+    //                 scopeId: this.id,
+    //             },
+    //         });
+    //         this.sourceMap = result;
+    //     }
+    // }
     /**
      * 从后端 JSON 生成规范的 Logic 对象
      */
@@ -437,6 +492,56 @@ export class Logic extends Vertex {
 
         return logic;
     }
+    /**
+     * 更新定时任务
+     */
+    @action('更新定时任务')
+    async updateTimer(cron: string) {
+        this.assign({ cron });
+        this.triggerType = 'cronTrigger';
+        await this.update(undefined, {
+            actionDesc: `设置定时任务"为"${cron}"`,
+        });
+
+        if (this.view) {
+            this.view.page.service.emit('pageTreeChange');
+            this.emit('change');
+        }
+        return this;
+    }
+    /**
+     * 验证表达式正确与否
+     */
+    async validateTimer() {
+        const body = this.toPlainJSON();
+        const result = await logicService.validateTimer({
+            body,
+            config: {
+                noErrorTip: true,
+            },
+        });
+        return result;
+    }
+    /**
+     * 输出最近十次运行结果
+     */
+    async testTimer() {
+        const body = this.toPlainJSON();
+        const result = await logicService.testTimer({
+            body,
+        });
+        return result;
+    }
+    /**
+     * 更新接口缓存
+     */
+    async updateCronCache() {
+        const body = this.toPlainJSON();
+        const result = await logicService.updateCronCache({
+            body,
+        });
+        return result;
+    }
 }
 
 export default Logic;

package/src/types/logic/LogicItem.ts

@@ -1,11 +1,12 @@
-import { immutable, excludedInJSON, circular, action } from '../decorators';
-import { config, history, typeCheck, utils, Vertex, Service, LEVEL_ENUM, Interface, Param, Return, Variable, Logic, View, Schema, ActionOptions, ACTION_MODE } from '..';
+import { immutable, excludedInJSON, action } from '../decorators';
+import { config, typeCheck, utils, Vertex, LEVEL_ENUM, Logic, Schema, ActionOptions, ACTION_MODE, BreakPoint } from '..';
 import { logicService } from '../../service/logic';
-import { assert } from 'console';
 import { traverse } from '../utils';
 import { vertexsMap } from '../cacheData';
 import { getSchemaOfExpressionNode } from './tools';
 import Structure from '../data/Structure';
+import { refreshLogic } from '../cache';
+import { BusinessCode } from '../enum';
 
 export enum LOGIC_TYPE {
     // LogicNode
@@ -56,6 +57,18 @@ export enum LOGIC_TYPE {
     QueryAggregateExpression = 'QueryAggregateExpression',
 }
 
+const atomicList = [
+    LOGIC_TYPE.Identifier,
+    LOGIC_TYPE.NumericLiteral,
+    LOGIC_TYPE.BooleanLiteral,
+    LOGIC_TYPE.StringLiteral,
+    LOGIC_TYPE.NullLiteral,
+    LOGIC_TYPE.UnaryExpression,
+    LOGIC_TYPE.MemberExpression,
+    LOGIC_TYPE.Unparsed,
+    LOGIC_TYPE.BuiltInFunction,
+];
+
 export function evaluate(node: LogicNode | ExpressionNode, finalCode = true): string {
     if (!node)
         return '';
@@ -76,11 +89,11 @@ export function evaluate(node: LogicNode | ExpressionNode, finalCode = true): st
 
     if (node.type === 'BinaryExpression') {
         let left: string = evaluate(<LogicNode>node.left, finalCode);
-        if (!finalCode && node.left?.type === LOGIC_TYPE.MemberExpression)
+        if (!atomicList.includes(node.left?.type as LOGIC_TYPE) || (!finalCode && node.left?.type === LOGIC_TYPE.MemberExpression))
             left = `(${left})`;
 
         let right: string = evaluate(<LogicNode>node.right, finalCode);
-        if (!finalCode && node.right?.type === LOGIC_TYPE.MemberExpression)
+        if (!atomicList.includes(node.right?.type as LOGIC_TYPE) || (!finalCode && node.left?.type === LOGIC_TYPE.MemberExpression))
             right = `(${right})`;
 
         return `${left} ${node.operator} ${right}`;
@@ -88,13 +101,11 @@ export function evaluate(node: LogicNode | ExpressionNode, finalCode = true): st
 
     if (node.type === 'LogicalExpression') {
         let left: string = evaluate(<LogicNode>node.left, finalCode);
-        if (!finalCode && node.left?.type === LOGIC_TYPE.MemberExpression)
+        if (!atomicList.includes(node.left?.type as LOGIC_TYPE) || (!finalCode && node.left?.type === LOGIC_TYPE.MemberExpression))
             left = `(${left})`;
-
         let right: string = evaluate(<LogicNode>node.right, finalCode);
-        if (!finalCode && node.right?.type === LOGIC_TYPE.MemberExpression)
+        if (!atomicList.includes(node.right?.type as LOGIC_TYPE) || (!finalCode && node.left?.type === LOGIC_TYPE.MemberExpression))
             right = `(${right})`;
-
         return `${left} ${node.operator} ${right}`;
     }
 
@@ -209,6 +220,18 @@ export const logicItemArrayKeyOfLogicItem: string[] = ['body', 'consequent', 'al
     'groupBy', 'orderBy', 'selectElementList', 'joinPartList', 'onExpressionList', 'where', 'having',
 ];
 
+export function catchFn(logic: Logic) {
+    return async (err: any) => {
+        if (err.code !== BusinessCode.HasReferenced) // 节点被引用，不用刷新数据
+            await refreshLogic(logic);
+        else
+            config.defaultApp?.emit('saved', err);
+
+        config.defaultApp?.history.load();
+        throw err;
+    };
+}
+
 /**
  * 逻辑项类
  */
@@ -287,6 +310,14 @@ export class LogicItem extends Vertex {
     public readonly pageParamKey: any = undefined;
     @immutable()
     public readonly pageParamKeyValue: any = undefined;
+
+    /**
+        断点集合
+     */
+    @immutable()
+    @excludedInJSON()
+    public breakPoints: Array<BreakPoint> = [];
+    public temporaryBreakPoint: BreakPoint = null;
     /**
      * CallQueryComponent 对应的 structure 的 id
      */
@@ -432,7 +463,7 @@ export class LogicItem extends Vertex {
                     operationIgnore: actionOptions?.actionIgnore,
                 },
                 body,
-            });
+            }).catch(catchFn(this.logic));
             this.deepPick(result, ['id', 'parentId', 'parentAttr', 'joinPartRef', 'structureRef']);
         }
 
@@ -548,7 +579,7 @@ export class LogicItem extends Vertex {
                         offsetY,
                     },
                 },
-            });
+            }).catch(catchFn(this.logic));
         }
 
         if (!(this.parentId === parentId && this.parentId === this.logic.playgroundId && this.parentAttr === parentAttr)) {
@@ -612,6 +643,8 @@ export class LogicItem extends Vertex {
      * @param targetId
      */
     static async paste(logicItems: LogicItem[] | LogicItem, targetType: 'logic' | 'html' | 'processComponent', targetId: string) {
+        config.defaultApp?.emit('saving');
+
         if (!Array.isArray(logicItems))
             logicItems = [logicItems];
 
@@ -630,7 +663,7 @@ export class LogicItem extends Vertex {
                 operationAction: 'LogicItem.paste',
                 operationDesc: `粘贴逻辑项"${logicItems[0].label || logicItems[0].type}"`,
             },
-        });
+        }).catch(catchFn(vertexsMap.get(targetId) as Logic));
 
         LogicItem.redoPaste(res);
     }
@@ -773,26 +806,23 @@ export class LogicItem extends Vertex {
 
         if (actionOptions?.actionMode !== ACTION_MODE.undoRedo) {
             if (this.id) {
+                await this.removeAllBreakPointsOfDescendants();
+
                 const body = this.toPlainJSON();
                 /// @TODO: 不知道哪里来的 index
                 delete body.index;
                 ///
 
-                try {
-                    await logicService.removeItem({
-                        headers: {
-                            appId: config.defaultApp?.id,
-                            serviceId: this.logic?.interface?.serviceId,
-                            operationAction: 'LogicItem.delete',
-                            operationDesc: `删除逻辑项"${this.label || this.type}"`,
-
-                        },
-                        body,
-                    });
-                } catch (err) {
-                    await config.defaultApp?.history.load();
-                    throw err;
-                }
+                await logicService.removeItem({
+                    headers: {
+                        appId: config.defaultApp?.id,
+                        serviceId: this.logic?.interface?.serviceId,
+                        operationAction: 'LogicItem.delete',
+                        operationDesc: `删除逻辑项"${this.label || this.type}"`,
+
+                    },
+                    body,
+                }).catch(catchFn(this.logic));
             }
         }
 
@@ -883,7 +913,7 @@ export class LogicItem extends Vertex {
                     operationIgnore: actionOptions?.actionIgnore,
                 },
                 body,
-            });
+            }).catch(catchFn(this.logic));
             // this.deepPick(result, ['id', 'parentId', 'parentAttr']);
 
             // 合并params里的id
@@ -1119,6 +1149,158 @@ export class LogicItem extends Vertex {
                 parentAttr: activeImage.parentAttr,
             };
     }
+
+    addBreakPointInstance(bp: BreakPoint) {
+        const finded = this.breakPoints.find((item) => item.offset === bp.offset);
+        if (!finded) {
+            this.breakPoints.push(bp);
+        }
+    }
+
+    async addBreakPoint(appId: string, offsetLine = 0) {
+        let bp = this.breakPoints.find((bp) => bp.offset === offsetLine);
+        if (bp) {
+            return bp;
+        }
+        bp = new BreakPoint();
+        await bp.create({
+            appId,
+            logicItem: this,
+            offset: offsetLine,
+        });
+        this.breakPoints.push(bp);
+        const app = config.defaultApp;
+        app.debuggerClient.breakPoints.push(bp);
+        return bp;
+    }
+
+    getBreakPointByLineNumber(lineNumber: number) {
+        return this.breakPoints.find((bp) => bp.lineNumberStart === lineNumber);
+    }
+
+    addTemperaryBreakPoint(offsetLine = 0) {
+        const bp = new BreakPoint({
+            target: this.logic && this.logic.view ? 'Frontend' : 'Backend',
+            logicItem: this,
+            logicItemId: this.id,
+            componentId: this.logic && this.logic.view && this.logic.view.id,
+            component: this.logic && this.logic.view,
+            logic: this.logic,
+            status: 'Enabled',
+            offset: offsetLine,
+            isTemporary: true,
+        });
+        bp.attachSourceMap();
+        this.temporaryBreakPoint = bp;
+        return bp;
+    }
+
+    get breakPoint(): BreakPoint {
+        if (this.parent?.type === 'SwitchCase' && this.parentAttr === 'test')
+            return this.parent.breakPoint;
+
+        return this.breakPoints?.find((bp) => bp.offset === 0);
+    }
+
+    get hasBreakPoint(): boolean {
+        if (this.parent?.type === 'SwitchCase' && this.parentAttr === 'test')
+            return this.parent.hasBreakPoint;
+
+        return !!(this.temporaryBreakPoint || this.breakPoint);
+    }
+
+    get isBreakPointEnabled(): boolean {
+        if (this.parent?.type === 'SwitchCase' && this.parentAttr === 'test')
+            return this.parent.isBreakPointEnabled;
+
+        return this.breakPoint?.status === 'Enabled';
+    }
+
+    get isBreakPointDisabled(): boolean {
+        if (this.parent?.type === 'SwitchCase' && this.parentAttr === 'test')
+            return this.parent.isBreakPointDisabled;
+
+        return this.breakPoint?.status === 'Disabled';
+    }
+
+    get isBreakPointActive(): boolean {
+        if (this.parent?.type === 'SwitchCase' && this.parentAttr === 'test')
+            return this.parent.isBreakPointActive;
+        if (config.defaultApp.debuggerClient?.currentThread) {
+            const bp = this.temporaryBreakPoint || this.breakPoint;
+            return bp === config.defaultApp.debuggerClient?.currentThread.breakPoint;
+        }
+        return false;
+        // if (this.temporaryBreakPoint) {
+        //     return true;
+        // }
+        // return this.breakPoint === config.defaultApp.debuggerClient?.currentBreakPoint;
+    }
+
+    async setBreakPoint(offsetLine = 0) {
+        const app = config.defaultApp;
+        if (app.debuggerClient?.isConnected) {
+            const breakPoint = new BreakPoint({
+                target: this.logic && this.logic.view ? 'Frontend' : 'Backend',
+                logicItem: this,
+                logicItemId: this.id,
+                componentId: this.logic && this.logic.view && this.logic.view.id,
+                component: this.logic && this.logic.view,
+                logic: this.logic,
+                status: 'Enabled',
+                offset: offsetLine,
+            });
+            const attachResult = breakPoint.attachSourceMap();
+            if (attachResult) {
+                await app.debuggerClient.setRemoteBreakPoint(breakPoint);
+                await this.addBreakPoint(app.id, offsetLine);
+            } else {
+                this.emit('breakpointattacherror', {
+                    message: '未在sourceMap中找到'
+                });
+            }
+        } else {
+            await this.addBreakPoint(app.id, offsetLine);
+        }
+    }
+
+    async removeBreakPoint(offsetLine = 0) {
+        const app = config.defaultApp;
+        const breakPoints = this.parent?.type === 'SwitchCase' && this.parentAttr === 'test' ? this.parent.breakPoints : this.breakPoints;
+        const breakPoint = breakPoints.find((bp) => bp.offset === offsetLine);
+        await app.debuggerClient?.removeRemoteBreakPoint(breakPoint);
+        await breakPoint?.remove();
+    }
+
+    async removeAllBreakPointsOfDescendants() {
+        const promises: Array<Promise<void>> = [];
+        utils.traverse(({ node }) => {
+            if (node.breakPoints?.length > 0) {
+                node.breakPoints.forEach((bp) => {
+                    promises.push(node.removeBreakPoint(bp.offset));
+                });
+            }
+        }, { node: this }, {
+            mode: 'anyObject',
+            excludedKeySet: this.JSON_EXCLUDED_KEYS,
+        });
+        await Promise.all(promises);
+    }
+
+    async disableAllBreakPointsOfDescendants() {
+        const promises: Array<Promise<void>> = [];
+        utils.traverse(({ node }) => {
+            if (node.breakPoints?.length > 0) {
+                node.breakPoints.forEach((bp) => {
+                    promises.push(bp.disable());
+                });
+            }
+        }, { node: this }, {
+            mode: 'anyObject',
+            excludedKeySet: this.JSON_EXCLUDED_KEYS,
+        });
+        await Promise.all(promises);
+    }
 }
 
 export class LogicNode extends LogicItem {
@@ -1254,4 +1436,44 @@ export class ExpressionNode extends LogicItem {
         super();
         source && this.assign(source);
     }
+
+    addBreakPoint(appId: string, offsetLine = 0) {
+        // let switchParent = this.parent;
+        // let switchCase;
+        // while (switchParent && switchParent.type !== 'SwitchStatement') {
+        //     if (switchParent.type === 'SwitchCase') {
+        //         switchCase = switchParent;
+        //     }
+        //     switchParent = switchParent.parent;
+        // }
+
+        // switchCase 是个 logicNode，直接加好了
+        if (this.parent?.type === 'SwitchCase' && this.parentAttr === 'test')
+            return this.parent.addBreakPoint(appId, offsetLine);
+        // const index = switchParent.cases.findIndex((c) => c === switchCase);
+        // const id = switchCase.id;
+
+        // const view = this.logic.view;
+        // const sourceMap = view.sourceMap;
+        // const componentId = view.id;
+        // // const id = `${switchParent.id}-case${index}`;
+        // const map = sourceMap[id];
+        // if (map) {
+        //     const lineNumberStart = map.from + offsetLine;
+        //     let bp = this.breakPoints.find((bp) => bp.lineNumberStart === lineNumberStart);
+        //     if (bp) {
+        //         return bp;
+        //     }
+        //     bp = new BreakPoint({
+        //         lineNumberStart,
+        //         logicItem: switchCase,
+        //         logicItemId: switchCase.id,
+        //         componentId,
+        //     });
+        //     switchCase.breakPoints.push(bp);
+        //     return bp;
+        // }
+        // return null;
+        return super.addBreakPoint(appId, offsetLine);
+    }
 }

package/src/types/logic/Param.ts

@@ -4,6 +4,29 @@ import { paramService } from '../../service/logic';
 import { convert2RefType, convert2SchemaType } from '../data/dataTypeUtils';
 import { getBasicTypeDefaultValue } from '../data/basicTypes';
 import { schemaService } from '../../service/common';
+import { refreshLogic, refreshInterfaces, refreshView } from '../cache';
+import { BusinessCode } from '../enum';
+
+export function catchFn(logic: Logic) {
+    return async (err: any) => {
+        const code = err?.code;
+        // 节点已存在； 节点不存在
+        if([BusinessCode.ElementExist, BusinessCode.ElementNotExist].includes(code)) {
+            await refreshLogic(logic);
+        } else if(code === BusinessCode.ParentElementNotExist) {  // 父节点不存在，即逻辑不存在
+            if(logic.interface) {
+                await refreshInterfaces();
+            } else if(logic.view) {
+                await refreshView(logic.view);
+            }
+        } else
+            config.defaultApp?.emit('saved', err);
+       
+        config.defaultApp?.history.load();
+
+        throw err;
+    }
+}
 
 /**
  * 逻辑输入参数
@@ -60,7 +83,7 @@ export class Param extends BaseVariable {
                 operationDesc: actionOptions?.actionDesc || `添加逻辑"${this.logic.name}"输入参数"${this.name}"`,
             },
             body,
-        });
+        }).catch(catchFn(this.logic));
         // convert2RefType(result.schema);
         this.deepPick(result, ['id']);
         this.assign({ code: this.genCode() });
@@ -85,7 +108,6 @@ export class Param extends BaseVariable {
         config.defaultApp?.emit('saving');
 
         if (this.id) {
-            try {
                 await paramService.delete({
                     headers: {
                         appId: config.defaultApp?.id,
@@ -96,11 +118,7 @@ export class Param extends BaseVariable {
                         loValId: this.id,
                         logicId: this.logic.id,
                     },
-                });
-            } catch(err) {
-                await config.defaultApp?.history.load();
-                throw err;
-            }
+                }).catch(catchFn(this.logic));
         }
 
         const index = this.logic.params.indexOf(this);
@@ -133,7 +151,7 @@ export class Param extends BaseVariable {
                 operationDesc: actionOptions?.actionDesc || `修改逻辑输入参数"${this.name}"`,
             },
             body,
-        });
+        }).catch(catchFn(this.logic));
         this.schema.id = result.schema.id;
         // convert2RefType(result.schema);
         // this.plainAssign(result);