atr-components 0.0.19 → 0.0.20

package/core/interceptor/base.interceptor.d.ts

@@ -0,0 +1,17 @@
+import { Injector } from '@angular/core';
+import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class BaseInterceptor implements HttpInterceptor {
+    private injector;
+    constructor(injector: Injector);
+    private get notification();
+    private get message();
+    private get menuService();
+    private goTo;
+    private checkStatus;
+    private handleData;
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseInterceptor>;
+}

package/esm2020/core/interceptor/base.interceptor.mjs

@@ -0,0 +1,152 @@
+import { Injectable } from '@angular/core';
+import { HttpErrorResponse, HttpResponseBase, HttpResponse } from '@angular/common/http';
+import { Observable, of, throwError } from 'rxjs';
+import { mergeMap, catchError } from 'rxjs/operators';
+import { Router } from '@angular/router';
+import { NzNotificationService } from 'ng-zorro-antd/notification';
+import { NzMessageService } from 'ng-zorro-antd/message';
+import { LocalStorageUtil } from "../utils/localstorage.util";
+import { AtrReuseStrategy } from "../routereuse/atr-reuse-strategy";
+import { MenuService } from "../services/menu.service";
+import { atr_static_datas } from "../base/atr-common";
+import * as i0 from "@angular/core";
+const CODEMESSAGE = {
+    200: '服务器成功返回请求的数据。',
+    201: '新建或修改数据成功。',
+    202: '一个请求已经进入后台排队（异步任务）。',
+    204: '删除数据成功。',
+    400: '发出的请求有错误，服务器没有进行新建或修改数据的操作。',
+    401: '用户没有权限（令牌、用户名、密码错误）。',
+    403: '用户得到授权，但是访问是被禁止的。',
+    404: '发出的请求针对的是不存在的记录，服务器没有进行操作。',
+    406: '请求的格式不可得。',
+    410: '请求的资源被永久删除，且不会再得到的。',
+    422: '当创建一个对象时，发生一个验证错误。',
+    500: '服务器发生错误，请检查服务器。',
+    502: '网关错误。',
+    503: '服务不可用，服务器暂时过载或维护。',
+    504: '网关超时。',
+};
+export class BaseInterceptor {
+    constructor(injector) {
+        this.injector = injector;
+    }
+    get notification() {
+        return this.injector.get(NzNotificationService);
+    }
+    get message() {
+        return this.injector.get(NzMessageService);
+    }
+    get menuService() {
+        return this.injector.get(MenuService);
+    }
+    goTo(url, isClearCache) {
+        // console.log("需要跳转到页面：")
+        // console.log(url);
+        setTimeout(() => this.injector.get(Router).navigateByUrl(url));
+        if (isClearCache) {
+            setTimeout(() => AtrReuseStrategy.deleteAll(), 50);
+        }
+    }
+    checkStatus(ev) {
+        if ((ev.status >= 200 && ev.status < 300) || ev.status === 401) {
+            return;
+        }
+        // console.log(ev.status);
+        // const errortext = CODEMESSAGE[ev.status] || ev.statusText;
+        this.message.error('网络错误,请稍后重试：' + ev.status);
+    }
+    handleData(ev) {
+        this.checkStatus(ev);
+        // 业务处理：一些通用操作
+        switch (ev.status) {
+            case 200:
+                // TODO status
+                // 业务层级错误处理，以下是假定restful有一套统一输出格式（指不管成功与否都有相应的数据格式）情况下进行处理
+                // 例如响应内容：
+                //  错误内容：{ status: 1, msg: '非法参数' }
+                //  正确内容：{ status: 0, response: {  } }
+                // 则以下代码片断可直接适用
+                if (ev instanceof HttpResponse) {
+                    const body = ev.body;
+                    if (body && body.status === 401) {
+                        this.notification.error(`未登录或登录已过期，请重新登录。`, ``, {
+                            nzKey: 'outTime'
+                        });
+                        // TODO 清空 token 信息
+                        LocalStorageUtil.clearUs();
+                        this.menuService.clear();
+                        this.goTo('/p/login', true);
+                    }
+                    else if (body && body.status === 1024) {
+                        // 或者依然保持完整的格式
+                        this.message.error(body.message);
+                    }
+                    else if (body && body.status === 1025) {
+                        // 或者依然保持完整的格式
+                        this.message.error(`参数为空。`);
+                    }
+                    else if (body && body.status === 503) {
+                        // 或者依然保持完整的格式
+                        this.message.error(body.message);
+                    }
+                    else if (body && body.status === 204) {
+                        // 或者依然保持完整的格式
+                        this.message.success(body.message);
+                    }
+                    else if (body && body.status === 201) {
+                        // 或者依然保持完整的格式
+                        this.message.success(body.message);
+                    }
+                    else {
+                        return of(ev);
+                    }
+                }
+                break;
+            case 401:
+                this.notification.error(`未登录或登录已过期，请重新登录。`, ``, {
+                    nzKey: 'outTime'
+                });
+                // TODO 清空 token 信息
+                // this.goTo('/p/login',false);
+                break;
+            case 403:
+            case 404:
+            case 500:
+                this.goTo(`/exception/${ev.status}`, false);
+                break;
+            default:
+                if (ev instanceof HttpErrorResponse) {
+                    // console.warn('未可知错误，大部分是由于后端不支持CORS或无效配置引起', ev);
+                    return throwError(ev);
+                }
+                break;
+        }
+        return of(ev);
+    }
+    intercept(req, next) {
+        if (!atr_static_datas.SERVER_URL) {
+            alert('请配置ip atr_static_datas.SERVER_URL');
+            return new Observable();
+        }
+        // 统一加上服务端前缀
+        let url = req.url;
+        if (!url.startsWith('https://') && !url.startsWith('http://')) {
+            url = atr_static_datas.SERVER_URL + url;
+            req = req.clone({ url });
+        }
+        return next.handle(req).pipe(mergeMap((event) => {
+            // 允许统一对请求错误处理
+            if (event instanceof HttpResponseBase)
+                return this.handleData(event);
+            // 若一切都正常，则后续操作
+            return of(event);
+        }), catchError((err) => this.handleData(err)));
+    }
+}
+BaseInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: BaseInterceptor, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+BaseInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: BaseInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: BaseInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.interceptor.js","sourceRoot":"","sources":["../../../../../projects/components/src/core/interceptor/base.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector } from '@angular/core';\r\nimport { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpErrorResponse, HttpResponseBase, HttpResponse, HttpHeaders } from '@angular/common/http';\r\nimport { Observable, of ,throwError  } from 'rxjs';\r\nimport { mergeMap, catchError } from 'rxjs/operators';\r\nimport { Router } from '@angular/router';\r\nimport { NzNotificationService } from 'ng-zorro-antd/notification';\r\nimport {NzMessageService} from 'ng-zorro-antd/message';\r\nimport {LocalStorageUtil} from \"../utils/localstorage.util\";\r\nimport {environment} from \"ng-zorro-antd/core/environments\";\r\nimport {AtrReuseStrategy} from \"../routereuse/atr-reuse-strategy\";\r\nimport {MenuService} from \"../services/menu.service\";\r\nimport {atr_static_datas} from \"../base/atr-common\";\r\n\r\nconst CODEMESSAGE = {\r\n    200: '服务器成功返回请求的数据。',\r\n    201: '新建或修改数据成功。',\r\n    202: '一个请求已经进入后台排队（异步任务）。',\r\n    204: '删除数据成功。',\r\n    400: '发出的请求有错误，服务器没有进行新建或修改数据的操作。',\r\n    401: '用户没有权限（令牌、用户名、密码错误）。',\r\n    403: '用户得到授权，但是访问是被禁止的。',\r\n    404: '发出的请求针对的是不存在的记录，服务器没有进行操作。',\r\n    406: '请求的格式不可得。',\r\n    410: '请求的资源被永久删除，且不会再得到的。',\r\n    422: '当创建一个对象时，发生一个验证错误。',\r\n    500: '服务器发生错误，请检查服务器。',\r\n    502: '网关错误。',\r\n    503: '服务不可用，服务器暂时过载或维护。',\r\n    504: '网关超时。',\r\n};\r\n\r\n@Injectable()\r\nexport class BaseInterceptor implements HttpInterceptor{\r\n    constructor(private injector: Injector) {}\r\n    private get notification(): NzNotificationService {\r\n        return this.injector.get(NzNotificationService);\r\n    }\r\n    private get message(): NzMessageService {\r\n        return this.injector.get(NzMessageService);\r\n    }\r\n    private get menuService(): MenuService{\r\n        return this.injector.get(MenuService)\r\n    }\r\n\r\n    private goTo(url: string,isClearCache:boolean) {\r\n      // console.log(\"需要跳转到页面：\")\r\n      // console.log(url);\r\n      setTimeout(() => this.injector.get(Router).navigateByUrl(url));\r\n      if(isClearCache){\r\n        setTimeout(()=>  AtrReuseStrategy.deleteAll(),50);\r\n      }\r\n    }\r\n\r\n    private checkStatus(ev: HttpResponseBase) {\r\n        if ((ev.status >= 200 && ev.status < 300) || ev.status === 401) {\r\n          return;\r\n        }\r\n        // console.log(ev.status);\r\n        // const errortext = CODEMESSAGE[ev.status] || ev.statusText;\r\n        this.message.error('网络错误,请稍后重试：' + ev.status);\r\n    }\r\n    private handleData(ev: HttpResponseBase): Observable<any> {\r\n        this.checkStatus(ev);\r\n        // 业务处理：一些通用操作\r\n        switch (ev.status) {\r\n          case 200:\r\n            // TODO status\r\n            // 业务层级错误处理，以下是假定restful有一套统一输出格式（指不管成功与否都有相应的数据格式）情况下进行处理\r\n            // 例如响应内容：\r\n            //  错误内容：{ status: 1, msg: '非法参数' }\r\n            //  正确内容：{ status: 0, response: {  } }\r\n            // 则以下代码片断可直接适用\r\n            if (ev instanceof HttpResponse) {\r\n                const body: any = ev.body;\r\n                if (body && body.status === 401) {\r\n                  this.notification.error(`未登录或登录已过期，请重新登录。`, ``,{\r\n                      nzKey: 'outTime'\r\n                  });\r\n                  // TODO 清空 token 信息\r\n                  LocalStorageUtil.clearUs()\r\n                  this.menuService.clear();\r\n                  this.goTo('/p/login',true);\r\n                } else if(body && body.status === 1024){\r\n                  // 或者依然保持完整的格式\r\n                  this.message.error(body.message);\r\n                } else if(body && body.status === 1025){\r\n                  // 或者依然保持完整的格式\r\n                  this.message.error(`参数为空。`);\r\n                } else if(body && body.status === 503){\r\n                  // 或者依然保持完整的格式\r\n                  this.message.error(body.message);\r\n                }else if(body && body.status === 204){\r\n                  // 或者依然保持完整的格式\r\n                  this.message.success(body.message);\r\n                }else if(body && body.status === 201){\r\n                  // 或者依然保持完整的格式\r\n                  this.message.success(body.message);\r\n                }else{\r\n                  return of(ev);\r\n                }\r\n            }\r\n            break;\r\n          case 401:\r\n            this.notification.error(`未登录或登录已过期，请重新登录。`, ``,{\r\n              nzKey: 'outTime'\r\n            });\r\n            // TODO 清空 token 信息\r\n\r\n            // this.goTo('/p/login',false);\r\n            break;\r\n          case 403:\r\n          case 404:\r\n          case 500:\r\n            this.goTo(`/exception/${ev.status}`,false);\r\n            break;\r\n          default:\r\n            if (ev instanceof HttpErrorResponse) {\r\n              // console.warn('未可知错误，大部分是由于后端不支持CORS或无效配置引起', ev);\r\n              return throwError(ev);\r\n            }\r\n            break;\r\n        }\r\n        return of(ev);\r\n      }\r\n    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\r\n      if(!atr_static_datas.SERVER_URL){\r\n        alert('请配置ip atr_static_datas.SERVER_URL')\r\n        return new Observable();\r\n      }\r\n        // 统一加上服务端前缀\r\n        let url = req.url;\r\n        if (!url.startsWith('https://') && !url.startsWith('http://')) {\r\n          url = atr_static_datas.SERVER_URL + url;\r\n          req = req.clone({ url });\r\n        }\r\n\r\n        return next.handle(req).pipe(\r\n          mergeMap((event: any) => {\r\n            // 允许统一对请求错误处理\r\n            if (event instanceof HttpResponseBase) return this.handleData(event);\r\n            // 若一切都正常，则后续操作\r\n            return of(event);\r\n          }),\r\n          catchError((err: HttpErrorResponse) => this.handleData(err)),\r\n        );\r\n      }\r\n}\r\n"]}

