@reskin/core 0.0.1

package/esm2015/interceptors/token.interceptor.js

@@ -0,0 +1,48 @@
+import { Injectable } from '@angular/core';
+import { HTTP_INTERCEPTORS, HttpHeaders } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "@reskin/core/services";
+export class TokenInterceptor {
+    constructor(service) {
+        this.service = service;
+    }
+    intercept(request, next) {
+        const tc = request.headers.get('Token-Control');
+        const auth = this.service.token;
+        // 当 header 中 Token-Control 为 no-token 时不携带 token
+        if (tc !== 'no-token' && auth.token) {
+            request = request.clone({
+                setHeaders: {
+                    'Authorization': auth.token,
+                    'X-Auth-Id': auth.id,
+                },
+            });
+        }
+        return next.handle(request);
+    }
+}
+TokenInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: TokenInterceptor, deps: [{ token: i1.RkAuthService }], target: i0.ɵɵFactoryTarget.Injectable });
+TokenInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: TokenInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: TokenInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.RkAuthService }]; } });
+/**
+ * 请求头增加token验证拦截器
+ */
+export function providerAuthToken() {
+    return { provide: HTTP_INTERCEPTORS, useClass: TokenInterceptor, multi: true };
+}
+/**
+ * 不带token验证信息请求
+ * @param urls 地址
+ * @param params 参数
+ * @constructor
+ */
+export function NoAuthTokenTemplate(urls, ...params) {
+    let [url] = urls;
+    if (params.length > 0) {
+        url = String.raw(urls, ...params);
+    }
+    return [url, { headers: new HttpHeaders({ 'Token-Control': 'no-token' }) }];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/public-api.js

@@ -0,0 +1,2 @@
+export default void 0;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYnJhcnkvY29yZS9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQWUsS0FBSyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZGVmYXVsdCB2b2lkIDA7XG4iXX0=

package/esm2015/reskin-core.js

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVza2luLWNvcmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWJyYXJ5L2NvcmUvcmVza2luLWNvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2015/services/account.service.js

@@ -0,0 +1,58 @@
+import { Injectable } from '@angular/core';
+import { tap } from 'rxjs/operators';
+import { Store } from '@reskin/core/utils';
+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) {
+        this.http = http;
+        this.auth = auth;
+        this.account = new Store('account', {});
+    }
+    /**
+     * 加载人员权限
+     */
+    onLoadAuth() {
+        var _a;
+        const url = 'api/gl-service-sys-user/v1/user/system/user/loadAuthData';
+        return this.http.post(url, { SYSTEM_USER_ID: (_a = this.auth.token) === null || _a === void 0 ? void 0 : _a.id }).pipe(tap((json) => {
+            if (json.code === 0) {
+                this.account.set(json.data);
+            }
+        }));
+    }
+    /**
+     * 获得账号基本信息
+     */
+    get userInfo() {
+        return this.account.get().UserInfo;
+    }
+    /**
+     * 获得账号人员库权限
+     */
+    get personnelPool() {
+        return this.account.get().AuthPersonnelPool;
+    }
+    /**
+     * 获得账号业务权限
+     */
+    get workflowAuth() {
+        return this.account.get().AuthWfId;
+    }
+    /**
+     * 获得账号机构分组权限
+     */
+    get authOrgGroup() {
+        return this.account.get().AuthOrgGroup;
+    }
+}
+RkAccountService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkAccountService, deps: [{ token: i1.HttpClient }, { token: i2.RkAuthService }], target: i0.ɵɵFactoryTarget.Injectable });
+RkAccountService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkAccountService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkAccountService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.RkAuthService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/services/app.config.js

