@freelog/freelog-cg-collection 1.0.0

package/src/calculator/ExpConditionCalculator.ts

@@ -0,0 +1,43 @@
+import {Calculator} from "../interface/Calculator";
+import {AssignmentClauseInfo} from "../model/AssignmentClauseInfo";
+import {VarContextCapable} from "../interface/VarContextCapable";
+import {ExpHelper} from "../helper/ExpHelper";
+import {ExpCondition} from "../model/exp-condition/ExpCondition";
+
+export class ExpConditionCalculator implements Calculator {
+
+    private expHelper: ExpHelper;
+
+    getExpValue(varObj: AssignmentClauseInfo, varContextCapable: VarContextCapable<any>): any {
+        if (varObj.expType == "expCondition") {
+            return this.generateExpConditionValue(varObj as any, varContextCapable);
+        }
+
+        throw new Error("getExpValue fail [ExpConditionCalculator]...");
+    }
+
+    generateExpConditionValue(expCondition: ExpCondition, varContextCapable: VarContextCapable<any>) {
+        let result = [];
+        // @ts-ignore
+        if (expCondition.paramList.length != 0) {
+            expCondition.paramList.forEach(param => {
+                if (param.paramConditionObj == null) {
+                    let paramV = this.expHelper.getExpValue(param.paramValueObj, varContextCapable);
+                    result.push(paramV);
+                } else {
+                    let paramC = this.expHelper.getExpValue(param.paramConditionObj, varContextCapable);
+                    if (paramC) {
+                        let paramV = this.expHelper.getExpValue(param.paramValueObj, varContextCapable);
+                        result.push(paramV);
+                    }
+                }
+            });
+        }
+
+        return result;
+    }
+
+    setExpHelper(expHelper: ExpHelper) {
+        this.expHelper = expHelper;
+    }
+}

package/src/function-executor/FunctionHandle.ts

@@ -0,0 +1,45 @@
+import {FunctionInvoke} from "../interface/FunctionInvoke";
+
+export class FunctionHandle implements FunctionInvoke {
+
+    public static functionCodeMap = {
+        "Kit.Max": "F_001",
+        "Kit.IsNull": "F_002",
+        "Kit.Array.Size": "F_003"
+    };
+
+    invokeEnable(functionName: string): boolean {
+        return functionName in FunctionHandle.functionCodeMap;
+    }
+
+    /**
+     * @param functionName 函数的全称
+     * @param args
+     */
+    invoke(functionName: string, args: any[]): any {
+        let functionCode = FunctionHandle.functionCodeMap[functionName];
+        let argsStr = "";
+        for (let i = 0; i < args.length; i++) {
+            if (i == 0) {
+                argsStr = JSON.stringify(args[i]);
+            } else {
+                argsStr = argsStr + "," + JSON.stringify(args[i]);
+            }
+        }
+        let expStr = `this.${functionCode}(${argsStr})`;
+        console.debug(`invoke 【FunctionHandle】expStr = ${expStr}`)
+        return eval(expStr);
+    }
+
+    F_001(va1, var2): any {
+        return va1 >= var2 ? va1 : var2;
+    }
+
+    F_002(va1): boolean {
+        return va1 == null;
+    }
+
+    F_003(elems): number {
+        return elems.length;
+    }
+}

package/src/function-executor/api/FunctionApiExecutor.ts

@@ -0,0 +1,11 @@
+import {FunctionInvoke} from "../../interface/FunctionInvoke";
+
+export class FunctionApiExecutor implements FunctionInvoke {
+
+    invokeEnable(functionName: string): boolean {
+        return false;
+    }
+
+    invoke(functionName: string, args: any[]): any {
+    }
+}

package/src/function-executor/fun/FunctionFunExecutor.ts

