引入镜屏和缓存

location-rescue-service/pom.xml

@@ -101,6 +101,32 @@
                </exclusion>
            </exclusions>
        </dependency>
        
        <!-- 缓存 -->
        <dependency>
		   <groupId>com.ai.ipu</groupId>
		   <artifactId>ipu-cache</artifactId>
		   <version>3.1-SNAPSHOT</version>
		   <exclusions>
                <exclusion>
                    <groupId>org.apache.logging.log4j</groupId>
                    <artifactId>log4j-slf4j-impl</artifactId>
                </exclusion>
            </exclusions>
		</dependency>
        
        <!--  IPU 镜屏 -->
        <dependency>
            <groupId>com.ai.ipu.server</groupId>
            <artifactId>iot-stomp-server</artifactId>
            <version>3.1-SNAPSHOT</version>
            <exclusions>
                <exclusion>
                    <groupId>org.apache.logging.log4j</groupId>
                    <artifactId>log4j-slf4j-impl</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
    <repositories>

location-rescue-service/src/main/java/com/ai/bss/location/rescue/LocationRescueApp.java

@@ -7,6 +7,10 @@ import org.springframework.context.annotation.ComponentScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.scheduling.annotation.EnableAsync;
import com.ai.ipu.server.connect.ConnectServerStart;
import com.ai.ipu.server.connect.util.ConnectServerManager;
import com.ai.ipu.server.stomp.WebSocketStompServer;
/**
 * @author zhangfeng
 */
@@ -17,6 +21,11 @@ import org.springframework.scheduling.annotation.EnableAsync;
@SpringBootApplication
public class LocationRescueApp {
    public static void main(String[] args) throws Exception {
    	//注册镜屏服务
		ConnectServerManager.registerServer("websocket.port", new WebSocketStompServer("/stomp"));
		//镜屏服务启动
		ConnectServerStart.start(args, false);
    	
        SpringApplication.run(LocationRescueApp.class, args);
    }
}

location-rescue-service/src/main/java/com/ai/bss/location/rescue/controller/LocationManagementController.java

@@ -0,0 +1,37 @@
package com.ai.bss.location.rescue.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ai.bss.location.rescue.util.MirrorSendDateUtil;
/**
 * 人员定位管理
 * @author konghl@asiainfo.com
 * 2020-11-13
 */
@Controller
@RequestMapping("/locationManagement")
public class LocationManagementController {
	/**
	 * 推送镜屏数据测试
	 * @param msg
	 * @return
	 */
	@ResponseBody
	@RequestMapping(value = "/mirrorSendDataTest", method = RequestMethod.POST)
	public String mirrorSendDataTest(@RequestBody String msg) {
		
		MirrorSendDateUtil.sendData(MirrorSendDateUtil.topic_personnel, msg);
		
		return msg;
	}
	
	
	
	
}

location-rescue-service/src/main/java/com/ai/bss/location/rescue/controller/ReceiveSubscribeController.java

@@ -1,119 +0,0 @@
package com.ai.bss.location.rescue.controller;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ai.bss.location.rescue.service.interfaces.ReceiveSubscribeService;
import com.ai.bss.location.rescue.util.EbcConstant;
import com.alibaba.fastjson.JSONObject;
/**
 * 接收订阅消息
 * @author konghl@asiainfo.com
 * 2020-10-19
 */
