Angular 处理来自不'；t在canActivate（）中返回布尔值

我正在尝试创建一个

canActivate（）

函数，该函数将：

return false;
this.router.navigateByUrl('/login'); 

当状态代码从一个可观察的

状态代码中读取时，即当
HttpErrorResponse
被触发时

==============================================

这是我的服务：

currentUser(token): Observable<any> {
    const url = `${this.BACKEND_URL}/status`;
    const httpOptions = {
        headers: new HttpHeaders({
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${token}`
        })
    };
    return this.http.post(url, {'token': token}, httpOptions);
}

我目前有一个代码，当状态代码为
401
时，该代码失败，错误：Uncaught（承诺中）：HttpErrorResponse

：

@Injectable()
export class EnsureAuthenticated implements CanActivate {
    constructor(private auth: AuthService, private router: Router) {}
    canActivate(): Observable<boolean> {
        console.log('AUTH');
        return this.auth.currentUser(localStorage.getItem('token')).pipe(map(suc => {
            if (suc.status = 'success') {
                return true;
            } else {
                this.router.navigateByUrl('/login');
                return false;
            }
        }));
    }
}

@Injectable（）
导出类确保重新验证的工具可以激活{
构造函数（私有身份验证：身份验证服务，私有路由器：路由器）{}
canActivate（）：可观察的{
console.log（'AUTH'）；
返回此.auth.currentUser（localStorage.getItem（'token'））.pipe（map（suc=>{
如果（suc.status='success'）{
返回true；
}否则{
this.router.navigateByUrl（'/login'）；
返回false；
}
}));
}
}

---

我使用的是angular 7.0.4。

答案是使用

catchError

捕捉错误：

import { Injectable } from '@angular/core';
import { CanActivate, Router } from '@angular/router';
import { AuthService } from './auth.service';
import {Observable, of} from 'rxjs';
import {catchError, map} from 'rxjs/operators';
import {HttpErrorResponse} from '@angular/common/http';

@Injectable()
export class EnsureAuthenticated implements CanActivate {
    constructor(private auth: AuthService, private router: Router) {}
    canActivate(): Observable<boolean> {
        return this.auth.currentUser(localStorage.getItem('token')).pipe(map(suc => {
            if (suc.status = 'success') {
                return true;
            } else {
                this.router.navigateByUrl('/login');
                return false;
            }
        }), catchError((err: HttpErrorResponse) => {
            this.router.navigateByUrl('/login');
            return of(false);
        }));
    }
}

从'@angular/core'导入{Injectable}；
从'@angular/Router'导入{CanActivate，Router}；
从“/auth.service”导入{AuthService}；
从'rxjs'导入{可观察的}；
从“rxjs/operators”导入{catchError，map}；
从“@angular/common/http”导入{HttpErrorResponse}；
@可注射（）
导出类确保重新验证的工具可以激活{
构造函数（私有身份验证：身份验证服务，私有路由器：路由器）{}
canActivate（）：可观察的{
返回此.auth.currentUser（localStorage.getItem（'token'））.pipe（map（suc=>{
如果（suc.status='success'）{
返回true；
}否则{
this.router.navigateByUrl（'/login'）；
返回false；
}
})，catchError（（err:HttpErrorResponse）=>{
this.router.navigateByUrl（'/login'）；
归还（假）；
}));
}
}

这对我很有效 不要返回不起任何作用的false，而是直接返回UrlTree以导航到您想要去的地方

canActivate(
        route: ActivatedRouteSnapshot,
        state: RouterStateSnapshot
      ):
        | Observable<boolean | UrlTree>
        | Promise<boolean | UrlTree>
        | boolean
        | UrlTree {
        return this.accountClientService.isLoggedIn().pipe(
          map((responseData: ResponseService<boolean>) => {
            if (responseData.model) {
              return responseData.model;
            }
    
            return this.router.createUrlTree(['/signin']);
          }),
          catchError((err) => {
            return of(this.router.createUrlTree(['/signin']));
          })
        );
      }

canActivate(
路由：ActivatedRouteSnapshot，
状态：RouterStateSnapshot
):
|可观察
|允诺
|布尔值
|UrlTree{
返回此.accountClientService.isLoggedIn（）管道(
映射（（响应数据：响应服务）=>{
if（响应数据模型）{
返回响应数据模型；
}
返回此.router.createUrlTree（['/sign']）；
}),
catchError（（err）=>{
返回（this.router.createUrlTree（['/sign']）；
})
);
}

没有，对不起，我删除了标签。

canActivate(
        route: ActivatedRouteSnapshot,
        state: RouterStateSnapshot
      ):
        | Observable<boolean | UrlTree>
        | Promise<boolean | UrlTree>
        | boolean
        | UrlTree {
        return this.accountClientService.isLoggedIn().pipe(
          map((responseData: ResponseService<boolean>) => {
            if (responseData.model) {
              return responseData.model;
            }
    
            return this.router.createUrlTree(['/signin']);
          }),
          catchError((err) => {
            return of(this.router.createUrlTree(['/signin']));
          })
        );
      }