@@ -0,0 +1,31 @@
+import {FunctionInvoke} from "../../interface/FunctionInvoke";
+
+export class FunctionFunExecutor implements FunctionInvoke {
+
+    private executorsMap = new Map<string, FunctionInvoke>();
+
+    private functionNameSet = new Set<string>(["fun.addElements"]);
+
+    invokeEnable(functionName: string): boolean {
+        return this.functionNameSet.has(functionName) || this.executorsMap.has(functionName);
+    }
+
+    invoke(functionName: string, args: any[]): any {
+        switch (functionName) {
+            case "fun.addElements":
+                return this.addElements(args[0], args[1]);
+        }
+        if (this.executorsMap.has(functionName)) {
+            return this.executorsMap.get(functionName).invoke(functionName, args);
+        }
+    }
+
+    addExecutor(functionName: string, executor: FunctionInvoke) {
+        this.executorsMap.set(functionName, executor);
+    }
+
+    addElements(set: [], elems: []) {
+        set.push(...elems);
+        return set;
+    }
+}

package/src/function-executor/kit/FunctionKitExecutor.ts

@@ -0,0 +1,11 @@
+import {FunctionInvoke} from "../../interface/FunctionInvoke";
+
+export class FunctionKitExecutor implements FunctionInvoke {
+
+    invokeEnable(functionName: string): boolean {
+        return false;
+    }
+
+    invoke(functionName: string, args: any[]): any {
+    }
+}

package/src/function-executor/query/FunctionQueryExecutor.ts

@@ -0,0 +1,11 @@
+import {FunctionInvoke} from "../../interface/FunctionInvoke";
+
+export class FunctionQueryExecutor implements FunctionInvoke {
+
+    invokeEnable(functionName: string): boolean {
+        return false;
+    }
+
+    invoke(functionName: string, args: any[]): any {
+    }
+}

package/src/function-executor/time/FunctionTimeExecutor.ts

@@ -0,0 +1,11 @@
+import {FunctionInvoke} from "../../interface/FunctionInvoke";
+
+export class FunctionTimeExecutor implements FunctionInvoke {
+
+    invokeEnable(functionName: string): boolean {
+        return false;
+    }
+
+    invoke(functionName: string, args: any[]): any {
+    }
+}

package/src/helper/ExpHelper.ts

@@ -0,0 +1,66 @@
+import {ExpCalculator} from "../calculator/ExpCalculator";
+import {VarContextCapable} from "../interface/VarContextCapable";
+import {FunctionHelper} from "./FunctionHelper";
+import {ExpBooleanCalculator} from "../calculator/ExpBooleanCalculator";
+import {Calculator} from "../interface/Calculator";
+import {AssignmentClauseInfo} from "../model/AssignmentClauseInfo";
+import {ExpConditionCalculator} from "../calculator/ExpConditionCalculator";
+import {ExpArgsGroupCalculator} from "../calculator/ExpArgsGroupCalculator";
+
+export class ExpHelper implements Calculator {
+
+    private functionHelper: FunctionHelper;
+
+    private expCalculator: ExpCalculator;
+
+    private expBooleanCalculator: ExpBooleanCalculator;
+
+    private expConditionCalculator: ExpConditionCalculator;
+
+    private expArgsGroupCalculator: ExpArgsGroupCalculator;
+
+    constructor() {
+        this.expCalculator = new ExpCalculator();
+        this.expCalculator.setExpHelper(this);
+        this.expBooleanCalculator = new ExpBooleanCalculator();
+        this.expBooleanCalculator.setExpHelper(this);
+        this.expConditionCalculator = new ExpConditionCalculator();
+        this.expConditionCalculator.setExpHelper(this);
+        this.expArgsGroupCalculator = new ExpArgsGroupCalculator();
+        this.expArgsGroupCalculator.setExpHelper(this);
+    }
+
+    getExpValue(varObj: AssignmentClauseInfo, varContextCapable: VarContextCapable<any>): any {
+        switch (varObj.expType) {
+            case "expOp":
+            case "number":
+            case "string":
+            case "entity":
+            case "variableChain":
+            case "functionCall":
+            case "expParen":
+            case "expSigned":
+                console.debug(`getExpValue 【ExpCalculator】${JSON.stringify(varObj)}`);
+                return this.expCalculator.getExpValue(varObj, varContextCapable);
+            case "expBooleanOpLogic":
+            case "expBooleanOpCompare":
+            case "boolean":
+                console.debug("getExpValue 【ExpBooleanCalculator】");
+                return this.expBooleanCalculator.getExpValue(varObj, varContextCapable);
+            case "expCondition":
+                console.debug("getExpValue 【ExpConditionCalculator】");
+                return this.expConditionCalculator.getExpValue(varObj, varContextCapable);
+            case "expArgsGroup":
+                console.debug("getExpValue 【ExpArgsGroupCalculator】");
+                return this.expArgsGroupCalculator.getExpValue(varObj, varContextCapable);
+
+        }
+
+        throw new Error("getExpValue fail [ExpHelper]...");
+    }
+
+    setFunctionHelper(functionHelper: FunctionHelper) {
+        this.functionHelper = functionHelper;
+        this.expCalculator.setFunctionHelper(this.functionHelper);
+    }
+}

