潘钊 / bsth_control · Files

package com.bsth.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.bsth.common.ResponseCode;
import com.bsth.entity.*;
import com.bsth.entity.search.CustomerSpecs;
import com.bsth.repository.*;
import com.bsth.service.StationService;
import com.bsth.util.CoordinateConverter;
import com.bsth.util.CoordinateConverter.Location;
import com.bsth.util.CustomBeanUtils;
import com.bsth.util.Geo.GeoUtils;
import com.bsth.util.Geo.Point;
import com.bsth.util.GeoConverter;
import org.geolatte.geom.LineString;
import org.geolatte.geom.Polygon;
import org.geolatte.geom.codec.Wkt;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 
 * @ClassName: StationServiceImpl(站点service业务层实现类)
 * 
 * @Extends : BaseService
 * 
 * @Description: TODO(站点service业务层)
 * 
 * @Author bsth@lq
 * 
 * @Date 2016年05月03日 上午9:21:17
 *
 * @Version 公交调度系统BS版 0.1
 * 
 */

@Service
public class StationServiceImpl extends BaseServiceImpl<Station, Integer> implements StationService {

	@Autowired
	private StationRepository repository;

	@Autowired
	private StationRouteRepository routeRepository;

	@Autowired
	private LsStationRouteRepository lsStationRouteRepository;

	@Autowired
	private LineInformationRepository informationRepository;

	@Autowired
	private LineRepository lineRepository;

	@Autowired
	private SectionRepository sectionRepository;

	@Autowired
	private SectionRouteRepository sectionRouteRepository;

	@Autowired
	private LsSectionRouteRepository lsSectionRouteRepository;

	@Autowired
	LineVersionsRepository lineVersionsRepository;

	@Autowired
	private JdbcTemplate jdbcTemplate;

	Logger logger = LoggerFactory.getLogger(this.getClass());

	/**
	 * @Description :TODO(系统规划保存数据)
	 * 
	 * @param map <stationJSON:站点信息； sectionJSON：路段信息；dbType：坐标类型； destroy：是否撤销；
	 *            directions：方向；lineId：线路ID；
	 * 
	 *            radius：圆半径；shapesType：图形类型；speedLimit：限速>
	 * 
	 * @return Map<String, Object> <SUCCESS ; ERROR>
	 */
	@Override
	public Map<String, Object> systemSaveStations(Map<String, Object> map) {
		Map<String, Object> resultMap = new HashMap<String, Object>();
		try {
			// 站点信息字符传
			String stationJSON = map.get("stationJSON").toString().equals("") ? "" : map.get("stationJSON").toString();
			// 路段信息字符串
			String sectionJSON = map.get("sectionJSON").toString().equals("") ? "" : map.get("sectionJSON").toString();
			// 方向
			int directions = Integer.parseInt(map.get("directions").toString());
			// 是否撤销
			int destroy = map.get("destroy").equals("") ? 0 : Integer.parseInt(map.get("destroy").toString());
			// 版本
			int versions = map.get("versions").equals("") ? 0 : Integer.parseInt(map.get("versions").toString());
			// 坐标类型
			String dbType = map.get("dbType").equals("") ? "" : map.get("dbType").toString();
			// 限速
			String speedLimitStr = map.get("speedLimit").equals("") ? "" : map.get("speedLimit").toString();
			// 线路ID
			int lineId = map.get("lineId").toString().equals("") ? 0 : Integer.parseInt(map.get("lineId").toString());
			// 半径
			int radius = map.get("radius").equals("") ? 0 : Integer.parseInt(map.get("radius").toString());
			// 图形类型
			String shapesType = map.get("shapesType").equals("") ? "" : map.get("shapesType").toString();
			// 路段距离
			Double sectionDistance = 0.0d;
			// 路段时长
			Double sectionDuration = 0.0d;
			// 里程(上或者下)
			double sumUpOrDownMileage = 0.0d;
			// 线路信息
			Line resultLine = lineRepository.findById(lineId).get();
			Map<String, Object> resultSaveMapm = new HashMap<String, Object>();
			String baseRes = map.get("baseRes").equals("") ? "" : map.get("baseRes").toString();
			if (!stationJSON.equals("")) {
				// 保存前先撤销原有站点

				// 保存站点与站点路由信息
				resultSaveMapm = savaStationAndStationRouteInfo(stationJSON, sectionDistance, sectionDuration, dbType,
						radius, shapesType, destroy, versions, sumUpOrDownMileage, directions, resultLine, baseRes);
			}

			// 路段长度
			sectionDistance = Double.valueOf(resultSaveMapm.get("sectionDistance").toString());

			// 路段时长
			sectionDuration = Double.valueOf(resultSaveMapm.get("sectionDuration").toString());

			// 如果路段信息JSON字符串不为空
			if (!sectionJSON.equals("")) {

				// 保存路段与路段路由信息
				saveSectionAndSectionRouteInfo(sectionJSON, directions, resultLine, speedLimitStr, sectionDistance,
						sectionDuration, dbType, versions, destroy);
			}

			// 里程
			sumUpOrDownMileage = Double.valueOf(resultSaveMapm.get("sumUpOrDownMileage").toString());

			BigDecimal s = new BigDecimal(sumUpOrDownMileage);

			sumUpOrDownMileage = s.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();

			// 更新里程
			updateLineInfoUpOrDownMileage(resultLine, directions, sumUpOrDownMileage);

			if (directions == 0) {

				lineUpdateStationName(resultLine);

			}
			resultMap.put("status", ResponseCode.SUCCESS);

		} catch (Exception e) {

			resultMap.put("status", ResponseCode.ERROR);

			logger.error("save erro.", e);

		}

		return resultMap;
	}