@Controller
@RequestMapping("/receiveSubscribe")
public class ReceiveSubscribeController {
	private static final Logger logger = LoggerFactory.getLogger(ReceiveSubscribeController.class);
	@Autowired
	ReceiveSubscribeService receiveSubscribeService;
	/**
	 * 接收定位消息
	 * @param msg
	 * @return
	 */
	@ResponseBody
	@RequestMapping(value = "/receiveIotLocationData", method = RequestMethod.POST)
	public String receiveIotLocationData(@RequestBody String msg) {
		logger.info("已接收定位消息，消息为：" + msg);
		// 解析数据
		JSONObject msgMap = (JSONObject) JSONObject.parse(msg);
		if (msgMap == null || msgMap.isEmpty() || msgMap.get("dataPointValue") == null) {
			logger.info("定位消息的解析数据为空");
			return "dataPointValue is null";
		}
		String msgJson = String.valueOf(msgMap.get("dataPointValue"));
		JSONObject detailInfo = JSONObject.parseObject(msgJson);
		Map<String, Object> detailInfoMap = new HashMap<String, Object>();
		detailInfoMap.put("deviceId", String.valueOf(msgMap.get("resourceId")));// 设备ID
		detailInfoMap.put("deviceNo", String.valueOf(msgMap.get("resourceId")));// 设备编码
		detailInfoMap.put("newDate", detailInfo.getJSONObject("msgDate").getString("value"));// 最新定位时间
		// 经度
		BigDecimal longitudeBigDecimal = detailInfo.getJSONObject("longitude").getBigDecimal("value");
		detailInfoMap.put("longitude",
				longitudeBigDecimal.setScale(EbcConstant.COORD_SCALE, BigDecimal.ROUND_HALF_UP).toString());
		// 纬度
		BigDecimal latitudeBigDecimal = detailInfo.getJSONObject("latitude").getBigDecimal("value");
		detailInfoMap.put("latitude",
				latitudeBigDecimal.setScale(EbcConstant.COORD_SCALE, BigDecimal.ROUND_HALF_UP).toString());
		// 解析并推送定位数据
		receiveSubscribeService.receiveIotLocationData(detailInfoMap);
		return msg;
	}
	/**
	 * 接收报警消息
	 * @param msg
	 * @return
	 */
	@ResponseBody
	@RequestMapping(value = "/receiveIotAlarmData", method = RequestMethod.POST)
	public String receiveIotAlarmData(@RequestBody String msg) {
		logger.info("已接收告警消息，消息为：" + msg);
		// 解析数据
		JSONObject msgMap = (JSONObject) JSONObject.parse(msg);
		if (msgMap == null || msgMap.isEmpty() || msgMap.get("dataPointValue") == null) {
			logger.info("定位消息的解析数据为空");
			return "dataPointValue is null";
		}
		String msgJson = String.valueOf(msgMap.get("dataPointValue"));
		JSONObject detailInfo = JSONObject.parseObject(msgJson);
		Map<String, Object> detailInfoMap = new HashMap<String, Object>();
		detailInfoMap.put("deviceId", String.valueOf(msgMap.get("resourceId")));// 设备ID
		detailInfoMap.put("deviceNo", String.valueOf(msgMap.get("resourceId")));// 设备编码
		detailInfoMap.put("newDate", detailInfo.getJSONObject("msgDate").getString("value"));// 最新定位时间
		// 经度
		BigDecimal longitudeBigDecimal = detailInfo.getJSONObject("longitude").getBigDecimal("value");
		detailInfoMap.put("longitude",
				longitudeBigDecimal.setScale(EbcConstant.COORD_SCALE, BigDecimal.ROUND_HALF_UP).toString());
		// 纬度
		BigDecimal latitudeBigDecimal = detailInfo.getJSONObject("latitude").getBigDecimal("value");
		detailInfoMap.put("latitude",
				latitudeBigDecimal.setScale(EbcConstant.COORD_SCALE, BigDecimal.ROUND_HALF_UP).toString());
		// 报警类型
		detailInfoMap.put("alarmType", detailInfo.getJSONObject("alarmType").getIntValue("value"));
		// 分析并推送报警数据
		receiveSubscribeService.receiveIotAlarmData(detailInfoMap);
		return msg;
	}
}

location-rescue-service/src/main/java/com/ai/bss/location/rescue/service/impl/LocationManagementServiceImpl.java

@@ -0,0 +1,16 @@
package com.ai.bss.location.rescue.service.impl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import com.ai.bss.location.rescue.service.interfaces.LocationManagementService;
@Service
public class LocationManagementServiceImpl implements LocationManagementService {
	Logger logger = LoggerFactory.getLogger(LocationManagementServiceImpl.class);
	
	
	
}	

location-rescue-service/src/main/java/com/ai/bss/location/rescue/service/impl/ReceiveSubscribeServiceImpl.java

