maycur-business/lib/FormChefCommon/formChefParser.js

maycur business react components of web

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _slimLodash = _interopRequireDefault(require("../utils/slimLodash"));

var _genAssociatedFormula = _interopRequireDefault(require("./genAssociatedFormula"));

var _genShareFieldFormula = _interopRequireDefault(require("./genShareFieldFormula"));

var _formulaParser = _interopRequireDefault(require("../utils/formulaParser"));

var _genFormulaFieldFormula = _interopRequireDefault(require("./genFormulaFieldFormula"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var FormChefParser = function FormChefParser() {
  var _this = this;

  _classCallCheck(this, FormChefParser);

  this.registerVariable = function (parserName) {
    var variableInfo = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    if (parserName && !_this.childParsers[parserName]) return;
    var parserCollection = parserName ? _this.childParsers[parserName] : _this.mainParser;
    if (!parserCollection.parser || !variableInfo) return;

    if (!(parserCollection.parser instanceof _formulaParser["default"])) {
      return;
    }

    var name = variableInfo.name,
        defaultValue = variableInfo.defaultValue,
        handle = variableInfo.handle,
        parent = variableInfo.parent;

    if (name) {
      if (_slimLodash["default"].has(parserCollection.variables, name)) console.log(name + '已经被注册，该行为覆盖原信息');
      parserCollection.variables[name] = {
        name: name,
        defaultValue: defaultValue,
        handle: handle,
        parent: parent
      };
      parserCollection.parser.setVariable(name, defaultValue);
    }
  };

  this.registerParser = function (name) {
    if (!_slimLodash["default"].has(_this.childParsers, name)) {
      _this.childParsers[name] = {
        name: name,
        parser: new _formulaParser["default"](),
        variables: {},
        functions: {}
      };
    }
  };

  this.registerFunction = function (parserName) {
    var functionInfo = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    if (parserName && !_this.childParsers[parserName]) return;
    var parserCollection = parserName ? _this.childParsers[parserName] : _this.mainParser;
    var parser = parserCollection.parser,
        functions = parserCollection.functions;
    if (!parser || !functionInfo) return;

    if (!(parser instanceof _formulaParser["default"])) {
      return;
    }

    var name = functionInfo.name,
        fn = functionInfo.fn;

    if (name && typeof fn === 'function') {
      if (_slimLodash["default"].has(functions, name)) console.log(name + '已经被注册，该行为覆盖原信息');
      functions[name] = {
        name: name,
        fn: fn
      };
      parser.setFunction(name, fn);
    }
  };

  this.buildFormVariable = function (variableInfo) {
    /* 定义主表单变量 */
    _slimLodash["default"].forEach(variableInfo, function (variable) {
      /* 定义表单 */
      _this.registerVariable('', variable);
    });
  };

  this.registerFormulaSet = function (name) {
    var singleFormula = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    if (!_slimLodash["default"].checkEmpty(name)) return;
    var theFormula = _this.formulaSet[name] || {
      referenceFields: [],
      rules: {}
    };
    theFormula.referenceFields = _slimLodash["default"].union(theFormula.referenceFields, [singleFormula.referField]);
    theFormula.rules[singleFormula.referField] = singleFormula.rule;
    _this.formulaSet[name] = theFormula;
  };

  this.updateParserPool = function (_ref) {
    var parser = _ref.parser,
        pool = _ref.pool;

    _this.updateParserPoolPrivate({
      parser: parser,
      pool: pool
    });
  };

  this.updateParserPoolPrivate = function (_ref2) {
    var parser = _ref2.parser,
        pool = _ref2.pool;

    if (parser instanceof _formulaParser["default"]) {
      parser.updateDataPool(pool);
    } else {
      _slimLodash["default"].forEach(pool, function (val, key) {
        var matchedVariableInfo = _this.mainParser.variables[key];

        if (val === undefined || val === null || !matchedVariableInfo) {
          return;
        }

        if (typeof matchedVariableInfo.handle === 'function') {
          pool[key] = matchedVariableInfo.handle(val);
        }
      });

      _this.mainParser.parser.updateDataPool(pool);
    }
  };

  this.genFormula = function () {
    var formula = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
    if (!formula) return;
    if (formula.length === 0) return;
    formula.forEach(function (formulaItem) {
      var rule = {
        formula: formulaItem.formula,
        canSetUndefined: formulaItem.canSetUndefined
      };

      if (_slimLodash["default"].has(formulaItem, 'updatePool')) {
        rule.updatePool = formulaItem.updatePool;
      }
      /* 是否需要私有编译器 */


      if (formulaItem.privateParser) {
        rule.parseName = formulaItem.referField;

        _this.registerParser(rule.parseName);

        _slimLodash["default"].forEach(formulaItem.registerVariables, function (varName) {
          _this.registerVariable(rule.parseName, {
            name: varName
          });
        });

        if (_slimLodash["default"].has(formulaItem, 'setFunctionList')) {
          _slimLodash["default"].forEach(formulaItem.setFunctionList, function (fn, key) {
            _this.registerFunction(rule.parseName, {
              name: key,
              fn: fn
            });
          });
        }
      }

      _this.registerFormulaSet(formulaItem.targetField, {
        referField: formulaItem.referField,
        rule: rule
      });
    });
  };

  this.triggerFormula = function (referVarName, referVarValue) {
    var formulaResult = {};
    var matchedVariableInfo = _this.mainParser.variables[referVarName];
    if (!matchedVariableInfo) return; //非法的变量不除法改变

    var variableValue = referVarValue;

    if (referVarValue === undefined || referVarValue === null) {
      if (_slimLodash["default"].has(matchedVariableInfo, 'defaultValue')) {
        variableValue = matchedVariableInfo.defaultValue;
      }
    } else if (typeof matchedVariableInfo.handle === 'function') {
      variableValue = matchedVariableInfo.handle(referVarValue);
    }

    var effectedVariables = [{
      name: referVarName,
      value: variableValue
    }];
    /* 主编译器原始变量的衍生变量 */

    _slimLodash["default"].forEach(_this.mainParser.variables, function (variableInfo, key) {
      var parent = variableInfo.parent,
          handle = variableInfo.handle;

      if (parent === referVarName && typeof handle === 'function') {
        if (!_slimLodash["default"].find(effectedVariables, function (o) {
          return o.name === key;
        })) {
          effectedVariables.push({
            name: key,
            value: handle(referVarValue, key)
          });
        }
      }
    });

    _slimLodash["default"].forEach(effectedVariables, function (data) {
      /* 更新主编译器 */
      _this.updateParserPoolPrivate({
        parser: _this.mainParser.parser,
        pool: _defineProperty({}, data.name, data.value)
      });

      _slimLodash["default"].forEach(_this.formulaSet, function (formula, key) {
        if (_slimLodash["default"].includes(formula.referenceFields, data.name)) {
          var rule = formula.rules[data.name];
          var parserCollect = rule.parseName && _this.childParsers[rule.parseName] ? _this.childParsers[rule.parseName] : _this.mainParser;
          var parser = parserCollect.parser;
          var poolValue;

          if (rule.parseName) {
            /* 私有编译器触发 更新私有updatePool*/
            poolValue = typeof rule.updatePool === 'function' ? rule.updatePool(data.value) : data.value;

            _this.updateParserPoolPrivate({
              parser: parser,
              pool: poolValue
            });
          }
        }
      });
    });

    _slimLodash["default"].forEach(effectedVariables, function (data) {
      _slimLodash["default"].forEach(_this.formulaSet, function (formula, key) {
        if (_slimLodash["default"].includes(formula.referenceFields, data.name)) {
          var rule = formula.rules[data.name];
          var parserCollect = rule.parseName && _this.childParsers[rule.parseName] ? _this.childParsers[rule.parseName] : _this.mainParser;
          var parser = parserCollect.parser;
          var result = parser.parse(rule.formula);

          if (!result.error && (rule.canSetUndefined || result.result !== undefined && result.result !== null)) {
            formulaResult[key] = result.result;
          } else {
            console.warn(result, parserCollect, rule);
          }
        }
      });
    });

    return formulaResult;
  };

  this.buildFormFormula = function (formFields) {
    var preDefinedFormulas = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
    if (formFields && formFields.length === 0) return;
    var formulaRules = preDefinedFormulas || [];
    var shareFields = [];
    /* 目前需要支持共享字段的表单元素 */

    var shareRelatedFields = ['ReceiptCrossInput', 'DeductionInput', 'FormAssociated'];
    /* 数据互联 */

    _slimLodash["default"].forEach(formFields, function (item) {
      if (item.type === 'AssociationInput') {
        var mapRules = (0, _genAssociatedFormula["default"])(item, formFields);
        formulaRules = _slimLodash["default"].union(formulaRules, mapRules);
      }
      /* 收集共享字段 */


      if (item.shared) {
        shareFields.push(item);
      }
    });
    /* 共享字段映射分配 */


    if (shareFields.length > 0) {
      _slimLodash["default"].forEach(formFields, function (item) {
        if (shareRelatedFields.includes(item.type) && item.property.isMap) {
          var mapRules = (0, _genShareFieldFormula["default"])(item, shareFields);
          formulaRules = _slimLodash["default"].union(formulaRules, mapRules);
        }
      });
    }
    /* 公式字段映射分配 */


    var formulaFieldRules = (0, _genFormulaFieldFormula["default"])(formFields);

    var _ref3 = formulaFieldRules || {},
        variableList = _ref3.variableList,
        formula = _ref3.formula;

    if (formulaFieldRules) {
      if (formula && formula.length > 0) {
        formulaRules = _slimLodash["default"].union(formulaRules, formula);
      }
    }

    _this.buildFormVariable(variableList);

    _this.genFormula(formulaRules);
  };

  this.mainParser = {
    name: 'mainForm',
    parser: new _formulaParser["default"](),
    variables: {},
    functions: {}
  };
  this.childParsers = {};
  this.formulaSet = {};
}
/* 注册变量 */
;

var _default = FormChefParser;
exports["default"] = _default;