@lcap/nasl-concepts 3.9.0-beta.1

package/out/service/getProcessesV2.js

@@ -0,0 +1,687 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProcessVariableSuggestions = exports.genProcessVariables = exports.isFromStartNode = exports.getFlowBeforeElements = exports.getFlowAfterElements = exports.genUserTaskLogic = exports.genProcessOperate = exports.genLaunchProcess = exports.getFlowSystemVariables = exports.getProcessSystemVariables = exports.transformIdentifier = exports.getPreviousTask = exports.getProcessSystemVariableType = exports.getProeprtiesLabelMap = exports.getProcessNameMap = void 0;
+const concepts_1 = require("../concepts");
+const utils = __importStar(require("../utils"));
+const getProcesses_1 = require("./getProcesses");
+const excludedKeySet = new Set([
+    'parentNode',
+    'sourceMap',
+    'storageJSON',
+    'tsErrorDetail',
+    'NaslAnnotatedJSON',
+    'calledFrom',
+    '_events',
+    '_collectingList',
+    '_historyList',
+    'typeAnnotation'
+]);
+exports.getProcessNameMap = {
+    procInstStartBy: '流程实例发起人',
+    procInstId: '流程实例ID',
+    procInstStartTime: '流程实例发起时间',
+    procInstEndTime: '流程实例结束时间',
+    nodeTitle: '节点标题',
+    nodeDesc: '节点描述',
+    nodeParticipants: '节点参与人',
+    nodeAssignees: '节点完成人',
+    nodeStartTime: '节点进入时间',
+    nodeEndTime: '节点退出时间',
+    nodeOutcome: '节点输出结果',
+    taskId: '任务ID',
+    taskStartTime: '任务创建时间',
+    taskEndTime: '任务完成时间',
+    taskOutcome: '任务输出结果'
+};
+function getProeprtiesLabelMap(entity) {
+    return entity.properties.reduce((acc, cur) => {
+        acc[cur.name] = cur.label;
+        return acc;
+    }, {});
+}
+exports.getProeprtiesLabelMap = getProeprtiesLabelMap;
+function getProcessSystemVariableType() {
+    const processSystemVariableType = {
+        procInstStartBy: concepts_1.TypeAnnotation.createPrimitive('String'),
+        procInstId: concepts_1.TypeAnnotation.createPrimitive('String'),
+        procInstStartTime: concepts_1.TypeAnnotation.createPrimitive('DateTime'),
+        procInstEndTime: concepts_1.TypeAnnotation.createPrimitive('DateTime'),
+        nodeTitle: concepts_1.TypeAnnotation.createPrimitive('String'),
+        nodeDesc: concepts_1.TypeAnnotation.createPrimitive('String'),
+        nodeParticipants: concepts_1.TypeAnnotation.createGeneric('List', { typeArguments: [concepts_1.TypeAnnotation.createPrimitive('String')] }),
+        nodeAssignees: concepts_1.TypeAnnotation.createGeneric('List', { typeArguments: [concepts_1.TypeAnnotation.createPrimitive('String')] }),
+        nodeStartTime: concepts_1.TypeAnnotation.createPrimitive('DateTime'),
+        nodeEndTime: concepts_1.TypeAnnotation.createPrimitive('DateTime'),
+        nodeOutcome: concepts_1.TypeAnnotation.createPrimitive('String'),
+        taskId: concepts_1.TypeAnnotation.createPrimitive('String'),
+        taskStartTime: concepts_1.TypeAnnotation.createPrimitive('DateTime'),
+        taskEndTime: concepts_1.TypeAnnotation.createPrimitive('DateTime'),
+        taskOutcome: concepts_1.TypeAnnotation.createPrimitive('String')
+    };
+    return processSystemVariableType;
+}
+exports.getProcessSystemVariableType = getProcessSystemVariableType;
+/**
+ * 获取当前任务之前的任务
+ * @param node
+ * @param nodePorcess
+ * @returns
+ */
+function getPreviousTask(node, nodePorcess) {
+    const likeProcessV2 = node.likeProcessV2 || nodePorcess;
+    const elems = likeProcessV2.elements;
+    const elements = [];
+    const visitedMap = new WeakMap();
+    function iterator(processElem) {
+        if (visitedMap.has(processElem)) {
+            return;
+        }
+        if (processElem !== node && (processElem.isTask)) {
+            elements.push(processElem);
+        }
+        visitedMap.set(processElem, true);
+        let links = [];
+        if (processElem.parentNode?.concept === 'BindEvent' || processElem.parentNode?.concept === 'Assignee') {
+            const elemParentNode = processElem.getAncestor('ProcessElementV2') || processElem.getAncestor('ProcessV2');
+            links = elems.filter((e) => e.isFlow && e.targetRef === elemParentNode.name); // 流程事件api逻辑名字与任务名字不同，需要重新适配
+        }
+        else if (processElem.isFlow) {
+            links = [processElem];
+        }
+        else {
+            links = elems.filter((e) => e.isFlow && e.targetRef === processElem.name);
+        }
+        links.forEach((l) => {
+            const s = l.sourceRef;
+            const t = elems.find((el) => el.name === s);
+            if (t) {
+                iterator(t);
+            }
+        });
+    }
+    iterator(node);
+    return elements;
+}
+exports.getPreviousTask = getPreviousTask;
+function transformIdentifier(arr) {
+    return arr.map(({ name, value }) => {
+        const node = (0, getProcesses_1.genMemberExpression)(name);
+        node.value = value;
+        return node;
+    });
+}
+exports.transformIdentifier = transformIdentifier;
+function isUniqueTargetRef(ele) {
+    const prefixEles = ele.getPrefixProcessElements();
+    if (prefixEles.length === 1) {
+        const prefixEle = prefixEles[0];
+        if (!prefixEle.isManualTask) {
+            return false;
+        }
+        return true;
+    }
+    return false;
+}
+function getProcessSystemVariables(processEle) {
+    const { processV2 } = processEle;
+    // ------------------------------流程变量--------------------------------
+    const startNode = {
+        name: processV2.name,
+        value: processV2.name,
+        title: processV2.name,
+        expanded: true,
+        icon: 'process',
+        children: transformIdentifier([{ value: '流程实例发起人', name: 'processSystem.procInstStartBy' }]),
+    };
+    const prefixNode = {
+        name: '上一任务节点',
+        value: '上一任务节点',
+        title: '上一任务节点',
+        expanded: true,
+        icon: 'ApprovalTask',
+        children: transformIdentifier([
+            { value: '节点参与人', name: 'processSystem.pre.nodeParticipants' },
+            { value: '节点完成人', name: 'processSystem.pre.nodeAssignees' },
+        ]),
+    };
+    const elements = getPreviousTask(processEle);
+    const prevtasks = elements.map((item) => {
+        return {
+            name: item.name,
+            value: item.name,
+            title: item.title,
+            expanded: true,
+            icon: item.type,
+            isProcess: true,
+            children: transformIdentifier([
+                { value: '节点参与人', name: `processSystem.${item.name}.nodeParticipants` },
+                { value: '节点完成人', name: `processSystem.${item.name}.nodeAssignees` },
+            ]),
+        };
+    });
+    // ------------------------------流程数据--------------------------------
+    const { properties = [] } = processV2.currentBindEntity || {};
+    let customs = properties.filter(({ typeAnnotation }) => ['String', 'List<String>'].includes(typeAnnotation?.sign));
+    if (processV2.composedBy) {
+        customs = customs.filter((item) => !['procInstId', 'status'].includes(item.name));
+    }
+    customs = transformIdentifier(customs.map(({ name, label, typeAnnotation }) => {
+        return { value: label, name: `custom.data.${name}`, typeAnnotation };
+    }));
+    const systempVars = [
+        {
+            title: '流程变量',
+            value: processV2.name,
+            children: [
+                startNode,
+            ],
+            expanded: true,
+            icon: 'category',
+        },
+        {
+            title: '流程数据',
+            value: '流程数据',
+            children: [
+                ...customs
+            ],
+            expanded: true,
+            icon: 'category',
+        }
+    ];
+    if (isUniqueTargetRef(processEle)) {
+        systempVars[0].children.push(prefixNode);
+    }
+    systempVars[0].children.push(...prevtasks);
+    return systempVars;
+}
+exports.getProcessSystemVariables = getProcessSystemVariables;
+function getFlowSystemVariables(processEle) {
+    const processSystemVariableType = getProcessSystemVariableType();
+    const processVar = [
+        { label: '流程实例发起人', value: 'procInstStartBy', icon: 'property' },
+        { label: '流程实例ID', value: 'procInstId', icon: 'property' },
+        { label: '流程实例发起时间', value: 'procInstStartTime', icon: 'property' },
+    ];
+    const prefixNodeVar = {
+        label: '上一任务节点',
+        value: 'pre',
+        expanded: true,
+        icon: 'ApprovalTask',
+        children: [
+            { label: '(审批)输出结果', value: 'nodeOutcome', icon: 'property' },
+            { label: '(审批)标识', value: 'nodeTitle', icon: 'property' },
+            { label: '(审批)描述', value: 'nodeDesc', icon: 'property' },
+            { label: '(审批)参与人', value: 'nodeParticipants', icon: 'property' },
+            { label: '(审批)完成人', value: 'nodeAssignees', icon: 'property' },
+            { label: '(审批)完成时间', value: 'nodeEndTime', icon: 'property' },
+        ],
+    };
+    const prefixElement = processEle.getPrefixProcessElements()[0];
+    const elements = getPreviousTask(prefixElement);
+    const prevtasksVar = elements.map((item) => {
+        return {
+            label: item.title,
+            value: item.name,
+            icon: item.type,
+            children: [
+                { label: '输出结果', value: `nodeOutcome`, icon: 'property' },
+                { label: '标题', value: `nodeTitle`, icon: 'property' },
+                { label: '描述', value: `nodeDesc`, icon: 'property' },
+                { label: '参与人', value: `nodeParticipants`, icon: 'property' },
+                { label: '完成人', value: `nodeAssignees`, icon: 'property' },
+                { label: '创建时间', value: `nodeStartTime`, icon: 'property' },
+                { label: '完成时间', value: `nodeEndTime`, icon: 'property' },
+            ],
+        };
+    });
+    if (isUniqueTargetRef(prefixElement)) {
+        processVar.push(prefixNodeVar);
+    }
+    const systempVars = {
+        value: 'processSystem',
+        label: '流程变量',
+        children: [...processVar, ...prevtasksVar],
+    };
+    utils.traverse(({ node }) => {
+        if (Object.prototype.hasOwnProperty.call(processSystemVariableType, node.value)) {
+            node.typeAnnotation = processSystemVariableType[node.value];
+        }
+    }, { node: systempVars }, {
+        mode: 'anyObject',
+        excludedKeySet,
+    });
+    return systempVars;
+}
+exports.getFlowSystemVariables = getFlowSystemVariables;
+function genLaunchProcess(process) {
+    const l = new concepts_1.Logic({
+        name: 'launchProcess',
+        params: [
+            new concepts_1.Param({
+                name: 'data',
+                typeAnnotation: new concepts_1.TypeAnnotation({
+                    typeNamespace: '',
+                    typeName: 'typeof bindData',
+                }),
+            }),
+            new concepts_1.Param({
+                name: 'procDefKey',
+                typeAnnotation: concepts_1.TypeAnnotation.createPrimitive('String'),
+            })
+        ],
+        body: [],
+        returns: [
+            new concepts_1.Return({
+                name: 'processId',
+                typeAnnotation: concepts_1.TypeAnnotation.createPrimitive('String'),
+            }),
+        ],
+    });
+    const path = `app.processes.${process.name}.logics`;
+    l.getNamespace = function () {
+        return path;
+    };
+    l.fake = true;
+    return l;
+}
+exports.genLaunchProcess = genLaunchProcess;
+function genProcessOperate(process, taskName) {
+    let params = [
+        new concepts_1.Param({
+            name: 'data',
+            typeAnnotation: new concepts_1.TypeAnnotation({
+                typeNamespace: '',
+                typeName: 'typeof bindData',
+            }),
+        }),
+        new concepts_1.Param({
+            name: 'procDefKey',
+            typeAnnotation: concepts_1.TypeAnnotation.createPrimitive('String'),
+        }),
+        new concepts_1.Param({
+            name: 'taskId',
+            typeAnnotation: concepts_1.TypeAnnotation.createPrimitive('String'),
+        }),
+    ];
+    if (['approveTask', 'rejectTask'].includes(taskName)) {
+        params.push(new concepts_1.Param({
+            name: 'comment',
+            typeAnnotation: concepts_1.TypeAnnotation.createPrimitive('String'),
+        }));
+    }
+    else if (taskName === 'getTaskData') {
+        params = [
+            new concepts_1.Param({
+                name: 'taskId',
+                typeAnnotation: concepts_1.TypeAnnotation.createPrimitive('String'),
+            }),
+            new concepts_1.Param({
+                name: 'procDefKey',
+                typeAnnotation: concepts_1.TypeAnnotation.createPrimitive('String'),
+            }),
+        ];
+    }
+    const returns = [];
+    if (taskName === 'getTaskData') {
+        const ret = new concepts_1.Return({
+            name: 'processId',
+            typeAnnotation: new concepts_1.TypeAnnotation({
+                typeNamespace: '',
+                typeName: 'typeof bindData',
+            }),
+        });
+        returns.push(ret);
+    }
+    const l = new concepts_1.Logic({
+        name: taskName,
+        params,
+        body: [],
+        returns,
+    });
+    const path = `app.processes.${process.name}.logics`;
+    l.getNamespace = function () {
+        return path;
+    };
+    l.fake = true;
+    return l;
+}
+exports.genProcessOperate = genProcessOperate;
+function genUserTaskLogic(userTask) {
+    //const taskId = userTask.constants.find((p) => p.name === 'taskId');
+    const { processV2 } = userTask;
+    let logics = [];
+    const usertaskLogics = [
+        new concepts_1.Logic({
+            name: `complete`,
+            fake: true,
+            //params: [constantToParam(taskId), ...userTask.returns.map(returnToParam)],
+            body: [],
+            returns: [],
+        }),
+        new concepts_1.Logic({
+            name: `reject`,
+            fake: true,
+            params: [
+                new concepts_1.Param({
+                    name: 'taskId',
+                    typeAnnotation: concepts_1.TypeAnnotation.createPrimitive('String'),
+                }),
+                new concepts_1.Param({
+                    name: 'targetTaskDefinitionId',
+                    typeAnnotation: concepts_1.TypeAnnotation.createPrimitive('String'),
+                }),
+                //...userTask.returns.map(returnToParam),
+            ],
+            body: [],
+            returns: [],
+        }),
+    ];
+    const multiTaskLogics = [
+        new concepts_1.Logic({
+            name: `reject`,
+            fake: true,
+            params: [
+                new concepts_1.Param({
+                    name: 'taskId',
+                    typeAnnotation: concepts_1.TypeAnnotation.createPrimitive('String'),
+                }),
+                new concepts_1.Param({
+                    name: 'targetTaskDefinitionId',
+                    typeAnnotation: concepts_1.TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
+            body: [],
+            returns: [
+                new concepts_1.Return({
+                    name: 'result',
+                    typeAnnotation: concepts_1.TypeAnnotation.createReference('LCAPOperateProcessResult', {
+                        typeNamespace: 'nasl.process',
+                    }),
+                }),
+            ],
+        }),
+        new concepts_1.Logic({
+            name: `pass`,
+            fake: true,
+            params: [
+                new concepts_1.Param({
+                    name: 'taskId',
+                    typeAnnotation: concepts_1.TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
+            returns: [],
+        }),
+        new concepts_1.Logic({
+            name: `fail`,
+            fake: true,
+            params: [
+                new concepts_1.Param({
+                    name: 'taskId',
+                    typeAnnotation: concepts_1.TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
+            returns: [],
+        }),
+    ];
+    logics = userTask.type === 'ApprovalTask' ? multiTaskLogics : usertaskLogics;
+    if (userTask.type === 'InitiateTask') {
+        logics.pop();
+    }
+    const path = `app.processes.${processV2.name}.elements.${userTask.name}.logics`;
+    logics.forEach((item) => {
+        item.getNamespace = function () {
+            return path;
+        };
+        item.fake = true;
+    });
+    return logics;
+}
+exports.genUserTaskLogic = genUserTaskLogic;
+function getFlowAfterElements(el) {
+    const likeProcessV2 = el.likeProcessV2;
+    const processname = el.name;
+    const elems = likeProcessV2.elements;
+    const links = elems.filter((e) => e.isFlow && e.sourceRef === processname);
+    return links;
+}
+exports.getFlowAfterElements = getFlowAfterElements;
+function getFlowBeforeElements(el) {
+    const likeProcessV2 = el.likeProcessV2;
+    const processname = el.name;
+    const elems = likeProcessV2?.elements;
+    const links = elems?.filter((e) => e.isFlow && e.targetRef === processname);
+    return links;
+}
+exports.getFlowBeforeElements = getFlowBeforeElements;
+function isFromStartNode(el) {
+    const likeProcessV2 = el.likeProcessV2;
+    const elems = likeProcessV2.elements;
+    const set = new WeakSet();
+    const stack = [el];
+    while (stack.length) {
+        const t = stack.shift();
+        const { name } = t;
+        if (t.type === 'InitiateTask') {
+            return true;
+        }
+        elems.forEach((e) => {
+            if (e.isFlow && e.targetRef === name && !set.has(e)) {
+                set.add(e);
+                const sourcename = e.sourceRef;
+                const source = elems.find((e) => e.name === sourcename);
+                stack.push(source);
+            }
+        });
+    }
+    return false;
+}
+exports.isFromStartNode = isFromStartNode;
+/**
+ * 生成属性
+ */
+function genConstants(prefix = [], variableNames = []) {
+    return variableNames.map((name) => {
+        const expression = (0, getProcesses_1.genCompletionProperty)(prefix)(new concepts_1.Constant({
+            name,
+        }));
+        expression.label = exports.getProcessNameMap[name] ?? null;
+        return expression;
+    });
+}
+/**
+ * 生成流程的变量
+ */
+function genProcessVariables(prefix = []) {
+    return genConstants(prefix, [
+        // 流程实例发起人
+        'procInstStartBy',
+        // 流程实例ID
+        'procInstId',
+        // 流程实例发起时间
+        'procInstStartTime',
+        // 流程实例结束时间
+        'procInstEndTime',
+    ]);
+}
+exports.genProcessVariables = genProcessVariables;
+/**
+ * 生成当前任务的变量
+ */
+function genCurNodeVariable(prefix = []) {
+    const curr = new concepts_1.CompletionProperty({
+        name: 'curr',
+        value: 'curr',
+        expression: (0, getProcesses_1.genMemberExpression)([...prefix, 'curr'].join('.')),
+        children: genConstants([...prefix, 'curr'], [
+            // 当前节点标题
+            'nodeTitle',
+            // 当前节点描述
+            'nodeDesc',
+            // 当前节点参与人
+            'nodeParticipants',
+            // 当前节点退出时间
+            'nodeEndTime',
+            // 当前节点输出结果
+            'nodeOutcome',
+            // 当前任务完成人
+            'taskCompleteUser',
+            // 当前任务ID
+            'taskId',
+            // 当前任务创建时间
+            'taskStartTime',
+            // 当前任务完成时间
+            'taskEndTime',
+            // 当前任务输出结果
+            'taskOutcome',
+        ])
+    });
+    curr.icon = 'Variable';
+    curr.label = '当前任务节点';
+    return curr;
+}
+/**
+ * 生成上一任务的变量
+ */
+function genPreNodeVariable(prefix = []) {
+    const pre = new concepts_1.CompletionProperty({
+        name: 'pre',
+        value: 'pre',
+        expression: (0, getProcesses_1.genMemberExpression)([...prefix, 'pre'].join('.')),
+        children: genConstants([...prefix, 'pre'], [
+            // 上一节点(审批)标识
+            'nodeTitle',
+            // 上一节点(审批)描述
+            'nodeDesc',
+            // 上一节点(审批)参与人
+            'nodeParticipants',
+            // 上一节点(审批)完成人
+            'nodeAssignees',
+            // 上一节点(审批)完成时间
+            'nodeEndTime',
+            // 上一节点(审批)输出结果
+            'nodeOutcome',
+        ])
+    });
+    pre.icon = 'Variable';
+    pre.label = '上一任务节点';
+    return pre;
+}
+/**
+ * 生成任务的变量
+ */
+function genTaskVariables(prefix = []) {
+    return genConstants(prefix, [
+        // 指定节点标题
+        'nodeTitle',
+        // 指定节点描述
+        'nodeDesc',
+        // 指定节点参与人
+        'nodeParticipants',
+        // 指定节点完成人
+        'nodeAssignees',
+        // 指定节点创建时间
+        'nodeStartTime',
+        // 指定节点完成时间
+        'nodeEndTime',
+        // 指定节点输出结果
+        'nodeOutcome',
+    ]);
+}
+/**
+ * @param node
+ * @returns
+ */
+function getProcessVariableSuggestions(node) {
+    // 流程下的callback没有processElement
+    const tempPorcessEle = new concepts_1.ProcessElementV2({});
+    const processElem = node.processElementV2 || tempPorcessEle;
+    const processV2 = node.processV2;
+    const list = [];
+    // 系统变量
+    const systemVariable = {
+        name: processV2.name,
+        value: 'processSystem',
+        concept: 'processV2',
+        rootName: 'processSystem',
+        selectable: false,
+        children: [
+            // 生成流程变量
+            ...genProcessVariables(['processSystem']),
+        ],
+    };
+    if (processElem.isTask) {
+        // 生成当前任务的变量
+        systemVariable.children.push(genCurNodeVariable(['processSystem']));
+        // 生成上一任务的变量
+        if (isUniqueTargetRef(processElem)) {
+            systemVariable.children.push(genPreNodeVariable(['processSystem']));
+        }
+    }
+    const elements = getPreviousTask(processElem, processV2);
+    if (elements?.length) {
+        systemVariable.children.push(...(elements.map((us) => {
+            const elementName = us.name;
+            const cp = new concepts_1.CompletionProperty({
+                name: elementName,
+                value: elementName,
+                children: [
+                    // 生成任务的变量
+                    ...genTaskVariables(['processSystem', elementName]),
+                ],
+            });
+            cp.icon = us.type;
+            cp.isProcess = true;
+            return cp;
+        })));
+    }
+    list.push(systemVariable);
+    const { properties } = processV2?.bind?.typeAnnotation || {};
+    if (Array.isArray(properties)) {
+        // 数据变量
+        const customVariable = {
+            name: processV2.name,
+            value: 'custom',
+            concept: 'processV2',
+            rootName: 'custom',
+            selectable: false,
+            children: [],
+        };
+        customVariable.children = [];
+        properties.forEach((property) => {
+            const { name, typeAnnotation } = property;
+            const dataVariable = new concepts_1.Variable({
+                name,
+                typeAnnotation: typeAnnotation.toJSON(),
+            });
+            dataVariable.parentNode = processV2;
+            customVariable.children.push((0, getProcesses_1.genCompletionProperty)(['custom'])(dataVariable));
+        });
+        list.push(customVariable);
+    }
+    return list;
+}
+exports.getProcessVariableSuggestions = getProcessVariableSuggestions;
+//# sourceMappingURL=getProcessesV2.js.map