@documment/mmp.ui.data/index.js

This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 1.0.1.

import { Injectable, NgModule } from '@angular/core';
import { Store, combineReducers } from '@ngrx/store/index';
import 'rxjs/add/operator/catch';
import 'rxjs/add/operator/map';
import { Headers, Http, HttpModule, Response } from '@angular/http';
import { Observable as Observable$1 } from 'rxjs/Observable';
import { cloneDeep, each, filter, find, findIndex, forOwn, get, hasIn, isEmpty, isEqual, isString, join, replace, size, some, trimEnd, trimStart } from 'lodash/index';
import { Dmc, ExchequerEvent, File, Goal, GoalMeta, GoalsFilter, Institution, OAuthResponse, Reaction, S3FileResponse, SocketFiltersRequest, SocketRefreshGoals, SocketRefreshInstitutions, SocketRefreshTransactions, SocketRefreshUsers, SocketRemoveGoal, SocketRemoveInstitution, SocketRemoveTransaction, SocketRemoveUser, SocketUpsertGoal, SocketUpsertInstitution, SocketUpsertTransaction, SocketUpsertUser, SystemHealth, Transaction, TransactionsFilter, User, Vitals } from '@documment/mmp.core/index';
import { Subject as Subject$1 } from 'rxjs/Subject';
import 'rxjs/add/operator/take';
import moment from 'moment';
import { connect } from 'socket.io-client';

var ApiOptions = (function () {
    /**
     * @param {?=} params
     */
    function ApiOptions(params) {
        if (params === void 0) { params = null; }
        this.publishStatus = get(params, 'publishStatus', true);
        this.publishData = get(params, 'publishData', true);
        this.publishReaction = get(params, 'publishReaction', true);
    }
    return ApiOptions;
}());
ApiOptions.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
ApiOptions.ctorParameters = function () { return [
    null,
]; };

var HttpResponseParser = (function () {
    function HttpResponseParser() {
    }
    /**
     * @param {?} response
     * @return {?}
     */
    HttpResponseParser.prototype.parse = function (response) {
        var /** @type {?} */ body = {};
        if (response) {
            if (response instanceof Response) {
                try {
                    var /** @type {?} */ json = response.json();
                    body = json || {};
                }
                catch (e) {
                    body = {};
                }
            }
            else {
                var /** @type {?} */ message = response.message ? response.message : response.toString();
                body = { message: message };
            }
        }
        return body;
    };
    return HttpResponseParser;
}());
HttpResponseParser.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
HttpResponseParser.ctorParameters = function () { return []; };

var ReactionMapper = (function () {
    /**
     * @param {?} responseParser
     */
    function ReactionMapper(responseParser) {
        this.responseParser = responseParser;
    }
    /**
     * @param {?} response
     * @return {?}
     */
    ReactionMapper.prototype.map = function (response) {
        var /** @type {?} */ body = this.responseParser.parse(response);
        return new Reaction(body);
    };
    return ReactionMapper;
}());
ReactionMapper.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
ReactionMapper.ctorParameters = function () { return [
    { type: HttpResponseParser, },
]; };

var OAuthCredentials = (function () {
    function OAuthCredentials() {
    }
    /**
     * @param {?} accessToken
     * @param {?} tokenType
     * @return {?}
     */
    OAuthCredentials.prototype.set = function (accessToken, tokenType) {
        this.accessToken = accessToken;
        this.tokenType = tokenType;
    };
    return OAuthCredentials;
}());
OAuthCredentials.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
OAuthCredentials.ctorParameters = function () { return []; };

var HttpHeaderBuilder = (function () {
    /**
     * @param {?} oAuthCredentials
     */
    function HttpHeaderBuilder(oAuthCredentials) {
        this.oAuthCredentials = oAuthCredentials;
    }
    /**
     * @return {?}
     */
    HttpHeaderBuilder.prototype.build = function () {
        var /** @type {?} */ headers = new Headers();
        headers.append('Content-Type', 'application/json');
        if (this.oAuthCredentials.accessToken) {
            var /** @type {?} */ authorizationHeader = this.oAuthCredentials.tokenType + ' ' + this.oAuthCredentials.accessToken;
            headers.append('Authorization', authorizationHeader);
        }
        return headers;
    };
    return HttpHeaderBuilder;
}());
HttpHeaderBuilder.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
HttpHeaderBuilder.ctorParameters = function () { return [
    { type: OAuthCredentials, },
]; };

var HttpBodyBuilder = (function () {
    function HttpBodyBuilder() {
    }
    /**
     * @param {?} params
     * @return {?}
     */
    HttpBodyBuilder.prototype.build = function (params) {
        var /** @type {?} */ body = '';
        if (params) {
            if (!isEmpty(params)) {
                try {
                    if (!isString(params)) {
                        body = JSON.stringify(params);
                    }
                    else {
                        body = params.toString();
                    }
                }
                catch (e) {
                    body = params.toString();
                }
            }
        }
        return body;
    };
    return HttpBodyBuilder;
}());
HttpBodyBuilder.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
HttpBodyBuilder.ctorParameters = function () { return []; };

var ApiConfig = (function () {
    /**
     * @param {?} rootUrl
     * @param {?} clientId
     * @param {?} clientSecret
     * @param {?} grantType
     */
    function ApiConfig(rootUrl, clientId, clientSecret, grantType) {
        this.rootUrl = rootUrl;
        this.clientId = clientId;
        this.clientSecret = clientSecret;
        this.grantType = grantType;
    }
    return ApiConfig;
}());
ApiConfig.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
ApiConfig.ctorParameters = function () { return [
    null,
    null,
    null,
    null,
]; };

