Angular 可以激活防护装置，并使用角度为5的观察物

我正在使用一个实现canActivate的路由守卫

我在代码中放了一堆控制台日志，以了解它在哪里失败

如果我导航到受保护的路由，会发生什么情况。导航失败，因为防护无法返回值。我拥有的http映射尚未完成

我目前有一个JWT令牌保存在会话存储中，但没有保存在本地存储中

这些是我运行警卫时得到的控制台日志

运行本地检查

运行会话检查

获得了授权它的会话令牌

然后http映射返回，然后代码中断

完整代码如下。谢谢你的帮助

import {Observable} from 'rxjs/Observable';
import 'rxjs/add/operator/map';
import {
  CanActivate,
  ActivatedRouteSnapshot,
  RouterStateSnapshot,
  Router
} from '@angular/router';
import {Injectable} from '@angular/core';
import {UserAuthorizationService} from "../userauthorizationservice/userauthorizationservice";


@Injectable()
export class ClientSuitsAdminSuperUserGuard implements CanActivate{
  constructor(private userservice: UserAuthorizationService, private router: Router){}
  user ={
    id: null,
    isclient: false,
    issuitsviewer: false,
    issuitsadministrator: false,
    issuitssuperuser: false,
    isvenueuser: false

  };

  canActivate(route: ActivatedRouteSnapshot,
              state: RouterStateSnapshot): Observable<boolean> | boolean {

    let token = this.userservice.checklocalfortoken();
    console.log('running the local check');
    if(token == null){
      console.log('running the session check');
      token = this.userservice.checksessionfortoken();
      if(token == null){
        console.log('no session token nav to sign in return false');
        this.router.navigate(['/signin']);
        return false;
      }
      console.log('got session token authorizing it');
      this.userservice.returnauthorizetoken(token)
        .map(
          (req: any)=>{
            this.user = req;
            console.log('this is the user object from the session auth');
            console.log(this.user);
            if(this.user.isclient || this.user.issuitsadministrator || this.user.issuitssuperuser){
              console.log('the user has permissions from the session');
              return true;
            }else{
              console.log('the user does  not have permissions from the session');
              this.router.navigate(['/401']);
              return false;
            }
          },
          error => {
            console.log('error with the session authorization');
            this.router.navigate(['/signin']);
            return false;
          }
        );

    }else{
      console.log('doing the local check');
      this.userservice.returnauthorizetoken(token)
        .map(
          (req: any)=>{
            this.user = req;
            console.log('got the user object from the local');
            console.log(this.user);
            if(this.user.isclient || this.user.issuitsadministrator || this.user.issuitssuperuser){
              console.log('user has permissions from the local');
              return true;
            }else{
              console.log('user does not have permissions from the local');
              this.router.navigate(['/401']);
              return false;
            }
          },
          error => {
            console.log('error from the local authorization');
            this.router.navigate(['/signin']);
            return false;
          }
        );
    }
  }

}

从'rxjs/Observable'导入{Observable}；
导入'rxjs/add/operator/map'；
进口{
激活，
激活的路由快照，
路由器状态快照，
路由器
}来自“@angular/router”；
从“@angular/core”导入{Injectable}；
从“./UserAuthorizationService/UserAuthorizationService”导入{UserAuthorizationService}；
@可注射（）
导出类ClientSuitesAdminSuperUserGuard实现CanActivate{
构造函数（私有用户服务：用户授权服务，私有路由器：路由器）{}
使用者={
id:null，
isclient:错误，
issuitsviewer:错，
管理员：错，
issuitssuperuser:false，
isvenueuser:false
};
canActivate（路由：ActivatedRouteSnapshot，
状态：RouterStateSnapshot）：可观察的|布尔值{
让token=this.userservice.checklocalfortoken（）；
log（“运行本地检查”）；
if（标记==null）{
log（“运行会话检查”）；
token=this.userservice.checksessionfortoken（）；
if（标记==null）{
log（'no session token nav to sign in return false'）；
this.router.navigate（['/sign']）；
返回false；
}
log（'got session token authorization it'）；
this.userservice.returnAuthorizationToken（令牌）
.地图(
（请求：任何）=>{
这个用户=req；
log（'这是会话身份验证中的用户对象'）；
console.log（this.user）；
if（this.user.isclient | | this.user.issuitsadministrator | | this.user.issuitsuperuser）{
log（'用户拥有会话的权限'）；
返回true；
}否则{
log（'用户没有来自会话的权限'）；
this.router.navigate（['/401']）；
返回false；
}
},
错误=>{
log（“会话授权错误”）；
this.router.navigate（['/sign']）；
返回false；
}
);
}否则{
log（“进行本地检查”）；
this.userservice.returnAuthorizationToken（令牌）
.地图(
（请求：任何）=>{
这个用户=req；
log（'从本地获取用户对象'）；
console.log（this.user）；
if（this.user.isclient | | this.user.issuitsadministrator | | this.user.issuitsuperuser）{
log（'用户拥有本地用户的权限'）；
返回true；
}否则{
log（'用户没有来自本地的权限'）；
this.router.navigate（['/401']）；
返回false；
}
},
错误=>{
log（“来自本地授权的错误”）；
this.router.navigate（['/sign']）；
返回false；
}
);
}
}
}

