imatrix-ui 0.2.0-up → 0.2.2-up

package/src/utils/calculator/calculator-factory-wf.js

@@ -1,558 +1,558 @@
-class CalculatorFactoryWf {
-  constructor() {
-    if (new.target === CalculatorFactoryWf) {
-      throw new Error('抽象类不能实例化!')
-    }
-  }
-  /**
-   * 空值时相等的处理
-   * @param leftVale
-   * @param operator
-   * @param rightValue
-   * @return
-   */
-  isEQEmptyValue(leftVale, operator, rightValue) {
-    const EQ = 'operator.number.eq'
-    const textEq = 'operator.text.eq'
-    const CONTAINS = 'operator.text.contain'
-    return (
-      (leftVale === undefined || leftVale === null || leftVale + '' === '') &&
-      (rightValue === undefined ||
-        rightValue === null ||
-        rightValue + '' === '') &&
-      (operator === EQ || operator === textEq || operator === CONTAINS)
-    )
-  }
-}
-
-class AmountCalculator extends CalculatorFactoryWf {
-  /**
-   *
-   * @param subExpression 二元逻辑表达式 例如：2.5 operator.text.eq.not 2.5
-   * @param dataType 数据类型
-   * @return
-   */
-  constructor(subExpression) {
-    super()
-    const NLT = 'operator.number.ge'
-    const NMT = 'operator.number.le'
-    const GT = 'operator.number.gt'
-    const LT = 'operator.number.lt'
-    const NET = 'operator.number.ne'
-    const EQ = 'operator.number.eq'
-    const textNet = 'operator.text.neq'
-    const textEq = 'operator.text.eq'
-    if (subExpression.indexOf(NLT) > 0) {
-      const operator = NLT
-      const leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      const rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      const preOperand = Number(leftOperand)
-      const value = Number(rightOperand)
-      if (preOperand === null) {
-        this.result = false
-      } else {
-        this.result = preOperand >= value
-      }
-    } else if (subExpression.indexOf(NMT) > 0) {
-      const operator = NMT
-      const leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      const rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      const preOperand = Number(leftOperand)
-      const value = Number(rightOperand)
-      if (preOperand === null) {
-        this.result = false
-      } else {
-        this.result = preOperand <= value
-      }
-    } else if (subExpression.indexOf(GT) > 0) {
-      const operator = GT
-      const leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      const rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      const preOperand = Number(leftOperand)
-      const value = Number(rightOperand)
-      if (preOperand === null) {
-        this.result = false
-      } else {
-        this.result = preOperand > value
-      }
-    } else if (subExpression.indexOf(LT) > 0) {
-      const operator = LT
-      const leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      const rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      const preOperand = Number(leftOperand)
-      const value = Number(rightOperand)
-      if (preOperand === null) {
-        this.result = false
-      } else {
-        this.result = preOperand < value
-      }
-    } else if (
-      subExpression.indexOf(NET) > 0 ||
-      subExpression.indexOf(textNet) > 0
-    ) {
-      let operator = NET
-      if (subExpression.indexOf(textNet) > 0) {
-        operator = textNet
-      }
-      const leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      const rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      const preOperand = Number(leftOperand)
-      const value = Number(rightOperand)
-      if (preOperand === null) {
-        this.result = false
-      } else {
-        this.result = preOperand !== value
-      }
-    } else if (
-      subExpression.indexOf(EQ) > 0 ||
-      subExpression.indexOf(textEq) > 0
-    ) {
-      let operator = EQ
-      if (subExpression.indexOf(textEq) > 0) {
-        operator = textEq
-      }
-      const leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      const rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      const preOperand = Number(leftOperand)
-      const value = Number(rightOperand)
-      if (this.isEQEmptyValue(preOperand, operator, value)) {
-        this.result = true
-      } else if (preOperand === null) {
-        this.result = false
-      } else {
-        this.result = preOperand === value
-      }
-    }
-  }
-}
-
-class NumberCalculator extends CalculatorFactoryWf {
-  /**
-   *
-   * @param subExpression 二元逻辑表达式 例如：2.5 operator.text.eq.not 2.5
-   * @param dataType 数据类型
-   * @return
-   */
-  constructor(subExpression) {
-    super()
-    const NLT = 'operator.number.ge'
-    const NMT = 'operator.number.le'
-    const GT = 'operator.number.gt'
-    const LT = 'operator.number.lt'
-    const NET = 'operator.number.ne'
-    const EQ = 'operator.number.eq'
-    const textNet = 'operator.text.neq'
-    const textEq = 'operator.text.eq'
-    if (subExpression.indexOf(NLT) > 0) {
-      const operator = NLT
-      let leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      let rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      if (!leftOperand) {
-        leftOperand = '0'
-      }
-      if (!rightOperand) {
-        rightOperand = '0'
-      } else {
-        rightOperand = rightOperand.replaceAll("'", '')
-      }
-      const preOperand = Number(leftOperand)
-      const value = Number(rightOperand)
-      if (preOperand === null) {
-        this.result = false
-      } else {
-        this.result = preOperand >= value
-      }
-    } else if (subExpression.indexOf(NMT) > 0) {
-      const operator = NMT
-      let leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      let rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      if (!leftOperand) {
-        leftOperand = '0'
-      }
-      if (!rightOperand) {
-        rightOperand = '0'
-      } else {
-        rightOperand = rightOperand.replaceAll("'", '')
-      }
-      const preOperand = Number(leftOperand)
-      const value = Number(rightOperand)
-      if (preOperand === null) {
-        this.result = false
-      } else {
-        this.result = preOperand <= value
-      }
-    } else if (subExpression.indexOf(GT) > 0) {
-      const operator = GT
-      let leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      let rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      if (!leftOperand) {
-        leftOperand = '0'
-      }
-      if (!rightOperand) {
-        rightOperand = '0'
-      } else {
-        rightOperand = rightOperand.replaceAll("'", '')
-      }
-      const preOperand = Number(leftOperand)
-      const value = Number(rightOperand)
-      if (preOperand === null) {
-        this.result = false
-      } else {
-        this.result = preOperand > value
-      }
-    } else if (subExpression.indexOf(LT) > 0) {
-      const operator = LT
-      let leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      let rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      if (!leftOperand) {
-        leftOperand = '0'
-      }
-      if (!rightOperand) {
-        rightOperand = '0'
-      } else {
-        rightOperand = rightOperand.replaceAll("'", '')
-      }
-      const preOperand = Number(leftOperand)
-      const value = Number(rightOperand)
-      if (preOperand === null) {
-        this.result = false
-      } else {
-        this.result = preOperand < value
-      }
-    } else if (
-      subExpression.indexOf(NET) > 0 ||
-      subExpression.indexOf(textNet) > 0
-    ) {
-      let operator = NET
-      if (subExpression.indexOf(textNet) > 0) {
-        operator = textNet
-      }
-      let leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      let rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      if (!leftOperand) {
-        leftOperand = '0'
-      }
-      if (!rightOperand) {
-        rightOperand = '0'
-      } else {
-        rightOperand = rightOperand.replaceAll("'", '')
-      }
-      const preOperand = Number(leftOperand)
-      const value = Number(rightOperand)
-      if (preOperand === null) {
-        this.result = false
-      } else {
-        this.result = preOperand !== value
-      }
-    } else if (
-      subExpression.indexOf(EQ) > 0 ||
-      subExpression.indexOf(textEq) > 0
-    ) {
-      let operator = EQ
-      if (subExpression.indexOf(textEq) > 0) {
-        operator = textEq
-      }
-      let leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      let rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      if (!leftOperand) {
-        leftOperand = '0'
-      }
-      if (!rightOperand) {
-        rightOperand = '0'
-      } else {
-        rightOperand = rightOperand.replaceAll("'", '')
-      }
-      const preOperand = Number(leftOperand)
-      const value = Number(rightOperand)
-      if (this.isEQEmptyValue(preOperand, operator, value)) {
-        this.result = true
-      } else if (preOperand === null) {
-        this.result = false
-      } else {
-        this.result = preOperand === value
-      }
-    }
-  }
-}
-
-class DateCalculator extends CalculatorFactoryWf {
-  /**
-   *
-   * @param subExpression 二元逻辑表达式 例如：2.5 operator.text.eq.not 2.5
-   * @param dataType 数据类型
-   * @return
-   */
-  constructor(subExpression, dataType) {
-    super()
-    const NLT = 'operator.date.ge'
-    const NGT = 'operator.date.le'
-    const GT = 'operator.date.gt'
-    const LT = 'operator.date.lt'
-    const NET = 'operator.date.ne'
-    const EQ = 'operator.date.et'
-    if (subExpression.indexOf(NLT) > 0) {
-      const operator = NLT
-      let leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      let rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      if (dataType && dataType === 'DATE' && leftOperand.indexOf(':') > 0) {
-        leftOperand = leftOperand.substring(0, leftOperand.indexOf(':'))
-      }
-      if (dataType && dataType === 'DATE' && rightOperand.indexOf(':') > 0) {
-        rightOperand = rightOperand.substring(0, rightOperand.indexOf(':'))
-      }
-      const preOperand = new Date(leftOperand).getTime()
-      const value = new Date(rightOperand).getTime()
-      if (preOperand === null) {
-        this.result = false
-      } else {
-        this.result = preOperand >= value
-      }
-    } else if (subExpression.indexOf(NGT) > 0) {
-      const operator = NGT
-      let leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      let rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      if (dataType && dataType === 'DATE' && leftOperand.indexOf(':') > 0) {
-        leftOperand = leftOperand.substring(0, leftOperand.indexOf(':'))
-      }
-      if (dataType && dataType === 'DATE' && rightOperand.indexOf(':') > 0) {
-        rightOperand = rightOperand.substring(0, rightOperand.indexOf(':'))
-      }
-      const preOperand = new Date(leftOperand).getTime()
-      const value = new Date(rightOperand).getTime()
-      if (preOperand === null) {
-        this.result = false
-      } else {
-        this.result = preOperand <= value
-      }
-    } else if (subExpression.indexOf(GT) > 0) {
-      const operator = GT
-      let leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      let rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      if (dataType && dataType === 'DATE' && leftOperand.indexOf(':') > 0) {
-        leftOperand = leftOperand.substring(0, leftOperand.indexOf(':'))
-      }
-      if (dataType && dataType === 'DATE' && rightOperand.indexOf(':') > 0) {
-        rightOperand = rightOperand.substring(0, rightOperand.indexOf(':'))
-      }
-      const preOperand = new Date(leftOperand).getTime()
-      const value = new Date(rightOperand).getTime()
-      if (preOperand === null) {
-        this.result = false
-      } else {
-        this.result = preOperand > value
-      }
-    } else if (subExpression.indexOf(LT) > 0) {
-      const operator = LT
-      let leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      let rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      if (dataType && dataType === 'DATE' && leftOperand.indexOf(':') > 0) {
-        leftOperand = leftOperand.substring(0, leftOperand.indexOf(':'))
-      }
-      if (dataType && dataType === 'DATE' && rightOperand.indexOf(':') > 0) {
-        rightOperand = rightOperand.substring(0, rightOperand.indexOf(':'))
-      }
-      const preOperand = new Date(leftOperand).getTime()
-      const value = new Date(rightOperand).getTime()
-      if (preOperand === null) {
-        this.result = false
-      } else {
-        this.result = preOperand < value
-      }
-    } else if (subExpression.indexOf(NET) > 0) {
-      const operator = NET
-      let leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      let rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      if (dataType && dataType === 'DATE' && leftOperand.indexOf(':') > 0) {
-        leftOperand = leftOperand.substring(0, leftOperand.indexOf(':'))
-      }
-      if (dataType && dataType === 'DATE' && rightOperand.indexOf(':') > 0) {
-        rightOperand = rightOperand.substring(0, rightOperand.indexOf(':'))
-      }
-      const preOperand = new Date(leftOperand).getTime()
-      const value = new Date(rightOperand).getTime()
-      if (preOperand === null) {
-        this.result = false
-      } else {
-        this.result = preOperand !== value
-      }
-    } else if (subExpression.indexOf(EQ) > 0) {
-      const operator = EQ
-      let leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      let rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      if (dataType && dataType === 'DATE' && leftOperand.indexOf(':') > 0) {
-        leftOperand = leftOperand.substring(0, leftOperand.indexOf(':'))
-      }
-      if (dataType && dataType === 'DATE' && rightOperand.indexOf(':') > 0) {
-        rightOperand = rightOperand.substring(0, rightOperand.indexOf(':'))
-      }
-      const preOperand = new Date(leftOperand).getTime()
-      const value = new Date(rightOperand).getTime()
-      if (this.isEQEmptyValue(preOperand, operator, value)) {
-        this.result = true
-      } else if (preOperand === null) {
-        this.result = false
-      } else {
-        this.result = preOperand === value
-      }
-    }
-  }
-}
-class TextCalculator extends CalculatorFactoryWf {
-  constructor(subExpression) {
-    super()
-    const NET = 'operator.text.neq'
-    const EQ = 'operator.text.eq'
-    const NOT_CONTAINS = 'operator.text.contain.not'
-    const CONTAINS = 'operator.text.contain'
-    if (subExpression.indexOf(NET) > 0) {
-      const operator = NET
-      const leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      const rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      if (leftOperand === null) {
-        this.result = false
-      } else {
-        this.result = leftOperand !== rightOperand
-      }
-    } else if (subExpression.indexOf(EQ) > 0) {
-      const operator = EQ
-      const leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      const rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      if (this.isEQEmptyValue(leftOperand, operator, rightOperand)) {
-        this.result = true
-      } else if (leftOperand === null) {
-        this.result = false
-      } else {
-        this.result = leftOperand === rightOperand
-      }
-    } else if (subExpression.indexOf(NOT_CONTAINS) > 0) {
-      const operator = NOT_CONTAINS
-      const leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      const rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      if (leftOperand === null) {
-        this.result = false
-      } else {
-        this.result = !leftOperand.includes(rightOperand)
-      }
-    } else if (subExpression.indexOf(CONTAINS) > 0) {
-      const operator = CONTAINS
-      const leftOperand = subExpression
-        .substring(0, subExpression.indexOf(operator))
-        .trim()
-      const rightOperand = subExpression
-        .substring(subExpression.indexOf(operator) + operator.length)
-        .trim()
-      if (this.isEQEmptyValue(leftOperand, operator, rightOperand)) {
-        this.result = true
-      } else if (leftOperand === null) {
-        this.result = false
-      } else {
-        this.result = leftOperand.includes(rightOperand)
-      }
-    }
-  }
-}
-
-export function getAbstractUserFactoryWf(dataType) {
-  switch (dataType) {
-    case 'TEXT':
-      return TextCalculator
-    case 'DOUBLE':
-      return AmountCalculator
-    case 'FLOAT':
-      return AmountCalculator
-    case 'INTEGER':
-      return NumberCalculator
-    case 'LONG':
-      return NumberCalculator
-    case 'DATE':
-      return DateCalculator
-    case 'TIME':
-      return DateCalculator
-    default:
-      return TextCalculator
-  }
-}
+class CalculatorFactoryWf {
+  constructor() {
+    if (new.target === CalculatorFactoryWf) {
+      throw new Error('抽象类不能实例化!')
+    }
+  }
+  /**
+   * 空值时相等的处理
+   * @param leftVale
+   * @param operator
+   * @param rightValue
+   * @return
+   */
+  isEQEmptyValue(leftVale, operator, rightValue) {
+    const EQ = 'operator.number.eq'
+    const textEq = 'operator.text.eq'
+    const CONTAINS = 'operator.text.contain'
+    return (
+      (leftVale === undefined || leftVale === null || leftVale + '' === '') &&
+      (rightValue === undefined ||
+        rightValue === null ||
+        rightValue + '' === '') &&
+      (operator === EQ || operator === textEq || operator === CONTAINS)
+    )
+  }
+}
+
+class AmountCalculator extends CalculatorFactoryWf {
+  /**
+   *
+   * @param subExpression 二元逻辑表达式 例如：2.5 operator.text.eq.not 2.5
+   * @param dataType 数据类型
+   * @return
+   */
+  constructor(subExpression) {
+    super()
+    const NLT = 'operator.number.ge'
+    const NMT = 'operator.number.le'
+    const GT = 'operator.number.gt'
+    const LT = 'operator.number.lt'
+    const NET = 'operator.number.ne'
+    const EQ = 'operator.number.eq'
+    const textNet = 'operator.text.neq'
+    const textEq = 'operator.text.eq'
+    if (subExpression.indexOf(NLT) > 0) {
+      const operator = NLT
+      const leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      const rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      const preOperand = Number(leftOperand)
+      const value = Number(rightOperand)
+      if (preOperand === null) {
+        this.result = false
+      } else {
+        this.result = preOperand >= value
+      }
+    } else if (subExpression.indexOf(NMT) > 0) {
+      const operator = NMT
+      const leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      const rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      const preOperand = Number(leftOperand)
+      const value = Number(rightOperand)
+      if (preOperand === null) {
+        this.result = false
+      } else {
+        this.result = preOperand <= value
+      }
+    } else if (subExpression.indexOf(GT) > 0) {
+      const operator = GT
+      const leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      const rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      const preOperand = Number(leftOperand)
+      const value = Number(rightOperand)
+      if (preOperand === null) {
+        this.result = false
+      } else {
+        this.result = preOperand > value
+      }
+    } else if (subExpression.indexOf(LT) > 0) {
+      const operator = LT
+      const leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      const rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      const preOperand = Number(leftOperand)
+      const value = Number(rightOperand)
+      if (preOperand === null) {
+        this.result = false
+      } else {
+        this.result = preOperand < value
+      }
+    } else if (
+      subExpression.indexOf(NET) > 0 ||
+      subExpression.indexOf(textNet) > 0
+    ) {
+      let operator = NET
+      if (subExpression.indexOf(textNet) > 0) {
+        operator = textNet
+      }
+      const leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      const rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      const preOperand = Number(leftOperand)
+      const value = Number(rightOperand)
+      if (preOperand === null) {
+        this.result = false
+      } else {
+        this.result = preOperand !== value
+      }
+    } else if (
+      subExpression.indexOf(EQ) > 0 ||
+      subExpression.indexOf(textEq) > 0
+    ) {
+      let operator = EQ
+      if (subExpression.indexOf(textEq) > 0) {
+        operator = textEq
+      }
+      const leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      const rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      const preOperand = Number(leftOperand)
+      const value = Number(rightOperand)
+      if (this.isEQEmptyValue(preOperand, operator, value)) {
+        this.result = true
+      } else if (preOperand === null) {
+        this.result = false
+      } else {
+        this.result = preOperand === value
+      }
+    }
+  }
+}
+
+class NumberCalculator extends CalculatorFactoryWf {
+  /**
+   *
+   * @param subExpression 二元逻辑表达式 例如：2.5 operator.text.eq.not 2.5
+   * @param dataType 数据类型
+   * @return
+   */
+  constructor(subExpression) {
+    super()
+    const NLT = 'operator.number.ge'
+    const NMT = 'operator.number.le'
+    const GT = 'operator.number.gt'
+    const LT = 'operator.number.lt'
+    const NET = 'operator.number.ne'
+    const EQ = 'operator.number.eq'
+    const textNet = 'operator.text.neq'
+    const textEq = 'operator.text.eq'
+    if (subExpression.indexOf(NLT) > 0) {
+      const operator = NLT
+      let leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      let rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      if (!leftOperand) {
+        leftOperand = '0'
+      }
+      if (!rightOperand) {
+        rightOperand = '0'
+      } else {
+        rightOperand = rightOperand.replaceAll("'", '')
+      }
+      const preOperand = Number(leftOperand)
+      const value = Number(rightOperand)
+      if (preOperand === null) {
+        this.result = false
+      } else {
+        this.result = preOperand >= value
+      }
+    } else if (subExpression.indexOf(NMT) > 0) {
+      const operator = NMT
+      let leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      let rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      if (!leftOperand) {
+        leftOperand = '0'
+      }
+      if (!rightOperand) {
+        rightOperand = '0'
+      } else {
+        rightOperand = rightOperand.replaceAll("'", '')
+      }
+      const preOperand = Number(leftOperand)
+      const value = Number(rightOperand)
+      if (preOperand === null) {
+        this.result = false
+      } else {
+        this.result = preOperand <= value
+      }
+    } else if (subExpression.indexOf(GT) > 0) {
+      const operator = GT
+      let leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      let rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      if (!leftOperand) {
+        leftOperand = '0'
+      }
+      if (!rightOperand) {
+        rightOperand = '0'
+      } else {
+        rightOperand = rightOperand.replaceAll("'", '')
+      }
+      const preOperand = Number(leftOperand)
+      const value = Number(rightOperand)
+      if (preOperand === null) {
+        this.result = false
+      } else {
+        this.result = preOperand > value
+      }
+    } else if (subExpression.indexOf(LT) > 0) {
+      const operator = LT
+      let leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      let rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      if (!leftOperand) {
+        leftOperand = '0'
+      }
+      if (!rightOperand) {
+        rightOperand = '0'
+      } else {
+        rightOperand = rightOperand.replaceAll("'", '')
+      }
+      const preOperand = Number(leftOperand)
+      const value = Number(rightOperand)
+      if (preOperand === null) {
+        this.result = false
+      } else {
+        this.result = preOperand < value
+      }
+    } else if (
+      subExpression.indexOf(NET) > 0 ||
+      subExpression.indexOf(textNet) > 0
+    ) {
+      let operator = NET
+      if (subExpression.indexOf(textNet) > 0) {
+        operator = textNet
+      }
+      let leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      let rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      if (!leftOperand) {
+        leftOperand = '0'
+      }
+      if (!rightOperand) {
+        rightOperand = '0'
+      } else {
+        rightOperand = rightOperand.replaceAll("'", '')
+      }
+      const preOperand = Number(leftOperand)
+      const value = Number(rightOperand)
+      if (preOperand === null) {
+        this.result = false
+      } else {
+        this.result = preOperand !== value
+      }
+    } else if (
+      subExpression.indexOf(EQ) > 0 ||
+      subExpression.indexOf(textEq) > 0
+    ) {
+      let operator = EQ
+      if (subExpression.indexOf(textEq) > 0) {
+        operator = textEq
+      }
+      let leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      let rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      if (!leftOperand) {
+        leftOperand = '0'
+      }
+      if (!rightOperand) {
+        rightOperand = '0'
+      } else {
+        rightOperand = rightOperand.replaceAll("'", '')
+      }
+      const preOperand = Number(leftOperand)
+      const value = Number(rightOperand)
+      if (this.isEQEmptyValue(preOperand, operator, value)) {
+        this.result = true
+      } else if (preOperand === null) {
+        this.result = false
+      } else {
+        this.result = preOperand === value
+      }
+    }
+  }
+}
+
+class DateCalculator extends CalculatorFactoryWf {
+  /**
+   *
+   * @param subExpression 二元逻辑表达式 例如：2.5 operator.text.eq.not 2.5
+   * @param dataType 数据类型
+   * @return
+   */
+  constructor(subExpression, dataType) {
+    super()
+    const NLT = 'operator.date.ge'
+    const NGT = 'operator.date.le'
+    const GT = 'operator.date.gt'
+    const LT = 'operator.date.lt'
+    const NET = 'operator.date.ne'
+    const EQ = 'operator.date.et'
+    if (subExpression.indexOf(NLT) > 0) {
+      const operator = NLT
+      let leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      let rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      if (dataType && dataType === 'DATE' && leftOperand.indexOf(':') > 0) {
+        leftOperand = leftOperand.substring(0, leftOperand.indexOf(':'))
+      }
+      if (dataType && dataType === 'DATE' && rightOperand.indexOf(':') > 0) {
+        rightOperand = rightOperand.substring(0, rightOperand.indexOf(':'))
+      }
+      const preOperand = new Date(leftOperand).getTime()
+      const value = new Date(rightOperand).getTime()
+      if (preOperand === null) {
+        this.result = false
+      } else {
+        this.result = preOperand >= value
+      }
+    } else if (subExpression.indexOf(NGT) > 0) {
+      const operator = NGT
+      let leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      let rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      if (dataType && dataType === 'DATE' && leftOperand.indexOf(':') > 0) {
+        leftOperand = leftOperand.substring(0, leftOperand.indexOf(':'))
+      }
+      if (dataType && dataType === 'DATE' && rightOperand.indexOf(':') > 0) {
+        rightOperand = rightOperand.substring(0, rightOperand.indexOf(':'))
+      }
+      const preOperand = new Date(leftOperand).getTime()
+      const value = new Date(rightOperand).getTime()
+      if (preOperand === null) {
+        this.result = false
+      } else {
+        this.result = preOperand <= value
+      }
+    } else if (subExpression.indexOf(GT) > 0) {
+      const operator = GT
+      let leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      let rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      if (dataType && dataType === 'DATE' && leftOperand.indexOf(':') > 0) {
+        leftOperand = leftOperand.substring(0, leftOperand.indexOf(':'))
+      }
+      if (dataType && dataType === 'DATE' && rightOperand.indexOf(':') > 0) {
+        rightOperand = rightOperand.substring(0, rightOperand.indexOf(':'))
+      }
+      const preOperand = new Date(leftOperand).getTime()
+      const value = new Date(rightOperand).getTime()
+      if (preOperand === null) {
+        this.result = false
+      } else {
+        this.result = preOperand > value
+      }
+    } else if (subExpression.indexOf(LT) > 0) {
+      const operator = LT
+      let leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      let rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      if (dataType && dataType === 'DATE' && leftOperand.indexOf(':') > 0) {
+        leftOperand = leftOperand.substring(0, leftOperand.indexOf(':'))
+      }
+      if (dataType && dataType === 'DATE' && rightOperand.indexOf(':') > 0) {
+        rightOperand = rightOperand.substring(0, rightOperand.indexOf(':'))
+      }
+      const preOperand = new Date(leftOperand).getTime()
+      const value = new Date(rightOperand).getTime()
+      if (preOperand === null) {
+        this.result = false
+      } else {
+        this.result = preOperand < value
+      }
+    } else if (subExpression.indexOf(NET) > 0) {
+      const operator = NET
+      let leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      let rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      if (dataType && dataType === 'DATE' && leftOperand.indexOf(':') > 0) {
+        leftOperand = leftOperand.substring(0, leftOperand.indexOf(':'))
+      }
+      if (dataType && dataType === 'DATE' && rightOperand.indexOf(':') > 0) {
+        rightOperand = rightOperand.substring(0, rightOperand.indexOf(':'))
+      }
+      const preOperand = new Date(leftOperand).getTime()
+      const value = new Date(rightOperand).getTime()
+      if (preOperand === null) {
+        this.result = false
+      } else {
+        this.result = preOperand !== value
+      }
+    } else if (subExpression.indexOf(EQ) > 0) {
+      const operator = EQ
+      let leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      let rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      if (dataType && dataType === 'DATE' && leftOperand.indexOf(':') > 0) {
+        leftOperand = leftOperand.substring(0, leftOperand.indexOf(':'))
+      }
+      if (dataType && dataType === 'DATE' && rightOperand.indexOf(':') > 0) {
+        rightOperand = rightOperand.substring(0, rightOperand.indexOf(':'))
+      }
+      const preOperand = new Date(leftOperand).getTime()
+      const value = new Date(rightOperand).getTime()
+      if (this.isEQEmptyValue(preOperand, operator, value)) {
+        this.result = true
+      } else if (preOperand === null) {
+        this.result = false
+      } else {
+        this.result = preOperand === value
+      }
+    }
+  }
+}
+class TextCalculator extends CalculatorFactoryWf {
+  constructor(subExpression) {
+    super()
+    const NET = 'operator.text.neq'
+    const EQ = 'operator.text.eq'
+    const NOT_CONTAINS = 'operator.text.contain.not'
+    const CONTAINS = 'operator.text.contain'
+    if (subExpression.indexOf(NET) > 0) {
+      const operator = NET
+      const leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      const rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      if (leftOperand === null) {
+        this.result = false
+      } else {
+        this.result = leftOperand !== rightOperand
+      }
+    } else if (subExpression.indexOf(EQ) > 0) {
+      const operator = EQ
+      const leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      const rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      if (this.isEQEmptyValue(leftOperand, operator, rightOperand)) {
+        this.result = true
+      } else if (leftOperand === null) {
+        this.result = false
+      } else {
+        this.result = leftOperand === rightOperand
+      }
+    } else if (subExpression.indexOf(NOT_CONTAINS) > 0) {
+      const operator = NOT_CONTAINS
+      const leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      const rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      if (leftOperand === null) {
+        this.result = false
+      } else {
+        this.result = !leftOperand.includes(rightOperand)
+      }
+    } else if (subExpression.indexOf(CONTAINS) > 0) {
+      const operator = CONTAINS
+      const leftOperand = subExpression
+        .substring(0, subExpression.indexOf(operator))
+        .trim()
+      const rightOperand = subExpression
+        .substring(subExpression.indexOf(operator) + operator.length)
+        .trim()
+      if (this.isEQEmptyValue(leftOperand, operator, rightOperand)) {
+        this.result = true
+      } else if (leftOperand === null) {
+        this.result = false
+      } else {
+        this.result = leftOperand.includes(rightOperand)
+      }
+    }
+  }
+}
+
+export function getAbstractUserFactoryWf(dataType) {
+  switch (dataType) {
+    case 'TEXT':
+      return TextCalculator
+    case 'DOUBLE':
+      return AmountCalculator
+    case 'FLOAT':
+      return AmountCalculator
+    case 'INTEGER':
+      return NumberCalculator
+    case 'LONG':
+      return NumberCalculator
+    case 'DATE':
+      return DateCalculator
+    case 'TIME':
+      return DateCalculator
+    default:
+      return TextCalculator
+  }
+}