@@ -1,160 +0,0 @@
package com.ai.bss.location.rescue.service.impl;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ai.bss.location.rescue.service.interfaces.ReceiveSubscribeService;
import com.ai.bss.location.rescue.service.iotdata.ManageIotInAreaData;
import com.ai.bss.location.rescue.service.iotdata.ManageIotNewAlarmData;
import com.ai.bss.location.rescue.service.iotdata.ManageIotNoCloseAlarmData;
import com.ai.bss.location.rescue.service.iotdata.ManageIotNoInAreaData;
import com.ai.bss.location.rescue.service.iotdata.ManageIotToolData;
@Service
public class ReceiveSubscribeServiceImpl implements ReceiveSubscribeService {
	private static final Logger logger = LoggerFactory.getLogger(ReceiveSubscribeServiceImpl.class);
	@Autowired
	ManageIotToolData manageIotToolData;
	@Autowired
	ManageIotNoInAreaData manageIotNoInAreaData;
	@Autowired
	ManageIotInAreaData manageIotInAreaData;
	@Autowired
	ManageIotNoCloseAlarmData manageIotNoCloseAlarmData;
	@Autowired
	ManageIotNewAlarmData manageIotNewAlarmData;
	private ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
	@Override
	public void receiveIotLocationData(Map<String, Object> params) {
		cachedThreadPool.execute(new Runnable() {
			@Override
			public void run() {
				try {
					logger.debug("启动定位信息新线程：" + Thread.currentThread().getName());
					// 处理定位数据
					executeReceiveIotLocationData(params);
					logger.debug("数据库连接全量提交");
					// SqlSessionManager.commitAll();
				} catch (Exception ex) {
					logger.error(ex.getMessage());
					logger.debug("数据库连接全量回滚");
					// SqlSessionManager.rollbackAll();
				} finally {
					logger.debug("数据库连接全量回收");
					// SqlSessionManager.closeAll();
				}
			}
		});
	}
	@Override
	public void receiveIotAlarmData(Map<String, Object> params) {
		cachedThreadPool.execute(new Runnable() {
			@Override
			public void run() {
				try {
					logger.debug("启动报警信息新线程：" + Thread.currentThread().getName());
					// 处理报警数据
					executeReceiveIotAlarmData(params);
					logger.debug("数据库连接全量提交");
					// SqlSessionManager.commitAll();
				} catch (Exception ex) {
					logger.error(ex.getMessage());
					logger.debug("数据库连接全量回滚");
					// SqlSessionManager.rollbackAll();
				} finally {
					logger.debug("数据库连接全量回收");
					// SqlSessionManager.closeAll();
				}
			}
		});
	}
	/**
	 * 处理定位数据
	 * @param params
	 * @throws Exception 
	 */
	private void executeReceiveIotLocationData(Map<String, Object> params) throws Exception {
		// 获取人员信息
		//Map<String, Object> bindInfoMap = deviceManageDao.queryOneBindUser(String.valueOf(params.get("deviceId")),null);
		Map<String, Object> bindInfoMap = null;
				
		if (bindInfoMap == null) {
			// 1、设备与工具(船)绑定
			manageIotToolData.executeReceiveIotData(params);
			return;
		}
		logger.debug("定位信息的对象为人员: " + bindInfoMap.get("NAME"));
		params.put("userName", bindInfoMap.get("NAME"));
		params.put("userCode", bindInfoMap.get("CODE"));
		// 2、是否为未被救援的定位信息
		if (manageIotNoCloseAlarmData.executeReceiveIotData(params)) {
			return;
		}
		logger.debug("定位信息不是报警人员");
		// 查询定位信息是否在围栏内
		//List<Map<String, Object>> currentAreaInfoList = mapTagManageDao.getInAreaInfo(String.valueOf(params.get("longitude")), String.valueOf(params.get("latitude")));
		List<Map<String, Object>> currentAreaInfoList = null;
		
		if (currentAreaInfoList == null || currentAreaInfoList.isEmpty()) {
			logger.debug("定位信息不在围栏内");
			// 3、不在围栏内
			manageIotNoInAreaData.executeReceiveIotData(params);
		} else {
			logger.debug("定位信息在围栏内,围栏数量:" + currentAreaInfoList.size());
			// 4、在围栏内
			manageIotInAreaData.executeReceiveIotData(params, currentAreaInfoList);
		}
	}
	/**
	 * 处理报警数据
	 * @throws Exception 
	 */
	private void executeReceiveIotAlarmData(Map<String, Object> params) throws Exception {
		// 获取人员信息
		//Map<String, Object> bindInfoMap = deviceManageDao.queryOneBindUser(String.valueOf(params.get("deviceId")),null);
		Map<String, Object> bindInfoMap =null;
		
		if (bindInfoMap == null) {
			// 设备未与人员绑定
			logger.error("定位设备未与人员绑定");
			return;
		}
		logger.debug("报警信息的对象为人员: " + bindInfoMap.get("NAME"));
		params.put("userName", bindInfoMap.get("NAME"));
		params.put("userCode", bindInfoMap.get("CODE"));
		// 1、是否为未被救援的报警信息
		if (manageIotNoCloseAlarmData.executeReceiveIotData(params)) {
			return;
		}
		logger.debug("新增报警信息");
		manageIotNewAlarmData.executeReceiveIotData(params, bindInfoMap);
	}
}

location-rescue-service/src/main/java/com/ai/bss/location/rescue/service/interfaces/LocationManagementService.java

@@ -0,0 +1,10 @@
package com.ai.bss.location.rescue.service.interfaces;
/**
 * 人员定位管理
 * @author konghl@asiainfo.com
 * 2020-11-13
 */
public interface LocationManagementService {
}

location-rescue-service/src/main/java/com/ai/bss/location/rescue/service/interfaces/MapTagManageService.java

@@ -1,14 +1,11 @@
package com.ai.bss.location.rescue.service.interfaces;
import com.ai.bss.components.common.model.PageBean;
import com.ai.bss.person.model.Organization;
import com.ai.bss.worker.model.MapTagInfoDto;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.List;
import java.util.Map;
import com.ai.bss.components.common.model.PageBean;
import com.ai.bss.worker.model.MapTagInfoDto;
public interface MapTagManageService {
	/**

location-rescue-service/src/main/java/com/ai/bss/location/rescue/service/interfaces/ReceiveSubscribeService.java

@@ -1,18 +0,0 @@
package com.ai.bss.location.rescue.service.interfaces;
import java.util.Map;
public interface ReceiveSubscribeService {
	
	/**
	 * 分析处理定位数据
	 * @param dataMap
	 */
	void receiveIotLocationData(Map<String,Object> dataMap);
	
	/**
	 * 分析处理报警数据
	 * @param dataMap
	 */
	void receiveIotAlarmData(Map<String,Object> dataMap);
}

location-rescue-service/src/main/java/com/ai/bss/location/rescue/service/iotdata/ManageIotInAreaData.java

