availity-angular/lib/core/api/resource.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 _moment = require('moment');

var _moment2 = _interopRequireDefault(_moment);

var _module = require('../module');

var _module2 = _interopRequireDefault(_module);

require('./constants');

require('../polling');

require('../localStorage');

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 ApiResourceProvider = function () {
  function ApiResourceProvider(AV_API) {
    _classCallCheck(this, ApiResourceProvider);

    this.defaultOptions = _extends({}, AV_API.OPTIONS);
  }

  _createClass(ApiResourceProvider, [{
    key: 'setOptions',
    value: function setOptions(options) {
      _extends(this.defaultOptions, options);
    }
  }, {
    key: 'getOptions',
    value: function getOptions() {
      return _angular2.default.copy(this.defaultOptions);
    }
  }, {
    key: '$get',
    value: function $get($http, $q, avPollingService, avLocalStorageService, AV_STORAGE) {

      var that = this;

      var AvApiResource = function () {
        function AvApiResource(_options) {
          _classCallCheck(this, AvApiResource);

          this.options = _options;

          if (!this.options) {
            throw new Error('[options] cannot be null or undefined');
          }

          if (this.options.name) {
            this.options.name = this.options.name.charAt(0) === '/' ? this.options.name : '/' + this.options.name;
          }

          if (!this.options.url && !this.options.name) {
            throw new Error('AvApiResource options [url] or [name] cannot be null');
          }

          // get the default options and merge into this instance
          this.options = _angular2.default.extend({}, that.defaultOptions, this.options);

          this.pageBustValue;
        }

        _createClass(AvApiResource, [{
          key: 'config',
          value: function config(_config2) {
            return _angular2.default.extend({}, this.options, _config2 || {});
          }
        }, {
          key: 'cacheBust',
          value: function cacheBust(config) {

            if (config.cacheBust === true) {
              config.params.cacheBust = (0, _moment2.default)().unix();
            } else if (_angular2.default.isFunction(config.cacheBust)) {
              config.params.cacheBust = config.cacheBust();
            } else {
              config.params.cacheBust = config.cacheBust;
            }
          }
        }, {
          key: 'setPageBust',
          value: function setPageBust(value) {
            this.pageBustValue = _angular2.default.isUndefined(value) ? (0, _moment2.default)().unix() : value;
          }
        }, {
          key: 'getPageBust',
          value: function getPageBust() {
            if (_angular2.default.isUndefined(this.pageBustValue)) {
              this.setPageBust();
            }
            return this.pageBustValue;
          }
        }, {
          key: 'pageBust',
          value: function pageBust(config) {
            if (config.pageBust === true) {
              config.params.pageBust = this.getPageBust();
            } else if (_angular2.default.isFunction(config.pageBust)) {
              config.params.pageBust = config.pageBust();
            } else {
              config.params.pageBust = config.pageBust;
            }
          }

          // cacheBust: supports the following types
          //    - true|false: Generate a timestamp each call
          //    - Value: Use this as a chacheBust variable for each call
          //    - Function: Call this function to return the cacheBust variable
          // pageBust: true|false, if true, set a cachebust variable to a timestamp of page load
          // sessionBust: true|false, if true, get the avCacheBust variable from local storage, set at
          //    login (if value not set, works like pageBust)

        }, {
          key: 'cacheParams',
          value: function cacheParams(_config) {

            var config = _angular2.default.copy(_config);
            config.params = config.params || {};

            if (config.cacheBust) {
              this.cacheBust(config);
            }

            if (config.pageBust) {
              this.pageBust(config);
            }

            if (config.sessionBust) {
              config.params.sessionBust = avLocalStorageService.getVal(AV_STORAGE.SESSION_CACHE) || this.getPageBust();
            }

            return config;
          }
        }, {
          key: 'getUrl',
          value: function getUrl(id) {

            if (this.options.api) {
              return this.getApiUrl(id);
            }

            return this.options.url;
          }
        }, {
          key: 'request',
          value: function request(config, afterCallback) {

            var self = this;
            var defer = $q.defer();

            $http(config).then(function (response) {

              // handle the async response if applicable
              var _promise = $q.when(avPollingService.response(response));

              // notify the promise listener of the original response
              defer.notify(response);

              // handle the polling service promise
              _promise.then(function (_successResponse) {

                var successResponse = _successResponse;

                if (afterCallback) {
                  successResponse = afterCallback.call(self, successResponse, config.data);
                }
                defer.resolve(successResponse);
              }, function (errorResponse) {
                return defer.reject(errorResponse);
              }, function (notifyResponse) {
                return defer.notify(notifyResponse);
              });
            }).catch(function (response) {
              defer.reject(response);
            });

            var promise = defer.promise;

            // recreate the success callback ala $http
            promise.success = function (fn) {
              promise.then(function (response) {
                fn(response.data, response.status, response.headers, response.config);
              });
              return promise;
            };

            // recreate the error callback ala $http
            promise.error = function (fn) {

              promise.then(null, function (response) {
                fn(response.data, response.status, response.headers, config);
              });

              return promise;
            };

            promise.always = promise.finally;

            return promise;
          }
        }, {
          key: 'normalize',
          value: function normalize(url) {
            return url.replace(/[\/]+/g, '/').replace(/\/$/, '');
          }
        }, {
          key: 'join',
          value: function join() {
            var joined = [].slice.call(arguments, 0).join('/');
            return this.normalize(joined);
          }
        }, {
          key: 'getApiUrl',
          value: function getApiUrl(_id) {

            var id = _id ? '/' + _id : '';

            var uri = void 0;

            var _options2 = this.options,
                path = _options2.path,
                version = _options2.version,
                name = _options2.name,
                url = _options2.url;


            if (name) {
              uri = this.join('/', path, version, name, id);
            } else {
              uri = this.join(url, id);
            }

            return uri;
          }
        }, {
          key: 'create',
          value: function create(_data, _config) {

            var data = _data;
            var config = _config;

            if (!data) {
              throw new Error('called method without [data]');
            }

            if (this.beforeCreate) {
              data = this.beforeCreate(data);
            }

            config = this.config(config);
            config.method = 'POST';
            config.url = this.getUrl();
            config.data = data;

            return this.request(config, this.afterCreate);
          }
        }, {
          key: 'postGet',
          value: function postGet(_data, _config) {
            var data = _data;
            var config = _config;

            if (!data) {
              throw new Error('called method without [data]');
            }
            if (this.beforePostGet) {
              data = this.beforePostGet(data);
            }
            config = this.config(config);
            config.method = 'POST';
            config.headers['X-HTTP-Method-Override'] = 'GET';
            config.url = this.getUrl();
            config.data = data;

            return this.request(config, this.afterPostGet);
          }
        }, {
          key: 'get',
          value: function get(id, _config) {

            var config = _config;

            if (!id) {
              throw new Error('called method without [id]');
            }

            config = this.config(config);
            config = this.cacheParams(config);

            config.method = 'GET';
            config.url = this.getUrl(id);

            return this.request(config, this.afterGet);
          }
        }, {
          key: 'query',
          value: function query(_config) {

            var config = _config;

            config = this.config(config);
            config = this.cacheParams(config);

            config.method = 'GET';
            config.url = this.getUrl();

            return this.request(config, this.afterQuery);
          }
        }, {
          key: 'update',
          value: function update(id, _data, _config) {

            var config = _config;
            var data = _data;

            var url = void 0;

            if (_angular2.default.isString(id) || _angular2.default.isNumber(id)) {
              url = this.getUrl(id);
            } else {
              url = this.getUrl();

              // At this point the function signature becomes:
              //
              // update(data, config) {} a.k.a function(id, data)
              //
              config = data; // config is really the 2nd param
              data = id; // data is really the first param
            }

            if (this.beforeUpdate) {
              data = this.beforeUpdate(data);
            }

            config = this.config(config);
            config.method = 'PUT';
            config.url = url;
            config.data = data;

            return this.request(config, this.afterUpdate);
          }
        }, {
          key: 'remove',
          value: function remove(id, _config) {

            var config = _config;

            var url = void 0;
            var data = void 0;

            if (_angular2.default.isString(id) || _angular2.default.isNumber(id)) {
              url = this.getUrl(id);
            } else {

              // At this point the function signature becomes:
              //
              // remove(data, config)
              //
              url = this.getUrl();
              data = id;
            }

            config = this.config(config);
            config.method = 'DELETE';
            config.url = url;
            config.data = data;

            return this.request(config, this.afterRemove);
          }
        }, {
          key: 'beforeCreate',
          value: function beforeCreate(data) {
            return data;
          }
        }, {
          key: 'afterCreate',
          value: function afterCreate(response) {
            return response;
          }
        }, {
          key: 'beforePostGet',
          value: function beforePostGet(data) {
            return data;
          }
        }, {
          key: 'afterPostGet',
          value: function afterPostGet(response) {
            return response;
          }
        }, {
          key: 'afterQuery',
          value: function afterQuery(response) {
            return response;
          }
        }, {
          key: 'afterGet',
          value: function afterGet(response) {
            return response;
          }
        }, {
          key: 'beforeUpdate',
          value: function beforeUpdate(data) {
            return data;
          }
        }, {
          key: 'afterUpdate',
          value: function afterUpdate(response) {
            return response;
          }
        }, {
          key: 'afterRemove',
          value: function afterRemove(response) {
            return response;
          }
        }]);

        return AvApiResource;
      }();

      return AvApiResource;
    }
  }]);

  return ApiResourceProvider;
}();

_module2.default.provider('AvApiResource', ApiResourceProvider);

exports.default = _module2.default;