instantjob-recruiter-client/dist/common/request.es6.js

a set of tools for creating an instantjob recruiter react client

'use strict';

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

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _keys = require('babel-runtime/core-js/object/keys');

var _keys2 = _interopRequireDefault(_keys);

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

var _stringify = require('babel-runtime/core-js/json/stringify');

var _stringify2 = _interopRequireDefault(_stringify);

exports.make_url = make_url;

require('whatwg-fetch');

var _superagent = require('superagent');

var _superagent2 = _interopRequireDefault(_superagent);

var _constants = require('common/constants');

var _store = require('common/store');

var _store2 = _interopRequireDefault(_store);

var _utilities = require('common/utilities');

var _auto_bind = require('common/auto_bind');

var _auto_bind2 = _interopRequireDefault(_auto_bind);

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

function make_url(endpoint) {
  return _constants.api_path + '/' + endpoint + '.json?';
}

var authentication_headers = function authentication_headers() {
  var token = _store2.default.getState().authentication.token;

  if (token) {
    return {
      'Authorization': 'Bearer ' + token
    };
  }
  return {};
};

var requestWithMethod = function requestWithMethod(method, endpoint) {
  var data = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

  var options = { method: method };
  var params = "";
  if (method == 'GET' && data !== null) {
    for (var key in data) {
      params += encodeURIComponent(key) + "=" + encodeURIComponent(data[key]) + "&";
    }
    data = null;
  }
  options.headers = authentication_headers();
  if (data !== null) {
    options.body = (0, _stringify2.default)(data);
    options.headers = (0, _extends3.default)({}, options.headers, {
      'Accept': 'application/json',
      'Content-Type': 'application/json'
    });
  }
  var request_url = '' + make_url(endpoint) + params;
  return fetch(request_url, options).catch(function (error) {
    return new _promise2.default(function (resolve, reject) {
      _constants.DEV && console.log(method, request_url, data);
      _constants.DEV && console.log(error);
      return reject(error);
    });
  }).then(function (response) {
    return new _promise2.default(function (resolve, reject) {
      if (response == null || response.error || (0, _utilities.array_contains)([400, 404, 422, 500], response.status)) {
        reject(response);
      } else if (response.status != 204) {
        response.json().then(function (responseObject) {
          if (responseObject == null || responseObject.error || (0, _utilities.array_contains)([400, 404, 422, 500], responseObject.status)) {
            reject(responseObject);
          } else {
            resolve(responseObject);
          }
        }).catch(function (error) {
          return reject(error);
        });
      } else {
        resolve(response);
      }
    });
  });
};

var request = {
  get: function get(endpoint, params, callback) {
    return requestWithMethod('GET', endpoint, params, callback);
  },

  post: function post(endpoint, data, callback) {
    return requestWithMethod('POST', endpoint, data, callback);
  },

  put: function put(endpoint, data, callback) {
    return requestWithMethod('PUT', endpoint, data, callback);
  },

  delete: function _delete(endpoint, data, callback) {
    return requestWithMethod('DELETE', endpoint, data, callback);
  },

  asynchronous: function asynchronous(endpoint, data) {
    return new _promise2.default(function (resolve, reject) {
      var poll_result = function poll_result(asynchronous_request_id) {
        return requestWithMethod('GET', 'asynchronous_requests/' + asynchronous_request_id).then(function (asynchronous_request) {
          switch (asynchronous_request.status) {
            case "pending":
              setTimeout(function () {
                return poll_result(asynchronous_request_id);
              }, 1000);
              break;
            case "completed":
              resolve(JSON.parse(asynchronous_request.result));
              break;
            default:
              reject(asynchronous_request);
          }
        });
      };

      requestWithMethod('POST', endpoint, data).then(function (response) {
        return setTimeout(function () {
          return poll_result(response.asynchronous_request_id);
        }, 1000);
      });
    });
  },

  get_paginated: function get_paginated(endpoint) {
    var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    var callback = arguments[2];

    return new _promise2.default(function (resolve, reject) {
      var request_page = function request_page(page) {
        return requestWithMethod('GET', endpoint, (0, _extends3.default)({}, data, { page: page })).then(function (page_results) {
          if (page_results.length == 0) {
            resolve();
          } else {
            callback(page_results);
            request_page(page + 1);
          }
        }).catch(reject);
      };

      request_page(1);
    });
  },

  upload: function upload(endpoint, file, data) {
    // request won't start if `then` is not called
    var request = _superagent2.default.put(make_url(endpoint)).set(authentication_headers()).accept('json').attach('file', file);
    return (0, _keys2.default)(data).reduce(function (request, key) {
      return request.field(key, data[key]);
    }, request);
  },
  delayed_put: function delayed_put(endpoint, data) {
    return new _promise2.default(function (resolve, reject) {
      var delayed_request = delayed_requests[endpoint];
      if (delayed_request && !delayed_request.completed) {
        resolve = delayed_request.cancel(resolve);
      }
      delayed_requests[endpoint] = new DelayedRequest(function () {
        return request.put(endpoint, data);
      }, resolve, reject);
    });
  }
};

var delayed_requests = {};

var DelayedRequest = function () {
  function DelayedRequest(request, resolve, reject) {
    (0, _classCallCheck3.default)(this, DelayedRequest);

    this.request = request;
    this.resolve = resolve;
    this.reject = reject;
    (0, _auto_bind2.default)(this);
    setTimeout(this.run, 2 * 1000);
  }

  (0, _createClass3.default)(DelayedRequest, [{
    key: 'run',
    value: function run() {
      this.completed = true;
      if (!this.canceled) {
        this.request().then(this.resolve, this.reject);
      }
    }
  }, {
    key: 'cancel',
    value: function cancel(resolve) {
      var _this = this;

      this.canceled = true;
      return function () {
        resolve.apply(undefined, arguments);
        _this.resolve.apply(_this, arguments);
      };
    }
  }]);
  return DelayedRequest;
}();

exports.default = request;