var HttpUrlBuilder = (function () {
    /**
     * @param {?} apiConfig
     */
    function HttpUrlBuilder(apiConfig) {
        this.apiConfig = apiConfig;
    }
    /**
     * @param {?} routeUrl
     * @return {?}
     */
    HttpUrlBuilder.prototype.build = function (routeUrl) {
        var /** @type {?} */ root = trimEnd(this.apiConfig.rootUrl, '/');
        var /** @type {?} */ route = trimStart(routeUrl, '/');
        var /** @type {?} */ url = root + '/' + route;
        return url;
    };
    return HttpUrlBuilder;
}());
HttpUrlBuilder.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
HttpUrlBuilder.ctorParameters = function () { return [
    { type: ApiConfig, },
]; };

var AuthPublisher = (function () {
    function AuthPublisher() {
        this.subject = new Subject$1();
    }
    /**
     * @param {?} state
     * @return {?}
     */
    AuthPublisher.prototype.next = function (state) {
        this.subject.next(state);
    };
    /**
     * @param {?} complete
     * @return {?}
     */
    AuthPublisher.prototype.subscribe = function (complete) {
        return this.subject.subscribe(complete);
    };
    /**
     * @return {?}
     */
    AuthPublisher.prototype.unsubscribe = function () {
        this.subject.unsubscribe();
    };
    return AuthPublisher;
}());
AuthPublisher.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
AuthPublisher.ctorParameters = function () { return []; };

var SessionPublisher = (function () {
    /**
     * @param {?} authPublisher
     */
    function SessionPublisher(authPublisher) {
        this.authPublisher = authPublisher;
    }
    Object.defineProperty(SessionPublisher.prototype, "auth", {
        /**
         * @return {?}
         */
        get: function () {
            return this.authPublisher;
        },
        enumerable: true,
        configurable: true
    });
    return SessionPublisher;
}());
SessionPublisher.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
SessionPublisher.ctorParameters = function () { return [
    { type: AuthPublisher, },
]; };

var ApiPublisher = (function () {
    function ApiPublisher() {
        this.subject = new Subject$1();
    }
    /**
     * @param {?} state
     * @return {?}
     */
    ApiPublisher.prototype.next = function (state) {
        this.subject.next(state);
    };
    /**
     * @param {?} complete
     * @return {?}
     */
    ApiPublisher.prototype.subscribe = function (complete) {
        return this.subject.subscribe(complete);
    };
    /**
     * @return {?}
     */
    ApiPublisher.prototype.unsubscribe = function () {
        this.subject.unsubscribe();
    };
    return ApiPublisher;
}());
ApiPublisher.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
ApiPublisher.ctorParameters = function () { return []; };

var ReactionPublisher = (function () {
    function ReactionPublisher() {
        this.subject = new Subject$1();
    }
    /**
     * @param {?} state
     * @return {?}
     */
    ReactionPublisher.prototype.next = function (state) {
        this.subject.next(state);
    };
    /**
     * @param {?} complete
     * @return {?}
     */
    ReactionPublisher.prototype.subscribe = function (complete) {
        return this.subject.subscribe(complete);
    };
    /**
     * @return {?}
     */
    ReactionPublisher.prototype.unsubscribe = function () {
        this.subject.unsubscribe();
    };
    return ReactionPublisher;
}());
ReactionPublisher.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
ReactionPublisher.ctorParameters = function () { return []; };

