@senior-gestao-empresarial/angular-components 6.11.5 → 6.12.0-29fe646c-2d98-4822-8690-597195a76ad7

package/bundles/senior-gestao-empresarial-angular-components.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/common'), require('primeng/breadcrumb'), require('@angular/router'), require('rxjs'), require('rxjs/operators'), require('moment'), require('@seniorsistemas/angular-components'), require('@angular/common/http'), require('primeng/api'), require('@ngx-translate/core'), require('@seniorsistemas/platform-components'), require('@seniorsistemas/senior-platform-data'), require('@angular/forms'), require('@stomp/stompjs'), require('js-cookie'), require('sockjs-client')) :
-    typeof define === 'function' && define.amd ? define('@senior-gestao-empresarial/angular-components', ['exports', '@angular/core', '@angular/common', 'primeng/breadcrumb', '@angular/router', 'rxjs', 'rxjs/operators', 'moment', '@seniorsistemas/angular-components', '@angular/common/http', 'primeng/api', '@ngx-translate/core', '@seniorsistemas/platform-components', '@seniorsistemas/senior-platform-data', '@angular/forms', '@stomp/stompjs', 'js-cookie', 'sockjs-client'], factory) :
-    (global = global || self, factory((global['senior-gestao-empresarial'] = global['senior-gestao-empresarial'] || {}, global['senior-gestao-empresarial']['angular-components'] = {}), global.ng.core, global.ng.common, global.breadcrumb, global.ng.router, global.rxjs, global.rxjs.operators, global.moment_, global.angularComponents, global.ng.common.http, global.api, global.core$1, global.platformComponents, global.seniorPlatformData, global.ng.forms, global.stompjs, global.jsCookie, global.SockJS));
-}(this, (function (exports, core, common, breadcrumb, router, rxjs, operators, moment_, angularComponents, http, api, core$1, platformComponents, seniorPlatformData, forms, stompjs, jsCookie, SockJS) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/common'), require('primeng/breadcrumb'), require('@angular/router'), require('rxjs'), require('rxjs/operators'), require('moment'), require('@seniorsistemas/angular-components'), require('@angular/common/http'), require('primeng/api'), require('@ngx-translate/core'), require('@seniorsistemas/platform-components'), require('@seniorsistemas/senior-platform-data'), require('@angular/forms'), require('@stomp/stompjs'), require('sockjs-client'), require('js-cookie')) :
+    typeof define === 'function' && define.amd ? define('@senior-gestao-empresarial/angular-components', ['exports', '@angular/core', '@angular/common', 'primeng/breadcrumb', '@angular/router', 'rxjs', 'rxjs/operators', 'moment', '@seniorsistemas/angular-components', '@angular/common/http', 'primeng/api', '@ngx-translate/core', '@seniorsistemas/platform-components', '@seniorsistemas/senior-platform-data', '@angular/forms', '@stomp/stompjs', 'sockjs-client', 'js-cookie'], factory) :
+    (global = global || self, factory((global['senior-gestao-empresarial'] = global['senior-gestao-empresarial'] || {}, global['senior-gestao-empresarial']['angular-components'] = {}), global.ng.core, global.ng.common, global.breadcrumb, global.ng.router, global.rxjs, global.rxjs.operators, global.moment_, global.angularComponents, global.ng.common.http, global.api, global.core$1, global.platformComponents, global.seniorPlatformData, global.ng.forms, global.stompjs, global.SockJS, global.jsCookie));
+}(this, (function (exports, core, common, breadcrumb, router, rxjs, operators, moment_, angularComponents, http, api, core$1, platformComponents, seniorPlatformData, forms, stompjs, SockJS, jsCookie) { 'use strict';
 
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation.
@@ -7412,320 +7412,508 @@
         return NpsService;
     }());
 
+    var AsyncLock = /** @class */ (function () {
+        function AsyncLock() {
+            this.queue = [];
+            this.acquired = false;
+        }
+        AsyncLock.prototype.acquire = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var _this = this;
+                return __generator(this, function (_a) {
+                    if (!this.acquired) {
+                        this.acquired = true;
+                        return [2 /*return*/, Promise.resolve()];
+                    }
+                    else {
+                        return [2 /*return*/, new Promise(function (resolve, _) {
+                                _this.queue.push(resolve);
+                            })];
+                    }
+                    return [2 /*return*/];
+                });
+            });
+        };
+        AsyncLock.prototype.release = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var continuation;
+                return __generator(this, function (_a) {
+                    if (this.queue.length === 0 && this.acquired) {
+                        this.acquired = false;
+                        return [2 /*return*/, Promise.resolve()];
+                    }
+                    continuation = this.queue.shift();
+                    return [2 /*return*/, new Promise(function (res) {
+                            continuation();
+                            res();
+                        })];
+                });
+            });
+        };
+        return AsyncLock;
+    }());
+
+    var UserInformationService = /** @class */ (function () {
+        function UserInformationService() {
+        }
+        UserInformationService_1 = UserInformationService;
+        UserInformationService.prototype.getAuthToken = function () {
+            var cookieValue = jsCookie.get(UserInformationService_1.TOKEN_COOKIE_KEY) || '{}';
+            var authToken = JSON.parse(cookieValue);
+            return authToken.access_token;
+        };
+        UserInformationService.prototype.getTenantDomain = function () {
+            var cookieValue = jsCookie.get(UserInformationService_1.TOKEN_COOKIE_KEY) || '{}';
+            var authToken = JSON.parse(cookieValue);
+            return authToken.username.split('@')[1];
+        };
+        UserInformationService.prototype.getWebSocketUrl = function () {
+            var baseUrl = jsCookie.get(UserInformationService_1.BASE_URL_COOKIE_KEY);
+            if (!baseUrl.endsWith('/')) {
+                baseUrl += '/';
+            }
+            return baseUrl + 'websocket';
+        };
+        var UserInformationService_1;
+        UserInformationService.BASE_URL_COOKIE_KEY = 'com.senior.base.url';
+        UserInformationService.TOKEN_COOKIE_KEY = 'com.senior.token';
+        UserInformationService.ɵprov = core.ɵɵdefineInjectable({ factory: function UserInformationService_Factory() { return new UserInformationService(); }, token: UserInformationService, providedIn: "root" });
+        UserInformationService = UserInformationService_1 = __decorate([
+            core.Injectable({
+                providedIn: 'root'
+            })
+        ], UserInformationService);
+        return UserInformationService;
+    }());
+
+    var PrimitiveManager = /** @class */ (function () {
+        function PrimitiveManager(domain, service, primitive) {
+            this.domain = domain;
+            this.service = service;
+            this.primitive = primitive;
+            this.stompSubscriptions = [];
+            this.event$ = new rxjs.Subject();
+            this.subscribed$ = new rxjs.BehaviorSubject(false);
+        }
+        PrimitiveManager.prototype.unsubscribe = function () {
+            var e_1, _a;
+            this.event$.complete();
+            try {
+                for (var _b = __values(this.stompSubscriptions), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var stompSubscription = _c.value;
+                    stompSubscription.unsubscribe();
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            this.subscribed$.complete();
+        };
+        PrimitiveManager.prototype.fireEvent = function (event) {
+            this.event$.next(event);
+        };
+        PrimitiveManager.prototype.subscribe = function () {
+            var _a;
+            var subscriptions = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                subscriptions[_i] = arguments[_i];
+            }
+            (_a = this.stompSubscriptions).push.apply(_a, __spread(subscriptions));
+            this.subscribed$.next(true);
+        };
+        PrimitiveManager.prototype.getEventObservable = function () {
+            return this.event$.asObservable();
+        };
+        PrimitiveManager.prototype.getSubscriptionObservable = function () {
+            return this.subscribed$.asObservable();
+        };
+        PrimitiveManager.prototype.hasObservers = function () {
+            // @IMPORTANT: Replace .observers.length === 1 with .observed in rxjs 7.0+
+            return this.event$.observers.length !== 1;
+        };
+        PrimitiveManager.prototype.getObserversCount = function () {
+            return this.event$.observers.length;
+        };
+        return PrimitiveManager;
+    }());
+
+    var RECONNECT_INTERVAL_MILLISECONDS = 3000;
+    var CONNECTION_TIMEOUT_MILLISECONDS = 5000;
     var WebsocketService = /** @class */ (function () {
-        function WebsocketService() {
-            /** @private */
-            this.wasConnected = false;
-            /** @private */
-            this.isConnected = false;
-            /** @private */
-            this.isConnecting = false;
-            /** @private */
-            this.primitiveManagers = new Map();
-            /** @private */
+        function WebsocketService(userInformationService) {
+            this.userInformationService = userInformationService;
             this.connected$ = new rxjs.BehaviorSubject(false);
-            /** @private */
-            this.disconnect$ = new rxjs.Subject();
-            /** @private */
-            this.reconnect$ = new rxjs.Subject();
-            /** @private */
+            this.disconnected$ = new rxjs.Subject();
+            this.reconnected$ = new rxjs.Subject();
             this.error$ = new rxjs.Subject();
             this.subscribed$ = new rxjs.Subject();
+            this.primitiveManagers = new Map();
+            this.connectionLock = new AsyncLock();
+            this.debugEnable = false;
+            this.lostConnection = false;
         }
-        WebsocketService_1 = WebsocketService;
         /**
-         * Observable responsável por emitir uma notificação quando a conexão websocket é estabelecida pela primeira vez.
-         * @return Um `Observable<void>` que emite uma notificação quando a conexão websocket é estabelecida pela primeira vez.
+         * Enables stompjs debug logs and additional info
          */
-        WebsocketService.prototype.onConnect = function () {
-            return this.connected$.asObservable().pipe(operators.filter(Boolean), operators.map(function () { return undefined; }), operators.take(1));
+        WebsocketService.prototype.enableDebugLogs = function () {
+            this.debugEnable = true;
         };
         /**
-         * Observable responsável por emitir uma notificação quando a conexão é desconectada.
-         * @return Um `Observable<void>` que emite uma notificação quando a conexão é desconectada.
+         * Manually starts the connection
          */
-        WebsocketService.prototype.onDisconnect = function () {
-            return this.disconnect$.asObservable();
+        WebsocketService.prototype.connect = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var stompConfig;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, this.connectionLock.acquire()];
+                        case 1:
+                            _a.sent();
+                            _a.label = 2;
+                        case 2:
+                            _a.trys.push([2, , 3, 5]);
+                            if (this.isConnected() || this.isConnecting()) {
+                                return [2 /*return*/];
+                            }
+                            this.lostConnection = false;
+                            stompConfig = {
+                                webSocketFactory: function () {
+                                    return new SockJS(_this.getSubscriptionUrl(), null, {
+                                        timeout: CONNECTION_TIMEOUT_MILLISECONDS
+                                    });
+                                },
+                                connectionTimeout: CONNECTION_TIMEOUT_MILLISECONDS,
+                                reconnectDelay: RECONNECT_INTERVAL_MILLISECONDS,
+                                debug: this.debug.bind(this),
+                                onConnect: this.handleOnConnected.bind(this),
+                                onDisconnect: this.handleOnDisconnect.bind(this),
+                                onWebSocketClose: this.handleOnWebSocketClose.bind(this),
+                                onStompError: this.handleOnStompError.bind(this),
+                                onWebSocketError: this.handleOnWebSocketError.bind(this)
+                            };
+                            this.debug('Connecting the Webscoket');
+                            this.stompClient = new stompjs.Client(stompConfig);
+                            this.stompClient.activate();
+                            return [3 /*break*/, 5];
+                        case 3: return [4 /*yield*/, this.connectionLock.release()];
+                        case 4:
+                            _a.sent();
+                            return [7 /*endfinally*/];
+                        case 5: return [2 /*return*/];
+                    }
+                });
+            });
         };
         /**
-         * Observable responsável por emitir uma notificação quando a conexão é reconectada.
-         * @return Um `Observable<void>` que emite uma notificação quando a conexão é reconectada.
+         * Manually disconnect the websocket. The reconnect loop will be stopped.
          */
