availity-angular/lib/core/polling/index.js

'use strict';

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

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 _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _angular = require('angular');

var _angular2 = _interopRequireDefault(_angular);

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

var _constants2 = _interopRequireDefault(_constants);

var _utils = require('../utils');

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var AvPollingService = function () {
  function AvPollingService($rootScope, $q, $injector, $timeout, $log, AV_POLLING, AV_API) {
    _classCallCheck(this, AvPollingService);

    this.av = { $rootScope: $rootScope, $q: $q, $injector: $injector, $timeout: $timeout, $log: $log, AV_POLLING: AV_POLLING, AV_API: AV_API };
    this.pendingRequests = []; // stores all request for polling
  }

  _createClass(AvPollingService, [{
    key: 'response',
    value: function response(_response) {

      if (this.isAsyncResponse(_response)) {
        return this.onAsyncReponse(_response);
      }

      return _response || this.av.$q.when(_response);
    }
  }, {
    key: 'setDefaults',
    value: function setDefaults(config) {

      var defaultOptions = {
        pollingInterval: this.av.AV_POLLING.INTERVAL,
        pollingDecay: this.av.AV_POLLING.DECAY,
        pollingMaxInterval: this.av.AV_POLLING.MAX_ELAPSED_TIME,
        pollingRetryCount: 0,
        pollingStartTime: new Date().getTime()
      };

      return _extends(defaultOptions, config);
    }
  }, {
    key: 'responseError',
    value: function responseError(response) {
      // Return the promise rejection
      return this.av.$q.reject(response);
    }

    /**
     * API layer return a link with a polling url for
     * async responses.
     *
     * @param  {Object}  response ajax response
     * @return {Boolean} true if response has status of 202 (accepted) and location param in header with uri+session link
     */

  }, {
    key: 'isAsyncResponse',
    value: function isAsyncResponse(response) {

      return response && response.config && response.config.api && response.status && response.status === 202 && _angular2.default.isFunction(response.headers) && !(0, _utils.isBlank)(response.headers(this.av.AV_API.HEADERS.SERVER.LOCATION));
    }
  }, {
    key: 'onAsyncReponse',
    value: function onAsyncReponse(response) {

      response.config = this.setDefaults(response.config);

      var deferred = this.av.$q.defer();

      this.queueRequest(deferred, response);

      // [rm3]: Can't call notify before you return promise object?
      this.av.$timeout(function () {
        // Notify deferred listeners with the original server response
        deferred.notify(response);
      }, 0, false);

      return deferred.promise;
    }
  }, {
    key: 'getUrl',
    value: function getUrl(url) {

      var result = url.match(this.av.AV_POLLING.REGEX_URL);
      if (result && result[1]) {
        return '/api' + result[1];
      }

      return url;
    }
  }, {
    key: 'queueRequest',
    value: function queueRequest(deferred, response) {

      var self = this;
      // server replies with location header so set the url into config
      var _url = (0, _utils.getRelativeUrl)(response.headers(this.av.AV_API.HEADERS.SERVER.LOCATION));
      var _config = response.config;

      // headers – {Object} – Map of strings or functions which return strings representing HTTP headers
      //  to send to the server. If the return value of a function is null, the header
      //  will not be sent. Functions accept a config object as an argument.
      var config = {
        method: 'GET',
        api: true,
        headers: _config.headers,
        pollingInterval: _config.pollingInterval,
        pollingMaxRetry: _config.pollingMaxRetry,
        pollingMaxInterval: _config.pollingMaxInterval,
        pollingStartTime: _config.pollingStartTime,
        _pollingDecay: _config._pollingDecay,
        pollingRetryCount: _config.pollingRetryCount,
        pollingDecay: _config.pollingDecay,
        url: _url, /* set the url from the server response */
        cache: false
      };

      var request = {
        id: (0, _utils.uuid)('request-'),
        config: config,
        deferred: deferred
      };

      var timeout = this.getPollingTimeout(config);

      // each async request should run on its own timer
      var timer = this.av.$timeout(function () {
        self.retryRequest(request.id);
      }, timeout, false);

      request.timer = timer;

      // add the async request to the queue
      this.pushRequest(request);
    }
  }, {
    key: 'popRequest',
    value: function popRequest(id) {

      var index = null;
      var request = null;

      for (var i = 0; i < this.pendingRequests.length; i++) {
        if (this.pendingRequests[i].id === id) {
          index = i;
          break;
        }
      }

      request = this.pendingRequests[index];
      this.pendingRequests.splice(index, 1);

      return request;
    }
  }, {
    key: 'pushRequest',
    value: function pushRequest(request) {
      this.pendingRequests.push(request);
    }
  }, {
    key: 'getPollingTimeout',
    value: function getPollingTimeout(config) {
      return config.pollingDecay * config.pollingInterval;
    }
  }, {
    key: 'isPollingMaxTimeout',
    value: function isPollingMaxTimeout(config) {
      var now = new Date().getTime();
      var elaspedTime = now - config.pollingStartTime;
      var isElapsed = elaspedTime > config.pollingMaxInterval;
      return isElapsed;
    }
  }, {
    key: 'isMaxRetried',
    value: function isMaxRetried(config) {
      return config.pollingRetryCount >= this.av.AV_POLLING.MAX_RETRY;
    }
  }, {
    key: 'isPollable',
    value: function isPollable(config) {
      var _isTimeout = this.isPollingMaxTimeout(config);
      var _isMax = this.isMaxRetried(config);

      return _isTimeout || _isMax ? false : true;
    }
  }, {
    key: 'retryRequest',
    value: function retryRequest(id) {

      var self = this;
      var request = this.popRequest(id);
      this.av.$timeout.cancel(request.timer);

      var config = request.config;

      var deferred = request.deferred;

      if (!this.isPollable(config)) {
        this.av.$log.info('Rejecting pollable response due to timeout');
        return deferred.reject(request);
      }

      // increment counters and polling timeouts
      this.increment(config);

      function successCallback(response) {
        if (self.isAsyncResponse(response)) {
          deferred.notify(response);
          self.queueRequest(request.deferred, response);
        } else {
          deferred.resolve(response);
        }
      }

      function errorCallback(response) {
        deferred.reject(response);
      }

      // Silly circular dependency trick
      var $http = this.av.$injector.get('$http');

      $http(config).then(successCallback, errorCallback);
    }
  }, {
    key: 'increment',
    value: function increment(config) {
      this.incrementCounter(config);
      this.incrementDecay(config);
    }
  }, {
    key: 'incrementDecay',
    value: function incrementDecay(config) {
      if (!config._pollingDecay) {
        // store the original decay param
        config._pollingDecay = config.pollingDecay;
      }
      config.pollingDecay *= config._pollingDecay;
    }
  }, {
    key: 'incrementCounter',
    value: function incrementCounter(config) {
      config.pollingRetryCount++;
    }
  }, {
    key: 'clearRequests',
    value: function clearRequests() {
      var self = this;
      _angular2.default.forEach(this.pendingRequests, function (request) {
        self.av.$timeout.cancel(request.timer);
      });
      this.pendingRequests = [];
    }
  }]);

  return AvPollingService;
}();

_constants2.default.service('avPollingService', AvPollingService);

exports.default = _constants2.default;