@sword916/vae-map-plus 1.0.0 → 1.0.1

package/src/packages/vae-cloudmap/scripts/L.Vae.Client/index.js

@@ -1,780 +0,0 @@
-import axios from 'axios'
-import {idGen, getTreeNode} from '@/utils'
-
-L.Vae = L.Vae || {}
-
-// LRMAP客户端
-L.Vae.CloudClient = L.Evented.extend({
-
-    options: {},
-
-    requestOptions: {},
-
-    leafletOptions: {},
-
-    extent: [],
-
-    treeLayers: [],
-
-    visibleKeys: [],
-
-    token: "",
-
-    async initialize(options) {
-        this.options = options
-        this.requestOptions = {url: null, uid: null, dsid: null, mapid: null, dsname: null, customTreeLayers: null}
-        this.leafletOptions = {}
-        // 获取云GIS的Token
-        this.token = await this.requestCouldGisToken()
-    },
-
-    /**
-     * 连接地图服务，构建地图参数
-     * @param {Boolean} alert 是否提示参数错误
-     */
-    async start({alert} = {}) {
-        return new Promise(async resolve => {
-            for (let v of ['url']) {
-                const value = this.options ? this.options[v] : null
-                const message = `参数 options.${v} 无效`
-                if (!_.isString(value) || value.trim().length == 0) {
-                    this.fire('fail', {message: message})
-                    if (alert) {
-                        this.fire('message', {message, messageType: 'error'})
-                    }
-                    return
-                }
-            }
-            this.requestOptions.uid = this.options?.uid || `vae_client_${idGen()}`
-
-            try {
-                this.fire('openmask', {text: `正在 获取图元信息`})
-                const params = new URLSearchParams()
-                params.append('packettype', 'map')
-                params.append('action', 'getmeta')
-                params.append('uid', this.requestOptions.uid)
-                if (_.isString(this.options.dsname) && this.options.dsname.trim().length > 0) {
-                    params.append('dsname', this.options.dsname)
-                } else {
-                    params.append('dsid', this.options.dsid || 'default')
-                }
-                if (_.isString(this.options.mapname) && this.options.mapname.trim().length > 0) {
-                    params.append('mapname', this.options.mapname)
-                } else {
-                    params.append('mapid', this.options.mapid || 'default')
-                }
-                const metaData = (await axios.post(this.options.url + 'map/getmeta?', params)).data
-                this.fire('closemask')
-                if (metaData.status == 'success') {
-                    this.buildMapOptions(metaData.result)
-                    resolve(true)
-                } else {
-                    this.fire('fail', {message: "未获取到正确的图元信息"})
-                    console.error(metaData.errinfo)
-                    this.fire('message', {message: "未获取到正确的图元信息", messageType: 'error'})
-                    resolve(false)
-                }
-            } catch (error) {
-                this.fire('fail', {message: "获取图元失败，请检查地图服务和请求参数"})
-                console.error(error)
-                this.fire('message', {message: "获取图元失败，请检查地图服务和请求参数", messageType: 'error'})
-                this.fire('closemask')
-                resolve(false)
-            }
-        })
-    },
-
-    // 构建地图配置项
-    buildMapOptions({dsid, mapid, extent}) {
-        try {
-            extent = this.options.extent || extent
-            if (_.isString(extent)) {
-                extent = extent.split(',')
-            }
-            if (Array.isArray(extent)) {
-                extent = extent.map(Number)
-            }
-
-            // 参数整理
-            if (dsid) {
-                this.requestOptions.url = this.options.url
-                this.requestOptions.dsid = dsid
-                this.requestOptions.mapid = mapid ?? this.options.mapid ?? 'default'
-                // this.requestOptions.mapid = mapid || this.options.mapid || 'default'
-                this.requestOptions.dsname = this.options.dsname
-            } else {
-                this.fire('fail', {message: '数据源dsid错误'})
-                throw new Error('数据源dsid错误')
-            }
-            // 构建配置
-            if (Array.isArray(extent) && extent.length == 4) {
-                // extent
-                this.extent = extent // [buildMapOptions] //extent
-                let centerX = (extent[0] + extent[2]) * 0.5
-                let centerY = (extent[1] + extent[3]) * 0.5
-                console.log(this.extent)
-                // crs
-                let crs = this.options.crs || L.Vae.CRS.SIMPLE()
-                if (crs == 'bj54') {
-                    crs = L.Vae.CRS.BJ54(centerX, this.options)
-                } else if (crs == 'xa80') {
-                    crs = L.Vae.CRS.XA80(centerX)
-                } else if (crs == 'simple') {
-                    crs = L.Vae.CRS.SIMPLE()
-                } else if (crs == 'CGCS2000' || crs == 'cgcs2000') {
-                    crs = L.Vae.CRS.CGCS2000(centerX,this.options)
-                }
-
-                // wmscrs
-                let wmscrs = this.options.wmscrs || crs
-                if (wmscrs == 'bj54') {
-                    wmscrs = L.Vae.CRS.BJ54(centerX)
-                } else if (wmscrs == 'xa80') {
-                    wmscrs = L.Vae.CRS.XA80(centerX)
-                } else if (crs == 'simple') {
-                    wmscrs = L.Vae.CRS.SIMPLE()
-                } else if (crs == 'CGCS2000' || crs == 'cgcs2000') {
-                    wmscrs = L.Vae.CRS.CGCS2000(centerX,this.options)
-                }
-                // center
-                const center = this.options.center || wmscrs.unproject(L.point(centerX, centerY))
-                // maxzoom
-                const maxZoom = this.options.maxZoom ? this.options.maxZoom :
-                    (crs.options && crs.options.resolutions) ? crs.options.resolutions.length - 1 : 25
-                // bounds
-                const corner1 = wmscrs.unproject(L.point(extent[0], extent[1]))
-                const corner2 = wmscrs.unproject(L.point(extent[2], extent[3]))
-                const bounds = L.latLngBounds(corner1, corner2)
-                this.leafletOptions = {crs, wmscrs, center, maxZoom, bounds}
-            } else {
-                this.fire('fail', {message: '地图属性extent错误'})
-                throw new Error('地图属性extent错误')
-            }
-        } catch (e) {
-            this.fire('fail', {message: "地图参数构建错误"})
-            console.error(e)
-            this.fire('message', {message: "地图参数构建错误", type: 'error'})
-        }
-    },
-
-    /**
-     * 请求地图服务
-     * @param {string} api 请求动作
-     * @param {string} message 提示消息
-     * @param {object} params 额外参数
-     * @param {boolean} forceResolve 请求结果无效时，强制resolve而不是reject
-     * @param {boolean} checkResult 是否校验结果
-     * @param {boolean} loadMask 是否添加遮罩层
-     */
-    requestServer({api, message = '加载数据', params = {}, forceResolve, checkResult = true, loadMask = true}) {
-        return new Promise((resolve, reject) => {
-            if (api) {
-                if (loadMask) {
-                    this.fire('openmask', {text: `正在 ${message}`})
-                }
-                axios.post(`${this.requestOptions.url}${api}`, L.extend({
-                    uid: this.requestOptions.uid,
-                    dsGuid: this.requestOptions.dsid
-                }, params)).then(result => {
-                    if (checkResult) {
-                        const data = result.data
-                        if (data && data.status == 'success') {
-                            resolve(data.result)
-                        } else {
-                            this.fire('fail', {message: data.errinfo})
-                            if (forceResolve) {
-                                console.error(data.errinfo)
-                                resolve('')
-                            } else {
-                                this.fire('message', {message: `${message}结果无效`, messageType: 'error'})
-                                console.error(data.errinfo)
-                                reject(data.errinfo)
-                            }
-                        }
-                    } else {
-                        resolve(result.data)
-                    }
-                }).catch(e => {
-                    this.fire('fail', {message: `${message}失败，请检查地图服务和和请求参数`})
-                    this.fire('message', {message: `${message}失败，请检查地图服务和和请求参数`, messageType: 'error'})
-                    console.error(e)
-                    reject(e)
-                }).finally(() => {
-                    if (loadMask) {
-                        this.fire('closemask')
-                    }
-                })
-            }
-        })
-    },
-    /**
-     * 请求云GIS地图服务
-     * @param {string} api 请求动作
-     * @param {string} message 提示消息
-     * @param {object} params 额外参数
-     * @param {boolean} forceResolve 请求结果无效时，强制resolve而不是reject
-     * @param {boolean} checkResult 是否校验结果
-     * @param {boolean} loadMask 是否添加遮罩层
-     */
-    requestCloudServer({api, message = '加载数据', params = {}, forceResolve, checkResult = true, loadMask = true}) {
-        return new Promise((resolve, reject) => {
-            if (api) {
-                if (loadMask) {
-                    this.fire('openmask', {text: `正在 ${message}`})
-                }
-                axios.get(`${this.options.url}${api}`, 
-                    {
-                        params: _.merge(params, { token : this.token})
-                    }
-                ).then(async result => {
-                    if (checkResult) {
-                        const data = result.data
-                        if (data && data.code == '0') {
-                            resolve(data.data)
-                        } else {
-                            this.fire('fail', {message: data.msg})
-                            if (forceResolve) {
-                                console.error(data.msg)
-                                resolve('')
-                            } else {
-                                // 判断Token过期
-                                if (data && data.code == '40001'){
-                                    console.log("requestCloudServer 登录过期，重新获取token", this.token)
-                                    // 获取云GIS的Token
-                                    this.token = await this.requestCouldGisToken()
-                                    this.requestCloudServer({api, message, params, forceResolve, checkResult, loadMask}).then(res =>{
-                                        resolve(res)
-                                    }).catch(err =>{
-                                        reject(err)
-                                    })
-                                }else{
-                                    this.fire('message', {message: `${message}结果无效`, messageType: 'error'})
-                                    console.error(data.msg)
-                                    reject(data.msg)
-                                }
-                            }
-                        }
-                    } else {
-                        resolve(result.data)
-                    }
-                }).catch(e => {
-                    console.log("catch ERROR", e)
-                    this.fire('fail', {message: `${message}失败，请检查地图服务和和请求参数`})
-                    this.fire('message', {message: `${message}失败，请检查地图服务和和请求参数`, messageType: 'error'})
-                    console.error(e)
-                    reject(e)
-                }).finally(() => {
-                    if (loadMask) {
-                        this.fire('closemask')
-                    }
-                })
-            }
-        })
-    },
-    /**
-     * 请求云GIS数据
-     * @param {string} api 请求动作
-     * @param {string} message 提示消息
-     * @param {object} params 额外参数
-     * @param {string} method 请求方式
-     * @param {object} data POST请求体
-     * @param {object} headers 请求头
-     * @param {boolean} forceResolve 请求结果无效时，强制resolve而不是reject
-     * @param {boolean} checkResult 是否校验结果
-     * @param {boolean} loadMask 是否添加遮罩层
-     */
-    requestCloudMapData({api, message = '加载数据', params = {}, method = 'get', data = null, headers = {}, forceResolve, checkResult = true, loadMask = true}) {
-        return new Promise((resolve, reject) => {
-            if (api) {
-                if (loadMask) {
-                    this.fire('openmask', {text: `正在 ${message}`})
-                }
-                const requestUrl = `${this.options.cloudGisUrl}${api}`
-                const requestMethod = String(method).toLowerCase()
-                const request = requestMethod === 'post'
-                    ? axios.post(requestUrl, data, {headers})
-                    : axios.get(requestUrl, {
-                        params: _.merge(params, { token : this.token})
-                    })
-                request.then(async result => {
-                    if (checkResult) {
-                        const response = result.data
-                        if (response && response.code == '0') {
-                            resolve(response.data)
-                        } else {
-                            this.fire('fail', {message: response.msg})
-                            if (forceResolve) {
-                                console.error(response.msg)
-                                resolve('')
-                            } else {
-                                // 判断Token过期
-                                if (response && response.code == '40001'){
-                                    console.log("requestCloudMapData 登录过期，重新获取token", this.token)
-                                    // 获取云GIS的Token
-                                    this.token = await this.requestCouldGisToken()
-                                    const nextHeaders = headers.Authorization ? _.merge({}, headers, {Authorization: this.token}) : headers
-                                    this.requestCloudMapData({api, message, params, method, data, headers: nextHeaders, forceResolve, checkResult, loadMask}).then(res =>{
-                                        resolve(res)
-                                    }).catch(err =>{
-                                        reject(err)
-                                    })
-                                }else{
-                                    this.fire('message', {message: `${message}结果无效`, messageType: 'error'})
-                                    console.error(response.msg)
-                                    reject(response.msg)
-                                }
-                            }
-                        }
-                    } else {
-                        resolve(result.data)
-                    }
-                }).catch(e => {
-                    console.log("catch ERROR", e)
-                    this.fire('fail', {message: `${message}失败，请检查地图服务和和请求参数`})
-                    this.fire('message', {message: `${message}失败，请检查地图服务和和请求参数`, messageType: 'error'})
-                    console.error(e)
-                    reject(e)
-                }).finally(() => {
-                    if (loadMask) {
-                        this.fire('closemask')
-                    }
-                })
-            }
-        })
-    },
-    /**
-     * 请求云GIS的Token
-     */
-    requestCouldGisToken() {
-        return new Promise((resolve, reject) => {
-            axios.post(`${this.options.cloudGisUrl}api/gis/mapserver/rest/auth`,{
-                user_name: this.options.username,
-                password: this.options.password
-            }).then(result => {
-                    const data = result.data
-                    if (data && data.code == '0') {
-                        resolve(data.data.token)
-                    } else {
-                        this.fire('fail', {message: data.msg})
-                        this.fire('message', {message: `请求Token失败，${data.msg}`, messageType: 'error'})
-                        console.error(data.msg)
-                        resolve('')
-                    }
-            }).catch(e => {
-                console.log('noErrorMsg', this.options);
-                
-                if(!this.options.noErrorMsg){
-                    this.fire('fail', {message: `请求Token失败，请检查云GIS账号和密码`})
-                    this.fire('message', {message: `请求Token失败，请检查云GIS账号和密码`, messageType: 'error'})
-                }
-                console.error(e)
-                reject(e)
-            })
-        })
-    },
-
-    // 设置默认图层
-    async setDefaultLayers() {
-        this.fire('openmask', {text: `正在 加载默认图层`})
-        const {defaultLayers, defaultLayerSets, disabledLayerSets, layerTreeType} = this.options
-        await this.formatLayerGroup_CloudGis(layerTreeType, disabledLayerSets)
-        if (Array.isArray(defaultLayers)) {
-            this.visibleKeys = await this.showLayers(defaultLayers, {loadMask: false, refreshTiles: false})
-        } else if (Array.isArray(defaultLayerSets)) {
-            this.visibleKeys = await this.showLayerSets(defaultLayerSets, {loadMask: false, refreshTiles: false})
-        } else if (Array.isArray(disabledLayerSets)) {
-            await this.showLayers(this.visibleKeys, {loadMask: false, refreshTiles: false})
-        }
-        this.fire('closemask')
-    },
-
-    /**
-     * 初始化图层信息
-     * 有协同服务时，处理为树结构
-     * 无协同服务时，处理为列表结构
-     * @param {enum} type 类型，'leaf'（默认）：叶子节点为实际图层，'branch'：叶子节点为末级图集，图层置于layers属性
-     * @param {array<string>} disabledLayerSets 禁用的图集，支持'x>y>z'的选择方式
-     * @returns {treeLayers,visibleLayers}
-     * @property {array<object>} treeLayers 树结构：{id,label,children}
-     * @property {array<string>} visibleKeys 可见图层keys
-     */
-    async formatLayerGroup_CloudGis(type = 'leaf', disabledLayerSets = []) {
-        // 处理结果：树结构和IDS
-        let treeLayers = [], visibleKeys = []
-
-        // 请求数据
-        let layersGroupRes = await this.requestCloudMapData({
-            api: 'api/sys/layerauth/getGroupLayer',
-            message: '获取图层',
-            loadMask: false,
-            params:{
-                dsGuid: this.options.dsGuid
-            }
-        })
-        if(!layersGroupRes){
-            this.fire('fail', {message: `请求图层信息失败`})
-            this.fire('message', {message: `请求图层信息失败`, messageType: 'error'})
-            return
-        }
-        
-        treeLayers = layersGroupRes
-        treeLayers.forEach(group =>{
-            this.handleLayerNode(group, 0)
-        })
-
-        // 处理禁用的图集
-        if (Array.isArray(disabledLayerSets) && disabledLayerSets.length > 0) {
-            let disabledKeys = []
-            let disabledAllKeys = []
-            disabledLayerSets.forEach(set => {
-                let node
-                set.split('>').forEach(v => {
-                    if (v) {
-                        node = getTreeNode(node ? [node] : treeLayers, {label: v})
-                    }
-                })
-                if (node) {
-                    disabledKeys.push(node.id)
-                }
-            })
-            if (disabledKeys.length > 0) {
-                // 获取节点下的图层
-                const collectLayers = node => {
-                    let result = []
-                    if (Array.isArray(node.children) && node.children.length > 0) {
-                        node.children.forEach(v => {
-                            result = _.concat(result, collectLayers(v))
-                        })
-                    } else {
-                        result = _.concat(result, node.layers || node)
-                    }
-                    return result
-                }
-                // 去除禁用的节点集
-                const collectNodes = node => {
-                    let result = node
-                    if (_.includes(disabledKeys, node.id)) {
-                        result = null
-                        disabledAllKeys.push(node.id)
-                        collectLayers(node).forEach(v => {
-                            disabledAllKeys.push(v.id)
-                        })
-                    } else {
-                        let children = result.children
-                        if (children && children.length > 0) {
-                            result.children = _.compact(children.map(v => collectNodes(v)))
-                        }
-                    }
-                    return result
-                }
-                // 更新图层树和全量keys
-                treeLayers = _.compact(treeLayers.map(v => collectNodes(v)))
-                this.visibleKeys = _.pull(this.visibleKeys, ..._.uniq(disabledAllKeys))
-            }
-        }
-        this.treeLayers = treeLayers
-    },
-    handleLayerNode(node, level = 0, parentId = '') {
-        // 为当前节点添加level属性
-        let tempNode;
-        node.level = level
-        if(node.type == 'layergroup'){
-            delete node.type
-            delete node.isLoad
-            delete node.mapInfo
-            delete node.isReadOnly
-            node.id = `NODE_${level}_${node.id}`
-        }
-        if(node.type == 'layeritem'){
-            delete node.type
-            delete node.isLoad
-            delete node.mapInfo
-            delete node.isReadOnly
-            node.id = `LEAF_${level}_${node.guid}_${parentId}`
-            this.visibleKeys.push(node.id)
-        }    
-        // 如果当前节点有children属性，则对每个子节点递归调用addLevelToNodes
-        if (node.children && Array.isArray(node.children)) {
-            node.children.forEach(child => this.handleLayerNode(child, level + 1, node.id));
-        }
-    },
-
-    /**
-     * 显示指定图层
-     * @param {array} nodes 图层节点集，兼容keys/leaf节点/branch节点
-     * @param {boolean} args.loadMask 是否添加遮罩层
-     * @param {boolean} args.refreshTiles 是否刷新瓦片
-     * @returns {array} 对应的图层keys
-     */
-    async showLayers(nodes = [], args = {loadMask: true, refreshTiles: true}) {
-        // 参数对象转义
-        const loadMask = _.isUndefined(args.loadMask) ? true : !!args.loadMask
-        const refreshTiles = _.isUndefined(args.refreshTiles) ? true : !!args.refreshTiles
-        // 关闭全部图层
-        await this.requestServer({
-            api: 'layer/hidelayers',
-            params: {type: 'all'},
-            message: '关闭全部图层',
-            loadMask
-        })
-        const nodesToLabels = ns => {
-            let ls = [], ks = []
-            if (Array.isArray(ns)) {
-                const getLabelByKey = (tree, key) => {
-                    let labels = []
-
-                    function doRecursion(array) {
-                        for (let node of array) {
-                            if (node.id == key) {
-                                if (Array.isArray(node.layers)) {
-                                    labels = node.layers.map(v => v.label)
-                                } else {
-                                    labels = [node.label]
-                                }
-                                break
-                            } else if (Array.isArray(node.children) && node.children.length > 0) {
-                                doRecursion(node.children)
-                            }
-                        }
-                    }
-
-                    doRecursion(tree)
-                    return labels
-                }
-                ns.forEach(n => {
-                    if (typeof (n) == 'string') {
-                        ls = _.concat(ls, getLabelByKey(this.treeLayers, n))
-                        ks.push(n)
-                    } else if (typeof (n) == 'object') {
-                        if (Array.isArray(n.layers)) {
-                            ls = _.concat(ls, n.layers.map(v => v.label))
-                            ks = _.concat(ls, n.layers.map(v => v.id))
-                        } else {
-                            ls.push(n.label)
-                            ks.push(n.id)
-                        }
-                    }
-                })
-            }
-            return [ls, ks]
-        }
-
-        const [labels, keys] = nodesToLabels(nodes)
-        await this.requestServer({
-            api: 'layer/showlayers',
-            params: {
-                layers: _.join(labels),
-                packettype: 'layer',
-                action:'showlayers',
-                mapid: this.requestOptions.mapid},
-            message: '打开指定图层',
-            loadMask
-        })
-        if (refreshTiles) {
-            this.fire('refreshtilelayer')
-        }
-        this.visibleKeys = keys
-
-        return this.visibleKeys
-    },
-
-    /**
-     * 显示指定图组，支持'xx>yy>zz'形式的精确选择
-     * @param {array} sets 图组名称
-     * @param {boolean} args.loadMask 是否添加遮罩层
-     * @param {boolean} args.refreshTiles 是否刷新瓦片
-     * @returns {array} 对应的图层keys
-     */
-    async showLayerSets(sets = [], args = {loadMask: true, refreshTiles: true}) {
-        // 参数对象转义
-        const loadMask = _.isUndefined(args.loadMask) ? true : !!args.loadMask
-        const refreshTiles = _.isUndefined(args.refreshTiles) ? true : !!args.refreshTiles
-        if (_.isString(sets) && sets.length > 0) {
-            sets = [sets]
-        }
-        if (this.treeLayers.length > 0) {
-            // 获取目标节点的图层集
-            const collectLayers = node => {
-                let result = []
-                if (Array.isArray(node.children) && node.children.length > 0) {
-                    node.children.forEach(v => {
-                        result = _.concat(result, collectLayers(v))
-                    })
-                } else {
-                    result = _.concat(result, node.layers || node)
-                }
-                return result
-            }
-
-            // 组织并定位图集
-            let keys = []
-            sets.forEach(set => {
-                let node
-                set.split('>').forEach(v => {
-                    if (v) {
-                        node = getTreeNode(node ? [node] : this.treeLayers, {label: v})
-                    }
-                })
-                if (node) {
-                    keys.push(node.id)
-                    collectLayers(node).forEach(v => {
-                        keys.push(v.id)
-                    })
-                }
-            })
-            await this.showLayers(keys, {loadMask, refreshTiles})
-            return keys
-        }
-    },
-
-    /**
-     * 获取指定图组的所有key，支持'xx>yy>zz'形式的精确选择
-     * @param {array} sets 图组名称
-     * @param {array} except 被排除的图层名称
-     * @returns {array} 对应的图层keys
-     */
-    async getLayerSetsKeys(sets = [], except = []){
-        if (_.isString(sets) && sets.length > 0) {
-            sets = [sets]
-        }
-        if (this.treeLayers.length > 0) {
-            // 获取目标节点的图层集
-            const collectLayers = node => {
-                let result = []
-                if (Array.isArray(node.children) && node.children.length > 0) {
-                    node.children.forEach(v => {
-                        result = _.concat(result, collectLayers(v))
-                    })
-                } else {
-                    result = _.concat(result, node.layers || node)
-                }
-                return result
-            }
-
-            // 组织并定位图集
-            let keys = []
-            sets.forEach(set => {
-                let node
-                set.split('>').forEach(v => {
-                    if (v) {
-                        node = getTreeNode(node ? [node] : this.treeLayers, {label: v})
-                    }
-                })
-                if (node) {
-                    keys.push(node.id)
-                    collectLayers(node).forEach(v => {
-                        let flag = false
-                        except.forEach(item =>{
-                            if(v.label.indexOf(item) > -1){
-                                flag = true
-                            }
-                        })
-                        if(!flag){
-                            keys.push(v.id)
-                        }
-                    })
-                }
-            })
-            return keys
-        }
-    },
-
-    /**
-     * 查询实体信息
-     * @param {object} params 查询参数
-     * @param {boolean} loadMask 是否添加遮罩层
-     */
-    queryEntity(params = {}, loadMask) {
-        const data = L.extend({
-            stamp: Date.now(),
-            dsGuid: this.options.dsGuid,  //this.requestOptions.dsid || '',
-            returnAttribute: true,
-            geometryTypes: 'point,line,polyline,polygon,compound',
-            layerNames: '',
-            returnFeatureInfo: 'all',
-            returnGroupByLayer: true
-        }, params)
-
-        return this.requestCloudMapData({
-            api: 'api/gis/mapserver/rest/feature/query',
-            method: 'post',
-            data,
-            headers: {
-                Authorization: this.token
-            },
-            message: '查询实体',
-            loadMask
-        })
-    },
-
-    /**
-     * 查询要素字典
-     * @param {string} targetDsGuid 数据源唯一标识
-     * @param {boolean} loadMask 是否添加遮罩层
-     */
-    getFeatureDict(loadMask) {
-        return this.requestCloudMapData({
-            api: 'api/cfg/features/get',
-            message: '查询字典',
-            loadMask,
-            params: {
-                stamp: Date.now(),
-                dsGuid: this.options.dsGuid,
-            }
-        })
-    },
-
-    // 获取缩略图
-    getThumbnail() {
-        return new Promise(resolve => {
-            if (this.extent.length == 4) {
-                const {url, dsid, mapid, uid} = this.requestOptions
-                axios.get(`${url}wmsmap/getmap`, {
-                    params: {
-                        dsid,
-                        mapid,
-                        uid,
-                        request: 'GetMap',
-                        service: 'WMS',
-                        width: 256,
-                        height: 256,
-                        format: 'image/png',
-                        transparent: true,
-                        version: '1.1.1',
-                        bbox: _.join(this.extent, ','),
-                    },
-                    responseType: 'arraybuffer'
-                }).then(result => {
-                    const base64Data = btoa(new Uint8Array(result.data).reduce((data, byte) => data + String.fromCharCode(byte), ''))
-                    resolve(`data:image/png;base64,${base64Data}`)
-                })
-            }
-        })
-    },
-
-
-    // 获取切片图层对象
-    // 适用于requestOptions、leafletOptions以及图层状态已经准备的场景
-    currentTileLayer() {
-        const {url, dsid, mapid, uid} = this.requestOptions
-        const {wmscrs, maxZoom} = this.leafletOptions
-        const wmsUrl = `${url}wmsmap/getmap?dsid=${dsid}&mapid=${mapid}&uid=${uid}&tid=${idGen()}`
-        return L.tileLayer.wms(wmsUrl, {
-            format: 'image/png',
-            transparent: true,
-            crs: wmscrs,
-            maxZoom: maxZoom
-        })
-    },
-
-    // 生成切片图层对象
-    async createTileLayer({beforeCreate} = {}) {
-        await this.start()
-        if (_.isFunction(beforeCreate)) {
-            await beforeCreate(this)
-        }
-        await this.setDefaultLayers()
-        return this.currentTileLayer()
-    }
-
-})