title: Disable AuthGuard and canActivate restrictions
body: <p>I received a project where I need to work on for an internship, but there is a <code>canActivate : [AuthGuard]</code> and many others restriction, so every routes redirect me to login page, and I don't have any credentials to connect so I need a way to disable temporarily those restrictions if someone can help me, I tried to return false in the <code>canActivate()</code> funciton but without success.
  Here the route array, auth.guard.ts and auth.service.ts:</p>
  <p><strong>Routes array:</strong></p>
  <pre><code>const routes: Routes = [
    { path: '', redirectTo: '/home/dashboard', pathMatch: 'full' },
    { path: 'home', component: HomeComponent, canActivate: [AuthGuard], children: [
      { path: '', redirectTo: '/home/dashboard', pathMatch: 'full' },
      { path: 'dashboard', component: DashboardComponent, canActivate: [CaseManagerDashboardGuard] },
      { path: 'messages_board', component: MessagesBoardComponent },
      { path: 'create_organization', component: CreateOrganizationComponent, canActivate: [CreateOrganizationGuard] },
      { path: 'my_profile/:id', component: MyProfileComponent },
      { path: 'profile/:id', component: MyProfileComponent, canActivate: [ProfileGuard] },
      { path: 'create_user', component: CreateUserComponent, canActivate: [CreateUserGuard] },
      { path: 'search_user', component: SearchUserComponent, canActivate: [SearchUserGuard] },
      { path: 'create_patient', component: CreatePatientComponent, canActivate: [CreatePatientGuard], canDeactivate: [CanDeactivateGuard] },
      { path: 'search_patient', component: SearchPatientComponent, canActivate: [SearchPatientGuard] },
      { path: 'patient/:id', component: ClientDashboardComponent, canActivate: [PatientGuard] },
      { path: 'patient_profile/:id', component: ClientProfileComponent, canActivate: [PatientGuard] },
      { path: 'reports', component: ReportsComponent }
    ]},
    { path: 'login', component: LoginComponent },
    { path: 'first-login', component: FirstLoginComponent },
    { path: 'reset-password', component: ResetPasswordComponent },
    { path: 'new-password', component: NewPasswordComponent },
    {
      path: 'chat-poc',
      loadChildren: () =&gt; import('./pages/poc/chat-poc.module').then(m =&gt; m.ChatPocModule)
    },
  
    // otherwise redirect to home
    { path: '**', redirectTo: '/home' }
  ];
  </code></pre>
  <p><strong>auth.guard.ts:</strong></p>
  <pre><code>import { Injectable } from '@angular/core';
  import { Router, CanActivate, ActivatedRouteSnapshot, RouterStateSnapshot, UrlTree } from '@angular/router';
  import { Observable } from 'rxjs';
  import { map, tap, take } from 'rxjs/operators';
  import { AuthService } from './auth.service';
  
  @Injectable({ providedIn: 'root' })
  export class AuthGuard implements CanActivate {
    constructor(private authService: AuthService, private router: Router) {}
  
  
    canActivate(route: ActivatedRouteSnapshot, router: RouterStateSnapshot) {
      console.log('canActivate - AuthGuard 1');
      return this.authService.user.pipe(
        take(1),
        map(user =&gt; {
          console.log('canActivate - AuthGuard 2');
          // console.log(user, 14);
          const isAuth = !!user;
          if (isAuth) {
            console.log('canActivate - AuthGuard 3');
            return true;
          }
          console.log('canActivate - AuthGuard 4');
          return this.router.createUrlTree(['/login']);
        })
      );
    }
  }
  </code></pre>
  <p><strong>auth.service.ts (a bit tall)</strong></p>
  <pre><code>import Swal from 'sweetalert2/dist/sweetalert2.js';
  import {Injectable} from '@angular/core';
  import {HttpClient, HttpErrorResponse, HttpHeaders} from '@angular/common/http';
  import {catchError, tap, concatMap} from 'rxjs/operators';
  import {BehaviorSubject, throwError, from} from 'rxjs';
  import {Router} from '@angular/router';
  import { User } from '../models/user.model';
  import { environment } from 'src/environments/environment';
  import { ChatThreadsService } from '../partials/chat/services/chat-threads.service';
  import { TranslateService } from '@ngx-translate/core';
  
  export interface AuthResponseData {
    kind: string;
    idToken: string;
    email: string;
    refreshToken: string;
    expiresIn: string;
    localId: string;
    registered?: boolean;
  }
  
  export interface FirstLoginResponseData {
    email: string;
  }
  
  export interface PasswordResetEmail {
    email: string;
  }
  
  @Injectable({ providedIn: 'root' })
  export class AuthService {
    user = new BehaviorSubject&lt;User&gt;(null);
    userExtraData = new BehaviorSubject&lt;any&gt;(null);
  
    private tokenExpirationTimer: any;
  
    constructor(
      private http: HttpClient,
      private router: Router,
      private _chatThreadsService: ChatThreadsService,
      public translate: TranslateService
    ) {}
  
    firstLogin(password: string, oobCode: string) {
      return this.http.post&lt;FirstLoginResponseData&gt;(
        environment.identitytoolkit + 'accounts:resetPassword?key=' + environment.firebase.apiKey,
        {
          oobCode,
          newPassword: password
        }
      ).pipe(
        catchError(this.handleError),
        tap(resData =&gt; {
          this.login(resData.email, password).subscribe(
            respData =&gt; {
              this.translate.get('Change_Password_completed_alert').subscribe((res: string) =&gt; {
                Swal.fire({title: '', text: res, icon: 'success', showCancelButton: false, confirmButtonText: 'Ok'})
                .then((result) =&gt; {
                  if (result.value) {
                    console.log(respData);
                    this.getUserExtData(respData.idToken).subscribe(
                      resp =&gt; {
                        this.router.navigate(['/home']);
                      }
                    );
                  }
                });
              });
            },
            errorMessage =&gt; {
              console.log(errorMessage);
              this.translate.get('Change_Password_error_alert').subscribe((res: string) =&gt; {
                Swal.fire({title: '', text: res, icon: 'error', showCancelButton: false, confirmButtonText: 'Close'})
                .then((result) =&gt; {
                  if (result.value) {
                      this.router.navigate(['/reset-password']);
                  }
                });
              });
            }
          );
        })
      );
    }
  
    sendPasswordResetEmail(email: string) {
      return this.http.post&lt;PasswordResetEmail&gt;(
        environment.identitytoolkit + 'accounts:sendOobCode?key=' + environment.firebase.apiKey,
        {
          requestType: 'PASSWORD_RESET',
          email
        }
      ).pipe(
        catchError(this.handleError),
        tap(resData =&gt; {
          console.log('sendPasswordResetEmail Done');
        })
      );
    }
  
    login(email: string, password: string) {
      return this.http.post&lt;AuthResponseData&gt;(
        environment.identitytoolkit + 'accounts:signInWithPassword?key=' + environment.firebase.apiKey,
        {
          email,
          password,
          returnSecureToken: true
        }
      ).pipe(
        catchError(this.handleError),
        tap(resData =&gt; {
          this.handleAuthentication(resData.email, resData.localId, resData.idToken, +resData.expiresIn, resData.refreshToken);
        })
      );
    }
  
    autoLogin() {
      const userData: {
        email: string,
        id: string,
        _token: string,
        _tokenExpirationDate: string,
        refToken: string,
      } = JSON.parse(localStorage.getItem('userData'));
  
      if (!userData) {
        return;
      }
  
      const loadedUser = new User(userData.email, userData.id, userData._token, new Date(userData._tokenExpirationDate), userData.refToken);
  
      if (loadedUser.token) {
        this.user.next(loadedUser);
        const expirationDuration = new Date(userData._tokenExpirationDate).getTime() - new Date().getTime();
        this.autoLogout(expirationDuration);
        // this.refreshToken(expirationDuration, loadedUser.refreshToken);
      }
    }
  
    logout() {
      this._chatThreadsService.logout();
      this.user.next(null);
      this.userExtraData.next(null);
      this.router.navigate(['/login']);
      localStorage.removeItem('userData');
      localStorage.removeItem('userExtData');
      if (this.tokenExpirationTimer) {
        clearTimeout(this.tokenExpirationTimer);
      }
      this.tokenExpirationTimer = null;
    }
  
    autoLogout(expirationDuration: number) {
      this.tokenExpirationTimer = setTimeout(() =&gt; {
        this.logout();
      }, expirationDuration);
    }
  
    refreshToken(expirationDuration: number, refToken: string) {
      console.log(expirationDuration);
      this.tokenExpirationTimer = setTimeout(() =&gt; {
        this.http.post&lt;any&gt;(
          'https://securetoken.googleapis.com/v1/token?key=' + environment.firebase.apiKey,
          {
            refresh_token: refToken,
            grant_type: 'refresh_token'
          }
        ).pipe(
          // catchError(this.handleError),
          tap(resData =&gt; {
            this.refreshToken((+resData.expires_in) * 1000, refToken);
          })
        ).subscribe();
      }, expirationDuration);
    }
  
    getUserExtData(idToken) {
      const headers = { Authorization: 'Bearer ' + idToken };
      return this.http.get&lt;any&gt;(
        environment.apiURL + 'users/me', { headers }
      ).pipe(
        tap(resExtData =&gt; {
          this.userExtraData.next(resExtData);
          localStorage.setItem('userExtData', JSON.stringify(resExtData));
        })
      );
    }
  
    userExtDataUpdate(id: string, language: string, units: string, date_format: string, week_start_day: string, idToken: string) {
      const headers = { Authorization: 'Bearer ' + idToken };
      return this.http.post&lt;any&gt;(
        environment.apiURL + 'users/update',
        {
          id,
          settings: {
            language,
            date_format,
            units,
            week_start_day
          }
        },
        {
          headers
        }
      ).pipe(
        tap(resExtData =&gt; {
          this.getUserExtData(idToken).subscribe();
        })
      );
    }
  
    private handleAuthentication(email: string, userId: string, token: string, expiresIn: number, refreshToken: string) {
      const expirationDate = new Date(new Date().getTime() + expiresIn * 1000);
      const user = new User(email, userId, token, expirationDate, refreshToken);
      this.user.next(user);
      this.autoLogout(expiresIn * 1000);
      // this.refreshToken(expiresIn * 1000, refreshToken);
      localStorage.setItem('userData', JSON.stringify(user));
    }
  
    private handleError(errorRes: HttpErrorResponse) {
      let errorMessage = 'An unknown error occurred!';
      if (!errorRes.error || !errorRes.error.error) {
        return throwError(errorMessage);
      }
      switch (errorRes.error.error.message) {
        case 'EMAIL_EXISTS':
          errorMessage = 'This email exists already';
          break;
        case 'EMAIL_NOT_FOUND':
          // errorMessage = 'This email does not exist.';
          errorMessage = 'Invalid Email';
          break;
        case 'INVALID_PASSWORD':
          errorMessage = 'This password is not correct.';
          break;
      }
      console.log('handleError', errorMessage);
      return throwError(errorMessage);
    }
  }
  </code></pre>