cspace-ui/lib/components/invocable/InvocationModal.js

CollectionSpace user interface for browsers

"use strict";

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

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

var _propTypes = _interopRequireDefault(require("prop-types"));

var _reactIntl = require("react-intl");

var _immutable = _interopRequireDefault(require("immutable"));

var _get = _interopRequireDefault(require("lodash/get"));

var _cspaceLayout = require("cspace-layout");

var _InvokeButton = _interopRequireDefault(require("./InvokeButton"));

var _InvocationEditorContainer = _interopRequireDefault(require("../../containers/invocable/InvocationEditorContainer"));

var _CancelButton = _interopRequireDefault(require("../navigation/CancelButton"));

var _InvocationModal = _interopRequireDefault(require("../../../styles/cspace-ui/InvocationModal.css"));

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

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }

const messages = (0, _reactIntl.defineMessages)({
  cancel: {
    "id": "invocationModal.cancel",
    "defaultMessage": "Cancel"
  },
  invoke: {
    "id": "invocationModal.run",
    "defaultMessage": "Run"
  }
});
const propTypes = {
  allowedModes: _propTypes.default.arrayOf(_propTypes.default.string),
  config: _propTypes.default.object.isRequired,
  csid: _propTypes.default.string,
  data: _propTypes.default.instanceOf(_immutable.default.Map),
  initialInvocationDescriptor: _propTypes.default.instanceOf(_immutable.default.Map),
  modeReadOnly: _propTypes.default.bool,
  invocationTargetReadOnly: _propTypes.default.bool,
  isOpen: _propTypes.default.bool,
  isRecordModified: _propTypes.default.bool,
  isRunning: _propTypes.default.bool,
  recordType: _propTypes.default.oneOf(['report', 'batch']),
  readRecord: _propTypes.default.func,
  searchCsid: _propTypes.default.func,
  onCancelButtonClick: _propTypes.default.func,
  onCloseButtonClick: _propTypes.default.func,
  onInvokeButtonClick: _propTypes.default.func
};

class InvocationModal extends _react.Component {
  constructor(props) {
    super(props);
    this.handleInvocationDescriptorCommit = this.handleInvocationDescriptorCommit.bind(this);
    this.handleInvokeButtonClick = this.handleInvokeButtonClick.bind(this);
    this.renderButtonBar = this.renderButtonBar.bind(this);
    this.state = {
      invocationDescriptor: props.initialInvocationDescriptor
    };
  }

  componentWillReceiveProps(nextProps) {
    const {
      isOpen
    } = this.props;
    const {
      isOpen: nextIsOpen
    } = nextProps;

    if (!isOpen && nextIsOpen) {
      this.setState({
        invocationDescriptor: nextProps.initialInvocationDescriptor
      });
    }
  }

  componentDidUpdate(prevProps) {
    const {
      csid,
      isOpen,
      readRecord
    } = this.props;
    const {
      isOpen: prevIsOpen
    } = prevProps;

    if (csid && !prevIsOpen && isOpen) {
      if (readRecord) {
        readRecord();
      }

      this.readInvocationItem();
    }
  }

  handleInvocationDescriptorCommit(invocationDescriptor) {
    this.setState({
      invocationDescriptor
    });
  }

  handleInvokeButtonClick() {
    const {
      data,
      onInvokeButtonClick
    } = this.props;
    const {
      invocationDescriptor
    } = this.state;
    const mode = invocationDescriptor.get('mode'); // Translate the items map to csids.

    const items = invocationDescriptor.get('items') || _immutable.default.Map();

    let csid = items.keySeq().toJS();

    if (mode === 'single' || mode === 'group') {
      csid = csid[0];
    }

    if (onInvokeButtonClick) {
      onInvokeButtonClick(data, invocationDescriptor.set('csid', csid));
    }
  }

