easy-core/bundles/easy-core.umd.js

(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/http'), require('rxjs/Rx'), require('rxjs/Subject'), require('angular-2-local-storage')) :
	typeof define === 'function' && define.amd ? define('easy-core', ['exports', '@angular/core', '@angular/http', 'rxjs/Rx', 'rxjs/Subject', 'angular-2-local-storage'], factory) :
	(factory((global['easy-core'] = {}),global.ng.core,global.ng.http,global.Rx,global.Rx,global.angular2LocalStorage));
}(this, (function (exports,core,http,Rx,Subject,angular2LocalStorage) { 'use strict';

/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = Object.setPrototypeOf ||
    ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
    function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
function __extends(d, b) {
    extendStatics(d, b);
    function __() { this.constructor = d; }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}








function __values(o) {
    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
    if (m) return m.call(o);
    return {
        next: function () {
            if (o && i >= o.length) o = void 0;
            return { value: o && o[i++], done: !o };
        }
    };
}

var Setting = /** @class */ (function () {
    function Setting(key, value) {
        this.key = key;
        this.value = value;
    }
    return Setting;
}());
var AppConfig = /** @class */ (function () {
    function AppConfig(http$$1) {
        this.http = http$$1;
        this.paths = [];
        this.config = [];
        this.env = null;
        this.subject = new Rx.Subject();
        this.initialized = this.subject.asObservable();
    }
    AppConfig.prototype.getPresentationConfigs = function () {
        return this.config.filter(function (x) { return x.key.toLowerCase().endsWith("config"); });
    };
    AppConfig.prototype.get = function (key) {
        var setting = this.config.filter(function (x) { return x.key.toLowerCase() == key.toLowerCase(); });
        return setting.length > 0 ? setting[0].value : null;
    };
    AppConfig.prototype.getEnv = function (key) {
        return this.env[key];
    };
    AppConfig.prototype.addNavigationItems = function (applicationName, paths) {
        var _loop_1 = function (path) {
            if (this_1.paths.filter(function (x) { return x.value.name == path.name; }).length == 0) {
                this_1.paths.push(new Setting(applicationName, { name: path.name, route: path.route }));
            }
        };
        var this_1 = this;
        try {
            for (var paths_1 = __values(paths), paths_1_1 = paths_1.next(); !paths_1_1.done; paths_1_1 = paths_1.next()) {
                var path = paths_1_1.value;
                _loop_1(path);
            }
        }
        catch (e_1_1) { e_1 = { error: e_1_1 }; }
        finally {
            try {
                if (paths_1_1 && !paths_1_1.done && (_a = paths_1.return)) _a.call(paths_1);
            }
            finally { if (e_1) throw e_1.error; }
        }
        var e_1, _a;
    };
    AppConfig.prototype.fetchNavigationItems = function (applicationName) {
        return this.paths.filter(function (x) { return x.key === applicationName; }).map(function (x) { return new Setting(x.value.name, x.value.route); });
    };
    AppConfig.prototype.initialize = function (settings, env) {
        this.config = this.config.concat(settings);
        this.env = env;
        this.subject.next(true);
    };
    return AppConfig;
}());
AppConfig.decorators = [
    { type: core.Injectable },
];
AppConfig.ctorParameters = function () { return [
    { type: http.Http, },
]; };
var contentHeaders = new http.Headers();
contentHeaders.append('Accept', 'application/json');
contentHeaders.append('Content-Type', 'application/json');
var LoaderService = /** @class */ (function () {
    function LoaderService() {
        this.loaderSubject = new Subject.Subject();
        this.loaderState = this.loaderSubject.asObservable();
    }
    LoaderService.prototype.show = function () {
        this.loaderSubject.next(({ show: true }));
    };
    LoaderService.prototype.hide = function () {
        this.loaderSubject.next(({ show: false }));
    };
    return LoaderService;
}());
LoaderService.decorators = [
    { type: core.Injectable },
];
LoaderService.ctorParameters = function () { return []; };
var LoaderComponent = /** @class */ (function () {
    function LoaderComponent(loaderService) {
        this.loaderService = loaderService;
        this.show = false;
    }
    LoaderComponent.prototype.ngOnInit = function () {
        var _this = this;
        this.subscription = this.loaderService.loaderState
            .subscribe(function (state) {
            _this.show = state.show;
        });
    };
    LoaderComponent.prototype.ngOnDestroy = function () {
        this.subscription.unsubscribe();
    };
    return LoaderComponent;
}());
LoaderComponent.decorators = [
    { type: core.Component, args: [{
                selector: 'angular-loader',
                template: "<div [class.loader-hidden]=\"!show\">\n                    <div class=\"loader-overlay\">\n                            <div>\n                                <mat-progress-bar color=\"warn\" mode=\"indeterminate\" *ngIf=\"show\"></mat-progress-bar>\n                            </div>\n                    </div>\n                </div>",
                styles: [".loader-hidden {\n        visibility: hidden;\n    }\n    .loader-overlay {\n        position: absolute;\n        width:100%;\n        top:0;\n        left: 0;\n        opacity: 1;\n        z-index: 9999999999;\n    }"],
            },] },
];
LoaderComponent.ctorParameters = function () { return [
    { type: LoaderService, },
]; };
var HttpIntegrationService = /** @class */ (function () {
    function HttpIntegrationService() {
        this.subject = new Subject.Subject();
        this.OnError = this.subject.asObservable();
    }
    HttpIntegrationService.prototype.error = function (res) {
        this.subject.next(res);
    };
    return HttpIntegrationService;
}());
HttpIntegrationService.decorators = [
    { type: core.Injectable },
];
var InterceptedHttp = /** @class */ (function (_super) {
    __extends(InterceptedHttp, _super);
    function InterceptedHttp(backend, defaultOptions, localStorageService, loaderService, httpIntegrationService) {
        var _this = _super.call(this, backend, defaultOptions) || this;
        _this.localStorageService = localStorageService;
        _this.loaderService = loaderService;
        _this.httpIntegrationService = httpIntegrationService;
        return _this;
    }
    InterceptedHttp.prototype.get = function (url, options) {
        var _this = this;
        this.showLoader();
        return _super.prototype.get.call(this, url, this.getRequestOptionArgs(options))
            .do(function (res) {
            _this.onSuccess(res);
        }, function (error) {
            _this.onError(error);
        })
            .finally(function () {
            _this.onEnd();
        });
    };
    InterceptedHttp.prototype.post = function (url, body, options) {
        var _this = this;
        this.showLoader();
        return _super.prototype.post.call(this, url, body, this.getRequestOptionArgs(options))
            .do(function (res) {
            _this.onSuccess(res);
        }, function (error) {
            _this.onError(error);
        })
            .finally(function () {
            _this.onEnd();
        });
    };
    InterceptedHttp.prototype.put = function (url, body, options) {
        var _this = this;
        this.showLoader();
        return _super.prototype.put.call(this, url, body, this.getRequestOptionArgs(options))
            .do(function (res) {
            _this.onSuccess(res);
        }, function (error) {
            _this.onError(error);
        })
            .finally(function () {
            _this.onEnd();
        });
    };
    InterceptedHttp.prototype.delete = function (url, options) {
        var _this = this;
        this.showLoader();
        return _super.prototype.delete.call(this, url, this.getRequestOptionArgs(options))
            .do(function (res) {
            _this.onSuccess(res);
        }, function (error) {
            _this.onError(error);
        })
            .finally(function () {
            _this.onEnd();
        });
    };
    InterceptedHttp.prototype.getRequestOptionArgs = function (options) {
        if (options == null) {
            options = new http.RequestOptions();
        }
        if (options.headers == null) {
            options.headers = new http.Headers();
        }
        if (!options.withCredentials)
            this.createAuthorizationHeader(options.headers);
        return options;
    };
    InterceptedHttp.prototype.createAuthorizationHeader = function (headers) {
        if (this.localStorageService.get('id_token') != null) {
            headers.append('Authorization', this.localStorageService.get('id_token'));
        }
    };
    InterceptedHttp.prototype.onSuccess = function (res) {
        console.log('Request successful');
    };
    InterceptedHttp.prototype.onError = function (res) {
        console.log('Error, status code: ' + res.status);
        this.httpIntegrationService.error(res);
    };
    InterceptedHttp.prototype.onEnd = function () {
        this.hideLoader();
    };
    InterceptedHttp.prototype.showLoader = function () {
        this.loaderService.show();
    };
    InterceptedHttp.prototype.hideLoader = function () {
        this.loaderService.hide();
    };
    return InterceptedHttp;
}(http.Http));
InterceptedHttp.decorators = [
    { type: core.Injectable },
];
InterceptedHttp.ctorParameters = function () { return [
    { type: http.ConnectionBackend, },
    { type: http.RequestOptions, },
    { type: angular2LocalStorage.LocalStorageService, },
    { type: LoaderService, },
    { type: HttpIntegrationService, },
]; };
function httpFactory(xhrBackend, requestOptions, localStorageService, loaderService, httpIntegrationService) {
    return new InterceptedHttp(xhrBackend, requestOptions, localStorageService, loaderService, httpIntegrationService);
}
if (!Array.prototype.add) {
    Array.prototype.add = function (item) {
        this.push(item);
    };
}
if (!Array.prototype.addRange) {
    Array.prototype.addRange = function (items) {
        var _this = this;
        items.forEach(function (x) { return _this.push(x); });
    };
}
if (!Array.prototype.remove) {
    Array.prototype.remove = function (item) {
        var index = this.indexOf(item);
        this.splice(index, 0);
        return index != -1;
    };
}
if (!Array.prototype.where) {
    Array.prototype.where = function (func) {
        var items = (this.filter(func));
        return items;
    };
}
if (!Array.prototype.orderBy) {
    Array.prototype.orderBy = function (propertyExpression) {
        var result = Array();
        var compareFunction = function (item1, item2) {
            if (propertyExpression(item1) > propertyExpression(item2))
                return 1;
            if (propertyExpression(item2) > propertyExpression(item1))
                return -1;
            return 0;
        };
        for (var i = 0; i < ((this)).length; i++) {
            return ((this)).sort(compareFunction);
        }
        return result;
    };
}
if (!Array.prototype.orderByDescending) {
    Array.prototype.orderByDescending = function (propertyExpression) {
        var result = Array();
        var compareFunction = function (item1, item2) {
            if (propertyExpression(item1) > propertyExpression(item2))
                return -1;
            if (propertyExpression(item2) > propertyExpression(item1))
                return 1;
            return 0;
        };
        for (var i = 0; i < ((this)).length; i++) {
            return ((this)).sort(compareFunction);
        }
        return result;
    };
}
if (!Array.prototype.single) {
    Array.prototype.single = function (func) {
        if (func === void 0) { func = null; }
        var items = this;
        if (func != null)
            items = (this.filter(func));
        if (items.length > 1)
            throw new SequenceContainsMoreThanOneElementException();
        if (items.length == 0)
            throw new SequenceDoesNotContainException();
        return items[0];
    };
}
if (!Array.prototype.singleOrDefault) {
    Array.prototype.singleOrDefault = function (func) {
        if (func === void 0) { func = null; }
        var items = this;
        if (func != null)
            items = (this.filter(func));
        if (items.length > 1)
            throw new SequenceContainsMoreThanOneElementException();
        if (items.length == 0)
            return null;
        return items[0];
    };
}
if (!Array.prototype.first) {
    Array.prototype.first = function (func) {
        if (func === void 0) { func = null; }
        var items = this;
        if (func != null)
            items = (this.filter(func));
        if (items.any())
            return items[0];
        else
            throw new SequenceDoesNotContainException();
    };
}
if (!Array.prototype.firstOrDefault) {
    Array.prototype.firstOrDefault = function (func) {
        if (func === void 0) { func = null; }
        var items = this;
        if (func != null)
            items = (this.filter(func));
        if (items.length > 0)
            return items[0];
        else
            return null;
    };
}
if (!Array.prototype.last) {
    Array.prototype.last = function (func) {
        if (func === void 0) { func = null; }
        var items = this.reverse();
        if (func != null)
            items = (this.filter(func));
        items = (this.filter(func));
        if (items.length > 1)
            return items[0];
        else
            throw new SequenceDoesNotContainException();
    };
}
if (!Array.prototype.lastOrDefault) {
    Array.prototype.lastOrDefault = function (func) {
        if (func === void 0) { func = null; }
        var items = this.reverse();
        if (func != null)
            items = (this.filter(func));
        if (items.length > 0)
            return items[0];
        else
            return null;
    };
}
if (!Array.prototype.any) {
    Array.prototype.any = function (func) {
        if (func === void 0) { func = null; }
        var items = this;
        if (func != null)
            items = (this.filter(func));
        return items.length > 0;
    };
}
if (!Array.prototype.all) {
    Array.prototype.all = function (func) {
        var items = (this.filter(func));
        return items.length == this.length;
    };
}
var SequenceDoesNotContainException = /** @class */ (function (_super) {
    __extends(SequenceDoesNotContainException, _super);
    function SequenceDoesNotContainException() {
        var _this = _super.call(this) || this;
        Object.setPrototypeOf(_this, SequenceDoesNotContainException.prototype);
        return _this;
    }
    return SequenceDoesNotContainException;
}(Error));
var SequenceContainsMoreThanOneElementException = /** @class */ (function (_super) {
    __extends(SequenceContainsMoreThanOneElementException, _super);
    function SequenceContainsMoreThanOneElementException() {
        var _this = _super.call(this) || this;
        Object.setPrototypeOf(_this, SequenceContainsMoreThanOneElementException.prototype);
        return _this;
    }
    return SequenceContainsMoreThanOneElementException;
}(Error));
var ArrayExtensions = /** @class */ (function () {
    function ArrayExtensions() {
    }
    return ArrayExtensions;
}());
if (!String.prototype.fromCamelCase) {
    String.prototype.fromCamelCase = function () {
        return this.replace(/([a-z](?=[A-Z]))/g, '$1 ');
    };
}
var StringExtensions = /** @class */ (function () {
    function StringExtensions() {
    }
    return StringExtensions;
}());
var CoreModule = /** @class */ (function () {
    function CoreModule() {
    }
    return CoreModule;
}());
CoreModule.decorators = [
    { type: core.NgModule, args: [{
                imports: [AppConfig, http.HttpModule],
                declarations: [],
                providers: [AppConfig],
                exports: [LoaderComponent]
            },] },
];

exports.CoreModule = CoreModule;
exports.LoaderComponent = LoaderComponent;
exports.httpFactory = httpFactory;
exports.AppConfig = AppConfig;
exports.Setting = Setting;
exports.contentHeaders = contentHeaders;
exports.LoaderService = LoaderService;
exports.HttpIntegrationService = HttpIntegrationService;
exports.InterceptedHttp = InterceptedHttp;
exports.ArrayExtensions = ArrayExtensions;
exports.StringExtensions = StringExtensions;

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

})));
//# sourceMappingURL=easy-core.umd.js.map