@@ -1,183 +0,0 @@
package com.ai.bss.location.rescue.service.iotdata;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.ai.bss.location.rescue.dao.interfaces.AreaInOutRecordDao;
import com.ai.bss.location.rescue.util.DateUtil;
import com.ai.bss.location.rescue.util.EbcConstant;
import com.ai.bss.location.rescue.util.MirrorSendDateUtil;
@Component
public class ManageIotInAreaData {
	private static final Logger logger = LoggerFactory.getLogger(ManageIotInAreaData.class);
	@Autowired
	AreaInOutRecordDao areaInOutRecordDao;
	public boolean executeReceiveIotData(Map<String,Object> params, List<Map<String, Object>> currentAreaInfoList) throws Exception {
		// 查询人员之前所在围栏信息
		List<Map<String, Object>> beforeAreaMapList = areaInOutRecordDao
				.getBeforeInAreaInfo(String.valueOf(params.get("deviceId")), null);
		// 新进入的围栏
		List<Map<String, String>> inAreaList = new ArrayList<Map<String, String>>();
		if (beforeAreaMapList == null || beforeAreaMapList.isEmpty()) {
			// 之前不在围栏内
			for (Map<String, Object> currentAreaInfoMap : currentAreaInfoList) {
				currentAreaInfoMap.put("inAreaDate", params.get("newDate"));
				Map<String, String> map = new HashMap<String, String>();
				map.put("mapTagId", String.valueOf(currentAreaInfoMap.get("MAP_TAG_ID")));
				map.put("recordLocation", String.valueOf(currentAreaInfoMap.get("MAP_TAG_NAME")));
				inAreaList.add(map);
			}
		} else {
			// 之前已在围栏内：判断围栏是否相同
			for (Map<String, Object> currentAreaInfoMap : currentAreaInfoList) {
				String mapTagId = String.valueOf(currentAreaInfoMap.get("MAP_TAG_ID"));
				boolean flag = false; // 判断围栏ID是否相同
				for (Iterator<Map<String, Object>> iterator = beforeAreaMapList.iterator(); iterator.hasNext();) {
					Map<String, Object> beforeAreaMap = iterator.next();
					if (mapTagId.equals(String.valueOf(beforeAreaMap.get("MAP_TAG_ID")))) {
						// 围栏ID相同:没有出围栏
						currentAreaInfoMap.put("inAreaDate", beforeAreaMap.get("IN_DATE"));
						flag = true;
						iterator.remove();
						break;
					}
				}
				if (!flag) {
					// 围栏ID不同:进入了新围栏
					currentAreaInfoMap.put("inAreaDate", params.get("newDate"));
					Map<String, String> map = new HashMap<String, String>();
					map.put("mapTagId", mapTagId);
					map.put("recordLocation", String.valueOf(currentAreaInfoMap.get("MAP_TAG_NAME")));
					inAreaList.add(map);
				}
			}
		}
		// 推送镜屏
		sendMirrorData(params, currentAreaInfoList);
		// 保存进出围栏记录
		saveOutAreaRecord(params, beforeAreaMapList);
		saveInAreaRecord(params, inAreaList);
		return true;
	}
	private void sendMirrorData(Map<String,Object> params, List<Map<String, Object>> currentAreaInfoList) throws Exception {
		int maxMapTagGrade = 0; // 围栏优先级(电子围栏5>定点3>考勤1、作业1)
		long minInAreaLong = System.currentTimeMillis();// 进入围栏最早的时间戳
		Map<String, Object> sendDataAreaInfo = null;// 用于推送镜屏的围栏信息
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat(DateUtil.NORM_DATETIME_PATTERN);
		for (int i = 0; i < currentAreaInfoList.size(); i++) {
			// 比较优先级
			int mapTagGrade = 1;
			switch (String.valueOf(currentAreaInfoList.get(i).get("MAP_TAG_TYPE"))) {
			case EbcConstant.area_type_exclusion:
				mapTagGrade = 5;
				break;
			case EbcConstant.area_type_temporariness:
				mapTagGrade = 3;
				break;
			case EbcConstant.area_type_job:
			case EbcConstant.area_type_attendance:
				mapTagGrade = 1;
				break;
			default:
				break;
			}
			if (mapTagGrade == maxMapTagGrade) {
				// 比较进入时长时间
				long inAreaLong = simpleDateFormat.parse(String.valueOf(currentAreaInfoList.get(i).get("inAreaDate")))
						.getTime();
				if (inAreaLong < minInAreaLong) {
					minInAreaLong = inAreaLong;
					sendDataAreaInfo = currentAreaInfoList.get(i);
				}
			} else if (mapTagGrade > maxMapTagGrade) {
				maxMapTagGrade = mapTagGrade;
				minInAreaLong = simpleDateFormat.parse(String.valueOf(currentAreaInfoList.get(i).get("inAreaDate")))
						.getTime();
				sendDataAreaInfo = currentAreaInfoList.get(i);
			}
		}
		// 判断是否在违规
		if (maxMapTagGrade == 5) {
			logger.info("镜屏推送进入电子围栏的信息");
			// 进入电子围栏(禁区)，需显示进入时间
			params.put("inDate", sendDataAreaInfo.get("inAreaDate")); // 进入时间
			params.put("locationStatus", EbcConstant.location_status_exclusion); // 定位状态
		} else if (maxMapTagGrade == 3) {
			// 进入定点(限时)，需计算是否超时
			int fixedLong = DateUtil.getDifferenceMinute(String.valueOf(sendDataAreaInfo.get("inAreaDate")),
					String.valueOf(params.get("newDate")));
			if (fixedLong > 0) {
				// 围栏要求定点时间
				int residenceTimeLength = Integer
						.parseInt(String.valueOf(sendDataAreaInfo.get("RESIDENCE_TIME_LENGTH")));
				if (residenceTimeLength <= fixedLong) {
					// 已超时
					logger.info("镜屏推送进入定点(限时)的信息:已超时");
					params.put("locationStatus", EbcConstant.location_status_overtime);// 定位状态
				}
			}
			params.put("fixedLong", fixedLong);// 停留时长
		} else {
			// 进入考勤区、工作区
			params.put("locationStatus", EbcConstant.location_status_normal); // 定位状态
		}
		// 推送镜屏
		MirrorSendDateUtil.sendData(MirrorSendDateUtil.topic_personnel, params);
	}
	private boolean saveOutAreaRecord(Map<String,Object> params, List<Map<String, Object>> outAreaList) throws Exception {
		boolean result = true;
		// 记录离开围栏时间
		if (!outAreaList.isEmpty()) {
			List<String> outAreaIdList = new ArrayList<String>();
			for (Map<String, Object> beforeAreaMap : outAreaList) {
				outAreaIdList.add(String.valueOf(beforeAreaMap.get("RECORD_ID")));
			}
			result = areaInOutRecordDao.updateSameOutTimeAreaOutRecord(String.valueOf(params.get("newDate")), outAreaIdList);
		}
		return result;
	}
	private boolean saveInAreaRecord(Map<String,Object> params, List<Map<String, String>> inAreaList) throws Exception {
		boolean result = true;
		// 记录进入围栏日志
		if (!inAreaList.isEmpty()) {
			result = areaInOutRecordDao.addSameInTimeAreaInRecord(params, inAreaList);
		}
		return result;
	}
}

