@rnga/orders/lib/node_modules/ui/Button/User/RequestCall/index.js

## Get schema from @prisma-cms 1. yarn get-api-schema -e http://localhost:4000 2. yarn build-api-fragments

'use strict';

exports.__esModule = true;
exports.default = undefined;

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

var _regenerator2 = _interopRequireDefault(_regenerator);

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _class, _temp2;

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _propTypes = require('prop-types');

var _propTypes2 = _interopRequireDefault(_propTypes);

var _query = require('query');

var _Component = require('../../../Component');

var _Component2 = _interopRequireDefault(_Component);

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

function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

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 CallRequestButton = (_temp2 = _class = function (_CustomComponent) {
  _inherits(CallRequestButton, _CustomComponent);

  function CallRequestButton() {
    var _temp, _this, _ret;

    _classCallCheck(this, CallRequestButton);

    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    return _ret = (_temp = (_this = _possibleConstructorReturn(this, _CustomComponent.call.apply(_CustomComponent, [this].concat(args))), _this), _this.state = {
      inRequest: false
    }, _temp), _possibleConstructorReturn(_this, _ret);
  }

  CallRequestButton.prototype.createCall = function () {
    var _ref = _asyncToGenerator( /*#__PURE__*/_regenerator2.default.mark(function _callee2(to) {
      var _this2 = this;

      var client, inRequest, room, data, _ref2, roomId, result;

      return _regenerator2.default.wrap(function _callee2$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              client = this.context.client;
              inRequest = this.state.inRequest;
              room = this.props.room;

              if (!inRequest) {
                _context2.next = 5;
                break;
              }

              return _context2.abrupt('return', false);

            case 5:
              data = void 0;
              _ref2 = room || {}, roomId = _ref2.id;


              if (roomId) {
                data = {
                  Room: {
                    id: roomId
                  }
                };
              }

              this.setState({
                inRequest: true
              });

              _context2.next = 11;
              return client.mutate({
                mutation: _query.createCall,
                variables: {
                  to: to,
                  data: data
                }
              }).then(function () {
                var _ref3 = _asyncToGenerator( /*#__PURE__*/_regenerator2.default.mark(function _callee(r) {
                  var object, _ref4, success, message, data, callId, history;

                  return _regenerator2.default.wrap(function _callee$(_context) {
                    while (1) {
                      switch (_context.prev = _context.next) {
                        case 0:
                          object = r.data.object;
                          _ref4 = object || {}, success = _ref4.success, message = _ref4.message, data = _ref4.data;

                          if (success) {
                            _context.next = 7;
                            break;
                          }

                          _this2.addError(message || "Can not create call");
                          return _context.abrupt('return');

                        case 7:
                          if (data) {
                            _context.next = 12;
                            break;
                          }

                          _this2.addError(message || "Can not create call");
                          return _context.abrupt('return');

                        case 12:
                          callId = data.id;
                          history = _this2.context.router.history;


                          history.push('/calls/' + callId);

                        case 15:
                          _context.next = 17;
                          return client.resetStore();

                        case 17:
                        case 'end':
                          return _context.stop();
                      }
                    }
                  }, _callee, _this2);
                }));

                return function (_x2) {
                  return _ref3.apply(this, arguments);
                };
              }()).catch(function (e) {
                console.error(e);
                _this2.addError(e.message || "Request error");
              });

            case 11:
              result = _context2.sent;


              this.setState({
                inRequest: false
              });

            case 13:
            case 'end':
              return _context2.stop();
          }
        }
      }, _callee2, this);
    }));

    function createCall(_x) {
      return _ref.apply(this, arguments);
    }

    return createCall;
  }();

  CallRequestButton.prototype.render = function render() {
    var _this3 = this;

    var _props = this.props,
        user = _props.user,
        other = _objectWithoutProperties(_props, ['user']);

    var currentUser = this.context.user;


    if (!user || !currentUser) {
      return null;
    }

    var userId = user.id;
    var currentUserId = currentUser.id;


    if (userId === currentUserId) {
      return null;
    }

    return _CustomComponent.prototype.render.call(this, _react2.default.createElement(
      'a',
      _extends({
        href: 'javascript:;',
        className: 'button-call ajax precall_add2',
        onClick: function onClick(event) {
          event.preventDefault();
          event.stopPropagation();
          _this3.createCall(userId);
        }
      }, other),
      'Request a call'
    ));
  };

  return CallRequestButton;
}(_Component2.default), _class.propTypes = _extends({}, _Component2.default.propTypes, {
  user: _propTypes2.default.object.isRequired,
  room: _propTypes2.default.object
}), _temp2);
exports.default = CallRequestButton;
module.exports = exports['default'];