package/src/helper/FunctionHelper.ts

@@ -0,0 +1,97 @@
+import {FunctionCallInfo} from "../model/exp/FunctionCallInfo";
+import {FunctionInvoke} from "../interface/FunctionInvoke";
+import {FunctionHandle} from "../function-executor/FunctionHandle";
+import {ExpHelper} from "./ExpHelper";
+import {VarContextCapable} from "../interface/VarContextCapable";
+import {FunctionQueryExecutor} from "../function-executor/query/FunctionQueryExecutor";
+import {FunctionKitExecutor} from "../function-executor/kit/FunctionKitExecutor";
+import {FunctionTimeExecutor} from "../function-executor/time/FunctionTimeExecutor";
+import {FunctionFunExecutor} from "../function-executor/fun/FunctionFunExecutor";
+import {FunctionApiExecutor} from "../function-executor/api/FunctionApiExecutor";
+
+export class FunctionHelper implements FunctionInvoke {
+
+    private expCustomList: any[];
+
+    private funcHandle: FunctionHandle;
+
+    private funcExecutors: FunctionInvoke[];
+
+    private readonly functionFunExecutor: FunctionFunExecutor;
+
+    private expHelper: ExpHelper;
+
+    constructor() {
+        this.expCustomList = [];
+        this.funcHandle = new FunctionHandle();
+        this.funcExecutors = [];
+        this.funcExecutors.push(new FunctionQueryExecutor());
+        this.funcExecutors.push(new FunctionKitExecutor());
+        this.funcExecutors.push(new FunctionTimeExecutor());
+        this.functionFunExecutor = new FunctionFunExecutor();
+        this.funcExecutors.push(this.functionFunExecutor);
+        this.funcExecutors.push(new FunctionApiExecutor());
+    }
+
+    setExpCustom(expCustom) {
+        this.expCustomList.push(expCustom);
+    }
+
+    getExpCustom(functionName) {
+        let expCustomListTmp = [...this.expCustomList].reverse();
+        return expCustomListTmp.find((elem) => {
+            return elem.varName == functionName;
+        });
+    }
+
+    getFunctionValue(funcInfo: FunctionCallInfo, varContextCapable: VarContextCapable<any>): any {
+        let args = funcInfo.paramList.map(paramElem => {
+            return this.expHelper.getExpValue(paramElem.paramValueObj, varContextCapable);
+        });
+        let functionName = funcInfo.funcName;
+        if (funcInfo.varChain != null) {
+            functionName = `${funcInfo.varChain}.${functionName}`;
+        }
+
+        return this.invoke(functionName, args);
+    }
+
+    invokeEnable(functionName: string): boolean {
+        throw new Error("这是个空实现，不能被调用！");
+    }
+
+    invoke(functionName: string, args: any[]): any {
+        let expCustom = this.getExpCustom(functionName);
+        if (expCustom != null) {
+            let varContextMap = new Map();
+            for (let i = 0; i < expCustom["paramList"].length; i++) {
+                varContextMap.set(expCustom["paramList"][i], args[i]);
+            }
+            return this.expHelper.getExpValue(expCustom["varValueObj"], new class implements VarContextCapable<any> {
+                getVarContext(varName: string): any {
+                    return varContextMap.get(varName);
+                }
+            });
+        }
+
+        this.funcExecutors.forEach(funcExecutor => {
+            if (funcExecutor.invokeEnable(functionName)) {
+                return funcExecutor.invoke(functionName, args);
+            }
+        });
+
+        if (this.funcHandle.invokeEnable(functionName)) {
+            return this.funcHandle.invoke(functionName, args);
+        }
+
+        throw new Error("invoke fail [FunctionHelper]...");
+    }
+
+    addExecutor4Fun(functionName: string, executor: FunctionInvoke) {
+        this.functionFunExecutor.addExecutor(functionName, executor);
+    }
+
+    setExpHelper(expHelper: ExpHelper): void {
+        this.expHelper = expHelper;
+    }
+}