location-rescue-service/src/main/java/com/ai/bss/location/rescue/service/iotdata/ManageIotNewAlarmData.java

@@ -1,101 +0,0 @@
package com.ai.bss.location.rescue.service.iotdata;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.ai.bss.location.rescue.dao.interfaces.RescueDao;
import com.ai.bss.location.rescue.util.EbcConstant;
import com.ai.bss.location.rescue.util.MirrorSendDateUtil;
@Component
public class ManageIotNewAlarmData {
	private static final Logger logger = LoggerFactory.getLogger(ManageIotNewAlarmData.class);
	@Autowired
	RescueDao rescueDao;
	public boolean executeReceiveIotData(Map<String,Object> params, Map<String, Object> bindInfoMap) throws Exception {
		logger.debug("新增报警信息");
		// 保存报警数据
		String logId = saveAlarmData(params, bindInfoMap);
		// 推送镜屏
		sendMirrorData(params, logId);
		return true;
	}
	private void sendMirrorData(Map<String,Object> params, String logId) {
		// 报警类型
		switch (Integer.parseInt(String.valueOf(params.get("alarmType")))) {
		case EbcConstant.alarm_type_autosos_beidou:
			// 自动报警
			params.put("locationStatus", EbcConstant.location_status_autosos);// 定位状态
			params.put("alarmType", EbcConstant.alarm_type_autosos_ZH);// 报警类型
			break;
		case EbcConstant.alarm_type_jogsos_beidou:
			// 手动报警
			params.put("locationStatus", EbcConstant.location_status_jogsos);// 定位状态
			params.put("alarmType", EbcConstant.alarm_type_jogsos_ZH);// 报警类型
			break;
		case EbcConstant.alarm_type_offline_beidou:
			// 离线
			params.put("locationStatus", EbcConstant.location_status_offline);// 定位状态
			params.put("alarmType", EbcConstant.alarm_type_offline_ZH);// 报警类型
			break;
		default:
			logger.error("告警消息的内容错误");
		}
		params.put("alarmDate", String.valueOf(params.get("newDate")));// 求救时间
		params.put("alarmLong", "0");// 求救时长
		// 未指派救援人员
		params.put("isNewAlarm", EbcConstant.alarm_status_new);
		// 求救记录ID
		params.put("alarmLogId", logId);
		MirrorSendDateUtil.sendData(MirrorSendDateUtil.topic_personnel, params);
	}
	private String saveAlarmData(Map<String,Object> params, Map<String, Object> deviceAndUser) throws Exception {
		Map<String, Object> dataMap = new HashMap<String, Object>();
		dataMap.put("callerId", deviceAndUser.get("CODE")); // 报警人员标识
		dataMap.put("deviceId", params.get("deviceId")); // 终端标识
		dataMap.put("partyType", deviceAndUser.get("TYPE")); // 参与人类型
		dataMap.put("partyCode", deviceAndUser.get("CODE")); // 参与人业务编码
		dataMap.put("partyName", deviceAndUser.get("NAME")); // 参与人名称
		dataMap.put("alarmType", params.get("alarmType")); // 告警类型
		dataMap.put("longitude", params.get("longitude")); // 报警经度
		dataMap.put("latitude", params.get("latitude")); // 报警纬度
		dataMap.put("callerDate", params.get("newDate")); // 报警时间
		dataMap.put("lastLocationDate", params.get("newDate")); // 最后定位时间
		// 获取当前所在围栏列表
		//List<Map<String, Object>> currentAreaInfoList = mapTagManageDao.getInAreaInfo(String.valueOf(params.get("longitude")),String.valueOf(params.get("latitude")));
		List<Map<String, Object>> currentAreaInfoList = null;
				
		// 报警位置
		if (currentAreaInfoList == null || currentAreaInfoList.isEmpty()) {
			dataMap.put("callerLocation", "");
		} else {
			StringBuffer mapTagName = new StringBuffer(String.valueOf(currentAreaInfoList.get(0).get("MAP_TAG_NAME")));
			for (int i = 1; i < currentAreaInfoList.size(); i++) {
				mapTagName.append(",").append(String.valueOf(currentAreaInfoList.get(i).get("MAP_TAG_NAME")));
			}
			dataMap.put("callerLocation", mapTagName.toString());
		}
		return rescueDao.addRescueLog(dataMap);
	}
}

