yyuap-ref/dist2/RefTreeTransfer/supportComponents/leftTree.js

cloud os fe ref project which is based on tinper

'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _tree = require('../../bee/tree');

var _tree2 = _interopRequireDefault(_tree);

var _formControl = require('../../bee/form-control');

var _formControl2 = _interopRequireDefault(_formControl);

require('./leftTree.css');

var _leftTree = {
  'uTreeSearchableFilter': 'uTreeSearchableFilter__leftTree___3KnuR',
  'leftTreeWrap': 'leftTreeWrap__leftTree___1qah_',
  'leftTreeSearchStyle': 'leftTreeSearchStyle__leftTree___2WVdH',
  'leftTreeStyle': 'leftTreeStyle__leftTree___2qwaZ'
};

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

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

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var TreeNode = _tree2.default.TreeNode;

var getParentKey = function getParentKey(key, tree) {
  var parentKey = void 0;
  for (var i = 0; i < tree.length; i++) {
    var node = tree[i];
    if (node.children) {
      if (node.children.some(function (item) {
        return item.refpk === key;
      })) {
        parentKey = node.refpk;
      } else if (getParentKey(key, node.children)) {
        parentKey = getParentKey(key, node.children);
      }
    }
  }
  return parentKey;
};

var leftTree = function (_Component) {
  _inherits(leftTree, _Component);

  function leftTree(props) {
    _classCallCheck(this, leftTree);

    var _this = _possibleConstructorReturn(this, (leftTree.__proto__ || Object.getPrototypeOf(leftTree)).call(this, props));

    _this.onExpand = function (expandedKeys) {
      _this.setState({
        expandedKeys: expandedKeys,
        autoExpandParent: false
      });
    };

    _this.onChange = function (value) {
      var expandedKeys = [];
      var dataList = _this.state.dataList;
      var data = _this.props.data;

      dataList.forEach(function (item) {
        if (item.title.indexOf(value) > -1) {
          expandedKeys.push(getParentKey(item.key, data));
        }
      });
      var uniqueExpandedKeys = [];
      expandedKeys.forEach(function (item) {
        if (item && uniqueExpandedKeys.indexOf(item) === -1) {
          uniqueExpandedKeys.push(item);
        }
      });
      _this.setState({
        expandedKeys: uniqueExpandedKeys,
        searchValue: value,
        autoExpandParent: true
      });
      if (!value) {
        _this.setState({
          expandedKeys: [],
          autoExpandParent: false
        });
      }
    };

    _this.state = {
      expandedKeys: [], //记录展开节点
      searchValue: '', //记录搜索内容
      autoExpandParent: true,
      dataList: []
    };
    _this.onTreeSelect = _this.onTreeSelect.bind(_this);
    return _this;
  }

  _createClass(leftTree, [{
    key: 'componentWillReceiveProps',
    value: function componentWillReceiveProps(nextProps) {
      var dataList = [];
      var generateList = function generateList(data) {
        for (var i = 0; i < data.length; i++) {
          var node = data[i];
          var key = node.refpk;
          var title = node.refname;
          dataList.push({
            key: key,
            title: title
          });
          if (node.children) {
            generateList(node.children, node.key);
          }
        }
      };
      generateList(nextProps.data);
      this.setState({
        dataList: dataList
      });
    }
  }, {
    key: 'onTreeSelect',
    value: function onTreeSelect(selectedKeys, e) {
      if (selectedKeys.length === 0) {
        return;
      }
      ///if(e.node.props.isLeaf){
      var fullInfo = {};
      var data = this.props.data;

      var loopSearch = function loopSearch(arr, key) {
        if (!arr) {
          return;
        }
        for (var i = 0; i < arr.length; i++) {
          if (arr[i].refpk == key) {
            fullInfo = arr[i];
          } else {
            loopSearch(arr[i].children, key);
          }
        }
      };
      loopSearch(data, selectedKeys[0]);
      this.props.handleTreeSelect(fullInfo);
      // }
    }
  }, {
    key: 'render',
    value: function render() {
      var _state = this.state,
          searchValue = _state.searchValue,
          expandedKeys = _state.expandedKeys,
          autoExpandParent = _state.autoExpandParent;
      var _props = this.props,
          _props$data = _props.data,
          data = _props$data === undefined ? [] : _props$data,
          searchtext = _props.searchtext;

      var loop = function loop(data) {
        return data.map(function (item) {
          var index = item.refname.search(searchValue);
          var beforeStr = item.refname.substr(0, index);
          var afterStr = item.refname.substr(index + searchValue.length);
          var title = index > -1 ? _react2.default.createElement(
            'span',
            null,
            beforeStr,
            _react2.default.createElement(
              'span',
              { className: _leftTree.uTreeSearchableFilter },
              searchValue
            ),
            afterStr
          ) : _react2.default.createElement(
            'span',
            null,
            item.refname
          );
          if (item.children && item.children.length > 0) {
            return _react2.default.createElement(
              TreeNode,
              { key: item.refpk, title: title },
              loop(item.children)
            );
          }
          return _react2.default.createElement(TreeNode, { key: item.refpk, title: title, isLeaf: true });
        });
      };
      return _react2.default.createElement(
        'div',
        { className: _leftTree.leftTreeWrap },
        _react2.default.createElement(_formControl2.default, {
          className: _leftTree.leftTreeSearchStyle,
          placeholder: searchtext,
          onChange: this.onChange
        }),
        _react2.default.createElement(
          'div',
          { className: _leftTree.leftTreeStyle },
          _react2.default.createElement(
            _tree2.default,
            {
              checkStrictly: false,
              multiple: false,
              onExpand: this.onExpand,
              expandedKeys: expandedKeys,
              autoExpandParent: autoExpandParent,
              onSelect: this.onTreeSelect
            },
            loop(data)
          )
        )
      );
    }
  }]);

  return leftTree;
}(_react.Component);

exports.default = leftTree;
module.exports = exports['default'];