	public void lineUpdateStationName(Line resultLine) {

		List<StationRoute> stationRoutes = routeRepository.findByLine(resultLine);

		int sizeL = stationRoutes.size();

		if (sizeL < 0) {

			return;

		}

		if (resultLine.getStartStationName().equals("")) {

			for (int k = 0; k < sizeL; k++) {

				StationRoute tempS = stationRoutes.get(k);

				if (tempS.getStationMark().equals("B") && tempS.getDirections() == 0) {

					resultLine.setStartStationName(tempS.getStationName());

					lineRepository.save(resultLine);

				}
			}

		}
		;

		if (resultLine.getEndStationName().equals("")) {

			for (int k = 0; k < sizeL; k++) {

				StationRoute tempS = stationRoutes.get(k);

				if (tempS.getStationMark().equals("E") && tempS.getDirections() == 0) {

					resultLine.setEndStationName(tempS.getStationName());

					lineRepository.save(resultLine);

				}
			}

		}
	}

	/**
	 * @Description :保存站点和站点路由信息（系统规划）
	 * 
	 * @param stationJSON：站点和站点路由json数据
	 * 
	 * @param sectionDistance：            总距离
	 * 
	 * @param sectionDuration：            总时长
	 * 
	 * @param dbType：原坐标类型
	 * 
	 * @param radius：半径
	 * 
	 * @param shapesType：图形类型
	 * 
	 * @param destroy：是否撤销
	 * 
	 * @param versions：版本
	 * 
	 * @param sumUpOrDownMileage：里程（上或者下）
	 * 
	 * @param directions：方向
	 * 
	 * @param resultLine：线路实体类
	 * 
	 * @return
	 * 
	 * @throws Exception
	 */
	public Map<String, Object> savaStationAndStationRouteInfo(String stationJSON, double sectionDistance,
			double sectionDuration, String dbType, int radius, String shapesType, int destroy, int versions,
			double sumUpOrDownMileage, int directions, Line resultLine, String baseRes) throws Exception {
		Map<String, Object> paramsMeleageAndDistncDura = new HashMap<String, Object>();
		JSONArray stationsArray = JSONArray.parseArray(stationJSON);
		if (stationsArray.size() > 0) {
			Station loopStartStation = new Station();
			for (int i = 0; i < stationsArray.size(); i++) {
				// 站点名称
				String stationName = stationsArray.getJSONObject(i).equals("") ? ""
						: stationsArray.getJSONObject(i).get("name").toString();
				Double distance = stationsArray.getJSONObject(i).get("distance").equals("") ? 0.0d
						: Double.parseDouble(stationsArray.getJSONObject(i).get("distance").toString());
				// 转成公里
				distance = distance / 1000;
				BigDecimal d = new BigDecimal(distance);
				distance = d.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
				sectionDistance = distance + sectionDistance;
				Double duration = stationsArray.getJSONObject(i).get("duration").equals("") ? 0.0d
						: Double.parseDouble(stationsArray.getJSONObject(i).get("duration").toString());
				// 转成分钟
				duration = duration / 60;
				BigDecimal t = new BigDecimal(duration);
				duration = t.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
				sectionDuration = duration + sectionDuration;
				// 百度坐标经度
				String bLonx = JSONObject.parseObject(stationsArray.getJSONObject(i).get("potion").toString())
						.get("lng").toString();
				bLonx = bLonx == null || bLonx.equals("") ? "0" : bLonx;
				// 百度坐标纬度
				String bLaty = JSONObject.parseObject(stationsArray.getJSONObject(i).get("potion").toString())
						.get("lat").toString();
				bLaty = bLaty == null || bLaty.equals("") ? "0" : bLaty;
				List<Object[]> stationNameList = repository.findStationName(directions, stationName);
				Map<String, Object> isHaveMap = isHaveStationname(bLonx, bLaty, stationNameList);
				// 初始化站点对象
				Station tempStation = new Station();
				if (Boolean.parseBoolean(isHaveMap.get("isHave").toString())) {
					/*
					 * Integer stationId = Integer.parseInt(stationNameList.get(0)[1].toString());
					 */
					Integer stationId = Integer.parseInt(isHaveMap.get("id").toString());
					tempStation = repository.findById(stationId).get();

					if (i == stationsArray.size() - 1 && resultLine.getLinePlayType() == 1) {// 环线终点和起点引用同一个站
						tempStation = loopStartStation;
					} else {
						List<Station> list = new ArrayList<>();
						list.add(tempStation);
						List<Station> stationlist = JSONArray.parseArray(JSON.toJSONString(list), Station.class);
						Station station = stationlist.get(0);
						// 站点编码
						int stationCode = repository.stationMaxId() + 1;
						station.setStationCode(String.valueOf(stationCode));
						station.setId(stationCode);
						station.setCreateDate(null);
						station.setUpdateDate(null);
						repository.save(station);
						tempStation = station;
						if (i == 0 && resultLine.getLinePlayType() == 1) {// 环线终点和起点引用同一个站
							loopStartStation = tempStation;
						}
					}
				} else {
					// 站点编码
					int stationCode = repository.stationMaxId() + 1 ;
					tempStation.setStationCode(String.valueOf(stationCode));
					tempStation.setId(stationCode);
					tempStation.setStationName(stationName);
					String gLonxStr = JSONObject.parseObject(stationsArray.getJSONObject(i).get("wgs").toString())
							.get("x").equals("") ? null
									: JSONObject.parseObject(stationsArray.getJSONObject(i).get("wgs").toString())
											.get("x").toString();
					String gLatyStr = JSONObject.parseObject(stationsArray.getJSONObject(i).get("wgs").toString())
							.get("y").equals("") ? null
									: JSONObject.parseObject(stationsArray.getJSONObject(i).get("wgs").toString())
											.get("y").toString();

					// 统一归化为wgs
					Location wgs = null;
					// 中心点wkt
					StringBuilder centerPointWkt = new StringBuilder();
					StringBuilder centerPointWgsWkt = new StringBuilder();
					if (baseRes.equals("No")) {
						/** BD to WGS坐标 */
						wgs = CoordinateConverter.transformFromBDToWGS(CoordinateConverter.LocationMake(Double.parseDouble(bLonx), Double.parseDouble(bLaty)));
						centerPointWkt.append("POINT(").append(bLonx).append(" ").append(bLaty).append(")");
						centerPointWgsWkt.append("POINT(").append(wgs.getLng()).append(" ").append(wgs.getLat()).append(")");
					} else if (baseRes.equals("GCJ02")) {
						Location gcj = CoordinateConverter.LocationMake(Double.valueOf(gLonxStr), Double.valueOf(gLatyStr));
						Location baidu = CoordinateConverter.bd_encrypt(gcj);
						wgs = CoordinateConverter.transformFromGCJToWGS(gcj);
						centerPointWkt.append("POINT(").append(baidu.getLng()).append(" ").append(baidu.getLat()).append(")");
						centerPointWgsWkt.append("POINT(").append(wgs.getLng()).append(" ").append(wgs.getLat()).append(")");
					} else if (baseRes.equals("BD09")) {
						wgs = CoordinateConverter.transformFromBDToWGS(CoordinateConverter.LocationMake(Double.valueOf(gLonxStr), Double.valueOf(gLatyStr)));
						centerPointWkt.append("POINT(").append(gLonxStr).append(" ").append(gLatyStr).append(")");
						centerPointWgsWkt.append("POINT(").append(wgs.getLng()).append(" ").append(wgs.getLat()).append(")");
					} else if (baseRes.equals("WGS84")) {
						wgs = CoordinateConverter.LocationMake(Double.valueOf(gLonxStr), Double.valueOf(gLatyStr));
						Location baidu = CoordinateConverter.transformFromWGSToBD(wgs);
						centerPointWkt.append("POINT(").append(baidu.getLng()).append(" ").append(baidu.getLat()).append(")");
						centerPointWgsWkt.append("POINT(").append(wgs.getLng()).append(" ").append(wgs.getLat()).append(")");
					}

					// 版本号
					tempStation.setVersions(versions);
					tempStation.setCenterPoint((org.geolatte.geom.Point) Wkt.fromWkt(centerPointWkt.toString()));
					tempStation.setCenterPointWgs((org.geolatte.geom.Point) Wkt.fromWkt(centerPointWgsWkt.toString()));
					// 插入站点信息
					if (i == 0 && resultLine.getLinePlayType() == 1) {// 环线终点和起点引用同一个站
						loopStartStation = tempStation;
						repository.save(tempStation);
					} else if (i == stationsArray.size() - 1 && resultLine.getLinePlayType() == 1) {// 环线终点和起点引用同一个站
						tempStation = loopStartStation;
					} else {
						repository.save(tempStation);
					}

				}

				Integer version = lineVersionsRepository.findCurrentVersion(resultLine.getId());

				if (versions == version) {
					// 站点路由对象
					StationRoute route = new StationRoute();
					// 站点名称
					route.setStationName(stationName);
					route.setDistances(distance);
					sumUpOrDownMileage = sumUpOrDownMileage + distance;
					route.setToTime(duration);
					// 站点编码
					route.setStationCode(tempStation.getStationCode());
					// 站点序号
					route.setStationRouteCode((i + 1) * 100);
					// 站点类型
					if (i == 0) {
						// 起始站
						route.setStationMark("B");
					} else if (i == stationsArray.size() - 1) {
						// 终点站
						route.setStationMark("E");
					} else {
						// 中途站
						route.setStationMark("Z");
					}
					// 版本号(获取线路当前版本)
					route.setVersions(versions);
					// 站点ID
					route.setStation(tempStation);
					// 方向
					route.setDirections(directions);
					// 线路ID
					route.setLine(resultLine);
					// 线路编码
					route.setLineCode(resultLine.getLineCode());
					route.setDestroy(destroy);
					route.setShapedType(shapesType);
					route.setRadius(80);
					// 插入站点路由信息
					routeRepository.save(route);
				} else {

					LsStationRoute route = new LsStationRoute();
					// 站点名称
					route.setStationName(stationName);
					route.setDistances(distance);
					sumUpOrDownMileage = sumUpOrDownMileage + distance;
					route.setToTime(duration);
					// 站点编码
					route.setStationCode(tempStation.getStationCode());
					// 站点序号
					route.setStationRouteCode((i + 1) * 100);
					// 站点类型
					if (i == 0) {
						// 起始站
						route.setStationMark("B");
					} else if (i == stationsArray.size() - 1) {
						// 终点站
						route.setStationMark("E");
					} else {
						// 中途站
						route.setStationMark("Z");
					}
					// 版本号(获取线路当前版本)
					route.setVersions(versions);
					// 站点ID
					route.setStation(tempStation);
					// 方向
					route.setDirections(directions);
					// 线路ID
					route.setLine(resultLine);
					// 线路编码
					route.setLineCode(resultLine.getLineCode());
					route.setDestroy(destroy);
					route.setShapedType(shapesType);
					route.setRadius(80);
					// 插入站点路由信息
					lsStationRouteRepository.save(route);
				}

			}
			paramsMeleageAndDistncDura.put("sumUpOrDownMileage", sumUpOrDownMileage);
			paramsMeleageAndDistncDura.put("sectionDistance", sectionDistance);
			paramsMeleageAndDistncDura.put("sectionDuration", sectionDuration);
			paramsMeleageAndDistncDura.put("stationdata", stationsArray);
		}
		return paramsMeleageAndDistncDura;
	}

