ze-react-component-library/lib/ZEUtil/rule.util.js

ZeroETP React Component Library

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getFilterValue = getFilterValue;
exports.revertFilterValue = revertFilterValue;
exports.treeRulesToDefaultQuery = treeRulesToDefaultQuery;
exports.queryToTreeRules = queryToTreeRules;

var _nanoid = require("nanoid");

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

var __assign = void 0 && (void 0).__assign || function () {
  __assign = Object.assign || function (t) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
      s = arguments[i];

      for (var p in s) {
        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
      }
    }

    return t;
  };

  return __assign.apply(this, arguments);
};

function getFilterValue(filter) {
  var _a;

  if (filter === null || filter === void 0 ? void 0 : filter.operator) {
    // 此时，value不存在
    if (["is null", "is not null"].includes(filter.operator)) {
      return {
        $exists: filter.operator === "is not null"
      };
    } // value一定要有


    if (!filter.value) {
      return null;
    } // 等于时，直接返回value


    if (filter.operator === "=") {
      return filter.value;
    } // 区间转换成$gte，$lte


    if (filter.operator === "between") {
      if (filter.value instanceof Array && filter.value.length > 0) {
        return {
          $gte: filter.value[0],
          $lte: filter.value[1]
        };
      }

      return null;
    } // 默认


    return _a = {}, _a[filter.operator] = filter.value, _a;
  }

  return null;
}

function revertFilterValue(filter) {
  var keys = Object.keys(filter);

  if (keys.length > 1) {
    var filters_1 = [];

    if ("$gte" in filter && "$lte" in filter) {
      filters_1.push({
        operator: "between",
        value: [filter["$gte"], filter["$lte"]]
      });
      keys.filter(function (k) {
        return !["$gte", "$lte"].includes(k);
      }).forEach(function (f) {
        var _a;

        filters_1.push(revertFilterValue((_a = {}, _a[f] = filter[f], _a)));
      });
    } else {
      keys.forEach(function (f) {
        var _a;

        filters_1.push(revertFilterValue((_a = {}, _a[f] = filter[f], _a)));
      });
    }

    return filters_1[0];
  }

  if ("$exists" in filter) {
    return {
      operator: filter["$exists"] ? "is not null" : "is null"
    };
  }

  if ("$eq" in filter) {
    return {
      operator: "=",
      value: filter["$eq"]
    };
  }

  return {
    operator: keys[0],
    value: filter[keys[0]]
  };
}

function mergeAndFilters(filters) {
  var res = {};
  filters.forEach(function (d) {
    var _a;

    var _b = Object.entries(d)[0],
        key = _b[0],
        value = _b[1];

    if (_typeof(value) === "object") {
      if (key === "$or") {
        res[key] = value;
      } else {
        res[key] = __assign(__assign({}, res[key]), value);
      }
    } else {
      res[key] = __assign(__assign({}, res[key]), (_a = {}, _a["$eq"] = value, _a));
    }
  });
  return res;
}

function treeRulesToDefaultQuery(rules) {
  return rules.map(function (d) {
    var _a, _b;

    var _c;

    if (d === null || d === void 0 ? void 0 : d.condition) {
      var children = treeRulesToDefaultQuery(d.children);

      if (children.length > 1) {
        // and时，需要合并返回
        if (d.condition === "and") {
          return mergeAndFilters(treeRulesToDefaultQuery(d.children));
        }

        return _a = {}, _a["$" + d.condition] = treeRulesToDefaultQuery(d.children), _a;
      }

      return children[0];
    }

    if ((_c = d === null || d === void 0 ? void 0 : d.props) === null || _c === void 0 ? void 0 : _c.value) {
      var filter = getFilterValue(d.props.filter);

      if (filter) {
        return _b = {}, _b[d.props.value] = filter, _b;
      }

      return null;
    }

    return null;
  }).filter(function (f) {
    return f;
  });
}

function queryToTreeRules(item) {
  if (item && _typeof(item) === "object") {
    var keys = Object.keys(item);
    var firstKey_1 = keys[0];
    var firstVal = item[firstKey_1];

    if (firstVal && _typeof(firstVal) === "object") {
      if (keys.length === 1) {
        // $or时
        if (firstKey_1 === "$or") {
          return {
            id: (0, _nanoid.nanoid)(),
            condition: firstKey_1.slice(1),
            children: firstVal === null || firstVal === void 0 ? void 0 : firstVal.map(function (d) {
              return queryToTreeRules(d);
            })
          };
        } // 不为$or时，则为单个属性


        var filter = revertFilterValue(firstVal);

        if (filter instanceof Array) {
          // 为筛选集合时，还原结构
          if (filter.length > 1) {
            return {
              id: (0, _nanoid.nanoid)(),
              condition: "and",
              children: filter.map(function (f) {
                return {
                  id: (0, _nanoid.nanoid)(),
                  props: {
                    value: firstKey_1,
                    filter: f
                  }
                };
              })
            };
          }

          return {
            id: (0, _nanoid.nanoid)(),
            props: {
              value: firstKey_1,
              filter: filter[0]
            }
          };
        }

        return {
          id: (0, _nanoid.nanoid)(),
          props: {
            value: firstKey_1,
            filter: filter
          }
        };
      } // 为属性集合时，还原结构


      return {
        id: (0, _nanoid.nanoid)(),
        condition: "and",
        children: keys.map(function (k) {
          var _a;

          return queryToTreeRules((_a = {}, _a[k] = item[k], _a));
        })
      };
    } // 操作符为等于时


    return {
      id: (0, _nanoid.nanoid)(),
      props: {
        value: firstKey_1,
        filter: {
          operator: "=",
          value: firstVal
        }
      }
    };
  }

  return item;
}