-        WebsocketService.prototype.onReconnect = function () {
-            return this.reconnect$.asObservable();
+        WebsocketService.prototype.disconnect = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var _a, _b, primitiveManager;
+                var e_1, _c;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0:
+                            if (!this.isConnected()) {
+                                return [2 /*return*/];
+                            }
+                            return [4 /*yield*/, this.connectionLock.acquire()];
+                        case 1:
+                            _d.sent();
+                            _d.label = 2;
+                        case 2:
+                            _d.trys.push([2, , 5, 7]);
+                            try {
+                                for (_a = __values(this.primitiveManagers.values()), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                    primitiveManager = _b.value;
+                                    primitiveManager.unsubscribe();
+                                }
+                            }
+                            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                            finally {
+                                try {
+                                    if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                                }
+                                finally { if (e_1) throw e_1.error; }
+                            }
+                            this.primitiveManagers.clear();
+                            this.connected$.next(false);
+                            if (!this.stompClient) return [3 /*break*/, 4];
+                            this.stompClient.forceDisconnect();
+                            return [4 /*yield*/, this.stompClient.deactivate()];
+                        case 3:
+                            _d.sent();
+                            _d.label = 4;
+                        case 4: return [3 /*break*/, 7];
+                        case 5: return [4 /*yield*/, this.connectionLock.release()];
+                        case 6:
+                            _d.sent();
+                            return [7 /*endfinally*/];
+                        case 7: return [2 /*return*/];
+                    }
+                });
+            });
         };
         /**
-         * Observable responsável por emitir uma notificação após o subscribe do evento pela primeira vez.
-         * @return Um `Observable<void>` que emite uma notificação após o subscribe do evento pela primeira vez.
+         * Check if the websocket is connected
+         * @return `boolean` representing if the websocket is connected
          */