	/**
	 * 
	 * 
	 * @param resultLine：线路实体类
	 * 
	 * @param directions：方向
	 * 
	 * @param sumUpOrDownMileage：里程（上或者下）
	 */
	public void updateLineInfoUpOrDownMileage(Line resultLine, int directions, double sumUpOrDownMileage) {

		List<LineInformation> listLineInfo = informationRepository.findByLine(resultLine);

		int listLineSize = listLineInfo.size();

		// 不存在线路标准信息则插入
		if (listLineSize == 0) {

			LineInformation paramInfo = new LineInformation();

			// 上行
			if (directions == 0) {

				paramInfo.setUpMileage(sumUpOrDownMileage);

				paramInfo.setDownMileage(0.0d);

				paramInfo.setTotalMileage(sumUpOrDownMileage + 0.0d);

				paramInfo.setType("zc");

				paramInfo.setLine(resultLine);

				// 下行
			} else if (directions == 1) {

				paramInfo.setUpMileage(0.0d);

				paramInfo.setDownMileage(sumUpOrDownMileage);

				paramInfo.setTotalMileage(sumUpOrDownMileage + 0.0d);

				paramInfo.setType("zc");

				paramInfo.setLine(resultLine);

			}

			informationRepository.save(paramInfo);

			// 存在则更新
		} else if (listLineSize > 0) {

			for (int s = 0; s < listLineSize; s++) {

				LineInformation lineInformation = listLineInfo.get(s);

				double tempUp = lineInformation.getUpMileage();

				double tempDown = lineInformation.getDownMileage();

				// 上行
				if (directions == 0) {

					if (tempUp > 0.0d) {

						continue;
					}

					lineInformation.setUpMileage(sumUpOrDownMileage);

					lineInformation.setTotalMileage(sumUpOrDownMileage + tempDown);

				} else if (directions == 1) {

					if (tempDown > 0.0d) {

						continue;
					}

					lineInformation.setDownMileage(sumUpOrDownMileage);

					lineInformation.setTotalMileage(sumUpOrDownMileage + tempUp);

				}

				informationRepository.save(lineInformation);

			}

		}

	}

