ngx-sp-auth 4.23.15 → 4.23.17

package/fesm2022/ngx-sp-auth.mjs

@@ -821,14 +821,20 @@ class AuthStorageService {
             });
         }
     }
+    /**
+     * Verifica a sessão atual no servidor (`/verify`).
+     * Chamadas simultâneas compartilham a mesma requisição em andamento.
+     * @returns Status da sessão e, quando válida, a identidade (domínio/usuário) informada pelo servidor.
+     */
     checkAuthentication() {
         if (!this.__authenticationCheck$) {
-            let errorMessage = '';
             this.__authenticationCheck$ = this.verifyToken()
-                .pipe(map((response) => {
-                errorMessage = response.ErrorMessage;
-                return { error: response.ErrorMessage, isLoggedIn: !response.Error };
-            }), catchError((err) => {
+                .pipe(map((response) => ({
+                error: response.ErrorMessage,
+                isLoggedIn: !response.Error,
+                dominio: response.Dominio,
+                usuario: response.Usuario
+            })), catchError((err) => {
                 this.isLoggedInSub.next(false);
                 return of({ error: err.error.ErrorMessage, isLoggedIn: false });
             }), finalize(() => this.__authenticationCheck$ = null), shareReplay({ bufferSize: 1, refCount: true }));
@@ -2353,6 +2359,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImpo
         }], ctorParameters: () => [] });
 
 class LoginOSComponent {
+    /**
+     * Nome do lock (Web Locks API) usado para garantir que apenas um login integrado OS
+     * seja processado por vez no navegador, mesmo com várias abas abertas simultaneamente.
+     */
+    static { this.LOGIN_OS_LOCK_NAME = 'ngx-sp-auth:login-os'; }
     // #endregion PUBLIC
     // #endregion ==========> PROPERTIES <==========
     // #region ==========> INITIALIZATION <==========
@@ -2379,65 +2390,105 @@ class LoginOSComponent {
             }
         });
         this.getParams();
-        this.logOn();
+        this.runExclusive(() => this.logOn());
     }
     // #endregion ==========> INITIALIZATION <==========
     // #region ==========> API METHODS <==========
     // #region LOGIN
