From 87b5c6927ee0f377d9fc0bcc0f9d1ea6b969ffe6 Mon Sep 17 00:00:00 2001
From: fengxiang <110431245@qq.com>
Date: Wed, 06 Jun 2018 15:12:59 +0800
Subject: [PATCH] 解决超时弹窗反复弹出

---
 src/app/core/net/default.interceptor.ts |  148 ++++++++++++++++++++++++++++++++++++------------
 1 files changed, 110 insertions(+), 38 deletions(-)

diff --git a/src/app/core/net/default.interceptor.ts b/src/app/core/net/default.interceptor.ts
index 7fa1f36..6f77ed7 100644
--- a/src/app/core/net/default.interceptor.ts
+++ b/src/app/core/net/default.interceptor.ts
@@ -1,67 +1,139 @@
 import { Injectable, Injector } from '@angular/core';
 import { Router } from '@angular/router';
-import { HttpInterceptor, HttpRequest, HttpHandler,
+import { HttpInterceptor, HttpRequest, HttpHandler, HttpErrorResponse,
          HttpSentEvent, HttpHeaderResponse, HttpProgressEvent, HttpResponse, HttpUserEvent,
        } from '@angular/common/http';
 import { Observable } from 'rxjs/Observable';
+import { of } from 'rxjs/observable/of';
 import { ErrorObservable } from 'rxjs/observable/ErrorObservable';
-import { catchError } from 'rxjs/operators';
-import { map, mergeMap } from 'rxjs/operators';
+import { mergeMap, catchError } from 'rxjs/operators';
+import { NzMessageService, NzModalService } from 'ng-zorro-antd';
+import { _HttpClient } from '@delon/theme';
 import { environment } from '@env/environment';
+import { LoginService } from '@business/services/http/login.service';
+import { Subject } from 'rxjs/Subject';
+import { error } from 'protractor';
+import { debug } from 'util';
+import {Location} from '@angular/common';
 
 /**
  * ������HTTP������������������������������ `app.module.ts`
  */
 @Injectable()
 export class DefaultInterceptor implements HttpInterceptor {
-    constructor(private injector: Injector) {}
-
-    private goLogin() {
-        const router = this.injector.get(Router);
-        this.injector.get(Router).navigate([ '/login' ]);
+    private unLoginHandle: Subject<HttpErrorResponse> = new Subject<HttpErrorResponse>();
+    
+    constructor(private injector: Injector) {
+         this.unLoginHandle.debounceTime(1000).subscribe( (event: HttpErrorResponse) => {
+                if (!!event.error) {
+                    let errorMsg = '';
+                    const erroCode =  !!event.error['errorCode'] ? Number.parseInt(event.error['errorCode']) : 0;
+                    switch (erroCode) {
+                    case 10: errorMsg = '���������,���������'; break;
+                    case 11: errorMsg = '������������,���������������'; break;
+                    case 12: errorMsg = '������������,������������������'; break;
+                    case 0: errorMsg = '���������������������������'; break;
+                    default: errorMsg = '������������,���������������'; break;
+                    }
+                    if (!this.isExpireModelShow) {
+                        this.isExpireModelShow = true;
+                        // ������refresh���������������������
+                        this.loginService.clearRefreshToken();
+                        this.model.info({
+                        title: errorMsg,
+                        onOk: () => {
+                            this.isExpireModelShow = false;
+                            this.goTo('/passport/login');
+                        }
+                        });
+                    }
+            }
+         });
+    }
+    private isExpireModelShow = false;
+    get loginService(): LoginService {
+        return this.injector.get<LoginService>(LoginService);
+    }
+    get msg(): NzMessageService {
+        return this.injector.get(NzMessageService);
+    }
+    get model(): NzModalService {
+        return this.injector.get(NzModalService);
+    }
+    private goTo(url: string) {
+        setTimeout(() => this.injector.get(Router).navigateByUrl(url));
     }
 
-    intercept(req: HttpRequest<any>, next: HttpHandler):
-        Observable<HttpSentEvent | HttpHeaderResponse | HttpProgressEvent | HttpResponse<any> | HttpUserEvent<any>> {
+    private handleData(event: HttpResponse<any> | HttpErrorResponse): Observable<any> {
+        // ��������������� `throw` ������������������ `_HttpClient` ��� `end()` ������
+        // this.injector.get(_HttpClient).end();
+        // ���������������������������������
+        const status = !!event.status ? event.status : 401;
+        switch (status) {
+            case 200:
+                // ��������������������������������������������������� `status` ��������� `0` ���������������������
+                // ��������� `error_message` ������
 
-        // TIPS������TOKEN��������������� `@delon/auth` ������
-        // Document: http://ng-alain.com/docs/auth
+                // const body: any = event instanceof HttpResponse && event.body;
+                // if (body && body.status !== 0) {
+                //     this.msg.error(body.error_message);
+                //     // ������������������������������������ Pipe���subscribe ������������������
+                //     // this.http.get('/').subscribe() ���������������
+                //     return ErrorObservable.throw(event);
+                // }
+                break;
+            case 401: // ������������������
+            // this.goTo('/passport/login');
+                if (!this.isLoginPage) {
+                    this.unLoginHandle.next(<HttpErrorResponse>event);
+                }
+                break;
+            case 403:
+            case 404:
+            case 500:
+                this.goTo(`/${event.status}`);
+                break;
+        }
+        // ��������������������� httpclient ������������
+        if (event instanceof HttpErrorResponse) {
+            return ErrorObservable.create(event);
+        } else {
+            return of(event);
+        }       
+    }
+    private get isLoginPage(): boolean {
+        return !!location && !!location.hash && location.hash.endsWith('login');
+    }
+    intercept(req: HttpRequest<any>, next: HttpHandler):
+        Observable<HttpSentEvent | HttpHeaderResponse | HttpProgressEvent | HttpResponse<any> | HttpUserEvent<any>> {       
         // ���������������������������
         let url = req.url;
-        
-        if (!url.startsWith('https://') && !url.startsWith('http://')) {
-            url = environment.SERVER_URL + url;
+        if (!url.startsWith('https://') && !url.startsWith('http://') && !url.startsWith('assets')) {
+            // url = environment.SERVER_URL + url;
+            url = environment.SERVER_BASH_URL + url;
         }
+
         const newReq = req.clone({
             url: url
         });
-
         return next.handle(newReq).pipe(
-                    mergeMap((event: any) => {
+                    mergeMap((event: any) => {                        
                         // ������������������������������������������������������������������������������������������������HTTP������������������200������������������
-                        if (event instanceof HttpResponse && event.status !== 200) {
-                            // ���������������observer.error ��������������������� `catch`
-                            // return ErrorObservable.create(event);
-                        }
+                        if (event instanceof HttpResponse && event.status === 200) {
+                                // ������token���������������������������
+                                if (!this.isLoginPage 
+                                    && !!newReq.headers 
+                                    && !newReq.headers.get('X-Refrsh-Token')
+                                    && !url.startsWith('assets')) {                                    
+                                    this.loginService.refreshToken();
+                                } 
+                                return this.handleData(event);
+                            }
                         // ������������������������������������
-                        return Observable.create(observer => observer.next(event));
+                        return of(event);
                     }),
-                    catchError((res: HttpResponse<any>) => {
-                        // ���������������������������������
-                        switch (res.status) {
-                            case 401: // ������������������
-                                this.goLogin();
-                                break;
-                            case 200:
-                                // ������������������������
-                                console.log('������������');
-                                break;
-                            case 404:
-                                // 404
-                                break;
-                        }
-                        // ������������������������������������
-                        return ErrorObservable.create(event);
+                    catchError((err: HttpErrorResponse) => {
+                        return this.handleData(err);
                     })
                 );
     }

--
Gitblit v1.8.0