Как использовать код, чтобы определить, обновляется ли токен в теле с помощью HTTP stutas 200 в rxjs

Question

Мне нужно получить содержимое кода тела из состояния HTTP 200, чтобы определить, обновлять ли токен, но сейчас я не знаком с rxjs6, поэтому у меня есть некоторые проблемы с этим кодом, пожалуйста, помогите мне.

Я просмотрел много информации, но все они делают это, собирая HTTP-статы для 401. Мне нужно судить, получая код тела для стутов для 200. Я действительно не знаю, что делать.

isRefreshingToken: boolean = false;
tokenSubject: BehaviorSubject<string> = new BehaviorSubject<string>(null);

private isTokenExpired(req: HttpRequest<any>, next: HttpHandler): Observable<any> {
   if (!this.isRefreshingToken) {
       this.isRefreshingToken = true;
       this.tokenSubject.next(null);
       let currentUser = this.authService.currentUserValue;
          return this.userService.RefreseToken({refreshToken:currentUser.refresh_token}).pipe(
           switchMap(user => {
                    if (user.code === '0') {
                        this.tokenSubject.next(user.data.access_token);
                        localStorage.setItem('jwt_token', JSON.stringify(user.data));
                        return next.handle(this.updateHeader(req, user.data.access_token));
                    } else {
                        this.nzMessageService.error(user.message);
                        this.router.navigateByUrl('/login');
                        return <any>this.authService.logout();
                    }
                }),
                catchError(err => {
                    return <any>this.authService.logout();
                }),
                finalize(() => {
                    this.isRefreshingToken = false;
                })
            )
        } else {
            this.isRefreshingToken = false;
            return this.tokenSubject.pipe(
                filter(token => token != null),
                take(1),
                switchMap(token => {
                    return next.handle(this.updateHeader(req, token));
                })
            )
        }
    }
    private checkTokenExpiryErr(err: HttpResponse<any>): boolean {
        return err.body.code === 'Unauthorized';
    }

    updateHeader(req: HttpRequest<any>, token: any): HttpRequest<any> {
        req = req.clone({
            setHeaders: {
                Authorization: `Bearer ${token}`
            }
        })
        return req;
    }

    intercept( req: HttpRequest<any>, next: HttpHandler ): Observable<HttpEvent<any>> {
        if (req.url.includes('RefreseToken') || req.url.includes('SmsAuthenticate') || req.url.includes('PasswordAuthenticate') || req.url.includes('SendCode')) {
            return next.handle(req);
        } else {
            let currentUser = this.authService.currentUserValue;
            req = req.clone({
                setHeaders: {
                    Authorization: `Bearer ${currentUser.access_token}`
                }
            })
            return next.handle(req).pipe(
                switchMap(res => {
                    if (res instanceof HttpResponse) {
                        if (this.checkTokenExpiryErr(res)) {
                            return this.isTokenExpired(req, next)
                        }
                         else {
                            if (res.body.code !== '0') {
                                this.nzMessageService.error(res.body.message);
                                this.router.navigateByUrl('/login');
                                this.authService.logout();
                                return throwError(res);
                            } else {
                                return of(res);
                            }
                        }
                    }
                    return of(res);
                })
            )
        }
}