@freelog/freelog-cg-collection 1.2.11 → 1.2.13

package/src/tools/PolicyDecompiler.ts

@@ -0,0 +1,329 @@
+import {AudienceSection, ContractDeclarationSection, PolicyInfo, StateInfo} from "../model/policy/PolicyInfo";
+import {VarDeclarationInfo} from "../model/policy/VarDeclarationInfo";
+import {ContractDeclarationInfo} from "../model/policy/ContractDeclarationInfo";
+import {EventInfo} from "../model/policy/EventInfo";
+import {AssignmentClauseInfo} from "../model/AssignmentClauseInfo";
+import {FunctionCallInfo} from "../model/exp/FunctionCallInfo";
+import {ExpArgsGroup} from "../model/exp-args-group/ExpArgsGroup";
+import {VariableChainInfo} from "../model/exp/VariableChainInfo";
+import {ExpCondition} from "../model/exp-condition/ExpCondition";
+import {StringInfo} from "../model/exp/StringInfo";
+import {EntityInfo} from "../model/exp/EntityInfo";
+import {NumberInfo} from "../model/exp/NumberInfo";
+import {ExpBooleanOpLogic} from "../model/exp-boolean/ExpBooleanOpLogic";
+import {ExpBooleanParen} from "../model/exp-boolean/ExpBooleanParen";
+import {ExpBooleanOpCollection} from "../model/exp-boolean/ExpBooleanOpCollection";
+import {ActionFunctionCall, ActionInfo, ActionVarAssignment} from "../model/policy/ActionInfo";
+import {BooleanInfo} from "../model/exp-boolean/BooleanInfo";
+import {ExpOp} from "../model/exp/ExpOp";
+import {ExpBooleanOpCompare} from "../model/exp-boolean/ExpBooleanOpCompare";
+import {ExpParen} from "../model/exp/ExpParen";
+import {ExpSigned} from "../model/exp/ExpSigned";
+
+export class PolicyDecompiler {
+
+    static decompile(policyInfo: PolicyInfo): string {
+        let content = "";
+        content += `\n${PolicyDecompiler.decompileAudienceSection(policyInfo.audienceSection)}`;
+        if (policyInfo.contractDeclarationSection != null && policyInfo.contractDeclarationSection.contractDeclarations != null && policyInfo.contractDeclarationSection.contractDeclarations.length != 0) {
+            content += `\n${PolicyDecompiler.decompileContractDeclarationSection(policyInfo.contractDeclarationSection)}`;
+        }
+        if (policyInfo.varDeclarationList != null && policyInfo.varDeclarationList.length != 0) {
+            content += `\n${PolicyDecompiler.decompileVarDeclarationList(policyInfo.varDeclarationList)}`;
+        }
+        content += `\n${PolicyDecompiler.decompileStateMachine(policyInfo.stateMachine)}`;
+
+        return content;
+    }
+
+    static decompileAudienceSection(audienceSection: AudienceSection): string {
+        let content = "";
+        content += `FOR ${audienceSection.audiences.join(", ")}`;
+        if (audienceSection.conditions != null && audienceSection.conditions.length != 0) {
+            content += `(${PolicyDecompiler.decompileParamList(audienceSection.conditions)})`;
+        }
+        return content;
+    }
+
+    static decompileContractDeclarationSection(contractDeclarationSection: ContractDeclarationSection): string {
+        let content = "\n";
+        if (contractDeclarationSection.contractDeclarations != null && contractDeclarationSection.contractDeclarations.length != 0) {
+            content += contractDeclarationSection.contractDeclarations.map(PolicyDecompiler.decompileContractDeclaration).join("\n");
+        }
+        return content;
+    }
+
+    static decompileContractDeclaration(contractDeclarationInfo: ContractDeclarationInfo): string {
+        let content = "";
+        let varValueObj = contractDeclarationInfo.varValueObj;
+        switch (contractDeclarationInfo.type) {
+            case "contractDeclaration": {
+                content += `${varValueObj.keyword} &${varValueObj.type}(${PolicyDecompiler.decompileParamList(varValueObj.conditions)}) AS ${varValueObj.varName}`;
+                break;
+            }
+        }
+        return content;
+    }
+
+    static decompileVarDeclarationList(varDeclarationList: VarDeclarationInfo[]): string {
+        let content = "";
+        if (varDeclarationList != null && varDeclarationList.length != 0) {
+            content += "\n";
+            content += varDeclarationList.map(PolicyDecompiler.decompileVarDeclaration).join("\n");
+        }
+        return content;
+    }
+
+    static decompileVarDeclaration(varDeclaration: VarDeclarationInfo): string {
+        let content = "";
+        switch (varDeclaration.type) {
+            case "varGlobal":
+                content += `${varDeclaration.varName} = ${PolicyDecompiler.decompileAssignmentClauseInfo(varDeclaration.varValueObj)}`;
+                break;
+            case "varMacro":
+                content += `${varDeclaration.varName} <- ${PolicyDecompiler.decompileAssignmentClauseInfo(varDeclaration.varValueObj)}`;
+                break;
+            case "expCustom":
+                content += `defExpr ${varDeclaration.varName}`;
+                content += `(`;
+                if (varDeclaration.paramList != null && varDeclaration.paramList.length != 0) {
+                    content += varDeclaration.paramList.join(", ");
+                }
+                content += `)`;
+                content += ` = ${PolicyDecompiler.decompileAssignmentClauseInfo(varDeclaration.varValueObj)}`;
+                break;
+            case "varInitial":
+                content += `let ${varDeclaration.varName} = ${PolicyDecompiler.decompileAssignmentClauseInfo(varDeclaration.varValueObj)}`;
+                break;
+            case "varAssigment":
+                content = `${varDeclaration.varName} = ${PolicyDecompiler.decompileAssignmentClauseInfo(varDeclaration.varValueObj)}`;
+                break;
+        }
+        return content;
+    }
+
+    static decompileStateMachine(stateMachine: StateInfo[]): string {
+        let content = "\n";
+        content += `${stateMachine.map(this.decompileStateInfo).join("\n\n")}`;
+        return content;
+    }
+
+    static decompileStateInfo(stateInfo: StateInfo): string {
+        let content = "";
+
+        /*
+         * serviceStateSection
+         */
+        content += stateInfo.stateName;
+        if (stateInfo.serviceStateSection.serviceState != null) {
+            content += ` ${stateInfo.serviceStateSection.serviceState}`
+        }
+        if (stateInfo.serviceStateSection.serviceStateCollection != null && stateInfo.serviceStateSection.serviceStateCollection.length != 0) {
+            content += `{`;
+            content += `${stateInfo.serviceStateSection.serviceStateCollection.join(", ")}`;
+            content += `}`;
+        }
+        if (stateInfo.stateContextArgs != null && stateInfo.stateContextArgs.length != 0) {
+            content += `[`;
+            content += `${stateInfo.stateContextArgs.join(", ")}`;
+            content += `]`;
+        }
+        content += `:\n`;
+
+        /*
+         * assignments
+         */
+        if (stateInfo.assignments != null && stateInfo.assignments.length != 0) {
+            content += stateInfo.assignments.map(assignment => {
+                return `\t${PolicyDecompiler.decompileVarDeclaration(assignment)}`;
+            }).join("\n");
+            content += `\n`;
+        }
+
+        /*
+         * events
+         */
+        content += stateInfo.events.map(eventInfo => {
+            return `\t${PolicyDecompiler.decompileEventInfo(eventInfo)}`;
+        }).join("\n");
+
+        return content;
+    }
+
+    static decompileEventInfo(eventInfo: EventInfo): string {
+        let content = "";
+        if (eventInfo.type == "normal") {
+            content += `Event.`;
+            if (eventInfo.eventPath != null) {
+                content += `${eventInfo.eventPath}.`;
+            }
+            content += `${eventInfo.eventName}(${PolicyDecompiler.decompileParamList(eventInfo.eventParamList)}) -> ${eventInfo.toState}`;
+            if (eventInfo.actions != null && eventInfo.actions.length != 0) {
+                content += `{`;
+                content += eventInfo.actions.map(PolicyDecompiler.decompileActionInfo).join("; ");
+                content += `}`;
+            }
+        } else if (eventInfo.type == "terminate") {
+            content += `terminate`;
+        }
+
+        return content;
+    }
+
+    static decompileActionInfo(actionInfo: ActionInfo): string {
+        let content = "";
+        if (actionInfo.type == "functionCall") {
+            let action: ActionFunctionCall = actionInfo as any;
+            content += PolicyDecompiler.decompileAssignmentClauseInfo(action.actionObj);
+        } else if (actionInfo.type == "varAssignment") {
+            let action: ActionVarAssignment = actionInfo as any;
+            content += `${action.actionObj.varName} = ${PolicyDecompiler.decompileAssignmentClauseInfo(action.actionObj.varValueObj)}`;
+        }
+        return content;
+    }
+
+    static decompileAssignmentClauseInfo(assignmentClauseInfo: AssignmentClauseInfo): string {
+        let content = "";
+
+        if (["expOp", "number", "string", "entity", "variableChain", "functionCall", "expParen", "expSigned"].includes(assignmentClauseInfo.expType)) {
+            // 表达式
+            content += PolicyDecompiler.decompileAssignmentClauseInfo4Exp(assignmentClauseInfo);
+        } else if (["expBooleanOpLogic", "expBooleanOpCollection", "expBooleanOpCompare", "expBooleanParen", "boolean"].includes(assignmentClauseInfo.expType)) {
+            // 布尔值
+            content += PolicyDecompiler.decompileAssignmentClauseInfo4ExpBoolean(assignmentClauseInfo);
+        } else if (assignmentClauseInfo.expType == "expCondition") {
+            // 数组
+            let info: ExpCondition = assignmentClauseInfo as any;
+            content += `[`;
+            if (info.paramList != null && info.paramList.length != 0) {
+                content += info.paramList.map(paramInfo => {
+                    if (paramInfo.paramConditionObj != null) {
+                        return `${PolicyDecompiler.decompileAssignmentClauseInfo(paramInfo.paramConditionObj)} : ${PolicyDecompiler.decompileAssignmentClauseInfo(paramInfo.paramValueObj)}`;
+                    } else {
+                        return `${PolicyDecompiler.decompileAssignmentClauseInfo(paramInfo.paramValueObj)}`;
+                    }
+                }).join(", ");
+            }
+            content += `]`;
+        } else if (assignmentClauseInfo.expType == "expArgsGroup") {
+            // 对象
+            let info: ExpArgsGroup = assignmentClauseInfo as any;
+            content += `{`;
+            if (info.paramList != null && info.paramList.length != 0) {
+                content += info.paramList.map(paramInfo => {
+                    return `"${paramInfo.paramName}":${PolicyDecompiler.decompileAssignmentClauseInfo(paramInfo.paramValueObj)}`;
+                }).join(", ");
+            }
+            content += `}`;
+        }
+
+        return content;
+    }
+
+    private static decompileAssignmentClauseInfo4Exp(assignmentClauseInfo: AssignmentClauseInfo): string {
+        let content = "";
+        switch (assignmentClauseInfo.expType) {
+            // 运算
+            case  "expOp": {
+                let info: ExpOp = assignmentClauseInfo as any;
+                content += `${PolicyDecompiler.decompileAssignmentClauseInfo(info.var1)} ${info.op} ${PolicyDecompiler.decompileAssignmentClauseInfo(info.var2)}`;
+                break;
+            }
+            // 数字
+            case "number": {
+                let info: NumberInfo = assignmentClauseInfo as any;
+                content += `${info.value}`;
+                break;
+            }
+            // 字符串
+            case "string": {
+                let info: StringInfo = assignmentClauseInfo as any;
+                content += `"${info.value}"`;
+                break;
+            }
+            // 实体
+            case "entity": {
+                let info: EntityInfo = assignmentClauseInfo as any;
+                content += `${info.entityType}.<${info.entityName}>`;
+                break;
+            }
+            // 变量
+            case "variableChain": {
+                let info: VariableChainInfo = assignmentClauseInfo as any;
+                content += info.content;
+                break;
+            }
+            // 函数
+            case "functionCall": {
+                let info: FunctionCallInfo = assignmentClauseInfo as any;
+                if (info.varChain != null) {
+                    content += `${info.varChain}.`;
+                }
+                content += `${info.funcName}(${PolicyDecompiler.decompileParamList(info.paramList)})`;
+                break;
+            }// 瓜括号
+            case "expParen": {
+                let info: ExpParen = assignmentClauseInfo as any;
+                content += `(${PolicyDecompiler.decompileAssignmentClauseInfo(info.var1)})`;
+                break;
+            }
+            // 符号
+            case "expSigned": {
+                let info: ExpSigned = assignmentClauseInfo as any;
+                content += `${info.symbol}${PolicyDecompiler.decompileAssignmentClauseInfo(info.var1)}`;
+                break;
+            }
+        }
+        return content;
+    }
+
+    private static decompileAssignmentClauseInfo4ExpBoolean(assignmentClauseInfo: AssignmentClauseInfo): string {
+        let content = "";
+        switch (assignmentClauseInfo.expType) {
+            case "expBooleanOpLogic": {
+                let info: ExpBooleanOpLogic = assignmentClauseInfo as any;
+                if (info.var2 != null) {
+                    content += `${PolicyDecompiler.decompileAssignmentClauseInfo4ExpBoolean(info.var1)} ${info.op} ${PolicyDecompiler.decompileAssignmentClauseInfo4ExpBoolean(info.var2)}`;
+                } else {
+                    content += `${info.op} ${PolicyDecompiler.decompileAssignmentClauseInfo4ExpBoolean(info.var1)}`;
+                }
+                break;
+            }
+            case "expBooleanOpCollection": {
+                let info: ExpBooleanOpCollection = assignmentClauseInfo as any;
+                content += `${PolicyDecompiler.decompileAssignmentClauseInfo(info.var1)} ${info.op} ${PolicyDecompiler.decompileAssignmentClauseInfo(info.var2)}`;
+                break;
+            }
+            case "expBooleanOpCompare": {
+                let info: ExpBooleanOpCompare = assignmentClauseInfo as any;
+                content += `${PolicyDecompiler.decompileAssignmentClauseInfo(info.var1)} ${info.op} ${PolicyDecompiler.decompileAssignmentClauseInfo(info.var2)}`;
+                break;
+            }
+            case "expBooleanParen": {
+                let info: ExpBooleanParen = assignmentClauseInfo as any;
+                content += `(${this.decompileAssignmentClauseInfo4ExpBoolean(info.var1)})`;
+                break;
+            }
+            case "boolean": {
+                let info: BooleanInfo = assignmentClauseInfo as any;
+                content += `${info.value}`;
+                break;
+            }
+        }
+        return content;
+    }
+
+    static decompileParamList(paramList: { paramName?: string, paramValue: string, paramValueObj: any }[]): string {
+        let content = "";
+        if (paramList != null && paramList.length != 0) {
+            content += paramList.map(paramInfo => {
+                if (paramInfo.paramName != null) {
+                    return `${paramInfo.paramName} = ${PolicyDecompiler.decompileAssignmentClauseInfo(paramInfo.paramValueObj)}`;
+                } else {
+                    return `${PolicyDecompiler.decompileAssignmentClauseInfo(paramInfo.paramValueObj)}`;
+                }
+            }).join(", ");
+        }
+        return content;
+    }
+}

