@rnga/orders/lib/node_modules/Component/src/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 _component = require('@prisma-cms/component');

var _component2 = _interopRequireDefault(_component);

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

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

var _propTypes2 = _interopRequireDefault(_propTypes);

var _Snackbar = require('Snackbar');

var _Snackbar2 = _interopRequireDefault(_Snackbar);

var _urijs = require('urijs');

var _urijs2 = _interopRequireDefault(_urijs);

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 CustomComponent = function (_PrismaCmsComponent) {
  _inherits(CustomComponent, _PrismaCmsComponent);

  function CustomComponent() {
    _classCallCheck(this, CustomComponent);

    return _possibleConstructorReturn(this, _PrismaCmsComponent.apply(this, arguments));
  }

  // static propTypes = {
  //   prop: PropTypes
  // }

  // static contextTypes = {
  //   router: PropTypes.object.isRequired,
  //   client: PropTypes.object.isRequired,
  //   loadApiData: PropTypes.func.isRequired,
  //   user: PropTypes.object,
  // }


  // state = {}


  // addError(error) {

  //   error = error || "Ошибка выполнения запроса";

  //   this.setState({
  //     error,
  //   }, () => {
  //     setTimeout(() => {

  //       // Проверка не очень надежная, так как строки не учитывают инстанс,
  //       // но это лучше, чем ничего.
  //       if (error === this.state.error) {
  //         this.setState({
  //           error: null,
  //         });
  //       }

  //     }, 5000);
  //   });
  // }


  // query(params) {

  //   return this.request("query", params);

  // }


  CustomComponent.prototype.mutate = function mutate(params) {

    return this.request("mutate", params);
  };

  CustomComponent.prototype.request = function () {
    var _ref = _asyncToGenerator( /*#__PURE__*/_regenerator2.default.mark(function _callee(method, params) {
      var client, result, error, errors, _ref2, response, _ref3, success, message, responseErrors, other;

      return _regenerator2.default.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:

              this.setState({
                loading: true
              });

              client = this.context.client;

              // params = {
              //   fetchPolicy: "network-only",
              //   ...params,
              // }

              _context.next = 4;
              return client[method](params).catch(function (error) {
                // console.error(error);

                return error;
              });

            case 4:
              result = _context.sent;


              // console.log("Component request result", result);


              this.setState({
                loading: false
              });

              error = void 0;
              errors = void 0;

              if (!(result instanceof Error)) {
                _context.next = 12;
                break;
              }

              error = result.message;
              // throw(result);
              _context.next = 22;
              break;

            case 12:
              _ref2 = result.data || {}, response = _ref2.response;

              // const {
              //   response,
              // } = resultData || {};

              // console.log("result", result);

              _ref3 = response || {}, success = _ref3.success, message = _ref3.message, responseErrors = _ref3.errors, other = _objectWithoutProperties(_ref3, ['success', 'message', 'errors']);


              errors = responseErrors;

              if (!(success !== undefined)) {
                _context.next = 22;
                break;
              }

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

              error = message || "Ошибка выполнения запроса";

              // errors && errors.map(error => {
              //   this.addError(error);
              // });

              // console.log("error 2", error);
              _context.next = 22;
              break;

            case 20:
              _context.next = 22;
              return this.onSuccess();

            case 22:

              // console.log("error", error);

              this.setState({
                errors: errors
              });

              if (!error) {
                _context.next = 28;
                break;
              }

              this.addError(error);
              throw result;

            case 28:
              this.setState({
                error: null
              });

            case 29:
              return _context.abrupt('return', result);

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

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

    return request;
  }();

  CustomComponent.prototype.onSuccess = function () {
    var _ref4 = _asyncToGenerator( /*#__PURE__*/_regenerator2.default.mark(function _callee2() {
      var client;
      return _regenerator2.default.wrap(function _callee2$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              client = this.context.client;
              return _context2.abrupt('return', client.reFetchObservableQueries());

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

    function onSuccess() {
      return _ref4.apply(this, arguments);
    }

    return onSuccess;
  }();

  CustomComponent.prototype.reloadApiData = function reloadApiData() {
    var loadApiData = this.context.loadApiData;


    return loadApiData();
  };

  CustomComponent.prototype.onChange = function onChange(event) {
    var _setState;

    var _event$target = event.target,
        name = _event$target.name,
        value = _event$target.value;


    this.setState((_setState = {}, _setState[name] = value, _setState));

    var onChange = this.props.onChange;


    return onChange ? onChange(event) : null;
  };

  CustomComponent.prototype.renderField = function renderField(field) {
    var _this2 = this;

    if (!field) {
      return null;
    }

    var errors = this.state.errors;

    var Type = field.type,
        _field$props = field.props,
        name = _field$props.name,
        helperText = _field$props.helperText,
        _onFocus = _field$props.onFocus,
        other = _objectWithoutProperties(_field$props, ['name', 'helperText', 'onFocus']);

    // console.log("field", field);


    var error = errors ? errors.find(function (n) {
      return n.key === name;
    }) : null;

    return _react2.default.createElement(Type, _extends({
      name: name,
      error: error ? true : false,
      helperText: error && error.message ? error.message : helperText,
      onFocus: function onFocus(event) {

        if (errors && error) {
          var index = errors.indexOf(error);
          errors.splice(index, 1);
          _this2.forceUpdate();
        }

        return _onFocus ? _onFocus(event) : null;
      },
      onChange: function onChange(event) {
        return _this2.onChange(event);
      }
    }, other));
  };

  // getHistory() {
  //   const {
  //     router: {
  //       history,
  //     },
  //   } = this.context;

  //   return history;
  // }

  // getLocation() {

  //   const {
  //     location,
  //   } = this.getHistory();

  //   return location;
  // }

  // getLocationUri() {

  //   const {
  //     pathname,
  //     search,
  //   } = this.getLocation();

  //   return new URI(`${pathname}${search}`);

  // }

  // getLocationQuery(field) {

  //   return this.getLocationUri().query(true)[field];
  // }


  CustomComponent.prototype.onFilterFieldChange = function onFilterFieldChange(event) {
    var _setFilters;

    var _event$target2 = event.target,
        name = _event$target2.name,
        value = _event$target2.value;


    this.setFilters((_setFilters = {}, _setFilters[name] = value ? value : undefined, _setFilters));
  };

  CustomComponent.prototype.setFilters = function setFilters(data) {

    var uri = this.getLocationUri();
    var query = uri.query(true);

    Object.assign(query, _extends({}, data, {
      page: undefined
    }));

    uri.query(query);

    var history = this.getHistory();

    // console.log("uri.toString()", uri.toString());

    history.push(uri.toString());

    // console.log("newUrl", newUrl);
  };

  /**
   * Простая проверка выставлены ли фильтры или нет
   */


  CustomComponent.prototype.hasFilters = function hasFilters() {

    // const {
    //   search,
    // } = this.getLocation();

    // let {
    //   page,
    //   ...query
    // } = this.getLocationUri().query(true);

    var filters = this.getFilters();

    // console.log("hasFilters search", Object.keys(filters).length);

    return Object.keys(filters).length > 0 ? true : false;
  };

  /**
   * Получаем фильтры из адресной строки
   */


  CustomComponent.prototype.getFilters = function getFilters() {
    var _getLocationUri$query = this.getLocationUri().query(true),
        page = _getLocationUri$query.page,
        authFilters = _getLocationUri$query.authFilters,
        filters = _objectWithoutProperties(_getLocationUri$query, ['page', 'authFilters']);

    // console.log("hasFilters search", Object.keys(query).length);

    return filters;
  };

  CustomComponent.prototype.addFilterCondition = function addFilterCondition(where, key, value) {
    var _Object$assign;

    return Object.assign(where, (_Object$assign = {}, _Object$assign[key] = value, _Object$assign));
  };

  CustomComponent.prototype.cleanFilters = function cleanFilters() {
    var _getLocation = this.getLocation(),
        search = _getLocation.search,
        pathname = _getLocation.pathname;

    var history = this.getHistory();

    history.push(pathname);
  };

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

    var error = this.state.error;


    return _react2.default.createElement(
      _react.Fragment,
      null,
      content,
      _react2.default.createElement(_Snackbar2.default, {
        opened: error ? true : false,
        message: error || "",
        close: function close() {
          _this3.setState({
            error: null
          });
        }
      })
    );
  };

  return CustomComponent;
}(_component2.default);

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