constructor(mapId, options = {}) {

if (typeof mapId === 'string' || typeof mapId === 'number') {

this.mapId = mapId;

} else if (mapId !== null && typeof mapId === 'object') {

this.mapInfo = mapId;

}

this.serverUrl = options.serverUrl || 'https://www.supermapol.com';

this.credentialKey = options.credentialKey;

this.credentialValue = options.credentialValue;

this.tiandituKey = options.tiandituKey || '';

this.withCredentials = options.withCredentials || false;

this.excludePortalProxyUrl = options.excludePortalProxyUrl;

this.iportalServiceProxyUrl = options.iportalServiceProxyUrlPrefix;

this.proxy = options.proxy;

this.preferServer = options.preferServer || false;

this.proxyOptions = {

data: 'apps/viewer/getUrlResource.json?url=',

image: 'apps/viewer/getUrlResource.png?url='

};

}

setMapId(mapId) {

if (typeof mapId === 'string' || typeof mapId === 'number') {

this.mapId = mapId;

this.mapInfo = null;

} else if (mapId !== null && typeof mapId === 'object') {

this.mapInfo = mapId;

this.mapId = '';

}

}

setServerUrl(serverUrl) {

this.serverUrl = serverUrl;

}

setWithCredentials(withCredentials) {

this.withCredentials = withCredentials;

}

setProxy(proxy) {

this.proxy = proxy;

}

handleServerUrl(serverUrl) {

const url = transformServerUrl(serverUrl);

this.serverUrl = url;

return url;

}

async getMapInfo() {

if (!this.mapId && this.mapInfo) {

return new Promise(resolve => {

resolve(this.mapInfo);

});

}

let mapUrl = this._handleMapUrl();

try {

await this.getiPortalServiceProxy();

return new Promise((resolve, reject) => {

FetchRequest.get(mapUrl, null, {

withCredentials: this.withCredentials

})

.then((response) => {

return response.json();

})

.then((mapInfo) => {

if (mapInfo && mapInfo.succeed === false) {

let error = { message: mapInfo && mapInfo.error && mapInfo.error.errorMsg };

reject(error);

return;

}

mapInfo.mapParams = {

title: mapInfo.title,

description: mapInfo.description

};

resolve(mapInfo);

})

.catch((error) => {

reject(error);

});

});

} catch (error) {

return Promise.reject(error);

}

}

getiPortalServiceProxy() {

return new Promise((resolve, reject) => {

FetchRequest.get(`${this.serverUrl}web/config/portal.json`, { scope: ['serviceProxy'] })

.then(response => {

return response.json();

})

.then(serviceProxyInfo => {

if (!serviceProxyInfo || !serviceProxyInfo.serviceProxy) {

reject('serviceProxyFailed');

return;

}

const serviceProxy = serviceProxyInfo.serviceProxy;

if (serviceProxy.enable) {

if (serviceProxy.proxyServerRootUrl) {

this.iportalServiceProxyUrl = serviceProxy.proxyServerRootUrl;

} else if (serviceProxy.port && serviceProxy.rootUrlPostfix) {

this.iportalServiceProxyUrl = `${serviceProxy.port}/${serviceProxy.rootUrlPostfix}`;

}

if (this.serverUrl.indexOf(this.iportalServiceProxyUrl) > -1) {

this.iportalServiceProxyUrl = '';

}

}

resolve(serviceProxy);

})

.catch(error => {

reject(error);

});

});

}

getLayerFeatures(type, layer, baseProjection) {

let pro;

switch (type) {

case 'hosted':

// 数据存储到iportal上了

pro = this._getFeaturesFromHosted(layer, baseProjection);

break;

case 'rest_data':

pro = this._getFeaturesFromRestData(layer, baseProjection);

break;

case 'rest_map':

pro = this._getFeaturesFromRestMap(layer);

break;

case 'dataflow':

pro = this._getFeaturesFromDataflow(layer);

break;

case 'user_data':

pro = this._getFeaturesFromUserData(layer);

break;

}

return pro;

}

