vue-ant-patterns/biz-lib/b-search-helper/SearchHelper.js

vue-ant-patterns

'use strict';

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

var _typeof2 = require('babel-runtime/helpers/typeof');

var _typeof3 = _interopRequireDefault(_typeof2);

var _defineProperty2 = require('babel-runtime/helpers/defineProperty');

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

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

var _extends3 = _interopRequireDefault(_extends2);

var _antDesignVue = require('ant-design-vue');

var _basicProps = require('./basicProps');

var _basicProps2 = _interopRequireDefault(_basicProps);

var _modalContent = require('./modalContent');

var _modalContent2 = _interopRequireDefault(_modalContent);

var _vueTypes = require('ant-design-vue/lib/_util/vue-types');

var _vueTypes2 = _interopRequireDefault(_vueTypes);

var _propsUtil = require('ant-design-vue/lib/_util/props-util');

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

var _request2 = _interopRequireDefault(_request);

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

var _classnames = require('classnames');

var _classnames2 = _interopRequireDefault(_classnames);

var _dModal = require('../../lib/d-modal');

var _dModal2 = _interopRequireDefault(_dModal);

var _dContainer = require('../../lib/d-container');

var _dContainer2 = _interopRequireDefault(_dContainer);

var _extend = require('extend');

var _extend2 = _interopRequireDefault(_extend);

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

var _defaultProps = require('../b-tree/defaultProps');

var _defaultProps2 = _interopRequireDefault(_defaultProps);

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

var Horizontal = _dContainer2['default'].Horizontal,
    Vertical = _dContainer2['default'].Vertical;

var Value = _vueTypes2['default'].shape({
  key: _vueTypes2['default'].oneOfType([_vueTypes2['default'].string, _vueTypes2['default'].number])
}).loose;

var API_PLATFORM = (global || window).globalJSConfig.SERVICE_CONFIG.API_PLATFORM;
var _globalJSConfig = (global || window).globalJSConfig,
    API_PREFIX = _globalJSConfig.API_PREFIX,
    API_HOST = _globalJSConfig.API_HOST;
var Option = _antDesignVue.Select.Option;