像这样使用它：

        canActivate(route: ActivatedRouteSnapshot,
                  state: RouterStateSnapshot): Observable<boolean> | boolean {
        let token = this.userservice.checklocalfortoken();
        console.log('running the local check');
        if(token == null){
          console.log('running the session check');
          token = this.userservice.checksessionfortoken();
          if(token == null){
            console.log('no session token nav to sign in return false');
            this.router.navigate(['/signin']);
            return false;
          }
          console.log('got session token authorizing it');
          //subscribe method_first and return boolean  variable from here
        }else{
       //subscribe method_second and return boolean  variable from here
        }
      }



       method_first(token): observable<any>{
       this.userservice.returnauthorizetoken(token)
            .map(
              (req: any)=>{
                this.user = req;
                console.log('this is the user object from the session auth');
                console.log(this.user);
                if(this.user.isclient || this.user.issuitsadministrator || this.user.issuitssuperuser){
                  console.log('the user has permissions from the session');
                  return true;
                }else{
                  console.log('the user does  not have permissions from the session');
                  this.router.navigate(['/401']);
                  return false;
                }
              },
              error => {
                console.log('error with the session authorization');
                this.router.navigate(['/signin']);
                return false;
              }
            );
      }

      method_second(token): observable<any>{
      console.log('doing the local check');
          this.userservice.returnauthorizetoken(token)
            .map(
              (req: any)=>{
                this.user = req;
                console.log('got the user object from the local');
                console.log(this.user);
                if(this.user.isclient || this.user.issuitsadministrator || 
    this.user.issuitssuperuser){
                  console.log('user has permissions from the local');
                  return true;
                }else{
                  console.log('user does not have permissions from the local');
                  this.router.navigate(['/401']);
                  return false;
                }
              },
              error => {
                console.log('error from the local authorization');
                this.router.navigate(['/signin']);
                return false;
              }
            );
    }

canActivate（路由：ActivatedRouteSnapshot，
状态：RouterStateSnapshot）：可观察的|布尔值{
让token=this.userservice.checklocalfortoken（）；
log（“运行本地检查”）；
if（标记==null）{
log（“运行会话检查”）；
token=this.userservice.checksessionfortoken（）；
if（标记==null）{
log（'no session token nav to sign in return false'）；
this.router.navigate（['/sign']）；
返回false；
}
log（'got session token authorization it'）；
//首先订阅方法_并从这里返回布尔变量
}否则{
//订阅方法_second并从这里返回布尔变量
}
}
方法_优先（标记）：可观察{
this.userservice.returnAuthorizationToken（令牌）
.地图(
（请求：任何）=>{
这个用户=req；
log（'这是会话身份验证中的用户对象'）；
console.log（this.user）；
if（this.user.isclient | | this.user.issuitsadministrator | | this.user.issuitsuperuser）{
log（'用户拥有会话的权限'）；
返回true；
}否则{
log（'用户没有来自会话的权限'）；
this.router.navigate（['/401']）；
返回false；
}
},
错误=>{
log（“会话授权错误”）；
this.router.navigate（['/sign']）；
返回false；
}
);
}
方法\秒（标记）：可观察{
log（“进行本地检查”）；
this.userservice.returnAuthorizationToken（令牌）
.地图(
（请求：任何）=>{
这个用户=req；
log（'从本地获取用户对象'）；
console.log（this.user）；
if（this.user.isclient | | this.user.issuitsadministrator | |
this.user.issuitsuperuser）{
log（'用户拥有本地用户的权限'）；
返回true；
}否则{