-    logOn() {
+    /**
+     * Processa o login integrado OS → V6.
+     *
+     * O fluxo é totalmente sequencial para evitar que respostas concorrentes sobrescrevam/expirem os cookies de autenticação:
+     * 1. Aguarda a verificação da sessão atual (`/verify`). Se já houver uma verificação em andamento
+     *    (ex.: disparada pelo construtor do `AuthStorageService`), ela é reaproveitada.
+     *    Assim, um eventual 401 (que expira os cookies) acontece ANTES do novo login gravar os cookies.
+     * 2. Se a sessão do servidor já pertence ao mesmo domínio/usuário do payload, reaproveita a sessão (sem criar outra).
+     * 3. Caso contrário, realiza o login do zero.
+     *
+     * Deve ser executado via `runExclusive()` para que apenas uma aba processe o login por vez.
+     */
+    async logOn() {
         this.loginStatus = "loading";
-        let status = "none";
-        const currDominio = this._storageService.dominio ?? undefined;
-        const currUsuario = this._storageService.user ?? undefined;
-        this._authService.getAuthentication(this._loginOSModel.dominio).subscribe({
-            next: () => {
-                if (currDominio === this._loginOSModel.dominio && currUsuario === this._loginOSModel.usuario) {
-                    // VALIDAR ÚLTIMO ESTAB LOGADO
-                    this._loginOSUtils.getEstabelecimentoSession('').subscribe({
-                        next: res => {
-                            // Atualiza os dados do estabelecimento na sessão
-                            this._storageService.infraEstabId = res.InfraEstabId;
-                            this._storageService.infraEstabNome = res.InfraEstabNome;
-                            this._storageService.infraEmpresaId = res.InfraEmpresaId;
-                            this._storageService.infraEmpresaNome = res.InfraEmpresaNome;
-                            // Após, redireciona para a URL de destino
-                            status = "keep";
-                            this.redirect();
-                            return;
-                        },
-                        error: error => {
-                            this.loginStatus = "error";
-                            this._authUtilService.showHTTPErrorOS(error);
-                        }
-                    });
+        const hadPreviousUser = !!this._storageService.dominio && !!this._storageService.user;
+        try {
+            // (1) Serializa com qualquer /verify em andamento
+            const check = await firstValueFrom(this._storageService.checkAuthentication());
+            // (2) Sessão atual válida e do mesmo usuário do payload → reaproveita
+            if (check.isLoggedIn && this.isSameUserSession(check.dominio, check.usuario)) {
+                const kept = await this.keepCurrentSession();
+                if (kept) {
+                    this.loginStatus = "updated";
+                    this.startTimer();
+                    return;
                 }
-                status = (!currDominio || !currUsuario) ? "none" : "updated";
-                this._authService.loginOS(this._parmsLogin, this._loginOSModel.serialV6).subscribe({
-                    next: () => {
-                        if (status === "none") {
-                            this.startTimer();
-                            this.loginStatus = "success";
-                        }
-                        else {
-                            this.startTimer();
-                            this.loginStatus = "updated";
-                        }
-                    },
-                    error: (error) => {
-                        this.loginStatus = "error";
-                        this._authUtilService.showHTTPErrorOS(error);
-                    },
-                });
-            },
-            error: (error) => {
-                this.loginStatus = "error";
-                this._authUtilService.showHTTPErrorOS(error);
             }
-        });
+            // (3) Login do zero
+            await firstValueFrom(this._authService.getAuthentication(this._loginOSModel.dominio));
+            await firstValueFrom(this._authService.loginOS(this._parmsLogin, this._loginOSModel.serialV6));
+            this.loginStatus = hadPreviousUser ? "updated" : "success";
+            this.startTimer();
+        }
+        catch (error) {
+            this.loginStatus = "error";
+            this._authUtilService.showHTTPErrorOS(error);
+        }
+    }
+    /**
+     * Reaproveita a sessão atual, atualizando os dados do estabelecimento logado.
+     * Só reaproveita se os dados locais (localStorage) também forem do mesmo usuário, pois as telas de destino dependem deles.
+     * @returns `true` se a sessão foi reaproveitada; `false` se deve seguir com um login novo.
+     */
+    async keepCurrentSession() {
+        const localMatches = this.equalsIgnoreCase(this._storageService.dominio, this._loginOSModel.dominio)
+            && this.equalsIgnoreCase(this._storageService.user, this._loginOSModel.usuario)
+            && !!this._storageService.infraUsuarioId;
+        if (!localMatches)
+            return false;
+        try {
+            // Atualiza o último estabelecimento logado do usuário
+            const res = await firstValueFrom(this._loginOSUtils.getEstabelecimentoSession(''));
+            this._storageService.infraEstabId = res.InfraEstabId;
+            this._storageService.infraEstabNome = res.InfraEstabNome;
+            this._storageService.infraEmpresaId = res.InfraEmpresaId;
+            this._storageService.infraEmpresaNome = res.InfraEmpresaNome;
+            return true;
+        }
+        catch (error) {
+            // Não foi possível confirmar os dados da sessão atual: segue com login novo
+            console.warn('login-os: não foi possível reaproveitar a sessão atual, realizando novo login.', error);
+            return false;
+        }
     }
     // #endregion LOGIN
     // #endregion ==========> API METHODS <==========
     // #region ==========> UTILS <==========
+    /**
+     * Executa a função de forma exclusiva no navegador (entre abas da mesma origem) usando a Web Locks API.
+     * Se a API não estiver disponível, executa diretamente.
+     */
+    runExclusive(fn) {
+        const locks = navigator.locks;
+        if (locks?.request) {
+            locks.request(LoginOSComponent.LOGIN_OS_LOCK_NAME, () => fn())
+                .catch(error => {
+                console.error('login-os: falha ao obter lock, executando sem exclusividade.', error);
+                fn();
+            });
+        }
+        else {
+            fn();
+        }
+    }
+    /** Verifica se a sessão informada pelo servidor pertence ao mesmo domínio/usuário do payload. */
+    isSameUserSession(dominio, usuario) {
+        return this.equalsIgnoreCase(dominio, this._loginOSModel.dominio)
+            && this.equalsIgnoreCase(usuario, this._loginOSModel.usuario);
+    }
+    equalsIgnoreCase(a, b) {
+        if (!a || !b)
+            return false;
+        return a.trim().toLowerCase() === b.trim().toLowerCase();
+    }
     redirect() {
         let hostname = window.location.host == "localhost" ? "v6siscandes.sispro.com.br" : window.location.host;
         let baseURL = `https://${hostname}/SisproErpCloud`;