-        WebsocketService.prototype.onSubscribe = function (_a) {
-            var _this = this;
-            var domain = _a.domain, service = _a.service, primitive = _a.primitive;
-            var key = this.getPrimitiveManagerKey(domain, service, primitive);
-            return this.onConnect().pipe(operators.switchMap(function () {
-                if (_this.primitiveManagers.has(key))
-                    return _this.primitiveManagers
-                        .get(key)
-                        .subscribed$.asObservable()
-                        .pipe(operators.map(function () { return undefined; }), operators.take(1));
-                return _this.subscribed$.asObservable().pipe(operators.filter(function (primitiveManager) {
-                    return _this.getPrimitiveManagerKey(primitiveManager.domain, primitiveManager.service, primitiveManager.primitive) === key;
-                }), operators.map(function () { return undefined; }), operators.take(1));
-            }));
+        WebsocketService.prototype.isConnected = function () {
+            if (!this.stompClient) {
+                return false;
+            }
+            return this.stompClient.connected;
+        };
+        /**
+         * Check if the websocket is tring to connect
+         * @return `boolean` representing if the websocket status
+         */
+        WebsocketService.prototype.isConnecting = function () {
+            if (!this.stompClient) {
+                return false;
+            }
+            return !this.stompClient.connected && this.stompClient.active;
+        };
+        /**
+         * Event responsable to emit an event when the connection is established.
+         * Do not forget to unsubscribe the observable when you don't need it anymore.
+         * @return `Observable<boolean>`
+         */
+        WebsocketService.prototype.onConnect = function () {
+            return this.connected$.asObservable()
+                .pipe(operators.filter(function (p) { return p === true; }));
+        };
+        /**
+         * Event responsable to emit an event when the connection is closed.
+         * Do not forget to unsubscribe the observable when you don't need it anymore.
+         * @return `Observable<void>`
+         */
+        WebsocketService.prototype.onDisconnect = function () {
+            return this.disconnected$.asObservable();
+        };
+        /**
+         * Event responsable to emit an event when the connection is reestablished.
+         * Do not forget to unsubscribe the observable when you don't need it anymore.
+         * @return `Observable<void>`
+         */
+        WebsocketService.prototype.onReconnect = function () {
+            return this.reconnected$.asObservable();
         };
         /**
-         * Observable responsável por emitir uma notificação quando ocorre algum erro.
-         * @return Um `Observable<FrameImpl>` que emite uma notificação quando ocorre algum erro.
+         * Event responsable to emit an event when an error ocurred.
+         * Do not forget to unsubscribe the observable when you don't need it anymore.
+         * @return `Observable<FrameImpl>`
          */
         WebsocketService.prototype.onError = function () {
             return this.error$.asObservable();
         };
         /**
-         * @typeParam `<T>` Tipo do objeto que o retorno do `observable` vai devolver.
-         * @param {Object} options Objeto de configuração do evento.
-         * @param {string} options.domain Domínio da primitiva.
-         * @param {string} options.service Serviço da primitiva.
-         * @param {string} options.primitive  Primitiva que será "observada".
-         * @return Um Observable<T> que emite notificações toda vez que o respectivo evento é publicado.
+         * Event responsible to emit an event when a primitive is called.
+         * Do not forget to unsubscribe the observable when you don't need it anymore.
+         * @typeParam `<T>` Object type that will be used in the observable for the `data` property.
+         * @param {OnEventOptions} options Configurations for the event.
+         * @return `Observable<PrimitiveEvent<T>>` Observable that emits an event when the service calls the primitive.
          */
         WebsocketService.prototype.onEvent = function (options) {
             var _this = this;
-            this.connect();
             var domain = options.domain, service = options.service, primitive = options.primitive;
-            var key = this.getPrimitiveManagerKey(domain, service, primitive);
+            var key = this.buildPrimitiveManagerKey(domain, service, primitive);
             if (this.primitiveManagers.has(key)) {
-                return this.primitiveManagers.get(key).event$.asObservable();
+                return this.primitiveManagers.get(key).getEventObservable();
             }
-            var primitiveManager = {
-                domain: domain,
-                service: service,
-                primitive: primitive,
-                stompSubscriptions: [],
-                event$: new rxjs.Subject(),
-                subscribed$: new rxjs.BehaviorSubject(false)
-            };
+            var primitiveManager = new PrimitiveManager(domain, service, primitive);
             this.primitiveManagers.set(key, primitiveManager);
-            this.onConnect()
-                .pipe(operators.take(1))
-                .subscribe(function () {
-                _this.createStompSubscriptions(primitiveManager);
+            this.connect().then(function () {
+                _this.onConnect()
+                    .pipe(operators.take(1))
+                    .subscribe(function () {
+                    _this.createStompSubscriptions(primitiveManager);
+                });
             });
-            return primitiveManager.event$
-                .asObservable()
-                .pipe(operators.finalize(function () { return _this.disconnectPrimitiveOnFinalize(primitiveManager); }));
-        };
-        /** @private */
-        WebsocketService.prototype.createStompSubscriptions = function (primitiveManager) {
-            var withTokenUrl = this.getSubscriptionUrlWithToken(primitiveManager.domain, primitiveManager.service, primitiveManager.primitive);
-            var stompSubscriptionWithToken = this.createStompSubscription(withTokenUrl, primitiveManager);
-            var withoutTokenUrl = this.getSubscriptionUrlWithoutToken(primitiveManager.domain, primitiveManager.service, primitiveManager.primitive);
-            var stompSubscriptionWithoutToken = this.createStompSubscription(withoutTokenUrl, primitiveManager);
-            primitiveManager.stompSubscriptions = [
-                stompSubscriptionWithToken,
-                stompSubscriptionWithoutToken
-            ];
-            primitiveManager.subscribed$.next(true);
-            this.subscribed$.next(primitiveManager);
+            return primitiveManager
+                .getEventObservable()
+                .pipe(operators.finalize(function () { return _this.unsubscribePrimitiveOnFinalize(primitiveManager); }));
         };
-        /** @private */
-        WebsocketService.prototype.connect = function () {
+        /**
+         * Event responsible to emit an event when a subscription is created for the primitive.
+         * Do not forget to unsubscribe the observable when you don't need it anymore.
+         * @param {OnEventOptions} options Configurations for the event.
+         * Observable responsável por emitir uma notificação após o subscribe do evento pela primeira vez.
+         * @return `Observable<boolean>` Observable that emits an event when the service calls the primitive.
+         */
+        WebsocketService.prototype.onSubscribe = function (options) {
             var _this = this;
-            if (this.isConnected || this.isConnecting)
-                return;
-            this.createStompClient();
-            this.isConnecting = true;
-            this._stompClient.connect({}, function () {
-                _this.isConnecting = false;
-                _this.isConnected = true;
-                if (_this.wasConnected) {
-                    _this.reconnectPrimitives();
-                    _this.connected$.next(true);
-                    _this.reconnect$.next();
+            var domain = options.domain, service = options.service, primitive = options.primitive;
+            var key = this.buildPrimitiveManagerKey(domain, service, primitive);
+            return this.onConnect().pipe(operators.take(1), operators.switchMap(function () {
+                if (_this.primitiveManagers.has(key)) {
+                    return _this.primitiveManagers
+                        .get(key)
+                        .getSubscriptionObservable()
+                        .pipe(operators.take(1));
                 }
-                else {
-                    _this.wasConnected = true;
-                    _this.connected$.next(true);
-                }
-            }, function (error) {
-                _this.isConnected = false;
-                _this.connected$.next(false);
-                _this.error$.next(error);
-                rxjs.race(_this.disconnect$.pipe(operators.take(1), operators.map(function () { return ({ wasDisconnected: true }); })), rxjs.timer(WebsocketService_1.RECONNECT_INTERVAL).pipe(operators.take(1), operators.switchMap(function () {
-                    return rxjs.iif(function () { return document.hidden; }, rxjs.fromEvent(document, 'visibilitychange').pipe(operators.first()), rxjs.of(void 0));
-                }), operators.map(function () { return ({ wasDisconnected: false }); })))
-                    .pipe(operators.take(1))
-                    .subscribe({
-                    next: function (_a) {
-                        var wasDisconnected = _a.wasDisconnected;
-                        if (!wasDisconnected &&
-                            !(_this.isConnected || _this.isConnecting)) {
-                            _this.connect();
-                        }
-                    }
-                });
-            });
+                return _this.subscribed$.asObservable().pipe(operators.filter(function (primitiveManager) {
+                    return _this.buildPrimitiveManagerKey(primitiveManager.domain, primitiveManager.service, primitiveManager.primitive) === key;
+                }), operators.map(function () { return true; }), operators.take(1));
+            }));
         };
-        WebsocketService.prototype.disconnect = function () {
-            var e_1, _a, e_2, _b, e_3, _c;
-            if (!this.isConnected || this.getObserversCount() > 0) {
-                return;
+        WebsocketService.prototype.debug = function (message) {
+            var optionalParams = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                optionalParams[_i - 1] = arguments[_i];
             }
-            try {
-                for (var _d = __values(this.primitiveManagers.values()), _e = _d.next(); !_e.done; _e = _d.next()) {
-                    var primitiveManager = _e.value;
-                    try {
-                        for (var _f = (e_2 = void 0, __values(primitiveManager.stompSubscriptions)), _g = _f.next(); !_g.done; _g = _f.next()) {
-                            var stompSubscription = _g.value;
-                            stompSubscription.unsubscribe();
-                        }
-                    }
-                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                    finally {
-                        try {
-                            if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
-                        }
-                        finally { if (e_2) throw e_2.error; }
-                    }
-                }
+            if (!this.debugEnable) {
+                return;
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
-                }
-                finally { if (e_1) throw e_1.error; }
+            console.log.apply(console, __spread(['WS debug: ' + message], optionalParams));
+        };
+        WebsocketService.prototype.info = function (message) {
+            console.info('WS info: ' + message);
+        };
+        WebsocketService.prototype.handleOnConnected = function () {
+            this.info('Webscoket connected');
+            this.connected$.next(true);
+            if (this.lostConnection) {
+                this.info('Webscoket reconnected, recriating subscriptions');
+                this.handleReconnection();
             }
-            try {
-                for (var _h = __values(this.primitiveManagers.values()), _j = _h.next(); !_j.done; _j = _h.next()) {
-                    var primitiveManager = _j.value;
-                    primitiveManager.event$.complete();
-                }
+        };
+        WebsocketService.prototype.handleOnDisconnect = function () {
+            this.info('Webscoket disconnected');
+            this.connected$.next(false);
+            this.disconnected$.next();
+        };
+        WebsocketService.prototype.handleOnWebSocketClose = function (data) {
+            if (data.wasClean) {
+                return;
             }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
-                }
-                finally { if (e_3) throw e_3.error; }
+            this.lostConnection = true;
+        };
+        WebsocketService.prototype.handleOnStompError = function (data) {
+            this.handleError('StompError', data);
+            if (this.isAuthenticationError(data)) {
+                this.info('Authentication error, recriating subscriptions');
+                this.handleReconnection();
             }
-            this.primitiveManagers.clear();
-            this._stompClient.disconnect();
-            this._stompClient.deactivate();
-            this.isConnected = false;
-            this.isConnecting = false;
-            this.wasConnected = false;
-            this.connected$.next(false);
-            this.disconnect$.next();
         };
-        /** @private */
-        WebsocketService.prototype.getSubscriptionUrlWithToken = function (domain, service, primitive) {
-            var tenant = WebsocketService_1.TOKEN
-                ? WebsocketService_1.TOKEN.username.split('@')[1]
-                : null;
-            var token = WebsocketService_1.TOKEN
-                ? WebsocketService_1.TOKEN.access_token
-                : null;
-            return "/topic/" + tenant + "/" + token + "/" + domain + "/" + service + "/" + primitive;
+        WebsocketService.prototype.isAuthenticationError = function (data) {
+            var _a;
+            var errorMessage = (_a = data === null || data === void 0 ? void 0 : data.headers) === null || _a === void 0 ? void 0 : _a.message;
+            if (!errorMessage) {
+                return false;
+            }
+            return errorMessage.toLowerCase().indexOf('forbiddenexception') !== -1;
         };
-        /** @private */
-        WebsocketService.prototype.getSubscriptionUrlWithoutToken = function (domain, service, primitive) {
-            var tenant = WebsocketService_1.TOKEN
-                ? WebsocketService_1.TOKEN.username.split('@')[1]
-                : null;
-            return "/topic/" + tenant + "/" + domain + "/" + service + "/" + primitive;
+        WebsocketService.prototype.handleOnWebSocketError = function (data) {
+            this.handleError('WebSocketError', data);
         };
-        /** @private */
-        WebsocketService.prototype.createStompSubscription = function (destination, primitiveManager) {
-            return this._stompClient.subscribe(destination, function (message) {
-                var event = JSON.parse(message.body || '{}');
-                primitiveManager.event$.next(event);
-            });
+        WebsocketService.prototype.handleError = function (origin, data) {
+            console.error(origin, data);
+            this.error$.next(data);
         };
-        /** @private */
-        WebsocketService.prototype.createStompClient = function () {
-            var ws = new SockJS(WebsocketService_1.WEBSOCKET_URL + "subscription", null, { timeout: WebsocketService_1.CONNECTION_TIMEOUT });
-            this._stompClient = stompjs.Stomp.over(ws);
-            this._stompClient.debug = function () { return null; };
+        WebsocketService.prototype.handleReconnection = function () {
+            this.lostConnection = false;
+            this.reconnectPrimitives();
+            this.reconnected$.next();
         };
-        /** @private */
         WebsocketService.prototype.reconnectPrimitives = function () {
-            var e_4, _a;
+            var e_2, _a;
             try {
                 for (var _b = __values(this.primitiveManagers.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
                     var primitiveManager = _c.value;
                     this.createStompSubscriptions(primitiveManager);
                 }
             }
-            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
             finally {
                 try {
                     if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
-                finally { if (e_4) throw e_4.error; }
+                finally { if (e_2) throw e_2.error; }
             }
         };
-        /** @private */
+        WebsocketService.prototype.buildSubscriptionUrlWithToken = function (domain, service, primitive) {
+            var authToken = this.userInformationService.getAuthToken();
+            var tenant = this.userInformationService.getTenantDomain();
+            return "/topic/" + tenant + "/" + authToken + "/" + domain + "/" + service + "/" + primitive;
+        };
+        WebsocketService.prototype.getSubscriptionUrlWithoutToken = function (domain, service, primitive) {
+            var tenant = this.userInformationService.getTenantDomain();
+            return "/topic/" + tenant + "/" + domain + "/" + service + "/" + primitive;
+        };
+        WebsocketService.prototype.buildPrimitiveManagerKey = function (domain, service, primitive) {
+            return domain + "/" + service + "/" + primitive;
+        };
+        WebsocketService.prototype.unsubscribePrimitiveOnFinalize = function (primitiveManager) {
+            return __awaiter(this, void 0, void 0, function () {
+                var key;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (primitiveManager.hasObservers()) {
+                                return [2 /*return*/];
+                            }
+                            primitiveManager.unsubscribe();
+                            key = this.buildPrimitiveManagerKey(primitiveManager.domain, primitiveManager.service, primitiveManager.primitive);
+                            this.primitiveManagers.delete(key);
+                            return [4 /*yield*/, this.disconnectIfNoMoreObservables()];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        WebsocketService.prototype.disconnectIfNoMoreObservables = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!(this.getObserversCount() === 0)) return [3 /*break*/, 2];
+                            this.debug('Manually disconnecting because there are no more observers');
+                            return [4 /*yield*/, this.disconnect()];
+                        case 1:
+                            _a.sent();
+                            _a.label = 2;
+                        case 2: return [2 /*return*/];
+                    }
+                });
+            });
+        };
         WebsocketService.prototype.getObserversCount = function () {
-            var e_5, _a;
             var observersCount = 0;
-            try {
-                for (var _b = __values(this.primitiveManagers.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var primitiveManager = _c.value;
-                    observersCount += primitiveManager.event$.observers.length;
-                }
-            }
-            catch (e_5_1) { e_5 = { error: e_5_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_5) throw e_5.error; }
-            }
+            this.primitiveManagers.forEach(function (primitiveManager) {
+                observersCount += primitiveManager.getObserversCount();
+            });
             return observersCount;
         };
-        /** @private */
-        WebsocketService.prototype.disconnectPrimitiveOnFinalize = function (primitiveManager) {
-            var e_6, _a;
-            // @IMPORTANT: Replace .observers.length === 1 with .observed in rxjs 7.0+
-            var hasObservers = !(primitiveManager.event$.observers.length === 1);
-            if (hasObservers)
-                return;
-            primitiveManager.event$.complete();
-            try {
-                for (var _b = __values(primitiveManager.stompSubscriptions), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var stompSubscription = _c.value;
-                    stompSubscription.unsubscribe();
-                }
-            }
-            catch (e_6_1) { e_6 = { error: e_6_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_6) throw e_6.error; }
-            }
-            primitiveManager.subscribed$.complete();
-            var key = this.getPrimitiveManagerKey(primitiveManager.domain, primitiveManager.service, primitiveManager.primitive);
-            this.primitiveManagers.delete(key);
-            this.disconnect();
+        WebsocketService.prototype.createStompSubscription = function (destination, primitiveManager) {
+            return this.stompClient.subscribe(destination, function (message) {
+                var event = JSON.parse(message.body || '{}');
+                primitiveManager.fireEvent(event);
+            });
         };
-        /** @private */
-        WebsocketService.prototype.getPrimitiveManagerKey = function (domain, service, primitive) {
-            return domain + "/" + service + "/" + primitive;
+        WebsocketService.prototype.createStompSubscriptions = function (primitiveManager) {
+            var subscriptionUrlWithToken = this.buildSubscriptionUrlWithToken(primitiveManager.domain, primitiveManager.service, primitiveManager.primitive);
+            var subscriptionUrlWithoutToken = this.getSubscriptionUrlWithoutToken(primitiveManager.domain, primitiveManager.service, primitiveManager.primitive);
+            var stompSubscriptionWithToken = this.createStompSubscription(subscriptionUrlWithToken, primitiveManager);
+            var stompSubscriptionWithoutToken = this.createStompSubscription(subscriptionUrlWithoutToken, primitiveManager);
+            primitiveManager.subscribe(stompSubscriptionWithToken, stompSubscriptionWithoutToken);
+            this.subscribed$.next(primitiveManager);
         };
-        var WebsocketService_1;
-        WebsocketService.RECONNECT_INTERVAL = 3000;
-        WebsocketService.CONNECTION_TIMEOUT = 15000;
-        /** @private */
-        WebsocketService.BASE_URL_COOKIE = 'com.senior.base.url';
-        /** @private */
-        WebsocketService.TOKEN_COOKIE = 'com.senior.token';
-        /** @private */
-        WebsocketService.TOKEN = JSON.parse(jsCookie.get(WebsocketService_1.TOKEN_COOKIE) || '{}');
-        /** @private */
-        WebsocketService.WEBSOCKET_URL = jsCookie.get(WebsocketService_1.BASE_URL_COOKIE) + '/websocket/';
-        WebsocketService.ɵprov = core.ɵɵdefineInjectable({ factory: function WebsocketService_Factory() { return new WebsocketService(); }, token: WebsocketService, providedIn: "root" });
-        WebsocketService = WebsocketService_1 = __decorate([
+        WebsocketService.prototype.getSubscriptionUrl = function () {
+            return this.userInformationService.getWebSocketUrl() + "/subscription";
+        };
+        WebsocketService.ctorParameters = function () { return [
+            { type: UserInformationService }
+        ]; };
+        WebsocketService.ɵprov = core.ɵɵdefineInjectable({ factory: function WebsocketService_Factory() { return new WebsocketService(core.ɵɵinject(UserInformationService)); }, token: WebsocketService, providedIn: "root" });
+        WebsocketService = __decorate([
             core.Injectable({
                 providedIn: 'root'
             })
@@ -7801,6 +7989,73 @@
         return VerifyModulePermission;
     }());
 
+    var VerifyModulePermissionsService = /** @class */ (function () {
+        function VerifyModulePermissionsService(http) {
+            this.http = http;
+        }
+        VerifyModulePermissionsService_1 = VerifyModulePermissionsService;
+        VerifyModulePermissionsService.prototype.consultaModulos = function (request) {
+            return this.http.post(VerifyModulePermissionsService_1.QUERY_MODULES_URL, request);
+        };
+        var VerifyModulePermissionsService_1;
+        VerifyModulePermissionsService.QUERY_MODULES_URL = "erpx_fnd/empresa/queries/consultaModulos";
+        VerifyModulePermissionsService.ctorParameters = function () { return [
+            { type: http.HttpClient }
+        ]; };
+        VerifyModulePermissionsService.ɵprov = core.ɵɵdefineInjectable({ factory: function VerifyModulePermissionsService_Factory() { return new VerifyModulePermissionsService(core.ɵɵinject(http.HttpClient)); }, token: VerifyModulePermissionsService, providedIn: "any" });
+        VerifyModulePermissionsService = VerifyModulePermissionsService_1 = __decorate([
+            core.Injectable({
+                providedIn: "any"
+            })
+        ], VerifyModulePermissionsService);
+        return VerifyModulePermissionsService;
+    }());
+
+    var VerifyModulePermissions = /** @class */ (function () {
+        function VerifyModulePermissions(verifyModulePermissionsService) {
+            this.verifyModulePermissionsService = verifyModulePermissionsService;
+        }
+        VerifyModulePermissions_1 = VerifyModulePermissions;
+        /**
+         * Method to verify if user has permission on a specific module
+         * @param modules Modules to verify the permission
+         * @param requestPermission Indicative if must be call the primitive
+         * @returns An boolean Observable
+         */
+        VerifyModulePermissions.prototype.hasPermissions = function (modules, requestPermission) {
+            var moduleSubject = VerifyModulePermissions_1.subjectsPerModuleMap.get(modules);
+            if (!moduleSubject || requestPermission) {
+                var newModuleSubject_1 = new rxjs.ReplaySubject(1);
+                VerifyModulePermissions_1.subjectsPerModuleMap.set(modules, newModuleSubject_1);
+                this.verifyModulePermissionsService
+                    .consultaModulos({ modulo: modules, somenteAtivo: true })
+                    .pipe(operators.take(1))
+                    .subscribe(function (response) {
+                    var hasPermissions = (response === null || response === void 0 ? void 0 : response.modulos) || [];
+                    newModuleSubject_1.next(hasPermissions);
+                }, function (err) {
+                    VerifyModulePermissions_1.subjectsPerModuleMap.delete(modules);
+                    newModuleSubject_1.error(err);
+                    newModuleSubject_1.unsubscribe();
+                });
+                return newModuleSubject_1.asObservable();
+            }
+            return moduleSubject.asObservable();
+        };
+        var VerifyModulePermissions_1;
+        VerifyModulePermissions.ctorParameters = function () { return [
+            { type: VerifyModulePermissionsService }
+        ]; };
+        VerifyModulePermissions.subjectsPerModuleMap = new Map();
+        VerifyModulePermissions.ɵprov = core.ɵɵdefineInjectable({ factory: function VerifyModulePermissions_Factory() { return new VerifyModulePermissions(core.ɵɵinject(VerifyModulePermissionsService)); }, token: VerifyModulePermissions, providedIn: "root" });
+        VerifyModulePermissions = VerifyModulePermissions_1 = __decorate([
+            core.Injectable({
+                providedIn: "root"
+            })
+        ], VerifyModulePermissions);
+        return VerifyModulePermissions;
+    }());
+
 
     (function (ModulesEnum) {
         ModulesEnum["CONTROLADORIA"] = "CONTROLADORIA";
@@ -7929,6 +8184,7 @@
     exports.NotaFiscalEntradaLookup = NotaFiscalEntradaLookup;
     exports.NpsService = NpsService;
     exports.ParametersLookup = ParametersLookup;
+    exports.PrimitiveManager = PrimitiveManager;
     exports.ProdutoServicoLookup = ProdutoServicoLookup;
     exports.QuantidadeDisponivelDemandaLookup = QuantidadeDisponivelDemandaLookup;
     exports.RequisicaoLookup = RequisicaoLookup;
@@ -7937,12 +8193,15 @@
     exports.UnidadeMedidaLookup = UnidadeMedidaLookup;
     exports.UtilsModule = UtilsModule;
     exports.VerifyModulePermission = VerifyModulePermission;
+    exports.VerifyModulePermissions = VerifyModulePermissions;
     exports.WebsocketService = WebsocketService;
     exports.naturezaReceitaPisCofins = naturezaReceitaPisCofins;
     exports.ɵ0 = ɵ0;
     exports.ɵa = ErpLookupsService;
     exports.ɵd = StorageService;
-    exports.ɵe = VerifyModulePermissionService;
+    exports.ɵe = UserInformationService;
+    exports.ɵf = VerifyModulePermissionService;
+    exports.ɵg = VerifyModulePermissionsService;
 
     Object.defineProperty(exports, '__esModule', { value: true });