var getSelectorInfoUrl = API_PLATFORM + 'selectorInfoController/getSelectorInfo';
exports['default'] = {
  name: 'BSearchHelper',
  mixins: [_modalContent2['default']],
  props: (0, _extends3['default'])({}, _basicProps2['default'], {
    // 模式
    mode: _vueTypes2['default'].oneOf(['modal', 'page']).def('modal'),
    // ...defaultProps,
    tmpPrefixCls: _vueTypes2['default'].string.def('depot-search-helper'),
    defaultValue: _vueTypes2['default'].oneOfType([String, Object, _vueTypes2['default'].arrayOf(Object)]),
    value: _vueTypes2['default'].oneOfType([_vueTypes2['default'].string, _vueTypes2['default'].number, _vueTypes2['default'].arrayOf(_vueTypes2['default'].oneOfType([Value, _vueTypes2['default'].string, _vueTypes2['default'].number])), Value]),
    code: _vueTypes2['default'].string, // 搜索助手编码
    disabled: _vueTypes2['default'].bool, // 是否禁用
    width: _vueTypes2['default'].string, // 弹框宽度
    searchStatus: _vueTypes2['default'].oneOf(['edit', 'view']).def('edit'),
    modalType: _vueTypes2['default'].bool.def(false), // 是否是点按钮打开弹框方式
    beforeHandlerOKCallback: _vueTypes2['default']['function'],
    // 日期选项
    dateOptions: _vueTypes2['default'].object,
    // 维度
    dimensionOptions: _vueTypes2['default'].object,
    // 搜索选项默认值
    searchOptionsData: _vueTypes2['default'].object,
    // 搜索结果下拉菜单选中的查询选项
    searchSelectOptions: _vueTypes2['default'].object,

    requestParam: _vueTypes2['default'].object,
    requestSubParam: _vueTypes2['default'].object,
    rel: _defaultProps2['default'].rel,
    renderKey: _defaultProps2['default'].renderKey,
    multiple: _vueTypes2['default'].bool.def(false), // 客户化需要指定单选还是多选
    valueField: _vueTypes2['default'].string, // 客户化需要指定页面显示key
    displayField: _vueTypes2['default'].string, // 客户化需要指定页面显示name
    defcondition: _vueTypes2['default'].object, // 列表页面配置-默认条件
    customServe: _vueTypes2['default'].string, // 列表页面配置-自定义数据查询接口
    defaultParams: _vueTypes2['default'].object, // 自定义页面需要的参数
    treeSelectedKeys: _vueTypes2['default'].Array, // 树和列表形式，树选中的值
    treeOtherParams: _vueTypes2['default'].object // 树的其它参数
  }),
  data: function data() {
    var _$props = this.$props,
        value = _$props.value,
        searchStatus = _$props.searchStatus,
        rel = _$props.rel,
        renderKey = _$props.renderKey,
        valueField = _$props.valueField,
        displayField = _$props.displayField,
        defaultParams = _$props.defaultParams,
        mode = _$props.mode,
        treeSelectedKeys = _$props.treeSelectedKeys,
        treeOtherParams = _$props.treeOtherParams;

    return {
      modalVisible: false, // 是否显示弹框
      optionList: [],
      searchHelperData: {}, // 搜索助手配置
      title: null, // 搜索助手名称
      bCustomize: false,
      comUrl: null, // 客户化组件路径
      sKey: valueField, // 值属性字段
      sValue: displayField, // 显示属性字段
      cType: null, // 搜索助手类型： 树+列表1， 树2， 列表3,
      selectMode: null, // 选择模式: 0-单选， 1-多选
      listCode: null, // 列表编码

      selectedRowKeys: [],
      selectedRows: [],
      v_oldSelectedRowKeys: [], // 旧的选择项keys
      v_oldSelectedRows: [], // 旧的选择
      selectedData: [], // 选择项
      // v_inputValue: value || undefined, // ''和null要转成undefined，placeholder才会显示
      v_inputValue: undefined, // ''和null要转成undefined，placeholder才会显示
      v_status: searchStatus,
      v_viewName: '',
      s_defcondition: {
        // ouHid: '',
        // treeId: '',
      }, // 列表默认条件，用于与树关联
      s_rel: rel,
      s_renderKey: renderKey,
      s_paramObj: _defaultProps.paramObj,
      s_paramSubObj: _defaultProps.paramSubObj,
      s_searchOptions: _defaultProps.searchDefaultOps, // 查询关键词, 与查询选中节点的相关节点
      s_customTableService: null, //
      treeSelectItem: null,
      treeSelectItems: null,
      params: defaultParams, // 参数
      treeSelectedRowKeys: treeSelectedKeys || [], // 树选择的keys
      isPage: mode === 'page',
      bChanged: false, // 标记是否是内部触发的value改变，
      bFirstInitialEvent: false, // 是否第一次进入
      treeParams: treeOtherParams || {}, // 单独设置树的参数
      bChangeDate: false, // 是否可以改变日期
      bChangeDim: false // 是否可以改变组织
    };
  },

  watch: {
    searchStatus: function searchStatus(v) {
      this.v_status = v;
    },
    code: function code(val) {
      this.getSearchHelperConfig();
    },
    value: function value(val, old) {
      // 如果不是内部触发的数据改变，不调用回显接口
      if (!this.bChanged) {
        if (val) {
          this.getSelectedData(val);
        } else {
          // 清空
          this.clearSelected();
          this.setInputValue('');
        }
      } else {
        this.bChanged = false;
      }
    },
    mode: function mode(v) {
      this.isPage = v === 'page';
    }
  },
  model: {
    prop: 'value',
    event: 'change'
  },

  created: function created() {
    var value = this.$props.value;
    // 初始化有数据时候

    if (Array.isArray(value) && value.length > 0) {
      this.selectedRowKeys = value;
    } else if (typeof value === 'string' && value) {
      this.selectedRowKeys.push(value);
    }
    this.getSearchHelperConfig();
  },


  computed: {
    // 选择行
    rowSelection: function rowSelection() {
      var _this = this;
      var isSingleSelect = _this.isSingleSelect();
      return {
        type: isSingleSelect ? 'radio' : 'checkbox',
        selectedAllRows: this.selectedRows,
        selectedAllRowKeys: isSingleSelect ? this.selectedRowKeys.slice(0, 1) : this.selectedRowKeys,
        onSelectTotle: function onSelectTotle(selectedAllRowKeys, selectedAllRows, selected, changeRows) {
          _this.selectedRowKeys = selectedAllRowKeys;
          _this.selectedRows = selectedAllRows;
          if (_this.isSingleSelect()) {
            // 单选延时关闭弹框，让用户可以看到选择的项
            setTimeout(function () {
              _this.handleOk();
            }, 500);
          }
        }
      };
    }
  },

  methods: {
    // 设置搜索助手显示的值
    setInputValue: function setInputValue(val) {
      if (val && val.length === 1) {
        this.v_inputValue = val[0];
      } else {
        this.v_inputValue = val;
      }
    },

    // 设置option选项
    setSelectedRows: function setSelectedRows(val) {
      if (val) {
        if (Array.isArray(val)) {
          this.selectedRows = val;
        } else {
          this.selectedRows = JSON.parse(JSON.stringify(val));
        }
      }
    },


    /**
     * @description: 动态拼接options
     * @param {type}
     * @return:
     */
    getOptions: function getOptions() {
      var h = this.$createElement;

      var selectedItems = this.selectedRows;
      var sKey = this.sKey,
          sValue = this.sValue;

      var options = [];
      if (Array.isArray(selectedItems)) {
        // 数组类型-多选
        options = selectedItems;
      } else {
        // 对象-单选
        options.push(selectedItems);
      }
      return options.map(function (item, index) {
        return h(
          Option,
          { key: item[sKey] },
          [item[sValue]]
        );
      });
    },
    setNewSearchValue: function setNewSearchValue() {
      var _this2 = this;

      var tmpVal = [];
      if (Array.isArray(this.selectedRows)) {
        this.selectedRows.forEach(function (item, index) {
          tmpVal.push(item[_this2.sKey]);
        });
      } else {
        tmpVal.push(this.selectedRows[this.sKey]);
      }
      // this.v_inputValue  = tmpVal;
      this.setInputValue(tmpVal);
      var bIsSingleSelect = this.isSingleSelect();
      var changeVal = (0, _extends3['default'])([], tmpVal);
      // 如果是单选,返回值转成字符，多选一直是数组
      if (bIsSingleSelect && changeVal.length === 1) {
        changeVal = changeVal[0]; // 只有一条数据，不返回数组
      }
      this.bChanged = true;
      var selectedRowKeys = this.selectedRowKeys,
          selectedRows = this.selectedRows,
          sKey = this.sKey,
          sValue = this.sValue,
          treeSelectItem = this.treeSelectItem,
          treeSelectItems = this.treeSelectItems,
          treeSelectedRowKeys = this.treeSelectedRowKeys;

      this.$emit('change', changeVal, {
        selectedRowKeys: selectedRowKeys,
        selectedRows: selectedRows,
        sKey: sKey,
        sValue: sValue,
        treeSelectItem: treeSelectItem,
        treeSelectItems: treeSelectItems,
        treeSelectedRowKeys: treeSelectedRowKeys
      });
      // this.$emit('change', changeVal);
    },


    // 获取搜索助手配置项
    getSearchHelperConfig: function getSearchHelperConfig() {
      var _this3 = this;

      var code = this.$props.code;

      if (code) {
        (0, _request2['default'])({
          url: getSelectorInfoUrl,
          data: {
            selectorCode: code
          }
        }).then(function (_ref) {
          var data = _ref.data;

          _this3.searchHelperData = data.data;
          _this3.setCommonData();
        });
      }
    },

    // 根据配置设置data
    setCommonData: function setCommonData() {
      var searchHelperData = this.searchHelperData;

      if ((0, _utils.isEmptyObj)(searchHelperData)) {
        return;
      }
      this.title = searchHelperData.name;
      this.bCustomize = searchHelperData.isCustomer;
      this.comUrl = searchHelperData.isCustomer ? searchHelperData.url : null;
      this.sKey = searchHelperData.valueField;
      this.sValue = searchHelperData.displayField;
      this.selectMode = searchHelperData.selectMode;
      if (!searchHelperData.isCustomer) {
        // 自定义组件不处理
        this.cType = searchHelperData.cType;
        this.listCode = searchHelperData.listCode;
        this.s_customTableService = searchHelperData.customTableService;
      }
      // 树类型的-自定义sKey, sValue
      var sKey = this.sKey,
          sValue = this.sValue;

      if (sKey === null && this.cType === 1) {
        // 只有树的情况,重新设置sKey和sValue
        this.setSkEY();
        this.setSValue();
      }

      var ids = this.$props.value;
      if (ids) {
        this.getSelectedData(ids, true);
      }
    },


    // 树类型的重新设置skey
    setSkEY: function setSkEY() {
      // 只有树的情况
      var s_rel = this.s_rel,
          searchHelperData = this.searchHelperData;
      var valueTreeRel = searchHelperData.valueTreeRel;
      // 父子节点关系数据

      var t_valueTreeRelArr = [];
      if (valueTreeRel) {
        var tmp_valueTreeRel = (0, _string.strTrim)(valueTreeRel, true).split(',');
        tmp_valueTreeRel.forEach(function (item, index) {
          if (item.split('.').length > 1) {
            t_valueTreeRelArr.push(item.split('.'));
          } else {
            t_valueTreeRelArr.push(item);
          }
        });
      } else {
        t_valueTreeRelArr = s_rel;
      }

      this.sKey = t_valueTreeRelArr[0][1];
    },


    // 树类型重新设置sValue
    setSValue: function setSValue() {
      // 处理树的显示name
      var s_renderKey = this.s_renderKey,
          searchHelperData = this.searchHelperData;
      var displayTreeField = searchHelperData.displayTreeField;

      var t_renderKey = [];
      if (displayTreeField) {
        t_renderKey = displayTreeField.split('.');
      } else {
        t_renderKey = s_renderKey;
      }
      this.sValue = t_renderKey[1];
    },


    // 根据id获取对应的数据结构用于数据的显示
    getSelectedData: function () {
      var _ref2 = (0, _asyncToGenerator3['default'])( /*#__PURE__*/_regenerator2['default'].mark(function _callee(ids) {
        var _this4 = this;

        var bFirst = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

        var searchHelperData, sKey, tmpIds, url, data, _paramObj, res, resData, resultArr, selectedRows, _sKey;

        return _regenerator2['default'].wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                searchHelperData = this.searchHelperData, sKey = this.sKey;
                tmpIds = [];

                if (Array.isArray(ids)) {
                  // tmpIds = this.isSingleSelect() ? ids[0] : ids;
                  tmpIds = ids; // 都按数组传递
                } else {
                  tmpIds.push(ids);
                }

                if (!(tmpIds.length > 0)) {
                  _context.next = 15;
                  break;
                }

                if (!(0, _utils.isEmptyObj)(searchHelperData)) {
                  _context.next = 6;
                  break;
                }

                return _context.abrupt('return');

              case 6:
                // 需要配置获取数据详情的方法
                url = this.getSelectorUrl();
                data = {};

                data.ids = tmpIds;
                _paramObj = {
                  url: url,
                  data: data
                };
                _context.next = 12;
                return (0, _request2['default'])(_paramObj);

              case 12:
                res = _context.sent;
                resData = res.data.data;
                // request({
                //   url: url,
                //   data: data,
                // }).then(({ data }) => {

                if (resData && resData.length > 0) {
                  this.$emit('propertyChange', resData, bFirst);
                  if (searchHelperData.cType === 0 || searchHelperData.cType === 2) {
                    // 有列表的需要转换下大小写
                    resultArr = [];

                    resData.map(function (value, index) {
                      resultArr.push(_this4.upperJSONKey(value));
                    });
                    this.setSelectedRows(resultArr);
                  } else {
                    this.setSelectedRows(resData);
                  }
                  // 这里应该处理下，如果没匹配到ids, 就不赋值
                  selectedRows = this.selectedRows, _sKey = this.sKey;
                  // let bFind = false;

                  selectedRows.map(function (item) {
                    if (item[_sKey] && -1 !== tmpIds.indexOf(item[_sKey])) {
                      // bFind = true;
                      _this4.setInputValue(tmpIds);
                    }
                  });
                  // if(!bFind) {
                  //   this.setInputValue(null);
                  // }
                  this.selectedRowKeys = tmpIds;
                }
                // });

              case 15:
              case 'end':
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function getSelectedData(_x2) {
        return _ref2.apply(this, arguments);
      }

      return getSelectedData;
    }(),


    // 获取回显接口地址
    getSelectorUrl: function getSelectorUrl() {
      var searchHelperData = this.searchHelperData;
      var system = searchHelperData.system,
          controlName = searchHelperData.controlName;
      // system是常数代码，不同的code代表不同的服务

      return API_HOST + system.code + '/' + API_PREFIX + controlName;
      // return system === 0 ? `${API_PLATFORM}${controlName}` : `${API_PLATFORM}${controlName}`;
    },


    // 获取树接口地址
    getTreeBaseUrl: function getTreeBaseUrl(treeControlName) {
      var searchHelperData = this.searchHelperData;
      var treeSystem = searchHelperData.treeSystem;
      // system是常数代码，不同的code代表不同的服务

      return API_HOST + treeSystem.code + '/' + API_PREFIX + treeControlName;
      // return treeSystem === 0 ? `${API_PLATFORM}${treeControlName}` : `${API_PLATFORM}${treeControlName}`;
    },


    // 大写转换
    upperJSONKey: function upperJSONKey(jsonObj) {
      var newObj = {};
      for (var key in jsonObj) {
        newObj['' + key.toUpperCase() + ''] = jsonObj[key];
        delete jsonObj[key];
      }
      return newObj;
    },

    // 自定义搜索助手输入框右侧图标
    renderSuffixIcon: function renderSuffixIcon() {
      var _this5 = this;

      var h = this.$createElement;

      var suffixIconProps = {
        'class': 'search-btn-icon',
        props: {
          disabled: this.$props.disabled
        },
        on: {
          click: function click() {
            _this5.openDialog();
          }
        }
      };
      return h(
        'd-icon-button',
        suffixIconProps,
        [h('d-icon', {
          attrs: { type: 'search' }
        })]
      );
    },

    // 弹框确定
    handleOk: function handleOk(e) {
      var _$props2 = this.$props,
          beforeHandlerOKCallback = _$props2.beforeHandlerOKCallback,
          modalType = _$props2.modalType;

      var selectedRowKeys = this.selectedRowKeys;
      var selectedRows = this.selectedRows;
      var sKey = this.sKey,
          sValue = this.sValue,
          treeSelectItem = this.treeSelectItem,
          treeSelectItems = this.treeSelectItems,
          isPage = this.isPage,
          treeSelectedRowKeys = this.treeSelectedRowKeys;

      var bResult = true;

      if (beforeHandlerOKCallback) {
        bResult = beforeHandlerOKCallback({
          selectedRowKeys: selectedRowKeys,
          selectedRows: selectedRows,
          sKey: sKey,
          sValue: sValue,
          treeSelectItem: treeSelectItem,
          treeSelectItems: treeSelectItems
        });
      }
      // 是否可以关闭弹框继续操作
      if (bResult) {
        this.$emit('select', {
          selectedRowKeys: selectedRowKeys,
          selectedRows: selectedRows,
          sKey: sKey,
          sValue: sValue,
          treeSelectItem: treeSelectItem,
          treeSelectItems: treeSelectItems,
          treeSelectedRowKeys: treeSelectedRowKeys
        });
        /**
         * 页面类型
         */
        if (isPage) {
          this.$emit('change', /* val */selectedRowKeys[0], {
            selectedRowKeys: selectedRowKeys,
            selectedRows: selectedRows,
            sKey: sKey,
            sValue: sValue,
            treeSelectItem: treeSelectItem,
            treeSelectItems: treeSelectItems,
            treeSelectedRowKeys: treeSelectedRowKeys
          });
          return { selectedRowKeys: selectedRowKeys, selectedRows: selectedRows, sKey: sKey, sValue: sValue, treeSelectItem: treeSelectItem, treeSelectItems: treeSelectItems, treeSelectedRowKeys: treeSelectedRowKeys };
        }
        this.modalVisible = false;
        this.bFirstInitialEvent = false;
        this.v_oldSelectedRows = (0, _extend2['default'])(true, [], selectedRows); // 保留一份旧的
        if (modalType === true) {
          this.clearSelected();
        } else {
          this.setNewSearchValue();
        }
      }
    },


    // 取消弹框
    handleCancel: function handleCancel(e) {
      var sKey = this.sKey,
          sValue = this.sValue,
          treeSelectItem = this.treeSelectItem,
          treeSelectItems = this.treeSelectItems,
          selectedRowKeys = this.selectedRowKeys,
          selectedRows = this.selectedRows,
          isPage = this.isPage;
      var modalType = this.$props.modalType;
      // const selectedRowKeys = this.selectedRowKeys; // this.$refs.searchHelper.value;
      // const selectedRows = this.selectedRows;

      if (isPage) {
        this.clearSelected();
        return;
      }

      if (modalType === true) {
        this.clearSelected();
      }

      this.$emit('modalCancel', { selectedRowKeys: selectedRowKeys, selectedRows: selectedRows, sKey: sKey, sValue: sValue, treeSelectItem: treeSelectItem, treeSelectItems: treeSelectItems });
      this.modalVisible = false;
      this.bFirstInitialEvent = false;
    },


    /*
    设置弹框
    单选操作-不显示确定按钮
    */
    renderModal: function renderModal() {
      var _cx;

      var h = this.$createElement;
      var _$props3 = this.$props,
          mode = _$props3.mode,
          tmpPrefixCls = _$props3.tmpPrefixCls;

      var dialogW = this.cType === 0 ? '1000px' : this.cType === 1 ? '600px' : '1000px';
      var bIsSingleSelect = this.isSingleSelect();
      var contentProps = {
        'class': (0, _classnames2['default'])((_cx = {}, (0, _defineProperty3['default'])(_cx, 'modal-single-content', bIsSingleSelect), (0, _defineProperty3['default'])(_cx, 'modal-multiple-content', !bIsSingleSelect), _cx))
      };
      var title = this.title,
          modalVisible = this.modalVisible;

      var modalProps = {
        props: {
          size: this.cType === 1 ? 'small' : 'large',
          title: title,
          visible: modalVisible,
          destroyOnClose: true,
          wrapClassName: tmpPrefixCls
        },
        on: {
          ok: this.handleOk,
          cancel: this.handleCancel
        }
      };
      if (mode === 'page') {
        return this.renderMainContent();
      }
      return h(
        _dModal2['default'],
        modalProps,
        [this.isSingleSelect() ? h(
          'div',
          { slot: 'footer' },
          [h(
            _antDesignVue.Button,
            {
              on: {
                'click': this.handleCancel
              }
            },
            ['\u53D6\u6D88']
          )]
        ) : null, this.renderMainContent()]
      );
    },


    // 显示弹框
    openDialog: function openDialog() {
      var _this6 = this;

      var v_inputValue = this.v_inputValue,
          selectedRowKeys = this.selectedRowKeys;

      if ((v_inputValue === undefined || v_inputValue.length === 0) && selectedRowKeys.length > 0) {
        // 不一致，要清空selectedRowKeys
        this.clearSelected();
      } else {
        // 如果是多选
        if (Array.isArray(v_inputValue) && v_inputValue.length > 0 && v_inputValue.length !== selectedRowKeys.length) {
          // 输入框里的值和弹框里的不一致的情况,以输入框的为准
          this.selectedRowKeys = v_inputValue;
          var v_oldSelectedRowKeys = this.v_oldSelectedRowKeys;

          this.setSelectedRows(v_oldSelectedRowKeys);
        }
      }
      this.modalVisible = true;
      setTimeout(function () {
        // 是否禁用组织树的维度和日期，默认是不禁用的
        if (_this6.bChangeDate) {
          _this6.$refs.selectorTree.setDisable('date', _this6.bChangeDate);
        }
        if (_this6.bChangeDim) {
          _this6.$refs.selectorTree.setDisable('dimension', _this6.bChangeDim);
        }
        _this6.$emit('modalShowEvent', _this6.$refs.selectorTree);
      }, 100);
    },


    /**
     * @description: 编辑状态的渲染
     * @param {type}
     * @return:
     */
    renderEditSelector: function renderEditSelector() {
      var _this7 = this,
          _cx2;

      var h = this.$createElement;
      var tmpPrefixCls = this.tmpPrefixCls,
          $listeners = this.$listeners,
          $props = this.$props,
          isPage = this.isPage;
      var multiple = $props.multiple,
          width = $props.width,
          disabled = $props.disabled,
          mode = $props.mode;

      var others = (0, _propsUtil.getOptionProps)(this);
      var selectMode = this.selectMode,
          v_inputValue = this.v_inputValue,
          sKey = this.sKey;

      var searchProps = {
        'class': tmpPrefixCls + '-container-inner',
        props: (0, _extends3['default'])({}, others, {
          showArrow: false,
          mode: multiple === true ? 'multiple' : selectMode === 1 ? 'multiple' : '',
          // mode: this.isCustomize() === false ?
          // (selectMode === 1 ? 'multiple' : '') : multiple === true ? 'multiple' : '',
          open: false, // 隐藏下拉菜单
          value: selectMode === 1 ? v_inputValue || [] : v_inputValue // 多选情况下需要默认''需要转成[]
        }),
        attrs: {
          readOnly: true
        },
        on: (0, _extends3['default'])({}, $listeners, {
          change: function change(val) {
            if (val === undefined || val === null || val.length === 0) {
              // 清空弹框里选中状态
              _this7.clearSelected();
            }
            _this7.setInputValue(val);
            _this7.bChanged = true;
            var selectedRowKeys = _this7.selectedRowKeys,
                selectedRows = _this7.selectedRows,
                sKey = _this7.sKey,
                sValue = _this7.sValue,
                treeSelectItem = _this7.treeSelectItem,
                treeSelectItems = _this7.treeSelectItems,
                treeSelectedRowKeys = _this7.treeSelectedRowKeys;

            _this7.$emit('change', val, {
              selectedRowKeys: selectedRowKeys,
              selectedRows: selectedRows,
              sKey: sKey,
              sValue: sValue,
              treeSelectItem: treeSelectItem,
              treeSelectItems: treeSelectItems,
              treeSelectedRowKeys: treeSelectedRowKeys
            });
            // this.$emit('change', val);
          },
          // 删除标签
          deselect: function deselect(value) {
            var selectedRowKeys = _this7.selectedRowKeys,
                selectedRows = _this7.selectedRows;

            _this7.$emit('deselect', value);
            selectedRows.map(function (item, index) {
              if (item[sKey] === value) {
                selectedRows.splice(index, 1);
                var newArr = selectedRowKeys.filter(function (T) {
                  return T !== value;
                });
                _this7.selectedRowKeys = newArr;
              }
            });
          }
        })
      };
      var cls = (0, _classnames2['default'])((_cx2 = {}, (0, _defineProperty3['default'])(_cx2, '' + tmpPrefixCls, 1), (0, _defineProperty3['default'])(_cx2, tmpPrefixCls + '-container', 1), (0, _defineProperty3['default'])(_cx2, 'flex', isPage), (0, _defineProperty3['default'])(_cx2, 'flex-col', isPage), (0, _defineProperty3['default'])(_cx2, 'flex-grow', isPage), _cx2));
      var wrapperDivProps = {
        'class': cls,
        style: {
          width: isPage ? '100%' : width !== undefined ? width : '100%'
        },
        on: {
          click: function click(e) {
            // 页面模式
            if (isPage) return;
            // 点击输入框也能打开弹框
            if (e.target.className !== 'ant-select-selection__rendered' && !e.target.className.includes('ant-select-selection') && e.target.className !== 'ant-select-selection__placeholder') {
              return;
            }
            _this7.openDialog();
          }
        }
      };
      return h(
        _dContainer2['default'],
        wrapperDivProps,
        [isPage ? null : h(
          _antDesignVue.Select,
          searchProps,
          [this.getOptions()]
        ), isPage ? null : this.renderSuffixIcon(), !disabled ? this.renderModal() : '']
      );
    },

    /**
     * @description: 查看状态的渲染
     * @param {type}
     * @return:
     */
    renderViewSelector: function renderViewSelector() {
      var h = this.$createElement;
      var selectedRows = this.selectedRows,
          sValue = this.sValue;

      var showName = [];
      if (selectedRows && selectedRows.length > 0) {
        showName = selectedRows.map(function (item, index) {
          return item[sValue];
        });
      }
      return h('span', [showName.join(',')]);
    },


    /**
     * @description: query string转成object
     * @param {type}
     * @return:
     */
    toQueryObject: function toQueryObject(queryString) {
      var queryObj = {};
      if (!!queryString) {
        var foo = queryString.split('&');
        for (var i = foo.length; i--;) {
          var index = foo[i].indexOf('=');
          if (index !== -1) {
            var n = foo[i].substring(0, index);
            var v = foo[i].substring(index + 1, foo[i].length);
            queryObj[n] = v;
          }
        }
      }
      return queryObj;
    },

    /**
     * @description: 设置参数
     * @param {type}
     * @return:
     */
    setParams: function setParams(value) {
      var params = {};
      if (typeof value === 'string') {
        params = this.toQueryObject(value);
      } else if ((typeof value === 'undefined' ? 'undefined' : (0, _typeof3['default'])(value)) === 'object') {
        params = value;
      }
      //
      this.params = (0, _extends3['default'])(this.params || {}, params);
    },


    /**
     * @description: 单独设置树的参数
     * @param {type}
     * @return {type}
     */
    setTreeParams: function setTreeParams(obj) {
      this.treeParams = obj;
    },

    /**
     * Params Getter & Setter
     * @returns
     */
    getParams: function getParams() {
      return this.params;
    },


    // 清空选中项
    clearSelected: function clearSelected() {
      this.selectedRows = [];
      this.selectedRowKeys = [];
      this.treeSelectedRowKeys = [];
      this.treeSelectItem = null;
      this.treeSelectItems = null;
    },

    // 组织树是否可以改变日期
    changeDate: function changeDate(bFlag) {
      this.bChangeDate = bFlag;
    },

    // 组织树是否可以改变维度
    changeDim: function changeDim(bFlag) {
      this.bChangeDim = bFlag;
    },

    // 获取对应的数据
    getData: function getData() {
      var isSingleSelect = this.isSingleSelect();
      if (isSingleSelect) {
        return this.selectedRows[0] || {};
      } else {
        return this.selectedRows;
      }
    },

    // 删除指定的key
    clearSetParams: function clearSetParams(key) {
      var tmpParams = this.params;

      if (key) {
        delete tmpParams[key];
        this.params = (0, _extends3['default'])({}, tmpParams);
      }
    }
  },

  render: function render() {
    var v_status = this.v_status,
        $props = this.$props;
    var modalType = $props.modalType;

    return modalType === false ? v_status === 'edit' ? this.renderEditSelector() : this.renderViewSelector() : this.renderModal();
  }
};