	/**
	 * @Description 保存路段与路段路由信息
	 * 
	 * @param sectionJSON：路段与路段路由json字符串数据
	 * 
	 * @param directions：方向
	 * 
	 * @param resultLine：线路实体类
	 * 
	 * @param speedLimitStr：限速
	 * 
	 * @param sectionDistance：总距离
	 * 
	 * @param sectionDuration：总时长
	 * 
	 * @param dbType：原中坐标类型
	 * 
	 * @param versions：版本号
	 * 
	 * @param destroy：是否撤销
	 * 
	 */
	public void saveSectionAndSectionRouteInfo(String sectionJSON, int directions, Line resultLine,
			String speedLimitStr,

			double sectionDistance, double sectionDuration, String dbType, int versions, int destroy) throws Exception {

		BigDecimal t = new BigDecimal(sectionDistance);

		sectionDistance = t.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();

		BigDecimal d = new BigDecimal(sectionDuration);

		sectionDuration = d.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();

		// 转换成JSON数组
		JSONArray sectionsArray = JSONArray.parseArray(sectionJSON);

		// 原始线状图形坐标集合
		String sectionsBpoints = "";

		// WGS线状图形坐标集合
		String sectionsWJPpoints = "";

		// 遍历
		for (int s = 0; s < sectionsArray.size(); s++) {

			String pointsLngStr = sectionsArray.getJSONObject(s).get("lng").toString();

			String pointsLatStr = sectionsArray.getJSONObject(s).get("lat").toString();

			String WGSLngStr = "";

			String WGSLatStr = "";

			Location resultPoint = CoordinateConverter.transformFromBDToWGS(CoordinateConverter.LocationMake(Double.parseDouble(pointsLngStr), Double.parseDouble(pointsLatStr)));

			WGSLngStr = String.valueOf(resultPoint.getLng());

			WGSLatStr = String.valueOf(resultPoint.getLat());
			/** to WGS坐标 */
			/*
			 * double lng = Double.parseDouble(WGSLngStr);
			 * 
			 * double lat = Double.parseDouble(WGSLatStr);
			 * 
			 * Location bdLoc = CoordinateConverter.LocationMake(lng, lat);
			 * 
			 * Location location = CoordinateConverter.bd_decrypt(bdLoc);
			 * 
			 * Location WGSPoint = CoordinateConverter.transformFromGCJToWGS(location);
			 */

			// String WGSLngStr =
			// JSONObject.parseObject(sectionsArray.getJSONObject(s).get("WGSpotion").toString()).get("Lng").toString();

			// String WGSLatStr =
			// JSONObject.parseObject(sectionsArray.getJSONObject(s).get("WGSpotion").toString()).get("Lat").toString();

			if (s == 0) {

				sectionsBpoints = pointsLngStr + " " + pointsLatStr;

				sectionsWJPpoints = WGSLngStr + " " + WGSLatStr;

			} else {

				sectionsBpoints = sectionsBpoints + "," + pointsLngStr + " " + pointsLatStr;

				sectionsWJPpoints = sectionsWJPpoints + "," + WGSLngStr + " " + WGSLatStr;

			}

		}

		long sectionMaxId = sectionRepository.sectionMaxId() + 1;

		String sectionCode = String.valueOf(sectionMaxId);

		int sectionid = (int) sectionMaxId;

		String upOrDownStr = "";

		if (directions == 0) {

			upOrDownStr = "上行路段";

		} else if (directions == 1) {

			upOrDownStr = "下行路段";

		}

		// 路段名称
		String sectionName = resultLine.getName() + upOrDownStr;

		// 交出路
		String crosesRoad = "";

		// 终止节点
		String endNode = "";

		// 开始节点
		String startNode = "";

		// 中间节点
		String middleNode = "";

		// WGS坐标点集合
		String gsectionVector = "LINESTRING(" + sectionsWJPpoints + ")";

		// 原坐标点集合
		String bsectionVector = "LINESTRING(" + sectionsBpoints + ")";

		// 城建坐标点集合
		String csectionVector = null;

		// 路段类型
		String sectionType = "";

		// 道路编码
		String roadCoding = "";

		// 限速
		double speedLimit = Double.parseDouble(speedLimitStr);

		// 说明
		String descriptions = "";

		// 路段保存
		sectionRepository.systemSave(sectionCode, sectionName, crosesRoad, endNode, startNode,

				middleNode, gsectionVector, bsectionVector, sectionType, csectionVector,

				roadCoding, sectionDistance, sectionDuration, dbType, speedLimit,

				descriptions, versions, sectionid);

		Section section = sectionRepository.findById(sectionid).get();
		// 路段路由
		SectionRoute sectionRoute = new SectionRoute();
		// 路段序号
		sectionRoute.setSectionrouteCode(100);
		// 线路编码
		sectionRoute.setLineCode(resultLine.getLineCode());
		// 路段ID
		sectionRoute.setSection(section);
		sectionRoute.setDestroy(destroy);
		// 线路ID
		sectionRoute.setLine(resultLine);
		// 路段编码
		sectionRoute.setSectionCode(sectionCode);
		// 版本
		sectionRoute.setVersions(versions);
		// 方向
		sectionRoute.setDirections(directions);
		// 路段路由保存
		sectionRouteRepository.save(sectionRoute);

	}

