/*+++++++++++++++地图管理类 所有与地图相关的内容均位于此++++++++++++++++++*/

/* 地图组件 */
var jtMapKit;
/* 图层类型 */

var LayerType = {
	server: 'server', //服务图层
	base: 'base', //基础图层
}

/* 定位比例尺 */
var locationScale = 6000;

/* 地图默认范围 */
var initMapExtent = {
	xmin: 118.032810723,
	ymin: 34.901398239,
	xmax: 118.51750693,
	ymax: 35.521009885,
}

/* 案件图层的查询URL及数据过滤条件 */
var caseServerUrl = undefined;
var caseQueryFilter = undefined;
let mapQueryUrl = undefined;
let rasterLayerTitle = "baseYxtMapLayer";

/* 图层配置 */
var layerConfig = undefined;
/* 当前地图用户 */
let mapByUser = undefined;

/**
 * 加载地图
 * @param {string} MainDivID 地图容器Id
 * @param {JSON} user 初始化位置
 */
function MapInit(MainDivID, user) {
	mapByUser = user;
	// muiShowWaitLoading("地图初始化...");
	getNetImageRootURL(function(rootUrl) {
		/* 初始化地图组件 */
		jtMapKit = new JTMapKit({
			selector: MainDivID,
			serverUrl: rootUrl + "resource/image/",
			baseMapUrl: user.baseMapUrl,
		});
		//挂接主地图的加载事件
		jtMapKit.onViewReady = function() {
			/* 加载影像地图 */
			LoadRasterServer(function() {
				/* 初始化范围 */
				jtMapKit.zoomToExtent(initMapExtent);
				/* 加载矢量地图 */
				LoadVectorServer(function() {
					muiToast("地图初始化！");
					jtMapKit.setUIScaleBarVisible(true);
					jtMapKit.isLoad = true;
				});
			});
		}
		/* 绑定多图层查询开始事件 */
		jtMapKit.onQueryLayersTaskBegin = function() {
			plus.nativeUI.showWaiting('查询中...');
		}
	});
}

/**
 * 加载栅格服务
 * @param {functions} callSuccess 加载成功回调
 */
function LoadRasterServer(callSuccess) {
	// console.log(JSON.stringify(layerConfig[0]));
	if (layerConfig) {
		let rasterLayer = undefined; /* 加载的影像服务 */
		/* 寻找当前需要显示的影像图层 */
		for (let layer of layerConfig[0].layerList) {
			if (layer.layerType === 'base' && layer.layerIsVisible === '1') {
				rasterLayer = layer;
				break;
			}
		}
		/* 加载影像图 */
		jtMapKit.addTileLayer({
			url: rasterLayer.layerURL,
			title: rasterLayerTitle,
		}, function() {
			if (callSuccess) callSuccess();
		}, function(err) {
			console.log(err);
		});
	}
}

/* 此处方法改造 主要是为了考虑图层加载成功或失败的问题 */

/**
 * 添加矢量图层
 * @param {function} callComplete 完成回调
 */
function LoadVectorServer(callComplete) {
	if (layerConfig) {
		let vectorLayers = [];
		for (let layer of layerConfig[0].layerList) {
			if (layer.layerType === 'server') {
				// vectorLayers.unshift(layer);
				vectorLayers.push(layer);
			}
			if (layer.layerType === 'server' && layer.isCase === '1') {
				caseServerUrl = layer.layerURL + "/" + layer.lyrIdx;
				caseQueryFilter = layer.layerIsFilter;
			}
		}
		/* 设置地图查询地址 */
		mapQueryUrl = layerConfig[0].layerList[0].layerURL;
		appendVectorLayers(0, vectorLayers, function() {
			if (callComplete) callComplete();
		})
	}
}

/**
 * 添加图层
 * @param {int} index 当前加载的图层索引
 * @param {array} layers 加载的图层数组
 * @param {function} callComplete 完成回调
 */
function appendVectorLayers(index, layers, callComplete) {
	if (index === layers.length) {
		if (callComplete) callComplete();
	} else {
		let layer = layers[index];
		jtMapKit.addDynamicLayer({
			url: layer.layerURL,
			title: layer.eName,
			subids: [parseInt(layer.lyrIdx)],
			visible: layer.layerIsVisible === '1' ? true : false,
			labelVisible: layer.labelIsVisible === "1" ? true : false,
			filter: layer.layerIsFilter,
		}, function() {
			appendVectorLayers(index + 1, layers, callComplete);
		}, function(err) {
			appendVectorLayers(index + 1, layers, callComplete);
		});
	}
}

/**
 * 创建草图绘制回调工具栏
 * @param {string} btnTitle 按钮标题名称
 * @param {string} functionName 调用函数名称
 * @param {JSON} options 调用参数
 */
