vue-ant-patterns/biz-lib/b-tree/search.js

vue-ant-patterns

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

var _extend = require('extend');

var _extend2 = _interopRequireDefault(_extend);

var _bizUtils = require('../_biz-utils');

var _utils = require('../../lib/_utils');

var _utils2 = require('./utils');

var _defaultProps = require('./defaultProps');

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

/**
 * 仅用程序于拆分
 */
exports['default'] = {
  name: 'tree-search',
  methods: {
    /**
     * 从搜索结果中选中某一项
     * 根据选中项查询与其相关的父级节点
     *
     * 如果当前节点 或 其父级节点已经存在, -- 则不在去查询
     *
     * bizInvoke 业务层调用
     */
    searchSelect: function searchSelect(key, itemData) {
      var _this = this;

      var _$props = this.$props,
          rel = _$props.rel,
          searchSelectOptions = _$props.searchSelectOptions;

      var sOps = (0, _extend2['default'])(true, {}, _defaultProps.searchSelectDefaultOps, searchSelectOptions);
      var url = sOps.url,
          method = sOps.method,
          _sOps$data = sOps.data,
          data = _sOps$data === undefined ? {} : _sOps$data;
      var listData = this.listData,
          vDateUnix = this.vDateUnix,
          nowDate = this.nowDate,
          dimensionValue = this.dimensionValue;

      /**
       * 在已有的数据中找到匹配的项
       */

      var isExistCur = listData.find(function (it) {
        return key === (0, _utils.relationHandler)(rel[0], it);
      });
      var isExistParent = itemData ? listData.find(function (it) {
        return (0, _utils.relationHandler)(rel[1], it) === (0, _utils.relationHandler)(rel[0], itemData);
      }) : null;

      /**
       * 是否存在, 如果存在则不再向下执行
       * 选中节点, 并展开其父级
       * TODO:
       * 感觉这里逻辑有问题
       */
      if (isExistCur || isExistParent) {
        var cloneItem = (0, _extend2['default'])({}, isExistCur);
        this.selectCur(isExistCur);
        this.$emit('searchSelect', { key: key, itemData: cloneItem });
        return new Promise(function (resolve, reject) {
          resolve();
        });
      }
      this.$root.isLoading = true;

      var queryKey = itemData ? (0, _utils.relationHandler)(rel[0], itemData) : key;
      /**
       * 有地儿可能不用维度日期
       * 以后有需求在整理
       * 暂时来看和组织相关的都需要维度
       */
      var vData = (0, _extend2['default'])({
        dimensionId: dimensionValue,
        queryDate: vDateUnix || nowDate.valueOf()
      }, data);
      if (!vData.dimensionId) {
        vData.dimensionId = dimensionValue;
      }
      if (!vData.queryDate) {
        vData.queryDate = vDateUnix || nowDate.valueOf();
      }

      var reqParams = {
        url: url,
        method: method,
        data: (0, _extends3['default'])({}, vData, {
          hid: queryKey
        }, this.getRequestParams())
      };
      // get parent
      return (0, _bizUtils.request)(reqParams).then(function (res) {
        var resData = res.data;
        var msg = resData.msg,
            code = resData.code,
            data = resData.data;

        if (code !== 200) {
          return Promise.reject(msg);
        }
        /**
         * 不明错误, data 会有空的情况
         */
        if (!data || !data.length) return;
        data.map(function (it) {
          // const t = this.$refs.swTree.$refs.insRef.$refs.tree.domTreeNodes;
          var nodeKey = (0, _utils.relationHandler)(rel[0], it);
          // const nodeParentKey = relationHandler(rel[1], it);
          // const name = relationHandler(this.renderKey, it);
          _this.vOpenKeys = [].concat((0, _toConsumableArray3['default'])(new Set([].concat((0, _toConsumableArray3['default'])(_this.vOpenKeys), [nodeKey]))));
          // console.log(name, nodeKey, nodeParentKey);
          // if (t && t[nodeKey]) {
          //   return this.getCategoryItemChildren(t[nodeKey]);
          // }
        }).filter(function (T) {
          return T;
        });

        /**
         * 获取到匹配的节点
         */
        var matchItem = itemData || data.find(function (it) {
          var nodeKey = (0, _utils.relationHandler)(rel[0], it);
          return nodeKey === key;
        });

        _this.selectCur(matchItem);
        _this.$emit('searchSelect', { key: key, itemData: matchItem });
        return res;
      })['catch'](function (e) {
        console.error(e);
        _this.$message.error(e);
        return Promise.reject(e);
      })['finally'](function () {
        _this.$root.isLoading = false;
      });
    },

    // 查找 item 祖先节点 id
    searchGetAncestors: function searchGetAncestors(item) {
      var rel = this.$props.rel;
      var listData = this.listData;

      var parentKeys = [];
      var curID = (0, _utils.relationHandler)(rel[0], item);
      var cur_Obj = listData.find(function (it) {
        if ((0, _utils.relationHandler)(rel[0], it) === curID) {
          return it;
        }
      });

      var pid = (0, _utils.relationHandler)(rel[1], cur_Obj);
      function getParent(parentId) {
        if (!parentId || parentId === '-1' || parentId === 'null') return;
        listData.map(function (it) {
          var itemId = (0, _utils.relationHandler)(rel[0], it);
          if (itemId === parentId) {
            parentKeys.push(itemId);
            getParent((0, _utils.relationHandler)(rel[1], it));
          }
        });
      }
      getParent(pid);

      return parentKeys;
    },

    // 根据 item 选择节点, 以祖先节点
    selectCur: function selectCur(item) {
      var _$props2 = this.$props,
          multiple = _$props2.multiple,
          searchOptions = _$props2.searchOptions,
          rel = _$props2.rel;
      var vOpenKeys = this.vOpenKeys,
          vSelectedKeys = this.vSelectedKeys;


      var curKey = (0, _utils.relationHandler)(rel[0], item);
      var parentKeys = this.searchGetAncestors(item);

      this.vOpenKeys = [].concat((0, _toConsumableArray3['default'])(new Set([].concat((0, _toConsumableArray3['default'])(vOpenKeys), (0, _toConsumableArray3['default'])(parentKeys), [curKey]))));
      if (multiple) {
        this.vSelectedKeys = [].concat((0, _toConsumableArray3['default'])(new Set([].concat((0, _toConsumableArray3['default'])(vSelectedKeys), [curKey]))));
      } else {
        this.vSelectedKeys = [curKey];
      }
    }
  }
}; /*
    * @Author: w.pengfei
    * @Date: 2020-09-06 11:56:55
    * @LastEditTime: 2020-12-14 16:39:26
    * @Description: ''
    * @LastEditors: w.pengfei
    */