	public Map<String, Object> isHaveStationname(String jd, String wd, List<Object[]> stationNameList) {
		Map<String, Object> rsM = new HashMap<String, Object>();
		boolean temp = false;
		if (stationNameList.size() > 0) {
			if (jd.equals("0") || wd.equals("0")) {
				rsM.put("id", stationNameList.get(0)[1]);
				temp = true;
			} else {
				Point p1 = new Point(Double.parseDouble(jd), Double.parseDouble(wd));
				for (int k = 0; k < stationNameList.size(); k++) {
					String bJwpoints[] = stationNameList.get(k)[0].toString().split(" ");
					Point p2 = new Point(Double.parseDouble(bJwpoints[0]), Double.parseDouble(bJwpoints[1]));
					double jl = GeoUtils.getDistance(p1, p2);
					if (jl <= 60d) {
						rsM.put("id", stationNameList.get(k)[1]);
						temp = true;
						break;
					}
				}
			}
		}
		rsM.put("isHave", temp);
		return rsM;
	}

	/**
	 * @Description :TODO(更新站点保存)
	 * 
	 * @param stationRoute
	 * 
	 * @return Map<String, Object> <SUCCESS ; ERROR>
	 */
	@Transactional(rollbackFor = Exception.class)
	@Override
	public void stationUpdate(LsStationRoute stationRoute) {
		Station station = stationRoute.getStation(), station1 = repository.findById(station.getId()).get();
		LsStationRoute stationRoute1 = lsStationRouteRepository.findById(stationRoute.getId()).get();

		// 中心点坐标信息
		String centerPoint = station.getCenterPointWkt();
		Location bd = CoordinateConverter.LocationMake(centerPoint);
		Location wgs = CoordinateConverter.transformFromBDToWGS(bd);
		org.geolatte.geom.Point baiduPoint = (org.geolatte.geom.Point) Wkt.fromWkt(bd.toWkt());
		org.geolatte.geom.Point wgsPoint = (org.geolatte.geom.Point) Wkt.fromWkt(wgs.toWkt());
		station.setCenterPoint(baiduPoint);
		station.setCenterPointWgs(wgsPoint);

		// 多边形缓冲区
		if ("d".equals(stationRoute.getShapedType())) {
			String wkt = stationRoute.getBufferPolygonWkt();

			stationRoute.setBufferPolygon((Polygon) Wkt.fromWkt(wkt));
			stationRoute.setBufferPolygonWgs(GeoConverter.polygonBd2wgs(wkt));
		}

		lsStationRouteRepository.updateStartZ(stationRoute);
		lsStationRouteRepository.updateStatiouRouteCode(stationRoute);
		CustomBeanUtils.copyPropertiesIgnoredNull(station, station1);
		CustomBeanUtils.copyPropertiesIgnoredNull(stationRoute, stationRoute1);
		repository.save(station1);
		lsStationRouteRepository.save(stationRoute1);
		lsStationRouteRepository.updateStartB(stationRoute);
	}

