@reskin/core 0.0.1 → 0.0.3

package/bundles/reskin-core-services.umd.js

@@ -513,7 +513,11 @@
           this.title = title;
       }
       /**
-       * 加载配置
+       * 异步加载配置数据
+       * 通过调用API端点获取系统参数，解析并应用这些参数
+       * 如果获取参数失败或参数不正确，则抛出错误
+       *
+       * @returns {Promise<WC>} 返回配置数据的Promise
        */
       AppConfig.prototype.onLoad = function () {
           return __awaiter(this, void 0, void 0, function () {
@@ -528,13 +532,18 @@
                           return [4 /*yield*/, response.json()];
                       case 2:
                           json = _a.sent();
+                          // 检查响应码，如果不为0，则抛出错误
                           if (json.code !== 0) {
                               throw new Error(json.msg);
                           }
                           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 [2 /*return*/, config];
                   }
               });
@@ -556,41 +565,56 @@
                       }] }, { type: i1__namespace.Title }];
       } });
   /**
-   * 项目初始化配置
-   * @param environment
+   * 配置应用的提供者和初始化函数
+   *
+   * 此函数用于配置应用程序的提供者和服务初始化逻辑它通过依赖注入机制，
+   * 将环境配置和应用配置对象提供给应用，并在应用启动时执行一个加载函数
+   *
+   * @param environment 应用环境的配置对象，包含运行时的各种环境变量和配置
+   * @returns 返回一个包含提供者配置的数组，用于 AppModule 的提供者列表
    */
   function providerAppConfig(environment) {
       return [
+          // 提供环境配置的提供者，将环境对象作为值提供给 RK_ENVIRONMENT 令牌
           { provide: RK_ENVIRONMENT, useValue: environment },
+          // 将 AppConfig 服务本身作为提供者
           AppConfig,
+          // 配置 APP_INITIALIZER 提供者，使用工厂函数在应用启动时调用 appConfig 的 onLoad 方法
+          // 这允许在应用启动完成后执行一些初始化逻辑
           {
               provide: i0.APP_INITIALIZER,
               useFactory: function (appConfig) { return function () { return appConfig.onLoad(); }; },
               deps: [AppConfig],
-              multi: true,
+              multi: true, // 标记此初始化函数为多值，可以有多个初始化函数
           },
       ];
   }
 