package/src/helper/PolicyHelper.ts

@@ -0,0 +1,99 @@
+import {PolicyInfo} from "../model/policy/PolicyInfo";
+import {ExpHelper} from "./ExpHelper";
+import {VarContextCapable} from "../interface/VarContextCapable";
+import {FunctionHelper} from "./FunctionHelper";
+import {Calculator} from "../interface/Calculator";
+import {AssignmentClauseInfo} from "../model/AssignmentClauseInfo";
+import {FunctionInvoke} from "../interface/FunctionInvoke";
+
+export class PolicyHelper implements VarContextCapable<any>, Calculator, FunctionInvoke {
+
+    protected policyInfo: PolicyInfo;
+
+    protected varGlobalList;
+
+    protected varMacroList;
+
+    private expHelper: ExpHelper;
+
+    private functionHelper: FunctionHelper;
+
+    constructor(policyInfo: PolicyInfo) {
+        this.policyInfo = policyInfo;
+        this.varGlobalList = [];
+        this.varMacroList = [];
+        this.expHelper = new ExpHelper();
+        this.functionHelper = new FunctionHelper();
+        this.expHelper.setFunctionHelper(this.functionHelper);
+        this.functionHelper.setExpHelper(this.expHelper);
+    }
+
+    // 在合约签约的时候，可签约条件和全局申明的变量是已经计算完毕的，在这里做这件事
+    async init(varContextCapable: VarContextCapable<any>) {
+        let varDeclarationList = this.policyInfo.varDeclarationList;
+        for (let varDeclaration of varDeclarationList) {
+            if (varDeclaration.type == "varGlobal") {
+                let value = this.expHelper.getExpValue(varDeclaration.varValueObj, varContextCapable);
+                this.getVarGlobalList().push({varName: varDeclaration.varName, varValue: value});
+            }
+            if (varDeclaration.type == "varMacro") {
+                this.varMacroList.push({varName: varDeclaration.varName, varValueObj: varDeclaration.varValueObj});
+            }
+            if (varDeclaration.type == "expCustom") {
+                this.functionHelper.setExpCustom({
+                    varName: varDeclaration.varName,
+                    paramList: varDeclaration.paramList,
+                    varValueObj: varDeclaration.varValueObj
+                });
+            }
+        }
+    }
+
+    setVarGlobal(varName: string, varValue: any) {
+        this.getVarGlobalList().push({varName, varValue});
+    }
+
+    setVarGlobalList(varGlobalList: []) {
+        this.varGlobalList = varGlobalList;
+    }
+
+    getVarGlobalList(): any[] {
+        return this.varGlobalList;
+    }
+
+    getVarContext(varName: string): any {
+        let varGlobalListTmp = [...this.getVarGlobalList()].reverse();
+        let result = varGlobalListTmp.find((elem) => {
+            return elem.varName == varName;
+        });
+        if (result != null) {
+            return result["varValue"];
+        }
+
+        let varMacroListTmp = [...this.varMacroList].reverse();
+        let resultObj = varMacroListTmp.find((elem) => {
+            return elem.varName == varName;
+        });
+        if (resultObj != null) {
+            return this.getExpValue(resultObj.varValueObj, this);
+        }
+
+        throw new Error("getVarContext fail [PolicyHelper]...");
+    }
+
+    getExpValue(varObj: AssignmentClauseInfo, varContextCapable: VarContextCapable<any>): any {
+        return this.expHelper.getExpValue(varObj, varContextCapable);
+    }
+
+    invokeEnable(functionName: string): boolean {
+        throw new Error("这是个空实现，不能被调用！");
+    }
+
+    invoke(functionName: string, args: any[]): any {
+        return this.functionHelper.invoke(functionName, args);
+    }
+
+    addExecutor4Fun(functionName: string, executor: FunctionInvoke) {
+        this.functionHelper.addExecutor4Fun(functionName, executor);
+    }
+}