	@Transactional
	@Override
	public Map<String, Object> saveRoutes(Integer lineId, Integer versions, Integer directions, List<LsStationRoute> stationRoutes, List<LsSectionRoute> sectionRoutes) {
		Map<String, Object> result = new HashMap<>();
		Line line = lineRepository.findById(lineId).get();
		if (line == null) {
			throw new RuntimeException(String.format("未找到ID为%d的线路信息", lineId));
		}
		List<Station> stations = stationRoutesHandle(line, versions, directions, stationRoutes);
		List<Section> sections = sectionRoutesHandle(line, versions, directions, sectionRoutes);

		repository.saveAll(stations);
		sectionRepository.saveAll(sections);
		lsStationRouteRepository.saveAll(stationRoutes);
		lsSectionRouteRepository.saveAll(sectionRoutes);

		return result;
	}

	private List<Station> stationRoutesHandle(Line line, Integer versions, Integer directions, List<LsStationRoute> stationRoutes) {
		List<Station> stations = new ArrayList<>();
		int currentId = repository.stationMaxId(), count = 0;
		for (int len = stationRoutes.size();count < len;) {
			LsStationRoute stationRoute = stationRoutes.get(count);
			stationRoute.setStationMark(count == 0 ? "B" : count == len - 1 ? "E" : "Z");
			count++;
			stationRoute.setLine(line);
			stationRoute.setVersions(versions);
			stationRoute.setDirections(directions);
			stationRoute.setLineCode(line.getLineCode());
			stationRoute.setStationRouteCode(100 * count);
			Station station = stationRoute.getStation();
			station.setId(currentId + count);
			station.setStationCode(station.getId().toString());
			stationRoute.setStationCode(station.getStationCode());
			String wkt = stationRoute.getStation().getCenterPointWkt();
			station.setCenterPoint((org.geolatte.geom.Point) Wkt.fromWkt(wkt));
			station.setCenterPointWgs(GeoConverter.pointBd2wgs(wkt));
			stations.add(station);
		}

		return stations;
	}