package/src/tools/PolicyMapper.ts

@@ -0,0 +1,81 @@
+import * as fs from "fs";
+
+export class PolicyMapper {
+
+    static compileResult4Old2New(compileResult): any {
+        let eventConfigs = JSON.parse(fs.readFileSync("./resources/context_config/event_configs.json", "utf-8"));
+        let eventNameMap = new Map([["TransactionEvent", "Pay"], ["RelativeTimeEvent", "Relative"], ["TimeEvent", "Schedule"]]);
+
+        let compileResultNew = {
+            audienceSection: {
+                conditions: [],
+                audiences: compileResult["audiences"].map(a => {
+                    return a["name"].toUpperCase();
+                })
+            },
+            contractDeclarationSection: {contractDeclarations: []},
+            varDeclarationList: [],
+            stateMachine: []
+        };
+        for (let stateData of Object.entries(compileResult["states"])) {
+            let stateInfo = {stateName: stateData[0], serviceStateSection: {}, events: []};
+            if (stateInfo.stateName == "initial") {
+                stateInfo.stateName = "Initial";
+            }
+            if (stateData[1]["serviceStates"].includes("active")) {
+                stateInfo.serviceStateSection["serviceState"] = "Permit";
+            }
+            if (stateData[1]["transitions"].length != 0) {
+                for (let transitionInfo of stateData[1]["transitions"]) {
+                    let eventConfig = eventConfigs.find(ec => ec["name"] == eventNameMap.get(transitionInfo["name"]));
+                    if (eventConfig == null) {
+                        continue;
+                    }
+                    let eventInfo = {
+                        type: "normal",
+                        eventName: eventConfig["name"],
+                        eventPath: eventConfig["path"],
+                        eventParamList: [],
+                        toState: transitionInfo["toState"]
+                    };
+
+                    // 参数处理
+                    for (let paramConfig of eventConfig["paramList"]) {
+                        let paramValue = transitionInfo["args"][paramConfig["name"]];
+                        if (paramValue != null) {
+                            switch (paramConfig["type"]) {
+                                case "number":
+                                    eventInfo.eventParamList.push({
+                                        // paramName: paramConfig["name"],
+                                        paramValueObj: {expType: "number", value: Number(paramValue)}
+                                    });
+                                    break;
+                                case "string":
+                                    eventInfo.eventParamList.push({
+                                        paramValueObj: {expType: "string", value: paramValue}
+                                    });
+                                    break;
+                                case "boolean":
+                                    eventInfo.eventParamList.push({
+                                        paramValueObj: {expType: "boolean", value: paramValue == "true"}
+                                    });
+                                    break;
+                            }
+                        }
+                    }
+                    // 特殊事件参数处理
+                    if (eventInfo.eventName == "Pay") {
+                        eventInfo.eventParamList.push({paramValueObj: {expType: "number", value: 1}});
+                    }
+
+                    stateInfo.events.push(eventInfo);
+                }
+            } else {
+                stateInfo.events.push({type: "terminate", eventName: "terminate"});
+            }
+            compileResultNew.stateMachine.push(stateInfo);
+        }
+
+        return compileResultNew;
+    }
+}

