    import BaseServer from '../BaseServer'
    import { Zondy } from '../../base'
    import { FetchMethod } from '../../base/enum'
    import { defined } from '../../util'

    /**
     * 要素服务
     * @class FeatureServer
     * @moduleEx ServiceModule
     * @extends BaseServer
     * @param {Object} options 构造参数
     * @param {String} [options.url] 服务基地址，支持igs2.0的要素服务、矢量图层的要素查询以及矢量文档的要素查询
     * @example
     * //igs2.0的要素服务
     * // ES5引入方式
     * const { FeatureServer } = Zondy.Service
     * // ES6引入方式
     * import { FeatureServer } from "@mapgis/webclient-common"
     * const featureServer = new FeatureServer({
     *   //服务地址，folder为IGS的服务管理中的文件夹夹名称，serviceName为发布的服务名
     *   url: 'http://192.168.88.12:8089/igs/rest/services/{folder}/{serviceName}/FeatureServer'
     * })
     * //基于矢量图层的要素查询
     * const featureServer = new FeatureServer({
     *   //服务地址，IGS1.0地址
     *   url: 'http://localhost:6163/igs/rest/mrfs/layer'
     *   //服务地址，IGS2.0地址
     *   //url: 'http://localhost:8089/igs/rest/mrfs/layer'
     * })
     * //基于矢量文档的要素查询
     * const featureServer = new FeatureServer({
     *   //服务地址，IGS1.0地址，serviceName为发布的服务名
     *   url: 'http://localhost:6163/igs/rest/mrfs/docs/{serviceName}'
     *   //服务地址，IGS2.0地址，serviceName为发布的服务名
     *   //url: 'http://localhost:8089/igs/rest/mrfs/docs/{serviceName}'
     * })
     */
    class FeatureServer extends BaseServer {
      constructor(options) {
        super(options)
        // 默认为igs2.0服务
        this.igsType = '2.0'
        // 是igs1.0服务
        if (this.url.indexOf('/igs/rest/mrfs') > -1) {
          this.igsType = '1.0'
        }
      }

      /**
       * 获取要素服务图层信息，支持IGS1.0,IGS2.0
       * @param options 查询参数
       * @param {String} [options.layerId] 图层id，必传
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @returns {Promise<Object>} 返回要素服务图层信息
       * @example <caption><h5>获取要素服务图层信息</h5></caption>
       * featureServer.queryLayerInfo({
       *   // 图层id
       *   layerId: '0'
       * })
       * .then((res)=>{
       *   console.log('查询图层信息成功：', res)
       * })
       * .catch((res)=>{
       *   console.log('查询图层信息失败：', res)
       * })
       */
      queryLayerInfo(options) {
        // baseurl http://localhost:8089/igs/rest/mrcs/docs/{name}
        // 拼接 {mapIndex}/{layerId}
        if (this.igsType === '1.0') {
          const baseUrl = this.url.replace('mrfs', 'mrcs')
          // 调用基类的查询信息方法
          return this._queryInfoByLayerId(options, function (url, options) {
            // 拼装返回基地址
            return `${baseUrl}/0/${options.layerId}?f=json`
          })
        }
        // 调用基类的查询信息方法
        return this._queryInfoByLayerId(options, function (url, options) {
          // 拼装返回基地址
          return `${url}/${options.layerId}?f=json`
        })
      }

      /**
       * @description 指定图层的要素查询,支持IGS2.0,IGS1.0服务
       * @param options 要素查询参数，IGS2.0服务
       * @param {String} [options.layerId ] 图层id, 必传
       * @param {String} [options.method = FetchMethod.get ] 请求类型
       * @param {queryLayerInfoSuccess} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {queryFailure} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {Geometry} [options.geometry ] 要素查询几何条件
       * @param {String} [options.geometryType ] 要素查询类型
       * @param {String} [options.where ] 要素查询where条件
       * @param {String} [options.outFields ] 输出属性字段，可为*表示所有，多个用英文逗号分隔
       * @param {String} [options.objectIds ] 过滤id，多个用英文逗号分隔(参数优先级很高，可能导致其它筛选条件失效)
       * @param {Number} [options.distance = 0] 仅igs2.0支持，几何缓冲的距离，geometry为point、line时有效（若数据源为大数据PG数据，且geometryType为line或者point时为必填数据）
       * @param {Number} [options.geometryPrecision ] 返回要素几何信息中坐标xy的精度
       * @param {Object} [options.rule] 仅1.0支持,rule={"CompareRectOnly":false,"MustInside":false,"Intersect":true},查询规则参数，JSON格式，CompareRectOnly为是否仅仅比较查询对象的外包络矩形框，MustInside为查询对象是否必须完全包含在输入的空间范围内，Intersect为是否与查询对象相交
       * @param {Boolean} [options.isAsc] 仅1.0支持,是否升序排列,格式:true/false
       * @param {SpatialRelation} [options.spatialRel ] 仅igs2.0支持，几何条件的空间判定规则，Intersects(相交)、EnvelopeIntersects(外包矩形相交)、Contains(包含)、Disjoint(相离)
       * @param {String} [options.orderByFields ] 排序字段,格式: fieldName [ASC|DESC]
       * @param {String|Array<Object>} [options.groupByFieldsForStatistics ] igs2.0 分组统计的字段信息,格式为field1,field2;igs1.0 进行分组的字段以计算统计信息，示例：[{"LayerIndex": 0,"GroupFieldName": "NAME"}]
       * @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] 仅igs2.0支持，是否只返回id，默认为false
       * @param {Boolean} [options.returnCountOnly = false] 仅igs2.0支持，是否只返回条数，默认为false
       * @param {Boolean} [options.returnExtentOnly = false] 仅igs2.0支持，是否只返回范围，默认为false
       * @param {Boolean} [options.returnZ = false] 是否返回Z轴，默认为false
       * @return {Promise<Object>} 返回指定图层要素查询结果
       * @example <caption><h5>IGS2.0的where查询</h5></caption>
       * featureServer.queryFeatures({
       *   // 图层id
       *   layerId: '1',
       *   // where语句
       *   where: "NAME='天门市'"
       * })
       * .then((res)=>{
       *     console.log('查询成功：', res)
       * })
       * .catch((res)=>{
       *     console.log('查询失败：', res)
       * })
       */
      queryFeatures(options) {
        const self = this
        let checkPathOpts
        let checkQueryOpts
        if (this.igsType === '1.0') {
          // 设置PATH PARAMETERS校验
          checkPathOpts = {
            layerId: {
              type: 'String'
            }
          }
          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            where: {
              type: 'String'
            },
            geometry: {
              type: 'Geometry'
            },
            geometryType: {
              type: 'String'
            },
            geometryPrecision: {
              type: 'Number',
              alias: 'coordPrecision'
            },
            outFields: {
              type: 'String',
              alias: 'fields'
            },
            objectIds: {
              type: 'String'
            },
            orderByFields: {
              type: 'String',
              alias: 'orderField'
            },
            groupByFieldsForStatistics: {
              type: 'Array',
              process(v) {
                return `&groupByFieldsForStatistics=${encodeURIComponent(JSON.stringify(v))}`
              }
            },
            resultRecordCount: {
              type: 'Number',
              alias: 'pageCount'
            },
            resultOffset: {
              type: 'Number',
              alias: 'page'
            },
            outStatistics: {
              type: 'OutStatistics',
              alias: 'statistics'
            },
            rule: {
              type: 'Object',
              process(v) {
                return `&rule=${encodeURIComponent(JSON.stringify(v))}`
              }
            },
            isAsc: {
              type: 'Boolean'
            },
            returnZ: {
              type: 'Boolean',
              alias: 'is3d'
            }
          }
        } else {
          // 设置PATH PARAMETERS校验
          checkPathOpts = {
            layerId: {
              type: 'String'
            }
          }
          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            where: {
              type: 'String'
            },
            geometry: {
              type: 'Geometry'
            },
            geometryType: {
              type: 'String'
            },
            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'
            },
            supportArc3: {
              type: 'Boolean'
            }
          }
        }
        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url, options) {
            if (self.igsType === '1.0') {
              const structs = {
                IncludeAttribute: true,
                IncludeGeometry: true,
                IncludeWebGraphic: false
              }
              const opt = options || {}
              if (opt) {
                if (defined(opt.returnGeometry)) {
                  structs.IncludeGeometry = opt.returnGeometry
                }
                if (defined(opt.returnAttribute)) {
                  structs.IncludeAttribute = opt.returnAttribute
                }
                if (defined(opt.returnStyle)) {
                  structs.IncludeWebGraphic = opt.returnStyle
                }
              }
              return `${url}/0/${
                options.layerId
              }/query?f=json&structs=${encodeURIComponent(JSON.stringify(structs))}`
            }
            return `${url}/${options.layerId}/query?f=json`
          }
        )
      }

      /**
       * @description 全图层要素查询，支持igs2.0、igs1.0
       * @param options 全图层要素查询参数
       * @param {String} [options.method = FetchMethod.get ] 请求类型
       * @param {queryLayerInfoSuccess} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {queryFailure} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {Array} [options.layerDefs ] 多图层的属性条件,包括layerId、where、outFields；当值为空时，查询所有图层，并当为拉框查询时，自动过滤不需要不需要查询的图层，示例："[{ "layerId":"0-0","where": "name='中国'", "outfields": "field1,field2"}]"
       * @param {Geometry} [options.geometry ] 要素查询几何条件
       * @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 {Number} [options.resultRecordCount = 20] 分页参数：结果返回条数，默认20
       * @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.returnZ = false] 是否返回Z轴，默认为false
       * @param GDBPOptions 基于矢量图层的要素查询参数
       * @param {String} [GDBPOptions.gdbp ] 图层的gdbp地址，允许多个图层，图层间用“，”号分隔，必传
       * @param {Geometry} [GDBPOptions.geometry ] 几何查询条件
       * @param {String} [GDBPOptions.where ] where查询条件，类似sql语句
       * @param {String} [GDBPOptions.objectIds ] 需要查询的要素的OID值，OID为要素的唯一标识码，多个objectIds间以“,”分隔
       * @param {Number} [GDBPOptions.page = 0] 返回的要素分页的页数，默认返回第0页
       * @param {Number} [GDBPOptions.pageCount = 20] 要素结果集每页的记录数量，默认为20条/页
       * @param {Object} [GDBPOptions.rule] 指定查询规则，参数不区分大小写，各参数的代表含义如下：
       * CompareRectOnly表示是否仅比较要素的外包矩形，来判定是否与几何约束图形有交集；EnableDisplayCondition表示是否将隐藏图层计算在内；MustInside表示是否完全包含；Intersect表示是否相交
       * @param {Object} [GDBPOptions.structs] 指定查询结果的结构，参数不区分大小写，可以省略，默认为IncludeAttribute:true，其他参数均为false；IncludeAttribute：是否包含属性信息；IncludeGeometry：是否包含空间信息；IncludeWebGraphic：是否包含图形信息（显示参数信息）
       * @param {String} [GDBPOptions.orderField] 排序字段名称，用于对输出结果进行排序，当ObjectIds有值时，orderField失效
       * @param {Boolean} [GDBPOptions.isAsc] 按照字段进行排序时，是否升序排列
       * @param DocsOptions 基于矢量文档的要素查询
       * @param {Number} [DocsOptions.mapIndex ] 地图在文档下的序号，从0开始编号，必传
       * @param {String} [DocsOptions.layerIndexes ] 图层序号，多图层间以“,”号分隔，必传
       * @param {Geometry} [DocsOptions.geometry ] 几何查询条件
       * @param {String} [DocsOptions.where ] where查询条件，类似sql语句
       * @param {String} [DocsOptions.objectIds ] 需要查询的要素的OID值，OID为要素的唯一标识码，多个objectIds间以“,”分隔
       * @param {Number} [DocsOptions.page = 0] 返回的要素分页的页数，默认返回第0页
       * @param {Number} [DocsOptions.pageCount = 20] 要素结果集每页的记录数量，默认为20条/页
       * @param {Object} [DocsOptions.rule] 指定查询规则，参数不区分大小写，各参数的代表含义如下：
       * CompareRectOnly表示是否仅比较要素的外包矩形，来判定是否与几何约束图形有交集；EnableDisplayCondition表示是否将隐藏图层计算在内；MustInside表示是否完全包含；Intersect表示是否相交
       * @param {Object} [DocsOptions.structs] 指定查询结果的结构，参数不区分大小写，可以省略，默认为IncludeAttribute:true，其他参数均为false；IncludeAttribute：是否包含属性信息；IncludeGeometry：是否包含空间信息；IncludeWebGraphic：是否包含图形信息（显示参数信息）
       * @param {String} [DocsOptions.orderField] 排序字段名称，用于对输出结果进行排序，当ObjectIds有值时，orderField失效
       * @param {Boolean} [DocsOptions.isAsc] 按照字段进行排序时，是否升序排列
       * @returns {Promise<Object>} 返回要素查询结果
       * @example <caption><h5>IGS2.0的几何查询</h5></caption>
       * featureServer.queryFeaturesInLayers({
       * // ES5引入方式
       * const { Polygon } = Zondy.Geometry
       * // ES6引入方式
       * import { Polygon } from "@mapgis/webclient-common"
       *   // 几何查询条件
       *   geometry: new Polygon({
       *     coordinates: [
       *       [
       *         [110.74, 32.41],
       *         [112.89, 31.06],
       *         [110.15, 30.16],
       *         [110.74, 32.41]
       *       ]
       *     ]
       *   })
       * })
       * .then((res)=>{
       *   console.log('查询成功：', res);
       * })
       * .catch((res)=>{
       *   console.log('查询失败：', res);
       * })
       *
       * @example <caption><h5>基于矢量文档的where查询</h5></caption>
       * featureServer.queryFeaturesInLayers({
       *   // 地图在文档下的序号，从0开始编号
       *   mapIndex: 0,
       *   // 图层序号，多图层间以“,”号分隔
       *   layerIndexes: '1',
       *   // where查询条件
       *   where: "NAME='黄石市'"
       * })
       * .then((res)=>{
       *   console.log('查询成功：', res);
       * })
       * .catch((res)=>{
       *   console.log('查询失败：', res);
       * })
       *
       * @example <caption><h5>基于矢量图层的where查询</h5></caption>
       * featureServer.queryFeaturesInLayers({
       *   // 图层的gdbp地址，允许多个图层，图层间用“，”号分隔
       *   gdbp: 'gdbp://MapGisLocalPlus/ClientTheme/ds/epsg4326/sfcls/湖北省市级区划2',
       *   // where查询条件
       *   where: "NAME='天门市'",
       * })
       * .then((res)=>{
       *   console.log('查询成功：', res);
       * })
       * .catch((res)=>{
       *   console.log('查询失败：', res);
       * })
       */
      queryFeaturesInLayers(options) {
        let checkPathOpts
        let checkQueryOpts
        // 基于矢量图层的要素查询
        if (this.url.indexOf('/igs/rest/mrfs/layer') > -1) {
          // 设置PATH PARAMETERS校验
          checkPathOpts = {}

          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            gdbp: {
              type: 'String',
              required: true
            },
            geometry: {
              type: 'Geometry',
              process: 'igsGeometryOld'
            },
            distance: {
              type: 'Number',
              process() {
                return ''
              },
              default: 0
            },
            where: {
              type: 'String'
            },
            objectIds: {
              type: 'String'
            },
            page: {
              type: 'Number'
            },
            pageCount: {
              type: 'Number'
            },
            rule: {
              type: 'Object',
              process(rule) {
                return `&rule=${encodeURIComponent(JSON.stringify(rule))}`
              }
            },
            structs: {
              type: 'Object',
              process(structs, defaultValue) {
                return `&structs=${encodeURIComponent(
                  JSON.stringify(structs || defaultValue)
                )}`
              },
              default: {
                IncludeAttribute: true,
                IncludeGeometry: true,
                IncludeWebGraphic: true
              }
            },
            orderField: {
              type: 'String'
            },
            isAsc: {
              type: 'Boolean'
            }
          }

          // 调用基类的查询信息方法
          return this._queryByParameters(
            options,
            checkPathOpts,
            checkQueryOpts,
            // 拼装返回基地址
            function (url) {
              return `${url}/query?f=json`
            }
          )
        } else if (this.url.indexOf('/igs/rest/mrfs/docs/') > -1) {
          // 基于矢量文档的要素查询
          // 设置PATH PARAMETERS校验
          checkPathOpts = {
            mapIndex: {
              type: 'Number'
            },
            layerIndexes: {
              type: 'String'
            }
          }
          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            geometry: {
              type: 'Geometry',
              process: 'igsGeometryOld'
            },
            distance: {
              type: 'Number',
              process() {
                return ''
              },
              default: 0
            },
            where: {
              type: 'String'
            },
            objectIds: {
              type: 'String'
            },
            page: {
              type: 'Number'
            },
            pageCount: {
              type: 'Number'
            },
            rule: {
              type: 'Object',
              process(rule) {
                return `&rule=${encodeURIComponent(JSON.stringify(rule))}`
              }
            },
            structs: {
              type: 'Object',
              process(structs, defaultValue) {
                return `&structs=${encodeURIComponent(
                  JSON.stringify(structs || defaultValue)
                )}`
              },
              default: {
                IncludeAttribute: true,
                IncludeGeometry: true,
                IncludeWebGraphic: true
              }
            },
            orderField: {
              type: 'String'
            },
            isAsc: {
              type: 'Boolean'
            }
          }

          // 调用基类的查询信息方法
          return this._queryByParameters(
            options,
            checkPathOpts,
            checkQueryOpts,
            // 拼装返回基地址
            function (url, options) {
              return `${url}/${options.mapIndex}/${options.layerIndexes}/query?f=json`
            }
          )
        } else {
          // 设置PATH PARAMETERS校验
          checkPathOpts = {}

          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            layerDefs: {
              type: 'Array'
            },
            geometry: {
              type: 'Geometry'
            },
            distance: {
              type: 'Number'
            },
            geometryPrecision: {
              type: 'Number'
            },
            spatialRel: {
              type: 'String'
            },
            resultRecordCount: {
              type: 'Number'
            },
            returnGeometry: {
              type: 'Boolean'
            },
            returnAttribute: {
              type: 'Boolean'
            },
            returnStyle: {
              type: 'Boolean'
            },
            returnIdsOnly: {
              type: 'Boolean'
            },
            returnCountOnly: {
              type: 'Boolean'
            },
            returnZ: {
              type: 'Boolean'
            }
          }

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

      /**
       * @description 指定图层的要素添加，支持IGS2.0的要素添加服务、基于矢量图层的要素添加服务以及基于矢量文档的要素添加
       * @param options 指定图层的要素添加参数，IGS2.0参数
       * @param {String} [options.layerId = 0] 图层id，必传
       * @param {String} [options.method = FetchMethod.get ] 请求类型
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {Array} [options.features = []] 要添加的要素集合
       * @param GDBPOptions 基于矢量图层的新增要素参数
       * @param {String} [GDBPOptions.gdbp] gdbp的url，仅支持单个数据库的要素新增，必传
       * @param {Object} [GDBPOptions.featureSet] 要更新的要素集合，注意是igs1.0的格式，必传
       * @param DocOptions 基于矢量文档的新增要素参数
       * @param {String} [DocOptions.mapIndex] 地图在文档下的序号，必传
       * @param {Object} [DocOptions.featureSet] 要更新的要素集合，注意是igs1.0的格式，必传
       * @return {Promise<Object>} 添加要素结果
       * @example <caption><h5>IGS2.0的要素新增示例</h5></caption>
       * // 创建一个线要素
       * // ES5引入方式
       * const { Feature } = Zondy
       * // ES6引入方式
       * import { Feature } from "@mapgis/webclient-common"
       * const lineString = new Feature({
       *   //可填空或者和数据库中的表结构一一对应
       *   attributes: {},
       *   //可填空或者和系统库中的样式一一对应
       *   symbol: {},
       *   //设置几何
       *   geometry: new Zondy.Geometry.LineString({
       *     coordinates: [
       *       [110.74, 32.41],
       *       [112.89, 31.06],
       *       [110.15, 30.16]
       *     ]
       *   })
       * })
       *
       * // 添加要素
       * featureServer.addFeature({
       *    // 指定图层id
       *    layerId: '0',
       *    // 要添加的要素，可以添加多个要素
       *    features: [lineString]
       *  })
       * .then((res) => {
       *   //成功回调函数
       *   console.log('添加要素: ', res)
       * })
       * .catch((res) => {
       *   //失败回调函数
       *   console.log('添加要素失败: ', res)
       * })
       *
       * @example <caption><h5>基于矢量图层的要素新增示例</h5></caption>
       * // 初始化资源服务
       * // ES5引入方式
       * const { ResourceServer} = Zondy.Service
       * const { Point} = Zondy.Geometry
       * const { Feature } = Zondy
       * // ES6引入方式
       * import { ResourceServer,Point,Feature } from "@mapgis/webclient-common"
       * const resourceServer = new ResourceServer({
       *   // 目录服务基地址，port可填6163(.net服务)或者8089(Java服务)
       *   url: 'http://localhost:6163/igs/rest/mrcs'
       * })
       * // 查询数据库表结构
       * resourceServer.queryGDBPInfo({
       *   // 要查询的gdbp的url
       *   gdbpUrl: 'gdbp://MapGisLocal/ClientTheme/sfcls/湖北省市驻地'
       * })
       * .then((result) => {
       *   // 表结构为result.data.FieldAtt
       *   // 创建一个要素
       *   const feature = new Feature({
       *     // 设置要素id，若id已在数据库中存在，则自增id
       *     id: 0,
       *     // 设置几何，支持点、多点、线、多线、区、多区
       *     geometry: new Point({
       *       coordinates: [110.66482, 31.747766]
       *     }),
       *     // 这里的属性一定要和数据库的表结构一一对应，顺序也不能出错
       *     attributes: {
       *       "CODE": "1",
       *       "NAME": "神龙架林区",
       *       "mpLayer": "0"
       *     },
       *     //设置样式
       *     symbol: {
       *       SymID": 43,
       *       SymHeight": 3.200000047683716,
       *       SymWidth": 3.200000047683716,
       *       Angle": 0,
       *       Color": 1467,
       *       Color1": 4,
       *       Color2": 3,
       *       Space": 1,
       *       OutPenW": [
       *         0.1,
       *         0.05,
       *         0.05
       *       ]
       *     }
       *   })
       *   // 创建新增要素的结构体
       *   const featureSet = {
       *     // 设置表结构，必填
       *     AttStruct: result.data.FieldAtt,
       *     // 设置要添加的要素，客串多个要素
       *     SFEleArray: [feature.toOldIGSFeature()]
       *   }
       *   // 添加要素
       *   featureServer.addFeature({
       *     // 新增要素的结构体
       *     featureSet: featureSet,
       *     // gdbo地址，仅支持单表添加
       *     gdbp: 'gdbp://MapGisLocal/ClientTheme/sfcls/湖北省市驻地'
       *   })
       *   .then((result) => {
       *      console.log('新增要素成功：', result);
       *   })
       *   .catch((result) => {
       *       console.log('新增要素失败：', result);
       *   })
       * })
       * .catch((result) => {
       *     console.log('查询GDBO失败：', result);
       * })
       *
       * @example <caption><h5>基于矢量文档的要素新增示例</h5></caption>
       * // 初始化资源服务
       * // ES5引入方式
       * const { MultiPoint} = Zondy.Geometry
       * const { Feature } = Zondy
       * // ES6引入方式
       * import { MultiPoint,Feature } from "@mapgis/webclient-common"
       * const resourceServer = new ResourceServer({
       *   // 目录服务基地址，port可填6163(.net服务)或者8089(Java服务)
       *   url: 'http://localhost:6163/igs/rest/mrcs'
       * })
       * // 查询数据库表结构
       * resourceServer.queryGDBPInfo({
       *   // 要查询的gdbp的url
       *   gdbpUrl: 'gdbp://MapGisLocal/ClientTheme/sfcls/湖北省市驻地'
       * })
       * .then((result) => {
       *   // 创建一个要素
       *   const feature = new Feature({
       *     // 设置要素id，若id已在数据库中存在，则自增id
       *     id: 0,
       *     // 设置几何，支持点、多点、线、多线、区、多区
       *     geometry: new MultiPoint({
       *       coordinates: [
       *         [109.47509, 30.270342],
       *         [111.27724, 30.706085]
       *       ]
       *     }),
       *     // 这里的属性一定要和数据库的表结构一一对应
       *     attributes: {
       *       "CODE": "0",
       *       "Name": "测试点多点2",
       *       "mpLayer": "0"
       *     },
       *     // 设置样式
       *     symbol: {
       *       "SymID": 43,
       *       "SymHeight": 3.200000047683716,
       *       "SymWidth": 3.200000047683716,
       *       "Angle": 0,
       *       "Color": 1467,
       *       "Color1": 4,
       *       "Color2": 3,
       *       "Space": 1,
       *       "OutPenW": [
       *         0.1,
       *         0.05,
       *         0.05
       *       ]
       *     }
       *   })
       *
       *   // 创建新增要素的结构体
       *   const featureSet = {
       *    // 设置表结构，必填
       *     AttStruct: result.data.FieldAtt,
       *     // 设置要添加的要素，客串多个要素
       *     SFEleArray: [feature.toOldIGSFeature()]
       *   }
       *
       *   // 添加要素
       *   featureServer.addFeature({
       *     // 新增要素的结构体
       *     featureSet: featureSet,
       *     // 地图在文档下的序号，从0开始编号
       *     mapIndex: 0,
       *     // 图层序号，从0开始编号
       *     layerIndex: 2
       *   })
       *   .then((result) => {
       *     console.log('新增要素成功：', result);
       *   })
       *   .catch((result) => {
       *     console.log('新增要素失败：', result);
       *   })
       * })
       * .catch((result) => {
       *     console.log('查询GDBO失败：', result);
       * })
       */
      addFeature(options) {
        let checkPathOpts
        let checkQueryOpts
        // 基于矢量图层的要素新增
        if (this.url.indexOf('/igs/rest/mrfs/layer') > -1) {
          // 设置PATH PARAMETERS校验
          checkPathOpts = {}
          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            gdbp: {
              type: 'String',
              required: true,
              process() {
                return ''
              }
            },
            featureSet: {
              type: 'Object',
              required: true,
              process(featureSet) {
                return encodeURIComponent(JSON.stringify(featureSet))
              }
            }
          }
          // 设置请求头，一定要是text/plain;charset=UTF-8
          options.headers = {
            'Content-Type': 'text/plain;charset=UTF-8'
          }
          options.method = FetchMethod.post
          // 调用基类的查询信息方法
          return this._queryByParameters(
            options,
            checkPathOpts,
            checkQueryOpts,
            // 拼装返回基地址
            function (url, options) {
              return `${url}/addFeatures?f=json&gdbp=${options.gdbp}`
            }
          )
        } // 基于矢量文档的要素添加
        else if (this.url.indexOf('/igs/rest/mrfs/docs') > -1) {
          // 设置PATH PARAMETERS校验
          checkPathOpts = {
            mapIndex: {
              type: 'Number'
            },
            layerIndex: {
              type: 'Number'
            }
          }
          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            featureSet: {
              type: 'Object',
              required: true,
              process(featureSet) {
                return encodeURIComponent(JSON.stringify(featureSet))
              }
            }
          }
          // 设置请求头，一定要是text/plain;charset=UTF-8
          options.headers = {
            'Content-Type': 'text/plain;charset=UTF-8'
          }
          options.method = FetchMethod.post
          // 调用基类的查询信息方法
          return this._queryByParameters(
            options,
            checkPathOpts,
            checkQueryOpts,
            // 拼装返回基地址
            function (url, options) {
              return `${url}/${options.mapIndex}/${options.layerIndex}/addFeatures?f=json`
            }
          )
        } else {
          // 设置PATH PARAMETERS校验
          checkPathOpts = {
            layerId: {
              type: 'String'
            }
          }

          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            features: {
              type: 'Array',
              process(v) {
                const features = v.map((feature) => feature.toIGSFeature())
                return `&features=${encodeURIComponent(JSON.stringify(features))}`
              }
            }
          }

          // 调用基类的查询信息方法
          return this._queryByParameters(
            options,
            checkPathOpts,
            checkQueryOpts,
            // 拼装返回基地址
            function (url) {
              return `${url}/${options.layerId}/add?f=json`
            }
          )
        }
      }

      /**
       * @description 指定图层的要素删除，支持IGS2.0的要素删除服务、基于矢量图层的要素删除服务以及基于矢量文档的要素删除服务
       * @param options 指定图层的要素删除参数，IGS2.0参数
       * @param {String} [options.layerId ] 图层id，必传
       * @param {String} [options.method = FetchMethod.get ] 请求类型
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {String} [options.objectIds ] 过滤id，多个用英文逗号分隔（使用大数据作为数据源发布的要素服务，该参数是唯一有效参数）
       * @param {String} [options.where ] 属性条件,类SQL语句
       * @param {Geometry} [options.geometry ] 空间几何条件
       * @param {Number} [options.distance ] 几何缓冲的距离，geometry为点、线时有效
       * @param {Boolean} [options.returnDeleteResults = true] 是否返回每个要素删除的结果，默认为true，如果要高效的批量删除，应设置为false
       * @param GDBPOptions 基于矢量图层的要素删除
       * @param {String} [GDBPOptions.gdbp] 图层的gdbp地址，允许多个图层，图层间用“;”号分隔，必填，例如：
       * gdbp=gdbp://MapGisLocal/示例数据/ds/世界地图/sfcls/海洋陆地;gdbp://sa@SqlServerGIS/MPDBMASTER/ds/兰伯特(全国)_400万/sfcls/中国地级县
       * @param {String} [GDBPOptions.objectIds] 需要删除的要素的OID值，OID为要素的唯一标识码，一个图层可包含多个objectIds间以“,”分隔，可包含多个图层，各个图层的objectIds间以“;”分隔，必填，lieu：
       * objectIds=1,2,3;2,3,4;8
       * @param DocOptions 基于矢量文档的要素删除
       * @param {String} [DocOptions.mapIndex] 地图在文档下的序号，从0开始编号，必填
       * @param {String} [DocOptions.layerIndex] 图层序号，从0开始编号，必填
       * @param {String} [DocOptions.objectIds] 要删除的要素id，多个id以','分割，必填
       * @return {Promise<Object>} 返回要素删除结果
       * @example <caption><h5>IGS2.0的要素删除示例</h5></caption>
       * // 删除要素
       * featureServer.deleteFeature({
       *   // 图层id
       *   layerId: '0',
       *   // 压迫删除的要素id，多个要素id以','分割
       *   objectIds: '0,1,2,3,5,6'
       * })
       * .then((res)=>{
       *   console.log('要素删除成功：', res);
       * })
       * .catch((res)=>{
       *   console.log('要素删除失败：', res);
       * })
       * @example <caption><h5>基于矢量地图的要素删除示例</h5></caption>
       * // 删除要素
       * featureServer.deleteFeature({
       *   // gdbp的url
       *   gdbp: 'gdbp://MapGisLocal/ClientTheme/sfcls/湖北省市驻地',
       *   // 要删除的要素id，多个id以','分割
       *   objectIds: '18053'
       * })
       * .then((res)=>{
       *   console.log('要素删除成功：', res);
       * })
       * .catch((res)=>{
       *   console.log('要素删除失败：', res);
       * })
       * @example <caption><h5>基于基于矢量文档的要素删除示例</h5></caption>
       * // 删除要素
       * featureServer.deleteFeature({
       *   // 地图在文档下的序号，从0开始编号
       *   mapIndex: 0,
       *   // 图层序号，从0开始编号
       *   layerIndex: 2,
       *   // 要删除的要素id，多个id以','分割
       *   objectIds: '18057'
       * })
       * .then((res)=>{
       *   console.log('要素删除成功：', res);
       * })
       * .catch((res)=>{
       *   console.log('要素删除失败：', res);
       * })
       */
      deleteFeature(options) {
        let checkPathOpts
        let checkQueryOpts
        // 基于矢量图层的要素删除
        if (this.url.indexOf('/igs/rest/mrfs/layer') > -1) {
          // 设置PATH PARAMETERS校验
          checkPathOpts = {}

          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            gdbp: {
              type: 'String'
            },
            objectIds: {
              type: 'String'
            }
          }

          // 调用基类的查询信息方法
          return this._queryByParameters(
            options,
            checkPathOpts,
            checkQueryOpts,
            // 拼装返回基地址
            function (url) {
              return `${url}/deleteFeatures?f=json`
            }
          )
        } // 基于矢量图层的要素删除
        else if (this.url.indexOf('/igs/rest/mrfs/docs') > -1) {
          // 设置PATH PARAMETERS校验
          checkPathOpts = {
            mapIndex: {
              type: 'Number'
            },
            layerIndex: {
              type: 'Number'
            }
          }

          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            objectIds: {
              type: 'String',
              required: true
            }
          }

          // 调用基类的查询信息方法
          return this._queryByParameters(
            options,
            checkPathOpts,
            checkQueryOpts,
            // 拼装返回基地址
            function (url, options) {
              return `${url}/${options.mapIndex}/${options.layerIndex}/deleteFeatures?f=json`
            }
          )
        } else {
          // 设置PATH PARAMETERS校验
          checkPathOpts = {
            layerId: {
              type: 'String'
            }
          }

          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            objectIds: {
              type: 'String'
            },
            where: {
              type: 'String'
            },
            geometry: {
              type: 'Geometry'
            },
            distance: {
              type: 'Number'
            },
            returnDeleteResults: {
              type: 'Boolean'
            }
          }

          // 调用基类的查询信息方法
          return this._queryByParameters(
            options,
            checkPathOpts,
            checkQueryOpts,
            // 拼装返回基地址
            function (url) {
              return `${url}/${options.layerId}/delete?f=json`
            }
          )
        }
      }

      /**
       * @description 指定图层的要素更新，支持IGS2.0的要素更新服务、基于矢量图层的要素更新服务以及基于矢量文档的要素更新服务
       * @param options 指定图层的要素更新参数，IGS2.0服务参数
       * @param {String} [options.layerId] 图层id，必传
       * @param {String} [options.method = FetchMethod.get ] 请求类型
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @param {Array} [options.features = []] 要更新的要素集合，需要注意要素属性必须携带FID字段才能更新
       * @param GDBPOptions 基于矢量图层的要素更新参数
       * @param {String} [GDBPOptions.gdbp] gdbp的url，仅支持单个数据库的要素更新，必传
       * @param {Object} [GDBPOptions.featureSet] 要更新的要素集合，注意是igs1.0的格式，必传
       * @return {Promise<Object>} 返回图层更新结果
       * @example <caption><h5>IGS2.0的要素更新示例</h5></caption>
       * // 创建线要素
       * // ES5引入方式
       * const { Feature } = Zondy
       * const { LineString } = Zondy.Geometry
       * // ES6引入方式
       * import { Feature } from "@mapgis/webclient-common"
       * const lineString = new Feature({
       *   // 更新要素时需要传一个FID来指定要素，其他的属性值可以根据需求来盖面
       *   attributes: { FID:'0' },
       *   // 更新样式
       *   symbol: {},
       *   // 更新几何，注意几何一定要是GDBP表对应的几何类型
       *   geometry: new LineString({
       *     coordinates: [
       *       [110.74, 32.41],
       *       [112.89, 31.06],
       *       [110.15, 30.16]
       *     ]
       *   })
       * })
       * // 更新线要素
       * featureServer.updateFeature({
       *   // 图层id
       *   layerId: '1',
       *   // 要更新的要素，支持一次更新多个要素
       *   features: [lineString]
       * })
       * .then((res) => {
       *   console.log('要素更新成功: ', res)
       * })
       * .catch((res) => {
       *   console.log('要素更新失败: ', res)
       * })
       *
       * @example <caption><h5>基于矢量图层的要素更新示例</h5></caption>
       * // 初始化资源服务
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { Feature } = Zondy
       * const { Point } = Zondy.Geometry
       * // ES6引入方式
       * import { ResourceServer,Feature, Point} from "@mapgis/webclient-common"
       * const resourceServer = new ResourceServer({
       *   // 目录服务基地址，port可填6163(.net服务)或者8089(Java服务)
       *   url: 'http://localhost:6163/igs/rest/mrcs'
       * })
       * // 查询数据库表结构
       * resourceServer.queryGDBPInfo({
       *   // 要查询的gdbp的url
       *   gdbpUrl: 'gdbp://MapGisLocal/ClientTheme/sfcls/湖北省市驻地'
       * })
       * .then((result) => {
       *   // 表结构为result.data.FieldAtt
       *   // 创建一个要素
       *   const feature = new Feature({
       *     // 设置更新要素的id
       *     id: 1220,
       *     // 设置几何，支持点、多点、线、多线、区、多区
       *     geometry: new Point({
       *       coordinates: [110.66482, 31.747766]
       *     }),
       *     // 更新属性
       *     attributes: {
       *       "CODE": "1",
       *       "NAME": "新的神龙架林区",
       *       "mpLayer": "0"
       *     },
       *     //更新样式
       *     symbol: {
       *       SymID": 43,
       *       SymHeight": 3.200000047683716,
       *       SymWidth": 3.200000047683716,
       *       Angle": 0,
       *       Color": 1467,
       *       Color1": 4,
       *       Color2": 3,
       *       Space": 1,
       *       OutPenW": [
       *         0.1,
       *         0.05,
       *         0.05
       *       ]
       *     }
       *   })
       *   // 创建更新要素的结构体
       *   const featureSet = {
       *     // 设置表结构，必填
       *     AttStruct: result.data.FieldAtt,
       *     // 设置要添加的要素，客串多个要素
       *     SFEleArray: [feature.toOldIGSFeature()]
       *   }
       *   // 更新要素
       *   featureServer.updateFeature({
       *     // 更新要素的结构体
       *     featureSet: featureSet,
       *     // gdbo地址，仅支持单表添加
       *     gdbp: 'gdbp://MapGisLocal/ClientTheme/sfcls/湖北省市驻地'
       *   })
       *   .then((result) => {
       *      console.log('更新要素成功：', result);
       *   })
       *   .catch((result) => {
       *       console.log('更新要素失败：', result);
       *   })
       * })
       * .catch((result) => {
       *     console.log('查询GDBO失败：', result);
       * })
       *
       * @example <caption><h5>基于矢量文档的要素更新示例</h5></caption>
       * // 初始化资源服务
       * // ES5引入方式
       * const { ResourceServer } = Zondy.Service
       * const { Feature } = Zondy
       * const { MultiPoint } = Zondy.Geometry
       * // ES6引入方式
       * import { ResourceServer,Feature,MultiPoint } from "@mapgis/webclient-common"
       * const resourceServer = new ResourceServer({
       *   // 目录服务基地址，port可填6163(.net服务)或者8089(Java服务)
       *   url: 'http://localhost:6163/igs/rest/mrcs'
       * })
       * // 查询数据库表结构
       * resourceServer.queryGDBPInfo({
       *   // 要查询的gdbp的url
       *   gdbpUrl: 'gdbp://MapGisLocal/ClientTheme/sfcls/湖北省市驻地'
       * })
       * .then((result) => {
       *   // 创建一个要素
       *   const feature = new Feature({
       *     // 设置要更新的要素id
       *     id: 0,
       *     // 设置几何，支持点、多点、线、多线、区、多区
       *     geometry: new MultiPoint({
       *       coordinates: [
       *         [109.47509, 30.270342],
       *         [111.27724, 30.706085]
       *       ]
       *     }),
       *     // 更新属性
       *     attributes: {
       *       "CODE": "0",
       *       "Name": "多点",
       *       "mpLayer": "0"
       *     },
       *     // 更新样式
       *     symbol: {
       *       "SymID": 43,
       *       "SymHeight": 3.200000047683716,
       *       "SymWidth": 3.200000047683716,
       *       "Angle": 0,
       *       "Color": 1467,
       *       "Color1": 4,
       *       "Color2": 3,
       *       "Space": 1,
       *       "OutPenW": [
       *         0.1,
       *         0.05,
       *         0.05
       *       ]
       *     }
       *   })
       *
       *   // 创建更新要素的结构体
       *   const featureSet = {
       *    // 设置表结构，必填
       *     AttStruct: result.data.FieldAtt,
       *     // 设置要更新的要素，客串多个要素
       *     SFEleArray: [feature.toOldIGSFeature()]
       *   }
       *
       *   // 更新要素
       *   featureServer.updateFeature({
       *     // 更新要素的结构体
       *     featureSet: featureSet,
       *     // 地图在文档下的序号，从0开始编号
       *     mapIndex: 0,
       *     // 图层序号，从0开始编号
       *     layerIndex: 2
       *   })
       *   .then((result) => {
       *     console.log('更新要素成功：', result);
       *   })
       *   .catch((result) => {
       *     console.log('更新要素失败：', result);
       *   })
       * })
       * .catch((result) => {
       *     console.log('查询GDBO失败：', result);
       * })
       */
      updateFeature(options) {
        let checkPathOpts
        let checkQueryOpts
        // 基于矢量图层的要素更新
        if (this.url.indexOf('/igs/rest/mrfs/layer') > -1) {
          // 设置PATH PARAMETERS校验
          checkPathOpts = {}
          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            gdbp: {
              type: 'String',
              required: true,
              process() {
                return ''
              }
            },
            featureSet: {
              type: 'Object',
              required: true,
              process(featureSet) {
                return encodeURIComponent(JSON.stringify(featureSet))
              }
            }
          }
          // 设置请求头，一定要是text/plain;charset=UTF-8
          options.headers = {
            'Content-Type': 'text/plain;charset=UTF-8'
          }
          options.method = FetchMethod.post
          // 调用基类的查询信息方法
          return this._queryByParameters(
            options,
            checkPathOpts,
            checkQueryOpts,
            // 拼装返回基地址
            function (url, options) {
              return `${url}/updateFeatures?f=json&gdbp=${options.gdbp}`
            }
          )
        } // 基于地图文档的要素更新
        else if (this.url.indexOf('/igs/rest/mrfs/docs') > -1) {
          // 设置PATH PARAMETERS校验
          checkPathOpts = {
            mapIndex: {
              type: 'Number'
            },
            layerIndex: {
              type: 'Number'
            }
          }
          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            featureSet: {
              type: 'Object',
              required: true,
              process(featureSet) {
                return encodeURIComponent(JSON.stringify(featureSet))
              }
            }
          }
          // 设置请求头，一定要是text/plain;charset=UTF-8
          options.headers = {
            'Content-Type': 'text/plain;charset=UTF-8'
          }
          options.method = FetchMethod.post
          // 调用基类的查询信息方法
          return this._queryByParameters(
            options,
            checkPathOpts,
            checkQueryOpts,
            // 拼装返回基地址
            function (url, options) {
              return `${url}/${options.mapIndex}/${options.layerIndex}/updateFeatures?f=json`
            }
          )
        } else {
          // 设置PATH PARAMETERS校验
          checkPathOpts = {
            layerId: {
              type: 'String'
            }
          }

          // 设置QUERY PARAMETERS校验
          checkQueryOpts = {
            features: {
              type: 'Array',
              process(v) {
                const features = v.map((feature) => feature.toIGSFeature())
                return `&features=${encodeURIComponent(JSON.stringify(features))}`
              }
            }
          }

          // 调用基类的查询信息方法
          return this._queryByParameters(
            options,
            checkPathOpts,
            checkQueryOpts,
            // 拼装返回基地址
            function (url) {
              return `${url}/${options.layerId}/update?f=json`
            }
          )
        }
      }

      /**
       * @description 根据id获取指定图层指定要素，IGS2.0新增服务
       * @param options 获取指定图层指定要素参数
       * @param {String} [options.layerId ] 图层id，必传
       * @param {Array} [options.featureId ] 要素id，必传
       * @param {String} [options.method = FetchMethod.get ] 请求类型
       * @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
       * @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
       * @return {Promise<Object>} 返回指定图层指定要素
       * @example <caption><h5>根据id获取指定图层指定要素</h5></caption>
       * featureServer.queryFeatureById({
       *   // 图层id
       *   layerId: '0',
       *   // 要素id
       *   featureId: '437'
       * })
       * .then((res) => {
       *   console.log('要素查询成功：', res)
       * })
       * .catch((res) => {
       *   console.log('要素查询失败：', res)
       * })
       */
      queryFeatureById(options) {
        // 设置PATH PARAMETERS校验
        const checkPathOpts = {
          layerId: {
            type: 'String'
          },
          featureId: {
            type: 'String'
          }
        }
        // 设置QUERY PARAMETERS校验
        const checkQueryOpts = {}

        // 只支持get方式
        options.method = FetchMethod.get

        // 调用基类的查询信息方法
        return this._queryByParameters(
          options,
          checkPathOpts,
          checkQueryOpts,
          // 拼装返回基地址
          function (url) {
            return `${url}/${options.layerId}/${options.featureId}?f=json`
          }
        )
      }
    }

    Zondy.Service.FeatureServer = FeatureServer
    export default FeatureServer