@gipisistemas/ng-core 1.0.67 → 1.0.68

package/esm5/core/services/abstract-crud.service.js

@@ -0,0 +1,30 @@
+import { __extends } from "tslib";
+import { catchError, map } from 'rxjs/operators';
+import { AbstractFindService } from './abstract-find.service';
+var AbstractCrudService = /** @class */ (function (_super) {
+    __extends(AbstractCrudService, _super);
+    function AbstractCrudService(path, http) {
+        var _this = _super.call(this, path, http) || this;
+        _this.path = path;
+        return _this;
+    }
+    AbstractCrudService.prototype.save = function (entity) {
+        this.validate(entity);
+        return this.http.post(this.url(), entity, this.options()).pipe(map(this.mapper), catchError(this.handleError));
+    };
+    AbstractCrudService.prototype.saveAll = function (entities) {
+        var _this = this;
+        entities.forEach(function (entity) { return _this.validate(entity); });
+        return this.http.post(this.url('save-all'), entities, this.options()).pipe(map(this.mapper), catchError(this.handleError));
+    };
+    AbstractCrudService.prototype.delete = function (id) {
+        return this.http.delete(this.url("" + id)).pipe(map(function () { return null; }), catchError(this.handleError));
+    };
+    AbstractCrudService.prototype.deleteAll = function (entities) {
+        return this.http.post(this.url('delete-all'), entities, this.options()).pipe(map(this.mapper), catchError(this.handleError));
+    };
+    AbstractCrudService.prototype.validate = function (entity) { };
+    return AbstractCrudService;
+}(AbstractFindService));
+export { AbstractCrudService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/core/services/abstract-find.service.js

@@ -0,0 +1,71 @@
+import { __extends } from "tslib";
+import { catchError, map, takeUntil } from 'rxjs/operators';
+import { ObjectUtil } from '../utils/object.util';
+import { StringUtil } from '../utils/string.util';
+import { AbstractService } from './abstract.service';
+var AbstractFindService = /** @class */ (function (_super) {
+    __extends(AbstractFindService, _super);
+    function AbstractFindService(path, http) {
+        var _this = _super.call(this) || this;
+        _this.path = path;
+        _this.http = http;
+        return _this;
+    }
+    AbstractFindService.prototype.ngOnDestroy = function () {
+        _super.prototype.ngOnDestroy.call(this);
+    };
+    AbstractFindService.prototype.url = function (path) {
+        var url = "api/" + this.path;
+        return path ? url.concat("/" + path) : url;
+    };
+    AbstractFindService.prototype.getOne = function (id) {
+        return this.http.get(this.url("" + id), this.options()).pipe(takeUntil(this.onDestroy), map(this.mapper), catchError(this.handleError));
+    };
+    AbstractFindService.prototype.find = function (filter) {
+        return this.http.post(this.url('find-all'), filter, this.options()).pipe(takeUntil(this.onDestroy), map(this.mapper), catchError(this.handleError));
+    };
+    AbstractFindService.prototype.findAll = function () {
+        return this.http.get(this.url(), this.options()).pipe(takeUntil(this.onDestroy), map(this.mapper), catchError(this.handleError));
+    };
+    AbstractFindService.prototype.findAllEnabled = function (page, size) {
+        if ((!page) || (page && (page < 0))) {
+            page = 0;
+        }
+        if ((!size) || (size && (size <= 0))) {
+            size = 10;
+        }
+        return this.http.get(this.url("find-all-enabled?page=" + page + "&size=" + size), this.options()).pipe(takeUntil(this.onDestroy), map(this.mapper), catchError(this.handleError));
+    };
+    /**
+     * Pesquisa páginada por valor.
+     * @param value valor para pesquisar
+     * @param page página que ira consultar. default = 0;
+     * @param size quantidade de registros a retornar. default = 10;
+     * @param sort tipo de ordenação. default = null;
+     * @returns Observable<PageDTO<T>>;
+     */
+    AbstractFindService.prototype.findByValue = function (value, page, size, sort) {
+        if (size === void 0) { size = 10; }
+        var lValue = value;
+        if (value) {
+            lValue = StringUtil.removeAccents(value).trim();
+        }
+        else {
+            lValue = '';
+        }
+        if ((!page) || (page && (page < 0))) {
+            page = 0;
+        }
+        if ((!size) || (size && (size <= 0))) {
+            size = 10;
+        }
+        var lSort = '';
+        if (!ObjectUtil.isNull(sort) && !StringUtil.isEmpty(sort.property)) {
+            lSort = "&sort=" + sort.property + "," + sort.direction;
+        }
+        return this.http.get(this.url("find-by-value?page=" + page + "&size=" + size + lSort + "&value=" + lValue), this.options()).pipe(takeUntil(this.onDestroy), map(this.mapper), catchError(this.handleError));
+    };
+    return AbstractFindService;
+}(AbstractService));
+export { AbstractFindService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-find.service.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["core/services/abstract-find.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { OnDestroy } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { catchError, map, takeUntil } from 'rxjs/operators';\n\nimport { AbstractModel } from '../models/abstract.model';\nimport { FilterDTO } from '../models/dto/filter.dto';\nimport { PageDTO } from '../models/dto/page.dto';\nimport { ObjectUtil } from '../utils/object.util';\nimport { StringUtil } from '../utils/string.util';\nimport { AbstractService } from './abstract.service';\n\nexport abstract class AbstractFindService<T extends AbstractModel, F extends FilterDTO> extends AbstractService implements OnDestroy {\n\n    constructor(\n        protected path: string,\n        protected http: HttpClient\n    ) {\n        super();\n    }\n\n    ngOnDestroy(): void {\n        super.ngOnDestroy();\n    }\n\n    protected url(path?: string): string {\n        const url = `api/${this.path}`;\n        return path ? url.concat(`/${path}`) : url;\n    }\n\n    getOne(id: number | string): Observable<T> {\n        return this.http.get(this.url(`${id}`), this.options()).pipe(\n            takeUntil(this.onDestroy),\n            map(this.mapper),\n            catchError(this.handleError)\n        );\n    }\n\n    find(filter?: F): Observable<PageDTO<any>> {\n        return this.http.post(this.url('find-all'), filter, this.options()).pipe(\n            takeUntil(this.onDestroy),\n            map(this.mapper),\n            catchError(this.handleError)\n        );\n    }\n\n    findAll(): Observable<T[]> {\n        return this.http.get(this.url(), this.options()).pipe(\n            takeUntil(this.onDestroy),\n            map(this.mapper),\n            catchError(this.handleError)\n        );\n    }\n\n    findAllEnabled(page: number, size: number): Observable<PageDTO<T>> {\n        if ((!page) || (page && (page < 0))) {\n            page = 0;\n        }\n        if ((!size) || (size && (size <= 0))) {\n            size = 10;\n        }\n\n        return this.http.get(this.url(`find-all-enabled?page=${page}&size=${size}`), this.options()).pipe(\n            takeUntil(this.onDestroy),\n            map(this.mapper),\n            catchError(this.handleError)\n        );\n    }\n\n    /**\n     * Pesquisa páginada por valor.\n     * @param value valor para pesquisar\n     * @param page página que ira consultar. default = 0;\n     * @param size quantidade de registros a retornar. default = 10;\n     * @param sort tipo de ordenação. default = null;\n     * @returns Observable<PageDTO<T>>;\n     */\n    findByValue(value: string, page: number, size: number = 10, sort?: { property: string; direction: 'asc' | 'desc'; }): Observable<PageDTO<T>> {\n        let lValue: string = value;\n        if (value) {\n            lValue = StringUtil.removeAccents(value).trim();\n        } else {\n            lValue = '';\n        }\n        if ((!page) || (page && (page < 0))) {\n            page = 0;\n        }\n        if ((!size) || (size && (size <= 0))) {\n            size = 10;\n        }\n        let lSort: string = '';\n        if (!ObjectUtil.isNull(sort) && !StringUtil.isEmpty(sort.property)) {\n            lSort = `&sort=${sort.property},${sort.direction}`;\n        }\n\n        return this.http.get(this.url(`find-by-value?page=${page}&size=${size}${lSort}&value=${lValue}`), this.options()).pipe(\n            takeUntil(this.onDestroy),\n            map(this.mapper),\n            catchError(this.handleError)\n        );\n    }\n\n}\n\n"]}

package/esm5/core/services/abstract.service.js

@@ -0,0 +1,32 @@
+import { HttpHeaders, HttpParams } from '@angular/common/http';
+import { Subject, throwError } from 'rxjs';
+var AbstractService = /** @class */ (function () {
+    function AbstractService() {
+        this.onDestroy = new Subject();
+    }
+    AbstractService.prototype.ngOnDestroy = function () {
+        this.onDestroy.next();
+        this.onDestroy.complete();
+    };
+    AbstractService.prototype.options = function (params, headers) {
+        return {
+            headers: headers ? headers : this.buildHeaders(),
+            params: params ? params : this.buildParams()
+        };
+    };
+    AbstractService.prototype.buildHeaders = function () {
+        return new HttpHeaders();
+    };
+    AbstractService.prototype.buildParams = function () {
+        return new HttpParams();
+    };
+    AbstractService.prototype.mapper = function (jsonObj) {
+        return jsonObj;
+    };
+    AbstractService.prototype.handleError = function (error) {
+        return throwError(error);
+    };
+    return AbstractService;
+}());
+export { AbstractService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/core/services/authentication.service.js

@@ -0,0 +1,121 @@
+import { __awaiter, __decorate, __extends, __generator, __metadata } from "tslib";
+import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { BehaviorSubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import * as moment_ from 'moment';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@angular/common/http";
+var moment = moment_;
+import { ObjectUtil } from '../utils/object.util';
+import { AbstractService } from './abstract.service';
+import { StringUtil } from '../utils/string.util';
+var AuthenticationService = /** @class */ (function (_super) {
+    __extends(AuthenticationService, _super);
+    function AuthenticationService(router, http) {
+        var _this = _super.call(this) || this;
+        _this.router = router;
+        _this.http = http;
+        _this.tokenSubject = new BehaviorSubject(JSON.parse(localStorage.getItem('token')));
+        _this.token = _this.tokenSubject.asObservable();
+        return _this;
+    }
+    AuthenticationService.prototype.login = function (user) {
+        var _this = this;
+        var body = new HttpParams()
+            .set('grant_type', 'password')
+            .set('username', user.username)
+            .set('password', user.password);
+        return this.http.post('api/authenticator/oauth/token', body, this.options()).pipe(map(function (accessToken) { return _this.setCurrentUser(accessToken); }));
+    };
+    AuthenticationService.prototype.logout = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.revokeToken().toPromise().then(function () {
+                            _this.removeToken();
+                            _this.router.navigate(['/oauth/login'], { queryParams: { returnUrl: _this.router.routerState.snapshot.url } });
+                        })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AuthenticationService.prototype.removeToken = function () {
+        localStorage.removeItem('token');
+        this.tokenSubject.next(null);
+    };
+    AuthenticationService.prototype.refreshToken = function (additionalParams) {
+        var _this = this;
+        var body = new HttpParams()
+            .set('grant_type', 'refresh_token')
+            .set('refresh_token', this.tokenValue.refreshToken);
+        if (!ObjectUtil.isNull(additionalParams)) {
+            additionalParams.forEach(function (value, key) { return body = body.append(key, value); });
+        }
+        return this.http.post('api/authenticator/oauth/token', body, this.options(this.buildParams(), this.buildHeaders().append('skip', 'true'))).pipe(map(function (accessToken) { return _this.setCurrentUser(accessToken); }));
+    };
+    AuthenticationService.prototype.revokeToken = function (token) {
+        var lHttpHeaders = null;
+        if (!ObjectUtil.isNull(token)) {
+            lHttpHeaders = new HttpHeaders()
+                .append('Authorization', token.accessToken)
+                .append('skip', 'true');
+        }
+        return this.http.post('api/authenticator/oauth/token/revoke', {}, this.options(null, lHttpHeaders));
+    };
+    AuthenticationService.prototype.isValidToken = function (token) {
+        if (!ObjectUtil.isNull(token) && !ObjectUtil.isNull(token.expiration)) {
+            return new Date(token.expiration).valueOf() > new Date().valueOf();
+        }
+        return false;
+    };
+    AuthenticationService.prototype.setCurrentUser = function (token) {
+        if (token && token.accessToken) {
+            localStorage.setItem('token', JSON.stringify(token));
+            this.tokenSubject.next(token);
+        }
+        return token;
+    };
+    Object.defineProperty(AuthenticationService.prototype, "tokenValue", {
+        get: function () {
+            return this.tokenSubject.value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AuthenticationService.prototype, "tokenValueLocalStorage", {
+        get: function () {
+            var token = localStorage.getItem('token');
+            return !StringUtil.isEmpty(token) ? JSON.parse(token) : null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AuthenticationService.prototype.buildHeaders = function () {
+        return new HttpHeaders()
+            .append('Authorization', 'Basic ' + btoa('CONVENANT_MANAGEMENT:123'))
+            .append('Content-Type', 'application/x-www-form-urlencoded')
+            .append('accessType', 'WEB')
+            .append('timeZone', moment(new Date()).format('ZZ'));
+    };
+    AuthenticationService.ctorParameters = function () { return [
+        { type: Router },
+        { type: HttpClient }
+    ]; };
+    AuthenticationService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function AuthenticationService_Factory() { return new AuthenticationService(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i2.HttpClient)); }, token: AuthenticationService, providedIn: "root" });
+    AuthenticationService = __decorate([
+        Injectable({
+            providedIn: 'root'
+        }),
+        __metadata("design:paramtypes", [Router, HttpClient])
+    ], AuthenticationService);
+    return AuthenticationService;
+}(AbstractService));
+export { AuthenticationService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authentication.service.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["core/services/authentication.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\n\nimport * as moment_ from 'moment';\nconst moment = moment_;\n\nimport { BaseUser } from '../models/base-user.model';\nimport { TokenDTO } from '../models/dto/token.dto';\nimport { ObjectUtil } from '../utils/object.util';\nimport { AbstractService } from './abstract.service';\nimport { StringUtil } from '../utils/string.util';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class AuthenticationService<U extends BaseUser> extends AbstractService {\n\n    protected tokenSubject: BehaviorSubject<TokenDTO<U>>;\n\n    token: Observable<TokenDTO<U>>;\n\n    constructor(protected router: Router, protected http: HttpClient) {\n        super();\n        this.tokenSubject = new BehaviorSubject<TokenDTO<U>>(JSON.parse(localStorage.getItem('token')));\n        this.token = this.tokenSubject.asObservable();\n    }\n\n    login(user: U): Observable<TokenDTO<U>> {\n        const body: HttpParams = new HttpParams()\n            .set('grant_type', 'password')\n            .set('username', user.username)\n            .set('password', user.password);\n\n        return this.http.post<TokenDTO<U>>('api/authenticator/oauth/token', body, this.options()).pipe(\n            map(accessToken => this.setCurrentUser(accessToken))\n        );\n    }\n\n    async logout(): Promise<void> {\n        await this.revokeToken().toPromise().then(() => {\n            this.removeToken();\n            this.router.navigate(['/oauth/login'], { queryParams: { returnUrl: this.router.routerState.snapshot.url } });\n        });\n    }\n\n    removeToken(): void {\n        localStorage.removeItem('token');\n        this.tokenSubject.next(null);\n    }\n\n    refreshToken(additionalParams?: Map<any, any>): Observable<TokenDTO<U>> {\n        let body: HttpParams = new HttpParams()\n            .set('grant_type', 'refresh_token')\n            .set('refresh_token', this.tokenValue.refreshToken);\n\n        if (!ObjectUtil.isNull(additionalParams)) {\n            additionalParams.forEach((value, key) => body = body.append(key, value));\n        }\n\n        return this.http.post<TokenDTO<U>>('api/authenticator/oauth/token', body, this.options(this.buildParams(), this.buildHeaders().append('skip', 'true'))).pipe(\n            map(accessToken => this.setCurrentUser(accessToken))\n        );\n    }\n\n    revokeToken(token?: TokenDTO<U>): Observable<any> {\n        let lHttpHeaders: HttpHeaders = null;\n        if (!ObjectUtil.isNull(token)) {\n            lHttpHeaders = new HttpHeaders()\n                .append('Authorization', token.accessToken)\n                .append('skip', 'true');\n        }\n        return this.http.post('api/authenticator/oauth/token/revoke', {}, this.options(null, lHttpHeaders));\n    }\n\n    isValidToken(token: TokenDTO<U>): boolean {\n        if (!ObjectUtil.isNull(token) && !ObjectUtil.isNull(token.expiration)) {\n            return new Date(token.expiration).valueOf() > new Date().valueOf();\n        }\n        return false;\n    }\n\n    protected setCurrentUser(token: TokenDTO<U>): TokenDTO<U> {\n        if (token && token.accessToken) {\n            localStorage.setItem('token', JSON.stringify(token));\n            this.tokenSubject.next(token);\n        }\n        return token;\n    }\n\n    get tokenValue(): TokenDTO<U> {\n        return this.tokenSubject.value;\n    }\n\n    get tokenValueLocalStorage(): TokenDTO<U> {\n        const token: string = localStorage.getItem('token');\n        return !StringUtil.isEmpty(token) ? JSON.parse(token) : null;\n    }\n\n    protected buildHeaders(): HttpHeaders {\n        return new HttpHeaders()\n            .append('Authorization', 'Basic ' + btoa('CONVENANT_MANAGEMENT:123'))\n            .append('Content-Type', 'application/x-www-form-urlencoded')\n            .append('accessType', 'WEB')\n            .append('timeZone', moment(new Date()).format('ZZ'));\n    }\n\n}\n"]}

package/esm5/core/services/breakpoint-observer.service.js

@@ -0,0 +1,52 @@
+import { __decorate, __extends, __metadata, __read } from "tslib";
+import { Injectable } from '@angular/core';
+import { fromEvent } from 'rxjs';
+import { distinctUntilChanged, map, shareReplay, startWith } from 'rxjs/operators';
+import { AbstractService } from './abstract.service';
+import * as i0 from "@angular/core";
+export var POINTS_NAME = [
+    'xl',
+    'lg',
+    'md',
+    'sm',
+    'xs'
+];
+var QUERY = new Map([
+    [POINTS_NAME[0], '(min-width: 1920px)'],
+    [POINTS_NAME[1], '(min-width: 1366px)'],
+    [POINTS_NAME[2], '(min-width: 768px)'],
+    [POINTS_NAME[3], '(min-width: 600px)'],
+    [POINTS_NAME[4], '(min-width: 0px)'],
+]);
+var BreakpointObserverService = /** @class */ (function (_super) {
+    __extends(BreakpointObserverService, _super);
+    function BreakpointObserverService() {
+        var _this = _super.call(this) || this;
+        _this._size$ = fromEvent(window, 'resize').pipe(startWith(_this._getScreenSize()), map(function (event) { return _this._getScreenSize(); }), distinctUntilChanged(), shareReplay(1));
+        return _this;
+    }
+    Object.defineProperty(BreakpointObserverService.prototype, "size$", {
+        get: function () {
+            return this._size$;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BreakpointObserverService.prototype._getScreenSize = function () {
+        var _a = __read(Array.from(QUERY.entries()).filter(function (_a) {
+            var _b = __read(_a, 2), size = _b[0], mediaQuery = _b[1];
+            return window.matchMedia(mediaQuery).matches;
+        }), 1), _b = __read(_a[0], 1), _c = _b[0], newSize = _c === void 0 ? 'never' : _c;
+        return newSize;
+    };
+    BreakpointObserverService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function BreakpointObserverService_Factory() { return new BreakpointObserverService(); }, token: BreakpointObserverService, providedIn: "root" });
+    BreakpointObserverService = __decorate([
+        Injectable({
+            providedIn: 'root'
+        }),
+        __metadata("design:paramtypes", [])
+    ], BreakpointObserverService);
+    return BreakpointObserverService;
+}(AbstractService));
+export { BreakpointObserverService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/core/services/confirmation.service.js

@@ -0,0 +1,66 @@
+import { __awaiter, __decorate, __extends, __generator, __metadata } from "tslib";
+import { Injectable } from '@angular/core';
+import { MatDialog, MatDialogConfig } from '@angular/material';
+import { tap } from 'rxjs/operators';
+import { GIPIConfirmationDialogComponent } from '../../shared/gipi-components/confirmation-dialog/confirmation-dialog.component';
+import { AbstractService } from './abstract.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+var ConfirmationService = /** @class */ (function (_super) {
+    __extends(ConfirmationService, _super);
+    function ConfirmationService(dialog) {
+        var _this = _super.call(this) || this;
+        _this.dialog = dialog;
+        return _this;
+    }
+    ConfirmationService.prototype.confirm = function (confirmation) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result, dialogConfig;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        result = false;
+                        dialogConfig = new MatDialogConfig();
+                        dialogConfig.disableClose = true;
+                        dialogConfig.autoFocus = true;
+                        dialogConfig.data = confirmation;
+                        dialogConfig.minWidth = '20%';
+                        (confirmation.width ? dialogConfig.width = confirmation.width : dialogConfig.maxWidth = '40%');
+                        return [4 /*yield*/, this.dialog
+                                .open(GIPIConfirmationDialogComponent, dialogConfig)
+                                .afterClosed()
+                                .pipe(tap(function (isAccept) {
+                                if (isAccept) {
+                                    if ((confirmation.accept !== null) && (confirmation.accept !== undefined)) {
+                                        confirmation.accept();
+                                    }
+                                }
+                                else {
+                                    if ((confirmation.cancel !== null) && (confirmation.cancel !== undefined)) {
+                                        confirmation.cancel();
+                                    }
+                                }
+                                result = isAccept;
+                            }))
+                                .toPromise()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    ConfirmationService.ctorParameters = function () { return [
+        { type: MatDialog }
+    ]; };
+    ConfirmationService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function ConfirmationService_Factory() { return new ConfirmationService(i0.ɵɵinject(i1.MatDialog)); }, token: ConfirmationService, providedIn: "root" });
+    ConfirmationService = __decorate([
+        Injectable({
+            providedIn: 'root'
+        }),
+        __metadata("design:paramtypes", [MatDialog])
+    ], ConfirmationService);
+    return ConfirmationService;
+}(AbstractService));
+export { ConfirmationService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/core/services/dialog.service.js

@@ -0,0 +1,44 @@
+import { __decorate, __extends, __metadata } from "tslib";
+import { Injectable } from '@angular/core';
+import { MatDialog, MatDialogRef } from '@angular/material';
+import { AbstractService } from './abstract.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+var DialogService = /** @class */ (function (_super) {
+    __extends(DialogService, _super);
+    function DialogService(dialog) {
+        var _this = _super.call(this) || this;
+        _this.dialog = dialog;
+        return _this;
+    }
+    DialogService.prototype.open = function (dialog) {
+        return this.dialog.open(dialog.componentOrTemplateRef, {
+            panelClass: dialog.panelClass,
+            disableClose: dialog.disableClose,
+            width: dialog.width,
+            height: dialog.height,
+            minWidth: dialog.minWidth,
+            minHeight: dialog.minHeight,
+            maxWidth: dialog.maxWidth,
+            maxHeight: dialog.maxHeight,
+            position: dialog.position,
+            data: dialog.data,
+            autoFocus: dialog.autoFocus,
+            restoreFocus: dialog.restoreFocus,
+            closeOnNavigation: dialog.closeOnNavigation,
+        });
+    };
+    DialogService.ctorParameters = function () { return [
+        { type: MatDialog }
+    ]; };
+    DialogService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function DialogService_Factory() { return new DialogService(i0.ɵɵinject(i1.MatDialog)); }, token: DialogService, providedIn: "root" });
+    DialogService = __decorate([
+        Injectable({
+            providedIn: 'root'
+        }),
+        __metadata("design:paramtypes", [MatDialog])
+    ], DialogService);
+    return DialogService;
+}(AbstractService));
+export { DialogService };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlhbG9nLnNlcnZpY2UuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AZ2lwaXNpc3RlbWFzL25nLWNvcmUvIiwic291cmNlcyI6WyJjb3JlL3NlcnZpY2VzL2RpYWxvZy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFHNUQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLG9CQUFvQixDQUFDOzs7QUFLckQ7SUFBbUMsaUNBQWU7SUFFOUMsdUJBQW1CLE1BQWlCO1FBQXBDLFlBQ0ksaUJBQU8sU0FDVjtRQUZrQixZQUFNLEdBQU4sTUFBTSxDQUFXOztJQUVwQyxDQUFDO0lBRUQsNEJBQUksR0FBSixVQUFLLE1BQWlCO1FBQ2xCLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLHNCQUFzQixFQUFFO1lBQ25ELFVBQVUsRUFBRSxNQUFNLENBQUMsVUFBVTtZQUM3QixZQUFZLEVBQUUsTUFBTSxDQUFDLFlBQVk7WUFDakMsS0FBSyxFQUFFLE1BQU0sQ0FBQyxLQUFLO1lBQ25CLE1BQU0sRUFBRSxNQUFNLENBQUMsTUFBTTtZQUNyQixRQUFRLEVBQUUsTUFBTSxDQUFDLFFBQVE7WUFDekIsU0FBUyxFQUFFLE1BQU0sQ0FBQyxTQUFTO1lBQzNCLFFBQVEsRUFBRSxNQUFNLENBQUMsUUFBUTtZQUN6QixTQUFTLEVBQUUsTUFBTSxDQUFDLFNBQVM7WUFDM0IsUUFBUSxFQUFFLE1BQU0sQ0FBQyxRQUFRO1lBQ3pCLElBQUksRUFBRSxNQUFNLENBQUMsSUFBSTtZQUNqQixTQUFTLEVBQUUsTUFBTSxDQUFDLFNBQVM7WUFDM0IsWUFBWSxFQUFFLE1BQU0sQ0FBQyxZQUFZO1lBQ2pDLGlCQUFpQixFQUFFLE1BQU0sQ0FBQyxpQkFBaUI7U0FDOUMsQ0FBQyxDQUFDO0lBQ1AsQ0FBQzs7Z0JBcEIwQixTQUFTOzs7SUFGM0IsYUFBYTtRQUh6QixVQUFVLENBQUM7WUFDUixVQUFVLEVBQUUsTUFBTTtTQUNyQixDQUFDO3lDQUc2QixTQUFTO09BRjNCLGFBQWEsQ0F3QnpCO3dCQWpDRDtDQWlDQyxBQXhCRCxDQUFtQyxlQUFlLEdBd0JqRDtTQXhCWSxhQUFhIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgTWF0RGlhbG9nLCBNYXREaWFsb2dSZWYgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbCc7XG5cbmltcG9ydCB7IERpYWxvZ0RUTyB9IGZyb20gJy4uL21vZGVscy9kdG8vZGlhbG9nLmR0byc7XG5pbXBvcnQgeyBBYnN0cmFjdFNlcnZpY2UgfSBmcm9tICcuL2Fic3RyYWN0LnNlcnZpY2UnO1xuXG5ASW5qZWN0YWJsZSh7XG4gICAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIERpYWxvZ1NlcnZpY2UgZXh0ZW5kcyBBYnN0cmFjdFNlcnZpY2Uge1xuXG4gICAgY29uc3RydWN0b3IocHVibGljIGRpYWxvZzogTWF0RGlhbG9nKSB7XG4gICAgICAgIHN1cGVyKCk7XG4gICAgfVxuXG4gICAgb3BlbihkaWFsb2c6IERpYWxvZ0RUTyk6IE1hdERpYWxvZ1JlZjxhbnk+IHtcbiAgICAgICAgcmV0dXJuIHRoaXMuZGlhbG9nLm9wZW4oZGlhbG9nLmNvbXBvbmVudE9yVGVtcGxhdGVSZWYsIHtcbiAgICAgICAgICAgIHBhbmVsQ2xhc3M6IGRpYWxvZy5wYW5lbENsYXNzLFxuICAgICAgICAgICAgZGlzYWJsZUNsb3NlOiBkaWFsb2cuZGlzYWJsZUNsb3NlLFxuICAgICAgICAgICAgd2lkdGg6IGRpYWxvZy53aWR0aCxcbiAgICAgICAgICAgIGhlaWdodDogZGlhbG9nLmhlaWdodCxcbiAgICAgICAgICAgIG1pbldpZHRoOiBkaWFsb2cubWluV2lkdGgsXG4gICAgICAgICAgICBtaW5IZWlnaHQ6IGRpYWxvZy5taW5IZWlnaHQsXG4gICAgICAgICAgICBtYXhXaWR0aDogZGlhbG9nLm1heFdpZHRoLFxuICAgICAgICAgICAgbWF4SGVpZ2h0OiBkaWFsb2cubWF4SGVpZ2h0LFxuICAgICAgICAgICAgcG9zaXRpb246IGRpYWxvZy5wb3NpdGlvbixcbiAgICAgICAgICAgIGRhdGE6IGRpYWxvZy5kYXRhLFxuICAgICAgICAgICAgYXV0b0ZvY3VzOiBkaWFsb2cuYXV0b0ZvY3VzLFxuICAgICAgICAgICAgcmVzdG9yZUZvY3VzOiBkaWFsb2cucmVzdG9yZUZvY3VzLFxuICAgICAgICAgICAgY2xvc2VPbk5hdmlnYXRpb246IGRpYWxvZy5jbG9zZU9uTmF2aWdhdGlvbixcbiAgICAgICAgfSk7XG4gICAgfVxuXG59XG4iXX0=

package/esm5/core/services/message.service.js

@@ -0,0 +1,36 @@
+import { __decorate, __extends, __metadata } from "tslib";
+import { Injectable } from '@angular/core';
+import { MatSnackBar } from '@angular/material';
+import { AbstractService } from './abstract.service';
+import { AlertComponent } from '../components/alert/alert.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/snack-bar";
+var MessageService = /** @class */ (function (_super) {
+    __extends(MessageService, _super);
+    function MessageService(snackBar) {
+        var _this = _super.call(this) || this;
+        _this.snackBar = snackBar;
+        return _this;
+    }
+    MessageService.prototype.add = function (message) {
+        this.snackBar.openFromComponent(AlertComponent, {
+            verticalPosition: 'top',
+            horizontalPosition: 'center',
+            duration: 8000,
+            data: message
+        });
+    };
+    MessageService.ctorParameters = function () { return [
+        { type: MatSnackBar }
+    ]; };
+    MessageService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function MessageService_Factory() { return new MessageService(i0.ɵɵinject(i1.MatSnackBar)); }, token: MessageService, providedIn: "root" });
+    MessageService = __decorate([
+        Injectable({
+            providedIn: 'root'
+        }),
+        __metadata("design:paramtypes", [MatSnackBar])
+    ], MessageService);
+    return MessageService;
+}(AbstractService));
+export { MessageService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/core/services/nav.service.js

@@ -0,0 +1,51 @@
+import { __decorate, __extends, __metadata } from "tslib";
+import { Injectable } from '@angular/core';
+import { NavigationEnd, Router } from '@angular/router';
+import { BehaviorSubject } from 'rxjs';
+import { AbstractService } from './abstract.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+var NavService = /** @class */ (function (_super) {
+    __extends(NavService, _super);
+    function NavService(router) {
+        var _this = _super.call(this) || this;
+        _this.router = router;
+        _this.menuItems = [];
+        _this.isOpened = false;
+        _this.currentUrl = new BehaviorSubject(undefined);
+        _this.router.events.subscribe(function (event) {
+            if (event instanceof NavigationEnd) {
+                _this.currentUrl.next(event.url);
+            }
+        });
+        return _this;
+    }
+    NavService.prototype.close = function () {
+        this.isOpened = false;
+        this._collapseAllMenu();
+    };
+    NavService.prototype.open = function () {
+        this.isOpened = true;
+        this._collapseAllMenu();
+    };
+    NavService.prototype.toggle = function () {
+        this.isOpened = !this.isOpened;
+        this._collapseAllMenu();
+    };
+    NavService.prototype._collapseAllMenu = function () {
+        this.menuItems.forEach(function (m) { return m.expanded = false; });
+    };
+    NavService.ctorParameters = function () { return [
+        { type: Router }
+    ]; };
+    NavService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function NavService_Factory() { return new NavService(i0.ɵɵinject(i1.Router)); }, token: NavService, providedIn: "root" });
+    NavService = __decorate([
+        Injectable({
+            providedIn: 'root'
+        }),
+        __metadata("design:paramtypes", [Router])
+    ], NavService);
+    return NavService;
+}(AbstractService));
+export { NavService };
+//# sourceMappingURL=data:application/json;base64,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