ngx-sp-auth 4.23.9 → 4.23.10

package/fesm2022/ngx-sp-auth.mjs

@@ -5,7 +5,7 @@ import { HTTP_INTERCEPTORS, HttpHeaders, HttpClient, HttpParams, HttpResponse }
 import * as i1$2 from '@azure/msal-angular';
 import { MsalInterceptor, MsalGuard, MsalModule, MSAL_GUARD_CONFIG } from '@azure/msal-angular';
 import { LogLevel, PublicClientApplication, InteractionType } from '@azure/msal-browser';
-import { take as take$1, tap as tap$1, map as map$1, switchMap as switchMap$1 } from 'rxjs/operators';
+import { take as take$1, tap as tap$1, map as map$1, filter as filter$1, switchMap as switchMap$1 } from 'rxjs/operators';
 import * as i1$1 from '@angular/router';
 import { RouterLink, NavigationEnd, RouterOutlet, Router, PRIMARY_OUTLET } from '@angular/router';
 import * as i3 from 'ngx-sp-infra';
@@ -807,8 +807,8 @@ class AuthStorageService {
     /** Inicia a verificação do login. */
     startLoginCheck() {
         if (!this.__isCheckingAuth) {
-            this.checkAuthentication().subscribe((isLoggedIn) => {
-                if (isLoggedIn) {
+            this.checkAuthentication().subscribe((res) => {
+                if (res.isLoggedIn) {
                     // ERICK: Chamada do método custom movida para cá para chamar uma única vez ao invés de se repetir a cada validação do token no método reCheckLogin, 
                     // visto que o método storageInitializeAutoStorage tem como objetivo realizar inicializações diversas quando o Login é executado via Pré Portal,
                     // e não há necessidade de repetir essas inicializações a cada verificação do token.
@@ -820,10 +820,14 @@ class AuthStorageService {
     }
     checkAuthentication() {
         if (!this.__authenticationCheck$) {
+            let errorMessage = '';
             this.__authenticationCheck$ = this.verifyToken()
-                .pipe(map((response) => !response.Error), catchError(() => {
+                .pipe(map((response) => {
+                errorMessage = response.ErrorMessage;
+                return { error: response.ErrorMessage, isLoggedIn: !response.Error };
+            }), catchError((err) => {
                 this.isLoggedInSub.next(false);
-                return of(false);
+                return of({ error: err.error.ErrorMessage, isLoggedIn: false });
             }), finalize(() => this.__authenticationCheck$ = null), shareReplay({ bufferSize: 1, refCount: true }));
         }
         return this.__authenticationCheck$;
@@ -832,7 +836,7 @@ class AuthStorageService {
         const url = `${this._BASE_VERIFICATION_URL}`;
         const headers = this._HTTP_HEADERS.set('x-application', this._customEnvironmentService.product);
         return defer(() => {
-            this._toastr.info('Validando token do usuário.', 'Aguarde...');
+            this._toastr.info('Validando token do usuário.', 'Aguarde...', { disableTimeOut: true, progressBar: true, progressAnimation: 'increasing', closeButton: true });
             const params = new HttpParams()
                 .set('ip', this.ip)
                 .set('browser', this._ipService.getDataBrowserUser().browser);
@@ -4510,16 +4514,21 @@ i0.ɵɵngDeclareClassMetadataAsync({ minVersion: "18.0.0", version: "19.2.25", n
             }], ctorParameters: () => [{ type: AuthUtilService }, { type: i4.BsModalService }, { type: MenuServicesService }, { type: i3.MessageService }, { type: MeuPerfilService }, { type: i1$1.Router }], propDecorators: null }) });
 
 class AuthGuard {
-    constructor(router, authStorageService) {
-        this.router = router;
-        this.authStorageService = authStorageService;
+    constructor(_router, _authStorage, _message) {
+        this._router = _router;
+        this._authStorage = _authStorage;
+        this._message = _message;
     }
-    IsUserAuth() {
-        return this.authStorageService.checkAuthentication()
-            .pipe(map$1((isLoggedIn) => {
-            if (!isLoggedIn || this.authStorageService.isExternalLogin) {
-                let login = this.router.parseUrl("/auth/login");
-                return login;
+    IsUserAuth(targetUrl = this._router.url) {
+        return this._authStorage.checkAuthentication()
+            .pipe(map$1(({ error, isLoggedIn }) => {
+            if (!isLoggedIn || this._authStorage.isExternalLogin) {
+                const targetPath = targetUrl.split(/[?#]/, 1)[0].replace(/\/+$/, '').toLowerCase();
+                if (error.trim() && (targetPath !== '/auth/login' && targetPath !== '')) {
+                    this._router.events.pipe(filter$1((event) => event instanceof NavigationEnd), filter$1(event => event.urlAfterRedirects.split(/[?#]/, 1)[0] === '/auth/login'), take$1(1))
+                        .subscribe(() => this._message.showAlertWarning(error));
+                }
+                return this._router.parseUrl('/auth/login');
             }
             return true;
         }));
@@ -4528,21 +4537,21 @@ class AuthGuard {
         if (segments[0]?.path.toLowerCase() === 'auth') {
             return of(false);
         }
-        return this.IsUserAuth();
+        return this.IsUserAuth(`/${segments.map(segment => segment.path).join('/')}`);
     }
-    canActivate(_route, _state) {
-        return this.IsUserAuth();
+    canActivate(_route, state) {
+        return this.IsUserAuth(state.url);
     }
-    canLoad(_route) {
-        return this.IsUserAuth();
+    canLoad(_route, segments) {
+        return this.IsUserAuth(`/${segments.map(segment => segment.path).join('/')}`);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: AuthGuard, deps: [{ token: i1$1.Router }, { token: AuthStorageService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: AuthGuard, deps: [{ token: i1$1.Router }, { token: AuthStorageService }, { token: i3.MessageService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: AuthGuard, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: AuthGuard, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: i1$1.Router }, { type: AuthStorageService }] });
+        }], ctorParameters: () => [{ type: i1$1.Router }, { type: AuthStorageService }, { type: i3.MessageService }] });
 
 class ExternaLoginlGuard {
     constructor(router, authService, authStorageService) {