location-rescue-service/src/main/java/com/ai/bss/location/rescue/service/iotdata/ManageIotNoCloseAlarmData.java

@@ -1,114 +0,0 @@
package com.ai.bss.location.rescue.service.iotdata;
import java.text.ParseException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.ai.bss.location.rescue.dao.interfaces.RescueDao;
import com.ai.bss.location.rescue.util.DateUtil;
import com.ai.bss.location.rescue.util.EbcConstant;
import com.ai.bss.location.rescue.util.MirrorSendDateUtil;
@Component
public class ManageIotNoCloseAlarmData {
	private static final Logger logger = LoggerFactory.getLogger(ManageIotNoCloseAlarmData.class);
	@Autowired
	RescueDao rescueDao;
	public boolean executeReceiveIotData(Map<String,Object> params) throws Exception {
		// 查询是否为未被救援的人员
		List<Map<String, Object>> alarmList = rescueDao.queryNoCloseRescueLog(String.valueOf(params.get("deviceId")));
		if (alarmList == null || alarmList.isEmpty()) {
			return false;
		}
		//判断是救援者还是求救者
		if (String.valueOf(params.get("userCode")).equals(String.valueOf(alarmList.get(0).get("RESCUER_CODE")))) {
			//救援者
			logger.info("定位信息为救援人员: " + String.valueOf(params.get("userName")));
			
			// 推送镜屏
			sendRescuerMirrorData(params, alarmList.get(0));
			
		}else {
			//求救者
			logger.info("定位信息为已求救的人员: " + String.valueOf(params.get("userName")));
			
			// 推送镜屏
			sendAlarmMirrorData(params, alarmList.get(0));
			// 修改最后定位时间
			updateLastLocationRecord(params, alarmList.get(0));
		}
		return true;
	}
	/**
	 * 推送救援者的镜屏信息
	 * @param params
	 * @param alarmMap
	 * @throws ParseException
	 */
	private void sendRescuerMirrorData(Map<String,Object> params, Map<String, Object> alarmMap) throws ParseException {
		params.put("locationStatus", EbcConstant.location_status_rescuer);// 定位状态
		params.put("alarmDeviceId", String.valueOf(alarmMap.get("DEVICE_ID"))); //求救者的设备ID
		
		// 推送镜屏
		MirrorSendDateUtil.sendData(MirrorSendDateUtil.topic_personnel, params);
	}
	
	/**
	 * 推送求救者的镜屏信息
	 * @param params
	 * @param alarmMap
	 * @throws Exception 
	 */
	private void sendAlarmMirrorData(Map<String,Object> params, Map<String, Object> alarmMap) throws Exception {
		// 求救时间
		String alarmDate = String.valueOf(alarmMap.get("CALLER_DATE"));
		params.put("alarmDate", DateUtil.formatStrDate(alarmDate));
		// 计算求救时长
		params.put("alarmLong", DateUtil.getDifferenceMinute(alarmDate, String.valueOf(params.get("newDate"))));
		// 报警类型
		String alarmType = String.valueOf(alarmMap.get("ALARM_TYPE"));
		params.put("alarmType", alarmType);
		if (EbcConstant.alarm_type_jogsos_ZH.equals(alarmType)) {
			params.put("locationStatus", EbcConstant.location_status_jogsos);// 定位状态
		} else if (EbcConstant.alarm_type_autosos_ZH.equals(alarmType)) {
			params.put("locationStatus", EbcConstant.location_status_autosos);// 定位状态
		}
		if (alarmMap.get("RESCUERS_ID")==null) {
			//未指派救援人员
			params.put("isNewAlarm", EbcConstant.alarm_status_needassign);
		}else {
			//已指派救援人员
			params.put("isNewAlarm", EbcConstant.alarm_status_needclose);
			params.put("rescuerDeviceId", String.valueOf(alarmMap.get("RESCUER_DEVICE_ID"))); //救援者的设备ID
		}
		
		//求救记录ID
		params.put("alarmLogId", alarmMap.get("LOG_ID"));
		MirrorSendDateUtil.sendData(MirrorSendDateUtil.topic_personnel, params);
	}
	private boolean updateLastLocationRecord(Map<String,Object> params, Map<String, Object> alarmMap) throws Exception {
		Map<String, Object> dataMap = new HashMap<String, Object>();
		dataMap.put("LOG_ID", alarmMap.get("LOG_ID")); // 日志ID
		dataMap.put("LAST_LOCATION_DATE", params.get("newDate")); // 最后定位时间
		return rescueDao.modifyRescueRecord(dataMap);
	}
}

location-rescue-service/src/main/java/com/ai/bss/location/rescue/service/iotdata/ManageIotNoInAreaData.java

@@ -1,60 +0,0 @@
package com.ai.bss.location.rescue.service.iotdata;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.ai.bss.location.rescue.dao.interfaces.AreaInOutRecordDao;
import com.ai.bss.location.rescue.util.EbcConstant;
import com.ai.bss.location.rescue.util.MirrorSendDateUtil;
@Component
public class ManageIotNoInAreaData {
	private static final Logger logger = LoggerFactory.getLogger(ManageIotNoInAreaData.class);
	@Autowired
	AreaInOutRecordDao areaInOutRecordDao;
	
