agilebuilder-ui 1.0.0

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

@@ -0,0 +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
+  }
+}

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

@@ -0,0 +1,145 @@
+class CalculatorFactory {
+  constructor() {
+    if (new.target === CalculatorFactory) {
+      throw new Error('抽象类不能实例化!')
+    }
+  }
+  /**
+   * 空IS NULL操作符时相的处理
+   * @param leftVale
+   * @param operator
+   * @return
+   */
+  isNullValue(leftValue, operator) {
+    return (
+      (leftValue === undefined ||
+        leftValue === null ||
+        leftValue + '' === '') &&
+      operator === 'IS_NULL'
+    )
+  }
+  /**
+   * 空IS NOT NULL操作符时的处理
+   * @param leftVale
+   * @param operator
+   * @return true 表示给定的值不为空
+   */
+  isNotNullValue(leftValue, operator) {
+    return (
+      leftValue !== undefined &&
+      leftValue !== null &&
+      leftValue + '' !== '' &&
+      operator === 'IS_NOT_NULL'
+    )
+  }
+  /**
+   * 空值时相等的处理
+   * @param leftVale
+   * @param operator
+   * @param rightValue
+   * @return
+   */
+  isEQEmptyValue(leftVale, operator, rightValue) {
+    return (
+      (leftVale === undefined || leftVale === null || leftVale + '' === '') &&
+      (rightValue === undefined ||
+        rightValue === null ||
+        rightValue + '' === '') &&
+      (operator === 'EQ' || operator === 'CONTAIN')
+    )
+  }
+}
+
+class NumberCalculator extends CalculatorFactory {
+  constructor(leftVale, operator, rightValue) {
+    super()
+    if (this.isNotNullValue(leftVale, operator)) {
+      this.result = true
+    } else if (this.isNullValue(leftVale, operator)) {
+      this.result = true
+    } else if (this.isEQEmptyValue(leftVale, operator, rightValue)) {
+      this.result = true
+    } else if (leftVale === undefined || leftVale === null) {
+      this.result = false
+    } else {
+      const preOperand = Number(leftVale + '')
+      const value = Number(rightValue + '')
+      if (operator === 'GET') {
+        this.result = preOperand >= value
+      } else if (operator === 'LET') {
+        this.result = preOperand <= value
+      } else if (operator === 'GT') {
+        this.result = preOperand > value
+      } else if (operator === 'LT') {
+        this.result = preOperand < value
+      } else if (operator === 'NET') {
+        this.result = preOperand !== value
+      } else if (operator === 'EQ') {
+        this.result = preOperand === value
+      } else if (operator === 'IS_NULL') {
+        this.result = leftVale === undefined || leftVale === null
+      } else if (operator === 'IS_NOT_NULL') {
+        this.result = leftVale !== undefined && leftVale !== null
+      } else {
+        throw new Error(
+          '表达式不合法:' + leftVale + ' ' + operator + ' ' + rightValue
+        )
+      }
+    }
+  }
+}
+class TextCalculator extends CalculatorFactory {
+  constructor(leftVale, operator, rightValue) {
+    super()
+    if (this.isNullValue(leftVale, operator)) {
+      this.result = true
+    } else if (this.isEQEmptyValue(leftVale, operator, rightValue)) {
+      this.result = true
+    } else if (this.isNotNullValue(leftVale, operator)) {
+      this.result = true
+    } else if (leftVale === undefined || leftVale === null) {
+      this.result = false
+    } else {
+      if (operator === 'NET') {
+        this.result = leftVale !== rightValue
+      } else if (operator === 'EQ') {
+        this.result = leftVale === rightValue
+      } else if (operator === 'NOT_CONTAIN') {
+        this.result = !leftVale.includes(rightValue)
+      } else if (operator === 'CONTAIN') {
+        this.result = leftVale.includes(rightValue)
+      } else if (operator === 'IS_NULL') {
+        this.result =
+          leftVale === undefined || leftVale === null || leftVale === ''
+      } else if (operator === 'IS_NOT_NULL') {
+        this.result =
+          leftVale !== undefined && leftVale !== null && leftVale !== ''
+      } else {
+        throw new Error(
+          '表达式不合法:' + leftVale + ' ' + operator + ' ' + rightValue
+        )
+      }
+    }
+  }
+}
+
+export function getAbstractUserFactory(dataType) {
+  switch (dataType) {
+    case 'TEXT':
+      return TextCalculator
+    case 'DOUBLE':
+      return NumberCalculator
+    case 'FLOAT':
+      return NumberCalculator
+    case 'INTEGER':
+      return NumberCalculator
+    case 'LONG':
+      return NumberCalculator
+    case 'DATE':
+      return NumberCalculator
+    case 'TIME':
+      return NumberCalculator
+    default:
+      return TextCalculator
+  }
+}