@lcap/nasl 0.3.9-beta

package/src/types/logic/translator_backup.js

@@ -0,0 +1,643 @@
+import generate from '@babel/generator';
+import * as babel from '@babel/core';
+import { TransforClientQuery as genQuery } from 'apollo-plugin-loader';
+import { Vertex, vertexesMap, utils } from '..';
+import { getQuerySchemaMap } from './tools';
+
+function switchCase2If(cases) {
+    const cas = cases.shift();
+
+    const result = {
+        type: 'IfStatement',
+        test: cas.test,
+        consequent: {
+            type: 'BlockStatement',
+            body: cas.consequent || [],
+        },
+        alternate: null,
+    };
+
+    if (cases.length) {
+        result.alternate = switchCase2If(cases);
+    } else {
+        return {
+            type: 'BlockStatement',
+            body: cas.consequent || [],
+        };
+    }
+
+    return result;
+}
+
+export default function (source) {
+    const definition = typeof source === 'string' ? JSON.parse(source) : source;
+
+    function traverse(node, func, parent, index) {
+        func(node, parent, index);
+        Object.values(node).forEach((value) => {
+            if (Array.isArray(value)) {
+                value.forEach((child, index) => child && traverse(child, func, node, index));
+            } else if (typeof value === 'object')
+                value && traverse(value, func, node, index);
+        });
+    }
+
+    const dataMap = {};
+    const globalDataMap = {
+        $route: true,
+        $global: true,
+        $refs: true,
+    };
+
+    /**
+     * 生成页面的 data
+     * genInitFromSchema 是为了将数据类型的处理和页面逻辑的生成分开
+     * 比如 param a.b 的 schema 有变化，View 代码无需再次生成
+     */
+    const paramsData = (definition.params || [])
+        .map((param) => {
+            // pass schema to genInitData function, transform init realtime after datatypes changed
+
+            // 标记 Vue 的 data 中已经使用声明了该变量
+            dataMap[param.code || param.name] = true;
+            return safeCodeAsKey(param) + `: this.$genInitFromSchema(${JSON.stringify(param.schema)}, this.$route.query.hasOwnProperty('${param.name}') ? this.$route.query.${param.name} : ${JSON.stringify(param.defaultValue)}, true)`;
+        }).join(',\n').trim();
+    /**
+     * 生成变量的 data
+     */
+    const variablesData = (definition.variables || [])
+        .map((variable) => {
+            // 标记 Vue 的 data 中已经使用声明了该变量
+            dataMap[variable.code || variable.name] = true;
+            return safeCodeAsKey(variable) + `: this.$genInitFromSchema(${JSON.stringify(variable.schema)}, ${JSON.stringify(variable.defaultValue)})`;
+        }).join(',\n').trim();
+
+    function checkThis(node) {
+        if (!node)
+            return;
+        if (node.type === 'Identifier') {
+            if (dataMap[node.code || node.name] || globalDataMap[node.code || node.name])
+                node.name = 'this.' + (node.code || node.name);
+        } else if (node.type === 'MemberExpression') {
+            return checkThis(node.object);
+        } else if (node.type === 'CallExpression') {
+            (node.arguments || []).forEach((arg) => {
+                return checkThis(arg);
+            });
+        }
+    }
+    function safeGenerate(node) {
+        if (!node)
+            return undefined;
+        checkThis(node);
+        const code = generate(node).code;
+        return code || undefined;
+    }
+    function safeKey(key) {
+        if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key))
+            return key;
+        else
+            return `['${key}']`;
+    }
+
+    function safeCodeAsKey(node) {
+        return `['${node.code || node.name}']`;
+    }
+
+    function safeCodeParamKey(node) {
+        return node.code || node.name;
+    }
+
+    function nameToCodeForMemberExpression(memberExpression) {
+        if (!memberExpression)
+            return memberExpression;
+
+        memberExpression = JSON.parse(JSON.stringify(memberExpression));
+        if (memberExpression.type === 'MemberExpression') {
+            const { object, property } = memberExpression;
+            if (object.code)
+                object.name = object.code;
+            if (property.code)
+                property.name = property.code;
+
+            if (object.type === 'MemberExpression')
+                memberExpression.object = nameToCodeForMemberExpression(object);
+        }
+        return memberExpression;
+    }
+
+    const lifecycles = (definition.lifecycles || [])
+        .filter((lifecycle) => lifecycle.name)
+        .map(
+            (lifecycle) => `componentOptions['${lifecycle.name}'] = function () {
+            return this.ID_${lifecycle.logicId}();
+        }`,
+        );
+
+    const methods = (definition.logics || []).map((logic) => {
+        let returnObj = {
+            type: 'Identifier',
+            name: 'result',
+            init: { type: 'Identifier', name: 'undefined' },
+        };
+        if (logic.returns[0])
+            returnObj = logic.returns[0];
+
+        traverse(logic, (node, parent, index) => {
+            if (node.type === 'Start' || node.type === 'Comment') {
+                node.type = 'Noop';
+            } else if (node.type === 'End') {
+                Object.assign(node, {
+                    type: 'ReturnStatement',
+                    argument: { type: 'Identifier', name: returnObj.name },
+                });
+            } else if (node.type === 'Identifier' && node.level === 'expressionNode') {
+                node.name = node.code || node.name;
+                if (!((parent && parent.type === 'MemberExpression' && node === parent.property) || (node.name && node.name.startsWith('this.'))))
+                    checkThis(node);
+            } else if (node.type === 'TypeNote') {
+                const { type, format } = node.schema;
+                Object.assign(
+                    node,
+                    babel.parse(`({ type: '${type}', format: '${format}' })`, {
+                        filename: 'file.js',
+                    }).program.body[0].expression,
+                );
+            } else if (node.type === 'Unparsed') {
+                // 借 Identifier 的鸡下个蛋
+                node.type = 'Identifier';
+                node.name = node.code;
+            } else if (node.type === 'AssignmentExpression') {
+                checkThis(node.left);
+                checkThis(node.right);
+            } else if (node.type === 'CallLogic') {
+                Object.assign(node, {
+                    type: 'AwaitExpression',
+                    argument: babel.parse(
+                        `this.${node.calleeCode}(${node.params.map((param) => safeGenerate(param.callInterParamValue) || 'undefined').join(',')})`,
+                        { filename: 'file.js' },
+                    ).program.body[0].expression,
+                });
+            } else if (node.type === 'BuiltInFunction') {
+                // 在View.ts 的 toScript进行转换，这里先注释
+                // Object.assign(
+                //     node,
+                //     babel.parse(`this.$utils['${node.calleeCode}']()`, {
+                //         filename: 'file.js',
+                //     }).program.body[0].expression,
+                //     {
+                //         arguments: (node.builtInFuncParams || []).map((param) => {
+                //             if (param.builtInFuncParamValue) {
+                //                 param.builtInFuncParamValue.name = param.builtInFuncParamValue.code;
+                //             }
+                //             return param.builtInFuncParamValue;
+                //         }),
+                //     },
+                // );
+            } else if (node.type === 'CallInterface') {
+                const key = node.interfaceKey || '';
+                const arr = key.split('/');
+
+                const getParams = (key) => {
+                    // 过滤掉 null 的 param
+                    const nodeParams = (node.params || []).filter((param) => param !== null && param !== 'null' && param !== '');
+                    if (key === 'body') {
+                        const body = (nodeParams || []).find((param) => {
+                            const refTarget = Vertex.getVertexByRef(param.callInterParam);
+                            return refTarget && refTarget.in === key;
+                        });
+                        if (body) {
+                            return safeGenerate(body.callInterParamValue);
+                        }
+                        return '{}';
+                    } else {
+                        return nodeParams
+                            .filter((param) => {
+                                const refTarget = Vertex.getVertexByRef(param.callInterParam);
+                                return refTarget && refTarget.in === key;
+                            })
+                            .map((param) => {
+                                const refTarget = Vertex.getVertexByRef(param.callInterParam);
+                                const callInterParamValue = nameToCodeForMemberExpression(param.callInterParamValue);
+                                const value = safeGenerate(callInterParamValue);
+
+                                return `${safeCodeAsKey(refTarget)}: ${value}`;
+                            });
+                    }
+                };
+                // 如果是 interface 判断接口参数类型window.location.href
+                Object.assign(node, {
+                    type: 'AwaitExpression',
+                    argument: babel.parse(
+                        `this.$services['_custom']['ID_${arr[arr.length - 1]}']({
+                        config: {
+                            download: ${node.interfaceKey.includes('export')},
+                        },
+                        path: {
+                            ${getParams('path').join(',\n')}
+                        },
+                        query: {
+                            ${getParams('query').join(',\n')}
+                        },
+                        body: ${getParams('body') || '{}'},
+                    })`,
+                        { filename: 'file.js' },
+                    ).program.body[0].expression,
+                });
+            } else if (node.type === 'CallGraphQL') {
+                const getParams = (key) => {
+                    // 过滤掉 null 的 param
+                    const nodeParams = (node.params || []).filter((param) => param !== null && param !== 'null' && param !== '');
+                    if (key === 'body') {
+                        const body = (nodeParams || []).find((param) => {
+                            const refTarget = Vertex.getVertexByRef(param.callInterParam);
+                            return refTarget && refTarget.in === key;
+                        });
+                        if (body) {
+                            return safeGenerate(body.callInterParamValue);
+                        }
+                        return '{}';
+                    } else {
+                        return nodeParams
+                            .filter((param) => {
+                                const refTarget = Vertex.getVertexByRef(param.callInterParam);
+                                return refTarget && refTarget.in === key;
+                            })
+                            .map((param) => {
+                                const refTarget = Vertex.getVertexByRef(param.callInterParam);
+
+                                const callInterParamValue = nameToCodeForMemberExpression(param.callInterParamValue);
+                                const value = safeGenerate(callInterParamValue);
+
+                                return `${safeCodeAsKey(refTarget)}: ${value}`;
+                            });
+                    }
+                };
+                // const getParams = () => {
+                //     const data = node.params || []; // .filter((param) => param.in === key);
+                //     const result = [];
+                //     // 目前主要 id，如果字段多了之后会有严格的顺序要求， 并且 path 里面不能使用名字为 query，body，这两个参数作为需要特殊处理的 key
+                //     const pathParams = data.filter((param) => {
+                //         const refTarget = Vertex.getVertexByRef(param.callInterParam);
+                //         return refTarget && refTarget.in === 'path';
+                //     });
+                //     pathParams.forEach((param) => {
+                //         const refTarget = Vertex.getVertexByRef(param.callInterParam);
+                //         const value = safeGenerate(param.callInterParamValue);
+                //         result.push(`${safeKey(refTarget.name)}: ${value}`);
+                //     });
+
+                //     const queryParams = data.filter((param) => {
+
+                //         param.in === 'query';
+                //     });
+                //     if (queryParams.length > 0) {
+                //         const queryValue = queryParams.map((param) => {
+                //             const value = safeGenerate(param.value);
+                //             return `${safeKey(param.name)}:${value}`;
+                //         });
+                //         // key：value 转化成 queryString
+                //         result.push(`query: { ${queryValue.join(',\n')} }`);
+                //     }
+
+                //     const bodyParams = data.filter((param) => param.in === 'body');
+                //     if (bodyParams.length > 0) {
+                //         const bodyValue = bodyParams.map((param) => {
+                //             const value = safeGenerate(param.value);
+                //             return `${safeKey(param.name)}:${value}`;
+                //         });
+                //         // 如果是 body 需要转化成对象
+                //         result.push(`body: {
+                //             ${bodyValue.join(',\n')}
+                //         }`);
+                //     }
+                //     // 最后再把按照 key 组装后的结果返回给页面
+                //     return result;
+                // };
+
+                const getOperationName = (schemaRef = '', name = '') => {
+                    const arr = schemaRef.split('/');
+                    const entityName = 'ID_' + arr[3];
+                    // 处理全局查询的单复数问题
+                    const singleName = name === 'getAll' ? `getAll${entityName}` : name;
+                    arr.pop();
+                    arr.push(singleName);
+                    arr.shift();
+                    return arr.join('_');
+                };
+
+                node.operationName = getOperationName(node.schemaRef, node.resolverName);
+                const entity = Vertex.getVertexByRef(node.schemaRef);
+                const resolver = entity && entity.resolvers.find((resolver) => resolver.name === node.resolverName);
+                const key = resolver && resolver.interface.key || '';
+                const arr = key.split('/');
+                // const graphqlClient = node.querySchemaMap ? genQuery(node) : `query test{}`;
+                // Object.assign(node, {
+                //     type: 'AwaitExpression',
+                //     argument: babel.parse(
+                //         `this.$graphql.${node.action || 'query'}('${node.schemaRef}', '${
+                //             node.operationName
+                //         }', \`${graphqlClient}\`, {
+                //             path: {
+                //                 ${getParams('path').join(',\n')}
+                //             },
+                //             query: {
+                //                 ${getParams('query').join(',\n')}
+                //             },
+                //             body: ${getParams('body') || '{}'},
+                //         })`,
+                //         { filename: 'file.js' },
+                //     ).program.body[0].expression,
+                // });
+                // GraphQL 还有一些问题，先用 CallInterface 解决
+
+                Object.assign(node, {
+                    type: 'MemberExpression',
+                    object: {
+                        type: 'AwaitExpression',
+                        argument: babel.parse(
+                            `this.$services['_custom']['ID_${arr[arr.length - 1]}']({
+                            config: {
+                                download: ${key.includes('export')},
+                            },
+                            path: {
+                                ${getParams('path').join(',\n')}
+                            },
+                            query: {
+                                ${getParams('query').join(',\n')}
+                            },
+                            body: ${getParams('body') || '{}'},
+                        })`,
+                            { filename: 'file.js' },
+                        ).program.body[0].expression,
+                    },
+                    property: {
+                        type: 'Identifier',
+                        name: 'Data',
+                    },
+                });
+            } else if (node.type === 'CallFlow') {
+                const bodyParams = (node.params || [])
+                    .filter((param) => param.in === undefined) // 放在body内部的参数
+                    .filter((param) => safeGenerate(param.value) !== undefined)
+                    .map((param) => `${safeKey(param.name)}: ${safeGenerate(param.value)}`)
+                    .join(',\n');
+
+                const getObj = (type) =>
+                    (node.params || [])
+                        .filter((param) => param.in === type)
+                        .reduce((obj, param) => {
+                            const key = safeKey(param.name);
+                            const value = safeGenerate(param.value);
+                            obj[key] = value;
+                            return obj;
+                        }, {});
+                const pathObj = getObj('path');
+                const bodyObj = getObj('body');
+
+                let params = '';
+                const variables = safeGenerate(node.variables);
+                if (node.action === 'start') {
+                    params = `{
+                        body: {
+                            processDefinitionKey: '${node.processDefinitionKey}',
+                            returnVariables: true,
+                            variables: ${variables},
+                            ${bodyParams}
+                        }
+                    }`;
+                } else if (node.action === 'complete') {
+                    params = `{
+                        path: {
+                            taskId: ${pathObj.taskId
+                              || safeGenerate(node.taskId)},
+                        },
+                        body: {
+                            action: 'complete',
+                            variables: ${variables},
+                            ${bodyParams}
+                        }
+                    }`;
+                } else if (node.action === 'getList') {
+                    params = `{
+                        body: {
+                            processDefinitionKey: '${node.processDefinitionKey}',
+                            processInstanceId: ${safeGenerate(node.processInstanceId)},
+                            includeProcessVariables: true,
+                            sort: 'startTime',
+                            order: 'desc',
+                            finished: ${node.finished},
+                            ${bodyParams}
+                        },
+                    }`;
+                } else if (node.action === 'get') {
+                    params = `{
+                        path: {
+                            taskId: '${pathObj.taskId || safeGenerate(node.taskId)}',
+                        },
+                    }`;
+                } else if (node.action === 'getProcessInstanceList') {
+                    params = `{
+                        body: {
+                            processDefinitionKey: '${node.processDefinitionKey}',
+                            includeProcessVariables: true,
+                            sort: 'startTime',
+                            order: 'desc',
+                            finished: ${node.finished},
+                            startedBy: ${safeGenerate(node.startedBy)},
+                            ${bodyParams}
+                        }
+                    }`;
+                } else if (node.action === 'getProcessInstance') {
+                    params = `{
+                        path: {
+                            processInstanceId: ${pathObj.processInstanceId || safeGenerate(node.processInstanceId)},
+                        },
+                    }`;
+                } else if (node.action === 'updateVariables') {
+                    params = `{
+                        path: {
+                            processInstanceId: ${pathObj.processInstanceId || safeGenerate(node.processInstanceId)},
+                        },
+                        body: ${bodyObj.variables || variables || '{}'},
+                    }`;
+                }
+
+                Object.assign(node, {
+                    type: 'AwaitExpression',
+                    argument: babel.parse(
+                        `this.$services.process.${node.action}(${params})`,
+                        { filename: 'file.js' },
+                    ).program.body[0].expression,
+                });
+            } else if (node.type === 'CallMessageShow') {
+                checkThis(node.arguments[0]);
+                Object.assign(
+                    node,
+                    babel.parse(`this.$toast.show()`, { filename: 'file.js' }).program.body[0].expression,
+                    { arguments: node.arguments },
+                );
+            } else if (node.type === 'CallConsoleLog') {
+                checkThis(node.arguments[0]);
+                Object.assign(
+                    node,
+                    babel.parse(`console.log()`, { filename: 'file.js' }).program.body[0].expression,
+                    { arguments: node.arguments },
+                );
+            } else if (node.type === 'Destination') {
+                const params = (node.params || [])
+                    .filter((param) => param.pageParamKey && param.pageParamKeyValue)
+                    .map((param) => {
+                        utils.traverse((current) => {
+                            if (current.node.type === 'Identifier') {
+                                current.node.name = current.node.code || current.node.name;
+                            }
+                        }, { node: param.pageParamKeyValue }, { mode: 'anyObject' });
+                        const value = safeGenerate(param.pageParamKeyValue);
+                        if (param.pageParamKeyValue.type === 'StringLiteral' || param.pageParamKeyValue.type === 'NumericLiteral') {
+                            return safeCodeParamKey(param.pageParamKey) + '=' + param.pageParamKeyValue.value;
+                        } else {
+                            return safeCodeParamKey(param.pageParamKey) + '=${' + value + '}';
+                        }
+                    });
+                let url = node.url;
+                if (params.length) {
+                    url = '`' + `${node.code}?${params.join('&')}` + '`';
+                } else {
+                    url = '`' + `${url}` + '`';
+                }
+                Object.assign(
+                    node,
+                    babel.parse(`this.$destination(${url})`, { filename: 'file.js' }).program.body[0].expression,
+                );
+            } else if (node.type === 'IfStatement') {
+                checkThis(node.test);
+                if (Array.isArray(node.consequent)) {
+                    node.consequent = {
+                        type: 'BlockStatement',
+                        body: node.consequent,
+                    };
+                }
+                if (Array.isArray(node.alternate)) {
+                    node.alternate = {
+                        type: 'BlockStatement',
+                        body: node.alternate,
+                    };
+                }
+            } else if (node.type === 'WhileStatement') {
+                checkThis(node.test);
+                if (Array.isArray(node.body)) {
+                    node.body = {
+                        type: 'BlockStatement',
+                        body: node.body,
+                    };
+                }
+            } else if (node.type === 'SwitchStatement') {
+                Object.assign(node, switchCase2If(node.cases));
+                delete node.cases;
+            } else if (node.type === 'ForEachStatement') {
+                const forEach = babel.parse(
+                    `for (let ${node.index.name} = start; ${node.index.name} < list.length; ${node.index.name}++) {
+                    const ${node.item.name} = list[${node.index.name}];
+                }`,
+                    { filename: 'file.js' },
+                ).program.body[0];
+
+                checkThis(node.start);
+                checkThis(node.end);
+                forEach.init.declarations[0].init = node.start;
+                forEach.test.right = node.end;
+                forEach.body.body[0].declarations[0].init.object = node.each;
+                forEach.body.body[0].declarations[0].init.property = node.index;
+                forEach.body.body.push(...node.body);
+                Object.assign(node, forEach);
+            } else if (node.type === 'JSONSerialize') {
+                checkThis(node.arguments[0]);
+                Object.assign(
+                    node,
+                    babel.parse(`JSON.stringify()`, { filename: 'file.js' }).program
+                        .body[0].expression,
+                    {
+                        arguments: node.arguments,
+                    },
+                );
+            } else if (node.type === 'JSONDeserialize') {
+                checkThis(node.arguments[0]);
+                Object.assign(
+                    node,
+                    babel.parse(`JSON.parse()`, { filename: 'file.js' }).program.body[0]
+                        .expression,
+                    {
+                        arguments: node.arguments,
+                    },
+                );
+            } else if (node.type === 'RaiseException') {
+                checkThis(node.arguments[0]);
+                const throwStatement = babel.parse(`throw new Error()`, {
+                    filename: 'file.js',
+                }).program.body[0];
+                throwStatement.argument.arguments = node.arguments;
+                Object.assign(node, throwStatement);
+            } else if (node.type === 'JSBlock') {
+                Object.assign(
+                    node,
+                    babel.parse(
+                        `{
+                        const jsBlock_${index} = async () => {
+                            ${node.code}
+                        }
+                    
+                        await jsBlock_${index}();
+                    }`,
+                        {
+                            filename: 'file.js',
+                            parserOpts: {
+                                allowAwaitOutsideFunction: true,
+                            },
+                        },
+                    ).program.body[0],
+                );
+            }
+        });
+
+        // console.info("JSON generate:", JSON.stringify(logic.body));
+        // console.log(generate({ type: 'Program', body: logic.body }).code);
+
+        return `methods['${logic.name}'] = async function (${logic.params.map((param) => param.name).join(', ')}) {
+            ${logic.params.length ? logic.params.map((param) => {
+        return `${param.name} = ${param.name} !== undefined ? ${param.name} : this.$genInitFromSchema(${JSON.stringify(param.schema)}, ${JSON.stringify(param.defaultValue)});`;
+    }).join('\n') + '' : ''}
+            ${logic.variables.length ? logic.variables.map((variable) => {
+        return `let ${variable.name} = this.$genInitFromSchema(${JSON.stringify(variable.schema)}, ${JSON.stringify(variable.defaultValue)});`;
+    }).join('\n') + '' : ''}
+            let ${returnObj.name} = this.$genInitFromSchema(${JSON.stringify(returnObj.schema)}, ${JSON.stringify(returnObj.defaultValue)});
+            ${generate({ type: 'Program', body: logic.body }).code}
+        }`;
+    });
+
+    const output = `
+        const methods = componentOptions.methods = componentOptions.methods || {};
+        const computed = componentOptions.computed = componentOptions.computed || {};
+        const oldDataFunc = componentOptions.data;
+        const data = function () {
+            const oldData = oldDataFunc ? oldDataFunc.call(this) : {};
+            return Object.assign(oldData, {
+                ${paramsData ? paramsData + ',' : ''}
+                ${variablesData}
+            });
+        };
+        componentOptions.data = data;
+        const meta = componentOptions.meta = componentOptions.meta || {};
+        Object.assign(meta, {
+            title: ${JSON.stringify(definition.title)},
+            crumb: ${JSON.stringify(definition.crumb)},
+            first: ${JSON.stringify(definition.first)},
+        });
+
+        ${lifecycles.join('\n\n')}
+
+        ${methods.join('\n\n')}
+    `;
+
+    return output;
+}

package/src/types/login.ts

@@ -0,0 +1,36 @@
+import config from './config';
+import axios from 'axios';
+
+/**
+ * 便捷登录，只支持普通登录
+ * @required 需要先配置好 config.baseURL
+ * @param username 用户名
+ * @param password 密码
+ */
+ export default async function login(username: string, password: string) {
+    const hostname = config.baseURL.split('/')[2];
+    const parts = hostname.split('.');
+
+    const res = await axios({
+        baseURL: config.baseURL,
+        params: { Action: 'Login', Version: '2020-06-01' },
+        method: 'POST',
+        url: '/proxy/nuims/gateway/nuims/nuims',
+        data: {
+          DomainName: 'low-code',
+          LoginType: 'Normal',
+          TenantName: parts[0],
+          UserName: username,
+          Password: password,
+        },
+        headers: {
+          Env: 'online',
+          'Content-Type': 'application/json;charset=UTF-8',
+        },
+        withCredentials: false
+    });
+
+    config.cookie = 'authorization=' + res.headers.authorization;
+    
+    return res.data && res.data.Data;
+}