ng2-restangular
Version:
1,052 lines (1,025 loc) • 66.6 kB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory(require("@angular/core"), require("@angular/http"), require("lodash"), require("rxjs"));
else if(typeof define === 'function' && define.amd)
define(["@angular/core", "@angular/http", "lodash", "rxjs"], factory);
else if(typeof exports === 'object')
exports["ng2-restangular"] = factory(require("@angular/core"), require("@angular/http"), require("lodash"), require("rxjs"));
else
root["ng2-restangular"] = factory(root["@angular/core"], root["@angular/http"], root["lodash"], root["rxjs"]);
})(this, function(__WEBPACK_EXTERNAL_MODULE_2__, __WEBPACK_EXTERNAL_MODULE_3__, __WEBPACK_EXTERNAL_MODULE_5__, __WEBPACK_EXTERNAL_MODULE_7__) {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
var ng2_restangular_module_1 = __webpack_require__(1);
exports.RestangularModule = ng2_restangular_module_1.RestangularModule;
var ng2_restangular_1 = __webpack_require__(6);
exports.Restangular = ng2_restangular_1.Restangular;
var ng2_restangular_http_1 = __webpack_require__(8);
exports.RestangularHttp = ng2_restangular_http_1.RestangularHttp;
/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
/* tslint:disable:member-ordering no-unused-variable */
var core_1 = __webpack_require__(2);
var http_1 = __webpack_require__(3);
var ng2_restangular_config_1 = __webpack_require__(4);
var ng2_restangular_1 = __webpack_require__(6);
var ng2_restangular_http_1 = __webpack_require__(8);
exports.CONFIG_OBJ = new core_1.OpaqueToken('configObj');
var RestangularModule = (function () {
function RestangularModule(parentModule) {
if (parentModule) {
throw new Error('RestangularModule is already loaded. Import it in the AppModule only');
}
}
RestangularModule.forRoot = function (config1, config2) {
return {
ngModule: RestangularModule,
providers: [
{ provide: exports.CONFIG_OBJ, useValue: [config1, config2] },
{ provide: ng2_restangular_config_1.RESTANGULAR, useFactory: ng2_restangular_config_1.RestangularFactory, deps: [exports.CONFIG_OBJ] },
]
};
};
RestangularModule = __decorate([
core_1.NgModule({
imports: [http_1.HttpModule],
providers: [ng2_restangular_http_1.RestangularHttp, ng2_restangular_1.Restangular]
}),
__param(0, core_1.Optional()),
__param(0, core_1.SkipSelf()),
__metadata('design:paramtypes', [RestangularModule])
], RestangularModule);
return RestangularModule;
}());
exports.RestangularModule = RestangularModule;
/***/ },
/* 2 */
/***/ function(module, exports) {
module.exports = require("@angular/core");
/***/ },
/* 3 */
/***/ function(module, exports) {
module.exports = require("@angular/http");
/***/ },
/* 4 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
var core_1 = __webpack_require__(2);
var _ = __webpack_require__(5);
exports.RESTANGULAR = new core_1.OpaqueToken('restangularWithConfig');
function RestangularFactory(config) {
var configObj = {
fn: config[0],
arrServices: [],
};
if (_.isArray(config[0])) {
configObj = {
arrServices: config[0],
fn: config[1]
};
}
return configObj;
}
exports.RestangularFactory = RestangularFactory;
/***/ },
/* 5 */
/***/ function(module, exports) {
module.exports = require("lodash");
/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
var core_1 = __webpack_require__(2);
var rxjs_1 = __webpack_require__(7);
var _ = __webpack_require__(5);
var ng2_restangular_config_1 = __webpack_require__(4);
var ng2_restangular_http_1 = __webpack_require__(8);
var ng2_restangular_config_factory_1 = __webpack_require__(10);
var Restangular = (function () {
function Restangular(configObj, injector, http) {
this.configObj = configObj;
this.injector = injector;
this.http = http;
this.provider = new providerConfig(http);
var element = this.provider.$get();
Object.assign(this, element);
this.setDefaultConfig();
}
Restangular.prototype.setDefaultConfig = function () {
var _this = this;
if (!this.configObj || !_.isFunction(this.configObj.fn)) {
return;
}
var arrDI = _.map(this.configObj.arrServices, function (services) {
return _this.injector.get(services);
});
(_a = this.configObj).fn.apply(_a, [this.provider].concat(arrDI));
var _a;
};
Restangular = __decorate([
core_1.Injectable(),
__param(0, core_1.Optional()),
__param(0, core_1.Inject(ng2_restangular_config_1.RESTANGULAR)),
__metadata('design:paramtypes', [Object, core_1.Injector, ng2_restangular_http_1.RestangularHttp])
], Restangular);
return Restangular;
}());
exports.Restangular = Restangular;
function providerConfig($http) {
var globalConfiguration = {};
ng2_restangular_config_factory_1.RestangularConfigurer(this, globalConfiguration);
this.$get = $get;
function $get() {
function createServiceForConfiguration(config) {
var service = {};
var urlHandler = new config.urlCreatorFactory[config.urlCreator]();
urlHandler.setConfig(config);
function restangularizeBase(parent, elem, route, reqParams, fromServer) {
elem[config.restangularFields.route] = route;
elem[config.restangularFields.getRestangularUrl] = _.bind(urlHandler.fetchUrl, urlHandler, elem);
elem[config.restangularFields.getRequestedUrl] = _.bind(urlHandler.fetchRequestedUrl, urlHandler, elem);
elem[config.restangularFields.addRestangularMethod] = _.bind(addRestangularMethodFunction, elem);
elem[config.restangularFields.clone] = _.bind(copyRestangularizedElement, elem);
elem[config.restangularFields.reqParams] = _.isEmpty(reqParams) ? null : reqParams;
elem[config.restangularFields.withHttpConfig] = _.bind(withHttpConfig, elem);
elem[config.restangularFields.plain] = _.bind(stripRestangular, elem, elem);
// Tag element as restangularized
elem[config.restangularFields.restangularized] = true;
// RequestLess connection
elem[config.restangularFields.one] = _.bind(one, elem, elem);
elem[config.restangularFields.all] = _.bind(all, elem, elem);
elem[config.restangularFields.several] = _.bind(several, elem, elem);
elem[config.restangularFields.oneUrl] = _.bind(oneUrl, elem, elem);
elem[config.restangularFields.allUrl] = _.bind(allUrl, elem, elem);
elem[config.restangularFields.fromServer] = !!fromServer;
if (parent && config.shouldSaveParent(route)) {
var parentId = config.getIdFromElem(parent);
var parentUrl = config.getUrlFromElem(parent);
var restangularFieldsForParent = _.union(_.values(_.pick(config.restangularFields, ['route', 'singleOne', 'parentResource'])), config.extraFields);
var parentResource = _.pick(parent, restangularFieldsForParent);
if (config.isValidId(parentId)) {
config.setIdToElem(parentResource, parentId, route);
}
if (config.isValidId(parentUrl)) {
config.setUrlToElem(parentResource, parentUrl, route);
}
elem[config.restangularFields.parentResource] = parentResource;
}
else {
elem[config.restangularFields.parentResource] = null;
}
return elem;
}
function one(parent, route, id, singleOne) {
var error;
if (_.isNumber(route) || _.isNumber(parent)) {
error = 'You\'re creating a Restangular entity with the number ';
error += 'instead of the route or the parent. For example, you can\'t call .one(12).';
throw new Error(error);
}
if (_.isUndefined(route)) {
error = 'You\'re creating a Restangular entity either without the path. ';
error += 'For example you can\'t call .one(). Please check if your arguments are valid.';
throw new Error(error);
}
var elem = {};
config.setIdToElem(elem, id, route);
config.setFieldToElem(config.restangularFields.singleOne, elem, singleOne);
return restangularizeElem(parent, elem, route, false);
}
function all(parent, route) {
return restangularizeCollection(parent, [], route, false);
}
function several(parent, route /*, ids */) {
var collection = [];
collection[config.restangularFields.ids] = Array.prototype.splice.call(arguments, 2);
return restangularizeCollection(parent, collection, route, false);
}
function oneUrl(parent, route, url) {
if (!route) {
throw new Error('Route is mandatory when creating new Restangular objects.');
}
var elem = {};
config.setUrlToElem(elem, url, route);
return restangularizeElem(parent, elem, route, false);
}
function allUrl(parent, route, url) {
if (!route) {
throw new Error('Route is mandatory when creating new Restangular objects.');
}
var elem = {};
config.setUrlToElem(elem, url, route);
return restangularizeCollection(parent, elem, route, false);
}
// Promises
function restangularizeResponse(subject, isCollection, valueToFill) {
return subject.filter(function (res) { return res; });
}
function resolvePromise(subject, response, data, filledValue) {
_.extend(filledValue, data);
// Trigger the full response interceptor.
if (config.fullResponse) {
subject.next(_.extend(response, {
data: data
}));
}
else {
subject.next(data);
}
subject.complete();
}
// Elements
function stripRestangular(elem) {
if (_.isArray(elem)) {
var array = [];
_.each(elem, function (value) {
array.push(config.isRestangularized(value) ? stripRestangular(value) : value);
});
return array;
}
else {
return _.omit(elem, _.values(_.omit(config.restangularFields, 'id')));
}
}
function addCustomOperation(elem) {
elem[config.restangularFields.customOperation] = _.bind(customFunction, elem);
var requestMethods = { get: customFunction, delete: customFunction };
_.each(['put', 'patch', 'post'], function (name) {
requestMethods[name] = function (operation, elem, path, params, headers) {
return _.bind(customFunction, this)(operation, path, params, headers, elem);
};
});
_.each(requestMethods, function (requestFunc, name) {
var callOperation = name === 'delete' ? 'remove' : name;
_.each(['do', 'custom'], function (alias) {
elem[alias + name.toUpperCase()] = _.bind(requestFunc, elem, callOperation);
});
});
elem[config.restangularFields.customGETLIST] = _.bind(fetchFunction, elem);
elem[config.restangularFields.doGETLIST] = elem[config.restangularFields.customGETLIST];
}
function copyRestangularizedElement(fromElement, toElement) {
if (toElement === void 0) { toElement = {}; }
var copiedElement = Object.assign(toElement, fromElement);
return restangularizeElem(copiedElement[config.restangularFields.parentResource], copiedElement, copiedElement[config.restangularFields.route], true);
}
function restangularizeElem(parent, element, route, fromServer, collection, reqParams) {
var elem = config.onBeforeElemRestangularized(element, false, route);
var localElem = restangularizeBase(parent, elem, route, reqParams, fromServer);
if (config.useCannonicalId) {
localElem[config.restangularFields.cannonicalId] = config.getIdFromElem(localElem);
}
if (collection) {
localElem[config.restangularFields.getParentList] = function () {
return collection;
};
}
localElem[config.restangularFields.restangularCollection] = false;
localElem[config.restangularFields.get] = _.bind(getFunction, localElem);
localElem[config.restangularFields.getList] = _.bind(fetchFunction, localElem);
localElem[config.restangularFields.put] = _.bind(putFunction, localElem);
localElem[config.restangularFields.post] = _.bind(postFunction, localElem);
localElem[config.restangularFields.remove] = _.bind(deleteFunction, localElem);
localElem[config.restangularFields.head] = _.bind(headFunction, localElem);
localElem[config.restangularFields.trace] = _.bind(traceFunction, localElem);
localElem[config.restangularFields.options] = _.bind(optionsFunction, localElem);
localElem[config.restangularFields.patch] = _.bind(patchFunction, localElem);
localElem[config.restangularFields.save] = _.bind(save, localElem);
addCustomOperation(localElem);
return config.transformElem(localElem, false, route, service, true);
}
function restangularizeCollection(parent, element, route, fromServer, reqParams) {
var elem = config.onBeforeElemRestangularized(element, true, route);
var localElem = restangularizeBase(parent, elem, route, reqParams, fromServer);
localElem[config.restangularFields.restangularCollection] = true;
localElem[config.restangularFields.post] = _.bind(postFunction, localElem, null);
localElem[config.restangularFields.remove] = _.bind(deleteFunction, localElem);
localElem[config.restangularFields.head] = _.bind(headFunction, localElem);
localElem[config.restangularFields.trace] = _.bind(traceFunction, localElem);
localElem[config.restangularFields.putElement] = _.bind(putElementFunction, localElem);
localElem[config.restangularFields.options] = _.bind(optionsFunction, localElem);
localElem[config.restangularFields.patch] = _.bind(patchFunction, localElem);
localElem[config.restangularFields.get] = _.bind(getById, localElem);
localElem[config.restangularFields.getList] = _.bind(fetchFunction, localElem, null);
addCustomOperation(localElem);
return config.transformElem(localElem, true, route, service, true);
}
function restangularizeCollectionAndElements(parent, element, route) {
var collection = restangularizeCollection(parent, element, route, false);
_.each(collection, function (elem) {
if (elem) {
restangularizeElem(parent, elem, route, false);
}
});
return collection;
}
function getById(id, reqParams, headers) {
return this.customGET(id.toString(), reqParams, headers);
}
function putElementFunction(idx, params, headers) {
var __this = this;
var elemToPut = this[idx];
var subject = new rxjs_1.BehaviorSubject(null);
var filledArray = [];
filledArray = config.transformElem(filledArray, true, elemToPut[config.restangularFields.route], service);
elemToPut.put(params, headers)
.subscribe(function (serverElem) {
var newArray = copyRestangularizedElement(__this);
newArray[idx] = serverElem;
filledArray = newArray;
subject.next(newArray);
}, function (response) {
subject.error(response);
}, function () {
subject.complete();
});
return restangularizeResponse(subject, true, filledArray);
}
function parseResponse(resData, operation, route, fetchUrl, response, subject) {
var data = config.responseExtractor(resData, operation, route, fetchUrl, response, subject);
var etag = response.headers.get('ETag');
if (data && etag) {
data[config.restangularFields.etag] = etag;
}
return data;
}
function fetchFunction(what, reqParams, headers) {
var __this = this;
var subject = new rxjs_1.BehaviorSubject(null);
var operation = 'getList';
var url = urlHandler.fetchUrl(this, what);
var whatFetched = what || __this[config.restangularFields.route];
var request = config.fullRequestInterceptor(null, operation, whatFetched, url, headers || {}, reqParams || {}, this[config.restangularFields.httpConfig] || {});
var filledArray = [];
filledArray = config.transformElem(filledArray, true, whatFetched, service);
var method = 'getList';
if (config.jsonp) {
method = 'jsonp';
}
var okCallback = function (response) {
var resData = response.data;
var fullParams = response.config.params;
var data = parseResponse(resData, operation, whatFetched, url, response, subject);
// support empty response for getList() calls (some APIs respond with 204 and empty body)
if (_.isUndefined(data) || '' === data) {
data = [];
}
if (!_.isArray(data)) {
throw new Error('Response for getList SHOULD be an array and not an object or something else');
}
if (true === config.plainByDefault) {
return resolvePromise(subject, response, data, filledArray);
}
var processedData = _.map(data, function (elem) {
if (!__this[config.restangularFields.restangularCollection]) {
return restangularizeElem(__this, elem, what, true, data);
}
else {
return restangularizeElem(__this[config.restangularFields.parentResource], elem, __this[config.restangularFields.route], true, data);
}
});
processedData = _.extend(data, processedData);
if (!__this[config.restangularFields.restangularCollection]) {
resolvePromise(subject, response, restangularizeCollection(__this, processedData, what, true, fullParams), filledArray);
}
else {
resolvePromise(subject, response, restangularizeCollection(__this[config.restangularFields.parentResource], processedData, __this[config.restangularFields.route], true, fullParams), filledArray);
}
};
urlHandler.resource(this, $http, request.httpConfig, request.headers, request.params, what, this[config.restangularFields.etag], operation)[method]()
.subscribe(okCallback, function error(response) {
if (response.status === 304 && __this[config.restangularFields.restangularCollection]) {
resolvePromise(subject, response, __this, filledArray);
}
else if (_.every(config.errorInterceptors, function (cb) {
return cb(response, subject, okCallback) !== false;
})) {
// triggered if no callback returns false
subject.error(response);
}
});
return restangularizeResponse(subject, true, filledArray);
}
function withHttpConfig(httpConfig) {
this[config.restangularFields.httpConfig] = httpConfig;
return this;
}
function save(params, headers) {
if (this[config.restangularFields.fromServer]) {
return this[config.restangularFields.put](params, headers);
}
else {
return _.bind(elemFunction, this)('post', undefined, params, undefined, headers);
}
}
function elemFunction(operation, what, params, obj, headers) {
var __this = this;
var subject = new rxjs_1.BehaviorSubject(null);
var resParams = params || {};
var route = what || this[config.restangularFields.route];
var fetchUrl = urlHandler.fetchUrl(this, what);
var callObj = obj || this;
// fallback to etag on restangular object (since for custom methods we probably don't explicitly specify the etag field)
var etag = callObj[config.restangularFields.etag] || (operation !== 'post' ? this[config.restangularFields.etag] : null);
if (_.isObject(callObj) && config.isRestangularized(callObj)) {
callObj = stripRestangular(callObj);
}
var request = config.fullRequestInterceptor(callObj, operation, route, fetchUrl, headers || {}, resParams || {}, this[config.restangularFields.httpConfig] || {});
var filledObject = {};
filledObject = config.transformElem(filledObject, false, route, service);
var okCallback = function (response) {
var resData = _.get(response, 'data');
var fullParams = _.get(response, 'config.params');
var elem = parseResponse(resData, operation, route, fetchUrl, response, subject);
if (elem) {
var data;
if (true === config.plainByDefault) {
return resolvePromise(subject, response, elem, filledObject);
}
if (operation === 'post' && !__this[config.restangularFields.restangularCollection]) {
data = restangularizeElem(__this[config.restangularFields.parentResource], elem, route, true, null, fullParams);
resolvePromise(subject, response, data, filledObject);
}
else {
data = restangularizeElem(__this[config.restangularFields.parentResource], elem, __this[config.restangularFields.route], true, null, fullParams);
data[config.restangularFields.singleOne] = __this[config.restangularFields.singleOne];
resolvePromise(subject, response, data, filledObject);
}
}
else {
resolvePromise(subject, response, undefined, filledObject);
}
};
var errorCallback = function (response) {
if (response.status === 304 && config.isSafe(operation)) {
resolvePromise(subject, response, __this, filledObject);
}
else if (_.every(config.errorInterceptors, function (cb) {
return cb(response, subject, okCallback) !== false;
})) {
// triggered if no callback returns false
subject.error(response);
}
};
// Overriding HTTP Method
var callOperation = operation;
var callHeaders = _.extend({}, request.headers);
var isOverrideOperation = config.isOverridenMethod(operation);
if (isOverrideOperation) {
callOperation = 'post';
callHeaders = _.extend(callHeaders, { 'X-HTTP-Method-Override': operation === 'remove' ? 'DELETE' : operation.toUpperCase() });
}
else if (config.jsonp && callOperation === 'get') {
callOperation = 'jsonp';
}
if (config.isSafe(operation)) {
if (isOverrideOperation) {
urlHandler.resource(this, $http, request.httpConfig, callHeaders, request.params, what, etag, callOperation)[callOperation]({}).subscribe(okCallback, errorCallback);
}
else {
urlHandler.resource(this, $http, request.httpConfig, callHeaders, request.params, what, etag, callOperation)[callOperation]().subscribe(okCallback, errorCallback);
}
}
else {
urlHandler.resource(this, $http, request.httpConfig, callHeaders, request.params, what, etag, callOperation)[callOperation](request.element).subscribe(okCallback, errorCallback);
}
return restangularizeResponse(subject, false, filledObject);
}
function getFunction(params, headers) {
return _.bind(elemFunction, this)('get', undefined, params, undefined, headers);
}
function deleteFunction(params, headers) {
return _.bind(elemFunction, this)('remove', undefined, params, undefined, headers);
}
function putFunction(params, headers) {
return _.bind(elemFunction, this)('put', undefined, params, undefined, headers);
}
function postFunction(what, elem, params, headers) {
return _.bind(elemFunction, this)('post', what, params, elem, headers);
}
function headFunction(params, headers) {
return _.bind(elemFunction, this)('head', undefined, params, undefined, headers);
}
function traceFunction(params, headers) {
return _.bind(elemFunction, this)('trace', undefined, params, undefined, headers);
}
function optionsFunction(params, headers) {
return _.bind(elemFunction, this)('options', undefined, params, undefined, headers);
}
function patchFunction(elem, params, headers) {
return _.bind(elemFunction, this)('patch', undefined, params, elem, headers);
}
function customFunction(operation, path, params, headers, elem) {
return _.bind(elemFunction, this)(operation, path, params, elem, headers);
}
function addRestangularMethodFunction(name, operation, path, defaultParams, defaultHeaders, defaultElem) {
var bindedFunction;
if (operation === 'getList') {
bindedFunction = _.bind(fetchFunction, this, path);
}
else {
bindedFunction = _.bind(customFunction, this, operation, path);
}
var createdFunction = function (params, headers, elem) {
var callParams = _.defaults({
params: params,
headers: headers,
elem: elem
}, {
params: defaultParams,
headers: defaultHeaders,
elem: defaultElem
});
return bindedFunction(callParams.params, callParams.headers, callParams.elem);
};
if (config.isSafe(operation)) {
this[name] = createdFunction;
}
else {
this[name] = function (elem, params, headers) {
return createdFunction(params, headers, elem);
};
}
}
function withConfigurationFunction(configurer) {
var newConfig = _.clone(_.omit(config, 'configuration'));
ng2_restangular_config_factory_1.RestangularConfigurer(newConfig, newConfig);
configurer(newConfig);
return createServiceForConfiguration(newConfig);
}
function toService(route, parent) {
var knownCollectionMethods = _.values(config.restangularFields);
var serv = {};
var collection = (parent || service).all(route);
serv.one = _.bind(one, (parent || service), parent, route);
serv.post = _.bind(collection.post, collection);
serv.getList = _.bind(collection.getList, collection);
for (var prop in collection) {
if (collection.hasOwnProperty(prop) && _.isFunction(collection[prop]) && !_.includes(knownCollectionMethods, prop)) {
serv[prop] = _.bind(collection[prop], collection);
}
}
return serv;
}
ng2_restangular_config_factory_1.RestangularConfigurer(service, config);
service.copy = _.bind(copyRestangularizedElement, service);
service.service = _.bind(toService, service);
service.withConfig = _.bind(withConfigurationFunction, service);
service.one = _.bind(one, service, null);
service.all = _.bind(all, service, null);
service.several = _.bind(several, service, null);
service.oneUrl = _.bind(oneUrl, service, null);
service.allUrl = _.bind(allUrl, service, null);
service.stripRestangular = _.bind(stripRestangular, service);
service.restangularizeElement = _.bind(restangularizeElem, service);
service.restangularizeCollection = _.bind(restangularizeCollectionAndElements, service);
return service;
}
return createServiceForConfiguration(globalConfiguration);
}
;
}
/***/ },
/* 7 */
/***/ function(module, exports) {
module.exports = require("rxjs");
/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var core_1 = __webpack_require__(2);
var http_1 = __webpack_require__(3);
var rxjs_1 = __webpack_require__(7);
var ng2_restangular_helper_1 = __webpack_require__(9);
var RestangularHttp = (function () {
function RestangularHttp(http) {
this.http = http;
}
RestangularHttp.prototype.createRequest = function (options) {
var requestOptions = ng2_restangular_helper_1.RestangularHelper.createRequestOptions(options);
var request = new http_1.Request(requestOptions);
return this.request(request);
};
RestangularHttp.prototype.request = function (request) {
var _this = this;
return this.http.request(request)
.map(function (response) {
response.config = { params: request };
return response;
})
.map(function (response) {
if (response._body) {
response.data = typeof response._body == 'string' ? JSON.parse(response._body) : response._body;
}
else {
response.data = null;
}
return response;
})
.catch(function (err) {
err.data = typeof err._body == 'string' ? JSON.parse(err._body) : err._body;
err.request = request;
err.repeatRequest = function (newRequest) {
return _this.request(newRequest || request);
};
return rxjs_1.Observable.throw(err);
});
};
RestangularHttp = __decorate([
core_1.Injectable(),
__metadata('design:paramtypes', [http_1.Http])
], RestangularHttp);
return RestangularHttp;
}());
exports.RestangularHttp = RestangularHttp;
/***/ },
/* 9 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
var http_1 = __webpack_require__(3);
var RestangularHelper = (function () {
function RestangularHelper() {
}
RestangularHelper.createRequestOptions = function (options) {
var requestQueryParams = RestangularHelper.createRequestQueryParams(options.params);
var requestHeaders = RestangularHelper.createRequestHeaders(options.headers);
var methodName = options.method.charAt(0).toUpperCase() + options.method.substr(1).toLowerCase();
var withCredentials = options.withCredentials || false;
var requestOptions = new http_1.RequestOptions({
method: http_1.RequestMethod[methodName],
headers: requestHeaders,
search: requestQueryParams,
url: options.url,
body: options.data,
withCredentials: withCredentials
});
return requestOptions;
};
RestangularHelper.createRequestQueryParams = function (queryParams) {
var requestQueryParams = Object.assign({}, queryParams);
var search = new http_1.URLSearchParams();
for (var key in requestQueryParams) {
var value = requestQueryParams[key];
if (typeof value === 'object') {
value = JSON.stringify(value);
}
search.append(key, value);
}
return search;
};
RestangularHelper.createRequestHeaders = function (headers) {
for (var key in headers) {
var value = headers[key];
if (typeof value === 'undefined') {
delete headers[key];
}
}
return new http_1.Headers(Object.assign({}, headers));
};
return RestangularHelper;
}());
exports.RestangularHelper = RestangularHelper;
/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
var _ = __webpack_require__(5);
function RestangularConfigurer(object, config) {
object.configuration = config;
/**
* Those are HTTP safe methods for which there is no need to pass any data with the request.
*/
var safeMethods = ['get', 'head', 'options', 'trace', 'getlist'];
config.isSafe = function (operation) {
return _.includes(safeMethods, operation.toLowerCase());
};
var absolutePattern = /^https?:\/\//i;
config.isAbsoluteUrl = function (string) {
return _.isUndefined(config.absoluteUrl) || _.isNull(config.absoluteUrl) ?
string && absolutePattern.test(string) :
config.absoluteUrl;
};
config.absoluteUrl = _.isUndefined(config.absoluteUrl) ? true : config.absoluteUrl;
object.setSelfLinkAbsoluteUrl = function (value) {
config.absoluteUrl = value;
};
/**
* This is the BaseURL to be used with Restangular
*/
config.baseUrl = _.isUndefined(config.baseUrl) ? '' : config.baseUrl;
object.setBaseUrl = function (newBaseUrl) {
config.baseUrl = /\/$/.test(newBaseUrl) ?
newBaseUrl.substring(0, newBaseUrl.length - 1) :
newBaseUrl;
return this;
};
/**
* Sets the extra fields to keep from the parents
*/
config.extraFields = config.extraFields || [];
object.setExtraFields = function (newExtraFields) {
config.extraFields = newExtraFields;
return this;
};
/**
* Some default $http parameter to be used in EVERY call
**/
config.defaultHttpFields = config.defaultHttpFields || {};
object.setDefaultHttpFields = function (values) {
config.defaultHttpFields = values;
return this;
};
/**
* Always return plain data, no restangularized object
**/
config.plainByDefault = config.plainByDefault || false;
object.setPlainByDefault = function (value) {
config.plainByDefault = value === true ? true : false;
return this;
};
config.withHttpValues = function (httpLocalConfig, obj) {
return _.defaults(obj, httpLocalConfig, config.defaultHttpFields);
};
config.encodeIds = _.isUndefined(config.encodeIds) ? true : config.encodeIds;
object.setEncodeIds = function (encode) {
config.encodeIds = encode;
};
config.defaultRequestParams = config.defaultRequestParams || {
get: {},
post: {},
put: {},
remove: {},
common: {}
};
object.setDefaultRequestParams = function (param1, param2) {
var methods = [], params = param2 || param1;
if (!_.isUndefined(param2)) {
if (_.isArray(param1)) {
methods = param1;
}
else {
methods.push(param1);
}
}
else {
methods.push('common');
}
_.each(methods, function (method) {
config.defaultRequestParams[method] = params;
});
return this;
};
object.requestParams = config.defaultRequestParams;
config.defaultHeaders = config.defaultHeaders || {};
object.setDefaultHeaders = function (headers) {
config.defaultHeaders = headers;
object.defaultHeaders = config.defaultHeaders;
return this;
};
object.defaultHeaders = config.defaultHeaders;
/**
* Method overriders response Method
**/
config.defaultResponseMethod = config.defaultResponseMethod || 'promise';
object.setDefaultResponseMethod = function (method) {
config.defaultResponseMethod = method;
object.defaultResponseMethod = config.defaultResponseMethod;
return this;
};
object.defaultResponseMethod = config.defaultResponseMethod;
/**
* Method overriders will set which methods are sent via POST with an X-HTTP-Method-Override
**/
config.methodOverriders = config.methodOverriders || [];
object.setMethodOverriders = function (values) {
var overriders = _.extend([], values);
if (config.isOverridenMethod('delete', overriders)) {
overriders.push('remove');
}
config.methodOverriders = overriders;
return this;
};
config.jsonp = _.isUndefined(config.jsonp) ? false : config.jsonp;
object.setJsonp = function (active) {
config.jsonp = active;
};
config.isOverridenMethod = function (method, values) {
var search = values || config.methodOverriders;
return !_.isUndefined(_.find(search, function (one) {
return one.toLowerCase() === method.toLowerCase();
}));
};
/**
* Sets the URL creator type. For now, only Path is created. In the future we'll have queryParams
**/
config.urlCreator = config.urlCreator || 'path';
object.setUrlCreator = function (name) {
if (!_.has(config.urlCreatorFactory, name)) {
throw new Error('URL Path selected isn\'t valid');
}
config.urlCreator = name;
return this;
};
/**
* You can set the restangular fields here. The 3 required fields for Restangular are:
*
* id: Id of the element
* route: name of the route of this element
* parentResource: the reference to the parent resource
*
* All of this fields except for id, are handled (and created) by Restangular. By default,
* the field values will be id, route and parentResource respectively
*/
config.restangularFields = config.restangularFields || {
id: 'id',
route: 'route',
parentResource: 'parentResource',
restangularCollection: 'restangularCollection',
cannonicalId: '__cannonicalId',
etag: 'restangularEtag',
selfLink: 'href',
get: 'get',
getList: 'getList',
put: 'put',
post: 'post',
remove: 'remove',
head: 'head',
trace: 'trace',
options: 'options',
patch: 'patch',
getRestangularUrl: 'getRestangularUrl',
getRequestedUrl: 'getRequestedUrl',
putElement: 'putElement',
addRestangularMethod: 'addRestangularMethod',
getParentList: 'getParentList',
clone: 'clone',
ids: 'ids',
httpConfig: '_$httpConfig',
reqParams: 'reqParams',
one: 'one',
all: 'all',
several: 'several',
oneUrl: 'oneUrl',
allUrl: 'allUrl',
customPUT: 'customPUT',
customPATCH: 'customPATCH',
customPOST: 'customPOST',
customDELETE: 'customDELETE',
customGET: 'customGET',
customGETLIST: 'customGETLIST',
customOperation: 'customOperation',
doPUT: 'doPUT',
doPATCH: 'doPATCH',
doPOST: 'doPOST',
doDELETE: 'doDELETE',
doGET: 'doGET',
doGETLIST: 'doGETLIST',
fromServer: 'fromServer',
withConfig: 'withConfig',
withHttpConfig: 'withHttpConfig',
singleOne: 'singleOne',
plain: 'plain',
save: 'save',
restangularized: 'restangularized'
};
object.setRestangularFields = function (resFields) {
config.restangularFields =
_.extend(config.restangularFields, resFields);
return this;
};
config.isRestangularized = function (obj) {
return !!obj[config.restangularFields.restangularized];
};
config.setFieldToElem = function (field, elem, value) {
var properties = field.split('.');
var idValue = elem;
_.each(_.initial(properties), function (prop) {
idValue[prop] = {};
idValue = idValue[prop];
});
var index = _.last(properties);
idValue[index] = value;
return this;
};
config.getFieldFromElem = function (field, elem) {
var properties = field.split('.');
var idValue = elem;
_.each(properties, function (prop) {
if (idValue) {
idValue = idValue[prop];
}
});
return _.clone(idValue);
};
config.setIdToElem = function (elem, id /*, route */) {
config.setFieldToElem(config.restangularFields.id, elem, id);
return this;
};
config.getIdFromElem = function (elem) {
return config.getFieldFromElem(config.restangularFields.id, elem);
};
config.isValidId = function (elemId) {
return '' !== elemId && !_.isUndefined(elemId) && !_.isNull(elemId);
};
config.setUrlToElem = function (elem, url /*, route */) {
config.setFieldToElem(config.restangularFields.selfLink, elem, url);
return this;
};
config.getUrlFromElem = function (elem) {
return config.getFieldFromElem(config.restangularFields.selfLink, elem);
};
config.useCannonicalId = _.isUndefined(config.useCannonicalId) ? false : config.useCannonicalId;
object.setUseCannonicalId = function (value) {
config.useCannonicalId = value;
return this;
};
config.getCannonicalIdFromElem = function (elem) {
var cannonicalId = elem[config.restangularFields.cannonicalId];
var actualId = config.isValidId(cannonicalId) ? cannonicalId : config.getIdFromElem(elem);
return actualId;
};
/**
* Sets the Response parser. This is used in case your response isn't directly the data.
* For example if you have a response like {meta: {'meta'}, data: {name: 'Gonto'}}
* you can extract this data which is the one that needs wrapping
*
* The ResponseExtract