	private List<Section> sectionRoutesHandle(Line line, Integer versions, Integer directions, List<LsSectionRoute> sectionRoutes) {
		List<Section> sections = new ArrayList<>();
		int currentId = repository.stationMaxId(), count = 0;
		for (int len = sectionRoutes.size();count < len;) {
			LsSectionRoute sectionRoute = sectionRoutes.get(count++);
			sectionRoute.setLine(line);
			sectionRoute.setVersions(versions);
			sectionRoute.setDirections(directions);
			sectionRoute.setLineCode(line.getLineCode());
			sectionRoute.setSectionrouteCode(100 * count);
			String wkt = sectionRoute.getSection().getBsectionVectorWkt();
			Section section = sectionRoute.getSection();
			section.setBsectionVector((LineString) Wkt.fromWkt(wkt));
			section.setGsectionVector(GeoConverter.lineStringBd2wgs(wkt));
			section.setId(currentId + count);
			section.setSectionCode(section.getId().toString());
			sectionRoute.setSectionCode(section.getSectionCode());
			sections.add(section);
		}

		return sections;
	}

	/**
	 * @Description :TODO(根据坐标点匹配数据库中的站点)
	 * 将匹配站点的名称赋值到新的站点
	 */
	@Override
	public void matchStation(List<Station> stations) {
		Map<String, Object> param = new HashMap<>();
		param.put("destroy_eq", 0);
		List<Station> stations1 = repository.findAll(new CustomerSpecs<>(param));
		for (Station s : stations) {
			Location location = CoordinateConverter.LocationMake(s.getCenterPointWkt());
			Point point = new Point(location.getLng(), location.getLat());
			for (Station s1 : stations1) {
				Location location1 = CoordinateConverter.LocationMake(s1.getCenterPoint().toString());
				Point point1 = new Point(location1.getLng(), location1.getLat());
				if (GeoUtils.getDistance(point, point1) <= 60) {
					s.setStationName(s1.getStationName());
					break;
				}
			}
		}
	}

	@Override
	public List<Station> getStationByName(String stationName) {
		String query = "SELECT a.id,a.station_code,a.station_name,ST_AsText(a.center_point) center_point_wkt,GROUP_CONCAT(c.`name`) pass_lines FROM bsth_c_station a JOIN bsth_c_stationroute b ON a.id = b.station JOIN bsth_c_line c ON b.line = c.id WHERE a.station_name LIKE CONCAT(?,'%') AND b.destroy = 0 AND c.destroy = 0 GROUP BY a.id";
		return jdbcTemplate.query(query, new Object[]{ stationName }, BeanPropertyRowMapper.newInstance(Station.class));
	}
}