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

vue-ant-patterns

import _toConsumableArray from 'babel-runtime/helpers/toConsumableArray';
import _extends from 'babel-runtime/helpers/extends';
/*
 * @Author: w.pengfei
 * @Date: 2020-09-06 11:56:55
 * @LastEditTime: 2020-12-14 16:39:26
 * @Description: ''
 * @LastEditors: w.pengfei
 */
import extend from 'extend';
import { serialPromise, request } from '../_biz-utils';
import { relationHandler } from '../../es/_utils';
import { uniq, recursionDragNode } from './utils';

import { searchSelectDefaultOps } from './defaultProps';

/**
 * 仅用程序于拆分
 */
export 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 = extend(true, {}, 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 === relationHandler(rel[0], it);
      });
      var isExistParent = itemData ? listData.find(function (it) {
        return relationHandler(rel[1], it) === relationHandler(rel[0], itemData);
      }) : null;

      /**
       * 是否存在, 如果存在则不再向下执行
       * 选中节点, 并展开其父级
       * TODO:
       * 感觉这里逻辑有问题
       */
      if (isExistCur || isExistParent) {
        var cloneItem = extend({}, 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 ? relationHandler(rel[0], itemData) : key;
      /**
       * 有地儿可能不用维度日期
       * 以后有需求在整理
       * 暂时来看和组织相关的都需要维度
       */
      var vData = extend({
        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: _extends({}, vData, {
          hid: queryKey
        }, this.getRequestParams())
      };
      // get parent
      return 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 = relationHandler(rel[0], it);
          // const nodeParentKey = relationHandler(rel[1], it);
          // const name = relationHandler(this.renderKey, it);
          _this.vOpenKeys = [].concat(_toConsumableArray(new Set([].concat(_toConsumableArray(_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 = 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 = relationHandler(rel[0], item);
      var cur_Obj = listData.find(function (it) {
        if (relationHandler(rel[0], it) === curID) {
          return it;
        }
      });

      var pid = relationHandler(rel[1], cur_Obj);
      function getParent(parentId) {
        if (!parentId || parentId === '-1' || parentId === 'null') return;
        listData.map(function (it) {
          var itemId = relationHandler(rel[0], it);
          if (itemId === parentId) {
            parentKeys.push(itemId);
            getParent(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 = relationHandler(rel[0], item);
      var parentKeys = this.searchGetAncestors(item);

      this.vOpenKeys = [].concat(_toConsumableArray(new Set([].concat(_toConsumableArray(vOpenKeys), _toConsumableArray(parentKeys), [curKey]))));
      if (multiple) {
        this.vSelectedKeys = [].concat(_toConsumableArray(new Set([].concat(_toConsumableArray(vSelectedKeys), [curKey]))));
      } else {
        this.vSelectedKeys = [curKey];
      }
    }
  }
};