	public boolean executeReceiveIotData(Map<String,Object> params) throws Exception {
		// 推送镜屏数据
		sendMirrorData(params);
		// 查询人员之前所在围栏信息
		List<Map<String, Object>> beforeAreaMapList = areaInOutRecordDao
				.getBeforeInAreaInfo(String.valueOf(params.get("deviceId")), null);
		if (beforeAreaMapList == null || beforeAreaMapList.isEmpty()) {
			logger.info("定位信息没有进入围栏");
			return true;
		}
		logger.info("定位信息已离开围栏");
		// 记录出围栏的信息
		updateOutAreaRecord(params, beforeAreaMapList);
		return true;
	}
	private void sendMirrorData(Map<String,Object> params) {
		params.put("locationStatus", EbcConstant.location_status_normal);// 定位状态
		MirrorSendDateUtil.sendData(MirrorSendDateUtil.topic_personnel, params);
	}
	private boolean updateOutAreaRecord(Map<String,Object> params, List<Map<String, Object>> beforeAreaMapList) throws Exception {
		List<String> recordIdList = new ArrayList<String>();
		for (Map<String, Object> beforeAreaMap : beforeAreaMapList) {
			recordIdList.add(String.valueOf(beforeAreaMap.get("RECORD_ID")));
		}
		// 记录离开围栏时间
		return areaInOutRecordDao.updateSameOutTimeAreaOutRecord(String.valueOf(params.get("newDate")), recordIdList);
	}
}

location-rescue-service/src/main/java/com/ai/bss/location/rescue/service/iotdata/ManageIotToolData.java

@@ -1,42 +0,0 @@
package com.ai.bss.location.rescue.service.iotdata;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import com.ai.bss.location.rescue.util.MirrorSendDateUtil;
@Component
public class ManageIotToolData {
	private static final Logger logger = LoggerFactory.getLogger(ManageIotToolData.class);
	public boolean executeReceiveIotData(Map<String,Object> params) throws Exception {
		//Map<String, Object> bindInfoMap = deviceManageDao.queryOneBindShip(String.valueOf(params.get("deviceId")), null);
		Map<String, Object> bindInfoMap = null;
				
		if (bindInfoMap == null) {
			// 设备未绑定
			logger.error("定位设备未绑定");
			return false;
		}
		logger.info("定位信息的对象为船舶: " + bindInfoMap.get("NAME"));
		// 推送镜屏
		sendMirrorData(params, bindInfoMap);
		return true;
	}
	private void sendMirrorData(Map<String,Object> params, Map<String, Object> bindInfoMap) {
		params.put("shipName", bindInfoMap.get("NAME"));
		params.put("shipCode", bindInfoMap.get("CODE"));
		MirrorSendDateUtil.sendData(MirrorSendDateUtil.topic_ship, params);
	}
}

location-rescue-service/src/main/java/com/ai/bss/location/rescue/util/MirrorSendDateUtil.java

@@ -1,29 +1,39 @@
package com.ai.bss.location.rescue.util;
import com.ai.bss.location.rescue.controller.MapTagManageController;
import com.ai.ipu.server.connect.ps.EventChannelTool;
import com.ai.ipu.server.connect.ps.EventChannelTool.PublisherEvent;
import com.ai.ipu.server.connect.ps.ISubscriber;
import com.ai.ipu.server.connect.ps.impl.Publisher;
import com.alibaba.fastjson.JSON;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
 * 镜屏推送消息
 * @author konghl@asiainfo.com
 * 2020-10-21
 */
public class MirrorSendDateUtil {
	private static final Logger logger = LoggerFactory.getLogger(MirrorSendDateUtil.class);
	
	// 人员定位topic
	public static final String topic_personnel = "personnel";
	// 船舶定位topic
	public static final String topic_ship = "ship";
	public static void sendData(String topic, Map<String,Object> params) {
/*		String msg = JSON.toJSONString(params);
	public static void sendData(String topic, String msg) {
		logger.debug("推送镜屏数据: topic="+topic+" , data=" + msg);
		
		if (!EventChannelTool.isExistSubscriber(topic)) {
			// 如果没有订阅 先不管
			return;
		}
		
		// 你发送的内容
		final Publisher publisher = new Publisher(topic);
		PublisherEvent<?> publisherEvent = new PublisherEvent<String>(msg) {
@@ -32,6 +42,6 @@ public class MirrorSendDateUtil {
				// 可记录消息发布后的统计日志
			}
		};
		publisher.publish(topic, publisherEvent);*/
		publisher.publish(topic, publisherEvent);
	}
}

location-rescue-service/src/main/resources/ipu-cache.xml