package/esm2020/public-api.mjs

@@ -2,6 +2,7 @@
  * Public API Surface of components
  */
 export * from "./core/animations/animations";
+export * from "./core/interceptor/base.interceptor";
 export * from "./core/ngz-module/cus-zorro-antd.module";
 export * from "./core/animations/fly-in";
 export * from "./core/animations/scroll-screen";
@@ -28,4 +29,4 @@ export * from "./core/pipe/defaultVal.pipe";
 export * from "./core/pipe/day.pipe";
 export * from "./core/pipe/safe-compute.pipe";
 export * from "./core/pipe/is-not-empty.pipe";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxjQUFjLDhCQUE4QixDQUFBO0FBQzVDLGNBQWMscUNBQXFDLENBQUE7QUFDbkQsY0FBYyx5Q0FBeUMsQ0FBQTtBQUN2RCxjQUFjLDBCQUEwQixDQUFBO0FBQ3hDLGNBQWMsaUNBQWlDLENBQUE7QUFDL0MsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsd0JBQXdCLENBQUE7QUFDdEMsY0FBYyxnQ0FBZ0MsQ0FBQTtBQUM5QyxjQUFjLGtDQUFrQyxDQUFBO0FBQ2hELGNBQWMsbUNBQW1DLENBQUE7QUFDakQsY0FBYyw4QkFBOEIsQ0FBQTtBQUM1QyxjQUFjLDhCQUE4QixDQUFBO0FBQzVDLGNBQWMsb0NBQW9DLENBQUE7QUFDbEQsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsT0FBTyxFQUFDLGNBQWMsRUFBQyxNQUFNLDZCQUE2QixDQUFDO0FBRTNELGNBQWMsZ0NBQWdDLENBQUE7QUFDOUMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsK0JBQStCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIGNvbXBvbmVudHNcbiAqL1xuZXhwb3J0ICogZnJvbSBcIi4vY29yZS9hbmltYXRpb25zL2FuaW1hdGlvbnNcIlxuZXhwb3J0ICogZnJvbSBcIi4vY29yZS9pbnRlcmNlcHRvci9iYXNlLmludGVyY2VwdG9yXCJcbmV4cG9ydCAqIGZyb20gXCIuL2NvcmUvbmd6LW1vZHVsZS9jdXMtem9ycm8tYW50ZC5tb2R1bGVcIlxuZXhwb3J0ICogZnJvbSBcIi4vY29yZS9hbmltYXRpb25zL2ZseS1pblwiXG5leHBvcnQgKiBmcm9tIFwiLi9jb3JlL2FuaW1hdGlvbnMvc2Nyb2xsLXNjcmVlblwiXG5leHBvcnQgKiBmcm9tICcuL2F0ci1jb21wb25lbnRzLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9oZWxsby9oZWxsby5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9jb3JlL2F1dGgvYXV0aC5ndWFyZCc7XG5leHBvcnQgKiBmcm9tICcuL2NvcmUvYmFzZS9hdHItY29tbW9uJztcbmV4cG9ydCAqIGZyb20gJy4vY29yZS9yb3V0ZXJldXNlL2F0ci1yZXVzZS1zdHJhdGVneSc7XG5leHBvcnQgKiBmcm9tIFwiLi9jb3JlL3V0aWxzL1Rvb2xzVXRpbFwiXG5leHBvcnQgKiBmcm9tIFwiLi9jb3JlL3V0aWxzL2xvY2Fsc3RvcmFnZS51dGlsXCJcbmV4cG9ydCAqIGZyb20gXCIuL2NvcmUvdXRpbHMvc2Vzc2lvbnN0b3JhZ2UudXRpbFwiXG5leHBvcnQgKiBmcm9tIFwiLi9jb3JlL3NlcnZpY2VzL2RpY3QvZGljdC5zZXJ2aWNlXCJcbmV4cG9ydCAqIGZyb20gXCIuL2NvcmUvc2VydmljZXMvaHR0cC5zZXJ2aWNlXCJcbmV4cG9ydCAqIGZyb20gXCIuL2NvcmUvc2VydmljZXMvbWVudS5zZXJ2aWNlXCJcbmV4cG9ydCAqIGZyb20gXCIuL2NvcmUvc2VydmljZXMvdXBsb2FkLW9zcy5zZXJ2aWNlXCJcbmV4cG9ydCAqIGZyb20gXCIuL2NvcmUvZGlyZWN0aXZlL3JvbGUuZGlyZWN0aXZlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb3JlL2RpcmVjdGl2ZS9lcnJvci1pbWcuZGlyZWN0aXZlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb3JlL2RpcmVjdGl2ZS9ocS1zcGluLmRpcmVjdGl2ZVwiO1xuZXhwb3J0IHtIZWxsb0NvbXBvbmVudH0gZnJvbSAnLi9saWIvaGVsbG8vaGVsbG8uY29tcG9uZW50JztcblxuZXhwb3J0ICogZnJvbSBcIi4vY29yZS9waXBlL3BpcGUtbW9kdWxlLm1vZHVsZVwiXG5leHBvcnQgKiBmcm9tIFwiLi9jb3JlL3BpcGUvaXMtZW1wdHkucGlwZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29yZS9waXBlL2RpY3RzLnBpcGVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvcmUvcGlwZS9kZWZhdWx0VmFsLnBpcGVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvcmUvcGlwZS9kYXkucGlwZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29yZS9waXBlL3NhZmUtY29tcHV0ZS5waXBlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb3JlL3BpcGUvaXMtbm90LWVtcHR5LnBpcGVcIjtcbiJdfQ==