import BaseServer from '../BaseServer'
import { Zondy } from '../../base'
import { Log, defaultValue } from '../../util'
import CAttStruct from './support/CAttStruct'
/**
* 资源服务，基地址为http://{ip}:{port}/igs/rest/services/system/ResourceServer
* @class ResourceServer
* @moduleEx ServiceModule
* @extends BaseServer
* @param {Object} options 构造参数
* @param {String} [options.url ] 服务基地址
*/
class ResourceServer extends BaseServer {
constructor(options) {
super(options)
// 默认为igs2.0服务
this.igsType = '2.0'
// 是igs1.0服务
if (this.url.indexOf('/igs/rest/mrcs') > -1) {
this.igsType = '1.0'
}
}
/**
* @function ResourceServer.prototype.queryDataSourceList
* @description 获取数据源列表,支持igs1.0和igs2.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @return {Promise<Object>}
* @example <caption><h5>igs2.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* // ES6引入方式
* import { ResourceServer } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const dataSourceList = resourceServer.queryDataSourceList({
success: function (res) {
console.log("res: ", res);
},
});
* @example <caption><h5>igs1.0</h5></caption>
// ES5引入方式
* const { ResourceServer } = Zondy.Service
* // ES6引入方式
* import { ResourceServer } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const dataSourceList = resourceServer.queryDataSourceList({
success: function (res) {
console.log("res: ", res);
},
});
*/
queryDataSourceList(options) {
const self = this
// 设置PATH PARAMETERS校验
const checkPathOpts = {}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
const pathDataSource =
self.igsType === '1.0' ? 'datasource' : 'datasources'
return self.igsType === '1.0'
? `${url}/${pathDataSource}`
: `${url}/${pathDataSource}?f=json`
}
)
}
/**
* @function ResourceServer.prototype.queryDataSourceInfo
* @description 查询数据源信息
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.datasource] 数据库名，必传
* @return {Promise<Object>}
* @example <caption><h5>igs2.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* // ES6引入方式
* import { ResourceServer } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const dataSourceInfo = resourceServer.queryDataSourceInfo({
datasource: "MapGISLocalPlus",
success: function (res) {
console.log("res: ", res);
},
});
*
*/
queryDataSourceInfo(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
datasource: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/datasources/${options.datasource}?f=json`
}
)
}
/**
* @function ResourceServer.prototype.queryGDBList
* @description 查询GDB列表
* @param options 查询参数
* @param {String} [options.datasource] 数据源名，必传
* @param {String} [options.userName ] 数据源用户名
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @return {Promise<Object>}
* @example <caption><h5>igs2.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* // ES6引入方式
* import { ResourceServer } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const queryGDBList = resourceServer.queryGDBList({
datasource: 'MapGISLocalPlus',
success: function (res) {
console.log('res: ', res)
}
})
* @example <caption><h5>igs1.0</h5></caption>
// ES5引入方式
* const { ResourceServer } = Zondy.Service
* // ES6引入方式
* import { ResourceServer } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const dataSourceInfo = resourceServer.queryDataSourceInfo({
datasource: "MapGISLocalPlus",
success: function (res) {
console.log("res: ", res);
},
});
*
*/
queryGDBList(options) {
const self = this
// 设置PATH PARAMETERS校验
const checkPathOpts = {
datasource: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
userName: {
type: 'String'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
const pathDataSource =
self.igsType === '1.0' ? 'datasource' : 'datasources'
return self.igsType === '1.0'
? `${url}/${pathDataSource}/${options.datasource}`
: `${url}/${pathDataSource}/${options.datasource}/gdbs?f=json`
}
)
}
/**
* @function ResourceServer.prototype.addGDB
* @description 新建数据库
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.datasource] 数据库名，必传
* @param {String} [options.gdbName ] gdb名称
* @param {String} [options.userName ] 数据源用户名
* @param {String} [options.path ] gdb路径
* @return {Promise<Object>}
* @example <caption><h5>igs2.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const addGDB = resourceServer.addGDB({
method: FetchMethod.post,
datasource: "MapGISLocalPlus",
gdbName: "test_0426",
path: "e://数据源",
useName: "",
success: function (res) {
console.log("res: ", res);
},
});
* @example <caption><h5>igs1.0</h5></caption>
// ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const addGDB = resourceServer.addGDB({
method: FetchMethod.get,
datasource: "MapGISLocalPlus",
gdbName: "test_04261",
path: "d:\\",
useName: "",
success: function (res) {
console.log("res: ", res);
},
});
*
*/
addGDB(options) {
const self = this
// 设置PATH PARAMETERS校验
let checkPathOpts = {}
// 设置QUERY PARAMETERS校验
let checkQueryOpts = {}
if (this.igsType === '2.0') {
checkPathOpts = {
datasource: {
type: 'String'
}
}
checkQueryOpts = {
gdbName: {
type: 'String'
},
userName: {
type: 'String'
},
path: {
type: 'String'
}
}
} else {
checkPathOpts = {
gdbName: {
type: 'String'
}
}
checkQueryOpts = {
datasource: {
type: 'String',
alias: 'gdbSvrName'
},
userName: {
type: 'String',
alias: 'gdbUserName'
},
path: {
type: 'String'
}
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
const pathDataSource =
self.igsType === '1.0' ? 'datasource' : 'datasources'
return self.igsType === '1.0'
? `${url}/gdb/creat/${options.gdbName}`
: `${url}/${pathDataSource}/${options.datasource}/gdbs`
}
)
}
/**
* @function ResourceServer.prototype.attachGDB
* @description 附加数据库
* @param options 查询参数
* @param {String} [options.userName ] 数据源用户名
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.datasource] 数据源名，必传
* @param {String} [options.gdbName ] gdb名称，必传
* @param {String} [options.path ] gdb路径，必传
* @param {String} [options.userName ] 数据源用户名
* @return {Promise<Object>}
* @example <caption><h5>igs2.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const attachGDB = resourceServer.attachGDB({
method: FetchMethod.post,
datasource: 'MapGISLocalPlus',
gdbName: 'test_0426',
path: 'e://数据源//test_0426.hdb',
useName: '',
success: function (res) {
console.log('res: ', res)
}
})
* @example <caption><h5>igs1.0</h5></caption>
// ES5引入方式
const { ResourceServer } = Zondy.Service
const { FetchMethod } = Zondy.Enum
// ES6引入方式
import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const attachGDB = resourceServer.attachGDB({
method: FetchMethod.get,
datasource: "MapGISLocalPlus",
gdbName: "test_0426",
path: "e:\\数据源\\test_0426.hdb",
useName: "",
success: function (res) {
console.log("res: ", res);
},
});
*
*/
attachGDB(options) {
const self = this
// 设置PATH PARAMETERS校验
let checkPathOpts = {}
// 设置QUERY PARAMETERS校验
let checkQueryOpts = {}
if (this.igsType === '2.0') {
checkPathOpts = {
datasource: {
type: 'String'
}
}
checkQueryOpts = {
gdbName: {
type: 'String',
required: true
},
useName: {
type: 'String'
},
path: {
type: 'String',
required: true
}
}
} else {
checkPathOpts = {
gdbName: {
type: 'String'
}
}
checkQueryOpts = {
datasource: {
type: 'String',
alias: 'gdbSvrName'
},
userName: {
type: 'String',
alias: 'gdbUserName'
},
path: {
type: 'String'
}
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
const pathDataSource =
self.igsType === '1.0' ? 'datasource' : 'datasources'
return self.igsType === '1.0'
? `${url}/gdb/attach/${options.gdbName}`
: `${url}/${pathDataSource}/${options.datasource}/gdbs/attach`
}
)
}
/**
* @function ResourceServer.prototype.deleteGDB
* @description 删除数据库
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.datasource] 数据源名，必传
* @param {String} [options.gdbName ] gdb名称，必传
* @param {String} [options.userName ] 数据源用户名
* @return {Promise<Object>}
* @example <caption><h5>igs2.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const deleteGDB = resourceServer.deleteGDB({
method: FetchMethod.delete,
datasource: "MapGISLocalPlus",
gdbName: "test_0426",
useName: "",
success: function (res) {
console.log("res: ", res);
},
});
* @example <caption><h5>igs1.0</h5></caption>
// ES5引入方式
const { ResourceServer } = Zondy.Service
const { FetchMethod } = Zondy.Enum
// ES6引入方式
import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const deleteGDB = resourceServer.deleteGDB({
method: FetchMethod.get,
datasource: "MapGISLocalPlus",
gdbName: "test_0426",
useName: "",
success: function (res) {
console.log("res: ", res);
},
});
*
*/
deleteGDB(options) {
const self = this
// 设置PATH PARAMETERS校验
let checkPathOpts = {}
// 设置QUERY PARAMETERS校验
let checkQueryOpts = {}
if (this.igsType === '2.0') {
checkPathOpts = {
datasource: {
type: 'String'
},
gdbName: {
type: 'String'
}
}
checkQueryOpts = {
useName: {
type: 'String'
}
}
} else {
checkPathOpts = {
gdbName: {
type: 'String'
}
}
checkQueryOpts = {
datasource: {
type: 'String',
alias: 'gdbSvrName'
},
userName: {
type: 'String',
alias: 'gdbUserName'
},
path: {
type: 'String'
}
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
const pathDataSource =
self.igsType === '1.0' ? 'datasource' : 'datasources'
return self.igsType === '1.0'
? `${url}/gdb/delete/${options.gdbName}`
: `${url}/${pathDataSource}/${options.datasource}/gdbs/${options.gdbName}`
}
)
}
/**
* @function ResourceServer.prototype.detachGDB
* @description 注销数据库
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.datasource] 数据源名，必传
* @param {String} [options.gdbName ] gdb名称，必传
* @param {String} [options.userName ] 数据源用户名
* @return {Promise<Object>}
* @example <caption><h5>igs2.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const detachGDB = resourceServer.detachGDB({
method: FetchMethod.put,
datasource: "MapGISLocalPlus",
gdbName: "test_0426",
useName: "",
success: function (res) {
console.log("res: ", res);
},
});
* @example <caption><h5>igs1.0</h5></caption>
// ES5引入方式
const { ResourceServer } = Zondy.Service
const { FetchMethod } = Zondy.Enum
// ES6引入方式
import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const detachGDB = resourceServer.detachGDB({
method: FetchMethod.get,
datasource: "MapGISLocalPlus",
gdbName: "test_0426",
useName: "",
success: function (res) {
console.log("res: ", res);
},
});
*
*/
detachGDB(options) {
const self = this
// 设置PATH PARAMETERS校验
let checkPathOpts = {}
// 设置QUERY PARAMETERS校验
let checkQueryOpts = {}
if (this.igsType === '2.0') {
checkPathOpts = {
datasource: {
type: 'String'
},
gdbName: {
type: 'String'
}
}
checkQueryOpts = {
useName: {
type: 'String'
}
}
} else {
checkPathOpts = {
gdbName: {
type: 'String'
}
}
checkQueryOpts = {
datasource: {
type: 'String',
alias: 'gdbSvrName'
},
userName: {
type: 'String',
alias: 'gdbUserName'
},
path: {
type: 'String'
}
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
const pathDataSource =
self.igsType === '1.0' ? 'datasource' : 'datasources'
return self.igsType === '1.0'
? `${url}/gdb/delete/${options.gdbName}`
: `${url}/${pathDataSource}/${options.datasource}/gdbs/${options.gdbName}/detach`
}
)
}
/**
* @function ResourceServer.prototype.queryFeatureDataSourceList
* @description 查询要素数据集列表
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.datasource] 数据源名，必传
* @param {String} [options.gdbName ] gdb名称，必传
* @param {String} [options.userName ] 数据源用户名
* @return {Promise<Object>}
* @example <caption><h5>igs2.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const queryFeatureDataSourceList =
resourceServer.queryFeatureDataSourceList({
method: FetchMethod.get,
datasource: 'MapGISLocalPlus',
gdbName: 'sample',
useName: '',
success: function (res) {
console.log('res: ', res)
}
})
* @example <caption><h5>igs1.0</h5></caption>
// ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryFeatureDataSourceList =
resourceServer.queryFeatureDataSourceList({
method: FetchMethod.get,
datasource: 'MapGISLocalPlus',
gdbName: 'sample',
useName: '',
success: function (res) {
console.log('res: ', res)
}
})
*
*/
queryFeatureDataSourceList(options) {
const self = this
// 设置PATH PARAMETERS校验
let checkPathOpts = {}
// 设置QUERY PARAMETERS校验
let checkQueryOpts = {}
if (this.igsType === '2.0') {
checkPathOpts = {
datasource: {
type: 'String'
},
gdbName: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
checkQueryOpts = {
useName: {
type: 'String'
}
}
} else {
checkPathOpts = {
datasource: {
type: 'String'
},
gdbName: {
type: 'String'
}
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
const pathDataSource =
self.igsType === '1.0' ? 'datasource' : 'datasources'
return self.igsType === '1.0'
? `${url}/${pathDataSource}/${options.datasource}/${options.gdbName}/fds`
: `${url}/${pathDataSource}/${options.datasource}/gdbs/${options.gdbName}/fds?f=json`
}
)
}
/**
* @function ResourceServer.prototype.queryTileDataSourceList
* @description 获取栅格数据集列表
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.datasource] 数据源名，必传
* @param {String} [options.gdbName ] gdb名称，必传
* @param {String} [options.userName ] 数据源用户名
* @return {Promise<Object>}
* @example <caption><h5>igs2.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const queryTileDataSourceList = resourceServer.queryTileDataSourceList({
method: FetchMethod.get,
datasource: "MapGISLocalPlus",
gdbName: "sample",
useName: "",
success: function (res) {
console.log("res: ", res);
},
});
* @example <caption><h5>igs1.0</h5></caption>
// ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryTileDataSourceList = resourceServer.queryTileDataSourceList({
method: FetchMethod.get,
datasource: "MapGISLocalPlus",
gdbName: "sample",
useName: "",
success: function (res) {
console.log("res: ", res);
},
});
*
*/
queryTileDataSourceList(options) {
const self = this
// 设置PATH PARAMETERS校验
let checkPathOpts = {}
// 设置QUERY PARAMETERS校验
let checkQueryOpts = {}
if (this.igsType === '2.0') {
checkPathOpts = {
datasource: {
type: 'String'
},
gdbName: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
checkQueryOpts = {
useName: {
type: 'String'
}
}
} else {
checkPathOpts = {
datasource: {
type: 'String'
},
gdbName: {
type: 'String'
}
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
const pathDataSource =
self.igsType === '1.0' ? 'datasource' : 'datasources'
return self.igsType === '1.0'
? `${url}/${pathDataSource}/${options.datasource}/${options.gdbName}/rds`
: `${url}/${pathDataSource}/${options.datasource}/gdbs/${options.gdbName}/rds?f=json`
}
)
}
/**
* @function ResourceServer.prototype.querySimpleFeatureList
* @description 简单要素类列表
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.datasource] 数据源名，必传
* @param {String} [options.gdbName ] gdb名称，必传
* @param {String} [options.userName ] 数据源用户名
* @param {String} [options.fdsName ] 要素数据集名称，如果不为空，则仅获取指定要素数据下的数据
* @param {Boolean} [options.includeAll = false] 是否包含要素数据集下及非要素数据集下的简单要素类数据，仅当fdsName为空时有效
* @return {Promise<Object>}
* @example <caption><h5>igs2.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new .ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const querySimpleFeatureList = resourceServer.querySimpleFeatureList({
method: FetchMethod.get,
datasource: "MapGISLocalPlus",
gdbName: "sample",
useName: "",
fdsName: "影像数据",
includeAll: true,
success: function (res) {
console.log("res: ", res);
},
});
* @example <caption><h5>igs1.0</h5></caption>
// ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const querySimpleFeatureList = resourceServer.querySimpleFeatureList({
method: FetchMethod.get,
datasource: "MapGISLocalPlus",
gdbName: "sample",
useName: "",
fdsName: "影像数据",
includeAll: true,
success: function (res) {
console.log("res: ", res);
},
});
*
*/
querySimpleFeatureList(options) {
const self = this
// 设置PATH PARAMETERS校验
let checkPathOpts = {}
// 设置QUERY PARAMETERS校验
let checkQueryOpts = {}
if (this.igsType === '2.0') {
checkPathOpts = {
datasource: {
type: 'String'
},
gdbName: {
type: 'String'
}
}
checkQueryOpts = {
useName: {
type: 'String'
},
fdsName: {
type: 'String'
},
includeAll: {
type: 'Boolean'
}
}
} else {
checkPathOpts = {
datasource: {
type: 'String'
},
gdbName: {
type: 'String'
}
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
const pathDataSource =
self.igsType === '1.0' ? 'datasource' : 'datasources'
return self.igsType === '1.0'
? `${url}/${pathDataSource}/${options.datasource}/${options.gdbName}/sfcls`
: `${url}/${pathDataSource}/${options.datasource}/gdbs/${options.gdbName}/sfcls?f=json`
}
)
}
/**
* @function ResourceServer.prototype.addClass
* @description 在数据库中创建一个类
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.datasource ] 数据源名称，必传
* @param {String} [options.gdbName] gdb名称，必传
* @param {String} [options.userName ] 数据源用户名
* @param {String} [options.layerName ] 图层名称，必传
* @param {String} [options.geomType ] 几何类型，必传，igs2.0支持"Pnt" "Lin" "Reg" "Ann" "Surface" "Entity" "Unknown"
* @param {String} [options.srs ] 参考系信息，支持mapgis参照系名称和EPSG编号,比如EPSG:4326、WGS1984_度
* @param {String} [options.fdsName ] 要素集名称
* @param {Array<Object>} [options.fields ] 属性字段结构信息，必传，示例:[{"name": "string","type": "string","alias": "string","length": 0}]
* @param {String} [options.featureType] 要素类型，取值为sfcls 或 acls，默认sfcls，目前仅支持简单要素类和注记类(只支持文本类型注记)
* @return {Promise<Object>}
* @example <caption><h5>igs2.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
* const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const addClass = resourceServer.addClass({
method: FetchMethod.post,
datasource: "MapGISLocalPlus",
gdbName: "test",
useName: "",
layerName: "test_0426_feature",
srs: "WGS1984_度",
geomType: "Reg",
fdsName: "test",
fields: [{ name: "string", type: "string", alias: "string", length: 0 }],
success: function (res) {
console.log("res: ", res);
},
});
*
*/
addClass(options) {
// 设置PATH PARAMETERS校验
let checkPathOpts = {}
// 设置QUERY PARAMETERS校验
let checkQueryOpts = {}
// 设置PATH PARAMETERS校验
checkPathOpts = {
datasource: {
type: 'String'
},
gdbName: {
type: 'String'
},
featureType: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
checkQueryOpts = {
userName: {
type: 'String'
},
layerName: {
type: 'String',
required: true
},
geomType: {
type: 'String',
required: true
},
srs: {
type: 'String'
},
fdsName: {
type: 'String'
},
fields: {
type: 'Array',
process(v) {
return `&fields=${JSON.stringify(v)}`
},
required: true
}
}
const opt = options || {}
opt.featureType = defaultValue(opt.featureType, 'sfcls')
// 调用基类的查询信息方法
return this._queryByParameters(
opt,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/datasources/${options.datasource}/gdbs/${options.gdbName}/${options.featureType}`
}
)
}
/**
* @function ResourceServer.prototype.getSimpleFeature
* @description 获取简单要素类
* @param options 查询参数
* @param {String} [options.datasource ] 数据源名称，必传
* @param {String} [options.gdbName ] gdb名称，必传
* @param {String} [options.featureSetName ] 简单要素类名称，必传
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.userName ] 数据源用户名
* @return {Promise<Object>}
* @example
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const getSimpleFeature = resourceServer.getSimpleFeature({
method: FetchMethod.get,
datasource: "MapGISLocalPlus",
gdbName: "sample",
featureSetName: "等值线1",
useName: "",
success: function (res) {
console.log("res: ", res);
},
});
*
*/
getSimpleFeature(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
datasource: {
type: 'String'
},
gdbName: {
type: 'String'
},
featureSetName: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
userName: {
type: 'String'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/datasources/${options.datasource}/gdbs/${options.gdbName}/sfcls/${options.featureSetName}?f=json`
}
)
}
/**
* @function ResourceServer.prototype.updateSimpleFeature
* @description 更新单个简单要素类信息
* @param options 查询参数
* @param {String} [options.datasource] 数据源名称，必传
* @param {String} [options.gdbName ] gdb名称，必传
* @param {String} [options.featureSetName ] 简单要素类名称，必传
* @param {Object} [options.updateInfo ] 更新的信息，必传
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.userName ] 数据源用户名
* @return {Promise<Object>}
* @example
*
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const updateSimpleFeature = resourceServer.updateSimpleFeature({
method: FetchMethod.put,
datasource: "MapGISLocalPlus",
gdbName: "sample",
featureSetName: "等值线1",
updateInfo: {
name: "等值线",
srs: "WGS1984_度",
},
success: function (res) {
console.log("res: ", res);
},
});
*
*/
updateSimpleFeature(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
datasource: {
type: 'String'
},
gdbName: {
type: 'String'
},
featureSetName: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
userName: {
type: 'String'
},
updateInfo: {
type: 'Object',
required: true,
process(v) {
return `&updateInfo=${JSON.stringify(v)}`
}
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/datasources/${options.datasource}/gdbs/${options.gdbName}/sfcls/${options.featureSetName}`
}
)
}
/**
* @function ResourceServer.prototype.deleteSimpleFeature
* @description 删除简单要素类
* @param options 查询参数
* @param {String} [options.datasource ] gdb名称，必传
* @param {String} [options.gdbName ] gdb名称，必传
* @param {String} [options.featureSetName ] 简单要素类名称，必传
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.userName ] 数据源用户名
* @return {Promise<Object>}
* @example
*
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const deleteSimpleFeature = resourceServer.deleteSimpleFeature({
method: FetchMethod.delete,
datasource: "MapGISLocalPlus",
gdbName: "sample",
featureSetName: "等值线",
useName: "",
success: function (res) {
console.log("res: ", res);
},
});
*
*/
deleteSimpleFeature(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
datasource: {
type: 'String'
},
gdbName: {
type: 'String'
},
featureSetName: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
userName: {
type: 'String'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/datasources/${options.datasource}/gdbs/${options.gdbName}/sfcls/${options.featureSetName}`
}
)
}
/**
* @function ResourceServer.prototype.querySrsList
* @description 查询参考系列表
* @param options 查询参数
* @param {String} [options.datasource ] 数据源名称，必传
* @param {String} [options.gdbName ] gdb名称，必传
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.userName ] 数据源用户名
* @return {Promise<Object>}
* @example <caption><h5>igs2.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const querySrsList = resourceServer.querySrsList({
method: FetchMethod.get,
datasource: "MapGISLocalPlus",
gdbName: "sample",
useName: "",
success: function (res) {
console.log("res: ", res);
},
});
* @example <caption><h5>igs1.0</h5></caption>
// ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const querySrsList = resourceServer.querySrsList({
method: FetchMethod.get,
datasource: "MapGISLocalPlus",
gdbName: "sample",
useName: "",
success: function (res) {
console.log("res: ", res);
},
});
*
*/
querySrsList(options) {
const self = this
// 设置PATH PARAMETERS校验
let checkPathOpts = {}
// 设置QUERY PARAMETERS校验
let checkQueryOpts = {}
if (this.igsType === '2.0') {
checkPathOpts = {
datasource: {
type: 'String'
},
gdbName: {
type: 'String'
}
}
checkQueryOpts = {
useName: {
type: 'String'
}
}
} else {
checkPathOpts = {
datasource: {
type: 'String'
},
gdbName: {
type: 'String'
}
}
checkQueryOpts = {
useName: {
type: 'String',
alias: 'user'
}
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
const pathDataSource =
self.igsType === '1.0' ? 'datasource' : 'datasources'
return self.igsType === '1.0'
? `${url}/${pathDataSource}/${options.datasource}/${options.gdbName}?f=json`
: `${url}/datasources/${options.datasource}/gdbs/${options.gdbName}/spatialRefs?f=json`
}
)
}
/**
* @function ResourceServer.prototype.querySrsInfo
* @description 查询参考系信息
* @param options 查询参数
* @param {String} [options.datasource ] 数据源名称，必传
* @param {String} [options.gdbName ] gdb名称，必传
* @param {String} [options.srsName ] 参考系名称，必传,在使用igs1.0服务时，需要传入参考系id
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.userName ] 数据源用户名
* @return {Promise<Object>}
* @example <caption><h5>igs2.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const querySrsInfo = resourceServer.querySrsInfo({
method: FetchMethod.get,
datasource: "MapGISLocalPlus",
gdbName: "sample",
srsName: "WGS1984_度",
useName: "",
success: function (res) {
console.log("res: ", res);
},
});
* @example <caption><h5>igs1.0</h5></caption>
// ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const querySrsInfo = resourceServer.querySrsInfo({
method: FetchMethod.get,
datasource: "MapGISLocalPlus",
gdbName: "sample",
srsName: "7",
useName: "",
success: function (res) {
console.log("res: ", res);
},
});
*
*/
querySrsInfo(options) {
const self = this
// 设置PATH PARAMETERS校验
let checkPathOpts = {}
// 设置QUERY PARAMETERS校验
let checkQueryOpts = {}
if (this.igsType === '2.0') {
checkPathOpts = {
datasource: {
type: 'String'
},
gdbName: {
type: 'String'
},
srsName: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
checkQueryOpts = {
useName: {
type: 'String'
}
}
} else {
checkPathOpts = {
datasource: {
type: 'String'
},
gdbName: {
type: 'String'
},
srsName: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
checkQueryOpts = {
useName: {
type: 'String'
}
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
const pathDataSource =
self.igsType === '1.0' ? 'datasource' : 'datasources'
return self.igsType === '1.0'
? `${url}/${pathDataSource}/${options.datasource}/${options.gdbName}/${options.srsName}?f=json`
: `${url}/datasources/${options.datasource}/gdbs/${options.gdbName}/spatialRefs/${options.srsName}?f=json`
}
)
}
/**
* @function ResourceServer.prototype.querySystemLibList
* @description 查询系统库资源列表
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @return {Promise<Object>}
* @example <caption><h5>igs2.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const querySystemLibList = resourceServer.querySystemLibList({
method: FetchMethod.get,
success: function (res) {
console.log("res: ", res);
},
});
* @example <caption><h5>igs1.0</h5></caption>
// ES5引入方式
const { ResourceServer } = Zondy.Service
const { FetchMethod } = Zondy.Enum
// ES6引入方式
import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const querySystemLibList = resourceServer.querySystemLibList({
method: FetchMethod.get,
success: function (res) {
console.log("res: ", res);
},
});
*
*/
querySystemLibList(options) {
const self = this
// 设置PATH PARAMETERS校验
const checkPathOpts = {}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return self.igsType === '1.0'
? `${url}/systemlibraries?f=json`
: `${url}/systemLibs?f=json`
}
)
}
/**
* @function ResourceServer.prototype.querySystemColorList
* @description 查询系统颜色列表
* @param options 查询参数
* @param {String} [options.sysLib ] 系统库id，必传
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {Number} [options.page = 1] 页码
* @param {Number} [options.pageSize = 20] 每页数量
* @return {Promise<Object>}
* @example <caption><h5>igs2.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const querySystemColorList = resourceServer.querySystemColorList({
method: FetchMethod.get,
sysLib: "DefaultSystemLib",
page: 1,
pageSize: 20,
success: function (res) {
console.log("res: ", res);
},
});
* @example <caption><h5>igs1.0</h5></caption>
// ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const querySystemColorList = resourceServer.querySystemColorList({
method: FetchMethod.get,
sysLib: "DefaultSystemLib",
page: 0,
pageSize: 20,
success: function (res) {
console.log("res: ", res);
},
});
*
*/
querySystemColorList(options) {
const self = this
// 设置PATH PARAMETERS校验
let checkPathOpts = {}
// 设置QUERY PARAMETERS校验
let checkQueryOpts = {}
if (this.igsType === '2.0') {
checkPathOpts = {
sysLib: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
checkQueryOpts = {
page: {
type: 'Number'
},
pageSize: {
type: 'Number'
}
}
} else {
checkPathOpts = {}
// 设置QUERY PARAMETERS校验
checkQueryOpts = {
page: {
type: 'Number'
},
pageSize: {
type: 'Number',
alias: 'size'
},
sysLib: {
type: 'String',
alias: 'systemLib'
}
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return self.igsType === '1.0'
? `${url}/colors?f=json`
: `${url}/systemLibs/${options.sysLib}/colors?f=json`
}
)
}
/**
* @function ResourceServer.prototype.getColorIndex
* @description 根据RGB值获取颜色号
* @param options 查询参数
* @param {String} [options.sysLib ] 系统库id，必传
* @param {Color} [options.color] 颜色值，必传
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {Boolean} [options.addIfNotExist = false] 如果查找到的颜色不存在，是否新增
* @return {Promise<Object>}
* @example <caption><h5>igs2.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* const { Color } = Zondy
* // ES6引入方式
* import { ResourceServer ,FetchMethod ,Color } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const getColorIndex = resourceServer.getColorIndex({
method: FetchMethod.get,
sysLib: "DefaultSystemLib",
color: new Color(225, 221, 20, 1),
addIfNotExist: false,
success: function (res) {
console.log("res: ", res);
},
});
* @example <caption><h5>igs1.0</h5></caption>
// ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* const { Color } = Zondy
* // ES6引入方式
* import { ResourceServer ,FetchMethod ,Color } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const getColorIndex = resourceServer.getColorIndex({
method: FetchMethod.get,
sysLib: "DefaultSystemLib",
color: new Color(225, 221, 20, 1),
addIfNotExist: false,
success: function (res) {
console.log("res: ", res);
},
});
*
*/
getColorIndex(options) {
const self = this
// 设置PATH PARAMETERS校验
let checkPathOpts = {}
// 设置QUERY PARAMETERS校验
let checkQueryOpts = {}
if (this.igsType === '2.0') {
checkPathOpts = {
sysLib: {
type: 'String'
}
}
checkQueryOpts = {
color: {
type: 'Color',
required: true,
process(v) {
return `&red=${v.red}&green=${v.green}&blue=${v.blue}`
}
},
addIfNotExist: {
type: 'Boolean'
}
}
} else {
checkPathOpts = {}
checkQueryOpts = {
sysLib: {
type: 'String',
alias: 'libID'
},
color: {
type: 'Color',
required: true,
process(v) {
return `&r=${v.red}&g=${v.green}&b=${v.blue}`
}
},
addIfNotExist: {
type: 'Boolean',
alias: 'addNewColor'
}
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return self.igsType === '1.0'
? `${url}/ColorLib/getColorNO?f=json`
: `${url}/systemLibs/${options.sysLib}/colors/findColorNo?f=json`
}
)
}
/**
* @function ResourceServer.prototype.getColorByIndex
* @description 根据颜色号获取RGB值
* @param options 查询参数
* @param {String} [options.sysLib ] 系统库id，必传
* @param {String} [options.colorIndex ] 颜色号，必传
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const querySystemColorList = resourceServer.querySystemColorList({
method: FetchMethod.get,
sysLib: "DefaultSystemLib",
page: 1,
pageSize: 20,
success: function (res) {
console.log("res: ", res);
},
});
* @example <caption><h5>igs1.0</h5></caption>
// ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const querySystemColorList = resourceServer.querySystemColorList({
method: FetchMethod.get,
sysLib: "DefaultSystemLib",
page: 1,
pageSize: 20,
success: function (res) {
console.log("res: ", res);
},
});
*
*/
getColorByIndex(options) {
const self = this
// 设置PATH PARAMETERS校验
let checkPathOpts = {}
// 设置QUERY PARAMETERS校验
let checkQueryOpts = {}
if (this.igsType === '2.0') {
// 设置PATH PARAMETERS校验
checkPathOpts = {
sysLib: {
type: 'String'
},
colorIndex: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
checkQueryOpts = {}
} else {
// 设置PATH PARAMETERS校验
checkPathOpts = {}
// 设置QUERY PARAMETERS校验
checkQueryOpts = {
sysLib: {
type: 'String',
alias: 'libID'
},
colorIndex: {
type: 'String',
alias: 'colorNO'
}
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return self.igsType === '1.0'
? `${url}/ColorLib/getColorRGB?f=json`
: `${url}/systemLibs/${options.sysLib}/colors/${options.colorIndex}?f=json`
}
)
}
/**
* @function ResourceServer.prototype.queryTempDataServerInfo
* @description 获取临时数据服务信息
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @return {Promise<Object>}
* @example <caption><h5>igs2.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const queryTempDataServerInfo = resourceServer.queryTempDataServerInfo({
method: FetchMethod.get,
success: function (res) {
console.log("res: ", res);
},
});
*
*/
queryTempDataServerInfo(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/tempData?f=json`
}
)
}
/**
* @function ResourceServer.prototype.queryTempDataFeatures
* @description 获取临时图层要素信息
* @param options 要素查询参数
* @param {String} [options.method = FetchMethod.get ] 请求类型
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {Geometry} [options.geometry ] 要素查询几何条件
* @param {String} [options.url] 图层资源的路径，可能是gdbp、filePath
* @param {Object} [options.mapResource] 地图文档的资源，与urls二选一，mapResource优先，示例："{"url": "/root/wuhan.mapx","mapIndex ": 0,"layerId": "string"}"
* @param {String} [options.where ] 要素查询where条件
* @param {String} [options.outFields ] 输出属性字段，可为*表示所有，多个用英文逗号分隔
* @param {String} [options.objectIds ] 过滤id，多个用英文逗号分隔(参数优先级很高，可能导致其它筛选条件失效)
* @param {Number} [options.distance = 0] 几何缓冲的距离，geometry为point、line时有效（若数据源为大数据PG数据，且geometryType为line或者point时为必填数据）
* @param {Number} [options.geometryPrecision ] 返回要素几何信息中坐标xy的精度
* @param {SpatialRelation} [options.spatialRel ] 几何条件的空间判定规则，Intersects(相交)、EnvelopeIntersects(外包矩形相交)、Contains(包含)、Disjoint(相离)
* @param {String} [options.orderByFields ] 排序字段,格式: fieldName [ASC|DESC]
* @param {String} [options.groupByFieldsForStatistics ] 分组统计的字段信息,格式为field1,field2
* @param {Number} [options.resultRecordCount = 20] 分页参数：结果返回条数，默认20
* @param {Number} [options.resultOffset ] 分页参数：跳过条数
* @param {Array} [options.outStatistics ] 计算一个或多个基于字段的统计信息结构,统计类型包括:FUNCTION_MAX/FUNCTION_MIN/FUNCTION_SUM/FUNCTION_AVG/FUNCTION_COUNT/FUNCTION_MAX_OID，示例："[{"statisticType": "FUNCTION_SUM","onStatisticField": "field1","outStatisticFieldName":"fieldName1"}]"
* @param {Boolean} [options.returnGeometry = true] 是否返回几何，默认为true
* @param {Boolean} [options.returnAttribute = true] 是否返回属性，默认为true
* @param {Boolean} [options.returnStyle = false] 是否返回图形参数信息，默认为false
* @param {Boolean} [options.returnIdsOnly = false] 是否只返回id，默认为false
* @param {Boolean} [options.returnCountOnly = false] 是否只返回条数，默认为false
* @param {Boolean} [options.returnExtentOnly = false] 是否只返回范围，默认为false
* @param {Boolean} [options.returnZ = false] 是否返回Z轴，默认为false
* @param {Boolean} [options.is6xAcls = true] 图层资源的路径是filePath且后缀是.wt时，需要指定图层资源是否是6x注记，默认为6x点
* @return {Promise<Object>}
* @example
*
* // ES5引入方式
const { ResourceServer } = Zondy.Service
const { FetchMethod } = Zondy.Enum
// ES6引入方式
import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const queryTempDataFeatures1 = resourceServer.queryTempDataFeatures({
method: FetchMethod.get,
url: "gdbp://MapGISLocalPlus/sample/sfcls/等值线1",
where: "高度='80'",
success: function (res) {
console.log("res: ", res);
},
});
*
*/
queryTempDataFeatures(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
url: { type: 'String' },
mapResource: {
type: 'Object',
process(data) {
return `&mapResource=${JSON.stringify(data)}`
}
},
where: {
type: 'String'
},
geometry: {
type: 'Geometry'
},
distance: {
type: 'Number'
},
geometryPrecision: {
type: 'Number'
},
spatialRel: {
type: 'String'
},
outFields: {
type: 'String'
},
objectIds: {
type: 'String'
},
orderByFields: {
type: 'String'
},
groupByFieldsForStatistics: {
type: 'String'
},
resultRecordCount: {
type: 'Number'
},
resultOffset: {
type: 'Number'
},
outStatistics: {
type: 'OutStatistics'
},
returnGeometry: {
type: 'Boolean'
},
returnAttribute: {
type: 'Boolean'
},
returnStyle: {
type: 'Boolean'
},
returnIdsOnly: {
type: 'Boolean'
},
returnCountOnly: {
type: 'Boolean'
},
returnExtentOnly: {
type: 'Boolean'
},
returnZ: {
type: 'Boolean'
},
is6xAcls: {
type: 'Boolean'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/tempData/features/query?f=json`
}
)
}
/**
* @function ResourceServer.prototype.queryTempDataInfo
* @description 获取临时数据信息
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.url] 资源url
* @return {Promise<Object>}
* @example
*
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const queryTempDataInfo = resourceServer.queryTempDataInfo({
method: FetchMethod.get,
url: "gdbp://MapGISLocalPlus/sample/sfcls/等值线1",
success: function (res) {
console.log("res: ", res);
},
});
*
*/
queryTempDataInfo(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
url: {
type: 'String',
required: true
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/tempData/info?f=json`
}
)
}
/**
* @function ResourceServer.prototype.editTempDataInfo
* @description 修改系统库
* @param options 查询参数
* @param {String} [options.urls ] 图层列表，必传，可能是gdbp、filePath，多个用","分隔
* @param {String} [options.systemLibId] 系统库id
* @param {String} [options.systemLibName] 系统库的名称，systemLibId参数为空时有效
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @return {Promise<Object>}
* @example
*
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/services/system/ResourceServer",
});
const editTempDataInfo = resourceServer.editTempDataInfo({
method: FetchMethod.put,
urls: "gdbp://MapGISLocalPlus/sample/sfcls/等值线1",
systemLibName: "DefaultSystemLib",
success: function (res) {
console.log("res: ", res);
},
});
*
*/
editTempDataInfo(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
urls: {
type: 'String',
required: true
},
systemLibId: {
type: 'String'
},
systemLibName: {
type: 'String'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/tempData/systemLib?f=json`
}
)
}
/**
* @function ResourceServer.prototype.createGdbLayer
* @description 在GDB数据库中创建一个图层,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.gdbSvrName] 数据源名称,必传
* @param {String} [options.gdbName] GDB数据名称,必传
* @param {String} [options.featureType] 要素类型，必传。FeatureDS（要素数据集）、SfeatureCls（简单要素类）、ObjectCls（对象类）、AnnotationCls（注记类）、RasterDataset（栅格数据集）、RasterCatalog（栅格目录）、GnetCls（几何网络）、AddrBaseCls（地名库）等。
* @param {String} [options.layerName] 图层名称,必传
* @param {String} [options.geoType] 几何类型,必传。区图层为Reg、线图层为Lin、点图层为Pnt
* @param {String} [options.srefName] 参考系名称
* @param {String} [options.dsName] 要素数据集名称
* @param {CAttStruct} [options.attStruct] 图层数据结构
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* const { CAttStruct } = Zondy.Object
* // ES6引入方式
* import { ResourceServer ,FetchMethod ,CAttStruct } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const createGdbLayer = resourceServer.createGdbLayer({
method: FetchMethod.post,
gdbSvrName: "MapGISLocalPlus",
gdbName: "sample",
featureType: "SfeatureCls",
layerName: "新图层",
dsName: "地图综合",
geoType: "Reg",
srefName: "WGS1984_度",
attStruct: new CAttStruct({
FldName: ["ID", "面积", "周长", "LayerID"],
FldNumber: 4,
FldType: ["FldLong", "FldDouble", "FldDouble", "FldLong"],
}),
success: function (res) {
console.log("res: ", res);
},
});
*/
createGdbLayer(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
gdbSvrName: {
type: 'String'
},
gdbName: {
type: 'String'
},
featureType: {
type: 'String'
},
layerName: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
attStruct: {
type(v) {
return v instanceof CAttStruct
},
process(v) {
return JSON.stringify(v)
},
required: true
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
const opts = defaultValue(options, {})
const srefName = defaultValue(opts.srefName, '')
const dsName = defaultValue(opts.dsName, '')
return `${url}/datasource/${options.gdbSvrName}/${options.gdbName}/${options.featureType}/${options.layerName}/create?f=json&geoType=${options.geoType}&srefName=${srefName}&dsName=${dsName}`
}
)
}
/**
* @function ResourceServer.prototype.queryGdbpAllData
* @description 获取GDB下某类型的所有数据,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.gdbSvrName] 数据源名称,必传
* @param {String} [options.gdbName] gdb名称,必传
* @param {String} [options.clsType] 要素数据类型,必传。数据类型（分为：ds、rcat、ras、sfcls、fcls、acls、ocls、rds、rcs、ncls、sfcls_new）或者为srefID 参考系id
* @param {String} [options.useName] 用户名
* @param {String} [options.password] 密码,igs1.0有效
* @param {Boolean} [options.containAll] 是否返回hdf下所有的对应数据,false表示只返回对应节点下的数据，默认值为true
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryGdbpAllData = resourceServer.queryGdbpAllData({
method: FetchMethod.get,
gdbSvrName: "MapGISLocalPlus",
gdbName: "sample",
clsType: "sfcls",
success: function (res) {
console.log("res: ", res);
},
});
*/
queryGdbpAllData(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
gdbSvrName: {
type: 'String'
},
gdbName: {
type: 'String'
},
clsType: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
useName: {
type: 'String',
alias: 'user'
},
password: {
type: 'String',
alias: 'pwd'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/datasource/${options.gdbSvrName}/${options.gdbName}/${options.clsType}?f=json`
}
)
}
/**
* @function ResourceServer.prototype.queryDsAllData
* @description 获取GDB下某类型的所有数据,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.gdbSvrName] 数据源名称,必传
* @param {String} [options.gdbName] gdb名称,必传
* @param {String} [options.clsType] 要素数据类型,必传。数据类型（分为：ds、rcat、ras、sfcls、fcls、acls、ocls、rds、rcs、ncls、sfcls_new）或者为srefID 参考系id
* @param {String} [options.useName] 用户名
* @param {String} [options.password] 密码,igs1.0有效
* @param {String} [options.dsName] 要素数据集名称,必传
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer, FetchMethod} from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryDsAllData = resourceServer.queryDsAllData({
method: FetchMethod.get,
gdbSvrName: "MapGISLocalPlus",
gdbName: "sample",
clsType: "sfcls",
dsName: "地图综合",
success: function (res) {
console.log("res: ", res);
},
});
*/
queryDsAllData(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
gdbSvrName: {
type: 'String'
},
gdbName: {
type: 'String'
},
clsType: {
type: 'String'
},
dsName: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
useName: {
type: 'String',
alias: 'user'
},
password: {
type: 'String',
alias: 'pwd'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/datasource/${options.gdbSvrName}/${options.gdbName}/${options.dsName}/${options.clsType}?f=json`
}
)
}
/**
* @function ResourceServer.prototype.createLayerInGdbp
* @description 在GDB数据库中创建一个图层,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.gdbSvrName] 数据源名称,必传
* @param {String} [options.gdbName] gdb名称,必传
* @param {String} [options.featureType] 要素类型,必传,要素数据集为FeatureDS、简单要素类为SFeatureCls，对象类为ObjectCls，注记类为AnnotationCls，网络类为GNetCls…..。
* @param {String} [options.layerName] 图层名称,必传
* @param {String} [options.geoType] 几何类型，必传，区图层为Reg、线图层为Lin、点图层为Pnt
* @param {String} [options.srefName] 参考系名称
* @param {String} [options.dsName] 要素名称
* @param {CAttStruct} [options.attStruct] 属性结构
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* const { CAttStruct } = Zondy.Object
* // ES6引入方式
* import { ResourceServer ,FetchMethod ,CAttStruct } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const createLayerInGdbp = resourceServer.createLayerInGdbp({
method: FetchMethod.post,
gdbSvrName: "MapGISLocalPlus",
gdbName: "sample",
featureType: "SfeatureCls",
layerName: "新图层",
dsName: "地图综合",
geoType: "Reg",
srefName: "WGS1984_度",
attStruct: new CAttStruct({
FldName: ["ID", "面积", "周长", "LayerID"],
FldNumber: 4,
FldType: ["FldLong", "FldDouble", "FldDouble", "FldLong"],
}),
success: function (res) {
console.log("res: ", res);
},
});
*/
createLayerInGdbp(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
gdbSvrName: {
type: 'String'
},
gdbName: {
type: 'String'
},
featureType: {
type: 'String'
},
layerName: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
attStruct: {
type(v) {
return v instanceof CAttStruct
},
process(v) {
return JSON.stringify(v)
},
required: true
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
const geoType = defaultValue(options.srefName, '')
if (!geoType) Log.error('geoType传入参数为空')
const srefName = defaultValue(options.srefName, '')
const dsName = defaultValue(options.dsName, '')
return `${url}/datasource/${options.gdbSvrName}/${options.gdbName}/${options.featureType}/${options.layerName}/create?f=json&geoType=${geoType}&srefName=${srefName}&dsName=${dsName}`
}
)
}
/**
* @function ResourceServer.prototype.deleteLayerInGdbp
* @description 删除GDB数据库中的一个图层,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.gdbSvrName] 数据源名称,必传
* @param {String} [options.gdbName] gdb名称,必传
* @param {String} [options.featureType] 要素类型,必传,要素数据集为FeatureDS、简单要素类为SFeatureCls，对象类为ObjectCls，注记类为AnnotationCls，网络类为GNetCls…..。
* @param {String} [options.layerName] 图层名称,必传
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const deleteLayerInGdbp = resourceServer.deleteLayerInGdbp({
method: FetchMethod.get,
gdbSvrName: "MapGISLocalPlus",
gdbName: "sample",
featureType: "SfeatureCls",
layerName: "等值线",
success: function (res) {
console.log("res: ", res);
},
});
*/
deleteLayerInGdbp(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
gdbSvrName: {
type: 'String'
},
gdbName: {
type: 'String'
},
featureType: {
type: 'String'
},
layerName: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/datasource/${options.gdbSvrName}/${options.gdbName}/${options.featureType}/${options.layerName}/delete?f=json`
}
)
}
/**
* @function ResourceServer.prototype.updateLayerInGdbp
* @description 更新GDB数据库中的一个图层,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.gdbSvrName] 数据源名称,必传
* @param {String} [options.gdbName] gdb名称,必传
* @param {String} [options.featureType] 要素类型,必传,要素类型:SFeatureCls或AnnotationCls
* @param {String} [options.layerName] 图层名称,必传
* @param {Object} [options.updateObject] 更新参数，必传,例如{"SrsName":"WGS1984_度","LayerName":"图层名"}
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const updateLayerInGdbp = resourceServer.updateLayerInGdbp({
method: FetchMethod.get,
gdbSvrName: "MapGISLocalPlus",
gdbName: "sample",
featureType: "SfeatureCls",
layerName: "等值线",
updateObject: {
SrsName: "WGS1984_度",
LayerName: "图层名",
},
success: function (res) {
console.log("res: ", res);
},
});
*/
updateLayerInGdbp(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
gdbSvrName: {
type: 'String'
},
gdbName: {
type: 'String'
},
featureType: {
type: 'String'
},
layerName: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
updateObject: {
type: 'Object',
process(v) {
return JSON.stringify(v)
}
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/datasource/${options.gdbSvrName}/${options.gdbName}/${
options.featureType
}/${options.layerName}?f=json&userName=${defaultValue(
options.userName,
''
)}`
}
)
}
/**
* @function ResourceServer.prototype.editMapLayerSystemLib
* @description 修改文档下图层的系统库,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.docName] 地图文档名称，必传
* @param {String} [options.mapIndex] 地图索引，必传
* @param {String} [options.systemLib] 系统库id或名称
* @param {String} [options.layerIndexs] 图层索引列表(多个用英文逗号分隔)
* @param {String} [options.guid] 用户会话id
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const editMapLayerSystemLib = resourceServer.editMapLayerSystemLib({
method: FetchMethod.get,
docName: "sz",
mapIndex: "新地图1",
systemLib: "DefaultSystemLib",
layerIndexs: "0",
success: function (res) {
console.log("res: ", res);
},
});
*/
editMapLayerSystemLib(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
docName: {
type: 'String'
},
mapIndex: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
systemLib: {
type: 'String'
},
layerIndexs: {
type: 'String'
},
guid: {
type: 'String'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/doc/${options.docName}/${options.mapIndex}/setSystemLibrary?f=json`
}
)
}
/**
* @function ResourceServer.prototype.queryMapDocList
* @description 获取发布的文档列表,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.version] 版本信息，默认为'1.0',可缺省（缺省时只返回直接发布的文档列表，如果v=2列表中将会包含目录形式发布的文档
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryMapDocList = resourceServer.queryMapDocList({
method: FetchMethod.get,
success: function (res) {
console.log("res: ", res);
},
});
*/
queryMapDocList(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
version: {
type: 'String',
alias: 'v'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/docs?f=json`
}
)
}
/**
* @function ResourceServer.prototype.addMapLayer
* @description 添加图层到文档中指定地图,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.docName] 地图文档名称，必传
* @param {String} [options.mapIndex] 地图索引，必传
* @param {Object} [options.updateObject] 更新参数，必传
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const addMapLayer = resourceServer.addMapLayer({
method: FetchMethod.post,
docName: "sz",
mapIndex: "新地图1",
updateObject:{},
success: function (res) {
console.log("res: ", res);
},
});
*/
addMapLayer(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
docName: {
type: 'String'
},
mapIndex: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
updateObject: {
type: 'Object',
process(v) {
return JSON.stringify(v)
}
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/docs/${options.docName}/${options.mapIndex}/layers/add?f=json`
}
)
}
/**
* @function ResourceServer.prototype.removeMapLayer
* @description 删除文档中指定地图中指定图层,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.docName] 地图文档名称，必传
* @param {String} [options.mapIndex] 地图索引，必传
* @param {String} [options.layerIndexs] 图层索引列表(多个用英文逗号分隔)
* @param {String} [options.guid] 用户会话id
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const removeMapLayer = resourceServer.removeMapLayer({
method: FetchMethod.get,
docName: "sz",
mapIndex: "新地图1",
layerIndexs: "0",
success: function (res) {
console.log("res: ", res);
},
});
*/
removeMapLayer(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
docName: {
type: 'String'
},
mapIndex: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
layerIndexs: {
type: 'String',
alias: 'layerIDs'
},
guid: {
type: 'String'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/docs/${options.docName}/${options.mapIndex}/layers/delete?f=json`
}
)
}
/**
* @function ResourceServer.prototype.editMapLayerIndex
* @description 修改文档中指定地图下图层的索引,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.docName] 地图文档名称，必传
* @param {String} [options.mapIndex] 地图索引，必传
* @param {String} [options.guid] 用户会话id
* @param {String} [options.updateObject] 更新参数，必传
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const editMapLayerIndex = resourceServer.editMapLayerIndex({
method: FetchMethod.post,
docName: "sz",
mapIndex: "新地图1",
layerIndexs: "0",
updateObject:{},
success: function (res) {
console.log("res: ", res);
},
});
*/
editMapLayerIndex(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
docName: {
type: 'String'
},
mapIndex: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
updateObject: {
type: 'Object',
process(v) {
return JSON.stringify(v)
}
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/docs/${options.docName}/${options.mapIndex}/layers/index?f=json&guid=${options.guid}`
}
)
}
/**
* @function ResourceServer.prototype.queryMapInfo
* @description 获取文档详细信息,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.docName] 文档名称,必传
* @param {Boolean} [options.tree] 是否按树形显示，缺省false
* @param {Object} [options.include] 返回中要求包含的属性 {"IncludeDetails":true,"IncludeSubs":true}
* @param {String} [options.returnFullStyle] 是否返回全部信息的标志位e
* @param {String} [options.guid] 用户会话id，可以缺省
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryMapInfo = resourceServer.queryMapInfo({
method: FetchMethod.get,
docName: "sz",
success: function (res) {
console.log("res: ", res);
},
});
*/
queryMapInfo(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
docName: { type: 'String' }
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
tree: {
type: 'Boolean'
},
include: {
type: 'Object',
process(v) {
return JSON.stringify(v)
}
},
returnFullStyle: {
type: 'String'
},
guid: {
type: 'String'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/docs/${options.docName}?f=json`
}
)
}
/**
* @function ResourceServer.prototype.queryMapInfoByIndex
* @description 获取指定地图的详细信息,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.docName] 地图文档名称，必传
* @param {String} [options.mapIndex] 地图索引，必传
* @param {Object} [options.include] 返回中要求包含的属性 {"IncludeDetails":true,"IncludeSubs":true}
* @param {String} [options.returnFullStyle] 是否返回全部信息的标志位e
* @param {String} [options.guid] 用户会话id，可以缺省
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryMapInfoByIndex = resourceServer.queryMapInfoByIndex({
method: FetchMethod.get,
docName: "sz",
mapIndex: "0",
success: function (res) {
console.log("res: ", res);
},
});
*/
queryMapInfoByIndex(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
docName: {
type: 'String'
},
mapIndex: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
include: {
type: 'Object',
process(v) {
return JSON.stringify(v)
}
},
returnFullStyle: {
type: 'String'
},
guid: {
type: 'String'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/docs/${options.docName}/${options.mapIndex}?f=json`
}
)
}
/**
* @function ResourceServer.prototype.queryMapLayerInfo
* @description 获取指定地图下所有图层的信息,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.docName] 地图文档名称，必传
* @param {String} [options.mapIndex] 地图索引，必传
* @param {String} [options.guid] 用户会话id，可以缺省
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryMapLayerInfo = resourceServer.queryMapLayerInfo({
method: FetchMethod.get,
docName: "sz",
mapIndex: "0",
success: function (res) {
console.log("res: ", res);
},
});
*/
queryMapLayerInfo(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
docName: {
type: 'String'
},
mapIndex: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
guid: {
type: 'String'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/docs/${options.docName}/${options.mapIndex}/layers?f=json`
}
)
}
/**
* @function ResourceServer.prototype.queryMapLayerInfoByIndex
* @description 获取指定地图下指定图层的信息,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.docName] 地图文档名称，必传
* @param {String} [options.mapIndex] 地图索引，必传
* @param {String} [options.layerId] 图层索引，必传
* @param {String} [options.guid] 用户会话id，可以缺省
* @param {String} [options.returnFullStyle] 是否返回全部信息的标志位e
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryMapLayerInfoByIndex = resourceServer.queryMapLayerInfoByIndex({
method: FetchMethod.get,
docName: "sz",
mapIndex: "0",
layerIndex: "0",
success: function (res) {
console.log("res: ", res);
},
});
*/
queryMapLayerInfoByIndex(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
docName: {
type: 'String'
},
mapIndex: {
type: 'String'
},
layerIndex: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
returnFullStyle: {
type: 'String'
},
guid: {
type: 'String'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/docs/${options.docName}/${options.mapIndex}/${options.layerIndex}?f=json`
}
)
}
/**
* @function ResourceServer.prototype.queryDataSourceFeatureClassList
* @description 获取数据集下的要素类列表,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.gdbServerName] GDB数据源名称，必传
* @param {String} [options.gdbName] GDB数据名称,必传
* @param {String} [options.dsName] 要素数据集名称,必传
* @param {String} [options.useName] 用户名
* @param {String} [options.password] 密码,igs1.0有效
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryDataSourceFeatureClassList =
resourceServer.queryDataSourceFeatureClassList({
method: FetchMethod.get,
gdbServerName: "MapGISLocalPlus",
gdbName: "test",
dsName: "test",
success: function (res) {
console.log("res: ", res);
},
});
*/
queryDataSourceFeatureClassList(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
gdbServerName: {
type: 'String'
},
gdbName: {
type: 'String'
},
dsName: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
useName: {
type: 'String',
alias: 'user'
},
password: {
type: 'String',
alias: 'pwd'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/featurelist/${options.gdbServerName}/${options.gdbName}/${options.dsName}?f=json`
}
)
}
/**
* @function ResourceServer.prototype.operaGdbp
* @description GDB操作接口,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.operType] 操作类型,必传（分为：attach、create、delete、detach）
* @param {String} [options.gdbName] GDB数据名称,必传
* @param {String} [options.gdbServerName] GDB数据源名称
* @param {String} [options.useName] 用户名
* @param {String} [options.password] 密码,igs1.0有效
* @param {String} [options.path] hdf路径或67文件夹路径
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const operaGdbp = resourceServer.operaGdbp({
method: FetchMethod.get,
gdbServerName: "MapGISLocalPlus",
gdbName: "test",
dsName: "test",
operType: "detach",
success: function (res) {
console.log("res: ", res);
},
});
*/
operaGdbp(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
operType: {
type: 'String'
},
gdbName: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
gdbServerName: {
type: 'String',
alias: 'gdbSvrName'
},
gdbUserName: {
type: 'String',
alias: 'gdbUserName'
},
password: {
type: 'String',
alias: 'gdbPwd'
},
path: {
type: 'String'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/gdb/${options.operType}/${options.gdbName}?f=json`
}
)
}
/**
* @function ResourceServer.prototype.editLayerSystemLib
* @description 修改图层的系统库,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.systemLib] 系统库id或名称
* @param {String} [options.gdbps] 图层列表，多个用英文逗号隔开
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const editLayerSystemLib = resourceServer.editLayerSystemLib({
method: FetchMethod.get,
systemLib: "0",
gdbps: "gdbp://MapGISLocalPlus/test/ds/test/sfcls/test_0426_feature1",
success: function (res) {
console.log("res: ", res);
},
});
*/
editLayerSystemLib(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
systemLib: {
type: 'String'
},
gdbps: {
type: 'String'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/layer/setSystemLibrary?f=json`
}
)
}
/**
* @function ResourceServer.prototype.queryGDBPInfo
* @description 获取GDB下某个图层的详细信息,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.gdbpUrl] gdbp地址
* @param {String} [options.proj] 对shp图层支持投影，获取到投影后的范围，传参考系名称
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryGDBPInfo = resourceServer.queryGDBPInfo({
method: FetchMethod.get,
gdbpUrl:
"gdbp://MapGISLocalPlus/test/sfcls/metro.json_Lin,gdbp://MapGISLocalPlus/test/sfcls/中国地级县x",
proj: "WGS1984_度",
success: function (res) {
console.log("res: ", res);
},
});
*/
queryGDBPInfo(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
gdbpUrl: {
type: 'String'
},
proj: {
type: 'String'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/layerinfo?f=json`
}
)
}
/**
* @function ResourceServer.prototype.queryLegendInfo
* @description 获取地图文档服务的图例信息,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.docName] 服务名
* @param {String} [options.layerIndex] 生成图例的图层索引号(多个用英文逗号分隔)
* @param {String} [options.size] 格式：width,height
* @param {String} [options.guid] 用户会话id
* @param {String} [options.maxCount] 返回图例项最大数量
* @param {String} [options.page] 页码
* @param {String} [options.pageSize] 分页大小
* @param {String} [options.where] 过滤条件
* @param {String} [options.range] 范围
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer ,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryLegendInfo = resourceServer.queryLegendInfo({
method: FetchMethod.get,
docName: "地图文档_1",
success: function (res) {
console.log("res: ", res);
},
});
*/
queryLegendInfo(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
docName: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
layerIndex: {
type: 'String'
},
size: {
type: 'String'
},
guid: {
type: 'String'
},
maxCount: {
type: 'String'
},
page: {
type: 'String'
},
pageSize: {
type: 'String'
},
where: {
type: 'String'
},
range: {
type: 'String'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/legend/${options.docName}?f=json`
}
)
}
/**
* @function ResourceServer.prototype.querySymbol
* @description 修改图层的系统库,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.systemLib] 系统库guid或者名称
* @param {String} [options.type] 类型SymbolGeomType(GeomEnt3D,GeomLin,GeomPnt,GeomReg,GeomSur3D,Unknown)
* @param {String} [options.systemNo] 符号序号
* @param {String} [options.systemSubNo] 符号子序号
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer, FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const querySymbol = resourceServer.querySymbol({
method: FetchMethod.get,
systemLib: "DefaultSystemLib",
type: "GeomPnt",
systemNo: "0",
systemSubNo: "0",
success: function (res) {
console.log("res: ", res);
},
});
*/
querySymbol(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
systemLib: {
type: 'String'
},
type: {
type: 'String'
},
systemNo: {
type: 'String'
},
systemSubNo: {
type: 'String'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/symbol?f=json`
}
)
}
/**
* @function ResourceServer.prototype.querySymbolList
* @description 修改图层的系统库,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.systemLib] 系统库guid或者名称
* @param {String} [options.page] 页码(默认0)
* @param {String} [options.size] 分页量(默认20)
* @param {String} [options.type] 类型SymbolGeomType(GeomEnt3D,GeomLin,GeomPnt,GeomReg,GeomSur3D,Unknown)
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* // ES6引入方式
* import { ResourceServer } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
*/
querySymbolList(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
systemLib: {
type: 'String'
},
type: {
type: 'String'
},
page: {
type: 'String'
},
size: {
type: 'String'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/symbols?f=json`
}
)
}
/**
* @function ResourceServer.prototype.queryTileList
* @description 获取发布的瓦片列表,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.version] 版本信息，默认为'1.0',可缺省（缺省时只返回直接发布的文档列表，如果v=2列表中将会包含目录形式发布的文档
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryTileList = resourceServer.queryTileList({
method: FetchMethod.get,
success: function (res) {
console.log("res: ", res);
},
});
*/
queryTileList(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
version: {
type: 'String',
alias: 'v'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/tiles?f=json`
}
)
}
/**
* @function ResourceServer.prototype.queryTileInfo
* @description 获取指定瓦片详细信息,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.version] 版本信息，默认为'1.0',可缺省（缺省时只返回直接发布的文档列表，如果v=2列表中将会包含目录形式发布的文档
* @param {String} [options.name] 瓦片名称，必传
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryTileInfo = resourceServer.queryTileInfo({
method: FetchMethod.get,
name: "Tile:WorldMKTTile",
success: function (res) {
console.log("res: ", res);
},
});
*/
queryTileInfo(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
name: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
version: {
type: 'String',
alias: 'v'
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/tiles/${options.name}?f=json`
}
)
}
/**
* @function ResourceServer.prototype.queryVectorTileFontList
* @description 矢量瓦片-获取字体列表,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryVectorTileFontList = resourceServer.queryVectorTileFontList({
method: FetchMethod.get,
success: function (res) {
console.log("res: ", res);
},
});
*/
queryVectorTileFontList(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/vtiles/fonts`
}
)
}
/**
* @function ResourceServer.prototype.queryVectorTileFont
* @description 矢量瓦片-获取字体,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.fontstack] 字体名称,必传
* @param {String} [options.range] 字体范围，必传
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryVectorTileFont = resourceServer.queryVectorTileFont({
method: FetchMethod.get,
fontstack: "黑体",
range: "0-255.pbf",
success: function (res) {
console.log("res: ", res);
},
});
*/
queryVectorTileFont(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
fontstack: {
type: 'String'
},
range: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/vtiles/fonts/${options.fontstack}/${options.range}?f=json`
}
)
}
/**
* @function ResourceServer.prototype.queryVectorTileStyleList
* @description 矢量瓦片-获取所有上传样式列表,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryVectorTileStyleList = resourceServer.queryVectorTileStyleList({
method: FetchMethod.get,
success: function (res) {
console.log("res: ", res);
},
});
*/
queryVectorTileStyleList(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/vtiles/styles?f=json`
}
)
}
/**
* @function ResourceServer.prototype.queryVectorTileStyle
* @description 矢量瓦片-获取上传样式,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.fileName] 样式文件名
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryVectorTileStyle = resourceServer.queryVectorTileStyle({
method: FetchMethod.get,
fileName: "统一专题图",
success: function (res) {
console.log("res: ", res);
},
});
*/
queryVectorTileStyle(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
fileName: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/vtiles/styles/${options.fileName}.json`
}
)
}
/**
* @function ResourceServer.prototype.queryVectorTileServiceFont
* @description 矢量瓦片-获取指定服务的字体,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.serviceName] 矢量瓦片服务名,必传
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryVectorTileServiceFont = resourceServer.queryVectorTileServiceFont({
method: FetchMethod.get,
serviceName: "统一专题图",
success: function (res) {
console.log("res: ", res);
},
});
*/
queryVectorTileServiceFont(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
serviceName: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/vtiles/${options.serviceName}/fonts`
}
)
}
/**
* @function ResourceServer.prototype.queryVectorTileServiceSprite
* @description 矢量瓦片-获取服务的sprite图,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.serviceName] 矢量瓦片服务名,必传
* @param {String} [options.format] 格式，支持后缀为.json或.png,必传
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryVectorTileServiceSprite =
resourceServer.queryVectorTileServiceSprite({
method: FetchMethod.get,
serviceName: "统一专题图",
format: ".json",
success: function (res) {
console.log("res: ", res);
},
});
*/
queryVectorTileServiceSprite(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
format: {
type: 'String'
},
serviceName: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/vtiles/${options.serviceName}/sprite${options.format}`
}
)
}
/**
* @function ResourceServer.prototype.updateVectorTileServiceStyle
* @description 更新指定服务的样式,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.serviceName] 矢量瓦片服务名,必传
* @param {Object} [options.updateObject] 更新参数，必传
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const updateVectorTileServiceStyle =
resourceServer.updateVectorTileServiceStyle({
method: FetchMethod.post,
serviceName: "统一专题图",
updateObject: {},
success: function (res) {
console.log("res: ", res);
},
});
*/
updateVectorTileServiceStyle(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
serviceName: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {
updateObject: {
type: 'Object',
process(v) {
return JSON.stringify(v)
}
}
}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/vtiles/${options.serviceName}/styles`
}
)
}
/**
* @function ResourceServer.prototype.queryVectorTileServiceStyle
* @description 矢量瓦片-获取指定服务的样式,仅支持igs1.0
* @param options 查询参数
* @param {String} [options.headers ] 请求头参数
* @param {Function} [options.success ] 查询成功回调函数，若使用Promise方式则不必填写
* @param {Function} [options.failure ] 查询失败回调函数，若使用Promise方式则不必填写
* @param {String} [options.serviceName] 矢量瓦片服务名,必传
* @param {String} [options.tpl] 自定义地图模板的索引号,必传
* @return {Promise<Object>}
* @example <caption><h5>igs1.0</h5></caption>
* // ES5引入方式
* const { ResourceServer } = Zondy.Service
* const { FetchMethod } = Zondy.Enum
* // ES6引入方式
* import { ResourceServer,FetchMethod } from "@mapgis/webclient-common"
const resourceServer = new ResourceServer({
//服务地址
url: "http://localhost:8089/igs/rest/mrcs",
});
const queryVectorTileServiceStyle = resourceServer.queryVectorTileServiceStyle({
method: FetchMethod.get,
serviceName: "统一专题图",
tpl: "0",
success: function (res) {
console.log("res: ", res);
},
});
*/
queryVectorTileServiceStyle(options) {
// 设置PATH PARAMETERS校验
const checkPathOpts = {
serviceName: {
type: 'String'
},
tpl: {
type: 'String'
}
}
// 设置QUERY PARAMETERS校验
const checkQueryOpts = {}
// 调用基类的查询信息方法
return this._queryByParameters(
options,
checkPathOpts,
checkQueryOpts,
// 拼装返回基地址
function (url) {
return `${url}/vtiles/${options.tpl}/${options.serviceName}`
}
)
}
}
Zondy.Service.ResourceServer = ResourceServer
export default ResourceServer