getWmsInfo(layerInfo) {

return new Promise(resolve => {

const proxy = this.handleProxy();

const serviceUrl = Util.urlAppend(layerInfo.url, 'REQUEST=GetCapabilities&SERVICE=WMS');

FetchRequest.get(serviceUrl, null, {

withCredentials: this.handleWithCredentials(proxy, layerInfo.url, false),

withoutFormatSuffix: true,

proxy

})

.then(response => {

return response.text();

})

.then(capabilitiesText => {

const parser = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: '@_' });

const capabilities = parser.parse(capabilitiesText);

const wmsCapabilities = capabilities.WMT_MS_Capabilities || capabilities.WMS_Capabilities;

const latlonBounds = wmsCapabilities['Capability']['Layer']['LatLonBoundingBox'];

let bounds = null;

if (latlonBounds) {

bounds = [+latlonBounds['@_minx'], +latlonBounds['@_miny'], +latlonBounds['@_maxx'], +latlonBounds['@_maxy']];

}

const EX_GeographicBoundingBox = wmsCapabilities['Capability']['Layer']['EX_GeographicBoundingBox'];

if (EX_GeographicBoundingBox) {

bounds = [+EX_GeographicBoundingBox['westBoundLongitude'], +EX_GeographicBoundingBox['southBoundLatitude'], +EX_GeographicBoundingBox['eastBoundLongitude'], +EX_GeographicBoundingBox['northBoundLatitude']];

}

resolve({ version: wmsCapabilities['@_version'], bounds });

});

});

}

getMapBoxStyle(styleURL, withoutFormatSuffix = false) {

return new Promise((resolve, reject) => {

const proxy = this.handleProxy();

FetchRequest.get(styleURL, {}, {

withoutFormatSuffix,

withCredentials: this.handleWithCredentials(proxy, styleURL, this.withCredentials)

})

.then(response => {

return response.json();

})

.then(styleJSON => {

resolve(styleJSON);

})

.catch(error => {

reject(error);

});

});

}

