@mmontes11/iot-client/dist/services/authService.js

ES6 client library for consuming IoT server REST API

"use strict";

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

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

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require("babel-runtime/helpers/asyncToGenerator");

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _getPrototypeOf = require("babel-runtime/core-js/object/get-prototype-of");

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

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

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

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

var _createClass3 = _interopRequireDefault(_createClass2);

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

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

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

var _inherits3 = _interopRequireDefault(_inherits2);

var _underscore = require("underscore");

var _underscore2 = _interopRequireDefault(_underscore);

var _service = require("./service");

var _tokenHandler = require("../helpers/tokenHandler");

var _auth = require("../helpers/auth");

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

var AuthService = exports.AuthService = function (_Service) {
  (0, _inherits3.default)(AuthService, _Service);

  function AuthService(client) {
    (0, _classCallCheck3.default)(this, AuthService);
    return (0, _possibleConstructorReturn3.default)(this, (AuthService.__proto__ || (0, _getPrototypeOf2.default)(AuthService)).call(this, client, "auth"));
  }

  (0, _createClass3.default)(AuthService, [{
    key: "checkAuth",
    value: function checkAuth(credentials) {
      return this.post(undefined, credentials);
    }
  }, {
    key: "checkAuthToken",
    value: function checkAuthToken(token) {
      return this.post(undefined, { token: token });
    }
  }, {
    key: "createUser",
    value: function createUser(user) {
      var options = { basicAuth: true };
      return this.post("user", user, options);
    }
  }, {
    key: "getToken",
    value: function () {
      var _ref = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee() {
        var tokenFromStorage, _ref2, token;

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

              case 2:
                tokenFromStorage = _context.sent;

                if (!tokenFromStorage) {
                  _context.next = 5;
                  break;
                }

                return _context.abrupt("return", tokenFromStorage);

              case 5:
                _context.prev = 5;
                _context.next = 8;
                return this._getToken();

              case 8:
                _ref2 = _context.sent;
                token = _ref2.body.token;
                _context.next = 12;
                return _tokenHandler.TokenHandler.storeToken(token);

              case 12:
                return _context.abrupt("return", token);

              case 15:
                _context.prev = 15;
                _context.t0 = _context["catch"](5);
                _context.next = 19;
                return _tokenHandler.TokenHandler.invalidateToken();

              case 19:
                throw _context.t0;

              case 20:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this, [[5, 15]]);
      }));

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

      return getToken;
    }()
  }, {
    key: "getBasicAuthToken",
    value: function getBasicAuthToken() {
      if (_underscore2.default.isUndefined(this.client.basicAuthCredentials)) {
        throw new Error("Basic auth credentials required");
      }
      var _client$basicAuthCred = this.client.basicAuthCredentials,
          username = _client$basicAuthCred.username,
          password = _client$basicAuthCred.password;

      return (0, _auth.getBasicAuthHeader)(username, password);
    }
  }, {
    key: "setCredentials",
    value: function setCredentials(username, password) {
      this.client.userCredentials = { username: username, password: password };
    }
  }, {
    key: "logout",
    value: function logout() {
      return _tokenHandler.TokenHandler.invalidateToken();
    }
  }, {
    key: "refreshToken",
    value: function () {
      var _ref3 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2() {
        return _regenerator2.default.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                _context2.next = 2;
                return this.logout();

              case 2:
                _context2.next = 4;
                return this.getToken();

              case 4:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function refreshToken() {
        return _ref3.apply(this, arguments);
      }

      return refreshToken;
    }()
  }, {
    key: "_getToken",
    value: function _getToken() {
      if (_underscore2.default.isUndefined(this.client.userCredentials)) {
        throw new Error("User credentials required");
      }
      var user = this.client.userCredentials;
      var reqOpts = {
        auth: false,
        basicAuth: false,
        retryOnUnauthorized: false
      };
      return this.post("token", user, reqOpts);
    }
  }]);
  return AuthService;
}(_service.Service);