package/test/library/CommonTest.test.ts

@@ -1,3 +1,4 @@
+import * as fs from "fs";
 const lodash = require('lodash');
 
 describe("test/library/CommonTest.test.ts", () => {
@@ -29,8 +30,15 @@ describe("test/library/CommonTest.test.ts", () => {
         console.log(arr.filter(a => a != 1));
     });
 
+    it("encodeURIComponent", async () => {
+        // 普通 FOR%20PUBLIC%0D%0A%0D%0AInitial%20Permit%3A%0D%0A%20%20%20%20terminate
+        // 集合 FOR%20PUBLIC%0D%0A%0D%0AInitial%20Full%3A%0D%0A%20%20%20%20terminate
+        let s = fs.readFileSync("./resources/zhaojn.sc", "utf-8");
+        console.log(encodeURIComponent(s));
+    });
+
     it("decodeURIComponent", async () => {
-        let s = "mongodb%3A%2F%2Fcontract_service%3AQzA4Qzg3QTA3NDRCQTA0NDU1RUQxMjI3MTA4ODQ1MTk%3D%40dds-wz9ff825617df8e41606-pub.mongodb.rds.aliyuncs.com%3A3717%2Cdds-wz9ff825617df8e42773-pub.mongodb.rds.aliyuncs.com%3A3717%2Fcontracts_dev%3FreplicaSet%3Dmgset-82892902";
+        let s = "for%20public%0A%0Ainitial%5Bactive%5D%3A%0A%20%20terminate";
         console.log(decodeURIComponent(s));
     });
 

package/test/tools/PolicyDecompilerTest.test.ts

@@ -0,0 +1,9 @@
+import * as fs from "fs";
+import {PolicyDecompiler} from "../../src/tools/PolicyDecompiler";
+
+describe("test/tools/PolicyDecompilerTest.test.ts", () => {
+    it("decompile", async () => {
+        let source = JSON.parse(fs.readFileSync("./resources/zhaojn.json", "utf-8"));
+        console.log(PolicyDecompiler.decompile(source));
+    });
+});

package/test/tools/PolicyMapperTest.test.ts

@@ -0,0 +1,15 @@
+import * as fs from "fs";
+import {PolicyMapper} from "../../src/tools/PolicyMapper";
+import {PolicyDecompiler} from "../../src/tools/PolicyDecompiler";
+
+describe("test/tools/PolicyMapperTest.test.ts", () => {
+    it("compileResult4Old2New", async () => {
+        let source = JSON.parse(fs.readFileSync("./resources/zhaojn2.json", "utf-8"));
+
+        let compileResultNew = PolicyMapper.compileResult4Old2New(source["state_machine"]);
+
+        fs.writeFileSync("./resources/zhaojn3.json", JSON.stringify(compileResultNew, null, 4));
+
+        console.log(PolicyDecompiler.decompile(compileResultNew));
+    });
+});