getWmtsInfo(layerInfo, mapCRS) {

return new Promise((resolve, reject) => {

let isMatched = false;

let matchMaxZoom = 22;

let matchMinZoom = 0;

let style = '';

let bounds;

let restResourceURL = '';

let kvpResourceUrl = '';

const scales = [];

const proxy = this.handleProxy();

let serviceUrl = Util.urlAppend(layerInfo.url, 'REQUEST=GetCapabilities&SERVICE=WMTS&VERSION=1.0.0');

serviceUrl = this.handleParentRes(serviceUrl);

FetchRequest.get(serviceUrl, null, {

withCredentials: this.handleWithCredentials(proxy, layerInfo.url, false),

withoutFormatSuffix: true,

proxy

})

.then(response => {

return response.text();

})

.then(capabilitiesText => {

// 用于决定哪些字段必须返回数组格式

const alwaysArray = ['Layer', 'TileMatrixSet', 'ows:Operation', 'ows:Get', 'ResourceURL', 'Style'];

const parser = new XMLParser({

ignoreAttributes: false,

attributeNamePrefix: '@_',

//name: is either tagname, or attribute name

isArray: (name) => {

if(alwaysArray.indexOf(name) !== -1) {

return true;

}

}

});

const capabilities = parser.parse(capabilitiesText).Capabilities;

const content = capabilities.Contents;

const metaData = capabilities['ows:OperationsMetadata'];

if (metaData) {

let operations = metaData['ows:Operation'];

if (!Array.isArray(operations)) {

operations = [operations];

}

const operation = operations.find(item => {

return item['@_name'] === 'GetTile';

});

if (operation) {

let getConstraints = operation['ows:DCP']['ows:HTTP']['ows:Get'];

if (!Array.isArray(getConstraints)) {

getConstraints = [getConstraints];

}

const getConstraint = getConstraints.find(item => {

return item['ows:Constraint']['ows:AllowedValues']['ows:Value'] === 'KVP';

});

if (getConstraint) {

kvpResourceUrl = getConstraint['@_xlink:href'];

}

}

}

let tileMatrixSet = content.TileMatrixSet;

const IDENTIFIER = 'ows:Identifier';

for (let i = 0; i < tileMatrixSet.length; i++) {

if (

tileMatrixSet[i][IDENTIFIER] &&

(tileMatrixSet[i][IDENTIFIER] + '') === layerInfo.tileMatrixSet

) {

if (

tileMatrixSet[i]['WellKnownScaleSet'] &&

DEFAULT_WELLKNOWNSCALESET.includes(tileMatrixSet[i]['WellKnownScaleSet'])

) {

isMatched = true;

} else {

let matchedScaleDenominator = {};

// 坐标系判断

let defaultCRSScaleDenominators =

// @ts-ignore -------- crs 为 enhance 新加属性

mapCRS === 'EPSG:3857' ? MB_SCALEDENOMINATOR_3857 : MB_SCALEDENOMINATOR_4326;

let defaultCRSTopLeftCorner =

// @ts-ignore -------- crs 为 enhance 新加属性

mapCRS === 'EPSG:3857' ? [-2.0037508342789248e7, 2.0037508342789087e7] : [-180, 90];

for (let j = 0; j < tileMatrixSet[i].TileMatrix.length; j++) {

const tileMatrix = tileMatrixSet[i].TileMatrix[j];

const identifier = tileMatrix[IDENTIFIER];

const topLeftCorner = [...tileMatrix['TopLeftCorner'].split(' ')];

scales.push(tileMatrix['ScaleDenominator']);

if (

(!this.numberEqual(topLeftCorner[0], defaultCRSTopLeftCorner[0]) ||

!this.numberEqual(topLeftCorner[1], defaultCRSTopLeftCorner[1])) &&

(!this.numberEqual(topLeftCorner[0], defaultCRSTopLeftCorner[1]) ||

!this.numberEqual(topLeftCorner[1], defaultCRSTopLeftCorner[0]))

) {

break;

}

const defaultScaleDenominator = defaultCRSScaleDenominators[+identifier];

if (!defaultScaleDenominator) {

break;

}

const scaleDenominator = parseFloat(tileMatrixSet[i].TileMatrix[j]['ScaleDenominator']);

if (this.numberEqual(defaultScaleDenominator, scaleDenominator)) {

matchedScaleDenominator[+identifier] = scaleDenominator;

} else {

if (Object.keys(matchedScaleDenominator).length > 0) {

break;

} else {

continue;

}

}

}

const zooms = Object.keys(matchedScaleDenominator).map(element => {

return +element;

});

matchMaxZoom = zooms.length > 0 ? Math.max(...zooms) : undefined;

matchMinZoom = zooms.length > 0 ? Math.min(...zooms) : undefined;

if (zooms.length !== 0) {

isMatched = true;

} else {

throw Error('TileMatrixSetNotSuppport');

}

}

break;

}

}

const layer = content.Layer && content.Layer.find(item => {

return item[IDENTIFIER] === layerInfo.layer;

});

if (layer) {

let styles = layer.Style;

if (Array.isArray(layer.Style)) {

style = styles[0][IDENTIFIER] ? styles[0][IDENTIFIER] : '';

} else {

style = styles[IDENTIFIER] ? styles[IDENTIFIER] : '';

}

if (layer['ows:WGS84BoundingBox']) {

const lowerCorner = layer['ows:WGS84BoundingBox']['ows:LowerCorner'].split(' ');

const upperCorner = layer['ows:WGS84BoundingBox']['ows:UpperCorner'].split(' ');

bounds = [

parseFloat(lowerCorner[0]),

parseFloat(lowerCorner[1]),

parseFloat(upperCorner[0]),

parseFloat(upperCorner[1])

];

}

let resourceUrls = layer.ResourceURL;

if (!Array.isArray(resourceUrls)) {

resourceUrls = [resourceUrls];

}

const resourceUrl = resourceUrls.find(item => {

return item['@_resourceType'] === 'tile';

});

if (resourceUrl) {

restResourceURL = resourceUrl['@_template'];

}

}

resolve({ isMatched, matchMaxZoom, matchMinZoom, style, bounds, restResourceURL, kvpResourceUrl, scales });

})

.catch(error => {

reject(error);

});

});

}

_getFeaturesFromHosted(layer, baseProjection) {

let { dataSource, layerType } = layer;

let serverId = dataSource ? dataSource.serverId : layer.serverId;

if (!serverId) {

return new Promise(resolve => {

resolve({ type: 'noServerId' });

});

}

let getDataFromIportal =

layerType === 'MARKER' || (dataSource && (!dataSource.accessType || dataSource.accessType === 'DIRECT'));

if (getDataFromIportal) {

return this._getDataFromIportal(serverId, layer);

} else {

return this._getDataFromHosted({ layer, serverId, baseProjection });

}

}

_getFeaturesFromRestData(layer, baseProjection) {

// 从restData获取数据

let features;

let dataSource = layer.dataSource;

return new Promise((resolve, reject) => {

this._getFeatureBySQL(

dataSource.url,

[decodeURIComponent(dataSource.dataSourceName) || layer.name],

result => {

if (!result.result.features) {

reject('features must be valid');

return;

}

features = this.parseGeoJsonData2Feature({

allDatas: {

features: result.result.features.features

}

});

resolve({ type: 'feature', features });

},

err => {

reject(err);

},

baseProjection

);

});

}

