@reskin/core 0.0.1 → 0.0.2

package/esm2015/interceptors/cache.interceptor.js

@@ -33,4 +33,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
 export function providerHttpCache() {
     return { provide: HTTP_INTERCEPTORS, useClass: CacheInterceptor, multi: true };
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGUuaW50ZXJjZXB0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJyYXJ5L2NvcmUvaW50ZXJjZXB0b3JzL2NhY2hlLmludGVyY2VwdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFzRSxpQkFBaUIsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRTdILE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQzs7O0FBSTdDLE1BQU0sT0FBTyxnQkFBZ0I7SUFDekIsWUFBb0IsU0FBNkI7UUFBN0IsY0FBUyxHQUFULFNBQVMsQ0FBb0I7SUFBRyxDQUFDO0lBRXJELFNBQVMsQ0FBQyxPQUE2QixFQUFFLElBQWlCO1FBQ3RELFdBQVc7UUFDWCxpQ0FBaUM7UUFDakMsTUFBTSxRQUFRLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDbEQsSUFBSSxPQUFPLENBQUMsTUFBTSxLQUFLLEtBQUssSUFBSSxRQUFRLEtBQUssU0FBUyxFQUFFO1lBQ3BELElBQUksUUFBUSxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUMvQyxJQUFJLENBQUMsUUFBUSxFQUFFO2dCQUNYLFFBQVEsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztnQkFDckQsSUFBSSxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLEdBQUcsRUFBRSxRQUFRLENBQUMsQ0FBQzthQUM3QztZQUNELE9BQU8sUUFBUSxDQUFDO1NBQ25CO1FBQ0QsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ2hDLENBQUM7OzhHQWhCUSxnQkFBZ0I7a0hBQWhCLGdCQUFnQjs0RkFBaEIsZ0JBQWdCO2tCQUQ1QixVQUFVOztBQW9CWDs7R0FFRztBQUNILE1BQU0sVUFBVSxpQkFBaUI7SUFDN0IsT0FBTyxFQUFFLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxRQUFRLEVBQUUsZ0JBQWdCLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRSxDQUFDO0FBQ25GLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IEh0dHBSZXF1ZXN0LCBIdHRwSGFuZGxlciwgSHR0cEV2ZW50LCBIdHRwSW50ZXJjZXB0b3IsIEh0dHBSZXNwb25zZSwgSFRUUF9JTlRFUkNFUFRPUlMgfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XHJcbmltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcclxuaW1wb3J0IHsgc2hhcmVSZXBsYXkgfSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XHJcbmltcG9ydCB7IFJrQ2FjaGVIdHRwU2VydmljZSB9IGZyb20gJ0ByZXNraW4vY29yZS9zZXJ2aWNlcyc7XHJcblxyXG5ASW5qZWN0YWJsZSgpXHJcbmV4cG9ydCBjbGFzcyBDYWNoZUludGVyY2VwdG9yIGltcGxlbWVudHMgSHR0cEludGVyY2VwdG9yIHtcclxuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgY2FjaGVIdHRwOiBSa0NhY2hlSHR0cFNlcnZpY2UpIHt9XHJcblxyXG4gICAgaW50ZXJjZXB0KHJlcXVlc3Q6IEh0dHBSZXF1ZXN0PHVua25vd24+LCBuZXh0OiBIdHRwSGFuZGxlcik6IE9ic2VydmFibGU8SHR0cEV2ZW50PHVua25vd24+PiB7XHJcbiAgICAgICAgLy8gMS7liKTmlq3mmK9HRVRcclxuICAgICAgICAvLyAyLmhlYWRlcuS4rea3u+WKoCBDYWNoZS1NYXA6IFN0b3JhZ2VcclxuICAgICAgICBjb25zdCBjYWNoZU1hcCA9IHJlcXVlc3QuaGVhZGVycy5nZXQoJ0NhY2hlLU1hcCcpO1xyXG4gICAgICAgIGlmIChyZXF1ZXN0Lm1ldGhvZCA9PT0gJ0dFVCcgJiYgY2FjaGVNYXAgPT09ICdTdG9yYWdlJykge1xyXG4gICAgICAgICAgICBsZXQgcmVzcG9uc2UgPSB0aGlzLmNhY2hlSHR0cC5nZXQocmVxdWVzdC51cmwpO1xyXG4gICAgICAgICAgICBpZiAoIXJlc3BvbnNlKSB7XHJcbiAgICAgICAgICAgICAgICByZXNwb25zZSA9IG5leHQuaGFuZGxlKHJlcXVlc3QpLnBpcGUoc2hhcmVSZXBsYXkoMSkpO1xyXG4gICAgICAgICAgICAgICAgdGhpcy5jYWNoZUh0dHAuc2V0KHJlcXVlc3QudXJsLCByZXNwb25zZSk7XHJcbiAgICAgICAgICAgIH1cclxuICAgICAgICAgICAgcmV0dXJuIHJlc3BvbnNlO1xyXG4gICAgICAgIH1cclxuICAgICAgICByZXR1cm4gbmV4dC5oYW5kbGUocmVxdWVzdCk7XHJcbiAgICB9XHJcbn1cclxuXHJcbi8qKlxyXG4gKiBHRVTor7fmsYLnvJPlrZjmi6bmiKrlmahcclxuICovXHJcbmV4cG9ydCBmdW5jdGlvbiBwcm92aWRlckh0dHBDYWNoZSgpIHtcclxuICAgIHJldHVybiB7IHByb3ZpZGU6IEhUVFBfSU5URVJDRVBUT1JTLCB1c2VDbGFzczogQ2FjaGVJbnRlcmNlcHRvciwgbXVsdGk6IHRydWUgfTtcclxufVxyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/interceptors/error.interceptor.js

@@ -12,7 +12,7 @@ export class ErrorInterceptor {
         return next.handle(request).pipe(catchError((result) => {
             var _a;
             if (result.status === 401) {
-                this.router.navigateByUrl('/').then();
+                this.router.navigate(['/errors/401']).then();
             }
             if (result.error.code) {
                 return of(result.error);
@@ -32,4 +32,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
 export function providerHttpError() {
     return { provide: HTTP_INTERCEPTORS, useClass: ErrorInterceptor, multi: true };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/interceptors/public-api.js

@@ -2,4 +2,4 @@ export * from './token.interceptor';
 export * from './error.interceptor';
 export * from './cache.interceptor';
 export * from './blob.interceptor';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYnJhcnkvY29yZS9pbnRlcmNlcHRvcnMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90b2tlbi5pbnRlcmNlcHRvcic7XHJcbmV4cG9ydCAqIGZyb20gJy4vZXJyb3IuaW50ZXJjZXB0b3InO1xyXG5leHBvcnQgKiBmcm9tICcuL2NhY2hlLmludGVyY2VwdG9yJztcclxuZXhwb3J0ICogZnJvbSAnLi9ibG9iLmludGVyY2VwdG9yJztcclxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYnJhcnkvY29yZS9pbnRlcmNlcHRvcnMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90b2tlbi5pbnRlcmNlcHRvcic7XG5leHBvcnQgKiBmcm9tICcuL2Vycm9yLmludGVyY2VwdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vY2FjaGUuaW50ZXJjZXB0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9ibG9iLmludGVyY2VwdG9yJztcbiJdfQ==

package/esm2015/interceptors/token.interceptor.js

@@ -45,4 +45,4 @@ export function NoAuthTokenTemplate(urls, ...params) {
     }
     return [url, { headers: new HttpHeaders({ 'Token-Control': 'no-token' }) }];
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW4uaW50ZXJjZXB0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJyYXJ5L2NvcmUvaW50ZXJjZXB0b3JzL3Rva2VuLmludGVyY2VwdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUF3RCxpQkFBaUIsRUFBRSxXQUFXLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQzs7O0FBTTVILE1BQU0sT0FBTyxnQkFBZ0I7SUFDekIsWUFBb0IsT0FBc0I7UUFBdEIsWUFBTyxHQUFQLE9BQU8sQ0FBZTtJQUFHLENBQUM7SUFFOUMsU0FBUyxDQUFDLE9BQTZCLEVBQUUsSUFBaUI7UUFDdEQsTUFBTSxFQUFFLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsZUFBZSxDQUFDLENBQUM7UUFDaEQsTUFBTSxJQUFJLEdBQVUsSUFBSSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUM7UUFDdkMsaURBQWlEO1FBQ2pELElBQUksRUFBRSxLQUFLLFVBQVUsSUFBSSxJQUFJLENBQUMsS0FBSyxFQUFFO1lBQ2pDLE9BQU8sR0FBRyxPQUFPLENBQUMsS0FBSyxDQUFDO2dCQUNwQixVQUFVLEVBQUU7b0JBQ1IsZUFBZSxFQUFFLElBQUksQ0FBQyxLQUFLO29CQUMzQixXQUFXLEVBQUUsSUFBSSxDQUFDLEVBQUU7aUJBQ3ZCO2FBQ0osQ0FBQyxDQUFDO1NBQ047UUFDRCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDaEMsQ0FBQzs7OEdBaEJRLGdCQUFnQjtrSEFBaEIsZ0JBQWdCOzRGQUFoQixnQkFBZ0I7a0JBRDVCLFVBQVU7O0FBb0JYOztHQUVHO0FBQ0gsTUFBTSxVQUFVLGlCQUFpQjtJQUM3QixPQUFPLEVBQUUsT0FBTyxFQUFFLGlCQUFpQixFQUFFLFFBQVEsRUFBRSxnQkFBZ0IsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLENBQUM7QUFDbkYsQ0FBQztBQUVEOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLG1CQUFtQixDQUFDLElBQTBCLEVBQUUsR0FBRyxNQUFhO0lBQzVFLElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxJQUFJLENBQUM7SUFDakIsSUFBSSxNQUFNLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRTtRQUNuQixHQUFHLEdBQUcsTUFBTSxDQUFDLEdBQUcsQ0FBQyxJQUFJLEVBQUUsR0FBRyxNQUFNLENBQUMsQ0FBQztLQUNyQztJQUNELE9BQU8sQ0FBQyxHQUFHLEVBQUUsRUFBRSxPQUFPLEVBQUUsSUFBSSxXQUFXLENBQUMsRUFBRSxlQUFlLEVBQUUsVUFBVSxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUM7QUFDaEYsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgSHR0cFJlcXVlc3QsIEh0dHBIYW5kbGVyLCBIdHRwRXZlbnQsIEh0dHBJbnRlcmNlcHRvciwgSFRUUF9JTlRFUkNFUFRPUlMsIEh0dHBIZWFkZXJzIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xyXG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XHJcbmltcG9ydCB7IFJrQXV0aFNlcnZpY2UgfSBmcm9tICdAcmVza2luL2NvcmUvc2VydmljZXMnO1xyXG5pbXBvcnQgeyBJQXV0aCB9IGZyb20gJ0ByZXNraW4vY29yZS9lbnRpdHkvdXNlcic7XHJcblxyXG5ASW5qZWN0YWJsZSgpXHJcbmV4cG9ydCBjbGFzcyBUb2tlbkludGVyY2VwdG9yIGltcGxlbWVudHMgSHR0cEludGVyY2VwdG9yIHtcclxuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgc2VydmljZTogUmtBdXRoU2VydmljZSkge31cclxuXHJcbiAgICBpbnRlcmNlcHQocmVxdWVzdDogSHR0cFJlcXVlc3Q8dW5rbm93bj4sIG5leHQ6IEh0dHBIYW5kbGVyKTogT2JzZXJ2YWJsZTxIdHRwRXZlbnQ8dW5rbm93bj4+IHtcclxuICAgICAgICBjb25zdCB0YyA9IHJlcXVlc3QuaGVhZGVycy5nZXQoJ1Rva2VuLUNvbnRyb2wnKTtcclxuICAgICAgICBjb25zdCBhdXRoOiBJQXV0aCA9IHRoaXMuc2VydmljZS50b2tlbjtcclxuICAgICAgICAvLyDlvZMgaGVhZGVyIOS4rSBUb2tlbi1Db250cm9sIOS4uiBuby10b2tlbiDml7bkuI3mkLrluKYgdG9rZW5cclxuICAgICAgICBpZiAodGMgIT09ICduby10b2tlbicgJiYgYXV0aC50b2tlbikge1xyXG4gICAgICAgICAgICByZXF1ZXN0ID0gcmVxdWVzdC5jbG9uZSh7XHJcbiAgICAgICAgICAgICAgICBzZXRIZWFkZXJzOiB7XHJcbiAgICAgICAgICAgICAgICAgICAgJ0F1dGhvcml6YXRpb24nOiBhdXRoLnRva2VuLFxyXG4gICAgICAgICAgICAgICAgICAgICdYLUF1dGgtSWQnOiBhdXRoLmlkLFxyXG4gICAgICAgICAgICAgICAgfSxcclxuICAgICAgICAgICAgfSk7XHJcbiAgICAgICAgfVxyXG4gICAgICAgIHJldHVybiBuZXh0LmhhbmRsZShyZXF1ZXN0KTtcclxuICAgIH1cclxufVxyXG5cclxuLyoqXHJcbiAqIOivt+axguWktOWinuWKoHRva2Vu6aqM6K+B5oum5oiq5ZmoXHJcbiAqL1xyXG5leHBvcnQgZnVuY3Rpb24gcHJvdmlkZXJBdXRoVG9rZW4oKSB7XHJcbiAgICByZXR1cm4geyBwcm92aWRlOiBIVFRQX0lOVEVSQ0VQVE9SUywgdXNlQ2xhc3M6IFRva2VuSW50ZXJjZXB0b3IsIG11bHRpOiB0cnVlIH07XHJcbn1cclxuXHJcbi8qKlxyXG4gKiDkuI3luKZ0b2tlbumqjOivgeS/oeaBr+ivt+axglxyXG4gKiBAcGFyYW0gdXJscyDlnLDlnYBcclxuICogQHBhcmFtIHBhcmFtcyDlj4LmlbBcclxuICogQGNvbnN0cnVjdG9yXHJcbiAqL1xyXG5leHBvcnQgZnVuY3Rpb24gTm9BdXRoVG9rZW5UZW1wbGF0ZSh1cmxzOiBUZW1wbGF0ZVN0cmluZ3NBcnJheSwgLi4ucGFyYW1zOiBhbnlbXSk6IFtzdHJpbmcsIHsgaGVhZGVyczogSHR0cEhlYWRlcnMgfV0ge1xyXG4gICAgbGV0IFt1cmxdID0gdXJscztcclxuICAgIGlmIChwYXJhbXMubGVuZ3RoID4gMCkge1xyXG4gICAgICAgIHVybCA9IFN0cmluZy5yYXcodXJscywgLi4ucGFyYW1zKTtcclxuICAgIH1cclxuICAgIHJldHVybiBbdXJsLCB7IGhlYWRlcnM6IG5ldyBIdHRwSGVhZGVycyh7ICdUb2tlbi1Db250cm9sJzogJ25vLXRva2VuJyB9KSB9XTtcclxufVxyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/services/account.service.js

@@ -5,13 +5,18 @@ import * as i0 from "@angular/core";
 import * as i1 from "@angular/common/http";
 import * as i2 from "./auth.service";
 export class RkAccountService {
-    constructor(http, auth) {
+    constructor(http, // HttpClient实例用于发送HTTP请求
+    auth) {
         this.http = http;
         this.auth = auth;
+        // 定义一个Store实例用于存储用户认证信息
         this.account = new Store('account', {});
     }
     /**
      * 加载人员权限
+     *
+     * 本方法通过发送HTTP POST请求来加载当前认证用户的权限数据，
+     * 如果请求成功，将权限数据存储在account Store实例中
      */
     onLoadAuth() {
         var _a;
@@ -24,24 +29,32 @@ export class RkAccountService {
     }
     /**
      * 获得账号基本信息
+     *
+     * @returns {IAccountProfile} 返回当前账号的基本信息对象
      */
     get userInfo() {
         return this.account.get().UserInfo;
     }
     /**
      * 获得账号人员库权限
+     *
+     * @returns {IAuthPersonnelPool} 返回当前账号的人员库权限对象
      */
     get personnelPool() {
         return this.account.get().AuthPersonnelPool;
     }
     /**
      * 获得账号业务权限
+     *
+     * @returns {IAuthWorkflow} 返回当前账号的业务权限对象
      */
     get workflowAuth() {
         return this.account.get().AuthWfId;
     }
     /**
      * 获得账号机构分组权限
+     *
+     * @returns {Array<IAuthOrgGroup>} 返回当前账号的机构分组权限数组
      */
     get authOrgGroup() {
         return this.account.get().AuthOrgGroup;
@@ -55,4 +68,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
                     providedIn: 'root',
                 }]
         }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.RkAuthService }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/services/app.config.js

@@ -12,20 +12,33 @@ export class AppConfig {
         this.title = title;
     }
     /**
-     * 加载配置
+     * 异步加载配置数据
+     * 通过调用API端点获取系统参数，解析并应用这些参数
+     * 如果获取参数失败或参数不正确，则抛出错误
+     *
+     * @returns {Promise<WC>} 返回配置数据的Promise
      */
     onLoad() {
         return __awaiter(this, void 0, void 0, function* () {
+            // 定义API请求的URL，用于获取系统参数
             const url = `api/gl-service-sys-core/v1/core/system/parameter/getOneByCode/${this.env.config.PROJECT_CONFIG_KEY}`;
+            // 发起API请求
             const response = yield fetch(url);
+            // 解析JSON响应
             const json = yield response.json();
+            // 检查响应码，如果不为0，则抛出错误
             if (json.code !== 0) {
                 throw new Error(json.msg);
             }
+            // 解析并处理配置数据
             const config = json.data.SYSTEM_PARAMETER_VALUE && JSON.parse(json.data.SYSTEM_PARAMETER_VALUE);
+            // 将production字符串转换为布尔值
             config.production = config.production === 'true';
+            // 将配置数据应用到应用配置中
             AppConfig.settings = config;
+            // 设置项目标题
             this.title.setTitle(config.insights.PROJECT_NAME);
+            // 返回配置数据
             return config;
         });
     }
@@ -42,19 +55,28 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
                     args: [RK_ENVIRONMENT]
                 }] }, { type: i1.Title }]; } });
 /**
- * 项目初始化配置
- * @param environment
+ * 配置应用的提供者和初始化函数
+ *
+ * 此函数用于配置应用程序的提供者和服务初始化逻辑它通过依赖注入机制，
+ * 将环境配置和应用配置对象提供给应用，并在应用启动时执行一个加载函数
+ *
+ * @param environment 应用环境的配置对象，包含运行时的各种环境变量和配置
+ * @returns 返回一个包含提供者配置的数组，用于 AppModule 的提供者列表
  */
 export function providerAppConfig(environment) {
     return [
+        // 提供环境配置的提供者，将环境对象作为值提供给 RK_ENVIRONMENT 令牌
         { provide: RK_ENVIRONMENT, useValue: environment },
+        // 将 AppConfig 服务本身作为提供者
         AppConfig,
+        // 配置 APP_INITIALIZER 提供者，使用工厂函数在应用启动时调用 appConfig 的 onLoad 方法
+        // 这允许在应用启动完成后执行一些初始化逻辑
         {
             provide: APP_INITIALIZER,
             useFactory: (appConfig) => () => appConfig.onLoad(),
             deps: [AppConfig],
-            multi: true,
+            multi: true, // 标记此初始化函数为多值，可以有多个初始化函数
         },
     ];
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/services/auth.service.js

@@ -5,24 +5,30 @@ import { Store } from '@reskin/core/utils';
 import { RK_ENVIRONMENT } from './app.config';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common/http";
+// RkAuthService 提供了与用户认证相关的服务
 export class RkAuthService {
+    // 构造函数，注入环境配置和HTTP客户端
     constructor(env, http) {
         this.env = env;
         this.http = http;
+        // auth 存储认证信息
         this.auth = new Store('auth', {});
     }
     /**
      * 系统登录
      * @param data 验证信息
-     * @returns
+     * @returns 登录结果
      */
     onLogin(data) {
         const url = 'api/gl-service-sys-user/v1/user/system/auth/login';
+        // 设置请求头，包含项目类型和无令牌控制信息
         const headers = new HttpHeaders({
             'ProjectNo': this.env.config.PROJECT_TYPE,
             'Token-Control': 'no-token',
         });
+        // 发送POST请求，并在成功后处理响应
         return this.http.post(url, { data }, { headers }).pipe(tap((json) => {
+            // 如果代码为0，表示登录成功，存储认证信息
             if (json.code === 0) {
                 this.auth.set(json.data);
             }
@@ -33,12 +39,15 @@ export class RkAuthService {
      */
     onLogout() {
         const url = 'api/gl-service-sys-user/v1/user/system/auth/logoutByAuthId';
+        // 发送POST请求，使用当前的AUTH_ID进行注销
         return this.http.post(url, { AUTH_ID: this.token.id });
     }
     /**
      * 获得 token
+     * @returns 当前用户的认证信息
      */
     get token() {
+        // 获取存储的认证信息
         return this.auth.get();
     }
 }
@@ -53,4 +62,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
                     type: Inject,
                     args: [RK_ENVIRONMENT]
                 }] }, { type: i1.HttpClient }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/services/cache.http.service.js

@@ -6,29 +6,42 @@ export class RkCacheHttpService {
         this.cache = new Map();
     }
     /**
-     * 获得已缓存的请求
-     * @param url GET请求地址
+     * 从缓存中获取指定URL的HTTP响应
+     *
+     * 此方法尝试从缓存中获取与指定URL相关的HTTP响应如果缓存中存在相应的响应，则返回该响应，否则返回未定义（undefined）
+     * 它避免了不必要的网络请求，从而提高应用的性能
+     *
+     * @param url 要从缓存中获取的资源的URL
+     * @returns 返回一个Observable对象，该对象发出未知类型的HTTP事件，或者在缓存中未找到时返回未定义
      */
     get(url) {
         return this.cache.get(url);
     }
     /**
-     * 缓存请求
-     * @param url GET请求地址
-     * @param response 响应内容
+     * 将HTTP响应缓存到指定的URL
+     *
+     * 此方法用于将给定的HTTP响应Observable对象与特定的URL关联，并存储在缓存中这样做的目的是为了在将来对同一URL的请求可以直接从缓存中获取响应，而不需要再次发送HTTP请求，从而提高应用的性能和响应速度
+     *
+     * @param url 要缓存响应的URL
+     * @param response HTTP响应的Observable对象，包含响应数据和状态
      */
     set(url, response) {
         this.cache.set(url, response);
     }
     /**
-     * 删除指定已缓存的请求
-     * @param url GET请求地址
+     * 删除指定的URL对应的缓存
+     *
+     * 本方法通过URL作为键，从缓存中删除对应的缓存项它使用了`cache.delete`方法来实现缓存的删除操作
+     *
+     * @param url {string} - 需要删除缓存的URL地址
      */
     delete(url) {
         this.cache.delete(url);
     }
     /**
-     * 删除所有已缓存的请求
+     * 清除缓存
+     *
+     * 该方法清空当前实例的缓存
      */
     clear() {
         this.cache.clear();
@@ -43,16 +56,25 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
                 }]
         }] });
 /**
- * 设置为缓存请求
+ * 生成带有缓存策略的HTTP请求模板
  * 使用方法：http.get(...CacheHttpTemplate`api/response.json`)
- * @param urls 请求地址
- * @param params 模板参数
+ *
+ * 该函数用于创建一个带有特定缓存策略的HTTP请求URL和相关头部信息它通过模板字符串和参数数组，
+ * 构建一个最终的URL，并自动添加一个名为'Cache-Map'的自定义头部，其值为'Storage'
+ *
+ * @param urls 模板字符串数组，通常用于构建URL的一部分
+ * @param params 任意数量的参数，用于与模板字符串一起构建最终的URL
+ * @returns 返回一个元组，第一个元素是构建好的URL字符串，第二个元素是一个对象，
+ * 包含了HTTP请求的头部信息，目前只包含一个自定义的'Cache-Map'头部
  */
 export function CacheHttpTemplate(urls, ...params) {
+    // 初始化URL为模板字符串数组的第一个元素
     let [url] = urls;
+    // 如果参数数组非空，则使用模板字符串和参数数组构建最终的URL
     if (params.length > 0) {
         url = String.raw(urls, ...params);
     }
+    // 返回构建好的URL和带有缓存策略的头部信息
     return [url, { headers: new HttpHeaders({ 'Cache-Map': 'Storage' }) }];
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/services/destroy.service.js

@@ -2,6 +2,15 @@ import { Injectable } from '@angular/core';
 import { Subject } from 'rxjs';
 import * as i0 from "@angular/core";
 export class RkDestroyService extends Subject {
+    /**
+     * 在组件销毁时调用的方法
+     *
+     * 该方法主要用于清理操作，确保在组件被销毁前完成所有的清理工作
+     * 首先，调用`this.next()`方法，用于发送一个通知或执行某些操作，以便在组件销毁前进行必要的处理
+     * 然后，调用`this.complete()`方法，表示已完成所有必要的清理操作，确保资源被正确释放
+     *
+     * @returns void - 该方法没有返回值
+     */
     ngOnDestroy() {
         this.next();
         this.complete();
@@ -12,4 +21,4 @@ RkDestroyService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", ver
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkDestroyService, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVzdHJveS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vbGlicmFyeS9jb3JlL3NlcnZpY2VzL2Rlc3Ryb3kuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFhLE1BQU0sZUFBZSxDQUFDO0FBQ3RELE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7O0FBRy9CLE1BQU0sT0FBTyxnQkFBaUIsU0FBUSxPQUFhO0lBQy9DLFdBQVc7UUFDUCxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUM7UUFDWixJQUFJLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDcEIsQ0FBQzs7OEdBSlEsZ0JBQWdCO2tIQUFoQixnQkFBZ0I7NEZBQWhCLGdCQUFnQjtrQkFENUIsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUsIE9uRGVzdHJveSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBTdWJqZWN0IH0gZnJvbSAncnhqcyc7XHJcblxyXG5ASW5qZWN0YWJsZSgpXHJcbmV4cG9ydCBjbGFzcyBSa0Rlc3Ryb3lTZXJ2aWNlIGV4dGVuZHMgU3ViamVjdDx2b2lkPiBpbXBsZW1lbnRzIE9uRGVzdHJveSB7XHJcbiAgICBuZ09uRGVzdHJveSgpOiB2b2lkIHtcclxuICAgICAgICB0aGlzLm5leHQoKTtcclxuICAgICAgICB0aGlzLmNvbXBsZXRlKCk7XHJcbiAgICB9XHJcbn1cclxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVzdHJveS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vbGlicmFyeS9jb3JlL3NlcnZpY2VzL2Rlc3Ryb3kuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFhLE1BQU0sZUFBZSxDQUFDO0FBQ3RELE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7O0FBRy9CLE1BQU0sT0FBTyxnQkFBaUIsU0FBUSxPQUFhO0lBQy9DOzs7Ozs7OztPQVFHO0lBQ0gsV0FBVztRQUNQLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNaLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztJQUNwQixDQUFDOzs4R0FiUSxnQkFBZ0I7a0hBQWhCLGdCQUFnQjs0RkFBaEIsZ0JBQWdCO2tCQUQ1QixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSwgT25EZXN0cm95IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IFN1YmplY3QgfSBmcm9tICdyeGpzJztcclxuXHJcbkBJbmplY3RhYmxlKClcclxuZXhwb3J0IGNsYXNzIFJrRGVzdHJveVNlcnZpY2UgZXh0ZW5kcyBTdWJqZWN0PHZvaWQ+IGltcGxlbWVudHMgT25EZXN0cm95IHtcclxuICAgIC8qKlxyXG4gICAgICog5Zyo57uE5Lu26ZSA5q+B5pe26LCD55So55qE5pa55rOVXHJcbiAgICAgKlxyXG4gICAgICog6K+l5pa55rOV5Li76KaB55So5LqO5riF55CG5pON5L2c77yM56Gu5L+d5Zyo57uE5Lu26KKr6ZSA5q+B5YmN5a6M5oiQ5omA5pyJ55qE5riF55CG5bel5L2cXHJcbiAgICAgKiDpppblhYjvvIzosIPnlKhgdGhpcy5uZXh0KClg5pa55rOV77yM55So5LqO5Y+R6YCB5LiA5Liq6YCa55+l5oiW5omn6KGM5p+Q5Lqb5pON5L2c77yM5Lul5L6/5Zyo57uE5Lu26ZSA5q+B5YmN6L+b6KGM5b+F6KaB55qE5aSE55CGXHJcbiAgICAgKiDnhLblkI7vvIzosIPnlKhgdGhpcy5jb21wbGV0ZSgpYOaWueazle+8jOihqOekuuW3suWujOaIkOaJgOacieW/heimgeeahOa4heeQhuaTjeS9nO+8jOehruS/nei1hOa6kOiiq+ato+ehrumHiuaUvlxyXG4gICAgICpcclxuICAgICAqIEByZXR1cm5zIHZvaWQgLSDor6Xmlrnms5XmsqHmnInov5Tlm57lgLxcclxuICAgICAqL1xyXG4gICAgbmdPbkRlc3Ryb3koKTogdm9pZCB7XHJcbiAgICAgICAgdGhpcy5uZXh0KCk7XHJcbiAgICAgICAgdGhpcy5jb21wbGV0ZSgpO1xyXG4gICAgfVxyXG59XHJcbiJdfQ==

package/esm2015/services/dictionary.service.js

@@ -4,15 +4,17 @@ import { CacheHttpTemplate } from './cache.http.service';
 import { Store } from '@reskin/core/utils';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common/http";
+// 提供字典服务，用于管理和查询字典数据
 export class RkDictionaryService {
     constructor(http) {
         this.http = http;
+        // 存储字典常用项的缓存，有效期为一周
         this.useItems = new Store('dictionary_use_items', {}, { expires: 1000 * 60 * 60 * 24 * 7 });
     }
     /**
      * 通过字典编码获得常用项
      * @param code 字典编码
-     * @returns 常用项
+     * @returns 常用项数组
      */
     getUseItems(code) {
         return this.useItems.get()[code] || [];
@@ -20,20 +22,24 @@ export class RkDictionaryService {
     /**
      * 通过字典编码设置常用项
      * @param code 字典编码
-     * @param item 常用项
+     * @param item 常用项对象
      */
     setUseItems(code, item) {
         const data = this.useItems.get();
+        // 如果字典编码不存在，则创建一个新数组
         if (!data[code]) {
             data[code] = [item];
         }
         else {
+            // 如果常用项已存在，则不进行重复添加
             if (data[code].find((v) => v.DICTIONARY_ITEM_CODE === item.DICTIONARY_ITEM_CODE)) {
                 return;
             }
+            // 如果常用项数组已满（超过9个），则移除最后一个元素
             if (data[code].length > 9) {
                 data[code].pop();
             }
+            // 将新的常用项添加到数组开头
             data[code].unshift(item);
         }
         this.useItems.set(data);
@@ -41,39 +47,40 @@ export class RkDictionaryService {
     /**
      * 通过字典编码获得字典基本信息
      * @param code 字典编码
-     * @returns 字典基本信息
+     * @returns 字典基本信息的Observable对象
      */
     getBaseInfo(code) {
         const url = `api/gl-service-sys-core/v1/core/system/dictionary/selectOneByDictionaryCode`;
         return this.http.get(...CacheHttpTemplate `${url}/${this.codeReplace(code)}`).pipe(filter((json) => json.code === 0), map((json) => json.data));
     }
     /**
-     * 通过字典编码获得获得字典项
+     * 通过字典编码获得字典项列表
      * @param code 字典编码
-     * @returns 字典项列表
+     * @returns 字典项列表的Observable对象
      */
     getData(code) {
         const url = `api/gl-service-sys-core/v1/core/system/dictionary/item/selectListByDictionaryCode`;
         return this.http.get(...CacheHttpTemplate `${url}/${this.codeReplace(code)}`).pipe(filter((json) => json.code === 0), map((json) => json.data));
     }
     /**
-     * 通过父节点获得字典项编码
+     * 通过父节点获得字典项列表
      * @param code 字典编码
-     * @param parentId 父节点编码
-     * @returns 字典项列表
+     * @param parentId 父节点编码，默认为根节点
+     * @returns 字典项列表的Observable对象
      */
     getChildData(code, parentId = '-1') {
         const url = `api/gl-service-sys-core/v1/core/system/dictionary/item/selectListByDictionaryCode`;
         return this.http.post(url, { DICTIONARY_CODE: code, SYS_PARENT: parentId }).pipe(filter((json) => json.code === 0), map((json) => json.data));
     }
+    // 私有方法，用于替换字典编码中的特殊字符
     codeReplace(code) {
         return code.replace(/\//g, '_');
     }
     /**
-     * 通过字典编码获得获得字典项
+     * 根据关键字搜索字典项
      * @param code 字典编码
      * @param keyword 关键字
-     * @returns 字典项列表
+     * @returns 最多10个匹配的字典项列表的Observable对象
      */
     requestSearchData(code, keyword) {
         const url = 'api/gl-service-sys-core/v1/core/system/dictionary/item/selectListByQuery';
@@ -86,10 +93,10 @@ export class RkDictionaryService {
         }))));
     }
     /**
-     * 获得字典项的所有父节点
+     * 获取字典项的所有父节点
      * @param code 字典编码
      * @param id 字典项编码
-     * @returns 字典项列表
+     * @returns 父节点列表的Observable对象
      */
     requestParentList(code, id) {
         const url = 'api/gl-service-sys-core/v1/core/system/dictionary/item/selectListInfoAllParentByCode';
@@ -104,4 +111,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
                     providedIn: 'root',
                 }]
         }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dictionary.service.js","sourceRoot":"","sources":["../../../../library/core/services/dictionary.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { filter, map } from 'rxjs/operators';\r\nimport { Observable } from 'rxjs';\r\nimport { CacheHttpTemplate } from './cache.http.service';\r\nimport { IDictionaryBaseInfo, IDictionaryItem } from '@reskin/core/entity/dictionary';\r\nimport { Store } from '@reskin/core/utils';\r\nimport { R } from '@reskin/core/entity';\r\n\r\n@Injectable({\r\n    providedIn: 'root',\r\n})\r\nexport class RkDictionaryService {\r\n    private useItems = new Store<Record<string, IDictionaryItem[]>>('dictionary_use_items', {}, { expires: 1000 * 60 * 60 * 24 * 7 });\r\n\r\n    constructor(private http: HttpClient) {}\r\n\r\n    /**\r\n     * 通过字典编码获得常用项\r\n     * @param code 字典编码\r\n     * @returns 常用项\r\n     */\r\n    getUseItems(code: string): IDictionaryItem[] {\r\n        return this.useItems.get()[code] || [];\r\n    }\r\n\r\n    /**\r\n     * 通过字典编码设置常用项\r\n     * @param code 字典编码\r\n     * @param item 常用项\r\n     */\r\n    setUseItems(code: string, item: IDictionaryItem) {\r\n        const data = this.useItems.get();\r\n        if (!data[code]) {\r\n            data[code] = [item];\r\n        } else {\r\n            if (data[code].find((v) => v.DICTIONARY_ITEM_CODE === item.DICTIONARY_ITEM_CODE)) {\r\n                return;\r\n            }\r\n            if (data[code].length > 9) {\r\n                data[code].pop();\r\n            }\r\n            data[code].unshift(item);\r\n        }\r\n        this.useItems.set(data);\r\n    }\r\n\r\n    /**\r\n     * 通过字典编码获得字典基本信息\r\n     * @param code 字典编码\r\n     * @returns 字典基本信息\r\n     */\r\n    getBaseInfo(code: string): Observable<IDictionaryBaseInfo> {\r\n        const url = `api/gl-service-sys-core/v1/core/system/dictionary/selectOneByDictionaryCode`;\r\n        return this.http.get<R>(...CacheHttpTemplate`${url}/${this.codeReplace(code)}`).pipe(\r\n            filter((json) => json.code === 0),\r\n            map((json) => json.data),\r\n        );\r\n    }\r\n\r\n    /**\r\n     * 通过字典编码获得获得字典项\r\n     * @param code 字典编码\r\n     * @returns 字典项列表\r\n     */\r\n    getData(code: string): Observable<IDictionaryItem[]> {\r\n        const url = `api/gl-service-sys-core/v1/core/system/dictionary/item/selectListByDictionaryCode`;\r\n        return this.http.get<R>(...CacheHttpTemplate`${url}/${this.codeReplace(code)}`).pipe(\r\n            filter((json) => json.code === 0),\r\n            map((json) => json.data),\r\n        );\r\n    }\r\n\r\n    /**\r\n     * 通过父节点获得字典项编码\r\n     * @param code 字典编码\r\n     * @param parentId 父节点编码\r\n     * @returns 字典项列表\r\n     */\r\n    getChildData(code: string, parentId = '-1'): Observable<IDictionaryItem[]> {\r\n        const url = `api/gl-service-sys-core/v1/core/system/dictionary/item/selectListByDictionaryCode`;\r\n        return this.http.post<R>(url, { DICTIONARY_CODE: code, SYS_PARENT: parentId }).pipe(\r\n            filter((json) => json.code === 0),\r\n            map((json) => json.data),\r\n        );\r\n    }\r\n\r\n    private codeReplace(code: string): string {\r\n        return code.replace(/\\//g, '_');\r\n    }\r\n\r\n    /**\r\n     * 通过字典编码获得获得字典项\r\n     * @param code 字典编码\r\n     * @param keyword 关键字\r\n     * @returns 字典项列表\r\n     */\r\n    requestSearchData(code: string, keyword: string) {\r\n        const url = 'api/gl-service-sys-core/v1/core/system/dictionary/item/selectListByQuery';\r\n        return this.http.post<R>(url, { DICTIONARY_CODE: code, DICTIONARY_ITEM_NAME: keyword }).pipe(\r\n            filter((json) => json.code === 0),\r\n            map((json) =>\r\n                json.data\r\n                    .filter((item: any, index: number) => index < 10)\r\n                    .map((item: any) => ({\r\n                        label: item.DICTIONARY_ITEM_NAME,\r\n                        key: item.SYSTEM_DICTIONARY_ITEM_ID,\r\n                        value: item.DICTIONARY_ITEM_CODE,\r\n                    })),\r\n            ),\r\n        );\r\n    }\r\n\r\n    /**\r\n     * 获得字典项的所有父节点\r\n     * @param code 字典编码\r\n     * @param id 字典项编码\r\n     * @returns 字典项列表\r\n     */\r\n    requestParentList(code: string, id: string): Observable<IDictionaryItem[]> {\r\n        const url = 'api/gl-service-sys-core/v1/core/system/dictionary/item/selectListInfoAllParentByCode';\r\n        return this.http.post<R>(url, { DICTIONARY_CODE: code, DICTIONARY_ITEM_CODE: id }).pipe(\r\n            filter((json) => json.code === 0),\r\n            map((json) => json.data),\r\n        );\r\n    }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dictionary.service.js","sourceRoot":"","sources":["../../../../library/core/services/dictionary.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { filter, map } from 'rxjs/operators';\r\nimport { Observable } from 'rxjs';\r\nimport { CacheHttpTemplate } from './cache.http.service';\r\nimport { IDictionaryBaseInfo, IDictionaryItem } from '@reskin/core/entity/dictionary';\r\nimport { Store } from '@reskin/core/utils';\r\nimport { R } from '@reskin/core/entity';\r\n\r\n// 提供字典服务，用于管理和查询字典数据\r\n@Injectable({\r\n    providedIn: 'root',\r\n})\r\nexport class RkDictionaryService {\r\n    // 存储字典常用项的缓存，有效期为一周\r\n    private useItems = new Store<Record<string, IDictionaryItem[]>>('dictionary_use_items', {}, { expires: 1000 * 60 * 60 * 24 * 7 });\r\n\r\n    constructor(private http: HttpClient) {}\r\n\r\n    /**\r\n     * 通过字典编码获得常用项\r\n     * @param code 字典编码\r\n     * @returns 常用项数组\r\n     */\r\n    getUseItems(code: string): IDictionaryItem[] {\r\n        return this.useItems.get()[code] || [];\r\n    }\r\n\r\n    /**\r\n     * 通过字典编码设置常用项\r\n     * @param code 字典编码\r\n     * @param item 常用项对象\r\n     */\r\n    setUseItems(code: string, item: IDictionaryItem) {\r\n        const data = this.useItems.get();\r\n        // 如果字典编码不存在，则创建一个新数组\r\n        if (!data[code]) {\r\n            data[code] = [item];\r\n        } else {\r\n            // 如果常用项已存在，则不进行重复添加\r\n            if (data[code].find((v) => v.DICTIONARY_ITEM_CODE === item.DICTIONARY_ITEM_CODE)) {\r\n                return;\r\n            }\r\n            // 如果常用项数组已满（超过9个），则移除最后一个元素\r\n            if (data[code].length > 9) {\r\n                data[code].pop();\r\n            }\r\n            // 将新的常用项添加到数组开头\r\n            data[code].unshift(item);\r\n        }\r\n        this.useItems.set(data);\r\n    }\r\n\r\n    /**\r\n     * 通过字典编码获得字典基本信息\r\n     * @param code 字典编码\r\n     * @returns 字典基本信息的Observable对象\r\n     */\r\n    getBaseInfo(code: string): Observable<IDictionaryBaseInfo> {\r\n        const url = `api/gl-service-sys-core/v1/core/system/dictionary/selectOneByDictionaryCode`;\r\n        return this.http.get<R>(...CacheHttpTemplate`${url}/${this.codeReplace(code)}`).pipe(\r\n            filter((json) => json.code === 0),\r\n            map((json) => json.data),\r\n        );\r\n    }\r\n\r\n    /**\r\n     * 通过字典编码获得字典项列表\r\n     * @param code 字典编码\r\n     * @returns 字典项列表的Observable对象\r\n     */\r\n    getData(code: string): Observable<IDictionaryItem[]> {\r\n        const url = `api/gl-service-sys-core/v1/core/system/dictionary/item/selectListByDictionaryCode`;\r\n        return this.http.get<R>(...CacheHttpTemplate`${url}/${this.codeReplace(code)}`).pipe(\r\n            filter((json) => json.code === 0),\r\n            map((json) => json.data),\r\n        );\r\n    }\r\n\r\n    /**\r\n     * 通过父节点获得字典项列表\r\n     * @param code 字典编码\r\n     * @param parentId 父节点编码，默认为根节点\r\n     * @returns 字典项列表的Observable对象\r\n     */\r\n    getChildData(code: string, parentId = '-1'): Observable<IDictionaryItem[]> {\r\n        const url = `api/gl-service-sys-core/v1/core/system/dictionary/item/selectListByDictionaryCode`;\r\n        return this.http.post<R>(url, { DICTIONARY_CODE: code, SYS_PARENT: parentId }).pipe(\r\n            filter((json) => json.code === 0),\r\n            map((json) => json.data),\r\n        );\r\n    }\r\n\r\n    // 私有方法，用于替换字典编码中的特殊字符\r\n    private codeReplace(code: string): string {\r\n        return code.replace(/\\//g, '_');\r\n    }\r\n\r\n    /**\r\n     * 根据关键字搜索字典项\r\n     * @param code 字典编码\r\n     * @param keyword 关键字\r\n     * @returns 最多10个匹配的字典项列表的Observable对象\r\n     */\r\n    requestSearchData(code: string, keyword: string) {\r\n        const url = 'api/gl-service-sys-core/v1/core/system/dictionary/item/selectListByQuery';\r\n        return this.http.post<R>(url, { DICTIONARY_CODE: code, DICTIONARY_ITEM_NAME: keyword }).pipe(\r\n            filter((json) => json.code === 0),\r\n            map((json) =>\r\n                json.data\r\n                    .filter((item: any, index: number) => index < 10)\r\n                    .map((item: any) => ({\r\n                        label: item.DICTIONARY_ITEM_NAME,\r\n                        key: item.SYSTEM_DICTIONARY_ITEM_ID,\r\n                        value: item.DICTIONARY_ITEM_CODE,\r\n                    })),\r\n            ),\r\n        );\r\n    }\r\n\r\n    /**\r\n     * 获取字典项的所有父节点\r\n     * @param code 字典编码\r\n     * @param id 字典项编码\r\n     * @returns 父节点列表的Observable对象\r\n     */\r\n    requestParentList(code: string, id: string): Observable<IDictionaryItem[]> {\r\n        const url = 'api/gl-service-sys-core/v1/core/system/dictionary/item/selectListInfoAllParentByCode';\r\n        return this.http.post<R>(url, { DICTIONARY_CODE: code, DICTIONARY_ITEM_CODE: id }).pipe(\r\n            filter((json) => json.code === 0),\r\n            map((json) => json.data),\r\n        );\r\n    }\r\n}\r\n"]}