package/src/interface/Calculator.ts

@@ -0,0 +1,6 @@
+import {AssignmentClauseInfo} from "../model/AssignmentClauseInfo";
+import {VarContextCapable} from "./VarContextCapable";
+
+export interface Calculator {
+    getExpValue(varObj: AssignmentClauseInfo, varContextCapable: VarContextCapable<any>): any;
+}

package/src/interface/DefaultFunctionInvoke.ts

@@ -0,0 +1,12 @@
+import {FunctionInvoke} from "./FunctionInvoke";
+
+export abstract class DefaultFunctionInvoke implements FunctionInvoke {
+
+    invoke(functionName: string, args: any[]): any {
+        throw new Error("这是个空实现，不能被调用！");
+    }
+
+    invokeEnable(functionName: string): boolean {
+        return false;
+    }
+}

package/src/interface/FunctionInvoke.ts

@@ -0,0 +1,6 @@
+export interface FunctionInvoke {
+
+    invokeEnable(functionName: string): boolean;
+
+    invoke(functionName: string, args: any[]): any;
+}

package/src/interface/VarContextCapable.ts

@@ -0,0 +1,3 @@
+export interface VarContextCapable<T> {
+    getVarContext(varName: string): T;
+}

package/src/model/AssignmentClauseInfo.ts

@@ -0,0 +1,3 @@
+export interface AssignmentClauseInfo {
+    expType: string;
+}

package/src/model/exp/EntityInfo.ts

@@ -0,0 +1,7 @@
+import {ExpAtom} from "./ExpAtom";
+
+export interface EntityInfo extends ExpAtom {
+    expType: "entity";
+    entityType: string;
+    entityName: string;
+}

package/src/model/exp/Exp.ts

@@ -0,0 +1,5 @@
+import {AssignmentClauseInfo} from "../AssignmentClauseInfo";
+
+export interface Exp extends AssignmentClauseInfo {
+
+}

package/src/model/exp/ExpAtom.ts

@@ -0,0 +1,5 @@
+import {Exp} from "./Exp";
+
+export interface ExpAtom extends Exp {
+
+}

package/src/model/exp/ExpOp.ts

@@ -0,0 +1,8 @@
+import {Exp} from "./Exp";
+
+export interface ExpOp extends Exp {
+    expType: "expOp";
+    op: "+" | "-" | "*" | "/" | "^";
+    var1: any;
+    var2: any;
+}

package/src/model/exp/ExpParen.ts

@@ -0,0 +1,6 @@
+import {ExpAtom} from "./ExpAtom";
+
+export interface ExpParen extends ExpAtom {
+    expType: "expParen";
+    var1: any;
+}

package/src/model/exp/ExpSigned.ts

@@ -0,0 +1,7 @@
+import {Exp} from "./Exp";
+
+export interface ExpSigned extends Exp {
+    expType: "expSigned";
+    symbol: "+" | "-";
+    var1: any;
+}

package/src/model/exp/FunctionCallInfo.ts

@@ -0,0 +1,13 @@
+import {Exp} from "./Exp";
+import {AssignmentClauseInfo} from "../AssignmentClauseInfo";
+
+export interface FunctionCallInfo extends Exp {
+    expType: "functionCall";
+    varChain?: string;
+    funcName: string;
+    paramList: [{
+        paramName?: string;
+        paramValue: string;
+        paramValueObj: AssignmentClauseInfo;
+    }];
+}

package/src/model/exp/NumberInfo.ts

@@ -0,0 +1,6 @@
+import {ExpAtom} from "./ExpAtom";
+
+export interface NumberInfo extends ExpAtom {
+    expType: "number";
+    value: string;
+}

package/src/model/exp/StringInfo.ts

@@ -0,0 +1,6 @@
+import {ExpAtom} from "./ExpAtom";
+
+export interface StringInfo extends ExpAtom {
+    expType: "string";
+    value: string;
+}

