@reskin/core 0.0.10 → 0.0.12

package/bundles/reskin-core-utils.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"reskin-core-utils.umd.js","sources":["../../../library/core/utils/store.ts","../../../library/core/utils/array.ts","../../../library/core/utils/dom.ts","../../../library/core/utils/reskin-core-utils.ts"],"sourcesContent":["/**\n * 缓存配置信息\n */\nexport interface StoreOptions {\n    /**\n     * 缓存存储方式\n     */\n    storageEngine?: Storage;\n    /**\n     * 过期时间(毫秒)\n     */\n    expires?: number;\n}\n\n/**\n * 默认前缀\n */\nlet prefix: string = 'SK_';\n\n/**\n * 设置存储前缀\n *\n * 该函数用于更改全局存储前缀，影响后续所有存储操作的键名前缀。\n * 存储前缀的更改可能会影响已存储的数据被正确识别和访问。\n *\n * @param newPrefix 新的存储前缀字符串\n */\nexport function setStorePrefix(newPrefix: string) {\n    prefix = newPrefix;\n}\n\n/**\n * 提供了一个用于缓存值的类，值可以被存储在浏览器的localStorage或sessionStorage中。\n * 如果提供了过期时间，存储的值会在过期后自动移除。\n */\nexport class Store<T> {\n    private value: T;\n    private readonly storage: Storage;\n    private readonly expires?: number;\n    private readonly storageKey: () => string;\n\n    /**\n     * 初始化Store类的实例。\n     * @param key 缓存值的键名。\n     * @param defaultValue 初始值，默认值会被存储并返回直到设置新的值。\n     * @param options 配置选项，包括存储引擎和过期时间。\n     */\n    constructor(key: string, defaultValue: T, options?: StoreOptions) {\n        this.value = defaultValue;\n\n        // 进行初始设置\n        this.storageKey = () => `@${prefix}_${key}`.toLocaleUpperCase();\n        const { storageEngine = sessionStorage, expires } = options ?? {};\n        this.storage = storageEngine;\n        this.expires = expires;\n\n        const storedValue = this.storage.getItem(this.storageKey());\n        if (storedValue) {\n            const { data, expiry } = JSON.parse(storedValue);\n            // 判断是否过期，过期后删除key\n            if (!expiry || expiry > Date.now()) {\n                this.value = data;\n            } else {\n                this.storage.removeItem(this.storageKey());\n            }\n        }\n    }\n\n    /**\n     * 获取当前缓存的值。\n     * @returns 缓存的值。\n     */\n    get(): T {\n        return this.value;\n    }\n\n    /**\n     * 设置新的缓存值。\n     * @param newValue 新的值。\n     */\n    set(newValue: T): void {\n        this.value = newValue;\n\n        // 设置值时进行Storage设置\n        const value = JSON.stringify({\n            data: newValue,\n            expiry: this.expires ? Date.now() + this.expires : null,\n        });\n        this.storage.setItem(this.storageKey(), value);\n    }\n\n    /**\n     * 使用提供的函数更新缓存的值。\n     * @param updateFn 一个接受当前值并返回新值的函数。\n     */\n    update(updateFn: (currentValue: T) => T): void {\n        if (typeof updateFn === 'function') {\n            this.set(updateFn(this.value));\n        }\n    }\n}\n","/**\n * 深克隆一个对象或数组\n *\n * 该函数通过递归方式深克隆输入的对象或数组，确保与原对象或数组隔离，不会相互影响\n *\n * @param source 需要克隆的源对象或数组\n * @returns 返回克隆后的对象或数组\n */\nexport function deepClone<T>(source: T): T {\n    // 如果源对象为null或不是对象类型，则直接返回源对象\n    if (source === null || typeof source !== 'object') {\n        return source;\n    }\n\n    // 如果源对象是数组，则创建一个新数组并递归克隆每个元素\n    if (Array.isArray(source)) {\n        const clonedArray = [];\n        for (let i = 0; i < source.length; i++) {\n            clonedArray[i] = deepClone(source[i]);\n        }\n        // 忽略类型检查器的警告，确保能够返回泛型T类型的数组\n        // @ts-ignore\n        return clonedArray as T;\n    }\n\n    // 如果源对象是普通对象，则创建一个新的空对象并递归克隆每个属性\n    if (typeof source === 'object') {\n        const clonedObject: Record<string, any> = {};\n        for (const key in source) {\n            // 确保只处理对象自身的属性，避免原型链上的属性被克隆\n            // @ts-ignore\n            if (source.hasOwnProperty(key)) {\n                clonedObject[key] = deepClone(source[key]);\n            }\n        }\n        // 忽略类型检查器的警告，确保能够返回泛型T类型的对象\n        return clonedObject as T;\n    }\n\n    // 如果源对象是其他非对象类型，则直接返回源对象\n    return source;\n}\n","import { Observable } from 'rxjs';\n\n/**\n * 监听元素的大小变化\n *\n * 此函数创建了一个Observable，用于观察给定HTMLElement元素的大小变化它使用了ResizeObserver API来实现\n * 当元素的大小发生变化时，会发出一个包含变化记录的数组\n *\n * @param element 需要观察大小变化的HTMLElement元素\n * @returns 返回一个Observable，其中包含ResizeObserverEntry的数组，用于记录每次大小变化的信息\n */\nexport function observeResize(element: HTMLElement): Observable<ResizeObserverEntry[]> {\n    return new Observable((observer) => {\n        // 创建ResizeObserver实例，当观察的目标元素大小发生变化时，会调用回调函数\n        const resizeObserver = new ResizeObserver((entries) => {\n            observer.next(entries);\n        });\n        // 开始观察指定的元素\n        resizeObserver.observe(element);\n        // 返回一个函数，用于在停止观察时调用，以清理资源\n        return () => {\n            // 停止观察指定的元素\n            resizeObserver.unobserve(element);\n            // 断开与所有目标的观察连接\n            resizeObserver.disconnect();\n        };\n    });\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":["Observable"],"mappings":"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"}
+{"version":3,"file":"reskin-core-utils.umd.js","sources":["../../../library/core/utils/store.ts","../../../library/core/utils/array.ts","../../../library/core/utils/dom.ts","../../../library/core/utils/reskin-core-utils.ts"],"sourcesContent":["/**\n * 缓存配置信息\n */\nexport interface StoreOptions {\n    /**\n     * 缓存存储方式\n     */\n    storageEngine?: Storage;\n    /**\n     * 过期时间(毫秒)\n     */\n    expires?: number;\n}\n\n/**\n * 默认前缀\n */\nlet prefix: string = 'SK_';\n\n/**\n * 设置存储前缀\n *\n * 该函数用于更改全局存储前缀，影响后续所有存储操作的键名前缀。\n * 存储前缀的更改可能会影响已存储的数据被正确识别和访问。\n *\n * @param newPrefix 新的存储前缀字符串\n */\nexport function setStorePrefix(newPrefix: string) {\n    prefix = newPrefix;\n}\n\n/**\n * 提供了一个用于缓存值的类，值可以被存储在浏览器的localStorage或sessionStorage中。\n * 如果提供了过期时间，存储的值会在过期后自动移除。\n */\nexport class Store<T> {\n    private value: T;\n    private readonly storage: Storage;\n    private readonly expires?: number;\n    private readonly storageKey: () => string;\n\n    /**\n     * 初始化Store类的实例。\n     * @param key 缓存值的键名。\n     * @param defaultValue 初始值，默认值会被存储并返回直到设置新的值。\n     * @param options 配置选项，包括存储引擎和过期时间。\n     */\n    constructor(key: string, defaultValue: T, options?: StoreOptions) {\n        this.value = defaultValue;\n\n        // 进行初始设置\n        this.storageKey = () => `@${prefix}_${key}`.toLocaleUpperCase();\n        const { storageEngine = sessionStorage, expires } = options ?? {};\n        this.storage = storageEngine;\n        this.expires = expires;\n\n        const storedValue = this.storage.getItem(this.storageKey());\n        if (storedValue) {\n            const { data, expiry } = JSON.parse(storedValue);\n            // 判断是否过期，过期后删除key\n            if (!expiry || expiry > Date.now()) {\n                this.value = data;\n            } else {\n                this.storage.removeItem(this.storageKey());\n            }\n        }\n    }\n\n    /**\n     * 获取当前缓存的值。\n     * @returns 缓存的值。\n     */\n    get(): T {\n        return this.value;\n    }\n\n    /**\n     * 设置新的缓存值。\n     * @param newValue 新的值。\n     */\n    set(newValue: T): void {\n        this.value = newValue;\n\n        // 设置值时进行Storage设置\n        const value = JSON.stringify({\n            data: newValue,\n            expiry: this.expires ? Date.now() + this.expires : null,\n        });\n        this.storage.setItem(this.storageKey(), value);\n    }\n\n    /**\n     * 使用提供的函数更新缓存的值。\n     * @param updateFn 一个接受当前值并返回新值的函数。\n     */\n    update(updateFn: (currentValue: T) => T): void {\n        if (typeof updateFn === 'function') {\n            this.set(updateFn(this.value));\n        }\n    }\n}\n","/**\n * 深克隆一个对象或数组\n *\n * 该函数通过递归方式深克隆输入的对象或数组，确保与原对象或数组隔离，不会相互影响\n *\n * @param source 需要克隆的源对象或数组\n * @returns 返回克隆后的对象或数组\n */\nexport function deepClone<T>(source: T): T {\n    // 如果源对象为null或不是对象类型，则直接返回源对象\n    if (source === null || typeof source !== 'object') {\n        return source;\n    }\n\n    // 如果源对象是数组，则创建一个新数组并递归克隆每个元素\n    if (Array.isArray(source)) {\n        const clonedArray = [];\n        for (let i = 0; i < source.length; i++) {\n            clonedArray[i] = deepClone(source[i]);\n        }\n        // 忽略类型检查器的警告，确保能够返回泛型T类型的数组\n        // @ts-ignore\n        return clonedArray as T;\n    }\n\n    // 如果源对象是普通对象，则创建一个新的空对象并递归克隆每个属性\n    if (typeof source === 'object') {\n        const clonedObject: Record<string, any> = {};\n        for (const key in source) {\n            // 确保只处理对象自身的属性，避免原型链上的属性被克隆\n            // @ts-ignore\n            if (source.hasOwnProperty(key)) {\n                clonedObject[key] = deepClone(source[key]);\n            }\n        }\n        // 忽略类型检查器的警告，确保能够返回泛型T类型的对象\n        return clonedObject as T;\n    }\n\n    // 如果源对象是其他非对象类型，则直接返回源对象\n    return source;\n}\n","import { Observable } from 'rxjs';\r\n\r\n/**\r\n * 监听元素的大小变化\r\n *\r\n * 此函数创建了一个Observable，用于观察给定HTMLElement元素的大小变化它使用了ResizeObserver API来实现\r\n * 当元素的大小发生变化时，会发出一个包含变化记录的数组\r\n *\r\n * @param element 需要观察大小变化的HTMLElement元素\r\n * @returns 返回一个Observable，其中包含ResizeObserverEntry的数组，用于记录每次大小变化的信息\r\n */\r\nexport function observeResize(element: HTMLElement): Observable<ResizeObserverEntry[]> {\r\n    return new Observable((observer) => {\r\n        // 创建ResizeObserver实例，当观察的目标元素大小发生变化时，会调用回调函数\r\n        const resizeObserver = new ResizeObserver((entries) => {\r\n            observer.next(entries);\r\n        });\r\n        // 开始观察指定的元素\r\n        resizeObserver.observe(element);\r\n        // 返回一个函数，用于在停止观察时调用，以清理资源\r\n        return () => {\r\n            // 停止观察指定的元素\r\n            resizeObserver.unobserve(element);\r\n            // 断开与所有目标的观察连接\r\n            resizeObserver.disconnect();\r\n        };\r\n    });\r\n}\r\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":["Observable"],"mappings":";;;;;;IAcA;;IAEG;IACH,IAAI,MAAM,GAAW,KAAK,CAAC;IAE3B;;;;;;;IAOG;IACG,SAAU,cAAc,CAAC,SAAiB,EAAA;QAC5C,MAAM,GAAG,SAAS,CAAC;IACvB,CAAC;IAED;;;IAGG;AACH,QAAA,KAAA,kBAAA,YAAA;IAMI;;;;;IAKG;IACH,IAAA,SAAA,KAAA,CAAY,GAAW,EAAE,YAAe,EAAE,OAAsB,EAAA;IAC5D,QAAA,IAAI,CAAC,KAAK,GAAG,YAAY,CAAC;;IAG1B,QAAA,IAAI,CAAC,UAAU,GAAG,YAAM,EAAA,OAAA,CAAA,GAAI,GAAA,MAAM,GAAI,GAAA,GAAA,GAAK,EAAC,iBAAiB,EAAE,CAAA,EAAA,CAAC;YAC1D,IAAA,EAAA,GAA8C,OAAO,aAAP,OAAO,KAAA,KAAA,CAAA,GAAP,OAAO,GAAI,EAAE,EAAzD,EAAA,GAAA,EAAA,CAAA,aAA8B,EAA9B,aAAa,GAAG,EAAA,KAAA,KAAA,CAAA,GAAA,cAAc,GAAA,EAAA,EAAE,OAAO,GAAA,EAAA,CAAA,OAAkB,CAAC;IAClE,QAAA,IAAI,CAAC,OAAO,GAAG,aAAa,CAAC;IAC7B,QAAA,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IAEvB,QAAA,IAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;IAC5D,QAAA,IAAI,WAAW,EAAE;IACP,YAAA,IAAA,EAAmB,GAAA,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,EAAxC,IAAI,GAAA,EAAA,CAAA,IAAA,EAAE,MAAM,YAA4B,CAAC;;gBAEjD,IAAI,CAAC,MAAM,IAAI,MAAM,GAAG,IAAI,CAAC,GAAG,EAAE,EAAE;IAChC,gBAAA,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACrB,aAAA;IAAM,iBAAA;oBACH,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;IAC9C,aAAA;IACJ,SAAA;SACJ;IAED;;;IAGG;IACH,IAAA,KAAA,CAAA,SAAA,CAAA,GAAG,GAAH,YAAA;YACI,OAAO,IAAI,CAAC,KAAK,CAAC;SACrB,CAAA;IAED;;;IAGG;QACH,KAAG,CAAA,SAAA,CAAA,GAAA,GAAH,UAAI,QAAW,EAAA;IACX,QAAA,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC;;IAGtB,QAAA,IAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC;IACzB,YAAA,IAAI,EAAE,QAAQ;IACd,YAAA,MAAM,EAAE,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,OAAO,GAAG,IAAI;IAC1D,SAAA,CAAC,CAAC;IACH,QAAA,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,KAAK,CAAC,CAAC;SAClD,CAAA;IAED;;;IAGG;QACH,KAAM,CAAA,SAAA,CAAA,MAAA,GAAN,UAAO,QAAgC,EAAA;IACnC,QAAA,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE;gBAChC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAClC,SAAA;SACJ,CAAA;QACJ,OAAA,KAAA,CAAA;IAAA,CAAA,EAAA;;ICpGD;;;;;;;IAOG;IACG,SAAU,SAAS,CAAI,MAAS,EAAA;;QAElC,IAAI,MAAM,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;IAC/C,QAAA,OAAO,MAAM,CAAC;IACjB,KAAA;;IAGD,IAAA,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YACvB,IAAM,WAAW,GAAG,EAAE,CAAC;IACvB,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBACpC,WAAW,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IACzC,SAAA;;;IAGD,QAAA,OAAO,WAAgB,CAAC;IAC3B,KAAA;;IAGD,IAAA,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;YAC5B,IAAM,YAAY,GAAwB,EAAE,CAAC;IAC7C,QAAA,KAAK,IAAM,GAAG,IAAI,MAAM,EAAE;;;IAGtB,YAAA,IAAI,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE;oBAC5B,YAAY,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9C,aAAA;IACJ,SAAA;;IAED,QAAA,OAAO,YAAiB,CAAC;IAC5B,KAAA;;IAGD,IAAA,OAAO,MAAM,CAAC;IAClB;;ICvCA;;;;;;;;IAQG;IACG,SAAU,aAAa,CAAC,OAAoB,EAAA;IAC9C,IAAA,OAAO,IAAIA,eAAU,CAAC,UAAC,QAAQ,EAAA;;IAE3B,QAAA,IAAM,cAAc,GAAG,IAAI,cAAc,CAAC,UAAC,OAAO,EAAA;IAC9C,YAAA,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC3B,SAAC,CAAC,CAAC;;IAEH,QAAA,cAAc,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;;YAEhC,OAAO,YAAA;;IAEH,YAAA,cAAc,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;;gBAElC,cAAc,CAAC,UAAU,EAAE,CAAC;IAChC,SAAC,CAAC;IACN,KAAC,CAAC,CAAC;IACP;;IC3BA;;IAEG;;;;;;;;;;;;;"}

package/directives/auth.directive.d.ts

@@ -10,14 +10,12 @@ export declare class RkAuthDirective implements OnDestroy {
      * @param condition
      */
     set rkAuth(condition: string | string[]);
-    set rkAuthThen(templateRef: TemplateRef<any> | null);
-    set rkAuthElse(templateRef: TemplateRef<any> | null);
+    set rkAuthThen(templateRef: TemplateRef<any>);
+    set rkAuthElse(templateRef: TemplateRef<any>);
     constructor(menu: RkMenuService, viewContainerRef: ViewContainerRef, templateRef: TemplateRef<any>);
     private condition;
-    private thenTemplateRef;
-    private elseTemplateRef;
-    private thenViewRef;
-    private elseViewRef;
+    private thenTemplateRef?;
+    private elseTemplateRef?;
     private authSubscription?;
     ngOnDestroy(): void;
     private updateView;

package/entity/annexCatalog/AnnexCatalogTypeEnum.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 附件类型枚举
+ */
+export declare enum AnnexCatalogTypeEnum {
+    /**
+     * 人员附件
+     */
+    PERSON = 0,
+    /**
+     * 单位附件
+     */
+    UNIT = 1,
+    /**
+     * 其他附件
+     */
+    OTHER = 2
+}

package/entity/annexCatalog/IAnnexCatalog.d.ts

@@ -0,0 +1,93 @@
+import { AnnexCatalogTypeEnum } from './AnnexCatalogTypeEnum';
+import { IEntityBase } from '@reskin/core/entity';
+/**
+ * 附件目录相关信息
+ */
+export interface IAnnexCatalog extends IEntityBase {
+    /**
+     * 附件描述
+     */
+    ANNEX_DESC: string;
+    /**
+     * 附件(目录)名称
+     */
+    ANNEX_NAME: string;
+    /**
+     * 附件类型
+     */
+    ANNEX_TYPE: AnnexCatalogTypeEnum;
+    /**
+     * 附件目录编码
+     */
+    ANNEX_CATALOG_ID: string;
+    /**
+     * 是否必须输入
+     */
+    ANNEX_IS_MUST_INPUT: boolean;
+    /**
+     * 附件标识符
+     */
+    ANNEX_IDENTIFIER: string;
+    /**
+     * 附件目录唯一标识
+     */
+    SYS_ANNEX_ID: string;
+}
+/**
+ * 附件信息
+ */
+export interface IAnnexInfo extends IEntityBase {
+    /**
+     * 附件类型
+     */
+    ANNEX_INFO_TYPE: AnnexCatalogTypeEnum;
+    /**
+     * 附件名称
+     */
+    ANNEX_INFO_NAME: string;
+    /**
+     * 附件大小
+     */
+    ANNEX_INFO_SIZE: number;
+    /**
+     * 附件后缀
+     */
+    ANNEX_INFO_EXT: string;
+    /**
+     * 附件路径
+     */
+    ANNEX_INFO_PATH?: string;
+    /**
+     * 附件文件编码
+     */
+    ANNEX_INFO_FILE_ID: string;
+    /**
+     * 附件标识 不同场景下的唯一编码
+     */
+    ANNEX_INFO_KEY_ID: string;
+    /**
+     * 附件标识 (用于删除附件）
+     */
+    SYS_ANNEX_INFO_ID?: string;
+    /**
+     * 附件目录标识
+     */
+    ANNEX_INFO_CATALOG_ID: string;
+    /**
+     * 关联单位标识
+     */
+    ANNEX_INFO_UNIT_ID?: string;
+}
+/**
+ * 批量上传附件参数
+ */
+export declare type IBatchParams = Pick<IAnnexInfo, 'ANNEX_INFO_KEY_ID' | 'ANNEX_INFO_CATALOG_ID'> & {
+    /**
+     * 附件列表
+     */
+    ANNEX_LIST: Array<Omit<IAnnexInfo, 'ANNEX_INFO_KEY_ID' | 'ANNEX_INFO_CATALOG_ID'>>;
+    /**
+     * 是否删除已有的附件信息
+     */
+    REMOVE_ANNEX_INFO?: boolean;
+};

package/entity/annexCatalog/package.json

@@ -0,0 +1,10 @@
+{
+  "main": "../../bundles/reskin-core-entity-annexCatalog.umd.js",
+  "module": "../../fesm2015/reskin-core-entity-annexCatalog.js",
+  "es2015": "../../fesm2015/reskin-core-entity-annexCatalog.js",
+  "esm2015": "../../esm2015/entity/annexCatalog/reskin-core-entity-annexCatalog.js",
+  "fesm2015": "../../fesm2015/reskin-core-entity-annexCatalog.js",
+  "typings": "reskin-core-entity-annexCatalog.d.ts",
+  "sideEffects": false,
+  "name": "@reskin/core/entity/annexCatalog"
+}

package/entity/annexCatalog/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './IAnnexCatalog';
+export * from './AnnexCatalogTypeEnum';

package/entity/annexCatalog/reskin-core-entity-annexCatalog.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@reskin/core/entity/annexCatalog" />
+export * from './public-api';

package/esm2015/classes/table.helper.js

@@ -32,4 +32,4 @@ export class RkTableHelper {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/directives/auth.directive.js

@@ -8,10 +8,6 @@ export class RkAuthDirective {
         this.viewContainerRef = viewContainerRef;
         this.templateRef = templateRef;
         this.condition = '';
-        this.thenTemplateRef = null;
-        this.elseTemplateRef = null;
-        this.thenViewRef = null;
-        this.elseViewRef = null;
         this.thenTemplateRef = templateRef;
     }
     /**
@@ -24,12 +20,10 @@ export class RkAuthDirective {
     }
     set rkAuthThen(templateRef) {
         this.thenTemplateRef = templateRef;
-        this.thenViewRef = null;
         this.updateView();
     }
     set rkAuthElse(templateRef) {
         this.elseTemplateRef = templateRef;
-        this.elseViewRef = null;
         this.updateView();
     }
     ngOnDestroy() {
@@ -43,12 +37,12 @@ export class RkAuthDirective {
             this.viewContainerRef.clear();
             if (context.status) {
                 if (this.thenTemplateRef) {
-                    this.thenViewRef = this.viewContainerRef.createEmbeddedView(this.thenTemplateRef, context);
+                    this.viewContainerRef.createEmbeddedView(this.thenTemplateRef, context);
                 }
             }
             else {
                 if (this.elseTemplateRef) {
-                    this.elseViewRef = this.viewContainerRef.createEmbeddedView(this.elseTemplateRef, context);
+                    this.viewContainerRef.createEmbeddedView(this.elseTemplateRef, context);
                 }
             }
         });
@@ -80,4 +74,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
             }], rkAuthElse: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/entity/annexCatalog/AnnexCatalogTypeEnum.js

@@ -0,0 +1,19 @@
+/**
+ * 附件类型枚举
+ */
+export var AnnexCatalogTypeEnum;
+(function (AnnexCatalogTypeEnum) {
+    /**
+     * 人员附件
+     */
+    AnnexCatalogTypeEnum[AnnexCatalogTypeEnum["PERSON"] = 0] = "PERSON";
+    /**
+     * 单位附件
+     */
+    AnnexCatalogTypeEnum[AnnexCatalogTypeEnum["UNIT"] = 1] = "UNIT";
+    /**
+     * 其他附件
+     */
+    AnnexCatalogTypeEnum[AnnexCatalogTypeEnum["OTHER"] = 2] = "OTHER";
+})(AnnexCatalogTypeEnum || (AnnexCatalogTypeEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQW5uZXhDYXRhbG9nVHlwZUVudW0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJyYXJ5L2NvcmUvZW50aXR5L2FubmV4Q2F0YWxvZy9Bbm5leENhdGFsb2dUeXBlRW51bS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBTixJQUFZLG9CQWFYO0FBYkQsV0FBWSxvQkFBb0I7SUFDNUI7O09BRUc7SUFDSCxtRUFBVSxDQUFBO0lBQ1Y7O09BRUc7SUFDSCwrREFBUSxDQUFBO0lBQ1I7O09BRUc7SUFDSCxpRUFBUyxDQUFBO0FBQ2IsQ0FBQyxFQWJXLG9CQUFvQixLQUFwQixvQkFBb0IsUUFhL0IiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICog6ZmE5Lu257G75Z6L5p6a5Li+XHJcbiAqL1xyXG5leHBvcnQgZW51bSBBbm5leENhdGFsb2dUeXBlRW51bSB7XHJcbiAgICAvKipcclxuICAgICAqIOS6uuWRmOmZhOS7tlxyXG4gICAgICovXHJcbiAgICBQRVJTT04gPSAwLFxyXG4gICAgLyoqXHJcbiAgICAgKiDljZXkvY3pmYTku7ZcclxuICAgICAqL1xyXG4gICAgVU5JVCA9IDEsXHJcbiAgICAvKipcclxuICAgICAqIOWFtuS7lumZhOS7tlxyXG4gICAgICovXHJcbiAgICBPVEhFUiA9IDIsXHJcbn1cclxuIl19

package/esm2015/entity/annexCatalog/IAnnexCatalog.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/entity/annexCatalog/public-api.js

@@ -0,0 +1,3 @@
+export * from './IAnnexCatalog';
+export * from './AnnexCatalogTypeEnum';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnJhcnkvY29yZS9lbnRpdHkvYW5uZXhDYXRhbG9nL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9JQW5uZXhDYXRhbG9nJztcclxuZXhwb3J0ICogZnJvbSAnLi9Bbm5leENhdGFsb2dUeXBlRW51bSc7XHJcbiJdfQ==

package/esm2015/entity/annexCatalog/reskin-core-entity-annexCatalog.js

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

package/esm2015/guards/auth.guard.js

@@ -50,4 +50,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
                     providedIn: 'root',
                 }]
         }], ctorParameters: function () { return [{ type: i1.RkMenuService }, { type: i2.Router }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/interceptors/blob.interceptor.js

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

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,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGUuaW50ZXJjZXB0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJyYXJ5L2NvcmUvaW50ZXJjZXB0b3JzL2NhY2hlLmludGVyY2VwdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUF3RCxpQkFBaUIsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRS9HLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQzs7O0FBSTdDLE1BQU0sT0FBTyxnQkFBZ0I7SUFDekIsWUFBb0IsU0FBNkI7UUFBN0IsY0FBUyxHQUFULFNBQVMsQ0FBb0I7SUFBRyxDQUFDO0lBRXJELFNBQVMsQ0FBQyxPQUE2QixFQUFFLElBQWlCO1FBQ3RELFdBQVc7UUFDWCxpQ0FBaUM7UUFDakMsTUFBTSxRQUFRLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDbEQsSUFBSSxPQUFPLENBQUMsTUFBTSxLQUFLLEtBQUssSUFBSSxRQUFRLEtBQUssU0FBUyxFQUFFO1lBQ3BELElBQUksUUFBUSxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUMvQyxJQUFJLENBQUMsUUFBUSxFQUFFO2dCQUNYLFFBQVEsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztnQkFDckQsSUFBSSxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLEdBQUcsRUFBRSxRQUFRLENBQUMsQ0FBQzthQUM3QztZQUNELE9BQU8sUUFBUSxDQUFDO1NBQ25CO1FBQ0QsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ2hDLENBQUM7OzhHQWhCUSxnQkFBZ0I7a0hBQWhCLGdCQUFnQjs0RkFBaEIsZ0JBQWdCO2tCQUQ1QixVQUFVOztBQW9CWDs7R0FFRztBQUNILE1BQU0sVUFBVSxpQkFBaUI7SUFDN0IsT0FBTyxFQUFFLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxRQUFRLEVBQUUsZ0JBQWdCLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRSxDQUFDO0FBQ25GLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IEh0dHBSZXF1ZXN0LCBIdHRwSGFuZGxlciwgSHR0cEV2ZW50LCBIdHRwSW50ZXJjZXB0b3IsIEhUVFBfSU5URVJDRVBUT1JTIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xyXG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XHJcbmltcG9ydCB7IHNoYXJlUmVwbGF5IH0gZnJvbSAncnhqcy9vcGVyYXRvcnMnO1xyXG5pbXBvcnQgeyBSa0NhY2hlSHR0cFNlcnZpY2UgfSBmcm9tICdAcmVza2luL2NvcmUvc2VydmljZXMnO1xyXG5cclxuQEluamVjdGFibGUoKVxyXG5leHBvcnQgY2xhc3MgQ2FjaGVJbnRlcmNlcHRvciBpbXBsZW1lbnRzIEh0dHBJbnRlcmNlcHRvciB7XHJcbiAgICBjb25zdHJ1Y3Rvcihwcml2YXRlIGNhY2hlSHR0cDogUmtDYWNoZUh0dHBTZXJ2aWNlKSB7fVxyXG5cclxuICAgIGludGVyY2VwdChyZXF1ZXN0OiBIdHRwUmVxdWVzdDx1bmtub3duPiwgbmV4dDogSHR0cEhhbmRsZXIpOiBPYnNlcnZhYmxlPEh0dHBFdmVudDx1bmtub3duPj4ge1xyXG4gICAgICAgIC8vIDEu5Yik5pat5pivR0VUXHJcbiAgICAgICAgLy8gMi5oZWFkZXLkuK3mt7vliqAgQ2FjaGUtTWFwOiBTdG9yYWdlXHJcbiAgICAgICAgY29uc3QgY2FjaGVNYXAgPSByZXF1ZXN0LmhlYWRlcnMuZ2V0KCdDYWNoZS1NYXAnKTtcclxuICAgICAgICBpZiAocmVxdWVzdC5tZXRob2QgPT09ICdHRVQnICYmIGNhY2hlTWFwID09PSAnU3RvcmFnZScpIHtcclxuICAgICAgICAgICAgbGV0IHJlc3BvbnNlID0gdGhpcy5jYWNoZUh0dHAuZ2V0KHJlcXVlc3QudXJsKTtcclxuICAgICAgICAgICAgaWYgKCFyZXNwb25zZSkge1xyXG4gICAgICAgICAgICAgICAgcmVzcG9uc2UgPSBuZXh0LmhhbmRsZShyZXF1ZXN0KS5waXBlKHNoYXJlUmVwbGF5KDEpKTtcclxuICAgICAgICAgICAgICAgIHRoaXMuY2FjaGVIdHRwLnNldChyZXF1ZXN0LnVybCwgcmVzcG9uc2UpO1xyXG4gICAgICAgICAgICB9XHJcbiAgICAgICAgICAgIHJldHVybiByZXNwb25zZTtcclxuICAgICAgICB9XHJcbiAgICAgICAgcmV0dXJuIG5leHQuaGFuZGxlKHJlcXVlc3QpO1xyXG4gICAgfVxyXG59XHJcblxyXG4vKipcclxuICogR0VU6K+35rGC57yT5a2Y5oum5oiq5ZmoXHJcbiAqL1xyXG5leHBvcnQgZnVuY3Rpb24gcHJvdmlkZXJIdHRwQ2FjaGUoKSB7XHJcbiAgICByZXR1cm4geyBwcm92aWRlOiBIVFRQX0lOVEVSQ0VQVE9SUywgdXNlQ2xhc3M6IENhY2hlSW50ZXJjZXB0b3IsIG11bHRpOiB0cnVlIH07XHJcbn1cclxuIl19

package/esm2015/interceptors/error.interceptor.js

@@ -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/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,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/services/annex.catalog.service.js

@@ -0,0 +1,107 @@
+import { Injectable } from '@angular/core';
+import { AnnexCatalogTypeEnum } from '@reskin/core/entity/annexCatalog';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class RkAnnexCatalogService {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * 查询当前附件目录下的所有附件列表
+     *
+     * 本函数通过调用后端API来获取特定标识符的附件目录列表它主要用于从服务器动态加载附件信息
+     * 而不是在前端代码中硬编码这些信息这样做允许应用程序更加灵活地处理附件数据
+     *
+     * @param identifier 用于标识附件目录的唯一键这个值通常来源于用户选择或系统配置
+     * 它作为请求参数被发送到服务器，以便服务器可以根据这个标识符找到对应的附件目录信息
+     *
+     * @returns 返回一个Observable，它将发出一个包含附件目录信息的数组
+     * 这个返回值类型被定义为`R<Array<IAnnexCatalog>>`，其中`R`通常是一个结果包装类型，可能包含
+     * 状态信息和服务器返回的数据`Array<IAnnexCatalog>`表示一个IAnnexCatalog对象的数组，
+     * 每个对象代表一个附件目录条目
+     *
+     * 注意：这个函数依赖于外部HTTP服务（由`this.http.post`调用），因此它可能受到网络状况、服务器
+     * 状态和API端点可用性的影响在调用这个函数时，应该考虑到错误处理和用户反馈
+     */
+    requestChildren(identifier) {
+        const url = 'api/gl-service-sys-core/v1/core/system/annex/selectSchemeByIdentifier';
+        return this.http.post(url, { ANNEX_IDENTIFIER: identifier });
+    }
+    /**
+     * 查询当前附件目录信息
+     *
+     * 本函数通过调用后端API，根据附件标识符(identifier)来获取特定的附件目录信息
+     * 使用Http客户端发起一个POST请求到指定的URL，携带包含附件标识符的请求体
+     *
+     * @param identifier 附件标识符，用于标识特定的附件目录
+     * @returns 返回一个Observable，它将发出类型为R<IAnnexCatalog>的结果，其中R是响应类型，IAnnexCatalog是附件目录的信息类型
+     */
+    requestData(identifier) {
+        const url = 'api/gl-service-sys-core/v1/core/system/annex/selectOneByIdentifier';
+        return this.http.post(url, { ANNEX_IDENTIFIER: identifier });
+    }
+    /**
+     * 新增附件在指定目录下
+     *
+     * 该方法通过HTTP POST请求向系统发送附件目录信息插入操作它使用特定的API端点来完成插入操作
+     *
+     * @param params 要插入的附件目录信息，符合IAnnexInfo接口的参数这包含了插入操作所需的所有必要信息
+     * @returns 返回一个Observable，它将发出一个R类型的响应，该响应包含操作成功与否的信息以及可能的服务器响应数据
+     */
+    requestAnnexInsert(params) {
+        const url = 'api/gl-service-sys-core/v1/core/system/annex/info/insert';
+        return this.http.post(url, params);
+    }
+    /**
+     * 批量新增附件在指定目录下
+     *
+     * 该方法用于将一组附件目录信息插入到系统中它封装了一个HTTP POST请求，发送到预定义的API端点
+     * 使用RxJS的Observable来处理异步操作和错误处理，这样的设计使得调用者可以使用链式操作处理响应
+     *
+     * @param params 包含要插入的附件目录信息的批量参数对象，符合IBatchParams接口的定义
+     * @returns 返回一个Observable，其结果是一个R类型的数组，每个元素都是IAnnexInfo接口的实例
+     * 表示系统中成功插入的附件目录信息
+     */
+    requestAnnexBatchInsert(params) {
+        const url = 'api/gl-service-sys-core/v1/core/system/annex/info/batchInsert';
+        return this.http.post(url, params);
+    }
+    /**
+     * 通过附件目录查询附件列表
+     *
+     * 此方法用于根据附件的关键ID、目录ID和类型来请求附件列表
+     * 它构建了请求URL并使用HTTP POST方法来发送请求，包括附件的关键ID、目录ID和类型作为请求参数
+     *
+     * @param ANNEX_INFO_KEY_ID 附件的关键ID这是识别附件的重要标识符
+     * @param ANNEX_INFO_CATALOG_ID 附件的目录ID用于确定附件在目录中的位置
+     * @param ANNEX_INFO_TYPE 附件的类型，默认为个人类型这影响返回的附件列表范围
+     * @returns 返回一个Observable，它将发出数组类型的附件目录信息这是异步操作的结果
+     */
+    requestAnnexList(ANNEX_INFO_KEY_ID, ANNEX_INFO_CATALOG_ID, ANNEX_INFO_TYPE = AnnexCatalogTypeEnum.PERSON) {
+        const url = 'api/gl-service-sys-core/v1/core/system/annex/info/selectListAnnexById';
+        return this.http.post(url, { ANNEX_INFO_KEY_ID, ANNEX_INFO_CATALOG_ID, ANNEX_INFO_TYPE });
+    }
+    /**
+     * 在附件目录下删除附件
+     *
+     * 此方法通过发送HTTP POST请求到指定的API端点，请求删除系统附件信息
+     * 主要用于UI或其他服务调用，以实现附件信息的删除功能
+     *
+     * @param SYS_ANNEX_INFO_ID 附件信息的唯一标识符，标识要删除的附件
+     * @returns 返回一个Observable，其内容为一个R类型的结果，包含布尔值
+     *          布尔值表示附件删除操作是否成功
+     */
+    requestAnnexDelete(SYS_ANNEX_INFO_ID) {
+        const url = 'api//gl-service-sys-core/v1/core/system/annex/info/delete';
+        return this.http.post(url, { SYS_ANNEX_INFO_ID });
+    }
+}
+RkAnnexCatalogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkAnnexCatalogService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+RkAnnexCatalogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkAnnexCatalogService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RkAnnexCatalogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"annex.catalog.service.js","sourceRoot":"","sources":["../../../../library/core/services/annex.catalog.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI3C,OAAO,EAAE,oBAAoB,EAA2C,MAAM,kCAAkC,CAAC;;;AAKjH,MAAM,OAAO,qBAAqB;IAC9B,YAAoB,IAAgB;QAAhB,SAAI,GAAJ,IAAI,CAAY;IAAG,CAAC;IAExC;;;;;;;;;;;;;;;;OAgBG;IACH,eAAe,CAAC,UAAkB;QAC9B,MAAM,GAAG,GAAG,uEAAuE,CAAC;QACpF,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAI,GAAG,EAAE,EAAE,gBAAgB,EAAE,UAAU,EAAE,CAAC,CAAC;IACpE,CAAC;IAED;;;;;;;;OAQG;IACH,WAAW,CAAC,UAAkB;QAC1B,MAAM,GAAG,GAAG,oEAAoE,CAAC;QACjF,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAI,GAAG,EAAE,EAAE,gBAAgB,EAAE,UAAU,EAAE,CAAC,CAAC;IACpE,CAAC;IAED;;;;;;;OAOG;IACH,kBAAkB,CAAC,MAAkB;QACjC,MAAM,GAAG,GAAG,0DAA0D,CAAC;QACvE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAI,GAAG,EAAE,MAAM,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;;;;;OASG;IACH,uBAAuB,CAAC,MAAoB;QACxC,MAAM,GAAG,GAAG,+DAA+D,CAAC;QAC5E,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAI,GAAG,EAAE,MAAM,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;;;;;;OAUG;IACH,gBAAgB,CACZ,iBAAyB,EACzB,qBAA6B,EAC7B,kBAAwC,oBAAoB,CAAC,MAAM;QAEnE,MAAM,GAAG,GAAG,uEAAuE,CAAC;QACpF,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAI,GAAG,EAAE,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,eAAe,EAAE,CAAC,CAAC;IACjG,CAAC;IAED;;;;;;;;;OASG;IACH,kBAAkB,CAAC,iBAAyB;QACxC,MAAM,GAAG,GAAG,2DAA2D,CAAC;QACxE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAI,GAAG,EAAE,EAAE,iBAAiB,EAAE,CAAC,CAAC;IACzD,CAAC;;mHApGQ,qBAAqB;uHAArB,qBAAqB,cAFlB,MAAM;4FAET,qBAAqB;kBAHjC,UAAU;mBAAC;oBACR,UAAU,EAAE,MAAM;iBACrB","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { R } from '@reskin/core/entity';\r\nimport { Observable } from 'rxjs';\r\nimport { AnnexCatalogTypeEnum, IAnnexCatalog, IAnnexInfo, IBatchParams } from '@reskin/core/entity/annexCatalog';\r\n\r\n@Injectable({\r\n    providedIn: 'root',\r\n})\r\nexport class RkAnnexCatalogService {\r\n    constructor(private http: HttpClient) {}\r\n\r\n    /**\r\n     * 查询当前附件目录下的所有附件列表\r\n     *\r\n     * 本函数通过调用后端API来获取特定标识符的附件目录列表它主要用于从服务器动态加载附件信息\r\n     * 而不是在前端代码中硬编码这些信息这样做允许应用程序更加灵活地处理附件数据\r\n     *\r\n     * @param identifier 用于标识附件目录的唯一键这个值通常来源于用户选择或系统配置\r\n     * 它作为请求参数被发送到服务器，以便服务器可以根据这个标识符找到对应的附件目录信息\r\n     *\r\n     * @returns 返回一个Observable，它将发出一个包含附件目录信息的数组\r\n     * 这个返回值类型被定义为`R<Array<IAnnexCatalog>>`，其中`R`通常是一个结果包装类型，可能包含\r\n     * 状态信息和服务器返回的数据`Array<IAnnexCatalog>`表示一个IAnnexCatalog对象的数组，\r\n     * 每个对象代表一个附件目录条目\r\n     *\r\n     * 注意：这个函数依赖于外部HTTP服务（由`this.http.post`调用），因此它可能受到网络状况、服务器\r\n     * 状态和API端点可用性的影响在调用这个函数时，应该考虑到错误处理和用户反馈\r\n     */\r\n    requestChildren(identifier: string): Observable<R<Array<IAnnexCatalog>>> {\r\n        const url = 'api/gl-service-sys-core/v1/core/system/annex/selectSchemeByIdentifier';\r\n        return this.http.post<R>(url, { ANNEX_IDENTIFIER: identifier });\r\n    }\r\n\r\n    /**\r\n     * 查询当前附件目录信息\r\n     *\r\n     * 本函数通过调用后端API，根据附件标识符(identifier)来获取特定的附件目录信息\r\n     * 使用Http客户端发起一个POST请求到指定的URL，携带包含附件标识符的请求体\r\n     *\r\n     * @param identifier 附件标识符，用于标识特定的附件目录\r\n     * @returns 返回一个Observable，它将发出类型为R<IAnnexCatalog>的结果，其中R是响应类型，IAnnexCatalog是附件目录的信息类型\r\n     */\r\n    requestData(identifier: string): Observable<R<IAnnexCatalog>> {\r\n        const url = 'api/gl-service-sys-core/v1/core/system/annex/selectOneByIdentifier';\r\n        return this.http.post<R>(url, { ANNEX_IDENTIFIER: identifier });\r\n    }\r\n\r\n    /**\r\n     * 新增附件在指定目录下\r\n     *\r\n     * 该方法通过HTTP POST请求向系统发送附件目录信息插入操作它使用特定的API端点来完成插入操作\r\n     *\r\n     * @param params 要插入的附件目录信息，符合IAnnexInfo接口的参数这包含了插入操作所需的所有必要信息\r\n     * @returns 返回一个Observable，它将发出一个R类型的响应，该响应包含操作成功与否的信息以及可能的服务器响应数据\r\n     */\r\n    requestAnnexInsert(params: IAnnexInfo): Observable<R<IAnnexInfo>> {\r\n        const url = 'api/gl-service-sys-core/v1/core/system/annex/info/insert';\r\n        return this.http.post<R>(url, params);\r\n    }\r\n\r\n    /**\r\n     * 批量新增附件在指定目录下\r\n     *\r\n     * 该方法用于将一组附件目录信息插入到系统中它封装了一个HTTP POST请求，发送到预定义的API端点\r\n     * 使用RxJS的Observable来处理异步操作和错误处理，这样的设计使得调用者可以使用链式操作处理响应\r\n     *\r\n     * @param params 包含要插入的附件目录信息的批量参数对象，符合IBatchParams接口的定义\r\n     * @returns 返回一个Observable，其结果是一个R类型的数组，每个元素都是IAnnexInfo接口的实例\r\n     * 表示系统中成功插入的附件目录信息\r\n     */\r\n    requestAnnexBatchInsert(params: IBatchParams): Observable<R<Array<IAnnexInfo>>> {\r\n        const url = 'api/gl-service-sys-core/v1/core/system/annex/info/batchInsert';\r\n        return this.http.post<R>(url, params);\r\n    }\r\n\r\n    /**\r\n     * 通过附件目录查询附件列表\r\n     *\r\n     * 此方法用于根据附件的关键ID、目录ID和类型来请求附件列表\r\n     * 它构建了请求URL并使用HTTP POST方法来发送请求，包括附件的关键ID、目录ID和类型作为请求参数\r\n     *\r\n     * @param ANNEX_INFO_KEY_ID 附件的关键ID这是识别附件的重要标识符\r\n     * @param ANNEX_INFO_CATALOG_ID 附件的目录ID用于确定附件在目录中的位置\r\n     * @param ANNEX_INFO_TYPE 附件的类型，默认为个人类型这影响返回的附件列表范围\r\n     * @returns 返回一个Observable，它将发出数组类型的附件目录信息这是异步操作的结果\r\n     */\r\n    requestAnnexList(\r\n        ANNEX_INFO_KEY_ID: string,\r\n        ANNEX_INFO_CATALOG_ID: string,\r\n        ANNEX_INFO_TYPE: AnnexCatalogTypeEnum = AnnexCatalogTypeEnum.PERSON,\r\n    ): Observable<R<Array<IAnnexInfo>>> {\r\n        const url = 'api/gl-service-sys-core/v1/core/system/annex/info/selectListAnnexById';\r\n        return this.http.post<R>(url, { ANNEX_INFO_KEY_ID, ANNEX_INFO_CATALOG_ID, ANNEX_INFO_TYPE });\r\n    }\r\n\r\n    /**\r\n     * 在附件目录下删除附件\r\n     *\r\n     * 此方法通过发送HTTP POST请求到指定的API端点，请求删除系统附件信息\r\n     * 主要用于UI或其他服务调用，以实现附件信息的删除功能\r\n     *\r\n     * @param SYS_ANNEX_INFO_ID 附件信息的唯一标识符，标识要删除的附件\r\n     * @returns 返回一个Observable，其内容为一个R类型的结果，包含布尔值\r\n     *          布尔值表示附件删除操作是否成功\r\n     */\r\n    requestAnnexDelete(SYS_ANNEX_INFO_ID: string): Observable<R<boolean>> {\r\n        const url = 'api//gl-service-sys-core/v1/core/system/annex/info/delete';\r\n        return this.http.post<R>(url, { SYS_ANNEX_INFO_ID });\r\n    }\r\n}\r\n"]}