@sword916/vae-map-plus 1.0.0

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

@@ -0,0 +1,780 @@
+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()
+    }
+
+})