  readInvocationItem() {
    const {
      config,
      searchCsid
    } = this.props;
    const {
      invocationDescriptor
    } = this.state;

    if (invocationDescriptor) {
      const invocationCsid = invocationDescriptor.get('csid');

      if (invocationCsid && typeof invocationCsid === 'string' && !invocationDescriptor.get('items')) {
        searchCsid(config, invocationDescriptor.get('recordType'), invocationCsid).then(response => {
          let item = (0, _get.default)(response, ['data', 'ns2:abstract-common-list', 'list-item']);

          if (item) {
            item = _immutable.default.fromJS(item);
          } else {
            item = _immutable.default.Map({
              csid: invocationCsid
            });
          }

          const nextInvocationDescriptor = this.state.invocationDescriptor.set('items', _immutable.default.Map({
            [invocationCsid]: item
          }));
          this.setState({
            invocationDescriptor: nextInvocationDescriptor
          });
        }).catch(() => {
          const item = _immutable.default.Map({
            csid: invocationCsid
          });

          const nextInvocationDescriptor = this.state.invocationDescriptor.set('items', _immutable.default.Map({
            [invocationCsid]: item
          }));
          this.setState({
            invocationDescriptor: nextInvocationDescriptor
          });
        });
      }
    }
  }

  renderButtonBar() {
    const {
      isRunning,
      onCancelButtonClick,
      recordType
    } = this.props;
    const {
      invocationDescriptor
    } = this.state;
    const mode = invocationDescriptor.get('mode');
    const items = invocationDescriptor.get('items');
    return _react.default.createElement("div", null, _react.default.createElement(_CancelButton.default, {
      disabled: isRunning,
      label: _react.default.createElement(_reactIntl.FormattedMessage, messages.cancel),
      onClick: onCancelButtonClick
    }), _react.default.createElement(_InvokeButton.default, {
      disabled: isRunning || mode !== 'nocontext' && (!items || items.isEmpty()),
      label: _react.default.createElement(_reactIntl.FormattedMessage, messages.invoke),
      recordType: recordType,
      onClick: this.handleInvokeButtonClick
    }));
  }

  renderTitle() {
    const {
      config,
      data,
      recordType
    } = this.props;

    if (!data) {
      return ' ';
    }

    const recordTypeConfig = (0, _get.default)(config, ['recordTypes', recordType]);
    const titleGetter = (0, _get.default)(recordTypeConfig, 'title');
    let title = titleGetter && titleGetter(data);

    if (!title) {
      const recordTypeMessages = (0, _get.default)(recordTypeConfig, ['messages', 'record']);
      title = _react.default.createElement(_reactIntl.FormattedMessage, recordTypeMessages.name);
    }

    return _react.default.createElement("h1", null, title);
  }

  render() {
    const {
      allowedModes,
      config,
      csid,
      data,
      modeReadOnly,
      invocationTargetReadOnly,
      isOpen,
      isRecordModified,
      recordType,
      onCloseButtonClick
    } = this.props;
    const {
      invocationDescriptor
    } = this.state;

    if (!isOpen || !csid) {
      return null;
    }

    const recordTypeConfig = (0, _get.default)(config, ['recordTypes', recordType]);
    const invocableNameGetter = (0, _get.default)(recordTypeConfig, 'invocableName');
    const invocableName = invocableNameGetter && invocableNameGetter(data);
    return _react.default.createElement(_cspaceLayout.Modal, {
      className: _InvocationModal.default.common,
      isOpen: isOpen,
      title: this.renderTitle(),
      closeButtonClassName: "material-icons",
      closeButtonLabel: "close",
      renderButtonBar: this.renderButtonBar,
      onCloseButtonClick: onCloseButtonClick
    }, _react.default.createElement(_InvocationEditorContainer.default, {
      allowedModes: allowedModes,
      config: config,
      metadata: data,
      invocationDescriptor: invocationDescriptor,
      modeReadOnly: modeReadOnly,
      invocationTargetReadOnly: invocationTargetReadOnly,
      invocableName: invocableName,
      isInvocationTargetModified: isRecordModified,
      recordType: recordType,
      onInvocationDescriptorCommit: this.handleInvocationDescriptorCommit
    }));
  }

}

exports.default = InvocationModal;
InvocationModal.modalName = 'InvocationModal';
InvocationModal.propTypes = propTypes;