atr-components 0.2.417 → 2.0.1

package/{esm2020 → esm2022}/core/directive/hq-spin.directive.mjs

@@ -1,48 +1,48 @@
-import { Directive, Input } from '@angular/core';
-import * as i0 from "@angular/core";
-export class HqSpinDirective {
-    constructor(el, render) {
-        this.el = el;
-        this.render = render;
-        this.spinLoading = false;
-        this.text = null;
-        this.render.addClass(this.el.nativeElement, 'hq-spin-container');
-        this.loadingEle = this.render.createElement('div');
-        let dom1 = document.createElement('div');
-        this.loadingEle.append(dom1);
-        this.render.addClass(dom1, 'loader-03');
-        // this.render.addClass(this.loadingEle, 'loader-04');
-    }
-    ngOnChanges(changes) {
-        const { spinLoading, text } = changes;
-        if (text && text.currentValue) {
-            let dom = document.createElement('div');
-            dom.innerText = text.currentValue;
-            this.loadingEle.append(dom);
-            this.render.addClass(dom, 'loader-04');
-        }
-        if (spinLoading) {
-            if (spinLoading.currentValue) {
-                this.render.addClass(this.el.nativeElement, 'hq-spin-blur');
-                this.render.appendChild(this.el.nativeElement, this.loadingEle);
-            }
-            else {
-                this.render.removeClass(this.el.nativeElement, 'hq-spin-blur');
-                this.render.removeChild(this.el.nativeElement, this.loadingEle);
-            }
-        }
-    }
-}
-HqSpinDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: HqSpinDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
-HqSpinDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.11", type: HqSpinDirective, selector: "[HqSpin]", inputs: { spinLoading: "spinLoading", text: "text" }, usesOnChanges: true, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: HqSpinDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[HqSpin]'
-                }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { spinLoading: [{
-                type: Input
-            }], text: [{
-                type: Input
-            }] } });
-//# sourceMappingURL=data:application/json;base64,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
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class HqSpinDirective {
+    constructor(el, render) {
+        this.el = el;
+        this.render = render;
+        this.spinLoading = false;
+        this.text = null;
+        this.render.addClass(this.el.nativeElement, 'hq-spin-container');
+        this.loadingEle = this.render.createElement('div');
+        let dom1 = document.createElement('div');
+        this.loadingEle.append(dom1);
+        this.render.addClass(dom1, 'loader-03');
+        // this.render.addClass(this.loadingEle, 'loader-04');
+    }
+    ngOnChanges(changes) {
+        const { spinLoading, text } = changes;
+        if (text && text.currentValue) {
+            let dom = document.createElement('div');
+            dom.innerText = text.currentValue;
+            this.loadingEle.append(dom);
+            this.render.addClass(dom, 'loader-04');
+        }
+        if (spinLoading) {
+            if (spinLoading.currentValue) {
+                this.render.addClass(this.el.nativeElement, 'hq-spin-blur');
+                this.render.appendChild(this.el.nativeElement, this.loadingEle);
+            }
+            else {
+                this.render.removeClass(this.el.nativeElement, 'hq-spin-blur');
+                this.render.removeChild(this.el.nativeElement, this.loadingEle);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: HqSpinDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.9", type: HqSpinDirective, selector: "[HqSpin]", inputs: { spinLoading: "spinLoading", text: "text" }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: HqSpinDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[HqSpin]'
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { spinLoading: [{
+                type: Input
+            }], text: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/directive/role.directive.mjs

@@ -0,0 +1,69 @@
+import { Directive, Input } from '@angular/core';
+import { Router } from '@angular/router';
+import { MenuService } from "../services/menu.service";
+import { ToolsUtil } from "../utils/ToolsUtil";
+import * as i0 from "@angular/core";
+export class AtrRoleDirective {
+    set atrRole(condition) {
+        if (ToolsUtil.isNull(condition)) {
+            this.viewContainer.createEmbeddedView(this.templateRef);
+            this.hasView = true;
+            return;
+        }
+        if (condition == "any") {
+            this.viewContainer.createEmbeddedView(this.templateRef);
+            this.hasView = true;
+            return;
+        }
+        let curPath = this.getRouterUrl();
+        this.menuService.getCurMenu(curPath).subscribe(result => {
+            let curMenu = result;
+            let isExited = false;
+            if (curMenu && curMenu != null && curMenu.operation) {
+                let operations = curMenu.operation.split(",");
+                for (let operation of operations) {
+                    if (operation == condition) {
+                        isExited = true;
+                        break;
+                    }
+                }
+            }
+            if (isExited && !this.hasView) {
+                this.viewContainer.createEmbeddedView(this.templateRef);
+                this.hasView = true;
+            }
+            else if (!condition && this.hasView) {
+                this.viewContainer.clear();
+                this.hasView = false;
+            }
+        }, error => {
+        });
+    }
+    constructor(injector, render, templateRef, viewContainer) {
+        this.injector = injector;
+        this.render = render;
+        this.templateRef = templateRef;
+        this.viewContainer = viewContainer;
+        this.hasView = false;
+    }
+    ngOnInit() {
+    }
+    get menuService() {
+        return this.injector.get(MenuService);
+    }
+    getRouterUrl() {
+        return this.injector.get(Router).url;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: AtrRoleDirective, deps: [{ token: i0.Injector }, { token: i0.Renderer2 }, { token: i0.TemplateRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.9", type: AtrRoleDirective, selector: "[atrRole]", inputs: { atrRole: "atrRole" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: AtrRoleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[atrRole]'
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i0.Renderer2 }, { type: i0.TemplateRef }, { type: i0.ViewContainerRef }], propDecorators: { atrRole: [{
+                type: Input,
+                args: ['atrRole']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/core/interceptor/base.interceptor.mjs

@@ -1,165 +1,165 @@
-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, noTip = false) {
-        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) {
-                        if (!noTip) {
-                            this.notification.error(`未登录或登录已过期，请重新登录。`, ``, {
-                                nzKey: 'outTime'
-                            });
-                        }
-                        // TODO 清空 token 信息
-                        LocalStorageUtil.clearUs();
-                        this.menuService.clear();
-                        this.goTo('/p/login', true);
-                    }
-                    else if (body && body.status === 1024) {
-                        // 或者依然保持完整的格式
-                        if (!noTip) {
-                            this.message.error(body.message);
-                        }
-                    }
-                    else if (body && body.status === 1025) {
-                        // 或者依然保持完整的格式
-                        if (!noTip) {
-                            this.message.error(`参数为空。`);
-                        }
-                    }
-                    else if (body && body.status === 503) {
-                        // 或者依然保持完整的格式
-                        if (!noTip) {
-                            this.message.error(body.message);
-                        }
-                    }
-                    else if (body && body.status === 204) {
-                        // 或者依然保持完整的格式
-                        if (!noTip) {
-                            this.message.success(body.message);
-                        }
-                    }
-                    else if (body && body.status === 201) {
-                        // 或者依然保持完整的格式
-                        if (!noTip) {
-                            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 });
-        }
-        let noTip = req.headers.get("noTip");
-        return next.handle(req).pipe(mergeMap((event) => {
-            // 允许统一对请求错误处理
-            if (event instanceof HttpResponseBase)
-                return this.handleData(event, noTip == "1");
-            // 若一切都正常，则后续操作
-            return of(event);
-        }), catchError((err) => this.handleData(err, noTip == "1")));
-    }
-}
-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,noTip = false): 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                  if(!noTip){\r\n                    this.notification.error(`未登录或登录已过期，请重新登录。`, ``,{\r\n                      nzKey: 'outTime'\r\n                    });\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                  if(!noTip) {\r\n                    this.message.error(body.message);\r\n                  }\r\n                } else if(body && body.status === 1025){\r\n                  // 或者依然保持完整的格式\r\n                  if(!noTip) {\r\n                    this.message.error(`参数为空。`);\r\n                  }\r\n                } else if(body && body.status === 503){\r\n                  // 或者依然保持完整的格式\r\n                  if(!noTip) {\r\n                    this.message.error(body.message);\r\n                  }\r\n                }else if(body && body.status === 204){\r\n                  // 或者依然保持完整的格式\r\n                  if(!noTip) {\r\n                    this.message.success(body.message);\r\n                  }\r\n                }else if(body && body.status === 201){\r\n                  // 或者依然保持完整的格式\r\n                  if(!noTip) {\r\n                    this.message.success(body.message);\r\n                  }\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      let noTip = req.headers.get(\"noTip\");\r\n        return next.handle(req).pipe(\r\n          mergeMap((event: any) => {\r\n            // 允许统一对请求错误处理\r\n            if (event instanceof HttpResponseBase) return this.handleData(event,noTip == \"1\");\r\n            // 若一切都正常，则后续操作\r\n            return of(event);\r\n          }),\r\n          catchError((err: HttpErrorResponse) => this.handleData(err,noTip == \"1\")),\r\n        );\r\n      }\r\n}\r\n"]}
+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, noTip = false) {
+        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) {
+                        if (!noTip) {
+                            this.notification.error(`未登录或登录已过期，请重新登录。`, ``, {
+                                nzKey: 'outTime'
+                            });
+                        }
+                        // TODO 清空 token 信息
+                        LocalStorageUtil.clearUs();
+                        this.menuService.clear();
+                        this.goTo('/p/login', true);
+                    }
+                    else if (body && body.status === 1024) {
+                        // 或者依然保持完整的格式
+                        if (!noTip) {
+                            this.message.error(body.message);
+                        }
+                    }
+                    else if (body && body.status === 1025) {
+                        // 或者依然保持完整的格式
+                        if (!noTip) {
+                            this.message.error(`参数为空。`);
+                        }
+                    }
+                    else if (body && body.status === 503) {
+                        // 或者依然保持完整的格式
+                        if (!noTip) {
+                            this.message.error(body.message);
+                        }
+                    }
+                    else if (body && body.status === 204) {
+                        // 或者依然保持完整的格式
+                        if (!noTip) {
+                            this.message.success(body.message);
+                        }
+                    }
+                    else if (body && body.status === 201) {
+                        // 或者依然保持完整的格式
+                        if (!noTip) {
+                            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 });
+        }
+        let noTip = req.headers.get("noTip");
+        return next.handle(req).pipe(mergeMap((event) => {
+            // 允许统一对请求错误处理
+            if (event instanceof HttpResponseBase)
+                return this.handleData(event, noTip == "1");
+            // 若一切都正常，则后续操作
+            return of(event);
+        }), catchError((err) => this.handleData(err, noTip == "1")));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: BaseInterceptor, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: BaseInterceptor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: BaseInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ 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 {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,noTip = false): 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                  if(!noTip){\r\n                    this.notification.error(`未登录或登录已过期，请重新登录。`, ``,{\r\n                      nzKey: 'outTime'\r\n                    });\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                  if(!noTip) {\r\n                    this.message.error(body.message);\r\n                  }\r\n                } else if(body && body.status === 1025){\r\n                  // 或者依然保持完整的格式\r\n                  if(!noTip) {\r\n                    this.message.error(`参数为空。`);\r\n                  }\r\n                } else if(body && body.status === 503){\r\n                  // 或者依然保持完整的格式\r\n                  if(!noTip) {\r\n                    this.message.error(body.message);\r\n                  }\r\n                }else if(body && body.status === 204){\r\n                  // 或者依然保持完整的格式\r\n                  if(!noTip) {\r\n                    this.message.success(body.message);\r\n                  }\r\n                }else if(body && body.status === 201){\r\n                  // 或者依然保持完整的格式\r\n                  if(!noTip) {\r\n                    this.message.success(body.message);\r\n                  }\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      let noTip = req.headers.get(\"noTip\");\r\n        return next.handle(req).pipe(\r\n          mergeMap((event: any) => {\r\n            // 允许统一对请求错误处理\r\n            if (event instanceof HttpResponseBase) return this.handleData(event,noTip == \"1\");\r\n            // 若一切都正常，则后续操作\r\n            return of(event);\r\n          }),\r\n          catchError((err: HttpErrorResponse) => this.handleData(err,noTip == \"1\")),\r\n        );\r\n      }\r\n}\r\n"]}