import {
Extent,
Geometry,
Polygon,
SpatialReference,
LineString,
MultiLineString,
Point,
Circle,
MultiPolygon,
MultiPoint
} from '../base/geometry'
import Log from '../util/Log'
import { defaultValue, isBoolean, isNull, isNumber, isString } from '../util'
import { Color, Feature, FeatureSet } from '../base'
/**
* @private
* @description 获取查询参数字符串
* @param fields 字段名数组
* @param options 查询参数
* @param checkOptions 检测规则
* @return String GUID
*/
function getParameters(fields, options, checkOptions) {
let url = ''
for (let i = 0; i < fields.length; i++) {
// 获取查询条件
const _filter = defaultValue(
options[fields[i]],
checkOptions[fields[i]].default
)
// 必须不为空
if (_filter !== undefined) {
let str = ''
// 没有process参数，走类型判断
if (isNull(checkOptions[fields[i]].process)) {
// 根据类型进行数据处理
switch (checkOptions[fields[i]].type) {
case 'String':
case 'Number':
case 'Boolean':
url += `&${
checkOptions[fields[i]].alias || fields[i]
}=${encodeURIComponent(_filter)}`
break
case 'Geometry':
case 'Point':
case 'MultiPoint':
case 'Extent':
case 'Circle':
case 'LineString':
case 'MultiLineString':
case 'Polygon':
case 'MultiPolygon':
url += `&${fields[i]}=${encodeURIComponent(
_filter.toString()
)}&geometryType=${encodeURIComponent(_filter.getIGSType())}`
break
case 'layerDefs':
str = '['
for (let i = 0; i < _filter.length; i++) {
if (
_filter[i] instanceof Object &&
!(_filter[i] instanceof Array)
) {
str += '{'
Object.keys(_filter[i]).forEach((key) => {
if (_filter[i].hasOwnProperty(key)) {
str += `"${key}":"${_filter[i][key]}",`
}
})
str = str.substring(0, str.length - 1)
str += '},'
}
}
if (_filter.length > 0) {
str = str.substring(0, str.length - 1)
}
str += ']'
if (str !== '[]') {
url += `&${fields[i]}=${encodeURIComponent(str)}`
}
break
case 'OutStatistics':
str += '['
for (let i = 0; i < _filter.length; i++) {
if (
_filter[i] instanceof Object &&
!(_filter[i] instanceof Array)
) {
str += '{'
Object.keys(_filter[i]).forEach((key) => {
if (_filter[i].hasOwnProperty(key)) {
if (
key === 'statisticType' ||
key === 'onStatisticField' ||
key === 'outStatisticFieldName'
) {
str += `"${key}":"${_filter[i][key]}",`
}
}
})
str = str.substring(0, str.length - 1)
str += '},'
}
}
if (_filter.length > 0) {
str = str.substring(0, str.length - 1)
}
str += ']'
if (str !== '[]') {
url += `&${fields[i]}=${encodeURIComponent(str)}`
}
break
case 'FeatureSet':
str = `&${fields[i]}=${encodeURIComponent(
JSON.stringify(options[fields[i]].toGeoJSON())
)}`
url += str
break
case 'FeatureCollection':
url += `&${fields[i]}=${encodeURIComponent(
JSON.stringify(options[fields[i]])
)}`
break
default:
url += `&${fields[i]}=${encodeURIComponent(_filter)}`
}
} else if (typeof checkOptions[fields[i]].process === 'string') {
// 有定义好的处理类型
switch (checkOptions[fields[i]].process) {
case 'igsGeometryServer':
url += `&${fields[i]}=${encodeURIComponent(
JSON.stringify(_filter.toGeoJSON())
)}&srs=`
// 确保spatialReference存在
if (_filter.spatialReference) {
// 是SpatialReference对象
if (_filter.spatialReference instanceof SpatialReference) {
url += encodeURIComponent(_filter.spatialReference.toString())
} else if (
_filter.spatialReference instanceof Object &&
!(_filter.spatialReference instanceof Array)
) {
// 外部传入一个对象
url += encodeURIComponent(
_filter.spatialReference.wkt
? _filter.spatialReference.wkt
: 'EPSG:4326'
)
} else if (typeof _filter.spatialReference === 'string') {
// 传入字符串
url += encodeURIComponent(_filter.spatialReference)
}
} else {
// spatialReference不存在，默认EPSG:4326
url += encodeURIComponent('EPSG:4326')
}
break
case 'igsGeometryServerNoSRS':
url += `&${fields[i]}=${encodeURIComponent(
JSON.stringify(_filter.toGeoJSON())
)}`
break
case 'igsRange$':
url += `&${
checkOptions[fields[i]].alias || fields[i]
}=${encodeURIComponent(_filter.toIGSOldString())}`
break
case 'igsGeometryOld':
if (_filter.type === 'Point' || _filter.type === 'LineString') {
if (_filter.type === 'Point' && _filter.hasZ === true) {
url += `&${fields[i]}=${encodeURIComponent(
`${_filter.toString()},${
options['distance'] || checkOptions['distance'].default
}`
)}&geometryType=${encodeURIComponent(_filter.getIGSType())}`
} else {
url += `&${fields[i]}=${encodeURIComponent(
`${_filter.toString()};${
options['distance'] || checkOptions['distance'].default
}`
)}&geometryType=${encodeURIComponent(_filter.getIGSType())}`
}
} else {
url += `&${fields[i]}=${encodeURIComponent(
_filter.toString()
)}&geometryType=${encodeURIComponent(_filter.getIGSType())}`
}
break
default:
url += `&${fields[i]}=${encodeURIComponent(
_filter.toString()
)}&geometryType=${encodeURIComponent(_filter.getIGSType())}`
}
} else if (checkOptions[fields[i]].process instanceof Function) {
// 方法类型
url += checkOptions[fields[i]].process(
options[fields[i]],
checkOptions[fields[i]].default
)
}
}
}
return url
}
function getParametersObject(fields, options, checkOptions) {
const data = {}
for (let i = 0; i < fields.length; i++) {
// 获取查询条件
const _filter = defaultValue(
options[fields[i]],
checkOptions[fields[i]].default
)
// 必须不为空
if (_filter !== undefined) {
// 没有process参数，走类型判断
if (isNull(checkOptions[fields[i]].process)) {
// 根据类型进行数据处理
switch (checkOptions[fields[i]].type) {
case 'String':
case 'Number':
case 'Boolean':
default:
data[checkOptions[fields[i]].alias || fields[i]] = _filter
break
case 'Geometry':
case 'Point':
case 'MultiPoint':
case 'Extent':
case 'Circle':
case 'LineString':
case 'MultiLineString':
case 'Polygon':
case 'MultiPolygon':
data[
checkOptions[fields[i]].alias || fields[i]
] = `${_filter.toString()}&geometryType=${_filter.getIGSType()}`
break
}
} else if (typeof checkOptions[fields[i]].process === 'string') {
// 有定义好的处理类型
switch (checkOptions[fields[i]].process) {
case 'igsDots':
data[checkOptions[fields[i]].alias || 'Dots'] = _filter.toDots()
break
case 'toOldIGSGeometry':
switch (_filter.type) {
case 'Point':
data[checkOptions[fields[i]].alias || 'Pnt'] =
_filter.toOldIGSGeometry().PntGeom[0]
break
case 'LineString':
data[checkOptions[fields[i]].alias || 'Line'] =
_filter.toOldIGSGeometry().LinGeom[0]
break
case 'Polygon':
data[checkOptions[fields[i]].alias || 'Reg'] =
_filter.toOldIGSGeometry().RegGeom[0]
break
default:
}
break
default:
data[checkOptions[fields[i]].alias || fields[i]] = _filter
}
} else if (checkOptions[fields[i]].process instanceof Function) {
// 方法类型
data[fields[i]] = checkOptions[fields[i]].process(
options[fields[i]],
checkOptions[fields[i]].default
)
}
}
}
return encodeURIComponent(JSON.stringify(data))
}
/**
* 检测输入参数类型是否是OutStatistics
* @private
* @param {OutStatistics} param 输入参数
* @return {Boolean} 是否是正确的类型
* */
function isOutStatistics(param) {
// 首先必须是数组
if (!(param instanceof Array)) {
return false
}
// 循环所有子元素
for (let i = 0; i < param.length; i++) {
// 子元素一定是对象
if (!(param[i] instanceof Object)) {
return false
}
// 子元素不可以是数组
if (param[i] instanceof Object && param[i] instanceof Array) {
return false
}
// 子元素必须包含statisticType、onStatisticField以及outStatisticFieldName
if (
!param[i].hasOwnProperty('statisticType') ||
!param[i].hasOwnProperty('onStatisticField') ||
!param[i].hasOwnProperty('outStatisticFieldName')
) {
return false
}
// 子元素的statisticType、onStatisticField以及outStatisticFieldName必须不为空
if (
isNull(param[i]['statisticType']) ||
isNull(param[i]['onStatisticField']) ||
isNull(param[i]['outStatisticFieldName'])
) {
return false
}
// 子元素的statisticType、onStatisticField以及outStatisticFieldName必须为String类型
if (
!isString(param[i]['statisticType']) ||
!isString(param[i]['onStatisticField']) ||
!isString(param[i]['outStatisticFieldName'])
) {
return false
}
}
return true
}
/**
* 检测输入参数类型是否正确
* @private
* @param {String} type 输入参数类型
* @param {Any} param 输入参数
* @return {Boolean} 是否是正确的类型
* */
function checkType(type, param) {
if (typeof type === 'function') {
return type(param)
}
let flag
switch (type) {
case 'String':
flag = isString(param)
break
case 'Number':
flag = isNumber(param)
break
case 'Boolean':
flag = isBoolean(param)
break
case 'Extent':
flag = param instanceof Extent
break
case 'Geometry':
flag = param instanceof Geometry
break
case 'Point':
flag = param instanceof Point
break
case 'Polygon':
flag = param instanceof Polygon
break
case 'MultiPolygon':
flag = param instanceof MultiPolygon
break
case 'Circle':
flag = param instanceof Circle
break
case 'LineString':
flag = param instanceof LineString
break
case 'MultiLineString':
flag = param instanceof MultiLineString
break
case 'LineString | MultiLineString':
flag = param instanceof LineString || param instanceof MultiLineString
break
case 'Polygon | Extent':
flag = param instanceof Polygon || param instanceof Extent
break
case 'Array':
flag = param instanceof Array
break
case 'Object':
flag = param instanceof Object
break
case 'OutStatistics':
flag = isOutStatistics(param)
break
case 'FeatureSet':
flag = param instanceof FeatureSet
break
case 'FeatureCollection':
flag =
param instanceof Object &&
!(param instanceof Array) &&
param.hasOwnProperty('features') &&
param.type === 'FeatureCollection'
break
case 'Color':
flag = param instanceof Color
break
default:
flag = isString(param)
}
return flag
}
/**
* 检测输入参数正确性
* @private
* @param {Object} options 输入参数
* @param {Object} checkOptions 检测规则
* */
function checkParam(options, checkOptions) {
// 是否检测通过
let isChecked = true
// 错误信息
let errorMessage = ''
// 错误类型
let errorType = ''
// 错误变量名
let wrongKey
// 请求参数
let queryString = ''
// 不通过检测不走下面的逻辑
try {
// 检测类型
let flag = true
Object.keys(checkOptions).forEach(function (key) {
if (
(options.hasOwnProperty(key) && checkOptions.hasOwnProperty(key)) ||
(checkOptions.hasOwnProperty(key) && checkOptions[key].required)
) {
// 检测空输入
if (checkOptions[key].required) {
// 不是多选一
if (isNull(checkOptions[key].oneOf)) {
if (isNull(options[key])) {
wrongKey = key
throw new Error('isNull')
}
} // 是多选一，如果都为空，才报错
else {
// 是否都为空
let allIsNull = false
// 确定本身是否为空
if (isNull(options[key])) {
allIsNull = true
}
// 确定其他的可选参数是否为空
for (let i = 0; i < checkOptions[key].oneOf.length; i++) {
if (!isNull(options[checkOptions[key].oneOf[i]])) {
allIsNull = false
break
}
}
// 如果都为空，报错
if (allIsNull) {
wrongKey = `${key},${checkOptions[key].oneOf.toString()}`
throw new Error('isNull')
}
}
}
// 由于上面做了多选一的判断，这里进行下非空判断
if (!isNull(options[key])) {
flag = checkType(checkOptions[key].type, options[key])
}
if (!flag) {
wrongKey = key
throw new Error('wrongType')
}
}
})
if (flag) {
const fields = []
Object.keys(checkOptions).forEach((key) => {
if (checkOptions.hasOwnProperty(key)) {
fields.push(key)
}
})
if (options.useObject) {
queryString = getParametersObject(fields, options, checkOptions)
} else {
queryString = getParameters(fields, options, checkOptions)
}
}
} catch (e) {
isChecked = false
switch (e.message) {
case 'isNull':
errorMessage = `${wrongKey}值不能为空！`
errorType = 'isNull'
Log.error(errorMessage)
break
case 'wrongType':
errorMessage = `${wrongKey}类型错误！`
errorType = 'isWrongType'
Log.error(errorMessage)
break
default:
errorMessage = `${wrongKey}值不能为空！`
errorType = 'isNull'
Log.error(errorMessage)
}
}
return {
isChecked,
errorMessage,
errorType,
queryString
}
}
/**
* 验证所有PathParameter参数的正确性，PathParameter里的参数都是必填参数，必须验证正确性
* @private
* @param {Object} checkOptions 验证对象
* @param {Object} options 请求参数对象
* @return {Object} 是否验证通过对象
* */
function checkPathParameters(checkOptions, options) {
let errorType = ''
let errorMessage = ''
let isChecked = true
// try&catch是为了跳出forEach的循环
try {
Object.keys(checkOptions).forEach((key) => {
// 要检测某个参数
if (checkOptions.hasOwnProperty(key)) {
// 有这个参数的值
if (options.hasOwnProperty(key)) {
const param = options[key]
// 非空判断
if (isNull(param)) {
errorType = 'isNull'
isChecked = false
throw new Error(`${key}不能为空！`)
}
// 类型判断
if (!checkType(checkOptions[key].type, options[key])) {
errorType = 'isWrongType'
isChecked = false
throw new Error(`${key}类型错误！`)
}
} else {
// 没有这个参数的值
errorType = 'isNull'
isChecked = false
throw new Error(`${key}不能为空！`)
}
}
})
} catch (e) {
Log.error(e)
errorMessage = e
return {
isChecked,
errorMessage,
errorType
}
}
return {
isChecked,
errorMessage,
errorType
}
}
/**
* 获取XML的DOM对象
* @param xml xml字符串对象
* @return string
*/
function getDoc(xml) {
let xmlDoc = null
if (window.DOMParser) {
const parser = new DOMParser()
xmlDoc = parser.parseFromString(xml, 'text/xml')
} else {
// IE
// eslint-disable-next-line no-undef
xmlDoc = new ActiveXObject('Microsoft.XMLDOM')
xmlDoc.async = 'false'
xmlDoc.loadXML(xml)
}
return xmlDoc
}
/**
* 从DOM元素中获取信息
* @param dom dom元素
* @param WMSInfo WMS信息对象
*/
function getWMSInfoFromDOM(dom, WMSInfo) {
// 取得整个图层的Title信息
if (dom.nodeName === 'Name') {
WMSInfo.name = dom.innerHTML
} else if (dom.nodeName === 'Abstract') {
// WMS的1.1.1版本信息
WMSInfo.abstract = dom.innerHTML
} else if (dom.nodeName === 'Title') {
let title = dom.innerHTML
// 注意排除文件夹名
if (title.indexOf(':') > -1) {
title = title.split(':')[1]
}
WMSInfo.title = title
} else if (dom.nodeName === 'SRS') {
// 取得整个图层的SRS信息
WMSInfo.srs.push(dom.innerHTML)
} else if (dom.nodeName === 'CRS') {
// 取得整个图层的CRS信息
WMSInfo.crs.push(dom.innerHTML)
} else if (dom.nodeName === 'BoundingBox') {
// 取得整个图层的BoundingBox信息
let boundingBox = {}
// WMS 1.1.1版本是SRS
if (dom.attributes.SRS) {
boundingBox = {
minx: dom.attributes.minx.value,
miny: dom.attributes.miny.value,
maxx: dom.attributes.maxx.value,
maxy: dom.attributes.maxy.value
}
boundingBox.srs = dom.attributes.SRS.value
} else if (dom.attributes.CRS) {
const EPSG = dom.attributes.CRS.value
const epsgNo = Number(EPSG.split(':')[1])
// 高斯坐标系，xy反转
if (
(epsgNo >= 2327 && epsgNo <= 2442) ||
(epsgNo >= 4491 && epsgNo <= 4554) ||
(epsgNo >= 21413 && epsgNo <= 21423) ||
(epsgNo >= 21473 && epsgNo <= 21483)
) {
boundingBox = {
minx: dom.attributes.miny.value,
miny: dom.attributes.minx.value,
maxx: dom.attributes.maxy.value,
maxy: dom.attributes.maxx.value
}
}
// 经纬度，xy反转
else if (
epsgNo === 4326 ||
epsgNo === 4214 ||
epsgNo === 4490 ||
epsgNo === 4610
) {
boundingBox = {
minx: dom.attributes.miny.value,
miny: dom.attributes.minx.value,
maxx: dom.attributes.maxy.value,
maxy: dom.attributes.maxx.value
}
}
// 其他xy正常
else {
boundingBox = {
minx: dom.attributes.minx.value,
miny: dom.attributes.miny.value,
maxx: dom.attributes.maxx.value,
maxy: dom.attributes.maxy.value
}
}
// WMS 1.3.0版本是CRS
boundingBox.crs = dom.attributes.CRS.value
}
WMSInfo.boundingBox.push(boundingBox)
} else if (dom.nodeName === 'LatLonBoundingBox') {
// WMS的1.1.1版本信息
WMSInfo.latLonBoundingBox = {
minx: dom.attributes.miny.value,
miny: dom.attributes.minx.value,
maxx: dom.attributes.maxy.value,
maxy: dom.attributes.maxx.value
}
} else if (dom.nodeName === 'EX_GeographicBoundingBox') {
// WMS的1.3.0版本信息
WMSInfo.geographicBoundingBox = {
westBoundLongitude: dom.childNodes[0].innerHTML,
eastBoundLongitude: dom.childNodes[1].innerHTML,
southBoundLatitude: dom.childNodes[2].innerHTML,
northBoundLatitude: dom.childNodes[3].innerHTML
}
}
}
/**
* 将XML的Document对象转换为JSON字符串
* @param xmlDoc xml的Document对象
* @param version WMS版本
* @return {Object} WMS的元数据信息
*/
function getWMSInfoFromXML(xmlDoc, version) {
const WMSInfo = {
boundingBox: [],
layer: []
}
if (version === '1.3.0') {
WMSInfo.crs = []
} else {
WMSInfo.srs = []
}
// 获取xml文档的所有子节点
const nodeList = xmlDoc.childNodes
for (let i = 0; i < nodeList.length; i++) {
// 取得localName为WMT_MS_Capabilities的子元素，注意一定是localName
if (
nodeList[i].nodeName === 'WMT_MS_Capabilities' ||
nodeList[i].nodeName === 'WMS_Capabilities'
) {
const childNodes = nodeList[i].childNodes
for (let j = 0; j < childNodes.length; j++) {
// 只取nodeName为Capability的子元素
if (childNodes[j].nodeName === 'Capability') {
const cbChildren = childNodes[j].childNodes
for (let k = 0; k < cbChildren.length; k++) {
// 取Capability里面名字为Layer的子元素
if (cbChildren[k].nodeName === 'Layer') {
const layerChildren = cbChildren[k].childNodes
// 取得整个图层的WMS信息
for (let m = 0; m < layerChildren.length; m++) {
// 取得所有Layer信息
if (layerChildren[m].nodeName === 'Layer') {
const layerInfos = layerChildren[m].childNodes
const layerInfo = {
boundingBox: []
}
if (version === '1.3.0') {
layerInfo.crs = []
} else {
layerInfo.srs = []
}
for (let n = 0; n < layerInfos.length; n++) {
// 取得单个图层的WMS信息
getWMSInfoFromDOM(layerInfos[n], layerInfo)
}
WMSInfo.layer.push(layerInfo)
} else {
// 取得其他信息
getWMSInfoFromDOM(layerChildren[m], WMSInfo)
}
}
break
}
}
break
}
}
break
}
}
return WMSInfo
}
/**
* 将XML的Document对象转换为JSON字符串
* @param xmlDoc xml的Document对象
* @return {Object} WMTS的元数据信息
*/
function getWMTSInfoFromXML(xmlDoc) {
const rootChildren = xmlDoc.childNodes
const WMTSInfo = {
layer: {
infoFormat: [],
tileMatrixSetLink: []
},
tileMatrixSet: []
}
for (let i = 0; i < rootChildren.length; i++) {
// 仅取Capabilities上的信息
if (rootChildren[i].nodeName === 'Capabilities') {
const cbChildren = rootChildren[i].childNodes
for (let j = 0; j < cbChildren.length; j++) {
// 仅取Contents上的信息
if (cbChildren[j].nodeName === 'Contents') {
const ctChildren = cbChildren[j].childNodes
for (let k = 0; k < ctChildren.length; k++) {
// 获取Layer上的信息
if (ctChildren[k].nodeName === 'Layer') {
const layerInfos = ctChildren[k].childNodes
for (let x = 0; x < layerInfos.length; x++) {
if (layerInfos[x].nodeName === 'ows:Title') {
WMTSInfo.layer.title = layerInfos[x].innerHTML
} else if (layerInfos[x].nodeName === 'ows:Identifier') {
WMTSInfo.layer.identifier = layerInfos[x].innerHTML
} else if (layerInfos[x].nodeName === 'ows:BoundingBox') {
const boundingBox = {}
for (let l = 0; l < layerInfos[x].childNodes.length; l++) {
if (
layerInfos[x].childNodes[l].nodeName === 'ows:LowerCorner'
) {
boundingBox.lowerCorner =
layerInfos[x].childNodes[l].innerHTML
}
if (
layerInfos[x].childNodes[l].nodeName === 'ows:UpperCorner'
) {
boundingBox.upperCorner =
layerInfos[x].childNodes[l].innerHTML
}
}
WMTSInfo.layer.boundingBox = boundingBox
} else if (layerInfos[x].nodeName === 'ows:WGS84BoundingBox') {
WMTSInfo.layer.WGS84BoundingBox = {
lowerCorner: layerInfos[x].childNodes[0].innerHTML,
upperCorner: layerInfos[x].childNodes[1].innerHTML
}
} else if (layerInfos[x].nodeName === 'Style') {
const Style = {}
for (let l = 0; l < layerInfos[x].childNodes.length; l++) {
if (
layerInfos[x].childNodes[l].nodeName === 'ows:Identifier'
) {
Style.identifier = layerInfos[x].childNodes[l].innerHTML
}
if (layerInfos[x].childNodes[l].nodeName === 'ows:Title') {
Style.title = layerInfos[x].childNodes[l].innerHTML
}
}
WMTSInfo.layer.Style = Style
} else if (layerInfos[x].nodeName === 'Format') {
WMTSInfo.layer.format = layerInfos[x].innerHTML
} else if (layerInfos[x].nodeName === 'InfoFormat') {
WMTSInfo.layer.infoFormat.push(layerInfos[x].innerHTML)
} else if (layerInfos[x].nodeName === 'TileMatrixSetLink') {
const links = layerInfos[x].childNodes
const TileMatrixSetLink = {
tileMatrixSetLimits: []
}
for (let w = 0; w < links.length; w++) {
if (links[w].nodeName === 'TileMatrixSet') {
TileMatrixSetLink.tileMatrixSet = links[w].innerHTML
} else if (links[w].nodeName === 'TileMatrixSetLimits') {
const limits = links[w].childNodes
for (let y = 0; y < limits.length; y++) {
const tls = limits[y].childNodes
const TileMatrixLimits = {}
for (let z = 0; z < tls.length; z++) {
if (tls[z].nodeName === 'TileMatrix') {
TileMatrixLimits.tileMatrix = tls[z].innerHTML
} else if (tls[z].nodeName === 'MinTileRow') {
TileMatrixLimits.minTileRow = tls[z].innerHTML
} else if (tls[z].nodeName === 'MaxTileRow') {
TileMatrixLimits.maxTileRow = tls[z].innerHTML
} else if (tls[z].nodeName === 'MinTileCol') {
TileMatrixLimits.minTileCol = tls[z].innerHTML
} else if (tls[z].nodeName === 'MaxTileCol') {
TileMatrixLimits.maxTileCol = tls[z].innerHTML
}
}
TileMatrixSetLink.tileMatrixSetLimits.push(
TileMatrixLimits
)
}
}
}
WMTSInfo.layer.tileMatrixSetLink.push(TileMatrixSetLink)
}
}
} else if (ctChildren[k].nodeName === 'TileMatrixSet') {
// 获取TileMatrixSet上的信息
const TileMatrixSet = ctChildren[k].childNodes
const tileMatrixSet = {
tileMatrix: []
}
for (let m = 0; m < TileMatrixSet.length; m++) {
if (TileMatrixSet[m].nodeName === 'ows:Title') {
tileMatrixSet.title = TileMatrixSet[m].innerHTML
} else if (TileMatrixSet[m].nodeName === 'ows:Abstract') {
tileMatrixSet.abstract = TileMatrixSet[m].innerHTML
} else if (TileMatrixSet[m].nodeName === 'ows:Identifier') {
tileMatrixSet.identifier = TileMatrixSet[m].innerHTML
} else if (TileMatrixSet[m].nodeName === 'ows:SupportedCRS') {
tileMatrixSet.supportedCRS = TileMatrixSet[m].innerHTML
} else if (TileMatrixSet[m].nodeName === 'TileMatrix') {
const TileMatrix = TileMatrixSet[m].childNodes
const tileMatrix = {}
for (let n = 0; n < TileMatrix.length; n++) {
if (TileMatrix[n].nodeName === 'ows:Identifier') {
tileMatrix.identifier = TileMatrix[n].innerHTML
} else if (TileMatrix[n].nodeName === 'ScaleDenominator') {
tileMatrix.scaleDenominator = TileMatrix[n].innerHTML
} else if (TileMatrix[n].nodeName === 'TopLeftCorner') {
tileMatrix.topLeftCorner = TileMatrix[n].innerHTML
} else if (TileMatrix[n].nodeName === 'TileWidth') {
tileMatrix.tileWidth = TileMatrix[n].innerHTML
} else if (TileMatrix[n].nodeName === 'TileHeight') {
tileMatrix.tileHeight = TileMatrix[n].innerHTML
} else if (TileMatrix[n].nodeName === 'MatrixWidth') {
tileMatrix.matrixWidth = TileMatrix[n].innerHTML
} else if (TileMatrix[n].nodeName === 'MatrixHeight') {
tileMatrix.matrixHeight = TileMatrix[n].innerHTML
}
}
tileMatrixSet.tileMatrix.push(tileMatrix)
}
}
WMTSInfo.tileMatrixSet.push(tileMatrixSet)
}
}
break
}
}
break
}
}
return WMTSInfo
}
/**
* 将XML的Document对象转换为JSON字符串
* @param xmlDoc xml的Document对象
* @return {Object} WFS的元数据信息
*/
function getWFSInfoFromXML(xmlDoc) {
const rootChildren = xmlDoc.childNodes
const WFSInfo = {
featureTypeList: []
}
// 循环子元素
for (let i = 0; i < rootChildren.length; i++) {
if (rootChildren[i].nodeName === 'wfs:WFS_Capabilities') {
const cpChildren = rootChildren[i].childNodes
for (let m = 0; m < cpChildren.length; m++) {
// 只拿FeatureTypeList里的数据
if (cpChildren[m].nodeName === 'FeatureTypeList') {
const ftList = cpChildren[m].childNodes
for (let j = 0; j < ftList.length; j++) {
// 只拿FeatureType里的数据
if (ftList[j].nodeName === 'FeatureType') {
const featureType = {}
const ftChildren = ftList[j].childNodes
for (let k = 0; k < ftChildren.length; k++) {
if (ftChildren[k].nodeName.toLowerCase() === 'name') {
featureType.name = ftChildren[k].innerHTML
} else if (ftChildren[k].nodeName.toLowerCase() === 'title') {
featureType.title = ftChildren[k].innerHTML
} else if (
ftChildren[k].nodeName.toLowerCase() === 'abstract'
) {
featureType.abstract = ftChildren[k].innerHTML
} else if (
ftChildren[k].nodeName.toLowerCase() === 'defaultsrs'
) {
featureType.defaultSRS = ftChildren[k].innerHTML
} else if (
ftChildren[k].nodeName.toLowerCase() ===
'ows:wgs84boundingbox'
) {
featureType.WGS84BoundingBox = {
lowerCorner: ftChildren[k].childNodes[0].innerHTML,
UpperCorner: ftChildren[k].childNodes[1].innerHTML
}
}
}
WFSInfo.featureTypeList.push(featureType)
}
}
break
}
}
}
}
return WFSInfo
}
function parseWFSElementForSpatialReference(element) {
let srsName = 'EPSG:4326'
if (!element) {
return srsName
}
const _srsName = element.getAttribute('srsName')
if (!_srsName) return srsName
const res = _srsName.match(/EPSG::\d+/)
if (res[0]) {
srsName = `EPSG:${res[0].replace('EPSG::', '')}`
}
return srsName
}
function getWFSFeature(xmlDoc) {
const rootChildren = xmlDoc.childNodes
const WFSFeatureDom = rootChildren[0].childNodes
const WFSFeature = new FeatureSet()
for (let i = 0; i < WFSFeatureDom.length; i++) {
const WFSSubLayer = WFSFeatureDom[i].childNodes[0]
const WFSSubLayerChildren = WFSSubLayer.childNodes
const attributes = {}
let geometry = undefined
for (let j = 0; j < WFSSubLayerChildren.length; j++) {
// 多边形几何，确保节点名称包含:the_geom
if (WFSSubLayerChildren[j].nodeName.indexOf(':the_geom') > -1) {
// 遍历子节点，最后找到节点名包含exterior的节点，里面的就是多边形的点坐标
const WFSGeometry = WFSSubLayerChildren[j]
// 解析空间参考系
const srsName = parseWFSElementForSpatialReference(
WFSGeometry.childNodes[0]
)
WFSFeature.spatialReference = new SpatialReference(srsName)
if (WFSGeometry.childNodes[0].nodeName.indexOf('MultiSurface') > -1) {
const WFSMultiSurface = WFSGeometry.childNodes[0]
const WFSSurfaceMembers = WFSMultiSurface.childNodes
if (WFSSurfaceMembers.length === 1) {
const WFSPolygon = WFSSurfaceMembers[0].childNodes[0]
const WFSPolygonChildNodes = WFSPolygon.childNodes
for (let k = 0; k < WFSPolygonChildNodes.length; k++) {
if (WFSPolygonChildNodes[k].nodeName.indexOf('exterior') > -1) {
const WFSPolygonExterior = WFSPolygonChildNodes[k]
const WFSPolygonExteriorPoints =
WFSPolygonExterior.childNodes[0].childNodes[0].innerHTML.split(
' '
)
const exteriorPoints = []
for (let l = 0; l < WFSPolygonExteriorPoints.length; l += 2) {
exteriorPoints.push([
Number(WFSPolygonExteriorPoints[l]),
Number(WFSPolygonExteriorPoints[l + 1])
])
}
geometry = new Polygon({
coordinates: [exteriorPoints]
})
}
}
} else if (WFSSurfaceMembers.length > 1) {
// 未测试该情况，要向igs了解
}
}
// 线几何，确保节点名称包含MultiCurve
else if (
WFSGeometry.childNodes[0].nodeName.indexOf('MultiCurve') > -1
) {
// 遍历子节点，最后找到节点名包含posList的节点，里面的就是线的点坐标
const WFSMultiSurface = WFSGeometry.childNodes[0]
const WFSSurfaceMembers = WFSMultiSurface.childNodes
if (WFSSurfaceMembers.length === 1) {
const WFSLine = WFSSurfaceMembers[0].childNodes[0]
const WFSLineChildNodes = WFSLine.childNodes
for (let k = 0; k < WFSLineChildNodes.length; k++) {
if (WFSLineChildNodes[k].nodeName.indexOf('posList') > -1) {
const WFSLineString = WFSLineChildNodes[k]
const WFSLineStringPoints = WFSLineString.innerHTML.split(' ')
const lineStringPoints = []
for (let l = 0; l < WFSLineStringPoints.length; l += 2) {
lineStringPoints.push([
Number(WFSLineStringPoints[l]),
Number(WFSLineStringPoints[l + 1])
])
}
geometry = new LineString({
coordinates: lineStringPoints
})
}
}
} else if (WFSSurfaceMembers.length > 1) {
// 未测试该情况，要向igs了解
}
}
// 点几何，确保节点名称包含MultiCurve
else if (
WFSGeometry.childNodes[0].nodeName.indexOf('MultiPoint') > -1
) {
// 遍历子节点，最后找到节点名包含posList的节点，里面的就是线的点坐标
const WFSMultiPoint = WFSGeometry.childNodes[0]
const WFSPointMembers = WFSMultiPoint.childNodes
if (WFSPointMembers.length === 1) {
const WFSPoint = WFSPointMembers[0].childNodes[0]
const WFSPointPos = WFSPoint.childNodes[0].innerHTML.split(' ')
geometry = new Point({
coordinates: [Number(WFSPointPos[0]), Number(WFSPointPos[1])]
})
} else if (WFSPointMembers.length > 1) {
// 未测试该情况，要向igs了解
}
}
}
// 属性信息
else {
let key = WFSSubLayerChildren[j].nodeName
key = key.split(':')[1]
attributes[key] = WFSSubLayerChildren[j].innerHTML
}
}
const feature = new Feature({
geometry,
attributes
})
WFSFeature.features.push(feature)
}
return WFSFeature
}
function fromQueryResult(result) {
function _fromQueryResult(result) {
if (
!result.hasOwnProperty('SFEleArray') ||
!result.hasOwnProperty('AttStruct') ||
(result.hasOwnProperty('SFEleArray') && !result.SFEleArray) ||
(result.hasOwnProperty('AttStruct') && !result.AttStruct)
) {
return []
}
const SFEleArray = result.SFEleArray
const AttStruct = result.AttStruct
const featureSet = new FeatureSet({
spatialReference: new SpatialReference('EPSG:0000')
})
let feature
let geometry
let coordinates
for (let i = 0; i < SFEleArray.length; i++) {
const attributes = {}
for (let j = 0; j < SFEleArray[i].AttValue.length; j++) {
if (SFEleArray[i].AttValue[j] !== '') {
attributes[AttStruct.FldName[j]] = SFEleArray[i].AttValue[j]
}
}
if (SFEleArray[i].fGeom) {
switch (SFEleArray[i].ftype) {
case 1:
// 多个点
const PntGeom = SFEleArray[i].fGeom.PntGeom
// 获取所有点的点坐标
coordinates = []
for (let k = 0; k < PntGeom.length; k++) {
// 处理数据
const dot = PntGeom[k].Dot
coordinates.push([dot.x, dot.y])
}
geometry = new MultiPoint({
coordinates
})
break
case 2:
// 多个线
const LinGeom = SFEleArray[i].fGeom.LinGeom
// 获取所有线的点坐标
coordinates = []
for (let k = 0; k < LinGeom.length; k++) {
// 处理下数据
const dots = LinGeom[k].Line.Arcs[0].Dots
const lineCos = []
for (let i = 0; i < dots.length; i++) {
lineCos.push([dots[i].x, dots[i].y])
}
coordinates.push(lineCos)
}
geometry = new MultiLineString({
coordinates
})
break
case 3:
default:
// 多个多边形
const RegGeom = SFEleArray[i].fGeom.RegGeom
// 获取所有多边形的点坐标
coordinates = []
for (let k = 0; k < RegGeom.length; k++) {
// 这个是多边形的外圈
const outerDots = RegGeom[k].Rings[0].Arcs[0].Dots
// 处理下数据
const outerCos = []
for (let i = 0; i < outerDots.length; i++) {
outerCos.push([outerDots[i].x, outerDots[i].y])
}
const singleCoordinates = [outerCos]
for (let m = 1; m < RegGeom[k].Rings.length; m++) {
// 这个是多边形的内圈
// 处理数据
const innerDots = RegGeom[k].Rings[m].Arcs[0].Dots
const innerCos = []
for (let i = 0; i < innerDots.length; i++) {
innerCos.push([innerDots[i].x, innerDots[i].y])
}
singleCoordinates.push(innerCos)
}
coordinates.push(singleCoordinates)
}
geometry = new MultiPolygon({
coordinates
})
break
}
}
let symbol
if (SFEleArray[i].GraphicInfo) {
const GraphicInfo = SFEleArray[i].GraphicInfo
switch (GraphicInfo.InfoType) {
case 1:
symbol = GraphicInfo.PntInfo
break
case 2:
symbol = GraphicInfo.LinInfo
break
case 3:
default:
symbol = GraphicInfo.RegInfo
break
}
}
feature = new Feature({
id: SFEleArray[i].FID,
attributes,
geometry,
symbol
})
featureSet.features.push(feature)
}
return featureSet
}
if (result instanceof Array) {
const featureSets = []
for (let i = 0; i < result.length; i++) {
featureSets.push(_fromQueryResult(result[i]))
}
return featureSets
} else {
return [_fromQueryResult(result)]
}
}
function formatBaseUrl(url) {
const _index = url.indexOf('?')
if (_index < 0) {
return {
baseUrl: url,
params: {}
}
}
const _baseUrl = url.substring(0, _index)
const _paramStr = url.substring(_index + 1, url.length)
return {
baseUrl: _baseUrl,
paramString: _paramStr ? `&${_paramStr}` : ''
}
}
function ServiceConfigToken(Config) {
let tokenStr = ''
if (Config) {
if (Config.tokenKey && Config.tokenValue) {
tokenStr = `${Config.tokenKey}=${Config.tokenValue}`
}
}
return tokenStr
}
function ServiceConfigRequestInterceptors(Config, url) {
url = defaultValue(url, '')
const requestInterceptors = Config.request.interceptors
const _urlOrigin = decodeURI(url)
if (requestInterceptors && requestInterceptors instanceof Array) {
let _beforeUrl = ''
for (let i = 0; i < requestInterceptors.length; i++) {
const urls = requestInterceptors[i].urls
const before = requestInterceptors[i].before
// 不存在urls，则应用到全部url上
if (!urls) {
if (before && before instanceof Function) {
const _before = before(url)
if (_before) {
_beforeUrl += _before
}
}
}
// urls是字符串
else if (typeof urls === 'string') {
const _url = decodeURI(urls)
if (_urlOrigin.indexOf(_url) > -1) {
if (before && before instanceof Function) {
const _before = before(url)
if (_before) {
_beforeUrl += _before
}
}
}
}
// urls是数组
else if (urls instanceof Array) {
for (let j = 0; j < urls.length; j++) {
const _url = decodeURI(urls[j])
if (_urlOrigin.indexOf(_url) > -1) {
if (before && before instanceof Function) {
const _before = before(url)
if (_before) {
_beforeUrl += _before
}
}
}
}
}
if (_beforeUrl) {
url = _beforeUrl
}
}
}
return url
}
function ServiceConfigResponseInterceptors(Config, url, response) {
url = defaultValue(url, '')
const requestInterceptors = Config.request.interceptors
const _urlOrigin = decodeURI(url)
if (requestInterceptors && requestInterceptors instanceof Array) {
for (let i = 0; i < requestInterceptors.length; i++) {
const urls = requestInterceptors[i].urls
const after = requestInterceptors[i].after
// 不存在urls，则应用到全部url上
if (!urls || (urls instanceof Array && urls.length === 0)) {
if (after && after instanceof Function) {
const _after = after(response)
if (_after) {
return _after
}
}
}
// urls是字符串
else if (typeof urls === 'string') {
const _url = decodeURI(urls)
if (_urlOrigin.indexOf(_url) > -1) {
if (after && after instanceof Function) {
const _after = after(response)
if (_after) {
return _after
}
}
}
}
// urls是数组
else if (urls instanceof Array) {
for (let j = 0; j < urls.length; j++) {
const _url = decodeURI(urls[j])
if (_urlOrigin.indexOf(_url) > -1) {
if (after && after instanceof Function) {
const _after = after(response)
if (_after) {
return _after
}
}
}
}
}
}
}
return response
}
export {
fromQueryResult,
checkParam,
getParameters,
checkPathParameters,
getWMSInfoFromXML,
getDoc,
getWMTSInfoFromXML,
getWFSInfoFromXML,
getParametersObject,
getWFSFeature,
formatBaseUrl,
ServiceConfigToken,
ServiceConfigRequestInterceptors,
ServiceConfigResponseInterceptors
}