_getFeaturesFromRestMap(layer) {

return new Promise((resolve, reject) => {

this._queryFeatureBySQL(

layer.dataSource.url,

layer.dataSource.layerName,

result => {

let recordsets = result && result.result.recordsets;

let recordset = recordsets && recordsets[0];

let attributes = recordset.fields;

if (recordset && attributes) {

let fileterAttrs = [];

for (let i in attributes) {

let value = attributes[i];

if (value.indexOf('Sm') !== 0 || value === 'SmID') {

fileterAttrs.push(value);

}

}

this._getFeatures(

fileterAttrs,

layer,

features => {

resolve({ type: 'feature', features });

},

err => {

reject(err);

}

);

}

},

err => {

reject(err);

},

'smid=1'

);

});

}

_getFeaturesFromUserData(layer) {

let dataSource = layer.dataSource;

return new Promise((resolve, reject) => {

const proxy = this.handleProxy();

let serviceUrl = this.handleParentRes(dataSource.url);

FetchRequest.get(serviceUrl, null, {

withCredentials: this.handleWithCredentials(proxy, serviceUrl, this.withCredentials),

proxy,

withoutFormatSuffix: true

})

.then(response => {

return response.json();

})

.then(data => {

let features;

if (data && data instanceof Object && data.type === 'FeatureCollection') {

features = data.features;

} else {

features = data;

}

features = this.parseGeoJsonData2Feature({

allDatas: {

features

}

});

resolve({ type: 'feature', features });

})

.catch(err => {

reject(err);

});

});

}

_queryFeatureBySQL(

url,

layerName,

processCompleted,

processFaild,

attributeFilter,

fields,

epsgCode,

startRecord,

recordLength,

onlyAttribute

) {

let queryBySQLParams = this._getQueryFeaturesParam(

layerName,

attributeFilter,

fields,

epsgCode,

startRecord,

recordLength,

onlyAttribute

);

const proxy = this.handleProxy();

let serviceUrl = this.handleParentRes(url);

// @ts-ignore

let queryBySQLService = new QueryBySQLService(serviceUrl, {

proxy,

withCredentials: this.handleWithCredentials(proxy, url, false),

eventListeners: {

processCompleted: data => {

processCompleted && processCompleted(data);

},

processFailed: data => {

processFaild && processFaild(data);

}

}

});

queryBySQLService.processAsync(queryBySQLParams);

}

_getFeatures(fields, layerInfo, resolve, reject) {

let source = layerInfo.dataSource;

// 示例数据

this._queryFeatureBySQL(

source.url,

source.layerName,

result => {

let recordsets = result.result.recordsets[0];

let features = recordsets.features.features;

let featuresObj = this.parseGeoJsonData2Feature({

allDatas: { features }

});

resolve(featuresObj);

},

err => {

reject(err);

},

null,

fields

);

}

_getQueryFeaturesParam(

layerName,

attributeFilter,

fields,

epsgCode,

startRecord,

recordLength,

onlyAttribute

) {

let queryParam = new FilterParameter({

name: layerName,

attributeFilter: attributeFilter

});

if (fields) {

queryParam.fields = fields;

}

let params = {

queryParams: [queryParam]

};

if (onlyAttribute) {

params.queryOption = QueryOption.ATTRIBUTE;

}

startRecord && (params.startRecord = startRecord);

recordLength && (params.expectCount = recordLength);

if (epsgCode) {

params.prjCoordSys = {

epsgCode: epsgCode

};

}

let queryBySQLParams = new QueryBySQLParameters(params);

return queryBySQLParams;

}

_getFeaturesFromDataflow(layer) {

return new Promise((resolve, reject) => {

this._getDataflowInfo(

layer,

() => {

resolve({ type: 'dataflow' });

},

e => {

reject(e);

}

);

});

}