var StatePublisher = (function () {
    /**
     * @param {?} apiPublisher
     * @param {?} reactionPublisher
     */
    function StatePublisher(apiPublisher, reactionPublisher) {
        this.apiPublisher = apiPublisher;
        this.reactionPublisher = reactionPublisher;
    }
    Object.defineProperty(StatePublisher.prototype, "api", {
        /**
         * @return {?}
         */
        get: function () {
            return this.apiPublisher;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(StatePublisher.prototype, "reaction", {
        /**
         * @return {?}
         */
        get: function () {
            return this.reactionPublisher;
        },
        enumerable: true,
        configurable: true
    });
    return StatePublisher;
}());
StatePublisher.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
StatePublisher.ctorParameters = function () { return [
    { type: ApiPublisher, },
    { type: ReactionPublisher, },
]; };

var ApiState = (function () {
    /**
     * @param {?} params
     */
    function ApiState(params) {
        this.isBusy = get(params, 'isBusy', false);
        this.method = get(params, 'method', '');
        this.route = get(params, 'route', '');
    }
    return ApiState;
}());

var AuthState = (function () {
    /**
     * @param {?} params
     */
    function AuthState(params) {
        if (params) {
            this.isAuthenticated = params.isAuthenticated;
            this.user = params.user;
        }
    }
    return AuthState;
}());
AuthState.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
AuthState.ctorParameters = function () { return [
    null,
]; };

var HttpRequester = (function () {
    /**
     * @param {?} http
     * @param {?} headerBuilder
     * @param {?} bodyBuilder
     * @param {?} urlBuilder
     * @param {?} reactionMapper
     * @param {?} statePublisher
     * @param {?} sessionPublisher
     */
    function HttpRequester(http$$1, headerBuilder, bodyBuilder, urlBuilder, reactionMapper, statePublisher, sessionPublisher) {
        this.http = http$$1;
        this.headerBuilder = headerBuilder;
        this.bodyBuilder = bodyBuilder;
        this.urlBuilder = urlBuilder;
        this.reactionMapper = reactionMapper;
        this.statePublisher = statePublisher;
        this.sessionPublisher = sessionPublisher;
    }
    /**
     * @param {?} route
     * @param {?=} options
     * @return {?}
     */
    HttpRequester.prototype.get = function (route, options) {
        var _this = this;
        if (options === void 0) { options = null; }
        options = options || new ApiOptions();
        return Observable$1.create(function (observer) {
            var /** @type {?} */ method = 'get';
            if (options.publishStatus) {
                _this.statePublisher.api.next(new ApiState({ isBusy: true, method: method, route: route }));
            }
            var /** @type {?} */ headers = _this.headerBuilder.build();
            var /** @type {?} */ url = _this.urlBuilder.build(route);
            _this.http.get(url, { headers: headers })
                .subscribe(function (response) {
                _this.handleResponse(response, options, observer, method, route);
            }, function (error) {
                _this.handleError(error, options, observer, method, route);
            });
        });
    };
    /**
     * @param {?} route
     * @param {?=} options
     * @return {?}
     */
    HttpRequester.prototype.delete = function (route, options) {
        var _this = this;
        if (options === void 0) { options = null; }
        options = options || new ApiOptions();
        return Observable$1.create(function (observer) {
            var /** @type {?} */ method = 'delete';
            if (options.publishStatus) {
                _this.statePublisher.api.next(new ApiState({ isBusy: true, method: method, route: route }));
            }
            var /** @type {?} */ headers = _this.headerBuilder.build();
            var /** @type {?} */ url = _this.urlBuilder.build(route);
            _this.http.delete(url, { headers: headers })
                .subscribe(function (response) {
                _this.handleResponse(response, options, observer, method, route);
            }, function (error) {
                _this.handleError(error, options, observer, method, route);
            });
        });
    };
    /**
     * @param {?} route
     * @param {?} params
     * @param {?=} options
     * @return {?}
     */
    HttpRequester.prototype.post = function (route, params, options) {
        var _this = this;
        if (options === void 0) { options = null; }
        options = options || new ApiOptions();
        return Observable$1.create(function (observer) {
            var /** @type {?} */ method = 'post';
            if (options.publishStatus) {
                _this.statePublisher.api.next(new ApiState({ isBusy: true, method: method, route: route }));
            }
            var /** @type {?} */ headers = _this.headerBuilder.build();
            var /** @type {?} */ url = _this.urlBuilder.build(route);
            var /** @type {?} */ body = _this.bodyBuilder.build(params);
            _this.http.post(url, body, { headers: headers })
                .subscribe(function (response) {
                _this.handleResponse(response, options, observer, method, route);
            }, function (error) {
                _this.handleError(error, options, observer, method, route);
            });
        });
    };
    /**
     * @param {?} route
     * @param {?} params
     * @param {?=} options
     * @return {?}
     */
    HttpRequester.prototype.put = function (route, params, options) {
        var _this = this;
        if (options === void 0) { options = null; }
        options = options || new ApiOptions();
        return Observable$1.create(function (observer) {
            var /** @type {?} */ method = 'put';
            if (options.publishStatus) {
                _this.statePublisher.api.next(new ApiState({ isBusy: true, method: method, route: route }));
            }
            var /** @type {?} */ headers = _this.headerBuilder.build();
            var /** @type {?} */ url = _this.urlBuilder.build(route);
            var /** @type {?} */ body = _this.bodyBuilder.build(params);
            _this.http.put(url, body, { headers: headers })
                .subscribe(function (response) {
                _this.handleResponse(response, options, observer, method, route);
            }, function (error) {
                _this.handleError(error, options, observer, method, route);
            });
        });
    };
    /**
     * @param {?} response
     * @param {?} options
     * @param {?} observer
     * @param {?} method
     * @param {?} route
     * @return {?}
     */
    HttpRequester.prototype.handleResponse = function (response, options, observer, method, route) {
        if (options.publishStatus) {
            this.statePublisher.api.next(new ApiState({ isBusy: false, method: method, route: route }));
        }
        observer.next(response);
        observer.complete();
    };
    /**
     * @param {?} error
     * @param {?} options
     * @param {?} observer
     * @param {?} method
     * @param {?} route
     * @return {?}
     */
    HttpRequester.prototype.handleError = function (error, options, observer, method, route) {
        if (error.status === 401) {
            this.sessionPublisher.auth.next(new AuthState({ isAuthenticated: false, user: null }));
        }
        if (options.publishReaction) {
            var /** @type {?} */ reaction = this.reactionMapper.map(error);
            this.statePublisher.reaction.next(reaction);
        }
        if (options.publishStatus) {
            this.statePublisher.api.next(new ApiState({ isBusy: false, method: method, route: route }));
        }
        observer.error(error);
    };
    return HttpRequester;
}());
HttpRequester.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
HttpRequester.ctorParameters = function () { return [
    { type: Http, },
    { type: HttpHeaderBuilder, },
    { type: HttpBodyBuilder, },
    { type: HttpUrlBuilder, },
    { type: ReactionMapper, },
    { type: StatePublisher, },
    { type: SessionPublisher, },
]; };

var InstitutionMapper = (function () {
    /**
     * @param {?} responseParser
     */
    function InstitutionMapper(responseParser) {
        this.responseParser = responseParser;
    }
    /**
     * @param {?} response
     * @return {?}
     */
    InstitutionMapper.prototype.map = function (response) {
        var /** @type {?} */ body = this.responseParser.parse(response);
        return new Institution(body);
    };
    return InstitutionMapper;
}());
InstitutionMapper.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
InstitutionMapper.ctorParameters = function () { return [
    { type: HttpResponseParser, },
]; };

var ServiceResponder = (function () {
    /**
     * @param {?} reactionMapper
     */
    function ServiceResponder(reactionMapper) {
        this.reactionMapper = reactionMapper;
    }
    /**
     * @template T
     * @param {?} options
     * @param {?} mapper
     * @param {?} publisher
     * @param {?} response
     * @return {?}
     */
    ServiceResponder.prototype.response = function (options, mapper, publisher, response) {
        var /** @type {?} */ model = mapper.map(response);
        if (options.publishData) {
            publisher.next(model);
        }
        return model;
    };
    /**
     * @param {?} error
     * @return {?}
     */
    ServiceResponder.prototype.error = function (error) {
        var /** @type {?} */ reaction = this.reactionMapper.map(error);
        return reaction;
    };
    return ServiceResponder;
}());
ServiceResponder.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
ServiceResponder.ctorParameters = function () { return [
    { type: ReactionMapper, },
]; };

var InstitutionPublisher = (function () {
    function InstitutionPublisher() {
        this.subject = new Subject$1();
    }
    /**
     * @param {?} state
     * @return {?}
     */
    InstitutionPublisher.prototype.next = function (state) {
        this.subject.next(state);
    };
    /**
     * @param {?} complete
     * @return {?}
     */
    InstitutionPublisher.prototype.subscribe = function (complete) {
        return this.subject.subscribe(complete);
    };
    /**
     * @return {?}
     */
    InstitutionPublisher.prototype.unsubscribe = function () {
        this.subject.unsubscribe();
    };
    return InstitutionPublisher;
}());
InstitutionPublisher.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
InstitutionPublisher.ctorParameters = function () { return []; };

var AffiliationService = (function () {
    /**
     * @param {?} httpRequester
     * @param {?} institutionMapper
     * @param {?} institutionPublisher
     * @param {?} serviceResponder
     */
    function AffiliationService(httpRequester, institutionMapper, institutionPublisher, serviceResponder) {
        this.httpRequester = httpRequester;
        this.institutionMapper = institutionMapper;
        this.institutionPublisher = institutionPublisher;
        this.serviceResponder = serviceResponder;
    }
    /**
     * @param {?} institutionId
     * @param {?} personaId
     * @param {?=} options
     * @return {?}
     */
    AffiliationService.prototype.approve = function (institutionId, personaId, options) {
        var _this = this;
        if (options === void 0) { options = new ApiOptions(); }
        return this.httpRequester.put('/api/institution/' + institutionId + '/approve/' + personaId, null, options)
            .map(function (response) {
            return _this.serviceResponder.response(options, _this.institutionMapper, _this.institutionPublisher, response);
        })
            .catch(function (error) {
            throw _this.serviceResponder.error(error);
        });
    };
    /**
     * @param {?} institutionId
     * @param {?} personaId
     * @param {?=} options
     * @return {?}
     */
    AffiliationService.prototype.activate = function (institutionId, personaId, options) {
        var _this = this;
        if (options === void 0) { options = new ApiOptions(); }
        return this.httpRequester.put('/api/institution/' + institutionId + '/activate/' + personaId, null, options)
            .map(function (response) {
            return _this.serviceResponder.response(options, _this.institutionMapper, _this.institutionPublisher, response);
        })
            .catch(function (error) {
            throw _this.serviceResponder.error(error);
        });
    };
    /**
     * @param {?} institutionId
     * @param {?} personaId
     * @param {?=} options
     * @return {?}
     */
    AffiliationService.prototype.disable = function (institutionId, personaId, options) {
        var _this = this;
        if (options === void 0) { options = new ApiOptions(); }
        return this.httpRequester.put('/api/institution/' + institutionId + '/disable/' + personaId, null, options)
            .map(function (response) {
            return _this.serviceResponder.response(options, _this.institutionMapper, _this.institutionPublisher, response);
        })
            .catch(function (error) {
            throw _this.serviceResponder.error(error);
        });
    };
    /**
     * @param {?} institutionId
     * @param {?=} options
     * @return {?}
     */
    AffiliationService.prototype.join = function (institutionId, options) {
        var _this = this;
        if (options === void 0) { options = new ApiOptions(); }
        return this.httpRequester.post('/api/institution/' + institutionId + '/join', null, options)
            .map(function (response) {
            return _this.serviceResponder.response(options, _this.institutionMapper, _this.institutionPublisher, response);
        })
            .catch(function (error) {
            throw _this.serviceResponder.error(error);
        });
    };
    /**
     * @param {?} institutionId
     * @param {?=} options
     * @return {?}
     */
    AffiliationService.prototype.leave = function (institutionId, options) {
        var _this = this;
        if (options === void 0) { options = new ApiOptions(); }
        return this.httpRequester.put('/api/institution/' + institutionId + '/leave', null, options)
            .map(function (response) {
            return _this.serviceResponder.response(options, _this.institutionMapper, _this.institutionPublisher, response);
        })
            .catch(function (error) {
            throw _this.serviceResponder.error(error);
        });
    };
    /**
     * @param {?} institutionId
     * @param {?} personaId
     * @param {?=} options
     * @return {?}
     */
    AffiliationService.prototype.reject = function (institutionId, personaId, options) {
        var _this = this;
        if (options === void 0) { options = new ApiOptions(); }
        return this.httpRequester.put('/api/institution/' + institutionId + '/reject/' + personaId, null, options)
            .map(function (response) {
            return _this.serviceResponder.response(options, _this.institutionMapper, _this.institutionPublisher, response);
        })
            .catch(function (error) {
            throw _this.serviceResponder.error(error);
        });
    };
    /**
     * @param {?} institutionId
     * @param {?} personaId
     * @param {?=} options
     * @return {?}
     */
    AffiliationService.prototype.suspend = function (institutionId, personaId, options) {
        var _this = this;
        if (options === void 0) { options = new ApiOptions(); }
        return this.httpRequester.put('/api/institution/' + institutionId + '/suspend/' + personaId, null, options)
            .map(function (response) {
            return _this.serviceResponder.response(options, _this.institutionMapper, _this.institutionPublisher, response);
        })
            .catch(function (error) {
            throw _this.serviceResponder.error(error);
        });
    };
    return AffiliationService;
}());
AffiliationService.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
AffiliationService.ctorParameters = function () { return [
    { type: HttpRequester, },
    { type: InstitutionMapper, },
    { type: InstitutionPublisher, },
    { type: ServiceResponder, },
]; };

var OAuthMapper = (function () {
    /**
     * @param {?} responseParser
     */
    function OAuthMapper(responseParser) {
        this.responseParser = responseParser;
    }
    /**
     * @param {?} response
     * @return {?}
     */
    OAuthMapper.prototype.map = function (response) {
        var /** @type {?} */ body = this.responseParser.parse(response);
        return new OAuthResponse(body);
    };
    return OAuthMapper;
}());
OAuthMapper.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
OAuthMapper.ctorParameters = function () { return [
    { type: HttpResponseParser, },
]; };

var AuthService = (function () {
    /**
     * @param {?} httpRequester
     * @param {?} oAuthMapper
     * @param {?} serviceResponder
     * @param {?} authPublisher
     */
    function AuthService(httpRequester, oAuthMapper, serviceResponder, authPublisher) {
        this.httpRequester = httpRequester;
        this.oAuthMapper = oAuthMapper;
        this.serviceResponder = serviceResponder;
        this.authPublisher = authPublisher;
    }
    /**
     * @param {?} params
     * @param {?=} options
     * @return {?}
     */
    AuthService.prototype.token = function (params, options) {
        var _this = this;
        if (options === void 0) { options = new ApiOptions(); }
        return this.httpRequester.post('/api/token', params, options)
            .map(function (response) {
            return _this.oAuthMapper.map(response);
        })
            .catch(function (error) {
            throw _this.serviceResponder.error(error);
        });
    };
    /**
     * @param {?} accessToken
     * @param {?} tokenType
     * @param {?=} options
     * @return {?}
     */
    AuthService.prototype.logout = function (accessToken, tokenType, options) {
        var _this = this;
        if (options === void 0) { options = new ApiOptions(); }
        var /** @type {?} */ observable = Observable$1.create(function (observer) {
            _this.authPublisher.next(new AuthState({ isAuthenticated: false, user: null }));
            var /** @type {?} */ oAuthResponse = new OAuthResponse({ accessToken: '', tokenType: '', expiresIn: 0, refreshToken: '' });
            observer.next(oAuthResponse);
        });
        return observable;
    };
    return AuthService;
}());
AuthService.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
AuthService.ctorParameters = function () { return [
    { type: HttpRequester, },
    { type: OAuthMapper, },
    { type: ServiceResponder, },
    { type: AuthPublisher, },
]; };

var DmcMapper = (function () {
    /**
     * @param {?} responseParser
     */
    function DmcMapper(responseParser) {
        this.responseParser = responseParser;
    }
    /**
     * @param {?} response
     * @return {?}
     */
    DmcMapper.prototype.map = function (response) {
        var /** @type {?} */ body = this.responseParser.parse(response);
        return new Dmc(body);
    };
    return DmcMapper;
}());
DmcMapper.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
DmcMapper.ctorParameters = function () { return [
    { type: HttpResponseParser, },
]; };

var GoalMapper = (function () {
    /**
     * @param {?} responseParser
     */
    function GoalMapper(responseParser) {
        this.responseParser = responseParser;
    }
    /**
     * @param {?} response
     * @return {?}
     */
    GoalMapper.prototype.map = function (response) {
        var /** @type {?} */ body = this.responseParser.parse(response);
        return new Goal(body);
    };
    return GoalMapper;
}());
GoalMapper.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
GoalMapper.ctorParameters = function () { return [
    { type: HttpResponseParser, },
]; };

var GoalPublisher = (function () {
    function GoalPublisher() {
        this.subject = new Subject$1();
    }
    /**
     * @param {?} state
     * @return {?}
     */
    GoalPublisher.prototype.next = function (state) {
        this.subject.next(state);
    };
    /**
     * @param {?} complete
     * @return {?}
     */
    GoalPublisher.prototype.subscribe = function (complete) {
        return this.subject.subscribe(complete);
    };
    /**
     * @return {?}
     */
    GoalPublisher.prototype.unsubscribe = function () {
        this.subject.unsubscribe();
    };
    return GoalPublisher;
}());
GoalPublisher.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
GoalPublisher.ctorParameters = function () { return []; };

var DmcService = (function () {
    /**
     * @param {?} httpRequester
     * @param {?} dmcMapper
     * @param {?} goalMapper
     * @param {?} goalPublisher
     * @param {?} serviceResponder
     */
    function DmcService(httpRequester, dmcMapper, goalMapper, goalPublisher, serviceResponder) {
        this.httpRequester = httpRequester;
        this.dmcMapper = dmcMapper;
        this.goalMapper = goalMapper;
        this.goalPublisher = goalPublisher;
        this.serviceResponder = serviceResponder;
    }
    /**
     * @param {?} goalId
     * @param {?} params
     * @param {?=} options
     * @return {?}
     */
    DmcService.prototype.create = function (goalId, params, options) {
        var _this = this;
        if (options === void 0) { options = new ApiOptions(); }
        return this.httpRequester.post('/api/goal/' + goalId + '/dmc', params, options)
            .map(function (response) {
            return _this.serviceResponder.response(options, _this.goalMapper, _this.goalPublisher, response);
        })
            .catch(function (error) {
            throw _this.serviceResponder.error(error);
        });
    };
    /**
     * @param {?} dmcId
     * @param {?=} options
     * @return {?}
     */
    DmcService.prototype.get = function (dmcId, options) {
        var _this = this;
        if (options === void 0) { options = new ApiOptions(); }
        return this.httpRequester.get('/api/dmc/' + dmcId, options)
            .map(function (response) {
            return _this.dmcMapper.map(response);
        })
            .catch(function (error) {
            throw _this.serviceResponder.error(error);
        });
    };
    /**
     * @param {?} goalId
     * @param {?} params
     * @param {?=} options
     * @return {?}
     */
    DmcService.prototype.update = function (goalId, params, options) {
        var _this = this;
        if (options === void 0) { options = new ApiOptions(); }
        return this.httpRequester.put('/api/goal/' + goalId + '/dmc/' + params.id, params, options)
            .map(function (response) {
            return _this.serviceResponder.response(options, _this.goalMapper, _this.goalPublisher, response);
        })
            .catch(function (error) {
            throw _this.serviceResponder.error(error);
        });
    };
    return DmcService;
}());
DmcService.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
DmcService.ctorParameters = function () { return [
    { type: HttpRequester, },
    { type: DmcMapper, },
    { type: GoalMapper, },
    { type: GoalPublisher, },
    { type: ServiceResponder, },
]; };

var ExchequerEventMapper = (function () {
    /**
     * @param {?} responseParser
     */
    function ExchequerEventMapper(responseParser) {
        this.responseParser = responseParser;
    }
    /**
     * @param {?} response
     * @return {?}
     */
    ExchequerEventMapper.prototype.map = function (response) {
        var /** @type {?} */ body = this.responseParser.parse(response);
        return new ExchequerEvent(body);
    };
    return ExchequerEventMapper;
}());
ExchequerEventMapper.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
ExchequerEventMapper.ctorParameters = function () { return [
    { type: HttpResponseParser, },
]; };

var TransactionMapper = (function () {
    /**
     * @param {?} responseParser
     */
    function TransactionMapper(responseParser) {
        this.responseParser = responseParser;
    }
    /**
     * @param {?} response
     * @return {?}
     */
    TransactionMapper.prototype.map = function (response) {
        var /** @type {?} */ body = this.responseParser.parse(response);
        return new Transaction(body);
    };
    return TransactionMapper;
}());
TransactionMapper.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
TransactionMapper.ctorParameters = function () { return [
    { type: HttpResponseParser, },
]; };

var TransactionsMapper = (function () {
    /**
     * @param {?} responseParser
     */
    function TransactionsMapper(responseParser) {
        this.responseParser = responseParser;
    }
    /**
     * @param {?} response
     * @return {?}
     */
    TransactionsMapper.prototype.map = function (response) {
        var /** @type {?} */ body = this.responseParser.parse(response);
        var /** @type {?} */ transactions = new Array();
        each(body, function (item) {
            var /** @type {?} */ transaction = new Transaction(item);
            transactions.push(transaction);
        });
        return transactions;
    };
    return TransactionsMapper;
}());
TransactionsMapper.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
TransactionsMapper.ctorParameters = function () { return [
    { type: HttpResponseParser, },
]; };

var TransactionPublisher = (function () {
    function TransactionPublisher() {
        this.subject = new Subject$1();
    }
    /**
     * @param {?} state
     * @return {?}
     */
    TransactionPublisher.prototype.next = function (state) {
        this.subject.next(state);
    };
    /**
     * @param {?} complete
     * @return {?}
     */
    TransactionPublisher.prototype.subscribe = function (complete) {
        return this.subject.subscribe(complete);
    };
    /**
     * @return {?}
     */
    TransactionPublisher.prototype.unsubscribe = function () {
        this.subject.unsubscribe();
    };
    return TransactionPublisher;
}());
TransactionPublisher.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
TransactionPublisher.ctorParameters = function () { return []; };

var TransactionsPublisher = (function () {
    function TransactionsPublisher() {
        this.subject = new Subject$1();
    }
    /**
     * @param {?} state
     * @return {?}
     */
    TransactionsPublisher.prototype.next = function (state) {
        this.subject.next(state);
    };
    /**
     * @param {?} complete
     * @return {?}
     */
    TransactionsPublisher.prototype.subscribe = function (complete) {
        return this.subject.subscribe(complete);
    };
    /**
     * @return {?}
     */
    TransactionsPublisher.prototype.unsubscribe = function () {
        this.subject.unsubscribe();
    };
    return TransactionsPublisher;
}());
TransactionsPublisher.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
TransactionsPublisher.ctorParameters = function () { return []; };

var ExchequerService = (function () {
    /**
     * @param {?} httpRequester
     * @param {?} exchequerEventMapper
     * @param {?} transactionMapper
     * @param {?} transactionsMapper
     * @param {?} transactionPublisher
     * @param {?} transactionsPublisher
     * @param {?} serviceResponder
     */
    function ExchequerService(httpRequester, exchequerEventMapper, transactionMapper, transactionsMapper, transactionPublisher, transactionsPublisher, serviceResponder) {
        this.httpRequester = httpRequester;
        this.exchequerEventMapper = exchequerEventMapper;
        this.transactionMapper = transactionMapper;
        this.transactionsMapper = transactionsMapper;
        this.transactionPublisher = transactionPublisher;
        this.transactionsPublisher = transactionsPublisher;
        this.serviceResponder = serviceResponder;
    }
    /**
     * @param {?} institutionId
     * @param {?} eventIds
     * @param {?=} options
     * @return {?}
     */
    ExchequerService.prototype.createTransactions = function (institutionId, eventIds, options) {
        var _this = this;
        if (options === void 0) { options = new ApiOptions(); }
        return this.httpRequester.post('/api/exchequer/transactions/' + institutionId + '/create', eventIds, options)
            .map(function (response) {
            return _this.serviceResponder.response(options, _this.transactionsMapper, _this.transactionsPublisher, response);
        })
            .catch(function (error) {
            throw _this.serviceResponder.error(error);
        });
    };
    /**
     * @param {?} transactionId
     * @param {?=} options
     * @return {?}
     */
    ExchequerService.prototype.getTransaction = function (transactionId, options) {
        var _this = this;
        if (options === void 0) { options = new ApiOptions(); }
        return this.httpRequester.get('/api/exchequer/transaction/' + transactionId, options)
            .map(function (response) {
            return _this.serviceResponder.response(options, _this.transactionMapper, _this.transactionPublisher, response);
        })
            .catch(function (error) {
            throw _this.serviceResponder.error(error);
        });
    };
    /**
     * @param {?=} options
     * @return {?}
     */
    ExchequerService.prototype.transactionCandidates = function (options) {
        var _this = this;
        if (options === void 0) { options = new ApiOptions(); }
        return this.httpRequester.get('/api/exchequer/transactions/candidates/all', options)
            .map(function (response) {
            return _this.serviceResponder.response(options, _this.transactionsMapper, _this.transactionsPublisher, response);
        })
            .catch(function (error) {
            throw _this.serviceResponder.error(error);
        });
    };
    /**
     * @param {?} exchequerEvent
     * @param {?=} options
     * @return {?}
     */
    ExchequerService.prototype.updateExchequerEvent = function (exchequerEvent, options) {
        var _this = this;
        if (options === void 0) { options = new ApiOptions(); }
        return this.httpRequester.put('/api/exchequer/event/' + exchequerEvent.id, exchequerEvent, options)
            .map(function (response) {
            return _this.exchequerEventMapper.map(response);
        })
            .catch(function (error) {
            throw _this.serviceResponder.error(error);
        });
    };
    return ExchequerService;
}());
// allTransactionsForInstitutions(institutionIds: number[], rangeStartDate: any, rangeEndDate: any, statusMask: any, sortProperty: string, sortDirection: string, options: any={}): Observable<any> {
//
//     let queryIds = _.join(institutionIds, ",");
//
//     rangeStartDate = rangeStartDate || '';
//     rangeEndDate = rangeEndDate || '';
//     statusMask = statusMask || '';
//     sortProperty = sortProperty || '';
//     sortDirection = sortDirection || '';
//
//     return this.httpGet('/api/exchequer/transactions?institutionIds=' + queryIds + '&rangeStartDate=' + rangeStartDate + '&rangeEndDate=' + rangeEndDate + '&statusMask=' + statusMask + '&sortProperty=' + sortProperty + '&sortDirection=' + sortDirection, options);
// }
//
// emailPdfFormsForEvents(institutionId: any, eventIds: number[], options: any={}): Observable<any> {
//
//     return this.httpPut('/api/exchequer/transactions/' + institutionId + '/email', eventIds, options);
// }
ExchequerService.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
ExchequerService.ctorParameters = function () { return [
    { type: HttpRequester, },
    { type: ExchequerEventMapper, },
    { type: TransactionMapper, },
    { type: TransactionsMapper, },
    { type: TransactionPublisher, },
    { type: TransactionsPublisher, },
    { type: ServiceResponder, },
]; };

var HttpQueryBuilder = (function () {
    function HttpQueryBuilder() {
    }
    /**
     * @param {?} params
     * @return {?}
     */
    HttpQueryBuilder.prototype.build = function (params) {
        var /** @type {?} */ query = '';
        if (params) {
            var /** @type {?} */ parameterNames = Object.keys(params);
            var /** @type {?} */ queries_1 = new Array();
            each(parameterNames, function (parameterName) {
                if (hasIn(params, parameterName)) {
                    var /** @type {?} */ parameterValue = params[parameterName];
                    if (parameterValue) {
                        queries_1.push(parameterName + '=' + parameterValue.toString());
                    }
                }
            });
            if (some(queries_1)) {
                query = join(queries_1, '&');
            }
        }
        return query;
    };
    return HttpQueryBuilder;
}());
HttpQueryBuilder.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
HttpQueryBuilder.ctorParameters = function () { return []; };

var FileMapper = (function () {
    /**
     * @param {?} responseParser
     */
    function FileMapper(responseParser) {
        this.responseParser = responseParser;
    }
    /**
     * @param {?} response
     * @return {?}
     */
    FileMapper.prototype.map = function (response) {
        var /** @type {?} */ body = this.responseParser.parse(response);
        return new File(body);
    };
    return FileMapper;
}());
FileMapper.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
FileMapper.ctorParameters = function () { return [
    { type: HttpResponseParser, },
]; };

var S3FileMapper = (function () {
    /**
     * @param {?} responseParser
     */
    function S3FileMapper(responseParser) {
        this.responseParser = responseParser;
    }
    /**
     * @param {?} response
     * @return {?}
     */
    S3FileMapper.prototype.map = function (response) {
        var /** @type {?} */ body = this.responseParser.parse(response);
        return new S3FileResponse(body);
    };
    return S3FileMapper;
}());
S3FileMapper.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
S3FileMapper.ctorParameters = function () { return [
    { type: HttpResponseParser, },
]; };

var FileService = (function () {
    /**
     * @param {?} httpRequester
     * @param {?} queryBuilder
     * @param {?} fileMapper
     * @param {?} s3FileMapper
     * @param {?} serviceResponder
     */
    function FileService(httpRequester, queryBuilder, fileMapper, s3FileMapper, serviceResponder) {
        this.httpRequester = httpRequester;
        this.queryBuilder = queryBuilder;
        this.fileMapper = fileMapper;
        this.s3FileMapper = s3FileMapper;
        this.serviceResponder = serviceResponder;
    }
    /**
     * @param {?} fileId
     * @param {?=} options
     * @return {?}
     */
    FileService.prototype.access = function (fileId, options) {
        var _this = this;
        if (options === void 0) { options = new ApiOptions(); }
        return this.httpRequester.put('/api/file/' + fileId + '/access?verbose=true', null, options)
            .map(function (response) {
            return _this.s3FileMapper.map(response);
        })
            .catch(function (error) {
            throw _this.serviceResponder.error(error);
        });
    };
    /**
     * @param {?} params
     * @param {?} goalId
     * @param {?} personaId
     * @param {?=} options
     * @return {?}
     */
    FileService.prototype.create = function (params, goalId, personaId, options) {
        var _this = this;
        if (options === void 0) { options = new ApiOptions(); }
        var /** @type {?} */ queryParams = this.queryBuilder.build({ goalId: goalId, personaId: personaId });
        var /** @type {?} */ query = (queryParams ? '?' + queryParams : '');
        return this.httpRequester.post('/api/file' + query, params, options)
            .map(function (response) {
            return _this.fileMapper.map(response);
        })
            .catch(function (error) {
            throw _this.serviceResponder.error(error);
        });
    };
    /**
     * @param {?} fileId
     * @param {?=} options
     * @return {?}
     */
    FileService.prototype.get = function (fileId, options) {
        var _this = this;
        if (options === void 0) { options = new ApiOptions(); }
        return this.httpRequester.get('/api/file/' + fileId, options)
            .map(function (response) {
            return _this.fileMapper.map(response);
        })
            .catch(function (error) {
            throw _this.serviceResponder.error(error);
        });
    };
    /**
     * @param {?} params
     * @param {?=} options
     * @return {?}
     */
    FileService.prototype.update = function (params, options) {
        var _this = this;
        if (options === void 0) { options = new ApiOptions(); }
        return this.httpRequester.put('/api/file/' + params.id, params, options)
            .map(function (response) {
            return _this.fileMapper.map(response);
        })
            .catch(function (error) {
            throw _this.serviceResponder.error(error);
        });
    };
    return FileService;
}());
FileService.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
FileService.ctorParameters = function () { return [
    { type: HttpRequester, },
    { type: HttpQueryBuilder, },
    { type: FileMapper, },
    { type: S3FileMapper, },
    { type: ServiceResponder, },
]; };

var GoalsMapper = (function () {
    /**
     * @param {?} responseParser
     */
    function GoalsMapper(responseParser) {
        this.responseParser = responseParser;
    }
    /**
     * @param {?} response
     * @return {?}
     */
    GoalsMapper.prototype.map = function (response) {
        var /** @type {?} */ body = this.responseParser.parse(response);
        var /** @type {?} */ goals = new Array();
        each(body, function (item) {
            var /** @type {?} */ goal = new Goal(item);
            goals.push(goal);
        });
        return goals;
    };
    return GoalsMapper;
}());
GoalsMapper.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
GoalsMapper.ctorParameters = function () { return [
    { type: HttpResponseParser, },
]; };

var GoalMetaMapper = (function () {
    /**
     * @param {?} responseParser
     */
    function GoalMetaMapper(responseParser) {
        this.responseParser = responseParser;
    }
    /**
     * @param {?} response
     * @return {?}
     */
    GoalMetaMapper.prototype.map = function (response) {
        var /** @type {?} */ body = this.responseParser.parse(response);
        return new GoalMeta(body);
    };
    return GoalMetaMapper;
}());
GoalMetaMapper.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
GoalMetaMapper.ctorParameters = function () { return [
    { type: HttpResponseParser, },
]; };

var GoalsPublisher = (function () {
    function GoalsPublisher() {
        this.subject = new Subject$1();
    }
    /**
     * @param {?} state
     * @return {?}
     */
    GoalsPublisher.prototype.next = function (state) {
        this.subject.next(state);
    };
    /**
     * @param {?} complete
     * @return {?}
     */
    GoalsPublisher.prototype.subscribe = function (complete) {
        return this.subject.subscribe(complete);
    };
    /**
     * @return {?}
     */
    GoalsPublisher.prototype.unsubscribe = function () {
        this.subject.unsubscribe();
    };
    return GoalsPublisher;
}());
GoalsPublisher.decorators = [
    { type: Injectable },
];
/**
 * @nocollapse
 */
GoalsPublisher.ctorParameters = function () { return []; };

var GoalService = (function () {
    /**
     * @param {?} httpRequester
     * @param {?} queryBuilder
     * @param {?} goalMapper
     * @param {?} goalsMapper
     * @param {?} goalMetaMapper