package com.ld.igds.sec.manager;
|
|
import com.ld.igds.camera.ApiCameraManager;
|
import com.ld.igds.camera.CameraUtil;
|
import com.ld.igds.camera.data.ApiCameraResp;
|
import com.ld.igds.common.CoreCommonService;
|
import com.ld.igds.common.CoreDeviceService;
|
import com.ld.igds.common.CoreSerService;
|
import com.ld.igds.common.dto.DepotSerData;
|
import com.ld.igds.constant.BizType;
|
import com.ld.igds.constant.DeviceType;
|
import com.ld.igds.constant.RespCodeEnum;
|
import com.ld.igds.data.PageResponse;
|
import com.ld.igds.door.dto.DoorAccessData;
|
import com.ld.igds.door.dto.DoorAccessParam;
|
import com.ld.igds.door.service.CoreDoorService;
|
import com.ld.igds.file.CoreFileService;
|
import com.ld.igds.io.RemoteControlService;
|
import com.ld.igds.io.RemoteManager;
|
import com.ld.igds.io.constant.OrderRespEnum;
|
import com.ld.igds.io.request.DeviceControlRequest;
|
import com.ld.igds.io.request.ExeDevice;
|
import com.ld.igds.io.response.DeviceControlResponse;
|
import com.ld.igds.common.DepotStatusService;
|
import com.ld.igds.models.Depot;
|
import com.ld.igds.models.Device;
|
import com.ld.igds.models.DeviceSer;
|
import com.ld.igds.models.DoorSensor;
|
import com.ld.igds.order.ExeOrderService;
|
import com.ld.igds.order.data.ExeRequest;
|
import com.ld.igds.sec.dto.*;
|
import com.ld.igds.camera.data.ApiCameraData;
|
import com.ld.igds.sec.service.CoreSecCameraService;
|
import com.ld.igds.sec.service.CoreSecFireService;
|
import com.ld.igds.sec.service.CoreSecPatrolService;
|
import com.ld.igds.util.ContextUtil;
|
import com.ld.igds.util.DateUtil;
|
import com.ld.igds.util.FfmpegUtil;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Component;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.stream.Collectors;
|
|
/**
|
* 安防模块
|
*/
|
@Slf4j
|
@Component
|
public class SecManager {
|
|
@Autowired
|
private CoreCommonService coreCommonService;
|
@Autowired
|
private CoreDeviceService coreDeviceService;
|
@Autowired
|
private ExeOrderService exeOrderService;
|
@Autowired
|
private CoreSerService coreSerService;
|
@Autowired
|
private CoreSecCameraService secCameraService;
|
@Autowired
|
private CoreSecFireService secFileService;
|
@Autowired
|
private RemoteManager remoteManager;
|
@Autowired
|
private CoreDoorService coreDoorService;
|
@Autowired
|
private DepotStatusService authCheckService;
|
@Autowired
|
private CoreSecPatrolService patrolService;
|
@Autowired
|
private CoreFileService fileService;
|
@Autowired
|
private ApiCameraManager apiCameraManager;
|
|
private RemoteControlService remoteControlService;
|
|
/**
|
* 获取手动通风仓库的设备列表
|
*
|
* @param param
|
* @return
|
*/
|
public PageResponse<List<Device>> listDevice(SecurityParam param) {
|
|
if (null == param.getCompanyId()) {
|
param.setCompanyId(ContextUtil.getCompanyId());
|
}
|
|
// 根据仓库缓存获取相同建筑物下的仓库集合
|
List<Depot> depotList = coreCommonService.getCacheCommonBuildingDepot(
|
param.getCompanyId(), param.getDepotId());
|
// 获取ID信息
|
List<String> depotIds = depotList.stream().map(Depot::getId)
|
.collect(Collectors.toList());
|
|
// 根据仓库多个ID获取仓库与分机的关系数据
|
List<DepotSerData> depotSerDataList = coreCommonService
|
.getCacheDepotSerByDepots(param.getCompanyId(), depotIds);
|
if (null == depotSerDataList) {
|
log.error("没有获取到当前仓库{}的相关分机，执行失败。", param.getDepotId());
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
"没有获取到当前仓的分机信息，执行被拒绝！");
|
}
|
|
List<Device> listAll = new ArrayList<>();// 分机的所有设备
|
List<Device> tempList;
|
for (DepotSerData depotSerData : depotSerDataList) {
|
tempList = coreDeviceService.getCacheDeviceBySerId(
|
param.getCompanyId(), depotSerData.getSerId());
|
listAll.addAll(tempList);
|
}
|
|
if (listAll.isEmpty()) {
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
"当前仓库没有获取到设备配置信息，请联管理员！！");
|
}
|
|
// 循环遍历出当前仓的
|
List<Device> listResult = listAll
|
.stream()
|
.filter(item -> item.getType().equals(
|
DeviceType.TYPE_0E.getCode()))
|
.collect(Collectors.toList());
|
|
if (null == listResult || listResult.isEmpty()) {
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
"当前仓库没有获取到气调设备信息，请联系管理员！！");
|
}
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000, listResult);
|
}
|
|
/**
|
* 设备操作接口管理
|
*
|
* @param param
|
* @return
|
*/
|
public DeviceControlResponse controlDevice(SecurityParam param) {
|
if (null == param.getCompanyId()) {
|
param.setCompanyId(ContextUtil.getCompanyId());
|
}
|
|
List<ExeDevice> deviceList = param.getDeviceList();
|
|
if (null == deviceList || deviceList.isEmpty()) {
|
return new DeviceControlResponse(
|
OrderRespEnum.ORDER_ERROR.getCode(),
|
"没有获取到需要被执行的设备信息，请重新选择执行");
|
}
|
|
// 添加逻辑验证
|
String msg = authCheckService.checkDepotStatus(param.getCompanyId(),
|
param.getDepotId(), deviceList);
|
if (null != msg) {
|
return new DeviceControlResponse(
|
OrderRespEnum.ORDER_ERROR.getCode(), msg);
|
}
|
|
// 如果是单个设备
|
if (deviceList.size() == 1) {
|
return controlDevice2(param);
|
}
|
|
// 如果多个设备，需要对设备按分机进行分组
|
Map<String, List<ExeDevice>> deviceMap = deviceList.stream().collect(
|
Collectors.groupingBy(ExeDevice::getSerId));
|
String temp = "";
|
DeviceControlResponse tempResp;
|
for (String key : deviceMap.keySet()) {
|
param.setDeviceList(deviceMap.get(key));
|
tempResp = controlDevice2(param);
|
if (OrderRespEnum.ORDER_ERROR.getCode().equals(tempResp.getCode())) {
|
temp += tempResp.getMsg();
|
}
|
}
|
|
if ("".equals(temp)) {
|
return new DeviceControlResponse(OrderRespEnum.ORDER_SUCCESS);
|
}
|
|
return new DeviceControlResponse(OrderRespEnum.ORDER_ERROR.getCode(),
|
"发送存在异常：" + temp);
|
}
|
|
/**
|
* 单个分机设备操作接口管理
|
*
|
* @param param
|
* @return
|
*/
|
public DeviceControlResponse controlDevice2(SecurityParam param) {
|
if (null == param.getCompanyId()) {
|
param.setCompanyId(ContextUtil.getCompanyId());
|
}
|
List<ExeDevice> deviceList = param.getDeviceList();
|
|
if (null == deviceList || deviceList.isEmpty()) {
|
return new DeviceControlResponse(
|
OrderRespEnum.ORDER_ERROR.getCode(),
|
"没有获取到需要被执行的设备信息，请重新选择执行");
|
}
|
String serId = deviceList.get(0).getSerId();
|
|
// 获取分机信息
|
DeviceSer deviceSer = coreSerService.getCacheSer(param.getCompanyId(),
|
serId);
|
|
DeviceControlRequest request = new DeviceControlRequest();
|
request.setDepotId(param.getDepotId());
|
request.setCompanyId(param.getCompanyId());
|
request.setDeviceList(deviceList);
|
request.setBizType(BizType.SECURITY.getCode());
|
request.setIp(deviceSer.getIp());
|
request.setPort(deviceSer.getPort());
|
request.setSerId(serId);
|
request.setControlModel(deviceSer.getControlModel());
|
request.setRealNum(deviceList.size());
|
|
// 避免重复发送命令和添加操作记录
|
ExeRequest exeRequest = new ExeRequest(request);
|
exeRequest.setRepeatTag(true);
|
exeOrderService.checkExecute(exeRequest);
|
|
// 添加开门记录
|
addDoorRecord(request);
|
|
remoteControlService = remoteManager.getRemoteControlService(deviceSer
|
.getProtocol());
|
|
if (null == remoteControlService) {
|
return new DeviceControlResponse(
|
OrderRespEnum.ORDER_ERROR.getCode(), "系统没有"
|
+ deviceSer.getProtocol() + "的协议实现，执行被拒绝！");
|
}
|
|
DeviceControlResponse response = remoteControlService
|
.deviceControl(request);
|
|
if (OrderRespEnum.ORDER_SUCCESS.getCode().equals(response.getCode())) {
|
exeOrderService.addCache(exeRequest);
|
}
|
|
return response;
|
}
|
|
public DeviceControlResponse queryDeviceStatus(SecurityParam param) {
|
if (null == param.getCompanyId()) {
|
param.setCompanyId(ContextUtil.getCompanyId());
|
}
|
if (null == param.getDepotId()) {
|
return new DeviceControlResponse(
|
OrderRespEnum.ORDER_ERROR.getCode(), "系统没有获取到仓库参数，执行被拒绝。");
|
}
|
// 根据仓库多个ID获取仓库与分机的关系数据
|
List<String> depotIds = new ArrayList<String>();
|
depotIds.add(param.getDepotId());
|
List<DepotSerData> depotSerDataList = coreCommonService
|
.getCacheDepotSerByDepots(param.getCompanyId(), depotIds);
|
|
if (null == depotSerDataList) {
|
return new DeviceControlResponse(
|
OrderRespEnum.ORDER_ERROR.getCode(),
|
"当前仓库没有匹配的控制柜信息，执行被拒绝。");
|
}
|
|
DeviceControlResponse response = new DeviceControlResponse(
|
OrderRespEnum.ORDER_SUCCESS.getCode(), "命令发送成功！");
|
|
DeviceSer deviceSer;
|
DeviceControlRequest request;
|
for (DepotSerData depotSerData : depotSerDataList) {
|
deviceSer = coreSerService.getCacheSer(param.getCompanyId(),
|
depotSerData.getSerId());
|
|
if (null == deviceSer) {
|
log.info("根据仓库{}获取设备状态，分机编码{}的分机不存在，取消执行。", param.getDepotId(),
|
depotSerData.getSerId());
|
continue;
|
}
|
|
request = new DeviceControlRequest();
|
request.setDepotId(param.getDepotId());
|
request.setCompanyId(param.getCompanyId());
|
request.setBizType(BizType.SECURITY.getCode());
|
request.setIp(deviceSer.getIp());
|
request.setPort(deviceSer.getPort());
|
request.setSerId(deviceSer.getId());
|
|
remoteControlService = remoteManager
|
.getRemoteControlService(deviceSer.getProtocol());
|
|
if (null == remoteControlService) {
|
return new DeviceControlResponse(
|
OrderRespEnum.ORDER_ERROR.getCode(), "系统没有"
|
+ deviceSer.getProtocol() + "的协议实现，执行被拒绝！");
|
}
|
|
response = remoteControlService.queryStatus(request);
|
}
|
|
return response;
|
}
|
|
public SecCameraDto getCameraById(String companyId, String cameraId,
|
boolean flag) {
|
|
if (StringUtils.isEmpty(cameraId))
|
return null;
|
|
SecCameraDto dto = secCameraService.getCameraById(companyId, cameraId);
|
|
if (flag) {
|
dto.setMediaAddr(CameraUtil.updateMediaAddr2(dto, false));
|
}
|
|
log.debug("视频信息={}", dto.toString());
|
return dto;
|
}
|
|
public List<SecCameraDto> listCamera(String deptId, String companyId) {
|
List<SecCameraDto> list = secCameraService.getAllCacheCamera(companyId);
|
|
if (null == list || list.isEmpty())
|
return list;
|
|
if (null == deptId)
|
return list;
|
|
return list.stream().filter(item -> deptId.equals(item.getDeptId()))
|
.collect(Collectors.toList());
|
|
}
|
|
public PageResponse<String> updatePos(List<SecurityParam> params) {
|
|
if (null == params || params.isEmpty()) {
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
"当前没有需要执行的信息！");
|
}
|
|
for (SecurityParam param : params) {
|
secCameraService.updatePos(param);
|
}
|
|
secCameraService.refreshCache(ContextUtil.getCompanyId());
|
return new PageResponse<>(RespCodeEnum.CODE_0000, "执行成功！！");
|
}
|
|
public List<SecFireDto> listFire(String deptId, String companyId) {
|
List<SecFireDto> list = secFileService.getAllFire(companyId);
|
|
if (null == list || list.isEmpty())
|
return list;
|
|
if (null == deptId)
|
return list;
|
|
return list.stream().filter(item -> deptId.equals(item.getDeptId()))
|
.collect(Collectors.toList());
|
|
}
|
|
public PageResponse<String> updateFirePos(List<SecurityParam> params) {
|
|
if (null == params || params.isEmpty()) {
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
"当前没有需要执行的信息！");
|
}
|
|
for (SecurityParam param : params) {
|
secFileService.updateFirePos(param);
|
}
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000, "执行成功！！");
|
}
|
|
public SecCameraDto getPlayAddr(SecCameraDto param) {
|
|
if (StringUtils.isEmpty(param.getId())) {
|
log.error("没有获取到ID"+ param.toString());
|
return null;
|
}
|
if(StringUtils.isEmpty(param.getCompanyId())){
|
param.setCompanyId(ContextUtil.getCompanyId());
|
}
|
// 根据id获取设备信息
|
SecCameraDto camera = secCameraService.getCameraById(param.getCompanyId(), param.getId());
|
if(camera == null){
|
log.error("缓存中没有获取到摄像头信息"+ param.toString());
|
return null;
|
}
|
|
//若为海康流媒体，使用插件播放则直接返回摄像头信息
|
if (CameraUtil.PLAY_TYPE_MEDIA_HIK.equals(camera.getPlayType())) {
|
camera.setPlayAddr(CameraUtil.PLAY_TYPE_MEDIA_HIK);
|
return camera;
|
}
|
|
//通过统一入口获取播放地址
|
ApiCameraData apiCameraData = new ApiCameraData();
|
apiCameraData.setCompanyId(camera.getCompanyId());
|
apiCameraData.setSn(camera.getSn());
|
apiCameraData.setCameraId(camera.getId());
|
apiCameraData.setPlayType(camera.getPlayType());
|
apiCameraData.setMediaAddr(CameraUtil.updateMediaAddr2(camera, false));
|
|
ApiCameraResp result = apiCameraManager.getApiCameraService(camera.getPlayType()).getPlayAddr(apiCameraData);
|
log.debug("视频播放地址为:"+result.toString());
|
if (null != result && ApiCameraResp.CODE_SUCCESS.equals(result.getCode())) {
|
camera.setPlayAddr(result.getPlayAddr());
|
camera.setPlayIframe(result.getPlayIframe());
|
return camera;
|
}
|
|
return null;
|
}
|
|
/**
|
* 云台控制
|
* @param param
|
* @return
|
*/
|
public ApiCameraResp ptzMedia(ApiCameraData param) {
|
|
if(StringUtils.isEmpty(param.getCompanyId())){
|
param.setCompanyId(ContextUtil.getCompanyId());
|
}
|
return apiCameraManager.getApiCameraService(param.getPlayType()).ptzMedia(param);
|
}
|
|
/**
|
* 流媒体保活
|
* @param param
|
* @return
|
*/
|
public ApiCameraResp keepAlive(ApiCameraData param) {
|
|
return apiCameraManager.getApiCameraService(param.getPlayType()).keepAlive(param);
|
}
|
|
/**
|
* 预置位设置
|
* @param param
|
* @return
|
*/
|
public ApiCameraResp ptzPreset(ApiCameraData param) {
|
|
return apiCameraManager.getApiCameraService(param.getPlayType()).ptzPreset(param);
|
}
|
|
/**
|
* 验证门禁权限码
|
*
|
* @param token
|
* @param depotId
|
* @return
|
*/
|
public PageResponse<String> checkToken(String token, String depotId,
|
String deptId, String companyId) {
|
DoorAccessParam param = new DoorAccessParam();
|
param.setCompanyId(companyId);
|
param.setDeptId(deptId);
|
param.setToken(token);
|
DoorAccessData doorToken = coreDoorService.getDoorAccess(param);
|
// 判断权限码是否存在
|
if (doorToken == null) {
|
return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
|
"权限码不存在，请重试！");
|
}
|
|
// 判断权限码是否失效
|
if (doorToken.getEnd() != null && doorToken.getEnd().before(new Date())) {
|
return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
|
"权限码已失效，请重新申请！");
|
}
|
|
// 判断操作仓库是否有权限
|
if (StringUtils.isNotEmpty(depotId)) {
|
if (!"ALL".equals(doorToken.getDepotId())
|
&& !doorToken.getDepotId().equals(depotId)) {
|
return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
|
"您没有操作此仓库门禁的权限！！");
|
}
|
}
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "验证成功！！");
|
}
|
|
/**
|
* 添加门禁操作记录
|
*
|
* @param request
|
*/
|
private void addDoorRecord(DeviceControlRequest request) {
|
// TODO
|
return;
|
}
|
|
/**
|
* 根据id获取巡更记录
|
*
|
* @param patrolId
|
*/
|
public List<SecPatrolRecordDto> getPatrolRecord(String patrolId) {
|
|
if (StringUtils.isEmpty(patrolId)) {
|
return null;
|
}
|
|
SecPatrolRecordParam param = new SecPatrolRecordParam();
|
param.setId(patrolId);
|
List<SecPatrolRecordDto> list = patrolService.getPatrolList(param);
|
if (list == null || list.isEmpty()) {
|
return null;
|
}
|
SecPatrolRecordDto data = list.get(0);
|
param.setId(null);
|
param.setCompanyId(data.getCompanyId());
|
param.setDeptId(data.getDeptId());
|
param.setUserName(data.getUserName());
|
param.setStart(DateUtil.getCurZero(data.getCreateTime()));
|
param.setEnd(DateUtil.getNextZero(data.getCreateTime()));
|
|
return patrolService.getPatrolList(param);
|
}
|
|
/**
|
* 获取巡更记录
|
*
|
* @param patrolId
|
*/
|
public SecPatrolRecordDto getPatrolImg(String patrolId) {
|
if (StringUtils.isEmpty(patrolId)) {
|
return null;
|
}
|
|
SecPatrolRecordParam param = new SecPatrolRecordParam();
|
param.setId(patrolId);
|
List<SecPatrolRecordDto> list = patrolService.getPatrolList(param);
|
if (list == null || list.isEmpty()) {
|
return null;
|
}
|
SecPatrolRecordDto data = list.get(0);
|
|
if (StringUtils.isNotEmpty(data.getImgName())) {
|
String bathPath = fileService.getInoutFilePath(data.getCreateTime());
|
String imgBase = FfmpegUtil.getImgStr(bathPath + data.getImgName());
|
data.setBase64Img(imgBase);
|
}
|
|
return list.get(0);
|
}
|
|
/**
|
* 获取巡更记录
|
*
|
* @param param
|
*/
|
@SuppressWarnings("unused")
|
public PageResponse<List<DoorSensor>> queryDoorSensorData(DoorSensor param) {
|
|
if (StringUtils.isEmpty(param.getCompanyId())) {
|
param.setCompanyId(ContextUtil.getCompanyId());
|
}
|
|
if (StringUtils.isEmpty(param.getDeptId())) {
|
param.setDeptId(ContextUtil.subDeptId(null));
|
}
|
|
// List<DoorSensor> list = doorSensorService.getDoorSensorList(param);
|
|
List<DoorSensor> list = null;
|
if (list == null || list.isEmpty()) {
|
return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
|
"没有获取到相关信息！");
|
}
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000, list);
|
}
|
|
public List<String> recordImgList(Integer id) {
|
|
return null;
|
}
|
|
/**
|
* 门禁撤防
|
*
|
* @param param
|
* @return
|
*/
|
public PageResponse<String> addDoorAccess(DoorAccessParam param) {
|
|
if (param == null || param.getStart() == null || param.getEnd() == null
|
|| StringUtils.isEmpty(param.getDepotId())) {
|
return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
|
"撤防失败，请重试！");
|
}
|
|
if (StringUtils.isEmpty(param.getCompanyId())) {
|
param.setCompanyId(ContextUtil.getCompanyId());
|
}
|
if (StringUtils.isEmpty(param.getDeptId())) {
|
param.setDeptId(ContextUtil.subDeptId(null));
|
}
|
|
param.setUser(ContextUtil.getLoginUserName());
|
param.setToken(coreDoorService.getNewToken(null));
|
// 添加一条门禁权限记录
|
coreDoorService.addDoorAccess(param);
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "撤防成功！！");
|
}
|
|
/**
|
* 门禁布防
|
*
|
* @param param
|
* @return
|
*/
|
public PageResponse<String> delDoorAccess(DoorAccessParam param) {
|
|
if (param == null || StringUtils.isEmpty(param.getDepotId())) {
|
return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
|
"布防失败，请重试！");
|
}
|
if (StringUtils.isEmpty(param.getCompanyId())) {
|
param.setCompanyId(ContextUtil.getCompanyId());
|
}
|
if (StringUtils.isEmpty(param.getDeptId())) {
|
param.setDeptId(ContextUtil.subDeptId(null));
|
}
|
param.setTime(new Date());
|
|
// coreDoorService.emptyDoorAccessByDepotId(param);
|
return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "布防成功！！");
|
}
|
}
|