@@ -0,0 +1,114 @@
<?xml version = '1.0' encoding = 'UTF-8'?>
<caches>
	<cache name="ssn" type="redis">
		<servers>
	        <!-- 如果不是cluster，则只使用第一个redis -->
	        <server ip="121.42.183.206" port="7101" />
	        <server ip="121.42.183.206" port="7102" />
	        <server ip="121.42.183.206" port="7103" />
	        <server ip="121.42.183.206" port="7104" />
	        <server ip="121.42.183.206" port="7105" />
	        <server ip="121.42.183.206" port="7106" />
	    </servers>
		<!-- 客户端类型:Jedis,JedisCluster -->
	    <config name="clientType" value="JedisCluster"/>
	    <!-- 访问redis的密码，可以为空 -->
	    <config name="auth" value="Ipu@321!"/>
	    <!-- redis池的可用连接实例的最大数目，缺省为8 -->
	    <config name="poolSize" value="10"/>
	    <!-- redis池最多有多少个状态为idle(空闲的)的jedis实例，缺省为8,空闲连接大于这个数会进行回收 -->
	    <config name="maxIdle"/>
	    <!-- 最小空闲数，空闲连接小于这个数会建立新的连接，缺省为0 -->
	    <config name="minIdle"/>
	    <!-- 等待Response超时时间,默认2000ms -->
	    <config name="soTimeout"/>
	    <!-- 连接Redis Server超时时间,默认2000ms -->
	    <config name="connTimeout"/>
	    <!-- 出现异常最大重试次数 -->
	    <config name="maxAttempts"/>
	</cache>
	
	<cache name="SSN_CACHE" type="redis">
		<servers>
	        <!-- 如果不是cluster，则只使用第一个redis -->
	        <server ip="121.42.183.206" port="7101" />
	        <server ip="121.42.183.206" port="7102" />
	        <server ip="121.42.183.206" port="7103" />
	        <server ip="121.42.183.206" port="7104" />
	        <server ip="121.42.183.206" port="7105" />
	        <server ip="121.42.183.206" port="7106" />
	    </servers>
		<!-- 客户端类型:Jedis,JedisCluster -->
	    <config name="clientType" value="JedisCluster"/>
	    <!-- 访问redis的密码，可以为空 -->
	    <config name="auth" value="Ipu@321!"/>
	    <!-- redis池的可用连接实例的最大数目，缺省为8 -->
	    <config name="poolSize" value="10"/>
	    <!-- redis池最多有多少个状态为idle(空闲的)的jedis实例，缺省为8,空闲连接大于这个数会进行回收 -->
	    <config name="maxIdle"/>
	    <!-- 最小空闲数，空闲连接小于这个数会建立新的连接，缺省为0 -->
	    <config name="minIdle"/>
	    <!-- 等待Response超时时间,默认2000ms -->
	    <config name="soTimeout"/>
	    <!-- 连接Redis Server超时时间,默认2000ms -->
	    <config name="connTimeout"/>
	    <!-- 出现异常最大重试次数 -->
	    <config name="maxAttempts"/>
	</cache>
	
	<cache name="client_route" type="redis">
		<servers>
	        <!-- 如果不是cluster，则只使用第一个redis -->
	        <server ip="121.42.183.206" port="7101" />
	        <server ip="121.42.183.206" port="7102" />
	        <server ip="121.42.183.206" port="7103" />
	        <server ip="121.42.183.206" port="7104" />
	        <server ip="121.42.183.206" port="7105" />
	        <server ip="121.42.183.206" port="7106" />
	    </servers>
		<!-- 客户端类型:Jedis,JedisCluster -->
	    <config name="clientType" value="JedisCluster"/>
	    <!-- 访问redis的密码，可以为空 -->
	    <config name="auth" value="Ipu@321!"/>
	    <!-- redis池的可用连接实例的最大数目，缺省为8 -->
	    <config name="poolSize" value="10"/>
	    <!-- redis池最多有多少个状态为idle(空闲的)的jedis实例，缺省为8,空闲连接大于这个数会进行回收 -->
	    <config name="maxIdle"/>
	    <!-- 最小空闲数，空闲连接小于这个数会建立新的连接，缺省为0 -->
	    <config name="minIdle"/>
	    <!-- 等待Response超时时间,默认2000ms -->
	    <config name="soTimeout"/>
	    <!-- 连接Redis Server超时时间,默认2000ms -->
	    <config name="connTimeout"/>
	    <!-- 出现异常最大重试次数 -->
	    <config name="maxAttempts"/>
	</cache>
	
	<cache name="pushServer_route" type="redis">
		<servers>
	        <!-- 如果不是cluster，则只使用第一个redis -->
	        <server ip="121.42.183.206" port="7101" />
	        <server ip="121.42.183.206" port="7102" />
	        <server ip="121.42.183.206" port="7103" />
	        <server ip="121.42.183.206" port="7104" />
	        <server ip="121.42.183.206" port="7105" />
	        <server ip="121.42.183.206" port="7106" />
	    </servers>
		<!-- 客户端类型:Jedis,JedisCluster -->
	    <config name="clientType" value="JedisCluster"/>
	    <!-- 访问redis的密码，可以为空 -->
	    <config name="auth" value="Ipu@321!"/>
	    <!-- redis池的可用连接实例的最大数目，缺省为8 -->
	    <config name="poolSize" value="10"/>
	    <!-- redis池最多有多少个状态为idle(空闲的)的jedis实例，缺省为8,空闲连接大于这个数会进行回收 -->
	    <config name="maxIdle"/>
	    <!-- 最小空闲数，空闲连接小于这个数会建立新的连接，缺省为0 -->
	    <config name="minIdle"/>
	    <!-- 等待Response超时时间,默认2000ms -->
	    <config name="soTimeout"/>
	    <!-- 连接Redis Server超时时间,默认2000ms -->
	    <config name="connTimeout"/>
	    <!-- 出现异常最大重试次数 -->
	    <config name="maxAttempts"/>
	</cache>
</caches>