_getDataflowInfo(layerInfo, success, faild) {

let url = layerInfo.url;

let token;

let requestUrl = `${url}.json`;

if (layerInfo.credential && layerInfo.credential.token) {

token = layerInfo.credential.token;

requestUrl += `?token=${token}`;

}

const proxy = this.handleProxy();

requestUrl = this.handleParentRes(requestUrl);

FetchRequest.get(requestUrl, null, {

proxy,

withCredentials: this.handleWithCredentials(proxy, requestUrl, false)

})

.then(function (response) {

return response.json();

})

.then(function (result) {

if (!result) {

faild();

return;

}

if (result.featureMetaData) {

layerInfo.featureType = result.featureMetaData.featureType.toUpperCase();

layerInfo.dataSource = { dataTypes: {} };

if (result.featureMetaData.fieldInfos && result.featureMetaData.fieldInfos.length > 0) {

result.featureMetaData.fieldInfos.forEach(function (data) {

let name = data.name.trim();

if (data.type === 'TEXT') {

layerInfo.dataSource.dataTypes[name] = 'STRING';

} else if (['DOUBLE', 'INT', 'FLOAT', 'LONG', 'SHORT'].includes(data.type)) {

layerInfo.dataSource.dataTypes[name] = 'NUMBER';

} else {

layerInfo.dataSource.dataTypes[name] = 'UNKNOWN';

}

});

}

}

layerInfo.wsUrl = result.urls[0].url;

layerInfo.name = result.urls[0].url.split('iserver/services/')[1].split('/dataflow')[0];

success();

})

.catch(function () {

faild();

});

}

getDatasourceType(layer) {

let { dataSource, layerType } = layer;

if (dataSource && dataSource.type === 'SAMPLE_DATA') {

return dataSource.type;

}

let type;

let isHosted = (dataSource && dataSource.serverId) || layerType === 'MARKER' || layerType === 'HOSTED_TILE';

let isTile =

layerType === 'ZXY_TILE' ||

layerType === 'SUPERMAP_REST' ||

layerType === 'TILE' ||

layerType === 'WMS' ||

layerType === 'WMTS' ||

layerType === 'MAPBOXSTYLE';

if (isHosted) {

type = 'hosted';

} else if (isTile) {

type = 'tile';

} else if (dataSource && dataSource.type === 'REST_DATA') {

type = 'rest_data';

} else if (dataSource && dataSource.type === 'REST_MAP' && dataSource.url) {

type = 'rest_map';

} else if (layerType === 'DATAFLOW_POINT_TRACK' || layerType === 'DATAFLOW_HEAT') {

type = 'dataflow';

} else if (dataSource && dataSource.type === 'USER_DATA') {

type = 'user_data';

}

return type;

}

getFeatureProperties(features) {

let properties = [];

if (features && features.length) {

features.forEach(feature => {

let property = feature.properties;

property && properties.push(property);

});

}

return properties;

}

parseGeoJsonData2Feature(metaData) {

let allFeatures = metaData.allDatas.features;

let features = [];

for (let i = 0, len = allFeatures.length; i < len; i++) {

let feature = allFeatures[i];

let coordinate = feature.geometry.coordinates;

if (allFeatures[i].geometry.type === 'Point') {

// 标注图层 还没有属性值时候不加

if (allFeatures[i].properties) {

allFeatures[i].properties.lon = coordinate[0];

allFeatures[i].properties.lat = coordinate[1];

}

}

feature.properties['index'] = i + '';

features.push(feature);

}

return features;

}

_getDataFromIportal(serverId, layerInfo) {

let features;

// 原来二进制文件

let url = `${this.serverUrl}web/datas/${serverId}/content.json?pageSize=9999999&currentPage=1`;

if (this.credentialKey && this.credentialValue) {

url = `${url}&${this.credentialKey}=${this.credentialValue}`;

}

return new Promise((resolve, reject) => {

url = this.handleParentRes(url);

const proxy = this.handleProxy();

FetchRequest.get(url, null, {

withCredentials: this.handleWithCredentials(proxy, url, this.withCredentials),

proxy

})

.then(response => {

return response.json();

})

.then(async data => {

if (data.succeed === false) {

reject(data.error);

}

if (data && data.type) {

if (data.type === 'JSON' || data.type === 'GEOJSON') {

data.content = JSON.parse(data.content.trim());

features = this._formatGeoJSON(data.content);

} else if (data.type === 'EXCEL' || data.type === 'CSV') {

if (layerInfo.dataSource && layerInfo.dataSource.administrativeInfo) {

// 行政规划信息

data.content.rows.unshift(data.content.colTitles);

const { divisionType, divisionField } = layerInfo.dataSource.administrativeInfo;

const geojson = await this._excelData2FeatureByDivision(data.content, divisionType, divisionField);

features = this._formatGeoJSON(geojson);

} else {

features = this._excelData2Feature(data.content, (layerInfo && layerInfo.xyField) || {});

}

} else if (data.type === 'SHP') {

data.content = JSON.parse(data.content.trim());

features = this._formatGeoJSON(data.content.layers[0]);

}

resolve({ type: 'feature', features });