doneit-web/src/app/infra/monitoring/interceptors/token.interceptors.ts

import { Injectable } from "@angular/core";
import {
  HttpRequest,
  HttpHandler,
  HttpEvent,
  HttpInterceptor,
  HttpErrorResponse,
  HTTP_INTERCEPTORS,
  HttpClient,
} from "@angular/common/http";
import { Observable, throwError, BehaviorSubject, of } from "rxjs";
import { catchError, filter, take, switchMap, tap } from "rxjs/operators";
import { SessionStore } from '../../../store/session.service';
import { environment } from "src/environments/environment";
import { Router } from "@angular/router";
import { HttpErrorHandle } from 'src/app/services/http-error-handle.service';
import { Platform } from '@ionic/angular';
import { UserLoginOutputResponse } from "../../../core/user/repository/user-remote-repository";
import { UserLoginMapper } from "../../../core/user/mapper/user-login";
import { UserSession } from "../../../models/user.model";

@Injectable()
export class TokenInterceptor implements HttpInterceptor {
  private isRefreshing = false;
  private refreshTokenSubject: BehaviorSubject<any> = new BehaviorSubject<any>(
    null
  );

  private excludedDomains = [ 'Login', environment.apiChatUrl, 'http://localhost:8019']; // Add the domains you want to exclude

  constructor(
    private http: HttpClient,
    private router: Router,
    private httpErrorHandle: HttpErrorHandle,
    private platform: Platform) { }


  intercept(
    request: HttpRequest<any>,
    next: HttpHandler
  ): Observable<HttpEvent<any>> {

    if (this.shouldExcludeDomain(request)) {
      return next.handle(request);
    }

    if (SessionStore.user.Authorization) {
      request = this.addToken(request, SessionStore.user.Authorization);
    }

    return next.handle(request).pipe(

      catchError((error) => {
        console.log('interceptor ',error)
        if(error.url.includes('/Users/RefreshToken') && error.status === 401) {
          console.log("refresh token error11",error)
          return throwError(error);
        }
        else if (error instanceof HttpErrorResponse && error.status === 401) {
          return this.handle401Error(request, next);
        } else if (error.url.includes('https://gdapi-dev.dyndns.info/stage/api/v2') && error.status === 0){
          return this.handle401Error(request, next);
        } else {
          return throwError(error);
        }
      })
    );
  }

  private shouldExcludeDomain(request: HttpRequest<any>): boolean {
    const url = request.url.toLowerCase();
    return this.excludedDomains.some((domain) => url.includes(domain.toLowerCase()));
  }

  private addToken(request: HttpRequest<any>, token: string) {

    return request.clone({
      setHeaders: {
        //'Access-Control-Allow-Origin': '*',
        Authorization: `Bearer ${token}`,
      },
    });

  }

  private handle401Error(request: HttpRequest<any>, next: HttpHandler) {
    // if not getting the new token yet
    if (!this.isRefreshing) {
      this.isRefreshing = true;
      this.refreshTokenSubject.next(null);

      return this.refreshToken().pipe(
        switchMap((data: UserLoginOutputResponse) => {
          this.isRefreshing = false;
          this.refreshTokenSubject.next(data?.data?.authorization);
          return next.handle(this.addToken(request, data?.data?.authorization));
        })
      );
    } else {
      // get new token
      return this.refreshTokenSubject.pipe(
        filter((token) => token != null),
        take(1),
        switchMap((jwt) => {
          return next.handle(this.addToken(request, jwt));
        })
      );
    }
  }


  //this method refresh token is declared here temporary beacouse a circular error
  refreshToken() {
    let channelId;
    if ( this.platform.is('desktop') || this.platform.is("mobileweb")){
      channelId = 2
    } else {
      channelId = 1
    }

    return this.http
      .post<UserLoginOutputResponse>('https://gdapi-dev.dyndns.info/stage/api/v2/Users/RefreshToken', {
        authorization: SessionStore.user.Authorization,
        refreshToken: SessionStore.user.RefreshToken,
        channelId
      },)
      .pipe(
        tap((data) => {

          SessionStore.user.Authorization = data.data.authorization;
          SessionStore.user.RefreshToken = data.data.refreshToken;
          //const userData = UserLoginMapper.toDomainData(data)
          //const session: UserSession = Object.assign(SessionStore.user, userData)
          //SessionStore.reset(session)ta

        }),
        catchError((error) => {
          console.log("refresh token error",error)
          // SessionStore.user.Authorization = SessionStore.user.Authorization;
          // SessionStore.user.RefreshToken = SessionStore.user.RefreshToken;
          SessionStore.setInativity(false)
          /*  SessionStore.setUrlBeforeInactivity(this.router.url); */

          if (environment.production) {
            window.location.pathname = '/auth'
          } else {
            const pathBeforeGoOut = window.location.pathname
            console.log('Before auth',window.location.pathname)
            this.router.navigateByUrl('/auth', { replaceUrl: true }).then(() =>{
              if(pathBeforeGoOut != "/auth") {
                this.httpErrorHandle.httpsSucessMessagge('sessonExpired')
              }

            })
          }
          return of(false);
        })
      );
  }

}

export const tokenInterceptor = {
  provide: HTTP_INTERCEPTORS,
  useClass: TokenInterceptor,
  multi: true
};