ming-demo3/lib/components/portal/LeftMenu.js

mdf metaui web

"use strict";

var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));

var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));

var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));

var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _react = _interopRequireWildcard(require("react"));

var _redux = require("redux");

var _reactRedux = require("react-redux");

var _menu = _interopRequireDefault(require("../basic/menu"));

var treeactions = _interopRequireWildcard(require("../../redux/tree"));

var tabsactions = _interopRequireWildcard(require("../../redux/tabs"));

var portalactions = _interopRequireWildcard(require("../../redux/portal"));

var _util = require("@mdf/cube/lib/helpers/util");

var LeftMenu = function (_Component) {
  (0, _inherits2["default"])(LeftMenu, _Component);

  function LeftMenu(props) {
    var _this;

    (0, _classCallCheck2["default"])(this, LeftMenu);
    _this = (0, _possibleConstructorReturn2["default"])(this, (0, _getPrototypeOf2["default"])(LeftMenu).call(this, props));
    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onBeforeUnload", function () {
      for (var attr in _this.windows) {
        _this.windows[attr].close();
      }
    });
    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onClick", function (selectedKeys) {
      if (selectedKeys.length !== 1) return;

      _this.props.treeactions.execHandler(selectedKeys[0]);
    });
    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleClick", function (activeKey, selectedNode, filterCondition) {
      var menuId = selectedNode[_this.state.keyField];

      if (!menuId) {
        cb.utils.alert('menuId为空', 'warning');
        return;
      }

      var _this$props = _this.props,
          tabsactions = _this$props.tabsactions,
          portalactions = _this$props.portalactions,
          tabs = _this$props.tabs,
          portal = _this$props.portal;
      var index = tabs.panes.findIndex(function (pane) {
        return pane.key === activeKey;
      });
      var viewType = selectedNode.viewType;

      if (viewType === 'external' || viewType === 'ajax') {
        var menuUrl = selectedNode.menuUrl,
            metaType = selectedNode.metaType;
        var config = null;

        try {
          config = JSON.parse(metaType);
        } catch (e) {
          cb.utils.alert(e.message, 'warning');
          config = {};
        }

        if (config.type === 'window') return _this.handleWindow(viewType, menuUrl, menuId, config.mode === 'fullscreen');
      }

      var keepFilter = true;

      if (filterCondition && filterCondition.filterId === null) {
        keepFilter = false;
        delete filterCondition.filterId;
      }

      if (index > -1) {
        tabsactions.activateItem(activeKey);
        var current = portal.tabs[activeKey];
        if (!current) return;
        var currentPanes = current.panes;
        if (!currentPanes || !currentPanes.length) return;

        if (filterCondition) {
          if (currentPanes.length === 1) {
            currentPanes[0].content.vm.execute('updateCondition', filterCondition);
            return;
          }
        } else {
          if (currentPanes.length === 1) return;
        }

        var activeContent = currentPanes[currentPanes.length - 1].content;
        if (!activeContent) return;

        if (activeContent.vm) {
          activeContent.vm.promiseExecute('return', '返回', function () {
            portalactions.firstItem(activeKey);
          });
        } else if (activeContent.type && activeContent.url) {
          if (activeContent.checkReturn) {
            portalactions.refreshItem(activeKey, '返回', function () {
              portalactions.firstItem(activeKey);
            });
          } else {
            portalactions.firstItem(activeKey);
          }
        }

        if (filterCondition) currentPanes[0].content.vm.execute('updateCondition', filterCondition);
        return;
      }

      var params = Object.assign({}, selectedNode, {
        userClick: true,
        menuId: menuId
      });

      var callback = function callback(returnData) {
        if (filterCondition) {
          var vm = returnData.content.vm;
          vm.getParams().condition = filterCondition;
          if (!keepFilter) vm.getParams().filterId = null;
        }

        tabsactions.addItem(returnData);
      };

      cb.loader.runCommandLine('menu', params, null, callback);
    });
    _this.state = {
      keyField: 'code',
      titleField: 'name'
    };
    _this.windows = {};
    return _this;
  }

  (0, _createClass2["default"])(LeftMenu, [{
    key: "componentDidMount",
    value: function componentDidMount() {
      var treeactions = this.props.treeactions;
      treeactions.setHandler(this.handleClick);
      window.onbeforeunload = this.onBeforeUnload;
    }
  }, {
    key: "componentWillUnmount",
    value: function componentWillUnmount() {
      this.onBeforeUnload();
    }
  }, {
    key: "windowOpen",
    value: function windowOpen(menuId, fullscreen, callback) {
      var currentWindow = this.windows[menuId];

      if (currentWindow && !currentWindow.closed) {
        currentWindow.focus();
        if (fullscreen) currentWindow.resizeTo(screen.availWidth, screen.availHeight);
        return;
      }

      var url = callback();
      if (url === false) return;
      url = (0, _util.getPredicateValue)(url);
      var features = fullscreen ? 'fullscreen=yes' : null;
      currentWindow = window.open(url, menuId, features);
      this.windows[menuId] = currentWindow;
      if (fullscreen) currentWindow.resizeTo(screen.availWidth, screen.availHeight);
    }
  }, {
    key: "handleWindow",
    value: function handleWindow(viewType, menuUrl, menuId, fullscreen) {
      if (!menuUrl) {
        cb.utils.alert('menuUrl为空', 'warning');
        return;
      }

      if (viewType === 'ajax') {
        this.windowOpen(menuId, fullscreen, function () {
          var proxy = cb.rest.DynamicProxy.create({
            getUrl: {
              url: menuUrl,
              method: 'GET',
              options: {
                async: false
              }
            }
          });
          var data = proxy.getUrl();
          if (!data.error) return data.result;
          cb.utils.alert(data.error.message, 'error');
          return false;
        });
      } else {
        this.windowOpen(menuId, fullscreen, function () {
          if (!cb.events.execute('menuClick', menuId)) return false;
          return menuUrl;
        });
      }
    }
  }, {
    key: "render",
    value: function render() {
      var treeData = this.props.tree.TreeData;
      if (!treeData.length) return null;
      var trigger = 'hover';

      if (process.env.__CLIENT__) {
        cb.rest.AppContext.portalTreeData = treeData;
        if (cb.rest.device === 'android') trigger = 'click';
      }

      return _react["default"].createElement("div", null, _react["default"].createElement(_menu["default"], {
        trigger: trigger,
        defaultSelectedKeys: ['PORTAL'],
        titleField: this.state.titleField,
        keyField: this.state.keyField,
        dataSource: treeData,
        onSelect: this.onClick,
        id: "menu".concat(this.props.tree.id)
      }));
    }
  }]);
  return LeftMenu;
}(_react.Component);

function mapStateToProps(state) {
  return {
    tree: state.tree.toJS(),
    tabs: state.tabs.toJS(),
    portal: state.portal.toJS()
  };
}

function mapDispatchToProps(dispatch) {
  return {
    treeactions: (0, _redux.bindActionCreators)(treeactions, dispatch),
    tabsactions: (0, _redux.bindActionCreators)(tabsactions, dispatch),
    portalactions: (0, _redux.bindActionCreators)(portalactions, dispatch)
  };
}

var _default = (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps)(LeftMenu);

exports["default"] = _default;
//# sourceMappingURL=LeftMenu.js.map