+  // RkAuthService 提供了与用户认证相关的服务
   var RkAuthService = /** @class */ (function () {
+      // 构造函数，注入环境配置和HTTP客户端
       function RkAuthService(env, http) {
           this.env = env;
           this.http = http;
+          // auth 存储认证信息
           this.auth = new utils.Store('auth', {});
       }
       /**
        * 系统登录
        * @param data 验证信息
-       * @returns
+       * @returns 登录结果
        */
       RkAuthService.prototype.onLogin = function (data) {
           var _this = this;
           var url = 'api/gl-service-sys-user/v1/user/system/auth/login';
+          // 设置请求头，包含项目类型和无令牌控制信息
           var headers = new i1$1.HttpHeaders({
               'ProjectNo': this.env.config.PROJECT_TYPE,
               'Token-Control': 'no-token',
           });
+          // 发送POST请求，并在成功后处理响应
           return this.http.post(url, { data: data }, { headers: headers }).pipe(operators.tap(function (json) {
+              // 如果代码为0，表示登录成功，存储认证信息
               if (json.code === 0) {
                   _this.auth.set(json.data);
               }
@@ -601,13 +625,16 @@
        */
       RkAuthService.prototype.onLogout = function () {
           var url = 'api/gl-service-sys-user/v1/user/system/auth/logoutByAuthId';
+          // 发送POST请求，使用当前的AUTH_ID进行注销
           return this.http.post(url, { AUTH_ID: this.token.id });
       };
       Object.defineProperty(RkAuthService.prototype, "token", {
           /**
            * 获得 token
+           * @returns 当前用户的认证信息
            */
           get: function () {
+              // 获取存储的认证信息
               return this.auth.get();
           },
           enumerable: false,
@@ -630,13 +657,18 @@
       } });
 
   var RkAccountService = /** @class */ (function () {
-      function RkAccountService(http, auth) {
+      function RkAccountService(http, // HttpClient实例用于发送HTTP请求
+      auth) {
           this.http = http;
           this.auth = auth;
+          // 定义一个Store实例用于存储用户认证信息
           this.account = new utils.Store('account', {});
       }
       /**
        * 加载人员权限
+       *
+       * 本方法通过发送HTTP POST请求来加载当前认证用户的权限数据，
+       * 如果请求成功，将权限数据存储在account Store实例中
        */
       RkAccountService.prototype.onLoadAuth = function () {
           var _this = this;
@@ -651,6 +683,8 @@
       Object.defineProperty(RkAccountService.prototype, "userInfo", {
           /**
            * 获得账号基本信息
+           *
+           * @returns {IAccountProfile} 返回当前账号的基本信息对象
            */
           get: function () {
               return this.account.get().UserInfo;
@@ -661,6 +695,8 @@
       Object.defineProperty(RkAccountService.prototype, "personnelPool", {
           /**
            * 获得账号人员库权限
+           *
+           * @returns {IAuthPersonnelPool} 返回当前账号的人员库权限对象
            */
           get: function () {
               return this.account.get().AuthPersonnelPool;
@@ -671,6 +707,8 @@
       Object.defineProperty(RkAccountService.prototype, "workflowAuth", {
           /**
            * 获得账号业务权限
+           *
+           * @returns {IAuthWorkflow} 返回当前账号的业务权限对象
            */
           get: function () {
               return this.account.get().AuthWfId;
@@ -681,6 +719,8 @@
       Object.defineProperty(RkAccountService.prototype, "authOrgGroup", {
           /**
            * 获得账号机构分组权限
+           *
+           * @returns {Array<IAuthOrgGroup>} 返回当前账号的机构分组权限数组
            */
           get: function () {
               return this.account.get().AuthOrgGroup;
@@ -704,29 +744,42 @@
           this.cache = new Map();
       }
       /**
-       * 获得已缓存的请求
-       * @param url GET请求地址
+       * 从缓存中获取指定URL的HTTP响应
+       *
+       * 此方法尝试从缓存中获取与指定URL相关的HTTP响应如果缓存中存在相应的响应，则返回该响应，否则返回未定义（undefined）
+       * 它避免了不必要的网络请求，从而提高应用的性能
+       *
+       * @param url 要从缓存中获取的资源的URL
+       * @returns 返回一个Observable对象，该对象发出未知类型的HTTP事件，或者在缓存中未找到时返回未定义
        */
       RkCacheHttpService.prototype.get = function (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对象，包含响应数据和状态
        */
       RkCacheHttpService.prototype.set = function (url, response) {
           this.cache.set(url, response);
       };
       /**
-       * 删除指定已缓存的请求
-       * @param url GET请求地址
+       * 删除指定的URL对应的缓存
+       *
+       * 本方法通过URL作为键，从缓存中删除对应的缓存项它使用了`cache.delete`方法来实现缓存的删除操作
+       *
+       * @param url {string} - 需要删除缓存的URL地址
        */
       RkCacheHttpService.prototype.delete = function (url) {
           this.cache.delete(url);
       };
       /**
-       * 删除所有已缓存的请求
+       * 清除缓存
+       *
+       * 该方法清空当前实例的缓存
        */
       RkCacheHttpService.prototype.clear = function () {
           this.cache.clear();
@@ -742,42 +795,66 @@
                   }]
           }] });
   /**
-   * 设置为缓存请求
+   * 生成带有缓存策略的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'头部
    */
   function CacheHttpTemplate(urls) {
       var params = [];
       for (var _i = 1; _i < arguments.length; _i++) {
           params[_i - 1] = arguments[_i];
       }
+      // 初始化URL为模板字符串数组的第一个元素
       var _a = __read(urls, 1), url = _a[0];
+      // 如果参数数组非空，则使用模板字符串和参数数组构建最终的URL
       if (params.length > 0) {
           url = String.raw.apply(String, __spreadArray([urls], __read(params)));
       }
+      // 返回构建好的URL和带有缓存策略的头部信息
       return [url, { headers: new i1$1.HttpHeaders({ 'Cache-Map': 'Storage' }) }];
   }
 
+  // 通过@Injectable装饰器指定RkMenuService可以被Angular的依赖注入系统提供和使用
+  // RkMenuService类用于处理系统导航菜单相关的业务逻辑
   var RkMenuService = /** @class */ (function () {
+      // 构造函数，注入HttpClient实例用于发送HTTP请求
       function RkMenuService(http) {
           this.http = http;
+          // AppConfig.settings存储了应用程序的配置信息
           this.appSettings = AppConfig.settings;
       }
       /**
        * 获得系统导航列表
+       *
+       * 通过HTTP GET请求从后端获取系统导航数据，返回一个Observable对象
+       *
+       * @returns Observable<R<Array<IMenu>>> 包含导航菜单数据的Observable对象
        */
       RkMenuService.prototype.requestData = function () {
           var _a;
+          // 定义请求的URL
           var url = 'api/gl-service-sys-core/v1/core/system/resource/tree/selectListNav';
+          // 发送HTTP GET请求，并使用tap操作符对返回的数据进行处理
           return (_a = this.http).get.apply(_a, __spreadArray([], __read(CacheHttpTemplate(templateObject_1$3 || (templateObject_1$3 = __makeTemplateObject(["", "/", ""], ["", "/", ""])), url, this.appSettings.servers.RESOURCE_GROUP_ID)))).pipe(operators.tap(function (json) {
+              // 检查返回的状态码，如果不为0，则不处理
               if (json.code !== 0) {
-                  throw new Error("\u83B7\u5F97\u7CFB\u7EDF\u5BFC\u822A\u5217\u8868 " + url + " \u51FA\u73B0\u9519\u8BEF: " + json.msg);
+                  return;
               }
+              // 提取导航菜单数据
               var menus = json.data;
-              menus.forEach(function (menu) {
-                  menu.children = menus.filter(function (v) { return menu.SYSTEM_RESOURCE_TREE_ID === v.SYS_PARENT; }) || [];
-              });
+              // 如果导航菜单为空，输出错误信息
+              if (menus.length) { // 处理返回的菜单数据，为每个菜单添加子菜单属性
+                  menus.forEach(function (menu) {
+                      menu.children = menus.filter(function (v) { return menu.SYSTEM_RESOURCE_TREE_ID === v.SYS_PARENT; }) || [];
+                  });
+              }
           }));
       };
       return RkMenuService;
@@ -797,9 +874,12 @@
           this.http = http;
       }
       /**
-       * 使用GET方法下载文件
-       * @param url 请求链接; url可以传递自定义文件名优先级最高;如：api/file/down?fileName=身份证.jpg
-       * @param params 请求参数
+       * 使用HTTP GET方法发送请求，以获取Blob类型的响应
+       * 此方法主要用于处理需要二进制响应的请求，如文件下载等
+       *
+       * @param url 请求的URL，必须提供，url可以传递自定义文件名优先级最高;如：api/file/down?fileName=身份证.jpg
+       * @param params 可选的查询参数，将作为URL查询字符串发送
+       * @returns 返回一个Observable，它发出HttpResponse对象，包含Blob类型的响应体
        */
       RkDownFileService.prototype.get = function (url, params) {
           var _this = this;
@@ -808,9 +888,14 @@
               .pipe(operators.tap(function (response) { return _this.handleResponse(response, url); }));
       };
       /**
-       * 使用POST方法下载文件
-       * @param url 请求链接; url可以传递自定义文件名优先级最高;如：api/file/down?fileName=身份证.jpg
-       * @param params 请求参数
+       * 发起POST请求下载数据
+       *
+       * 本函数用于向指定URL发起POST请求，并期望返回二进制数据（如文件等）
+       * 使用场景包括但不限于文件下载等需要获取原始二进制数据的操作
+       *
+       * @param url 请求的URL，必须提供，url可以传递自定义文件名优先级最高;如：api/file/down?fileName=身份证.jpg
+       * @param params 请求的参数，可以是任意类型的数据，会作为请求体发送
+       * @returns 返回一个Observable，其类型参数为HttpResponse<Blob>，表示服务器的响应
        */
       RkDownFileService.prototype.post = function (url, params) {
           var _this = this;
@@ -875,9 +960,15 @@
           this.http = http;
       }
       /**
-       * 获得人员照片静态路径
-       * @param fileId 文件编码
-       * @param fileName 文件名称
+       * 构建静态人员照片的URL
+       *
+       * 该方法用于根据文件ID构建访问静态图片的URL如果提供了文件名，
+       * 则将其作为查询参数附加到URL上这个函数主要用于前端展示静态图片，
+       * 通过传入文件的唯一标识符（fileId）和可选的文件名来确保图片的正确加载
+       *
+       * @param fileId 图片文件的唯一标识符，用于定位具体的图片资源
+       * @param fileName 可选参数，图片文件的名称如果提供，将作为查询参数附加到URL上
+       * @returns 返回构建的静态图片URL
        */
       RkFileService.prototype.staticPhotoUrl = function (fileId, fileName) {
           var url = "api/gl-file-service/static/photo/" + fileId;
@@ -887,31 +978,68 @@
           return url;
       };
       /**
-       * 上传人员照片
-       * @param data 文件
+       * 上传图片
+       *
+       * 该方法用于将图片文件上传到服务器它封装了HTTP POST请求，发送FormData对象到指定的API端点
+       * 主要用于用户头像的上传操作
+       *
+       * @param data FormData对象，包含了需要上传的文件以及其他可能的表单数据
+       * @returns 返回一个Observable对象，其类型参数为R<IUploadFileData>，表示上传操作的结果
        */
       RkFileService.prototype.photoUpload = function (data) {
           var url = 'api/gl-file-service/photo/upload';
           return this.http.post(url, data);
       };
       /**
-       * 获得附件静态路径
-       * @param fileId 文件编码
-       * @param fileName 文件名称
+       * 构建静态文件的URL地址
+       *
+       * 本函数用于根据文件ID和可选的文件名构建访问静态文件的URL地址
+       * 如果提供了文件名，将会将其编码并附加到URL上，以便在访问时可以直接下载文件
+       *
+       * @param fileId 文件的唯一标识符，用于定位具体文件
+       * @param fileName 可选参数，文件的名称如果提供此参数，将会在URL中进行编码后附加
+       * @returns 返回构建好的静态文件URL地址
        */
       RkFileService.prototype.staticFileUrl = function (fileId, fileName) {
+          // 初始化URL，指向文件服务的静态附件访问路径
           var url = "api/gl-file-service/static/attachment/" + fileId;
+          // 如果提供了文件名，则进行编码并追加到URL中
           if (fileName) {
               url += "?fileName=" + encodeURI(fileName);
           }
+          // 返回最终构建好的URL
           return url;
       };
       /**
-       * 上传附件
-       * @param data 文件
+       * 上传文件
+       *
+       * 此方法用于将文件数据上传到服务器它封装了HTTP POST请求，用于文件上传服务
+       * 使用FormData对象来构建需要上传的文件数据
+       *
+       * @param data FormData对象，包含了需要上传的文件数据
+       * @returns 返回一个Observable对象，它发出包含上传结果数据的动作
        */
       RkFileService.prototype.fileUpload = function (data) {
+          // 定义上传文件的API URL
           var url = 'api/gl-file-service/attachment/upload';
+          // 调用HTTP POST方法进行文件上传
+          return this.http.post(url, data);
+      };
+      /**
+       * 批量上传文件
+       *
+       * 该方法负责将一组文件作为FormData发送到服务器进行批量上传
+       * 主要用于处理大量文件上传的情况，提高效率和用户体验
+       *
+       * @param data FormData对象，包含了需要上传的文件数据
+       *                这个对象通常由前端表单生成，包含了多个文件
+       * @returns 返回一个Observable对象，它发出一个结果类型为R<IUploadFileData[]>的响应
+       *             这个响应包含了上传结果的详细信息，包括成功与否，文件信息等
+       *
+       * 注意：该方法依赖于后端提供的文件上传服务，URL路径为'api/gl-file-service/attachment/batchUpload'
+       */
+      RkFileService.prototype.batchUpload = function (data) {
+          var url = 'api/gl-file-service/attachment/batchUpload';
           return this.http.post(url, data);
       };
       return RkFileService;
@@ -925,6 +1053,7 @@
                   }]
           }], ctorParameters: function () { return [{ type: i1__namespace$1.HttpClient }]; } });
 
+  // 组织机构服务，提供获取单位列表、搜索机构和获取所有父节点的功能
   var RkOrgService = /** @class */ (function () {
       function RkOrgService(http) {
           this.http = http;
@@ -954,7 +1083,8 @@
       };
       /**
        * 通过单位编码获得所有父节点
-       * @param id
+       * @param id 单位编码
+       * @returns 父节点列表
        */
       RkOrgService.prototype.requestParentList = function (id) {
           var url = 'api/gl-service-data/v1/data/unit/org/selectListAllParentById';
@@ -971,15 +1101,17 @@
                   }]
           }], ctorParameters: function () { return [{ type: i1__namespace$1.HttpClient }]; } });
 
+  // 提供字典服务，用于管理和查询字典数据
   var RkDictionaryService = /** @class */ (function () {
       function RkDictionaryService(http) {
           this.http = http;
+          // 存储字典常用项的缓存，有效期为一周
           this.useItems = new utils.Store('dictionary_use_items', {}, { expires: 1000 * 60 * 60 * 24 * 7 });
       }
       /**
        * 通过字典编码获得常用项
        * @param code 字典编码
-       * @returns 常用项
+       * @returns 常用项数组
        */
       RkDictionaryService.prototype.getUseItems = function (code) {
           return this.useItems.get()[code] || [];
@@ -987,20 +1119,24 @@
       /**
        * 通过字典编码设置常用项
        * @param code 字典编码
-       * @param item 常用项
+       * @param item 常用项对象
        */
       RkDictionaryService.prototype.setUseItems = function (code, item) {
           var data = this.useItems.get();
+          // 如果字典编码不存在，则创建一个新数组
           if (!data[code]) {
               data[code] = [item];
           }
           else {
+              // 如果常用项已存在，则不进行重复添加
               if (data[code].find(function (v) { return 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);
@@ -1008,7 +1144,7 @@
       /**
        * 通过字典编码获得字典基本信息
        * @param code 字典编码
-       * @returns 字典基本信息
+       * @returns 字典基本信息的Observable对象
        */
       RkDictionaryService.prototype.getBaseInfo = function (code) {
           var _a;
@@ -1016,9 +1152,9 @@
           return (_a = this.http).get.apply(_a, __spreadArray([], __read(CacheHttpTemplate(templateObject_1$2 || (templateObject_1$2 = __makeTemplateObject(["", "/", ""], ["", "/", ""])), url, this.codeReplace(code))))).pipe(operators.filter(function (json) { return json.code === 0; }), operators.map(function (json) { return json.data; }));
       };
       /**
-       * 通过字典编码获得获得字典项
+       * 通过字典编码获得字典项列表
        * @param code 字典编码
-       * @returns 字典项列表
+       * @returns 字典项列表的Observable对象
        */
       RkDictionaryService.prototype.getData = function (code) {
           var _a;
@@ -1026,24 +1162,25 @@
           return (_a = this.http).get.apply(_a, __spreadArray([], __read(CacheHttpTemplate(templateObject_2 || (templateObject_2 = __makeTemplateObject(["", "/", ""], ["", "/", ""])), url, this.codeReplace(code))))).pipe(operators.filter(function (json) { return json.code === 0; }), operators.map(function (json) { return json.data; }));
       };
       /**
-       * 通过父节点获得字典项编码
+       * 通过父节点获得字典项列表
        * @param code 字典编码
-       * @param parentId 父节点编码
-       * @returns 字典项列表
+       * @param parentId 父节点编码，默认为根节点
+       * @returns 字典项列表的Observable对象
        */
       RkDictionaryService.prototype.getChildData = function (code, parentId) {
           if (parentId === void 0) { parentId = '-1'; }
           var url = "api/gl-service-sys-core/v1/core/system/dictionary/item/selectListByDictionaryCode";
           return this.http.post(url, { DICTIONARY_CODE: code, SYS_PARENT: parentId }).pipe(operators.filter(function (json) { return json.code === 0; }), operators.map(function (json) { return json.data; }));
       };
+      // 私有方法，用于替换字典编码中的特殊字符
       RkDictionaryService.prototype.codeReplace = function (code) {
           return code.replace(/\//g, '_');
       };
       /**
-       * 通过字典编码获得获得字典项
+       * 根据关键字搜索字典项
        * @param code 字典编码
        * @param keyword 关键字
-       * @returns 字典项列表
+       * @returns 最多10个匹配的字典项列表的Observable对象
        */
       RkDictionaryService.prototype.requestSearchData = function (code, keyword) {
           var url = 'api/gl-service-sys-core/v1/core/system/dictionary/item/selectListByQuery';
@@ -1056,10 +1193,10 @@
           }); }); }));
       };
       /**
-       * 获得字典项的所有父节点
+       * 获取字典项的所有父节点
        * @param code 字典编码
        * @param id 字典项编码
-       * @returns 字典项列表
+       * @returns 父节点列表的Observable对象
        */
       RkDictionaryService.prototype.requestParentList = function (code, id) {
           var url = 'api/gl-service-sys-core/v1/core/system/dictionary/item/selectListInfoAllParentByCode';
@@ -1083,21 +1220,35 @@
           this.appSettings = AppConfig.settings;
       }
       /**
-       * 通过界面方案标识符获得界面方案内容
-       * @param permission 界面方案标识符
-       * @returns 界面方案
+       * 根据权限标识符获取界面方案内容
+       *
+       * 此方法主要用于根据提供的权限标识符，从后端服务中获取相应的界面方案内容它首先检查是否设置了应用设置中的区域代码，
+       * 如果设置了，则将其前缀到权限标识符上，然后构造请求的URL，并调用HTTP服务进行获取在处理HTTP响应时，
+       * 它会检查返回的状态码，并在状态码不为0（成功）时抛出错误，否则返回界面方案数据
+       *
+       * @param permission 权限标识符，用于获取相应的界面方案
+       * @returns 返回一个Observable，其中包含界面方案数据
        */
       RkSchemeService.prototype.getData = function (permission) {
           var _a;
+          // 检查应用设置中是否设置了区域代码，如果设置了，则将其前缀到权限标识符上
           if (this.appSettings && this.appSettings.servers.AREA_CODE) {
               permission = this.appSettings.servers.AREA_CODE + "_" + permission;
           }
+          // 构造请求的URL
           var url = "api/gl-service-sys-core/v1/core/system/scheme/selectSchemeByPermission";
-          return (_a = this.http).get.apply(_a, __spreadArray([], __read(CacheHttpTemplate(templateObject_1$1 || (templateObject_1$1 = __makeTemplateObject(["", "/", ""], ["", "/", ""])), url, permission)))).pipe(operators.tap(function (json) {
+          // 调用HTTP服务进行GET请求，并对返回的Observable进行处理
+          return (_a = this.http).get.apply(_a, __spreadArray([], __read(CacheHttpTemplate(templateObject_1$1 || (templateObject_1$1 = __makeTemplateObject(["", "/", ""], ["", "/", ""])), url, permission)))).pipe(
+          // 检查返回的状态码，如果不为0，则抛出错误
+          operators.tap(function (json) {
               if (json.code !== 0) {
                   throw new Error("\u901A\u8FC7\u754C\u9762\u65B9\u6848\u6807\u8BC6\u7B26\u83B7\u5F97\u754C\u9762\u65B9\u6848\u5185\u5BB9 " + url + " \u51FA\u73B0\u9519\u8BEF: " + json.msg);
               }
-          }), operators.filter(function (json) { return json.code === 0; }), operators.map(function (json) { return json.data; }));
+          }), 
+          // 过滤出状态码为0的响应
+          operators.filter(function (json) { return json.code === 0; }), 
+          // 提取并返回响应中的数据部分
+          operators.map(function (json) { return json.data; }));
       };
       return RkSchemeService;
   }());
@@ -1117,21 +1268,34 @@
           this.appSettings = AppConfig.settings;
       }
       /**
-       * 通过字段方案标识符获得字段方案内容
-       * @param permission 字段方案标识符
-       * @returns 字段方案
+       * 根据权限标识符获取字段方案
+       *
+       * 此方法主要用于根据提供的权限标识符，从后端服务中获取相应的字段方案
+       * 如果应用设置中包含了地区代码，则会将其前缀添加到权限标识符上
+       *
+       * @param permission 字段方案的权限标识符，用于定位特定的字段方案
+       * @returns 返回一个Observable，其中包含字段方案的数据
        */
       RkFieldSchemeService.prototype.getData = function (permission) {
           var _a;
+          // 检查应用设置中是否提供了地区代码，如果有，则将其添加到权限标识符的前面
           if (this.appSettings && this.appSettings.servers.AREA_CODE) {
               permission = this.appSettings.servers.AREA_CODE + "_" + permission;
           }
+          // 定义请求的URL，用于从后端服务获取字段方案
           var url = "api/gl-service-sys-core/v1/core/system/field/scheme/selectSchemeByIdentifier";
-          return (_a = this.http).get.apply(_a, __spreadArray([], __read(CacheHttpTemplate(templateObject_1 || (templateObject_1 = __makeTemplateObject(["", "/", ""], ["", "/", ""])), url, permission)))).pipe(operators.tap(function (json) {
+          // 发起HTTP GET请求，使用缓存HTTP模板，并对返回的结果进行处理
+          return (_a = this.http).get.apply(_a, __spreadArray([], __read(CacheHttpTemplate(templateObject_1 || (templateObject_1 = __makeTemplateObject(["", "/", ""], ["", "/", ""])), url, permission)))).pipe(
+          // 如果返回码不为0，则抛出错误，提示获取字段方案内容时出现错误
+          operators.tap(function (json) {
               if (json.code !== 0) {
                   throw new Error("\u901A\u8FC7\u5B57\u6BB5\u65B9\u6848\u6807\u8BC6\u7B26\u83B7\u5F97\u5B57\u6BB5\u65B9\u6848\u5185\u5BB9 " + url + " \u51FA\u73B0\u9519\u8BEF: " + json.msg);
               }
-          }), operators.filter(function (json) { return json.code === 0; }), operators.map(function (json) { return json.data; }));
+          }), 
+          // 过滤出返回码为0的结果，即操作成功的数据
+          operators.filter(function (json) { return json.code === 0; }), 
+          // 提取结果数据中的字段方案内容
+          operators.map(function (json) { return json.data; }));
       };
       return RkFieldSchemeService;
   }());
@@ -1150,6 +1314,15 @@
       function RkDestroyService() {
           return _super !== null && _super.apply(this, arguments) || this;
       }
+      /**
+       * 在组件销毁时调用的方法
+       *
+       * 该方法主要用于清理操作，确保在组件被销毁前完成所有的清理工作
+       * 首先，调用`this.next()`方法，用于发送一个通知或执行某些操作，以便在组件销毁前进行必要的处理
+       * 然后，调用`this.complete()`方法，表示已完成所有必要的清理操作，确保资源被正确释放
+       *
+       * @returns void - 该方法没有返回值
+       */
       RkDestroyService.prototype.ngOnDestroy = function () {
           this.next();
           this.complete();