TypeScript angular2-jwt.JwtHelper类代码示例

  public getJwt(): any {
    var jwtHelper = new JwtHelper();
    var encodedToken = window.localStorage.getItem('jwt');
    var jwt = jwtHelper.decodeToken(encodedToken);

    return jwt;
  }

 isTokenValid(token: string): Boolean {
 //   auth0 = new auth0.WebAuth({
 //   clientID: AUTH_CONFIG.CLIENT_ID,
 //   domain: AUTH_CONFIG.CLIENT_DOMAIN
 // });
   const jwtHelper: JwtHelper = new JwtHelper();
   return jwtHelper.isTokenExpired(token);
 }

  // Checks for token expiration to display appropriate page
  ngOnInit() {
  var jwtHelper = new JwtHelper();
  var token = localStorage.getItem('auth_token');
  if (token) {
    console.log(jwtHelper.isTokenExpired(token));
    if (jwtHelper.isTokenExpired(token)) {
    this.router.navigate(['/']);
    } else {
    this.router.navigate(['/home']);
    }
  } else {
    this.router.navigate(['/']);
  }

  }

	public static tokenNotExpired(tokenName?: string, jwt?: string) {

		var authToken: string = tokenName || 'id_token';
		var token: string;

		if (jwt) {
			token = jwt;
		} else {
			token = localStorage.getItem(authToken);
		}

		var jwtHelper = new JwtHelper();

		if (!token || jwtHelper.isTokenExpired(token, null)) {
			return false;
		} else {
			return true;
		}
	}

 constructor(public router: Router, public http: Http, public authHttp: AuthHttp) {
   let timer = Observable.timer(2000, 1000);
   let jwtHelper: JwtHelper = new JwtHelper();
   timer.subscribe(t => {
     var token = jwtHelper.decodeToken(localStorage.getItem('id_token'));
     if (token) {
       this.tokenExpires = ((token.exp * 1000) - Number(new Date()));
       this.tokenExpired = this.tokenExpires <= 0;
       if (this.tokenExpires > -5000 && this.tokenExpires < 2000) {
         this.refreshToken();
       }
     }
   });
 }

    constructor(private _httpClient: HttpClient,
                private _notificationService: NotificationService) {
        this.baseUrl = API_ENDPOINT.concat('/auth/local/');
		console.log(`baseurl : ${this.baseUrl}`)
        this.jwtHelper = new JwtHelper();
        //the user doesn't need to login as long as the token is valid
        if (tokenNotExpired()) {
            let idToken = localStorage.getItem('id_token');
            let token = this.jwtHelper.decodeToken(idToken);
            this.currentUser = new User();
            this.currentUser._id = token._id;
            this.currentUser.name = token.name;
            this.currentUser.role = token.role;
			console.log(`existing token - ${this.currentUser.name}`);	
        }

    }

 constructor(public router: Router, public http: Http, public authHttp: AuthHttp,
 public jwtHelper: JwtHelper, private userService: UserService) {
     this.jwt = localStorage.getItem('jwt');
     this.decodedJwt = this.jwt && this.jwtHelper.decodeToken(this.jwt);
     this.user = this.userService.getCurrentUser();
 }

  canActivate() {
    var token = localStorage.getItem("jwt");
 
    if (token && !this.jwtHelper.isTokenExpired(token)){
        console.log(this.jwtHelper.decodeToken(token));
        return true;
    }
    this.router.navigate(["login"]);
    return false;
  }

		tokenGetter: () => {
			// Look in session storage for id_token, but fallback to local storage
			let session = sessionStorage.getItem('id_token');
			let local = localStorage.getItem('id_token');

			let token = session || local;

			if (typeof token !== 'string') { return ''; }

			// Remove any quotations from the sides
			token = token.split('"').join('');

			// Check validity of jwt token
			if (token.split('.').length !== 3) {
				localStorage.removeItem('id_token');
				sessionStorage.removeItem('id_token');
				return '';
			}

			// Check if token is expired. If it is, delete and send user to login page
			if (jwtHelper.isTokenExpired(token)) {
				sessionStorage.removeItem('id_token');
				localStorage.removeItem('id_token');

				this.router.navigate(['/login']);
				return '';
			}

			return token;
		},

            .mergeMap((token) => {
                const decodedToken = this.jwtHelper.decodeToken(token);

                return Observable.interval(
                    new Date(0).setUTCSeconds(decodedToken.exp) - new Date(0).setUTCSeconds(decodedToken.iat)
                );
            })

 this.authProvider.authUser.subscribe(jwt => {
   if (jwt) {
     const decoded = this.jwtHelper.decodeToken(jwt);
     this.user = decoded.sub
   }
   else {
     this.user = null;
   }
 });

  canActivate(next: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
    if (window.localStorage.getItem('token') &&
      !jwtHelper.isTokenExpired(window.localStorage.getItem('token'))) {
      return true;
    }

    this.router.navigate(['login']);
    return false;
  }

 getUserName(): string {
   if (window.localStorage.getItem('token')) {
     let token = window.localStorage.getItem('token');
     let decoded = this.jwtHelper.decodeToken(token);
     return decoded.login
   } else {
     return "not logged in"
   }
 }

    isAuthenticated(): boolean {
        let jwt = this.jwtStorage.getToken();

        if (null === jwt) {
            return false;
        }

        return !this.jwtHelper.isTokenExpired(jwt.token);
    }

 timer.subscribe(t => {
   var token = jwtHelper.decodeToken(localStorage.getItem('id_token'));
   if (token) {
     this.tokenExpires = ((token.exp * 1000) - Number(new Date()));
     this.tokenExpired = this.tokenExpires <= 0;
     if (this.tokenExpires > -5000 && this.tokenExpires < 2000) {
       this.refreshToken();
     }
   }
 });