@@ -0,0 +1,60 @@
+import { __awaiter } from "tslib";
+import { APP_INITIALIZER, Inject, Injectable, InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+/**
+ * 项目环境变量配置 Token
+ */
+export const RK_ENVIRONMENT = new InjectionToken('environment');
+export class AppConfig {
+    constructor(env, title) {
+        this.env = env;
+        this.title = title;
+    }
+    /**
+     * 加载配置
+     */
+    onLoad() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `api/gl-service-sys-core/v1/core/system/parameter/getOneByCode/${this.env.config.PROJECT_CONFIG_KEY}`;
+            const response = yield fetch(url);
+            const json = yield response.json();
+            if (json.code !== 0) {
+                throw new Error(json.msg);
+            }
+            const config = json.data.SYSTEM_PARAMETER_VALUE && JSON.parse(json.data.SYSTEM_PARAMETER_VALUE);
+            config.production = config.production === 'true';
+            AppConfig.settings = config;
+            this.title.setTitle(config.insights.PROJECT_NAME);
+            return config;
+        });
+    }
+}
+AppConfig.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AppConfig, deps: [{ token: RK_ENVIRONMENT }, { token: i1.Title }], target: i0.ɵɵFactoryTarget.Injectable });
+AppConfig.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AppConfig, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AppConfig, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [RK_ENVIRONMENT]
+                }] }, { type: i1.Title }]; } });
+/**
+ * 项目初始化配置
+ * @param environment
+ */
+export function providerAppConfig(environment) {
+    return [
+        { provide: RK_ENVIRONMENT, useValue: environment },
+        AppConfig,
+        {
+            provide: APP_INITIALIZER,
+            useFactory: (appConfig) => () => appConfig.onLoad(),
+            deps: [AppConfig],
+            multi: true,
+        },
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/services/auth.service.js

@@ -0,0 +1,56 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import { tap } from 'rxjs/operators';
+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";
+export class RkAuthService {
+    constructor(env, http) {
+        this.env = env;
+        this.http = http;
+        this.auth = new Store('auth', {});
+    }
+    /**
+     * 系统登录
+     * @param data 验证信息
+     * @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',
+        });
+        return this.http.post(url, { data }, { headers }).pipe(tap((json) => {
+            if (json.code === 0) {
+                this.auth.set(json.data);
+            }
+        }));
+    }
+    /**
+     * 注销系统
+     */
+    onLogout() {
+        const url = 'api/gl-service-sys-user/v1/user/system/auth/logoutByAuthId';
+        return this.http.post(url, { AUTH_ID: this.token.id });
+    }
+    /**
+     * 获得 token
+     */
+    get token() {
+        return this.auth.get();
+    }
+}
+RkAuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkAuthService, deps: [{ token: RK_ENVIRONMENT }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+RkAuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkAuthService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkAuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [RK_ENVIRONMENT]
+                }] }, { type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,58 @@
+import { Injectable } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import * as i0 from "@angular/core";
+export class RkCacheHttpService {
+    constructor() {
+        this.cache = new Map();
+    }
+    /**
+     * 获得已缓存的请求
+     * @param url GET请求地址
+     */
+    get(url) {
+        return this.cache.get(url);
+    }
+    /**
+     * 缓存请求
+     * @param url GET请求地址
+     * @param response 响应内容
+     */
+    set(url, response) {
+        this.cache.set(url, response);
+    }
+    /**
+     * 删除指定已缓存的请求
+     * @param url GET请求地址
+     */
+    delete(url) {
+        this.cache.delete(url);
+    }
+    /**
+     * 删除所有已缓存的请求
+     */
+    clear() {
+        this.cache.clear();
+    }
+}
+RkCacheHttpService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkCacheHttpService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+RkCacheHttpService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkCacheHttpService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkCacheHttpService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+/**
+ * 设置为缓存请求
+ * 使用方法：http.get(...CacheHttpTemplate`api/response.json`)
+ * @param urls 请求地址
+ * @param params 模板参数
+ */
+export function CacheHttpTemplate(urls, ...params) {
+    let [url] = urls;
+    if (params.length > 0) {
+        url = String.raw(urls, ...params);
+    }
+    return [url, { headers: new HttpHeaders({ 'Cache-Map': 'Storage' }) }];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/services/destroy.service.js

@@ -0,0 +1,15 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class RkDestroyService extends Subject {
+    ngOnDestroy() {
+        this.next();
+        this.complete();
+    }
+}
+RkDestroyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkDestroyService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+RkDestroyService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkDestroyService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkDestroyService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVzdHJveS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vbGlicmFyeS9jb3JlL3NlcnZpY2VzL2Rlc3Ryb3kuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFhLE1BQU0sZUFBZSxDQUFDO0FBQ3RELE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7O0FBRy9CLE1BQU0sT0FBTyxnQkFBaUIsU0FBUSxPQUFhO0lBQy9DLFdBQVc7UUFDUCxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUM7UUFDWixJQUFJLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDcEIsQ0FBQzs7OEdBSlEsZ0JBQWdCO2tIQUFoQixnQkFBZ0I7NEZBQWhCLGdCQUFnQjtrQkFENUIsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUsIE9uRGVzdHJveSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBTdWJqZWN0IH0gZnJvbSAncnhqcyc7XHJcblxyXG5ASW5qZWN0YWJsZSgpXHJcbmV4cG9ydCBjbGFzcyBSa0Rlc3Ryb3lTZXJ2aWNlIGV4dGVuZHMgU3ViamVjdDx2b2lkPiBpbXBsZW1lbnRzIE9uRGVzdHJveSB7XHJcbiAgICBuZ09uRGVzdHJveSgpOiB2b2lkIHtcclxuICAgICAgICB0aGlzLm5leHQoKTtcclxuICAgICAgICB0aGlzLmNvbXBsZXRlKCk7XHJcbiAgICB9XHJcbn1cclxuIl19

package/esm2015/services/dictionary.service.js

@@ -0,0 +1,107 @@
+import { Injectable } from '@angular/core';
+import { filter, map } from 'rxjs/operators';
+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 常用项
+     */
+    getUseItems(code) {
+        return this.useItems.get()[code] || [];
+    }
+    /**
+     * 通过字典编码设置常用项
+     * @param code 字典编码
+     * @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;
+            }
+            if (data[code].length > 9) {
+                data[code].pop();
+            }
+            data[code].unshift(item);
+        }
+        this.useItems.set(data);
+    }
+    /**
+     * 通过字典编码获得字典基本信息
+     * @param code 字典编码
+     * @returns 字典基本信息
+     */
+    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 字典项列表
+     */
+    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 字典项列表
+     */
+    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 字典项列表
+     */
+    requestSearchData(code, keyword) {
+        const url = 'api/gl-service-sys-core/v1/core/system/dictionary/item/selectListByQuery';
+        return this.http.post(url, { DICTIONARY_CODE: code, DICTIONARY_ITEM_NAME: keyword }).pipe(filter((json) => json.code === 0), map((json) => json.data
+            .filter((item, index) => index < 10)
+            .map((item) => ({
+            label: item.DICTIONARY_ITEM_NAME,
+            key: item.SYSTEM_DICTIONARY_ITEM_ID,
+            value: item.DICTIONARY_ITEM_CODE,
+        }))));
+    }
+    /**
+     * 获得字典项的所有父节点
+     * @param code 字典编码
+     * @param id 字典项编码
+     * @returns 字典项列表
+     */
+    requestParentList(code, id) {
+        const url = 'api/gl-service-sys-core/v1/core/system/dictionary/item/selectListInfoAllParentByCode';
+        return this.http.post(url, { DICTIONARY_CODE: code, DICTIONARY_ITEM_CODE: id }).pipe(filter((json) => json.code === 0), map((json) => json.data));
+    }
+}
+RkDictionaryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkDictionaryService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+RkDictionaryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkDictionaryService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkDictionaryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    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"]}

package/esm2015/services/down.file.service.js

@@ -0,0 +1,79 @@
+import { Injectable } from '@angular/core';
+import { tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class RkDownFileService {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * 使用GET方法下载文件
+     * @param url 请求链接; url可以传递自定义文件名优先级最高;如：api/file/down?fileName=身份证.jpg
+     * @param params 请求参数
+     */
+    get(url, params) {
+        return this.http
+            .get(url, { params, responseType: 'blob', observe: 'response' })
+            .pipe(tap((response) => this.handleResponse(response, url)));
+    }
+    /**
+     * 使用POST方法下载文件
+     * @param url 请求链接; url可以传递自定义文件名优先级最高;如：api/file/down?fileName=身份证.jpg
+     * @param params 请求参数
+     */
+    post(url, params) {
+        return this.http
+            .post(url, params, { responseType: 'blob', observe: 'response' })
+            .pipe(tap((response) => this.handleResponse(response, url)));
+    }
+    handleResponse(response, url) {
+        const filename = this.getFileName(response.headers, url);
+        this.saveAs(response.body, filename);
+    }
+    getFileName(headers, url) {
+        const urlParams = new URLSearchParams(url.split('?')[1]);
+        const fileNameFromParams = urlParams.get('fileName');
+        if (fileNameFromParams) {
+            return decodeURIComponent(fileNameFromParams);
+        }
+        const disposition = headers.get('content-disposition');
+        if (disposition) {
+            const filenameMatch = disposition.match(/filename=([^;]+)/);
+            if (filenameMatch) {
+                return decodeURIComponent(filenameMatch[1]);
+            }
+        }
+        const filenameFromHeaders = headers.get('filename');
+        if (filenameFromHeaders) {
+            return decodeURIComponent(filenameFromHeaders);
+        }
+        const urlSegments = url.split('/');
+        return decodeURIComponent(urlSegments[urlSegments.length - 1].split('?')[0]);
+    }
+    /**
+     * 文件另存为
+     * @param body 二进制内容
+     * @param filename 文件名
+     */
+    saveAs(body, filename) {
+        const blob = new Blob([body], { type: 'application/x-msdownload' });
+        const blobURL = URL.createObjectURL(blob);
+        const link = document.createElement('a');
+        link.href = blobURL;
+        link.download = filename;
+        link.style.display = 'none';
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+        URL.revokeObjectURL(blobURL);
+    }
+}
+RkDownFileService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkDownFileService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+RkDownFileService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkDownFileService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkDownFileService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/services/field.scheme.service.js

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import { AppConfig } from './app.config';
+import { CacheHttpTemplate } from './cache.http.service';
+import { filter, map, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class RkFieldSchemeService {
+    constructor(http) {
+        this.http = http;
+        this.appSettings = AppConfig.settings;
+    }
+    /**
+     * 通过字段方案标识符获得字段方案内容
+     * @param permission 字段方案标识符
+     * @returns 字段方案
+     */
+    getData(permission) {
+        if (this.appSettings && this.appSettings.servers.AREA_CODE) {
+            permission = `${this.appSettings.servers.AREA_CODE}_${permission}`;
+        }
+        const url = `api/gl-service-sys-core/v1/core/system/field/scheme/selectSchemeByIdentifier`;
+        return this.http.get(...CacheHttpTemplate `${url}/${permission}`).pipe(tap((json) => {
+            if (json.code !== 0) {
+                throw new Error(`通过字段方案标识符获得字段方案内容 ${url} 出现错误: ${json.msg}`);
+            }
+        }), filter((json) => json.code === 0), map((json) => json.data));
+    }
+}
+RkFieldSchemeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkFieldSchemeService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+RkFieldSchemeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkFieldSchemeService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkFieldSchemeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,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