package com.ruoyi.device.camera.service.impl;
|
|
import java.text.SimpleDateFormat;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
import com.ruoyi.alarm.global.domain.GuidePoint;
|
import com.ruoyi.alarmpoints.well.domain.ArdAlarmpointsWell;
|
import com.ruoyi.common.constant.CacheConstants;
|
import com.ruoyi.common.constant.CameraConstants;
|
import com.ruoyi.common.core.domain.entity.SysDept;
|
import com.ruoyi.common.core.domain.entity.SysUser;
|
import com.ruoyi.common.core.redis.RedisCache;
|
import com.ruoyi.common.exception.ServiceException;
|
import com.ruoyi.common.utils.DateUtils;
|
import com.ruoyi.common.utils.SecurityUtils;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.common.utils.bean.BeanValidators;
|
import com.ruoyi.common.utils.spring.SpringUtils;
|
import com.ruoyi.common.utils.uuid.IdUtils;
|
import com.ruoyi.device.camera.domain.CameraCmd;
|
import com.ruoyi.device.camera.domain.DeptAndCamerasDto;
|
import com.ruoyi.device.channel.domain.ArdChannel;
|
import com.ruoyi.device.channel.mapper.ArdChannelMapper;
|
import com.ruoyi.media.service.IVtduService;
|
import com.ruoyi.scheduling.domian.SchedulingParam;
|
import com.ruoyi.system.service.ISysDeptService;
|
import com.ruoyi.utils.gis.GisUtil;
|
import com.ruoyi.utils.tools.ArdTool;
|
import com.ruoyi.device.camera.domain.ArdCameras;
|
import com.ruoyi.device.camera.mapper.ArdCamerasMapper;
|
import com.ruoyi.device.camera.service.IArdCamerasService;
|
import com.ruoyi.common.annotation.DataScope;
|
import com.ruoyi.system.mapper.SysDeptMapper;
|
import com.ruoyi.utils.gis.Point;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import javax.annotation.PostConstruct;
|
import javax.annotation.Resource;
|
import javax.validation.Validator;
|
|
/**
|
* 相机设备Service业务层处理
|
*
|
* @author 刘苏义
|
* @date 2023-02-11
|
*/
|
@Service
|
@Slf4j
|
public class ArdCamerasServiceImpl implements IArdCamerasService {
|
@Resource
|
private ArdCamerasMapper ardCamerasMapper;
|
@Resource
|
private SysDeptMapper sysDeptMapper;
|
@Resource
|
private RedisCache redisCache;
|
@Autowired
|
private ISysDeptService deptService;
|
@Resource
|
private ArdChannelMapper ardChannelMapper;
|
@Resource
|
private IVtduService vtduService;
|
@Autowired
|
protected Validator validator;
|
|
@PostConstruct
|
public void loadCameras() {
|
|
//清空相机缓存
|
Collection<String> cacheKeys = redisCache.keys(getCacheKey("*"));
|
redisCache.deleteObject(cacheKeys);
|
//重新加载相机到缓存
|
List<ArdCameras> ardCameras = selectArdCamerasListNoDataScope(new ArdCameras());
|
for (ArdCameras ardCamera : ardCameras) {
|
redisCache.setCacheObject(getCacheKey(ardCamera.getId()), ardCamera);
|
}
|
|
}
|
|
/**
|
* 设置cache key
|
*
|
* @param configKey 参数键
|
* @return 缓存键key
|
*/
|
private String getCacheKey(String configKey) {
|
return CacheConstants.CAMERA_LIST_KEY + configKey;
|
}
|
|
/**
|
* 查询相机设备
|
*
|
* @param id 相机设备主键
|
* @return 相机设备
|
*/
|
@Override
|
public ArdCameras selectArdCamerasById(String id) {
|
ArdCameras ardCameras = ardCamerasMapper.selectArdCamerasById(id);
|
if (ardCameras != null) {
|
ArdChannel ardChannel = new ArdChannel();
|
ardChannel.setDeviceId(ardCameras.getId());
|
List<ArdChannel> ardChannels = ardChannelMapper.selectArdChannelList(ardChannel);
|
if (ardChannels != null) {
|
ardCameras.setChannelList(ardChannels);
|
}
|
}
|
return ardCameras;
|
}
|
|
/**
|
* 查询相机设备列表
|
*
|
* @param ardCameras 相机设备
|
* @return 相机设备
|
*/
|
@Override
|
@DataScope(deptAlias = "d", userAlias = "u")
|
public List<ArdCameras> selectArdCamerasList(ArdCameras ardCameras) {
|
List<ArdCameras> ardCamerasList = ardCamerasMapper.selectArdCamerasList(ardCameras);
|
if (ardCamerasList.size() > 0) {
|
for (ArdCameras camera : ardCamerasList) {
|
ArdChannel ardChannel = new ArdChannel();
|
ardChannel.setDeviceId(camera.getId());
|
List<ArdChannel> ardChannels = ardChannelMapper.selectArdChannelList(ardChannel);
|
if (ardChannels != null) {
|
camera.setChannelList(ardChannels);
|
}
|
}
|
}
|
return ardCamerasList;
|
}
|
|
/**
|
* 查询相机设备列表-不进行数据过滤
|
*
|
* @param ardCameras 相机设备
|
* @return 相机设备
|
*/
|
@Override
|
public List<ArdCameras> selectArdCamerasListNoDataScope(ArdCameras ardCameras) {
|
return ardCamerasMapper.selectArdCamerasListNoDataScope(ardCameras);
|
}
|
|
/**
|
* 新增相机设备
|
*
|
* @param ardCameras 相机设备
|
* @return 结果
|
*/
|
@Override
|
public int insertArdCameras(ArdCameras ardCameras) {
|
ardCameras.setId(IdUtils.simpleUUID());
|
ardCameras.setCreateBy(SecurityUtils.getUsername());
|
ardCameras.setCreateTime(DateUtils.getNowDate());
|
ardCameras.setUserId(SecurityUtils.getUserId());
|
redisCache.setCacheObject(getCacheKey(ardCameras.getId()), ardCameras);
|
return ardCamerasMapper.insertArdCameras(ardCameras);
|
}
|
|
/**
|
* 修改相机设备
|
*
|
* @param ardCameras 相机设备
|
* @return 结果
|
*/
|
@Override
|
public int updateArdCameras(ArdCameras ardCameras) {
|
ardCameras.setUpdateTime(DateUtils.getNowDate());
|
int res = ardCamerasMapper.updateArdCameras(ardCameras);
|
if (res > 0) {
|
redisCache.deleteObject(getCacheKey(ardCameras.getId()));
|
redisCache.setCacheObject(getCacheKey(ardCameras.getId()), ardCameras);
|
}
|
return res;
|
}
|
|
/**
|
* 批量删除相机设备
|
*
|
* @param ids 需要删除的相机设备主键
|
* @return 结果
|
*/
|
@Override
|
public int deleteArdCamerasByIds(String[] ids) {
|
int res = ardCamerasMapper.deleteArdCamerasByIds(ids);
|
if (res > 0) {
|
for (String id : ids) {
|
redisCache.deleteObject(getCacheKey(id));
|
//删除流媒体
|
vtduService.deleteVtduByCameraId(id);
|
//删除当前相机的所有通道
|
ardChannelMapper.deleteArdChannelByDeviceId(id);
|
}
|
}
|
return res;
|
}
|
|
/**
|
* 删除相机设备信息
|
*
|
* @param id 相机设备主键
|
* @return 结果
|
*/
|
@Override
|
public int deleteArdCamerasById(String id) {
|
int i = ardCamerasMapper.deleteArdCamerasById(id);
|
if (i > 0) {
|
//删除当前相机的所有通道
|
ardChannelMapper.deleteArdChannelByDeviceId(id);
|
}
|
return i;
|
}
|
|
@Override
|
public String importCameras(List<ArdCameras> ardCamerasList, Boolean isUpdateSupport, String operName) {
|
if (StringUtils.isNull(ardCamerasList) || ardCamerasList.size() == 0) {
|
throw new ServiceException("导入井数据不能为空！");
|
}
|
int successNum = 0;
|
int failureNum = 0;
|
StringBuilder successMsg = new StringBuilder();
|
StringBuilder failureMsg = new StringBuilder();
|
for (ArdCameras camera : ardCamerasList) {
|
try {
|
//获取当前登录用户id
|
String userId = SecurityUtils.getUserId();
|
camera.setUserId(userId);
|
// 验证是否存在这个用户
|
ArdCameras u = ardCamerasMapper.selectArdCamerasById(camera.getId());
|
if (StringUtils.isNull(u)) {
|
BeanValidators.validateWithException(validator, camera);
|
camera.setCreateBy(operName);
|
this.insertArdCameras(camera);
|
successNum++;
|
successMsg.append("<br/>" + successNum + "、相机ID " + camera.getId() + " 导入成功");
|
} else if (isUpdateSupport) {
|
BeanValidators.validateWithException(validator, camera);
|
checkCameraDataScope(camera.getUserId());
|
camera.setUpdateBy(operName);
|
this.updateArdCameras(camera);
|
successNum++;
|
successMsg.append("<br/>" + successNum + "、相机ID " + camera.getId() + " 更新成功");
|
} else {
|
failureNum++;
|
failureMsg.append("<br/>" + failureNum + "、相机ID " + camera.getId() + " 已存在");
|
}
|
} catch (Exception e) {
|
failureNum++;
|
String msg = "<br/>" + failureNum + "、相机ID " + camera.getId() + " 导入失败：";
|
failureMsg.append(msg + e.getMessage());
|
log.error(msg, e);
|
}
|
}
|
if (failureNum > 0) {
|
failureMsg.insert(0, "很抱歉，导入失败！共 " + failureNum + " 条数据格式不正确，错误如下：");
|
throw new ServiceException(failureMsg.toString());
|
} else {
|
successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条，数据如下：");
|
}
|
return successMsg.toString();
|
}
|
|
/**
|
* 校验相机是否允许操作
|
*
|
* @param ardCameras 相机信息
|
*/
|
@Override
|
public void checkCameraAllowed(ArdCameras ardCameras) {
|
if (StringUtils.isNotNull(ardCameras.getId())) {
|
throw new ServiceException("不允许操作井");
|
}
|
}
|
|
/**
|
* 校验用户是否有数据权限
|
*
|
* @param userId 用户id
|
*/
|
@Override
|
public void checkCameraDataScope(String userId) {
|
if (!SysUser.isAdmin(SecurityUtils.getUserId())) {
|
ArdCameras camera = new ArdCameras();
|
camera.setUserId(userId);
|
List<ArdCameras> cameras = SpringUtils.getAopProxy(this).selectArdCamerasList(camera);
|
if (StringUtils.isEmpty(cameras)) {
|
throw new ServiceException("没有权限访问井数据！");
|
}
|
}
|
}
|
|
public List findOptions(ArdCameras ardCameras) {
|
List<ArdCameras> options = ardCamerasMapper.findOptions(ardCameras);
|
for (ArdCameras camera :
|
options) {
|
ArdChannel ardChannel = new ArdChannel();
|
ardChannel.setDeviceId(camera.getId());
|
List<ArdChannel> ardChannels = ardChannelMapper.selectArdChannelList(ardChannel);
|
camera.setChannelList(ardChannels);
|
}
|
return options;
|
}
|
|
/**
|
* @描述 获取本部门以下的所有相机和部门
|
* @参数 []
|
* @返回值 java.util.Map
|
* @创建人 刘苏义
|
* @创建时间 2023/6/2 10:58
|
* @修改人和其它信息
|
*/
|
@Override
|
public Map getChildDeptAndCamera(Boolean disabled) {
|
Long deptId = SecurityUtils.getDeptId();
|
SysDept sysDept = sysDeptMapper.selectDeptById(deptId);
|
Map<String, Object> map = fetchChildDepartments(sysDept, disabled);
|
return map;
|
}
|
|
@Override
|
public List<DeptAndCamerasDto> getChildDeptAndCamera() {
|
List<SysDept> depts = deptService.selectDeptList(new SysDept());
|
return fetchChildDepartments(depts);
|
}
|
/**
|
* @描述 递归查询
|
* @参数 [sysDept]
|
* @返回值 java.util.Map<java.lang.String, java.lang.Object>
|
* @创建人 刘苏义
|
* @创建时间 2023/6/2 14:38
|
* @修改人和其它信息
|
*/
|
public Map<String, Object> fetchChildDepartments(SysDept sysDept, Boolean disabled) {
|
Map<String, Object> map = new HashMap<>();
|
map.put("name", sysDept.getDeptName());
|
map.put("deptId", sysDept.getDeptId());
|
map.put("disabled", disabled);
|
List<SysDept> sysDepts = sysDeptMapper.selectNextChildrenDeptById(sysDept.getDeptId());
|
List<ArdCameras> ardCameras = ardCamerasMapper.selectArdCamerasByDeptId(sysDept.getDeptId());
|
List<Object> childList = new ArrayList<>();
|
for (SysDept childDept : sysDepts) {
|
Map<String, Object> childMap = new HashMap<>();
|
childMap.put("name", childDept.getDeptName());
|
childMap.put("deptId", childDept.getDeptId());
|
childMap.put("disabled", disabled);
|
Map<String, Object> map1 = fetchChildDepartments(childDept, disabled);
|
childMap.putAll(map1);
|
childList.add(childMap);
|
}
|
if (ardCameras.size() > 0) {
|
for (ArdCameras camera : ardCameras) {
|
ArdChannel ardChannel = new ArdChannel();
|
ardChannel.setDeviceId(camera.getId());
|
List<ArdChannel> ardChannels = ardChannelMapper.selectArdChannelList(ardChannel);
|
if (ardChannels != null) {
|
camera.setChannelList(ardChannels);
|
}
|
Map<String, Object> cameraMap = ArdTool.convertEntityToMap(camera);
|
childList.add(cameraMap);
|
}
|
}
|
map.put("children", childList);
|
return map;
|
}
|
|
/**
|
* 获取所有部门及部门下的相机
|
* 刘苏义
|
* 2024/3/4 14:45:03
|
*/
|
public List<DeptAndCamerasDto> fetchChildDepartments(List<SysDept> sysDepts) {
|
|
List<DeptAndCamerasDto> deptAndCamerasList = sysDepts.stream()
|
.map(sysDept -> {
|
List<ArdCameras> ardCameras = ardCamerasMapper.selectArdCamerasByDeptId(sysDept.getDeptId());
|
ardCameras.stream().forEach(ardCamera ->{
|
ArdChannel ardChannel = new ArdChannel();
|
ardChannel.setDeviceId(ardCamera.getId());
|
List<ArdChannel> ardChannels = ardChannelMapper.selectArdChannelList(ardChannel);
|
if (ardChannels != null) {
|
ardCamera.setChannelList(ardChannels);
|
}
|
});
|
DeptAndCamerasDto deptAndCamerasDto = new DeptAndCamerasDto();
|
deptAndCamerasDto.setSysDept(sysDept);
|
deptAndCamerasDto.setArdCamerasList(ardCameras);
|
return deptAndCamerasDto;
|
})
|
.collect(Collectors.toList());
|
|
return deptAndCamerasList;
|
}
|
|
/**
|
* @描述 通过坐标获取附近的相机
|
* @参数 [cmd]
|
* @返回值 java.util.Map
|
* @创建人 刘苏义
|
* @创建时间 2023/6/17 11:55
|
* @修改人和其它信息
|
*/
|
@Override
|
public TreeMap getNearCamerasBycoordinate(CameraCmd cmd) {
|
try {
|
double[] targetPosition = cmd.getTargetPosition();
|
if (targetPosition == null) {
|
log.debug("目标位置为空");
|
return new TreeMap<>();
|
}
|
String dayNightTime = redisCache.getCacheObject("sys_config:dayNightTime");
|
//获取所有大光电
|
List<ArdCameras> ardCamerasList = ardCamerasMapper.selectArdCamerasList(new ArdCameras("1"));
|
//统计所有大光电可视范围内与报警点的距离
|
Map<String, Double> distanceMap = new HashMap<>();
|
TreeMap<Double, ArdCameras> ardCameras = new TreeMap<>();
|
for (ArdCameras camera : ardCamerasList) {
|
if (camera.getLongitude() == null && camera.getLatitude() == null) {
|
continue;
|
}
|
double[] camPosition = new double[]{camera.getLongitude(), camera.getLatitude()};
|
double distance = GisUtil.getDistance(targetPosition, camPosition);
|
if (camera.getCamMaxVisibleDistance() == null) {
|
continue;
|
}
|
if (distance != 0.0 && distance <= camera.getCamMaxVisibleDistance()) {
|
distanceMap.put(camera.getId(), distance);
|
camera.setChanNo(ArdTool.getChannelBydayNightTime(dayNightTime));
|
ardCameras.put(distance, camera);
|
}
|
//获取通道列表
|
ArdChannel ardChannel = new ArdChannel();
|
ardChannel.setDeviceId(camera.getId());
|
List<ArdChannel> ardChannels = ardChannelMapper.selectArdChannelList(ardChannel);
|
if (ardChannels != null) {
|
camera.setChannelList(ardChannels);
|
}
|
}
|
return ardCameras;
|
} catch (Exception ex) {
|
log.error("获取附近相机异常:" + ex.getMessage());
|
}
|
return null;
|
}
|
|
/**
|
* 获取监控圈内所有在线光电
|
* 刘苏义
|
* 2023/8/17 13:57:21
|
*/
|
@Override
|
public List<ArdCameras> getNearCameras(SchedulingParam param) {
|
try {
|
Long deptId = SecurityUtils.getLoginUser().getUser().getDeptId();
|
Double longitude = param.getLongitude();
|
Double latitude = param.getLatitude();
|
if (longitude == null && latitude == null) {
|
log.debug("原点坐标为空");
|
return null;
|
}
|
Integer radius = param.getMonitoringRadius();
|
if (radius == null) {
|
log.debug("监控圈半径距离为空");
|
return null;
|
}
|
String dayNightTime = redisCache.getCacheObject("sys_config:dayNightTime");
|
//获取所有光电(按部门)
|
ArdCameras cameras = new ArdCameras();
|
cameras.setDeptId(deptId);
|
List<ArdCameras> ardCamerasList = ardCamerasMapper.selectArdCamerasList(cameras);
|
//统计所有光电可视范围内与报警点的距离
|
List<ArdCameras> ardCameras = new ArrayList<>();
|
for (ArdCameras camera : ardCamerasList) {
|
if (camera.getLongitude() == null && camera.getLatitude() == null) {
|
continue;
|
}
|
double[] camPosition = new double[]{camera.getLongitude(), camera.getLatitude()};
|
double distance = GisUtil.getDistance(new double[]{longitude, latitude}, camPosition);
|
if (distance <= radius) {
|
/*获取通道列表*/
|
ArdChannel ardChannel = new ArdChannel();
|
ardChannel.setDeviceId(camera.getId());
|
List<ArdChannel> ardChannels = ardChannelMapper.selectArdChannelList(ardChannel);
|
camera.setChannelList(ardChannels);
|
ardCameras.add(camera);
|
}
|
}
|
//过滤在线相机
|
List<ArdCameras> onlineList = ardCameras.stream()
|
.filter(ardCamera -> (!ardCamera.getLoginId().equals(-1)))
|
.collect(Collectors.toList());
|
return onlineList;
|
} catch (Exception ex) {
|
log.error("获取附近相机异常:" + ex.getMessage());
|
}
|
return null;
|
}
|
|
/**
|
* 获取监控圈内所有在线光电
|
* 刘苏义
|
* 2023/8/17 13:57:21
|
*/
|
@Override
|
public List<ArdCameras> getNearCamerasWithPolygon(SchedulingParam param) {
|
try {
|
Long deptId = SecurityUtils.getLoginUser().getUser().getDeptId();
|
List<Point> partitionLocation = param.getPartitionLocation();
|
if (partitionLocation == null) {
|
log.debug("多边形坐标集合为空");
|
return null;
|
}
|
String dayNightTime = redisCache.getCacheObject("sys_config:dayNightTime");
|
//获取所有光电(按部门)
|
ArdCameras cameras = new ArdCameras();
|
cameras.setDeptId(deptId);
|
List<ArdCameras> ardCamerasList = ardCamerasMapper.selectArdCamerasList(cameras);
|
List<ArdCameras> ardCameras = new ArrayList<>();
|
for (ArdCameras camera : ardCamerasList) {
|
if (camera.getLongitude() == null && camera.getLatitude() == null) {
|
continue;
|
}
|
/*判断坐标是否在多边形范围内*/
|
Point camPosition = new Point(camera.getLongitude(), camera.getLatitude());
|
boolean inPolygon = GisUtil.isInPolygon(camPosition, partitionLocation);
|
if (inPolygon) {
|
/*获取通道列表*/
|
ArdChannel ardChannel = new ArdChannel();
|
ardChannel.setDeviceId(camera.getId());
|
List<ArdChannel> ardChannels = ardChannelMapper.selectArdChannelList(ardChannel);
|
camera.setChannelList(ardChannels);
|
ardCameras.add(camera);
|
}
|
}
|
//过滤在线相机
|
List<ArdCameras> onlineList = ardCameras.stream()
|
.filter(ardCamera -> (!ardCamera.getLoginId().equals(-1)))
|
.collect(Collectors.toList());
|
return onlineList;
|
} catch (Exception ex) {
|
log.error("获取附近相机异常:" + ex.getMessage());
|
}
|
return null;
|
}
|
|
/**
|
* 校验相机是否唯一
|
*
|
* @param camera 相机
|
* @return 结果
|
*/
|
@Override
|
public String checkCameraIpAndPortUnique(ArdCameras camera) {
|
String id = camera.getId();
|
String ip = camera.getIp();
|
Integer port = camera.getPort();
|
ArdCameras info = ardCamerasMapper.checkCameraIpAndPortUnique(ip, port);
|
if (StringUtils.isNotNull(info) && !info.getId().equals(id)) {
|
return CameraConstants.NOT_UNIQUE;
|
}
|
return CameraConstants.UNIQUE;
|
}
|
|
@Override
|
public List<Map<String, Object>> getCamerasByDeptId(Long deptId) {
|
List<Map<String, Object>> result = ardCamerasMapper.getCamerasByDeptId(deptId);
|
return result;
|
}
|
|
@Override
|
public Boolean getCameraOperationByCameraId(String id, String userId) {
|
Boolean result = ardCamerasMapper.getCameraOperationByCameraId(id,userId);
|
return result;
|
}
|
|
@Override
|
public Map<String, Object> getChannelByCameraId(String id) {
|
List<Map<String,Object>> result = ardCamerasMapper.getChannelByCameraId(id);
|
Map<String,Object> resultMap = new HashMap();
|
if(result.size() == 1){
|
resultMap.put("chanNo", result.get(0).get("chan_no"));
|
return resultMap;
|
}else{
|
String configValue = (String) result.get(0).get("config_value");
|
String beginTime = configValue.split("-")[0];
|
String endTime = configValue.split("-")[1];
|
Date now = new Date();
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
|
String nowDay = sdf.format(now);
|
try{
|
Long beginDate = sdf.parse(nowDay).getTime()
|
+ Integer.parseInt(beginTime.split(":")[0]) * 60 * 60 *1000
|
+ Integer.parseInt(beginTime.split(":")[1]) * 60 *1000;
|
Long endDate = sdf.parse(nowDay).getTime()
|
+ Integer.parseInt(endTime.split(":")[0]) * 60 * 60 *1000
|
+ Integer.parseInt(endTime.split(":")[1]) * 60 *1000;
|
if(now.getTime() >= beginDate && now.getTime() <= endDate){
|
result = result.stream().filter(map -> ((Integer)map.get("chan_no")) == 1).collect(Collectors.toList());
|
resultMap.put("chanNo", result.get(0).get("chan_no"));
|
return resultMap;
|
}else{
|
result = result.stream().filter(map -> ((Integer)map.get("chan_no")) == 2).collect(Collectors.toList());
|
resultMap.put("chanNo", result.get(0).get("chan_no"));
|
return resultMap;
|
}
|
}catch (Exception e){
|
e.printStackTrace();
|
return resultMap;
|
}
|
}
|
}
|
}
|