function createToolsBySketch(btnTitle, functionName, options) {
	var btnHtml = "";
	btnHtml +=
		"<button class='mui-btn mui-btn-primary mui-icon app-icon app-icon-map-redo jt-btn-normal'";
	btnHtml += " onclick=\"sketchUndo()\">撤销</button>";
	btnHtml +=
		"<button class='mui-btn mui-btn-primary mui-icon app-icon app-icon-map-undo mui-right jt-btn-normal'";
	btnHtml += " onclick=\"sketchRedo()\">恢复</button>";
	if (functionName) {
		btnHtml +=
			"<button class='mui-btn mui-btn-primary mui-icon app-icon app-icon-map-areaquery jt-btn-normal wc-btn-query wc-btn-map-query'";
		btnHtml += " onclick=\"" + functionName + "(" + JSON.stringify(options).replace(/\"/g, "'") + ")\">" +
			btnTitle + "</button>";
	} else {
		btnHtml += "<button class='mui-btn mui-btn-primary jt-btn-normal wc-btn-query wc-btn-map-query'>" +
			options
			.text + "</button>";
	}
	showNormalResult(btnHtml);
}

/**
 * 草图工具 恢复
 */
function sketchRedo() {
	jtMapKit.sketchRedo();
}

/**
 * 草图工具 回退
 */
function sketchUndo() {
	jtMapKit.sketchUndo();
}


/**
 * 定位地图位置
 * @param {string} longitude 定位经度
 * @param {string} latitude 定位纬度
 */
function mapLocation(longitude, latitude) {
	var iLongitude = parseFloat(longitude);
	var iLatitude = parseFloat(latitude);
	jtMapKit.setCenter([iLongitude, iLatitude]);
	jtMapKit.setScale(locationScale);
}

/**
 * 切换底图为影像底图
 */
function EventClick_ShowRaster() {
	jtMapKit.loadBaseRasterMap(function() {

	});
}
/**
 * 切换底图为标准底图
 */
function EventClick_ShowVector() {
	jtMapKit.loadBaseVectorMap(function() {

	});
}

/**
 * 测量长度
 */
function EventClick_MeasureLength() {
	hideNormalResult();
	muiToast("地图单击测量长度!");
	jtMapKit.eMeasureLength(function(len) {
		createToolsBySketch('', undefined, {
			text: len,
		})
	});
}

/**
 * 测量面积
 */
function EventClick_MeasureArea() {
	hideNormalResult();
	muiToast("地图单击测量面积!");
	jtMapKit.eMeasureArea(function(area) {
		createToolsBySketch('', undefined, {
			text: area,
		})
	});
}

/* GPS定位是否开启 */
let gpsIsOn = false;
/**
 * 定位位置
 */
function EventClick_Location() {
	/* 开启或关闭方向监听 */
	if (gpsIsOn) {
		gpsIsOn = false;
		plusOrientationListenerOff(function() {
			plusGPSListenerOff(function() {
				jtMapKit.gpsRemoveFromMap();
				muiToast("定位关闭！");
				$("#spanLocationLabel").text("开启定位");
				jtMapKit.gpsSetAngle(0);
			});
		});
	} else {
		gpsIsOn = true;
		plusGPSListenerOn(function(latitude, longitude) {
			jtMapKit.gpsAppendToMap({
				longitude: longitude,
				latitude: latitude,
			});
		}, function(err) {
			muiAlert(err);
		});
		plusOrientationListenerOn(function(angle) {
			// console.log("方位角 = " + angle);
			jtMapKit.gpsSetAngle(angle);
		});
		muiToast("定位开启！");
		$("#spanLocationLabel").text("关闭定位");
	}
}

/**
 * 地图初始化
 */
function EventClick_MapInit() {
	jtMapKit.zoomToExtent(initMapExtent);
	muiToast("地图范围已初始化！");
}

/**
 * 查询地图上点击位置的坐标
 */
function EventClick_QueryCoord() {
	hideNormalResult();
	muiToast("地图单击,获取地理坐标!");
	jtMapKit.eMeasureCoordinate(function(res) {
		let msg = "经度:" + res.x.toFixed(6) + " 纬度:" + res.y.toFixed(6);
		showNormalResult(msg);
	});
}

/**
 * 输入坐标进行查询定位
 */
function EventClick_CoordQuery() {
	mui('#popoverCoordLocation').popover('toggle');
}

/**
 * 输入定位按钮
 */
function EventClick_InputLocation() {
	var longitude = $("#iLongitude").val();
	var latitude = $("#iLatitude").val();
	if (longitude == '') {
		muiAlert("请输入经度", "提示", function() {
			$("#iLongitude").focus();
		});
		return;
	}
	if (latitude == '') {
		muiAlert("请输入纬度", "提示", function() {
			$("#iLatitude").focus();
		});
		return;
	}
	var fLongitude = parseFloat(longitude);
	var fLatitude = parseFloat(latitude);
	if (fLongitude < 100 || fLongitude > 150) {
		muiAlert("经度数值必须在100～150之间", "提示", function() {
			$("#iLongitude").focus();
		});
		return;
	}
	if (fLatitude < 20 || fLatitude > 50) {
		muiAlert("纬度数值必须在20～50之间", "提示", function() {
			$("#iLatitude").focus();
		});
		return;
	}
	jtMapKit.AddPointToMap(fLongitude, fLatitude);
}

/**
 * 清除绘制内容 恢复地图初始状态
 */
function EventClick_Clean() {
	jtMapKit.DeleteTempDraw(function() {
		hideNormalResult();
	});
}

/* 控制的图层数组 */
var controlLayers = [];
var controlCategorys = [];

/**
 * 图层控制事件
 * @param {Object} btnObj 按钮
 */
function EventClick_Layer(btnObj) {
	/* 初始化图层控制数组 */
	controlLayers = [];
	controlCategorys = [];
	/* 组装图层控制 */
	if (layerConfig) {
		/* 获取分组 */
		for (var i in layerConfig[0].categoryList) {
			var category = layerConfig[0].categoryList[i];
			controlCategorys.push({
				name: category.cyName,
				childs: "",
			});
		}
		/* 获取具体图层 */
		for (var i in layerConfig[0].layerList) {
			/* 添加到控制数组 */
			var layer = layerConfig[0].layerList[i];
			controlLayers.push(layer);
			var parLayer = {
				layerType: layer.layerType,
				eName: layer.eName,
			};
			var mmm = "";
			if (layer.layerType == LayerType.server) {
				mmm += "<div class='mui-input-row jt-layer-control-input-row'>";
				mmm += "<label><span class='app-icon app-icon-map-layer-vector'></span>" + layer
					.cName +
					"</label>";
				if (layer.layerIsVisible == "1") {
					mmm += "<input name='checkbox' type='checkbox' checked";
				} else {
					mmm += "<input name='checkbox' type='checkbox'";
				}
				mmm += " onclick=\"LayerControl(this,'" + layer.eName + "','" + layer.layerType + "')\">";
				/* 加入控制图层标注 */
				mmm += "<span class='jt-label'>标注</span>";
				if (layer.labelIsVisible == "1") {
					mmm += "<input name='checkbox' type='checkbox' checked";
				} else {
					mmm += "<input name='checkbox' type='checkbox'";
				}
				mmm += " onclick=\"LayerLabelControl(this,'" + layer.eName + "')\">";
			} else if (layer.layerType == LayerType.base) {
				mmm += "<div class='mui-input-row jt-layer-control-input-row'>";
				mmm += "<label><span class='app-icon app-icon-map-layer-raster'></span>" + layer
					.cName +
					"</label>"
				if (layer.layerIsVisible == "1") {
					mmm += "<input name='chkbaselayer' type='checkbox' checked";
				} else {
					mmm += "<input name='chkbaselayer' type='checkbox'";
				}
				mmm += " onclick=\"LayerControl(this,'" + layer.eName + "','" + layer.layerType + "')\">";
			}
			mmm += "</div>";
			/* 加入分组 */
			for (var cIdx = 0; cIdx < controlCategorys.length; cIdx++) {
				if (layer.pName == controlCategorys[cIdx].name) {
					controlCategorys[cIdx].childs += mmm;
					continue;
				}
			}
		}
		/* 组装并展示 */
		var contentHtml = "";
		for (var i in controlCategorys) {
			var content = controlCategorys[i];
			if (content.childs != "") {
				contentHtml += "<h5 class='jt-layer-control-label'>" + content.name + "</h5>";
				contentHtml += "<form class='mui-input-group jt-layer-control-content'>" + content
					.childs + "</form>";
			}
		}
		showRightResultWindow("图层管理", contentHtml);
	}
}

/**
 * 存储图层设置
 * @param {string} layerName 图层名称
 * @param {boolean} isVisible 显示/隐藏
 */
function SaveLayerControl(layerName, isVisible) {
	if (layerConfig) {
		for (let layer of layerConfig[0].layerList) {
			if (layer.eName.toLocaleLowerCase() === layerName.toLocaleLowerCase()) {
				layer.layerIsVisible = isVisible === true ? "1" : "0";
				break;
			}
		}
		/* 更新图层控制信息本地化 */
		saveStorage({
			key: layerKey,
			value: JSON.stringify(layerConfig),
		})
	}
}

/**
 * 控制图层显示或隐藏
 * @param {Object} obj checkbox控件
 * @param {string} layerName 图层名称
 * @param {string} layerType 图层类型 
 */
function LayerControl(obj, layerName, layerType) {
	/* 定义控制图层 */
	let controlLayer = undefined;
	if (layerConfig) {
		/* 如果设置的影像基础图层 则将全部显示的图层默认设置为关闭 */
		if (layerType === LayerType.base) {
			/* 设置全部图层默认关闭 */
			for (let layer of layerConfig[0].layerList) {
				if (layer.layerType === LayerType.base) {
					layer.layerIsVisible = "0";
				}
			}
			/* 设置控件样式 */
			if (obj.checked) {
				/* 设置其他控件为关闭状态 */
				let chkObjs = document.getElementsByName('chkbaselayer');
				for (let chkObj of chkObjs) {
					chkObj.checked = false;
				}
				/* 设置当前控件为选择状态 */
				obj.checked = true;
			}
		}
		/* 先找到需要控制的图层 */
		for (let layer of layerConfig[0].layerList) {
			if (layer.eName === layerName) {
				layer.layerIsVisible = obj.checked ? "1" : "0";
				controlLayer = layer;
			}
		}
		/* 更新图层控制信息本地化 */
		saveStorage({
			key: layerKey,
			value: JSON.stringify(layerConfig),
		})
	}
	/* 判断控制的图层是 要素图层/影像图层 */
	if (controlLayer && controlLayer.layerType == LayerType.server) {
		jtMapKit.setVisibleByName(controlLayer.eName, controlLayer.layerIsVisible == "1" ? true : false);
	} else if (controlLayer && controlLayer.layerType === LayerType.base) {
		jtMapKit.removeLayer(rasterLayerTitle, function() {
			if (obj.checked) {
				jtMapKit.addTileLayer({
					url: controlLayer.layerURL,
					title: rasterLayerTitle,
				});
			}
		}, function(err) {
			/* 说明要删除的图层不存在 */
			if (obj.checked) {
				jtMapKit.addTileLayer({
					url: controlLayer.layerURL,
					title: rasterLayerTitle,
				});
			}
		});
	}
}

/**
 * 图层标注控制
 * @param {Object} obj CheckBox控件
 * @param {string} layerName 图层名称
 */
function LayerLabelControl(obj, layerName) {
	/* 获取当前控制的图层 */
	if (layerConfig) {
		let isVisible = undefined;
		for (let layer of layerConfig[0].layerList) {
			if (layer.eName === layerName) {
				layer.labelIsVisible = obj.checked ? "1" : "0";
				isVisible = layer.labelIsVisible;
				break; //退出循环
			}
		}
		if (isVisible) jtMapKit.setLabelVisibleByName(layerName, isVisible === '1' ? true : false);
	}
	/* 更新图层本地化 */
	saveStorage({
		key: layerKey,
		value: JSON.stringify(layerConfig),
	})
}

/**
 * 右侧弹出窗口并展示内容
 * @param {String} title 标题
 * @param {String} content 展示内容
 */
function showRightResultWindow(title, content) {
	/* 如果已经弹出图层控制 则关闭显示 */
	if (mui('.mui-off-canvas-wrap').offCanvas().isShown()) {
		$("#divTitle").html(title);
		$("#divContent").html(content);
	} else {
		$("#divTitle").html(title);
		$("#divContent").html(content);
		/* 打印 */
		mui('.mui-off-canvas-wrap').offCanvas('show');
	}
}

/**
 * 展示查询结果
 * @param {Array[string,string]} Ids 查询要素集
 */
function showQueryTaskResult(Ids) {
	queryCaseIds = [];
	for (let Id of Ids) {
		queryCaseIds.push(Id);
	}
	caseBase.queryDataByCaseId(queryCaseIds);
}

/**
 * 显示结果内容
 * @param {Object} result 结果信息
 */
function showNormalResult(result) {
	$('.cr-result div').html(result);
	if ($('.cr-result').is(':hidden')) {
		$('.cr-result').slideDown(200, function() {});
	}
}

/**
 * 隐藏查询工具
 * @param {function} callback 隐藏后回调
 */
function hideNormalResult(callback) {
	$('.cr-result').hide(function() {
		if (callback) callback();
	});
}

/**
 * 地图点击查询图层数据
 */
function EventClick_Query_Point() {
	hideNormalResult();
	/* 查询的图层数组 */
	let queryLayers = [];
	for (let layer of layerConfig[0].layerList) {
		if (layer.isQuery == "1" && layer.layerIsVisible == '1') {
			queryLayers.push({
				id: layer.lyrIdx,
				fldName: layer.showField,
				eName: layer.eName,
				cName: layer.cName,
				isCase: layer.isCase === '1' ? true : false,
			});
		}
	}
	if (queryLayers.length == 0) {
		muiAlert("请开启显示需要查询的图层!");
		return;
	}
	muiToast("地图上单击，查询当前可视的地图数据!");
	jtMapKit.manyLayerQueryByPoint({
		url: mapQueryUrl,
		queryLayers: queryLayers,
	}, function(res) {
		showManyLayerQueryResult(res);
	}, function(err) {
		muiAlert(err, '提示');
	});
}

/**
 * 地图区域查询图层数据
 */
function EventClick_Query_Polygon() {
	hideNormalResult();
	/* 查询的图层数组 */
	let queryLayers = [];
	for (let layer of layerConfig[0].layerList) {
		if (layer.isQuery == "1" && layer.layerIsVisible == '1') {
			queryLayers.push({
				id: layer.lyrIdx,
				fldName: layer.showField,
				eName: layer.eName,
				cName: layer.cName,
				isCase: layer.isCase === '1' ? true : false,
			});
		}
	}
	if (queryLayers.length == 0) {
		muiAlert("请开启需要查询的图层!");
		return;
	}
	muiToast("地图上单击绘制查询区域，单击查询按钮开始查询数据!");
	jtMapKit.manyLayerQueryByPolygon({
		url: mapQueryUrl,
		queryLayers: queryLayers,
	}, function(op) {
		createToolsBySketch('开始查询', 'manyLayerQuerySpatialData', {
			geometry: op.geometry,
		});
	}, function(res) {
		hideNormalResult();
		showManyLayerQueryResult(res);
	}, function(err) {
		hideNormalResult();
		muiAlert(err, '提示');
	});
}

/**
 * 通用占压分析
 */
function EventClick_Common_Spatial_Analysis() {
	muiToast("地图上单击绘制分析区域，单击分析按钮进行占压分析!");
	jtMapKit.commonOccupyAnalysis(function(res) {
		createToolsBySketch('占压分析', 'commonSpatialAnalysis', {
			geometry: res,
		});
	})
	hideNormalResult();
}

/**
 * 开始根据绘制进行多图层查询
 * @param {JSON} options 参数项
 * options.queryLayers{array{JSON}}:可查询图层数组
 * options.url{string}:查询服务地址
 * options.geometry{JSON}:查询参考要素
 */
function manyLayerQuerySpatialData(options) {
	if (options.geometry == undefined || options.geometry.rings[0].length <= 3) {
		muiAlert("绘制的区域不符合要求,请继续绘制");
		return;
	}
	jtMapKit.manyLayerQueryByPolygonComplete();
}

/**
 * 开始根据绘制区域进行空间占压分析
 * @param {JSON} options 参数项
 * options.geometry{string}:坐标串
 */
function commonSpatialAnalysis(options) {
	let count = options.geometry.split(',').length;
	if (count < 8) {
		muiAlert("绘制的区域不符合要求,请继续绘制");
		return;
	}
	/* 隐藏窗口 */
	hideNormalResult();
	/* 锁定草图 */
	jtMapKit.sketchComplete();
	/* 查询配置表 */
	csaConfig = [];
	sendAjax({
		url: 'appQuerySpatialAnalysisConfig',
		data: {
			tabName: 'zdfx'
		},
		waitMessage: '初始化...',
		success: function(resData) {
			/* 装配配置表 */
			for (let item of resData[0].itemList) {
				csaConfig.push({
					tabEName: item.tabEName,
					tabCName: item.tabCName,
					fldName: item.fldEName,
					cntName: item.cntName,
					cntCName: item.cntCName,
					geoCoords: options.geometry,
					isDelete: '0',
				})
			}
			/* 执行分析 */
			if (csaConfig.length > 0) {
				csaConfig[0].isDelete = "1"; /* 设置删除原有数据标志 */
				_executeCSA(0);
			} else {
				muiAlertError("没有配置数据，请联系管理员！");
			}
		},
		error: function(err) {
			muiAlertError(err);
		}
	})
}

/* 通用占压分析配置表 */
let csaConfig = [];

/**
 * 执行通用占压分析
 * @param {int} index 配置索引
 */
function _executeCSA(index) {
	if (index == csaConfig.length) {
		console.log("占压分析执行完成...");
		/* 清除已有数据 */
		csaDatas = [];
		/* 分析完成 开始查询结果数据 */
		// _queryCSAData(0);
		_queryCSACount();
		return;
	}
	sendAjax({
		url: 'appExecuteCommonSpatialAnalysis',
		data: csaConfig[index],
		waitMessage: '执行' + csaConfig[index].tabCName + "占压分析...",
		success: function(resData) {
			_executeCSA(index + 1);
		},
		error: function(err) {
			_executeCSA(index + 1);
			console.log(err);
		}
	})
}

/**
 * 查询占压分析统计结果
 */
function _queryCSACount() {
	sendAjax({
		url: 'appQueryOccupyAnalysisCount',
		waitMessage: '查询中...',
		data: {},
		success: function(resData) {
			let csaCounts = [];
			for (let data of resData) {
				let items = [];
				for (let item of data.itemList) {
					items.push({
						selCode: item.selCode,
						selName: item.selName,
						selNumber: item.selNumber,
					})
				}
				csaCounts.push({
					tabName: data.tabName,
					fldName: data.fldName,
					items: items,
				});
				_showCSACountResult(csaCounts);
			}
		},
		error: function(err) {
			muiAlertError(err);
		}
	})
}

/**
 * 展示统计数据
 * @param {Array} datas 统计数据Array{JSON} 
 */
function _showCSACountResult(datas) {
	/* 初始化 加入根节点*/
	let divRoot = document.createElement('div');
	divRoot.className = 'jt-csa-count-result-panel';
	let rootHtml = "";
	/* 创建横向滚动tab */
	rootHtml +=
		"<div class='mui-scroll-wrapper mui-slider-indicator mui-segmented-control mui-segmented-control-inverted'>";
	rootHtml += "<div class='mui-scroll'>";
	for (let i = 0; i < datas.length; i++) {
		let data = datas[i];
		rootHtml += "<a href='#csa_count_" + i + "' class='mui-control-item";
		if (i === 0) {
			rootHtml += " mui-active";
		}
		rootHtml += "'>" + data.tabName + "</a>";
	}
	rootHtml += "</div>";
	rootHtml += "</div>";
	/* 创建统计信息详细内容 */
	rootHtml += "<div class='mui-content-padded'>";
	for (let i = 0; i < datas.length; i++) {
		let data = datas[i];
		rootHtml += "<div id='csa_count_" + i + "' class='mui-control-content";
		if (i === 0) {
			rootHtml += " mui-active";
		}
		rootHtml += "'>";
		/* 加入具体内容头 */
		rootHtml += "<div class='jt-row-head'>";
		rootHtml += "<span onclick='showDetails(this)'>" + data.fldName + "</span>";
		rootHtml += "<span>面积</span>";
		rootHtml += "</div>";
		/* 加入数据 */
		rootHtml += "<div class='jt-row-content'>";
		rootHtml += "<div class='mui-scroll-wrapper'>";
		rootHtml += "<div class='mui-scroll'>";
		for (let item of data.items) {
			rootHtml += "<div class='jt-row'>";
			rootHtml += "<span onclick='showDetails(this)'>" + item.selCode + "</span>";
			rootHtml += "<span onclick='showDetails(this)'>" + item.selName + "</span>";
			rootHtml += "</div>";
		}
		rootHtml += "</div>";
		rootHtml += "</div>";
		rootHtml += "</div>";

		rootHtml += "</div>";
	}
	rootHtml += "</div>";
	divRoot.innerHTML = rootHtml;
	/* 创建弹窗的标题头 */
	var header = document.createElement('header');
	header.className = 'mui-bar';
	let headHtml = "<div class='jt-cnt-bar'>";
	headHtml +=
		"<button type='button' class='app-icon app-iocn-details jt-cnt-bar-button' onclick='_queryCSAData(0)'>详细信息</button>";
	headHtml += "<span class='jt-cnt-bar-title'>占压分析统计</span>";
	headHtml += "</div>";
	header.innerHTML = headHtml;
	/* 显示信息 */
	_showMuiPopover(header, divRoot);
}

/**
 * 显示结果内容
 * @param {Object} domHeader 标题
 * @param {Object} domContent 内容
 * @param {boolean} isCase 多图层查询包含案件 调整弹出框高度 
 */
function _showMuiPopover(domHeader, domContent, isCase) {
	if (isCase && isCase === true) {
		$("#queryResultPopover").addClass('wc-popover-case-property');
	} else {
		$("#queryResultPopover").removeClass('wc-popover-case-property');
	}
	/* 清除原有显示内容 */
	$("#queryResultPopover").html('');
	/* 添加弹框显示内容 */
	$("#queryResultPopover").append(domHeader);
	$("#queryResultPopover").append(domContent);
	/* 显示弹框 */
	mui("#queryResultPopover").popover('show');
	/* 重置滚动容器 该方法是必须的 否则将导致滚动容器滚动失败 */
	mui('.mui-scroll-wrapper').scroll();
	/* 给标题添加事件 */
	domHeader.onclick = function() {
		mui("#queryResultPopover").popover('hide');
	};
}

/* 查询结果数据集 */
let csaDatas = [];

/**
 * 查询通用占地分析数据
 * @param {int} index 查询索引
 */
function _queryCSAData(index) {
	if (index == csaConfig.length) {
		// _initCSAData(csaDatas);
		_initCSADetailData(csaDatas);
		return;
	}
	sendAjax({
		url: 'appQueryCommonSpatialAnalysis',
		data: {
			tabEName: csaConfig[index].tabEName,
			start: '1',
			count: '10',
		},
		waitMessage: '查询' + csaConfig[index].tabCName + "分析结果...",
		success: function(resData) {
			if (resData[0].dataCount > 0) {
				let items = [];
				for (let item of resData[0].dataList) {
					items.push(item);
				}
				csaDatas.push({
					config: {
						name: csaConfig[index].tabCName,
						isLast: resData[0].isLast,
					},
					queryParam: {
						tabEName: csaConfig[index].tabEName,
						start: '1',
						count: '10',
					},
					items: items,
				});
			}
			_queryCSAData(index + 1);
		},
		error: function(err) {
			_queryCSAData(index + 1);
		}
	})
}

/**
 * 展示通用占压分析明细数据
 * @param {Array} datas 明细数据Array{JSON}
 */
function _initCSADetailData(datas) {
	/* 初始化 加入根节点*/
	let divRoot = document.createElement('div');
	divRoot.className = 'jt-csa-count-result-panel';
	let rootHtml = "";
	/* 创建横向滚动tab */
	rootHtml +=
		"<div class='mui-scroll-wrapper mui-slider-indicator mui-segmented-control mui-segmented-control-inverted'>";
	rootHtml += "<div class='mui-scroll'>";
	for (let i = 0; i < datas.length; i++) {
		let data = datas[i];
		rootHtml += "<a href='#item_count" + i + "' class='mui-control-item";
		if (i === 0) {
			rootHtml += " mui-active";
		}
		rootHtml += "'>" + data.config.name + "</a>";
	}
	rootHtml += "</div>";
	rootHtml += "</div>";
	/* 创建具体内容 */
	rootHtml += "<div class='mui-content-padded'>";
	for (let i = 0; i < datas.length; i++) {
		let data = datas[i];
		rootHtml += "<div id='item_count" + i + "' class='mui-control-content jt-mui-control-content";
		if (i === 0) {
			rootHtml += " mui-active";
		}
		rootHtml += "'>";
		rootHtml += "<div class='jt-row-content'>";
		rootHtml += "<div class='mui-scroll-wrapper'>";
		let panelId = 'panel' + i;
		rootHtml += "<div class='mui-scroll' id='" + panelId + "'>";
		rootHtml += _createCASDetailDataItem(data.items, panelId, data.config.isLast, data.queryParam);
		/* 以上是具体内容 */
		rootHtml += "</div>";
		rootHtml += "</div>";
		rootHtml += "</div>";
		rootHtml += "</div>";
	}
	rootHtml += "</div>";
	divRoot.innerHTML = rootHtml;
	/* 创建弹窗的标题头 */
	var header = document.createElement('header');
	header.className = 'mui-bar';
	let headHtml = "<div class='jt-cnt-bar'>";
	headHtml +=
		"<button type='button' class='app-icon app-iocn-details jt-cnt-bar-button' onclick='_queryCSACount()'>统计信息</button>";
	headHtml += "<span class='jt-cnt-bar-title'>占压分析明细</span>";
	headHtml += "</div>";
	header.innerHTML = headHtml;
	/* 显示弹框 */
	_showMuiPopover(header, divRoot);
}

/**
 * 根据数据项创建Html
 * @param {JSON} items 数据集
 * @param {string} domId 装载数据项的容器Id
 * @param {string} isLast 是否到达数据末尾
 * @param {JSON} queryParam 数据查询参数
 */
function _createCASDetailDataItem(items, domId, isLast, queryParam) {
	let itemHtml = "";
	for (let j = 0; j < items.length; j++) {
		let item = items[j];
		if (j % 2 == 0) {
			itemHtml += "<div class='jt-feature-data-row jt-row-even-number'>";
		} else {
			itemHtml += "<div class='jt-feature-data-row jt-row-odd-number'>";
		}
		itemHtml += "<span>" + item.rowNumber + "</span>";
		itemHtml += "<span class='jt-nowrap' onclick='showDetails(this)'>" + item.showName + "</span>";
		itemHtml += "<span class='jt-nowrap' onclick='showDetails(this)'>" + item.feaArea + "亩</span>";
		itemHtml += "<button type='button' class='mui-btn app-icon app-icon-location jt-button'";
		itemHtml += " onclick = \"_queryFeatureWktAndLocation('" + item.oid +
			"','fx_common_spatial_analysis')\" />";
		itemHtml += "<button type='button' class='mui-btn app-icon app-iocn-details jt-button'";
		itemHtml += " onclick = \"openDetailsPage('" + item.tabEName + "','" + item.fId + "')\" />"
		itemHtml += "</div>";
	}
	/* 删除加载更多按钮 */
	let btnPanelId = domId + "_" + "lastDom";
	$("#" + btnPanelId).remove();
	/* 判断是否需要加载更多按钮 */
	if (isLast === '0') {
		itemHtml += "<div class='jt-csa-data-item-row' id='" + btnPanelId + "'>";
		itemHtml += "<button class='mui-btn mui-btn-block jt-btn-load'";
		itemHtml += " onclick=\"_loadManyCSAData('" + domId + "'," + JSON.stringify(queryParam).replace(/\"/g,
			"'") + ")\"/>";
		itemHtml += "加载更多";
		itemHtml += "</button>";
		itemHtml += "</div>"
	}
	return itemHtml;
}


/**
 * 查询要素并定位
 * @param {string} objId objectid
 * @param {string} tabName 数据表名称
 */
function _queryFeatureWktAndLocation(objId, tabName) {
	var iData = {
		tabName: tabName,
		objId: objId,
	}
	sendAjax({
		type: 'post',
		url: "appQueryJSONCoordinates",
		waitMessage: '正在查询图形数据...',
		data: iData,
		success: function(resData) {
			let item = resData[0];
			if (item.type === 'Polygon' || item.type === 'MultiPolygon') {
				jtMapKit.appendPolygonToMap({
					type: item.type,
					coordinates: item.coordinates,
				})
			} else {
				muiAlertError('图形异常，请联系管理员！');
			}
		},
		error: function(err) {
			muiAlertError(err);
		}
	})
}

/**
 * @param {string} domId 数据装载容器Id
 * @param {JSON} queryParam 查询参数
 */
function _loadManyCSAData(domId, queryParam) {
	queryParam.start = parseInt(queryParam.start) + parseInt(queryParam.count);
	sendAjax({
		url: 'appQueryCommonSpatialAnalysis',
		data: queryParam,
		waitMessage: '加载更多数据...',
		success: function(resData) {
			let itemHtml = _createCASDetailDataItem(resData[0].dataList, domId, resData[0].isLast,
				queryParam);
			$("#" + domId).html($("#" + domId).html() + itemHtml);
		},
		error: function(err) {
			muiAlertError(err);
		}
	})
}

/**
 * 控制通用占地分析数据项容器显示/隐藏
 * @param {Object} dom 点击事件的dom 
 * @param {int} index 数据项容器索引
 */
function _showCSADataItem(dom, index) {
	/* 指示器点击 */
	indicator(dom);
	/* 设置所有数据项容器默认隐藏 */
	$(".jt-csa-data-panel").each(function(index, element) {
		$(element).hide();
	});
	/* 显示当前数据项 */
	$($(".jt-csa-data-panel")[index]).show();
	/* 设置滚动条到最顶端 */
	mui('#csaScrollWrapper').scroll().scrollTo(0, 0, 100); //100毫秒滚动到顶
}

/* 多图层查询结果展示相关 */

/**
 * 多图层查询结果展示
 * @param {JSON} datas 
 */
function showManyLayerQueryResult(datas, isInputQuery) {
	/* 案件要素 */
	let caseItems = undefined;
	/* 承载案件的容器 */
	let caseDomId = undefined;
	/* 可修改内容的容器Id */
	let caseHeadDomId = undefined;
	/* 初始化 加入根节点*/
	let divRoot = document.createElement('div');
	divRoot.className = 'jt-csa-count-result-panel';
	let rootHtml = "";
	/* 创建横向滚动tab */
	rootHtml +=
		"<div class='mui-scroll-wrapper mui-slider-indicator mui-segmented-control mui-segmented-control-inverted'>";
	rootHtml += "<div class='mui-scroll'>";
	for (let i = 0; i < datas.length; i++) {
		let data = datas[i];
		let topDomId = "top_item_" + i;
		rootHtml += "<a href='#item_count" + i + "' class='mui-control-item";
		if (i === 0) {
			if (datas.length === 1) {
				rootHtml += " jt-control-item mui-active";
			} else {
				rootHtml += " mui-active";
			}
		}
		rootHtml += "' id='" + topDomId + "'>" + data.cName + "</a>";
		if (data.isCase) {
			caseHeadDomId = topDomId;
		}
	}
	rootHtml += "</div>";
	rootHtml += "</div>";
	/* 创建具体内容 */
	rootHtml += "<div class='mui-content-padded'>";
	for (let i = 0; i < datas.length; i++) {
		let data = datas[i];
		rootHtml += "<div id='item_count" + i + "' class='mui-control-content jt-mui-control-content";
		if (i === 0) {
			rootHtml += " mui-active";
		}
		rootHtml += "'>";
		rootHtml += "<div class='jt-row-content'>";
		rootHtml += "<div class='mui-scroll-wrapper'>";
		let panelId = 'panel' + i;
		rootHtml += "<div class='mui-scroll' id='" + panelId + "'>";
		if (!data.isCase) {
			rootHtml += createManyLayerQueryItem(data.features);
		} else {
			caseDomId = panelId;
			if (!isInputQuery) {
				caseItems = data.features;
			} else {
				caseItems = data.caseId;
			}
		}
		/* 以上是具体内容 */
		rootHtml += "</div>";
		rootHtml += "</div>";
		rootHtml += "</div>";
		rootHtml += "</div>";
	}
	rootHtml += "</div>";
	divRoot.innerHTML = rootHtml;
	/* 创建弹窗的标题头 */
	/* 创建弹窗的标题头 */
	var header = document.createElement('header');
	header.className = 'mui-bar';
	header.innerHTML = '查询结果';
	/* 显示弹框 */
	_showMuiPopover(header, divRoot, true);
	/* 判断是否存案件 */
	if (caseDomId && caseItems && caseHeadDomId) {
		_manyLayerQueryCases(caseDomId, caseItems, caseHeadDomId);
	}
}

/* 记录案件展示轮播器当前位置及总数 */
let caseSliderCurrentIndex = 0;
let caseSliderItemCount = 0;
let caseSliderQueryModel = undefined;
let caseSliderContent = undefined;
let caseSliderIsLast = false;

/**
 * 装载案件
 * @param {String} domId 承载内容的容器Id
 * @param {Array} items 数据集
 * @param {String} domHeadId 子容器关联的标题头容器Id
 */
function _manyLayerQueryCases(domId, items, domHeadId) {
	/* 初始化案件展示轮播器当前位置及项目总数 */
	caseSliderCurrentIndex = 0;
	caseSliderItemCount = 0;
	caseSliderIsLast = false;
	caseSliderQueryModel = undefined;
	caseSliderContent = undefined;
	/* 创建查询模型 */
	caseSliderQueryModel = {
		userID: mapByUser.userID,
		queryCount: '10',
		queryType: 'Input',
		startNum: '0',
		additionalConditions: '',
	}
	/* 重置标题头容器样式 */
	$("#" + domHeadId).addClass('jt-segmented-control-item');
	setCaseHeadContent(domHeadId, '案件图斑', undefined, undefined, false);
	if (Object.prototype.toString.call(items) === '[object Array]') {
		let caseIds = [];
		/* 加载案件Id */
		for (let item of items) {
			caseIds.push("'" + item.sValue + "'");
		}
		caseSliderQueryModel.additionalConditions = "ajh in (" + caseIds.toString() + ")";
	} else {
		caseSliderQueryModel.additionalConditions = "ajh like '%" + items + "%'";
	}
	/* 创建内容slider容器*/
	let divSlider = document.createElement('div');
	divSlider.className = 'mui-slider';
	/* 创建具体内容容器 */
	caseSliderContent = document.createElement('div');
	caseSliderContent.className = 'mui-slider-group'
	divSlider.append(caseSliderContent);
	/* 加入slider到容器中 */
	$("#" + domId).append(divSlider);
	/* 滑动组件滑动监听 */
	document.querySelector(".mui-slider").addEventListener('slide', function(event) {
		/* 记录当前滑动位置 */
		caseSliderCurrentIndex = event.detail.slideNumber;
		if (caseSliderCurrentIndex === caseSliderItemCount - 1 && !caseSliderIsLast) {
			setCaseHeadContent(domHeadId, '案件图斑', caseSliderCurrentIndex, caseSliderItemCount, true);
		} else {
			setCaseHeadContent(domHeadId, '案件图斑', caseSliderCurrentIndex, caseSliderItemCount, false);
		}
	});
	/* 加载数据 */
	_manyLayerQueryAndAppendItems(caseSliderQueryModel, caseSliderContent, function() {
		/* 初始化slider 这很重要 否则将无法滑动 定位到上次滑动结束位置*/
		mui('.mui-slider').slider().gotoItem(caseSliderCurrentIndex);
		setCaseHeadContent(domHeadId, '案件图斑', caseSliderCurrentIndex, caseSliderItemCount, false);
	});
}

/**
 * 设置显示内容
 * @param {String} domId 显示内容的容器Id
 * @param {String} title 标题
 * @param {Number} index 当前索引
 * @param {Number} count 总数
 * @param {boolean} isLoadMany 是否显示加载更多按钮
 */
function setCaseHeadContent(domId, title, index, count, isLoadMany) {
	let divHtml = "<div class='jt-segmented-control-item-content'>";
	divHtml += "<span>" + title + "</span>";
	if (count) {
		divHtml += "<span class='jt-number'>" + (parseInt(index) + 1) + "/" + count + "</span>";
	}
	if (isLoadMany) {
		divHtml +=
			"<button class='app-icon app-iocn-details jt-cnt-bar-button' onclick=\"_caseSliderLoadMany('" + domId +
			"')\">加载更多</button>";
	}
	divHtml += "<div>";
	setHtmlByDomId(domId, divHtml);
}

/**
 * 加载更多
 * @param {String} domHeadId 显示内容的容器Id
 */
function _caseSliderLoadMany(domHeadId) {
	caseSliderQueryModel.startNum = parseInt(caseSliderQueryModel.startNum) + parseInt(caseSliderQueryModel.queryCount);
	_manyLayerQueryAndAppendItems(caseSliderQueryModel, caseSliderContent, function() {
		/* 初始化slider 这很重要 否则将无法滑动 定位到上次滑动结束位置*/
		mui('.mui-slider').slider().gotoItem(caseSliderCurrentIndex);
		setCaseHeadContent(domHeadId, '案件图斑', caseSliderCurrentIndex, caseSliderItemCount, false);
	})
}

/**
 * @param {JSON} queryModel 查询模型
 * @param {Object} domSliderContent 加载具体内容的容器dom
 * @param {Function} callSuccess 成功回调callSuccess()
 */
function _manyLayerQueryAndAppendItems(queryModel, domSliderContent, callSuccess) {
	/* 远程获取案件信息 */
	sendAjax({
		data: queryModel,
		url: 'appQueryCases',
		waitMessage: '案件装载中...',
		success: function(caseDatas) {
			/* 循环增加所有案件 */
			for (var i = 0; i < caseDatas.length; i++) {
				appendToSliderItemByCase(caseDatas[i], domSliderContent, false);
				/* 总数增加 */
				caseSliderItemCount++;
			}
			/* 判断是否已经到最后 */
			if (caseDatas.length < parseInt(queryModel.queryCount)) caseSliderIsLast = true;
			/* 回调告知已经加载完成 */
			if (callSuccess) callSuccess();
		},
		error: function(err) {
			muiAlertError(err);
		},
	});
}


/**
 * 创建多图层查询项目
 * @param {JSON} items 传递的数据
 */
function createManyLayerQueryItem(items) {
	let itemHtml = "";
	for (let j = 0; j < items.length; j++) {
		let item = items[j];
		if (j % 2 == 0) {
			itemHtml += "<div class='jt-feature-data-row jt-row-even-number'>";
		} else {
			itemHtml += "<div class='jt-feature-data-row jt-row-odd-number'>";
		}
		itemHtml += "<span>" + (parseInt(j) + 1) + "</span>";
		itemHtml += "<span class='jt-nowrap' onclick='showDetails(this)'>" + item.sValue + "</span>";
		itemHtml += "<button type='button' class='mui-btn app-icon app-icon-location jt-button'";
		itemHtml += " onclick = \"_queryFeatureWktAndLocation('" + item.fId +
			"','" + item.tabName + "')\" />";
		itemHtml += "<button type='button' class='mui-btn app-icon app-iocn-details jt-button'";
		itemHtml += " onclick = \"openDetailsPage('" + item.tabName + "','" + item.fId + "')\" />"
		itemHtml += "</div>";
	}
	return itemHtml;
}

/**
 * 定位地图到指定区域
 * @param {string} xmin x最小值
 * @param {string} ymin y最小值
 * @param {string} xmax x最大值
 * @param {string} ymax y最大值
 */
function mapToExtent(xmin, ymin, xmax, ymax) {
	let _xmin = parseFloat(xmin);
	let _ymin = parseFloat(ymin);
	let _xmax = parseFloat(xmax);
	let _ymax = parseFloat(ymax);
	jtMapKit.zoomToExtentNormal({
		xmin: _xmin,
		ymin: _ymin,
		xmax: _xmax,
		ymax: _ymax,
	})
}

/**
 * 打开详情页面
 * @param {string} tabName 表名称
 * @param {string} fldValue 值
 */
function openDetailsPage(tabName, fldValue) {
	mui.openWindow({
		url: 'page-details.html',
		id: 'page-details.html',
		styles: {
			top: '0px',
			bottom: '0px',
			left: '0px',
			right: '0px',
			background: 'transparent',
		},
		show: {
			aniShow: 'slide-in-bottom',
			duration: '300',
		},
		extras: {
			tabName: tabName,
			fldValue: fldValue,
		}
	});
}

/* +++++++++++++++++++++通用选择图斑占地分析相关代码+++++++++++++++++++++ */

/**
 * 弹窗展示内容
 * @param {string} title 标题
 * @param {string} html 展示内容 li的集合
 */
function _showPopover(title, html) {
	/* 创建根据容器-滚动容器的父容器 */
	let divScrollWrapper = document.createElement('div');
	divScrollWrapper.className = 'mui-scroll-wrapper';

	/* 创建滚动子容器 */
	let divScroll = document.createElement('div');
	divScroll.className = 'mui-scroll';
	divScrollWrapper.append(divScroll);

	/* 加入数据项内容html */
	divScroll.innerHTML = html;

	/* 创建弹窗的标题头 */
	var header = document.createElement('header');
	header.className = 'mui-bar';
	header.innerHTML = title;

	/* 显示信息 */
	_showMuiPopover(header, divScrollWrapper);
}

/**
 * 选择要素空间占压分析
 */
function EventClick_Select_Spatial_Analysis() {
	hideNormalResult();
	/* 查询的图层数组 */
	let queryLayers = [];
	for (let layer of layerConfig[0].layerList) {
		if (layer.isQuery === '1' && layer.layerIsVisible == '1') {
			queryLayers.push({
				fldName: layer.showField,
				eName: layer.eName,
				cName: layer.cName,
			});
		}
	}
	if (queryLayers.length == 0) {
		muiAlert("请开启需要进行占压分析的图层!");
		return;
	}
	muiToast("地图单击图斑进行分析!");
	selectFeatureExecuteAnalysis({
		queryLayers: queryLayers,
	});
}

/**
 * 选择要素进行分析
 * @param {JSON} options 配置项
 * @param {Array} options.queryLayers 分析的表JSON数组
 */
function selectFeatureExecuteAnalysis(options) {
	if (options === undefined || options.queryLayers === undefined) {
		muiAlert('参数异常！', '警告');
		return;
	}
	jtMapKit.occupyAnalysis({
		url: mapQueryUrl,
		queryLayers: options.queryLayers,
	}, function(res) {
		showSelectOccypyFeatures(res);
		// console.log(JSON.stringify(res));
	}, function(err) {
		muiAlertError(err);
	});
}

/**
 * 展示选择的图元要素数据
 * @param {Array} data 选择的图元要素
 */
function showSelectOccypyFeatures(data) {
	let resHtml = "";
	resHtml += "<div class='mui-card'>";
	resHtml += "<ul class='mui-table-view'>";
	for (let index in data) {
		let item = data[index];
		if (index % 2 === 0) {
			resHtml += "<li class='mui-table-view-cell jt-row-even-number mui-collapse'>";
		} else {
			resHtml += "<li class='mui-table-view-cell jt-row-odd-number mui-collapse'>";
		}
		/* 创建主项 */
		resHtml += "<a class='mui-navigate-right'><span>" + item.tabCName + "</span></a>";
		resHtml += "<div class='mui-collapse-content'>";
		/* 创建子项 */
		for (let feaIdx in item.features) {
			let feature = item.features[feaIdx];
			resHtml += "<div class='jt-csa-data-item-row'>";
			resHtml += "<span class='jt-number-icon'>" + (parseInt(feaIdx) + 1) + "</span>";
			resHtml += "<div class='jt-content jt-nowrap'>";
			resHtml += "<span class='jt-title jt-nowrap'>" + feature.showName + "</span>";
			resHtml += "</div>";
			resHtml += "<button type='button' class='mui-btn app-icon app-icon-location jt-button'";
			resHtml += " onclick = \"_queryFeatureWktAndLocation('" + feature.objId + "','" + feature.tabName +
				"')\" />"
			resHtml += "<button type='button' class='mui-btn app-icon app-icon-accupy-analysis jt-button'";
			resHtml += " onclick = \"_featureOccupyAnalysis('" + feature.tabName + "','" + feature.objId + "')\" />"
			resHtml += "</div>";
		}
		resHtml += "</div>";
		resHtml += "</li>";
	}
	resHtml += "</ul>";
	resHtml += "</div>";
	/* 展示结果 */
	_showPopover('进行占压分析', resHtml);
}

/**
 * 要素占压分析
 * @param {string} tabName 分析表名
 * @param {int} objId 要素唯一标识
 */
function _featureOccupyAnalysis(tabName, objId) {
	/* 分析配置表 该表与通用占压分析通用 */
	csaConfig = [];
	sendAjax({
		url: 'appQuerySpatialAnalysisConfig',
		data: {
			tabName: tabName,
		},
		waitMessage: '初始化...',
		success: function(resData) {
			/* 装配配置表 */
			for (let item of resData[0].itemList) {
				csaConfig.push({
					tabEName: item.tabEName,
					tabCName: item.tabCName,
					fldName: item.fldEName,
					cntName: item.cntName,
					cntCName: item.cntCName,
					objId: objId,
					sName: tabName,
					isDelete: '0',
				})
			}
			/* 执行分析 */
			if (csaConfig.length > 0) {
				csaConfig[0].isDelete = "1"; /* 设置删除原有数据标志 */
				_executeFOA(0);
			} else {
				muiAlertError("没有配置数据，请联系管理员！");
			}
		},
		error: function(err) {
			muiAlertError(err);
		}
	})
}

/**
 * 执行选择要素占压分析
 * @param {int} index 配置索引
 */
function _executeFOA(index) {
	if (index == csaConfig.length) {
		/* 清除已有数据 */
		csaDatas = [];
		/* 开始查询结果数据 */
		_queryCSACount();
		return;
	}
	sendAjax({
		url: 'appExecuteFeatureOccupyAnalysis',
		data: csaConfig[index],
		waitMessage: '执行' + csaConfig[index].tabCName + "占压分析...",
		success: function(resData) {
			_executeFOA(index + 1);
		},
		error: function(err) {
			_executeFOA(index + 1);
		}
	})
}