    import BaseServer from '../BaseServer'
    import { Zondy } from '../../base'
    import { Log, defaultValue } from '../../util'
    import CAttStruct from './support/CAttStruct'

    /**
     * 资源服务，基地址为http://{ip}:{port}/igs/rest/services/system/ResourceServer
     * @class ResourceServer
     * @moduleEx ServerModule
     * @extends BaseServer
     * @param {Object} options 构造参数
     * @param {String} [options.url ] 服务基地址
     */
    class ResourceServer extends BaseServer {
      constructor(options) {
        super(options)
        // 默认为igs2.0服务
        this.igsType = '2.0'
        // 是igs1.0服务
        if (this.url.indexOf('/igs/rest/mrcs') > -1) {
          this.igsType = '1.0'
        }
      }

      /**
       * @function ResourceServer.prototype.queryDataSourceList
       * @description 获取数据源列表,支持igs1.0和igs2.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @return {Promise<Object>}
       * @example <caption><h5>igs2.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * // ES6引入方式
       * import { ResourceServer } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
        //服务地址
        url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
      });
        const dataSourceList = resourceServer.queryDataSourceList({
          success: function (res) {
            console.log("res: ", res);
          },
        });
       * @example <caption><h5>igs1.0</h5></caption>
        // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * // ES6引入方式
       * import { ResourceServer } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const dataSourceList = resourceServer.queryDataSourceList({
          success: function (res) {
            console.log("res: ", res);
          },
        });

       */
      queryDataSourceList(options) {
        const self = this
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {}
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            const pathDataSource =
              self.igsType === '1.0' ? 'datasource' : 'datasources'
            return self.igsType === '1.0'
              ? `${url}/${pathDataSource}`
              : `${url}/${pathDataSource}?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryDataSourceInfo
       * @description 查询数据源信息
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.datasource] 数据库名，必传
       * @return {Promise<Object>}
       * @example <caption><h5>igs2.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * // ES6引入方式
       * import { ResourceServer } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
        });
        const dataSourceInfo = resourceServer.queryDataSourceInfo({
          datasource: "MapGISLocalPlus",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       *
       */
      queryDataSourceInfo(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          datasource: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {}
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/datasources/${options.datasource}?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryGDBList
       * @description 查询GDB列表
       * @param options 查询参数
       * @param {String} [options.datasource] 数据源名，必传
       * @param {String} [options.userName ] 数据源用户名
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @return {Promise<Object>}
        * @example <caption><h5>igs2.0</h5></caption>
        * // ES5引入方式
        * const { ResourceServer } = Zondy.Service
        * // ES6引入方式
        * import { ResourceServer  } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
        });
        const queryGDBList = resourceServer.queryGDBList({
          datasource: 'MapGISLocalPlus',
          success: function (res) {
            console.log('res: ', res)
          }
        })
        * @example <caption><h5>igs1.0</h5></caption>
        // ES5引入方式
        * const { ResourceServer } = Zondy.Service
        * // ES6引入方式
        * import { ResourceServer  } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const dataSourceInfo = resourceServer.queryDataSourceInfo({
          datasource: "MapGISLocalPlus",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       *
       */
      queryGDBList(options) {
        const self = this
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          datasource: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          userName: {
            type: 'String'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            const pathDataSource =
              self.igsType === '1.0' ? 'datasource' : 'datasources'
            return self.igsType === '1.0'
              ? `${url}/${pathDataSource}/${options.datasource}`
              : `${url}/${pathDataSource}/${options.datasource}/gdbs?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.addGDB
       * @description 新建数据库
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.datasource] 数据库名，必传
       * @param {String} [options.gdbName ] gdb名称
       * @param {String} [options.userName ] 数据源用户名
       * @param {String} [options.path ] gdb路径
       * @return {Promise<Object>}
       * @example <caption><h5>igs2.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
        });
        const addGDB = resourceServer.addGDB({
          method: FetchMethod.post,
          datasource: "MapGISLocalPlus",
          gdbName: "test_0426",
          path: "e://数据源",
          useName: "",
          success: function (res) {
            console.log("res: ", res);
          },
        });
        * @example <caption><h5>igs1.0</h5></caption>
        // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const addGDB = resourceServer.addGDB({
          method: FetchMethod.get,
          datasource: "MapGISLocalPlus",
          gdbName: "test_04261",
          path: "d:\\",
          useName: "",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       *
       */
      addGDB(options) {
        const self = this
        // 设置PATH PARAMETERS校验
        let checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        let checkQueryOpts = {}
        if (this.igsType === '2.0') {
          checkPathOpts = {
            datasource: {
              type: 'String'
            }
          }
          checkQueryOpts = {
            gdbName: {
              type: 'String'
            },
            userName: {
              type: 'String'
            },
            path: {
              type: 'String'
            }
          }
        } else {
          checkPathOpts = {
            gdbName: {
              type: 'String'
            }
          }
          checkQueryOpts = {
            datasource: {
              type: 'String',
              alias: 'gdbSvrName'
            },
            userName: {
              type: 'String',
              alias: 'gdbUserName'
            },
            path: {
              type: 'String'
            }
          }
        }

        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            const pathDataSource =
              self.igsType === '1.0' ? 'datasource' : 'datasources'
            return self.igsType === '1.0'
              ? `${url}/gdb/creat/${options.gdbName}`
              : `${url}/${pathDataSource}/${options.datasource}/gdbs`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.attachGDB
       * @description 附加数据库
       * @param options 查询参数
       * @param {String} [options.userName ] 数据源用户名
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.datasource] 数据源名，必传
       * @param {String} [options.gdbName ] gdb名称，必传
       * @param {String} [options.path ] gdb路径，必传
       * @param {String} [options.userName ] 数据源用户名
       * @return {Promise<Object>}
       * @example <caption><h5>igs2.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
        });
        const attachGDB = resourceServer.attachGDB({
          method: FetchMethod.post,
          datasource: 'MapGISLocalPlus',
          gdbName: 'test_0426',
          path: 'e://数据源//test_0426.hdb',
          useName: '',
          success: function (res) {
            console.log('res: ', res)
          }
        })

        * @example <caption><h5>igs1.0</h5></caption>
        // ES5引入方式
        const { ResourceServer } = Zondy.Service
        const { FetchMethod } = Zondy.Enum
        // ES6引入方式
        import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const attachGDB = resourceServer.attachGDB({
          method: FetchMethod.get,
          datasource: "MapGISLocalPlus",
          gdbName: "test_0426",
          path: "e:\\数据源\\test_0426.hdb",
          useName: "",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       *
       */
      attachGDB(options) {
        const self = this
        // 设置PATH PARAMETERS校验
        let checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        let checkQueryOpts = {}
        if (this.igsType === '2.0') {
          checkPathOpts = {
            datasource: {
              type: 'String'
            }
          }
          checkQueryOpts = {
            gdbName: {
              type: 'String',
              required: true
            },
            useName: {
              type: 'String'
            },
            path: {
              type: 'String',
              required: true
            }
          }
        } else {
          checkPathOpts = {
            gdbName: {
              type: 'String'
            }
          }
          checkQueryOpts = {
            datasource: {
              type: 'String',
              alias: 'gdbSvrName'
            },
            userName: {
              type: 'String',
              alias: 'gdbUserName'
            },
            path: {
              type: 'String'
            }
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            const pathDataSource =
              self.igsType === '1.0' ? 'datasource' : 'datasources'
            return self.igsType === '1.0'
              ? `${url}/gdb/attach/${options.gdbName}`
              : `${url}/${pathDataSource}/${options.datasource}/gdbs/attach`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.deleteGDB
       * @description 删除数据库
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.datasource] 数据源名，必传
       * @param {String} [options.gdbName ] gdb名称，必传
       * @param {String} [options.userName ] 数据源用户名
       * @return {Promise<Object>}
       * @example <caption><h5>igs2.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
        });
        const deleteGDB = resourceServer.deleteGDB({
          method: FetchMethod.delete,
          datasource: "MapGISLocalPlus",
          gdbName: "test_0426",
          useName: "",
          success: function (res) {
            console.log("res: ", res);
          },
        });
        * @example <caption><h5>igs1.0</h5></caption>
        // ES5引入方式
        const { ResourceServer } = Zondy.Service
        const { FetchMethod } = Zondy.Enum
        // ES6引入方式
        import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const deleteGDB = resourceServer.deleteGDB({
          method: FetchMethod.get,
          datasource: "MapGISLocalPlus",
          gdbName: "test_0426",
          useName: "",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       *
       */
      deleteGDB(options) {
        const self = this
        // 设置PATH PARAMETERS校验
        let checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        let checkQueryOpts = {}

        if (this.igsType === '2.0') {
          checkPathOpts = {
            datasource: {
              type: 'String'
            },
            gdbName: {
              type: 'String'
            }
          }
          checkQueryOpts = {
            useName: {
              type: 'String'
            }
          }
        } else {
          checkPathOpts = {
            gdbName: {
              type: 'String'
            }
          }
          checkQueryOpts = {
            datasource: {
              type: 'String',
              alias: 'gdbSvrName'
            },
            userName: {
              type: 'String',
              alias: 'gdbUserName'
            },
            path: {
              type: 'String'
            }
          }
        }

        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            const pathDataSource =
              self.igsType === '1.0' ? 'datasource' : 'datasources'
            return self.igsType === '1.0'
              ? `${url}/gdb/delete/${options.gdbName}`
              : `${url}/${pathDataSource}/${options.datasource}/gdbs/${options.gdbName}`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.detachGDB
       * @description 注销数据库
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.datasource] 数据源名，必传
       * @param {String} [options.gdbName ] gdb名称，必传
       * @param {String} [options.userName ] 数据源用户名
       * @return {Promise<Object>}
       * @example <caption><h5>igs2.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
        });
        const detachGDB = resourceServer.detachGDB({
          method: FetchMethod.put,
          datasource: "MapGISLocalPlus",
          gdbName: "test_0426",
          useName: "",
          success: function (res) {
            console.log("res: ", res);
          },
        });
        * @example <caption><h5>igs1.0</h5></caption>
        // ES5引入方式
        const { ResourceServer } = Zondy.Service
        const { FetchMethod } = Zondy.Enum
        // ES6引入方式
        import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const detachGDB = resourceServer.detachGDB({
          method: FetchMethod.get,
          datasource: "MapGISLocalPlus",
          gdbName: "test_0426",
          useName: "",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       *
       */
      detachGDB(options) {
        const self = this
        // 设置PATH PARAMETERS校验
        let checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        let checkQueryOpts = {}

        if (this.igsType === '2.0') {
          checkPathOpts = {
            datasource: {
              type: 'String'
            },
            gdbName: {
              type: 'String'
            }
          }
          checkQueryOpts = {
            useName: {
              type: 'String'
            }
          }
        } else {
          checkPathOpts = {
            gdbName: {
              type: 'String'
            }
          }
          checkQueryOpts = {
            datasource: {
              type: 'String',
              alias: 'gdbSvrName'
            },
            userName: {
              type: 'String',
              alias: 'gdbUserName'
            },
            path: {
              type: 'String'
            }
          }
        }

        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            const pathDataSource =
              self.igsType === '1.0' ? 'datasource' : 'datasources'
            return self.igsType === '1.0'
              ? `${url}/gdb/delete/${options.gdbName}`
              : `${url}/${pathDataSource}/${options.datasource}/gdbs/${options.gdbName}/detach`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryFeatureDataSourceList
       * @description 查询要素数据集列表
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.datasource] 数据源名，必传
       * @param {String} [options.gdbName ] gdb名称，必传
       * @param {String} [options.userName ] 数据源用户名
       * @return {Promise<Object>}
       * @example <caption><h5>igs2.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
        //服务地址
        url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
      });
      const queryFeatureDataSourceList =
        resourceServer.queryFeatureDataSourceList({
          method: FetchMethod.get,
          datasource: 'MapGISLocalPlus',
          gdbName: 'sample',
          useName: '',
          success: function (res) {
            console.log('res: ', res)
          }
        })
       * @example <caption><h5>igs1.0</h5></caption>
        // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
        //服务地址
        url: "http://localhost:8089/igs/rest/mrcs",
      });
      const queryFeatureDataSourceList =
        resourceServer.queryFeatureDataSourceList({
          method: FetchMethod.get,
          datasource: 'MapGISLocalPlus',
          gdbName: 'sample',
          useName: '',
          success: function (res) {
            console.log('res: ', res)
          }
        })
       *
       */
      queryFeatureDataSourceList(options) {
        const self = this
        // 设置PATH PARAMETERS校验
        let checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        let checkQueryOpts = {}
        if (this.igsType === '2.0') {
          checkPathOpts = {
            datasource: {
              type: 'String'
            },
            gdbName: {
              type: 'String'
            }
          }
          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            useName: {
              type: 'String'
            }
          }
        } else {
          checkPathOpts = {
            datasource: {
              type: 'String'
            },
            gdbName: {
              type: 'String'
            }
          }
        }

        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            const pathDataSource =
              self.igsType === '1.0' ? 'datasource' : 'datasources'
            return self.igsType === '1.0'
              ? `${url}/${pathDataSource}/${options.datasource}/${options.gdbName}/fds`
              : `${url}/${pathDataSource}/${options.datasource}/gdbs/${options.gdbName}/fds?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryTileDataSourceList
       * @description 获取栅格数据集列表
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.datasource] 数据源名，必传
       * @param {String} [options.gdbName ] gdb名称，必传
       * @param {String} [options.userName ] 数据源用户名
       * @return {Promise<Object>}
       * @example <caption><h5>igs2.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
        });
        const queryTileDataSourceList = resourceServer.queryTileDataSourceList({
          method: FetchMethod.get,
          datasource: "MapGISLocalPlus",
          gdbName: "sample",
          useName: "",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       * @example <caption><h5>igs1.0</h5></caption>
        // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const queryTileDataSourceList = resourceServer.queryTileDataSourceList({
          method: FetchMethod.get,
          datasource: "MapGISLocalPlus",
          gdbName: "sample",
          useName: "",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       *
       */
      queryTileDataSourceList(options) {
        const self = this
        // 设置PATH PARAMETERS校验
        let checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        let checkQueryOpts = {}
        if (this.igsType === '2.0') {
          checkPathOpts = {
            datasource: {
              type: 'String'
            },
            gdbName: {
              type: 'String'
            }
          }
          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            useName: {
              type: 'String'
            }
          }
        } else {
          checkPathOpts = {
            datasource: {
              type: 'String'
            },
            gdbName: {
              type: 'String'
            }
          }
        }

        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            const pathDataSource =
              self.igsType === '1.0' ? 'datasource' : 'datasources'
            return self.igsType === '1.0'
              ? `${url}/${pathDataSource}/${options.datasource}/${options.gdbName}/rds`
              : `${url}/${pathDataSource}/${options.datasource}/gdbs/${options.gdbName}/rds?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.querySimpleFeatureList
       * @description 简单要素类列表
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.datasource] 数据源名，必传
       * @param {String} [options.gdbName ] gdb名称，必传
       * @param {String} [options.userName ] 数据源用户名
       * @param {String} [options.fdsName ] 要素数据集名称，如果不为空，则仅获取指定要素数据下的数据
       * @param {Boolean} [options.includeAll = false] 是否包含要素数据集下及非要素数据集下的简单要素类数据，仅当fdsName为空时有效
       * @return {Promise<Object>}
       * @example <caption><h5>igs2.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
        const resourceServer = new .ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
        });
        const querySimpleFeatureList = resourceServer.querySimpleFeatureList({
          method: FetchMethod.get,
          datasource: "MapGISLocalPlus",
          gdbName: "sample",
          useName: "",
          fdsName: "影像数据",
          includeAll: true,
          success: function (res) {
            console.log("res: ", res);
          },
        });
        * @example <caption><h5>igs1.0</h5></caption>
        // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const querySimpleFeatureList = resourceServer.querySimpleFeatureList({
          method: FetchMethod.get,
          datasource: "MapGISLocalPlus",
          gdbName: "sample",
          useName: "",
          fdsName: "影像数据",
          includeAll: true,
          success: function (res) {
            console.log("res: ", res);
          },
        });
       *
       */
      querySimpleFeatureList(options) {
        const self = this
        // 设置PATH PARAMETERS校验
        let checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        let checkQueryOpts = {}

        if (this.igsType === '2.0') {
          checkPathOpts = {
            datasource: {
              type: 'String'
            },
            gdbName: {
              type: 'String'
            }
          }
          checkQueryOpts = {
            useName: {
              type: 'String'
            },
            fdsName: {
              type: 'String'
            },
            includeAll: {
              type: 'Boolean'
            }
          }
        } else {
          checkPathOpts = {
            datasource: {
              type: 'String'
            },
            gdbName: {
              type: 'String'
            }
          }
        }

        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            const pathDataSource =
              self.igsType === '1.0' ? 'datasource' : 'datasources'
            return self.igsType === '1.0'
              ? `${url}/${pathDataSource}/${options.datasource}/${options.gdbName}/sfcls`
              : `${url}/${pathDataSource}/${options.datasource}/gdbs/${options.gdbName}/sfcls?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.addClass
       * @description 在数据库中创建一个类
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.datasource ] 数据源名称，必传
       * @param {String} [options.gdbName] gdb名称，必传
       * @param {String} [options.userName ] 数据源用户名
       * @param {String} [options.layerName ] 图层名称，必传
       * @param {String} [options.geomType ] 几何类型，必传，igs2.0支持"Pnt" "Lin" "Reg" "Ann" "Surface" "Entity" "Unknown"
       * @param {String} [options.srs ] 参考系信息，支持mapgis参照系名称和EPSG编号,比如EPSG:4326、WGS1984_度
       * @param {String} [options.fdsName ] 要素集名称
       * @param {Array<Object>} [options.fields ] 属性字段结构信息，必传，示例:[{"name": "string","type": "string","alias": "string","length": 0}]
       * @param {String} [options.featureType] 要素类型，取值为sfcls 或 acls，默认sfcls，目前仅支持简单要素类和注记类(只支持文本类型注记)
       * @return {Promise<Object>}
       * @example <caption><h5>igs2.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
       * const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
        });
        const addClass = resourceServer.addClass({
          method: FetchMethod.post,
          datasource: "MapGISLocalPlus",
          gdbName: "test",
          useName: "",
          layerName: "test_0426_feature",
          srs: "WGS1984_度",
          geomType: "Reg",
          fdsName: "test",
          fields: [{ name: "string", type: "string", alias: "string", length: 0 }],
          success: function (res) {
            console.log("res: ", res);
          },
        });
       *
       */
      addClass(options) {
        // 设置PATH PARAMETERS校验
        let checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        let checkQueryOpts = {}
        // 设置PATH PARAMETERS校验
        checkPathOpts = {
          datasource: {
            type: 'String'
          },
          gdbName: {
            type: 'String'
          },
          featureType: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        checkQueryOpts = {
          userName: {
            type: 'String'
          },
          layerName: {
            type: 'String',
            required: true
          },
          geomType: {
            type: 'String',
            required: true
          },
          srs: {
            type: 'String'
          },
          fdsName: {
            type: 'String'
          },
          fields: {
            type: 'Array',
            process(v) {
              return `&fields=${JSON.stringify(v)}`
            },
            required: true
          }
        }

        const opt = options || {}
        opt.featureType = defaultValue(opt.featureType, 'sfcls')

        // 调用基类的查询信息方法
        return this._queryByParameters(
          opt,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/datasources/${options.datasource}/gdbs/${options.gdbName}/${options.featureType}`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.getSimpleFeature
       * @description 获取简单要素类
       * @param options 查询参数
       * @param {String} [options.datasource ] 数据源名称，必传
       * @param {String} [options.gdbName ] gdb名称，必传
       * @param {String} [options.featureSetName ] 简单要素类名称，必传
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.userName ] 数据源用户名
       * @return {Promise<Object>}
       * @example
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
        });
        const getSimpleFeature = resourceServer.getSimpleFeature({
          method: FetchMethod.get,
          datasource: "MapGISLocalPlus",
          gdbName: "sample",
          featureSetName: "等值线1",
          useName: "",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       *
       */
      getSimpleFeature(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          datasource: {
            type: 'String'
          },
          gdbName: {
            type: 'String'
          },
          featureSetName: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          userName: {
            type: 'String'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/datasources/${options.datasource}/gdbs/${options.gdbName}/sfcls/${options.featureSetName}?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.updateSimpleFeature
       * @description 更新单个简单要素类信息
       * @param options 查询参数
       * @param {String} [options.datasource] 数据源名称，必传
       * @param {String} [options.gdbName ] gdb名称，必传
       * @param {String} [options.featureSetName ] 简单要素类名称，必传
       * @param {Object} [options.updateInfo ] 更新的信息，必传
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.userName ] 数据源用户名
       * @return {Promise<Object>}
       * @example
       *
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
        //服务地址
        url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
      });
      const updateSimpleFeature = resourceServer.updateSimpleFeature({
        method: FetchMethod.put,
        datasource: "MapGISLocalPlus",
        gdbName: "sample",
        featureSetName: "等值线1",
        updateInfo: {
          name: "等值线",
          srs: "WGS1984_度",
        },
        success: function (res) {
          console.log("res: ", res);
        },
      });
       *
       */
      updateSimpleFeature(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          datasource: {
            type: 'String'
          },
          gdbName: {
            type: 'String'
          },
          featureSetName: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          userName: {
            type: 'String'
          },
          updateInfo: {
            type: 'Object',
            required: true,
            process(v) {
              return `&updateInfo=${JSON.stringify(v)}`
            }
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/datasources/${options.datasource}/gdbs/${options.gdbName}/sfcls/${options.featureSetName}`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.deleteSimpleFeature
       * @description 删除简单要素类
       * @param options 查询参数
       * @param {String} [options.datasource ] gdb名称，必传
       * @param {String} [options.gdbName ] gdb名称，必传
       * @param {String} [options.featureSetName ] 简单要素类名称，必传
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.userName ] 数据源用户名
       * @return {Promise<Object>}
       * @example
       *
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
        //服务地址
        url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
      });
        const deleteSimpleFeature = resourceServer.deleteSimpleFeature({
          method: FetchMethod.delete,
          datasource: "MapGISLocalPlus",
          gdbName: "sample",
          featureSetName: "等值线",
          useName: "",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       *
       */
      deleteSimpleFeature(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          datasource: {
            type: 'String'
          },
          gdbName: {
            type: 'String'
          },
          featureSetName: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          userName: {
            type: 'String'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/datasources/${options.datasource}/gdbs/${options.gdbName}/sfcls/${options.featureSetName}`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.querySrsList
       * @description 查询参考系列表
       * @param options 查询参数
       * @param {String} [options.datasource ] 数据源名称，必传
       * @param {String} [options.gdbName ] gdb名称，必传
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.userName ] 数据源用户名
       * @return {Promise<Object>}
       * @example <caption><h5>igs2.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
        //服务地址
        url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
      });
        const querySrsList = resourceServer.querySrsList({
          method: FetchMethod.get,
          datasource: "MapGISLocalPlus",
          gdbName: "sample",
          useName: "",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       * @example <caption><h5>igs1.0</h5></caption>
         // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const querySrsList = resourceServer.querySrsList({
          method: FetchMethod.get,
          datasource: "MapGISLocalPlus",
          gdbName: "sample",
          useName: "",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       *
       */
      querySrsList(options) {
        const self = this
        // 设置PATH PARAMETERS校验
        let checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        let checkQueryOpts = {}

        if (this.igsType === '2.0') {
          checkPathOpts = {
            datasource: {
              type: 'String'
            },
            gdbName: {
              type: 'String'
            }
          }
          checkQueryOpts = {
            useName: {
              type: 'String'
            }
          }
        } else {
          checkPathOpts = {
            datasource: {
              type: 'String'
            },
            gdbName: {
              type: 'String'
            }
          }
          checkQueryOpts = {
            useName: {
              type: 'String',
              alias: 'user'
            }
          }
        }

        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            const pathDataSource =
              self.igsType === '1.0' ? 'datasource' : 'datasources'
            return self.igsType === '1.0'
              ? `${url}/${pathDataSource}/${options.datasource}/${options.gdbName}?f=json`
              : `${url}/datasources/${options.datasource}/gdbs/${options.gdbName}/spatialRefs?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.querySrsInfo
       * @description 查询参考系信息
       * @param options 查询参数
       * @param {String} [options.datasource ] 数据源名称，必传
       * @param {String} [options.gdbName ] gdb名称，必传
       * @param {String} [options.srsName ] 参考系名称，必传,在使用igs1.0服务时，需要传入参考系id
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.userName ] 数据源用户名
       * @return {Promise<Object>}
       * @example <caption><h5>igs2.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
        //服务地址
        url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
      });
        const querySrsInfo = resourceServer.querySrsInfo({
          method: FetchMethod.get,
          datasource: "MapGISLocalPlus",
          gdbName: "sample",
          srsName: "WGS1984_度",
          useName: "",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       * @example <caption><h5>igs1.0</h5></caption>
        // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
        //服务地址
        url: "http://localhost:8089/igs/rest/mrcs",
      });
        const querySrsInfo = resourceServer.querySrsInfo({
          method: FetchMethod.get,
          datasource: "MapGISLocalPlus",
          gdbName: "sample",
          srsName: "7",
          useName: "",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       *
       */
      querySrsInfo(options) {
        const self = this
        // 设置PATH PARAMETERS校验
        let checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        let checkQueryOpts = {}
        if (this.igsType === '2.0') {
          checkPathOpts = {
            datasource: {
              type: 'String'
            },
            gdbName: {
              type: 'String'
            },
            srsName: {
              type: 'String'
            }
          }
          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            useName: {
              type: 'String'
            }
          }
        } else {
          checkPathOpts = {
            datasource: {
              type: 'String'
            },
            gdbName: {
              type: 'String'
            },
            srsName: {
              type: 'String'
            }
          }
          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            useName: {
              type: 'String'
            }
          }
        }

        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            const pathDataSource =
              self.igsType === '1.0' ? 'datasource' : 'datasources'
            return self.igsType === '1.0'
              ? `${url}/${pathDataSource}/${options.datasource}/${options.gdbName}/${options.srsName}?f=json`
              : `${url}/datasources/${options.datasource}/gdbs/${options.gdbName}/spatialRefs/${options.srsName}?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.querySystemLibList
       * @description 查询系统库资源列表
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @return {Promise<Object>}
       * @example <caption><h5>igs2.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
        });
        const querySystemLibList = resourceServer.querySystemLibList({
          method: FetchMethod.get,
          success: function (res) {
            console.log("res: ", res);
          },
        });
       * @example <caption><h5>igs1.0</h5></caption>
        // ES5引入方式
        const { ResourceServer } = Zondy.Service
        const { FetchMethod } = Zondy.Enum
        // ES6引入方式
        import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const querySystemLibList = resourceServer.querySystemLibList({
          method: FetchMethod.get,
          success: function (res) {
            console.log("res: ", res);
          },
        });
       *
       */
      querySystemLibList(options) {
        const self = this
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {}
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return self.igsType === '1.0'
              ? `${url}/systemlibraries?f=json`
              : `${url}/systemLibs?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.querySystemColorList
       * @description 查询系统颜色列表
       * @param options 查询参数
       * @param {String} [options.sysLib ] 系统库id，必传
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {Number} [options.page = 1] 页码
       * @param {Number} [options.pageSize = 20] 每页数量
       * @return {Promise<Object>}
       * @example <caption><h5>igs2.0</h5></caption>
       *  // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
        });
        const querySystemColorList = resourceServer.querySystemColorList({
          method: FetchMethod.get,
          sysLib: "DefaultSystemLib",
          page: 1,
          pageSize: 20,
          success: function (res) {
            console.log("res: ", res);
          },
        });
       * @example <caption><h5>igs1.0</h5></caption>
        // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const querySystemColorList = resourceServer.querySystemColorList({
          method: FetchMethod.get,
          sysLib: "DefaultSystemLib",
          page: 0,
          pageSize: 20,
          success: function (res) {
            console.log("res: ", res);
          },
        });
       *
       */
      querySystemColorList(options) {
        const self = this
        // 设置PATH PARAMETERS校验
        let checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        let checkQueryOpts = {}
        if (this.igsType === '2.0') {
          checkPathOpts = {
            sysLib: {
              type: 'String'
            }
          }
          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            page: {
              type: 'Number'
            },
            pageSize: {
              type: 'Number'
            }
          }
        } else {
          checkPathOpts = {}
          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            page: {
              type: 'Number'
            },
            pageSize: {
              type: 'Number',
              alias: 'size'
            },
            sysLib: {
              type: 'String',
              alias: 'systemLib'
            }
          }
        }

        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return self.igsType === '1.0'
              ? `${url}/colors?f=json`
              : `${url}/systemLibs/${options.sysLib}/colors?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.getColorIndex
       * @description 根据RGB值获取颜色号
       * @param options 查询参数
       * @param {String} [options.sysLib ] 系统库id，必传
       * @param {Color} [options.color] 颜色值，必传
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {Boolean} [options.addIfNotExist = false] 如果查找到的颜色不存在，是否新增
       * @return {Promise<Object>}
       * @example <caption><h5>igs2.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * const { Color } = Zondy
       * // ES6引入方式
       * import { ResourceServer ,FetchMethod ,Color } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
        //服务地址
        url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
      });
        const getColorIndex = resourceServer.getColorIndex({
          method: FetchMethod.get,
          sysLib: "DefaultSystemLib",
          color: new Color(225, 221, 20, 1),
          addIfNotExist: false,
          success: function (res) {
            console.log("res: ", res);
          },
        });
         * @example <caption><h5>igs1.0</h5></caption>
        // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * const { Color } = Zondy
       * // ES6引入方式
       * import { ResourceServer ,FetchMethod ,Color } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
        //服务地址
        url: "http://localhost:8089/igs/rest/mrcs",
      });
        const getColorIndex = resourceServer.getColorIndex({
          method: FetchMethod.get,
          sysLib: "DefaultSystemLib",
          color: new Color(225, 221, 20, 1),
          addIfNotExist: false,
          success: function (res) {
            console.log("res: ", res);
          },
        });
       *
       */
      getColorIndex(options) {
        const self = this
        // 设置PATH PARAMETERS校验
        let checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        let checkQueryOpts = {}
        if (this.igsType === '2.0') {
          checkPathOpts = {
            sysLib: {
              type: 'String'
            }
          }
          checkQueryOpts = {
            color: {
              type: 'Color',
              required: true,
              process(v) {
                return `&red=${v.red}&green=${v.green}&blue=${v.blue}`
              }
            },
            addIfNotExist: {
              type: 'Boolean'
            }
          }
        } else {
          checkPathOpts = {}
          checkQueryOpts = {
            sysLib: {
              type: 'String',
              alias: 'libID'
            },
            color: {
              type: 'Color',
              required: true,
              process(v) {
                return `&r=${v.red}&g=${v.green}&b=${v.blue}`
              }
            },
            addIfNotExist: {
              type: 'Boolean',
              alias: 'addNewColor'
            }
          }
        }

        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return self.igsType === '1.0'
              ? `${url}/ColorLib/getColorNO?f=json`
              : `${url}/systemLibs/${options.sysLib}/colors/findColorNo?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.getColorByIndex
       * @description 根据颜色号获取RGB值
       * @param options 查询参数
       * @param {String} [options.sysLib ] 系统库id，必传
       * @param {String} [options.colorIndex ] 颜色号，必传
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
        });
        const querySystemColorList = resourceServer.querySystemColorList({
          method: FetchMethod.get,
          sysLib: "DefaultSystemLib",
          page: 1,
          pageSize: 20,
          success: function (res) {
            console.log("res: ", res);
          },
        });
       * @example <caption><h5>igs1.0</h5></caption>
        // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const querySystemColorList = resourceServer.querySystemColorList({
          method: FetchMethod.get,
          sysLib: "DefaultSystemLib",
          page: 1,
          pageSize: 20,
          success: function (res) {
            console.log("res: ", res);
          },
        });
       *
       */
      getColorByIndex(options) {
        const self = this
        // 设置PATH PARAMETERS校验
        let checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        let checkQueryOpts = {}

        if (this.igsType === '2.0') {
          // 设置PATH PARAMETERS校验
          checkPathOpts = {
            sysLib: {
              type: 'String'
            },
            colorIndex: {
              type: 'String'
            }
          }
          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {}
        } else {
          // 设置PATH PARAMETERS校验
          checkPathOpts = {}
          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            sysLib: {
              type: 'String',
              alias: 'libID'
            },
            colorIndex: {
              type: 'String',
              alias: 'colorNO'
            }
          }
        }

        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return self.igsType === '1.0'
              ? `${url}/ColorLib/getColorRGB?f=json`
              : `${url}/systemLibs/${options.sysLib}/colors/${options.colorIndex}?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryTempDataServerInfo
       * @description 获取临时数据服务信息
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @return {Promise<Object>}
       * @example <caption><h5>igs2.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
        });
        const queryTempDataServerInfo = resourceServer.queryTempDataServerInfo({
          method: FetchMethod.get,
          success: function (res) {
            console.log("res: ", res);
          },
        });
       *
       */
      queryTempDataServerInfo(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {}
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/tempData?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryTempDataFeatures
       * @description 获取临时图层要素信息
       * @param options 要素查询参数
       * @param {String} [options.method = FetchMethod.get ] 请求类型
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {Geometry} [options.geometry ] 要素查询几何条件
       * @param {String} [options.url] 图层资源的路径，可能是gdbp、filePath
       * @param {Object} [options.mapResource] 地图文档的资源，与urls二选一，mapResource优先，示例："{"url": "/root/wuhan.mapx","mapIndex ": 0,"layerId": "string"}"
       * @param {String} [options.where ] 要素查询where条件
       * @param {String} [options.outFields ] 输出属性字段，可为*表示所有，多个用英文逗号分隔
       * @param {String} [options.objectIds ] 过滤id，多个用英文逗号分隔(参数优先级很高，可能导致其它筛选条件失效)
       * @param {Number} [options.distance = 0] 几何缓冲的距离，geometry为point、line时有效（若数据源为大数据PG数据，且geometryType为line或者point时为必填数据）
       * @param {Number} [options.geometryPrecision ] 返回要素几何信息中坐标xy的精度
       * @param {SpatialRelation} [options.spatialRel ] 几何条件的空间判定规则，Intersects(相交)、EnvelopeIntersects(外包矩形相交)、Contains(包含)、Disjoint(相离)
       * @param {String} [options.orderByFields ] 排序字段,格式: fieldName [ASC|DESC]
       * @param {String} [options.groupByFieldsForStatistics ] 分组统计的字段信息,格式为field1,field2
       * @param {Number} [options.resultRecordCount = 20] 分页参数：结果返回条数，默认20
       * @param {Number} [options.resultOffset ] 分页参数：跳过条数
       * @param {Array} [options.outStatistics ] 计算一个或多个基于字段的统计信息结构,统计类型包括:FUNCTION_MAX/FUNCTION_MIN/FUNCTION_SUM/FUNCTION_AVG/FUNCTION_COUNT/FUNCTION_MAX_OID，示例："[{"statisticType": "FUNCTION_SUM","onStatisticField": "field1","outStatisticFieldName":"fieldName1"}]"
       * @param {Boolean} [options.returnGeometry = true] 是否返回几何，默认为true
       * @param {Boolean} [options.returnAttribute = true] 是否返回属性，默认为true
       * @param {Boolean} [options.returnStyle = false] 是否返回图形参数信息，默认为false
       * @param {Boolean} [options.returnIdsOnly = false] 是否只返回id，默认为false
       * @param {Boolean} [options.returnCountOnly = false] 是否只返回条数，默认为false
       * @param {Boolean} [options.returnExtentOnly = false] 是否只返回范围，默认为false
       * @param {Boolean} [options.returnZ = false] 是否返回Z轴，默认为false
       * @param {Boolean} [options.is6xAcls = true] 图层资源的路径是filePath且后缀是.wt时，需要指定图层资源是否是6x注记，默认为6x点
       * @return {Promise<Object>}
       * @example
       *
       *  // ES5引入方式
        const { ResourceServer } = Zondy.Service
        const { FetchMethod } = Zondy.Enum
        // ES6引入方式
        import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
        //服务地址
        url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
      });
      const queryTempDataFeatures1 = resourceServer.queryTempDataFeatures({
        method: FetchMethod.get,
        url: "gdbp://MapGISLocalPlus/sample/sfcls/等值线1",
        where: "高度='80'",
        success: function (res) {
          console.log("res: ", res);
        },
      });
       *
       */
      queryTempDataFeatures(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          url: { type: 'String' },
          mapResource: {
            type: 'Object',
            process(data) {
              return `&mapResource=${JSON.stringify(data)}`
            }
          },
          where: {
            type: 'String'
          },
          geometry: {
            type: 'Geometry'
          },
          distance: {
            type: 'Number'
          },
          geometryPrecision: {
            type: 'Number'
          },
          spatialRel: {
            type: 'String'
          },
          outFields: {
            type: 'String'
          },
          objectIds: {
            type: 'String'
          },
          orderByFields: {
            type: 'String'
          },
          groupByFieldsForStatistics: {
            type: 'String'
          },
          resultRecordCount: {
            type: 'Number'
          },
          resultOffset: {
            type: 'Number'
          },
          outStatistics: {
            type: 'OutStatistics'
          },
          returnGeometry: {
            type: 'Boolean'
          },
          returnAttribute: {
            type: 'Boolean'
          },
          returnStyle: {
            type: 'Boolean'
          },
          returnIdsOnly: {
            type: 'Boolean'
          },
          returnCountOnly: {
            type: 'Boolean'
          },
          returnExtentOnly: {
            type: 'Boolean'
          },
          returnZ: {
            type: 'Boolean'
          },
          is6xAcls: {
            type: 'Boolean'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/tempData/features/query?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryTempDataInfo
       * @description 获取临时数据信息
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.url] 资源url
       * @return {Promise<Object>}
       * @example
       *
       *  // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
        //服务地址
        url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
      });
      const queryTempDataInfo = resourceServer.queryTempDataInfo({
        method: FetchMethod.get,
        url: "gdbp://MapGISLocalPlus/sample/sfcls/等值线1",
        success: function (res) {
          console.log("res: ", res);
        },
      });
       *
       */
      queryTempDataInfo(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          url: {
            type: 'String',
            required: true
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/tempData/info?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.editTempDataInfo
       * @description 修改系统库
       * @param options 查询参数
       * @param {String} [options.urls ] 图层列表，必传，可能是gdbp、filePath，多个用","分隔
       * @param {String} [options.systemLibId] 系统库id
       * @param {String} [options.systemLibName] 系统库的名称，systemLibId参数为空时有效
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @return {Promise<Object>}
       * @example
       *
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
        //服务地址
        url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
      });
        const editTempDataInfo = resourceServer.editTempDataInfo({
          method: FetchMethod.put,
          urls: "gdbp://MapGISLocalPlus/sample/sfcls/等值线1",
          systemLibName: "DefaultSystemLib",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       *
       */
      editTempDataInfo(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          urls: {
            type: 'String',
            required: true
          },
          systemLibId: {
            type: 'String'
          },
          systemLibName: {
            type: 'String'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/tempData/systemLib?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.createGdbLayer
       * @description 在GDB数据库中创建一个图层,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.gdbSvrName] 数据源名称,必传
       * @param {String} [options.gdbName] GDB数据名称,必传
       * @param {String} [options.featureType] 要素类型，必传。FeatureDS（要素数据集）、SfeatureCls（简单要素类）、ObjectCls（对象类）、AnnotationCls（注记类）、RasterDataset（栅格数据集）、RasterCatalog（栅格目录）、GnetCls（几何网络）、AddrBaseCls（地名库）等。
       * @param {String} [options.layerName] 图层名称,必传
       * @param {String} [options.geoType] 几何类型,必传。区图层为Reg、线图层为Lin、点图层为Pnt
       * @param {String} [options.srefName] 参考系名称
       * @param {String} [options.dsName] 要素数据集名称
       * @param {CAttStruct} [options.attStruct] 图层数据结构
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * const { CAttStruct } = Zondy.Object
       * // ES6引入方式
       * import { ResourceServer ,FetchMethod ,CAttStruct } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
       });
      const createGdbLayer = resourceServer.createGdbLayer({
        method: FetchMethod.post,
        gdbSvrName: "MapGISLocalPlus",
        gdbName: "sample",
        featureType: "SfeatureCls",
        layerName: "新图层",
        dsName: "地图综合",
        geoType: "Reg",
        srefName: "WGS1984_度",
        attStruct: new CAttStruct({
          FldName: ["ID", "面积", "周长", "LayerID"],
          FldNumber: 4,
          FldType: ["FldLong", "FldDouble", "FldDouble", "FldLong"],
        }),
        success: function (res) {
          console.log("res: ", res);
        },
      });
       */
      createGdbLayer(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          gdbSvrName: {
            type: 'String'
          },
          gdbName: {
            type: 'String'
          },
          featureType: {
            type: 'String'
          },
          layerName: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          attStruct: {
            type(v) {
              return v instanceof CAttStruct
            },
            process(v) {
              return JSON.stringify(v)
            },
            required: true
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            const opts = defaultValue(options, {})
            const srefName = defaultValue(opts.srefName, '')
            const dsName = defaultValue(opts.dsName, '')
            return `${url}/datasource/${options.gdbSvrName}/${options.gdbName}/${options.featureType}/${options.layerName}/create?f=json&geoType=${options.geoType}&srefName=${srefName}&dsName=${dsName}`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryGdbpAllData
       * @description 获取GDB下某类型的所有数据,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.gdbSvrName] 数据源名称,必传
       * @param {String} [options.gdbName] gdb名称,必传
       * @param {String} [options.clsType] 要素数据类型,必传。数据类型（分为：ds、rcat、ras、sfcls、fcls、acls、ocls、rds、rcs、ncls、sfcls_new）或者为srefID 参考系id
       * @param {String} [options.useName] 用户名
       * @param {String} [options.password] 密码,igs1.0有效
       * @param {Boolean} [options.containAll] 是否返回hdf下所有的对应数据,false表示只返回对应节点下的数据，默认值为true
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod  } from "@mapgis/webclient-common"
        const resourceServer = new ResourceServer({
            //服务地址
            url: "http://localhost:8089/igs/rest/mrcs",
          });
        const queryGdbpAllData = resourceServer.queryGdbpAllData({
          method: FetchMethod.get,
          gdbSvrName: "MapGISLocalPlus",
          gdbName: "sample",
          clsType: "sfcls",
          success: function (res) {
            console.log("res: ", res);
          },
        });

       */
      queryGdbpAllData(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          gdbSvrName: {
            type: 'String'
          },
          gdbName: {
            type: 'String'
          },
          clsType: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          useName: {
            type: 'String',
            alias: 'user'
          },
          password: {
            type: 'String',
            alias: 'pwd'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/datasource/${options.gdbSvrName}/${options.gdbName}/${options.clsType}?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryDsAllData
       * @description 获取GDB下某类型的所有数据,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.gdbSvrName] 数据源名称,必传
       * @param {String} [options.gdbName] gdb名称,必传
       * @param {String} [options.clsType] 要素数据类型,必传。数据类型（分为：ds、rcat、ras、sfcls、fcls、acls、ocls、rds、rcs、ncls、sfcls_new）或者为srefID 参考系id
       * @param {String} [options.useName] 用户名
       * @param {String} [options.password] 密码,igs1.0有效
       * @param {String} [options.dsName] 要素数据集名称,必传
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer, FetchMethod} from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const queryDsAllData = resourceServer.queryDsAllData({
          method: FetchMethod.get,
          gdbSvrName: "MapGISLocalPlus",
          gdbName: "sample",
          clsType: "sfcls",
          dsName: "地图综合",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       */
      queryDsAllData(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          gdbSvrName: {
            type: 'String'
          },
          gdbName: {
            type: 'String'
          },
          clsType: {
            type: 'String'
          },
          dsName: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          useName: {
            type: 'String',
            alias: 'user'
          },
          password: {
            type: 'String',
            alias: 'pwd'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/datasource/${options.gdbSvrName}/${options.gdbName}/${options.dsName}/${options.clsType}?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.createLayerInGdbp
       * @description 在GDB数据库中创建一个图层,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.gdbSvrName] 数据源名称,必传
       * @param {String} [options.gdbName] gdb名称,必传
       * @param {String} [options.featureType] 要素类型,必传,要素数据集为FeatureDS、简单要素类为SFeatureCls，对象类为ObjectCls，注记类为AnnotationCls，网络类为GNetCls…..。
       * @param {String} [options.layerName] 图层名称,必传
       * @param {String} [options.geoType] 几何类型，必传，区图层为Reg、线图层为Lin、点图层为Pnt
       * @param {String} [options.srefName] 参考系名称
       * @param {String} [options.dsName] 要素名称
       * @param {CAttStruct} [options.attStruct] 属性结构
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * const { CAttStruct } = Zondy.Object
       * // ES6引入方式
       * import { ResourceServer ,FetchMethod ,CAttStruct } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const createLayerInGdbp = resourceServer.createLayerInGdbp({
          method: FetchMethod.post,
          gdbSvrName: "MapGISLocalPlus",
          gdbName: "sample",
          featureType: "SfeatureCls",
          layerName: "新图层",
          dsName: "地图综合",
          geoType: "Reg",
          srefName: "WGS1984_度",
          attStruct: new CAttStruct({
            FldName: ["ID", "面积", "周长", "LayerID"],
            FldNumber: 4,
            FldType: ["FldLong", "FldDouble", "FldDouble", "FldLong"],
          }),
          success: function (res) {
            console.log("res: ", res);
          },
        });
       */
      createLayerInGdbp(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          gdbSvrName: {
            type: 'String'
          },
          gdbName: {
            type: 'String'
          },
          featureType: {
            type: 'String'
          },
          layerName: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          attStruct: {
            type(v) {
              return v instanceof CAttStruct
            },
            process(v) {
              return JSON.stringify(v)
            },
            required: true
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            const geoType = defaultValue(options.srefName, '')
            if (!geoType) Log.error('geoType传入参数为空')
            const srefName = defaultValue(options.srefName, '')
            const dsName = defaultValue(options.dsName, '')
            return `${url}/datasource/${options.gdbSvrName}/${options.gdbName}/${options.featureType}/${options.layerName}/create?f=json&geoType=${geoType}&srefName=${srefName}&dsName=${dsName}`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.deleteLayerInGdbp
       * @description 删除GDB数据库中的一个图层,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.gdbSvrName] 数据源名称,必传
       * @param {String} [options.gdbName] gdb名称,必传
       * @param {String} [options.featureType] 要素类型,必传,要素数据集为FeatureDS、简单要素类为SFeatureCls，对象类为ObjectCls，注记类为AnnotationCls，网络类为GNetCls…..。
       * @param {String} [options.layerName] 图层名称,必传
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       *  // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const deleteLayerInGdbp = resourceServer.deleteLayerInGdbp({
          method: FetchMethod.get,
          gdbSvrName: "MapGISLocalPlus",
          gdbName: "sample",
          featureType: "SfeatureCls",
          layerName: "等值线",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       */
      deleteLayerInGdbp(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          gdbSvrName: {
            type: 'String'
          },
          gdbName: {
            type: 'String'
          },
          featureType: {
            type: 'String'
          },
          layerName: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {}
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/datasource/${options.gdbSvrName}/${options.gdbName}/${options.featureType}/${options.layerName}/delete?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.updateLayerInGdbp
       * @description 更新GDB数据库中的一个图层,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.gdbSvrName] 数据源名称,必传
       * @param {String} [options.gdbName] gdb名称,必传
       * @param {String} [options.featureType] 要素类型,必传,要素类型:SFeatureCls或AnnotationCls
       * @param {String} [options.layerName] 图层名称,必传
       * @param {Object} [options.updateObject] 更新参数，必传,例如{"SrsName":"WGS1984_度","LayerName":"图层名"}
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const updateLayerInGdbp = resourceServer.updateLayerInGdbp({
          method: FetchMethod.get,
          gdbSvrName: "MapGISLocalPlus",
          gdbName: "sample",
          featureType: "SfeatureCls",
          layerName: "等值线",
          updateObject: {
            SrsName: "WGS1984_度",
            LayerName: "图层名",
          },
          success: function (res) {
            console.log("res: ", res);
          },
        });
       */
      updateLayerInGdbp(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          gdbSvrName: {
            type: 'String'
          },
          gdbName: {
            type: 'String'
          },
          featureType: {
            type: 'String'
          },
          layerName: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          updateObject: {
            type: 'Object',
            process(v) {
              return JSON.stringify(v)
            }
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/datasource/${options.gdbSvrName}/${options.gdbName}/${
              options.featureType
            }/${options.layerName}?f=json&userName=${defaultValue(
              options.userName,
              ''
            )}`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.editMapLayerSystemLib
       * @description 修改文档下图层的系统库,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.docName] 地图文档名称，必传
       * @param {String} [options.mapIndex] 地图索引，必传
       * @param {String} [options.systemLib] 系统库id或名称
       * @param {String} [options.layerIndexs] 图层索引列表(多个用英文逗号分隔)
       * @param {String} [options.guid] 用户会话id
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const editMapLayerSystemLib = resourceServer.editMapLayerSystemLib({
          method: FetchMethod.get,
          docName: "sz",
          mapIndex: "新地图1",
          systemLib: "DefaultSystemLib",
          layerIndexs: "0",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       */
      editMapLayerSystemLib(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          docName: {
            type: 'String'
          },
          mapIndex: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          systemLib: {
            type: 'String'
          },
          layerIndexs: {
            type: 'String'
          },
          guid: {
            type: 'String'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/doc/${options.docName}/${options.mapIndex}/setSystemLibrary?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryMapDocList
       * @description 获取发布的文档列表,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.version] 版本信息，默认为'1.0',可缺省（缺省时只返回直接发布的文档列表，如果v=2列表中将会包含目录形式发布的文档
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const queryMapDocList = resourceServer.queryMapDocList({
          method: FetchMethod.get,
          success: function (res) {
            console.log("res: ", res);
          },
        });
       */
      queryMapDocList(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          version: {
            type: 'String',
            alias: 'v'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/docs?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.addMapLayer
       * @description 添加图层到文档中指定地图,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.docName] 地图文档名称，必传
       * @param {String} [options.mapIndex] 地图索引，必传
       * @param {Object} [options.updateObject] 更新参数，必传
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const addMapLayer = resourceServer.addMapLayer({
          method: FetchMethod.post,
          docName: "sz",
          mapIndex: "新地图1",
          updateObject:{},
          success: function (res) {
            console.log("res: ", res);
          },
        });
       */
      addMapLayer(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          docName: {
            type: 'String'
          },
          mapIndex: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          updateObject: {
            type: 'Object',
            process(v) {
              return JSON.stringify(v)
            }
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/docs/${options.docName}/${options.mapIndex}/layers/add?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.removeMapLayer
       * @description 删除文档中指定地图中指定图层,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.docName] 地图文档名称，必传
       * @param {String} [options.mapIndex] 地图索引，必传
       * @param {String} [options.layerIndexs] 图层索引列表(多个用英文逗号分隔)
       * @param {String} [options.guid] 用户会话id
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const removeMapLayer = resourceServer.removeMapLayer({
          method: FetchMethod.get,
          docName: "sz",
          mapIndex: "新地图1",
          layerIndexs: "0",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       */
      removeMapLayer(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          docName: {
            type: 'String'
          },
          mapIndex: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          layerIndexs: {
            type: 'String',
            alias: 'layerIDs'
          },
          guid: {
            type: 'String'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/docs/${options.docName}/${options.mapIndex}/layers/delete?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.editMapLayerIndex
       * @description 修改文档中指定地图下图层的索引,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.docName] 地图文档名称，必传
       * @param {String} [options.mapIndex] 地图索引，必传
       * @param {String} [options.guid] 用户会话id
       * @param {String} [options.updateObject] 更新参数，必传
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
       const editMapLayerIndex = resourceServer.editMapLayerIndex({
          method: FetchMethod.post,
          docName: "sz",
          mapIndex: "新地图1",
          layerIndexs: "0",
          updateObject:{},
          success: function (res) {
            console.log("res: ", res);
          },
        });

       */
      editMapLayerIndex(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          docName: {
            type: 'String'
          },
          mapIndex: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          updateObject: {
            type: 'Object',
            process(v) {
              return JSON.stringify(v)
            }
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/docs/${options.docName}/${options.mapIndex}/layers/index?f=json&guid=${options.guid}`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryMapInfo
       * @description 获取文档详细信息,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.docName] 文档名称,必传
       * @param {Boolean} [options.tree] 是否按树形显示，缺省false
       * @param {Object} [options.include] 返回中要求包含的属性 {"IncludeDetails":true,"IncludeSubs":true}
       * @param {String} [options.returnFullStyle] 是否返回全部信息的标志位e
       * @param {String} [options.guid] 用户会话id，可以缺省
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const queryMapInfo = resourceServer.queryMapInfo({
          method: FetchMethod.get,
          docName: "sz",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       */
      queryMapInfo(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          docName: { type: 'String' }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          tree: {
            type: 'Boolean'
          },
          include: {
            type: 'Object',
            process(v) {
              return JSON.stringify(v)
            }
          },
          returnFullStyle: {
            type: 'String'
          },
          guid: {
            type: 'String'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/docs/${options.docName}?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryMapInfoByIndex
       * @description 获取指定地图的详细信息,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.docName] 地图文档名称，必传
       * @param {String} [options.mapIndex] 地图索引，必传
       * @param {Object} [options.include] 返回中要求包含的属性 {"IncludeDetails":true,"IncludeSubs":true}
       * @param {String} [options.returnFullStyle] 是否返回全部信息的标志位e
       * @param {String} [options.guid] 用户会话id，可以缺省
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
      const queryMapInfoByIndex = resourceServer.queryMapInfoByIndex({
        method: FetchMethod.get,
        docName: "sz",
        mapIndex: "0",
        success: function (res) {
          console.log("res: ", res);
        },
      });
       */
      queryMapInfoByIndex(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          docName: {
            type: 'String'
          },
          mapIndex: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          include: {
            type: 'Object',
            process(v) {
              return JSON.stringify(v)
            }
          },
          returnFullStyle: {
            type: 'String'
          },
          guid: {
            type: 'String'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/docs/${options.docName}/${options.mapIndex}?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryMapLayerInfo
       * @description 获取指定地图下所有图层的信息,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.docName] 地图文档名称，必传
       * @param {String} [options.mapIndex] 地图索引，必传
       * @param {String} [options.guid] 用户会话id，可以缺省
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const queryMapLayerInfo = resourceServer.queryMapLayerInfo({
          method: FetchMethod.get,
          docName: "sz",
          mapIndex: "0",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       */
      queryMapLayerInfo(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          docName: {
            type: 'String'
          },
          mapIndex: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          guid: {
            type: 'String'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/docs/${options.docName}/${options.mapIndex}/layers?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryMapLayerInfoByIndex
       * @description 获取指定地图下指定图层的信息,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.docName] 地图文档名称，必传
       * @param {String} [options.mapIndex] 地图索引，必传
       * @param {String} [options.layerId] 图层索引，必传
       * @param {String} [options.guid] 用户会话id，可以缺省
       * @param {String} [options.returnFullStyle] 是否返回全部信息的标志位e
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const queryMapLayerInfoByIndex = resourceServer.queryMapLayerInfoByIndex({
          method: FetchMethod.get,
          docName: "sz",
          mapIndex: "0",
          layerIndex: "0",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       */
      queryMapLayerInfoByIndex(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          docName: {
            type: 'String'
          },
          mapIndex: {
            type: 'String'
          },
          layerIndex: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          returnFullStyle: {
            type: 'String'
          },
          guid: {
            type: 'String'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/docs/${options.docName}/${options.mapIndex}/${options.layerIndex}?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryDataSourceFeatureClassList
       * @description 获取数据集下的要素类列表,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.gdbServerName] GDB数据源名称，必传
       * @param {String} [options.gdbName] GDB数据名称,必传
       * @param {String} [options.dsName] 要素数据集名称,必传
       * @param {String} [options.useName] 用户名
       * @param {String} [options.password] 密码,igs1.0有效
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
      const queryDataSourceFeatureClassList =
        resourceServer.queryDataSourceFeatureClassList({
          method: FetchMethod.get,
          gdbServerName: "MapGISLocalPlus",
          gdbName: "test",
          dsName: "test",
          success: function (res) {
            console.log("res: ", res);
          },
        });
        */
      queryDataSourceFeatureClassList(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          gdbServerName: {
            type: 'String'
          },
          gdbName: {
            type: 'String'
          },
          dsName: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          useName: {
            type: 'String',
            alias: 'user'
          },
          password: {
            type: 'String',
            alias: 'pwd'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/featurelist/${options.gdbServerName}/${options.gdbName}/${options.dsName}?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.operaGdbp
       * @description GDB操作接口,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.operType] 操作类型,必传（分为：attach、create、delete、detach）
       * @param {String} [options.gdbName] GDB数据名称,必传
       * @param {String} [options.gdbServerName] GDB数据源名称
       * @param {String} [options.useName] 用户名
       * @param {String} [options.password] 密码,igs1.0有效
       * @param {String} [options.path] hdf路径或67文件夹路径
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const operaGdbp = resourceServer.operaGdbp({
          method: FetchMethod.get,
          gdbServerName: "MapGISLocalPlus",
          gdbName: "test",
          dsName: "test",
          operType: "detach",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       */
      operaGdbp(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          operType: {
            type: 'String'
          },
          gdbName: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          gdbServerName: {
            type: 'String',
            alias: 'gdbSvrName'
          },
          gdbUserName: {
            type: 'String',
            alias: 'gdbUserName'
          },
          password: {
            type: 'String',
            alias: 'gdbPwd'
          },
          path: {
            type: 'String'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/gdb/${options.operType}/${options.gdbName}?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.editLayerSystemLib
       * @description 修改图层的系统库,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.systemLib] 系统库id或名称
       * @param {String} [options.gdbps] 图层列表，多个用英文逗号隔开
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       *  import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
      const editLayerSystemLib = resourceServer.editLayerSystemLib({
        method: FetchMethod.get,
        systemLib: "0",
        gdbps: "gdbp://MapGISLocalPlus/test/ds/test/sfcls/test_0426_feature1",
        success: function (res) {
          console.log("res: ", res);
        },
      });
       */
      editLayerSystemLib(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          systemLib: {
            type: 'String'
          },
          gdbps: {
            type: 'String'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/layer/setSystemLibrary?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryGDBPInfo
       * @description 获取GDB下某个图层的详细信息,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.gdbpUrl] gdbp地址
       * @param {String} [options.proj] 对shp图层支持投影，获取到投影后的范围，传参考系名称
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
      const queryGDBPInfo = resourceServer.queryGDBPInfo({
        method: FetchMethod.get,
        gdbpUrl:
          "gdbp://MapGISLocalPlus/test/sfcls/metro.json_Lin,gdbp://MapGISLocalPlus/test/sfcls/中国地级县x",
        proj: "WGS1984_度",
        success: function (res) {
          console.log("res: ", res);
        },
      });
       */
      queryGDBPInfo(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          gdbpUrl: {
            type: 'String'
          },
          proj: {
            type: 'String'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/layerinfo?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryLegendInfo
       * @description 获取地图文档服务的图例信息,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.docName] 服务名
       * @param {String} [options.layerIndex] 生成图例的图层索引号(多个用英文逗号分隔)
       * @param {String} [options.size] 格式：width,height
       * @param {String} [options.guid] 用户会话id
       * @param {String} [options.maxCount] 返回图例项最大数量
       * @param {String} [options.page] 页码
       * @param {String} [options.pageSize] 分页大小
       * @param {String} [options.where] 过滤条件
       * @param {String} [options.range] 范围
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
      const queryLegendInfo = resourceServer.queryLegendInfo({
        method: FetchMethod.get,
        docName: "地图文档_1",
        success: function (res) {
          console.log("res: ", res);
        },
      });
       */
      queryLegendInfo(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          docName: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          layerIndex: {
            type: 'String'
          },
          size: {
            type: 'String'
          },
          guid: {
            type: 'String'
          },
          maxCount: {
            type: 'String'
          },
          page: {
            type: 'String'
          },
          pageSize: {
            type: 'String'
          },
          where: {
            type: 'String'
          },
          range: {
            type: 'String'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/legend/${options.docName}?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.querySymbol
       * @description 修改图层的系统库,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.systemLib] 系统库guid或者名称
       * @param {String} [options.type] 类型SymbolGeomType(GeomEnt3D,GeomLin,GeomPnt,GeomReg,GeomSur3D,Unknown)
       * @param {String} [options.systemNo] 符号序号
       * @param {String} [options.systemSubNo] 符号子序号
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const querySymbol = resourceServer.querySymbol({
          method: FetchMethod.get,
          systemLib: "DefaultSystemLib",
          type: "GeomPnt",
          systemNo: "0",
          systemSubNo: "0",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       */
      querySymbol(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          systemLib: {
            type: 'String'
          },
          type: {
            type: 'String'
          },
          systemNo: {
            type: 'String'
          },
          systemSubNo: {
            type: 'String'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/symbol?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.querySymbolList
       * @description 修改图层的系统库,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.systemLib] 系统库guid或者名称
       * @param {String} [options.page] 页码(默认0)
       * @param {String} [options.size] 分页量(默认20)
       * @param {String} [options.type] 类型SymbolGeomType(GeomEnt3D,GeomLin,GeomPnt,GeomReg,GeomSur3D,Unknown)
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * // ES6引入方式
       * import { ResourceServer } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });

       */
      querySymbolList(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          systemLib: {
            type: 'String'
          },
          type: {
            type: 'String'
          },
          page: {
            type: 'String'
          },
          size: {
            type: 'String'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/symbols?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryTileList
       * @description 获取发布的瓦片列表,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.version] 版本信息，默认为'1.0',可缺省（缺省时只返回直接发布的文档列表，如果v=2列表中将会包含目录形式发布的文档
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
      const queryTileList = resourceServer.queryTileList({
        method: FetchMethod.get,
        success: function (res) {
          console.log("res: ", res);
        },
      });

       */
      queryTileList(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          version: {
            type: 'String',
            alias: 'v'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/tiles?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryTileInfo
       * @description 获取指定瓦片详细信息,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.version] 版本信息，默认为'1.0',可缺省（缺省时只返回直接发布的文档列表，如果v=2列表中将会包含目录形式发布的文档
       * @param {String} [options.name] 瓦片名称，必传
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       *   // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
      const queryTileInfo = resourceServer.queryTileInfo({
        method: FetchMethod.get,
        name: "Tile:WorldMKTTile",
        success: function (res) {
          console.log("res: ", res);
        },
      });
       */
      queryTileInfo(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          name: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          version: {
            type: 'String',
            alias: 'v'
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/tiles/${options.name}?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryVectorTileFontList
       * @description 矢量瓦片-获取字体列表,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
      const queryVectorTileFontList = resourceServer.queryVectorTileFontList({
        method: FetchMethod.get,
        success: function (res) {
          console.log("res: ", res);
        },
      });
       */
      queryVectorTileFontList(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {}
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/vtiles/fonts`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryVectorTileFont
       * @description 矢量瓦片-获取字体,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.fontstack] 字体名称,必传
       * @param {String} [options.range] 字体范围，必传
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });

       const queryVectorTileFont = resourceServer.queryVectorTileFont({
        method: FetchMethod.get,
        fontstack: "黑体",
        range: "0-255.pbf",
        success: function (res) {
          console.log("res: ", res);
        },
      });

       */
      queryVectorTileFont(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          fontstack: {
            type: 'String'
          },
          range: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {}
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/vtiles/fonts/${options.fontstack}/${options.range}?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryVectorTileStyleList
       * @description 矢量瓦片-获取所有上传样式列表,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
      const queryVectorTileStyleList = resourceServer.queryVectorTileStyleList({
        method: FetchMethod.get,
        success: function (res) {
          console.log("res: ", res);
        },
      });
       */
      queryVectorTileStyleList(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {}
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {}
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/vtiles/styles?f=json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryVectorTileStyle
       * @description 矢量瓦片-获取上传样式,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.fileName] 样式文件名
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
       const queryVectorTileStyle = resourceServer.queryVectorTileStyle({
        method: FetchMethod.get,
        fileName: "统一专题图",
        success: function (res) {
          console.log("res: ", res);
        },
      });
       */
      queryVectorTileStyle(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          fileName: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {}
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/vtiles/styles/${options.fileName}.json`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryVectorTileServiceFont
       * @description 矢量瓦片-获取指定服务的字体,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.serviceName] 矢量瓦片服务名,必传
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const queryVectorTileServiceFont = resourceServer.queryVectorTileServiceFont({
          method: FetchMethod.get,
          serviceName: "统一专题图",
          success: function (res) {
            console.log("res: ", res);
          },
        });
       */
      queryVectorTileServiceFont(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          serviceName: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {}
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/vtiles/${options.serviceName}/fonts`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryVectorTileServiceSprite
       * @description 矢量瓦片-获取服务的sprite图,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.serviceName] 矢量瓦片服务名,必传
       * @param {String} [options.format] 格式，支持后缀为.json或.png,必传
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
      const queryVectorTileServiceSprite =
        resourceServer.queryVectorTileServiceSprite({
          method: FetchMethod.get,
          serviceName: "统一专题图",
          format: ".json",
          success: function (res) {
            console.log("res: ", res);
          },
        });

       */
      queryVectorTileServiceSprite(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          format: {
            type: 'String'
          },
          serviceName: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {}
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/vtiles/${options.serviceName}/sprite${options.format}`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.updateVectorTileServiceStyle
       * @description 更新指定服务的样式,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.serviceName] 矢量瓦片服务名,必传
       * @param {Object} [options.updateObject] 更新参数，必传
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       *  // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
        const updateVectorTileServiceStyle =
          resourceServer.updateVectorTileServiceStyle({
            method: FetchMethod.post,
            serviceName: "统一专题图",
            updateObject: {},
            success: function (res) {
              console.log("res: ", res);
            },
          });
       */
      updateVectorTileServiceStyle(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          serviceName: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {
          updateObject: {
            type: 'Object',
            process(v) {
              return JSON.stringify(v)
            }
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/vtiles/${options.serviceName}/styles`
          }
        )
      }

      /**
       * @function ResourceServer.prototype.queryVectorTileServiceStyle
       * @description 矢量瓦片-获取指定服务的样式,仅支持igs1.0
       * @param options 查询参数
       * @param {String} [options.headers ] 请求头参数
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.serviceName] 矢量瓦片服务名,必传
       * @param {String} [options.tpl] 自定义地图模板的索引号,必传
       * @return {Promise<Object>}
       * @example <caption><h5>igs1.0</h5></caption>
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { FetchMethod } = Zondy.Enum
       * // ES6引入方式
       * import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
       const resourceServer = new ResourceServer({
          //服务地址
          url: "http://localhost:8089/igs/rest/mrcs",
        });
      const queryVectorTileServiceStyle = resourceServer.queryVectorTileServiceStyle({
        method: FetchMethod.get,
        serviceName: "统一专题图",
        tpl: "0",
        success: function (res) {
          console.log("res: ", res);
        },
      });
       */
      queryVectorTileServiceStyle(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          serviceName: {
            type: 'String'
          },
          tpl: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {}
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/vtiles/${options.tpl}/${options.serviceName}`
          }
        )
      }
    }

    Zondy.Service.ResourceServer = ResourceServer
    export default ResourceServer