package/src/model/exp/VariableChainInfo.ts

@@ -0,0 +1,7 @@
+import {ExpAtom} from "./ExpAtom";
+
+export interface VariableChainInfo extends ExpAtom {
+    expType: "variableChain";
+    varType: "normal" | "context" | "event";
+    content: string;
+}

package/src/model/exp-args-group/ExpArgsGroup.ts

@@ -0,0 +1,10 @@
+import {AssignmentClauseInfo} from "../AssignmentClauseInfo";
+
+export interface ExpArgsGroup extends AssignmentClauseInfo {
+    expType: "expArgsGroup";
+    paramList: [{
+        paramName: string;
+        paramValue: string;
+        paramValueObj: any;
+    }];
+}

package/src/model/exp-boolean/BooleanInfo.ts

@@ -0,0 +1,6 @@
+import {ExpBooleanAtom} from "./ExpBooleanAtom";
+
+export interface BooleanInfo extends ExpBooleanAtom {
+    expType: "boolean";
+    value: string;
+}

package/src/model/exp-boolean/ExpBoolean.ts

@@ -0,0 +1,5 @@
+import {AssignmentClauseInfo} from "../AssignmentClauseInfo";
+
+export interface ExpBoolean extends AssignmentClauseInfo{
+
+}

package/src/model/exp-boolean/ExpBooleanAtom.ts

@@ -0,0 +1,5 @@
+import {ExpBoolean} from "./ExpBoolean";
+
+export interface ExpBooleanAtom extends ExpBoolean {
+
+}

package/src/model/exp-boolean/ExpBooleanOpCollection.ts

@@ -0,0 +1,8 @@
+import {ExpBoolean} from "./ExpBoolean";
+
+export interface ExpBooleanOpCollection extends ExpBoolean {
+    expType: "expBooleanOpCollection";
+    op: "in";
+    var1: any;
+    var2: any;
+}

package/src/model/exp-boolean/ExpBooleanOpCompare.ts

@@ -0,0 +1,9 @@
+import {ExpBoolean} from "./ExpBoolean";
+
+export interface ExpBooleanOpCompare extends ExpBoolean {
+    expType: "expBooleanOpCompare";
+    op: "less" | "before" | "lessOrEqual" | "greater" | "after" | "greaterOrEqual" | "equal" | "notEqual"
+        | "<" | "<=" | ">" | ">=" | "==" | "!=";
+    var1: any;
+    var2: any;
+}

package/src/model/exp-boolean/ExpBooleanOpLogic.ts

@@ -0,0 +1,8 @@
+import {ExpBoolean} from "./ExpBoolean";
+
+export interface ExpBooleanOpLogic extends ExpBoolean {
+    expType: "expBooleanOpLogic";
+    op: "and" | "or" | "not";
+    var1: ExpBoolean;
+    var2?: ExpBoolean;
+}

package/src/model/exp-boolean/ExpBooleanParen.ts

@@ -0,0 +1,6 @@
+import {ExpBoolean} from "./ExpBoolean";
+
+export interface ExpBooleanParen {
+    expType: "expBooleanParen";
+    var1: ExpBoolean;
+}

package/src/model/exp-collection/ExpCollection.ts

@@ -0,0 +1,10 @@
+import {AssignmentClauseInfo} from "../AssignmentClauseInfo";
+import {Exp} from "../exp/Exp";
+
+export interface ExpCollection extends AssignmentClauseInfo{
+    expType: "expCollection";
+    lSymbol:"["|"(";
+    rSymbol:"]"|")";
+    var1:Exp;
+    var2:Exp;
+}

package/src/model/exp-condition/ExpCondition.ts

@@ -0,0 +1,12 @@
+import {AssignmentClauseInfo} from "../AssignmentClauseInfo";
+import {ExpBoolean} from "../exp-boolean/ExpBoolean";
+
+export interface ExpCondition extends AssignmentClauseInfo {
+    expType: "expCondition";
+    paramList: [{
+        paramCondition?: string;
+        paramConditionObj?: ExpBoolean;
+        paramValue: string;
+        paramValueObj: any;
+    }];
+}