package com.moral.api.service.impl;
|
|
import com.alibaba.fastjson.JSON;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.moral.api.entity.*;
|
import com.moral.api.mapper.*;
|
import com.moral.api.pojo.vo.device.DeviceVO;
|
import com.moral.api.service.SpecialDeviceService;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.moral.api.util.CacheUtils;
|
import com.moral.api.util.LogUtils;
|
import com.moral.constant.Constants;
|
import com.moral.constant.RedisConstants;
|
import com.moral.constant.ResponseCodeEnum;
|
import com.moral.util.DateUtils;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.data.redis.core.RedisTemplate;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.context.request.RequestContextHolder;
|
import org.springframework.web.context.request.ServletRequestAttributes;
|
|
import javax.servlet.http.HttpServletRequest;
|
import java.text.SimpleDateFormat;
|
import java.util.*;
|
|
/**
|
* <p>
|
* 服务实现类
|
* </p>
|
*
|
* @author moral
|
* @since 2021-08-11
|
*/
|
@Service
|
public class SpecialDeviceServiceImpl extends ServiceImpl<SpecialDeviceMapper, SpecialDevice> implements SpecialDeviceService {
|
|
@Autowired(required = false)
|
private SpecialDeviceMapper specialDeviceMapper;
|
|
@Autowired(required = false)
|
private ManageAccountMapper manageAccountMapper;
|
|
@Autowired(required = false)
|
private VersionMapper versionMapper;
|
|
@Autowired(required = false)
|
private SysDictDataMapper sysDictDataMapper;
|
|
@Autowired(required = false)
|
private SpecialDeviceHistoryMapper specialDeviceHistoryMapper;
|
|
@Autowired(required = false)
|
private OrganizationMapper organizationMapper;
|
|
@Autowired(required = false)
|
private RedisTemplate redisTemplate;
|
|
@Autowired(required = false)
|
private OrganizationUnitAlarmMapper organizationUnitAlarmMapper;
|
|
@Autowired(required = false)
|
private VersionSensorUnitMapper versionSensorUnitMapper;
|
|
@Autowired
|
private LogUtils logUtils;
|
|
/*
|
* 从redis获取设备信息
|
* */
|
private Map<String, Object> getDeviceInfoFromRedis(String mac) {
|
return (Map<String, Object>) redisTemplate.opsForHash().get(RedisConstants.DEVICE, mac);
|
}
|
|
/*
|
* 设备信息存入redis
|
*/
|
private void setDeviceInfoToRedis(String mac, Map<String, Object> deviceInfo) {
|
redisTemplate.opsForHash().put(RedisConstants.DEVICE, mac, deviceInfo);
|
}
|
|
/*
|
* 从redis删除设备信息
|
*/
|
private void delDeviceInfoFromRedis(String mac) {
|
redisTemplate.opsForHash().delete(RedisConstants.DEVICE, mac);
|
}
|
|
@Override
|
public Map<String, Object> getDataByCondition(Map map) {
|
Map<String,Object> resultMap = new HashMap<>();
|
if (!map.containsKey("current")||!map.containsKey("size")){
|
resultMap.put("code",ResponseCodeEnum.PARAMETERS_IS_MISSING.getCode());
|
resultMap.put("msg",ResponseCodeEnum.PARAMETERS_IS_MISSING.getMsg());
|
return resultMap;
|
}
|
int current = Integer.parseInt(map.get("current").toString());
|
int size = Integer.parseInt(map.get("size").toString());
|
Page<SpecialDevice> page = new Page<>(current,size);
|
QueryWrapper<SpecialDevice> wrapper_Condition = new QueryWrapper<>();
|
wrapper_Condition.eq("is_delete",Constants.NOT_DELETE);
|
if (!ObjectUtils.isEmpty(map.get("organization_id"))){
|
wrapper_Condition.eq("organization_id",map.get("organization_id").toString());
|
}
|
if (!ObjectUtils.isEmpty(map.get("keyword"))){
|
wrapper_Condition.and(wc -> wc.like("name",map.get("keyword").toString()).or().like("mac",map.get("keyword").toString()));
|
//wrapper_Condition.like("name",map.get("keyword").toString()).or().like("mac",map.get("keyword").toString());
|
}
|
wrapper_Condition.orderByDesc("create_time");
|
Page resultPage = specialDeviceMapper.selectPage(page,wrapper_Condition);
|
int totalNumber = specialDeviceMapper.selectCount(wrapper_Condition);
|
List<SpecialDevice> specialDevices = resultPage.getRecords();
|
SimpleDateFormat SDF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
List<Map<String,Object>> specialDeviceList = new ArrayList<>();
|
for (SpecialDevice specialDevice:specialDevices) {
|
Map specialDeviceMap = JSON.parseObject(JSON.toJSONString(specialDevice),Map.class);
|
String createTime = SDF.format(specialDevice.getCreateTime());
|
String updateTime = SDF.format(specialDevice.getUpdateTime());
|
specialDeviceMap.put("createTime",createTime);
|
specialDeviceMap.put("updateTime",updateTime);
|
List<Map<String,Object>> operateList = new ArrayList<>();
|
if (!ObjectUtils.isEmpty(specialDevice.getOperateIds()) && specialDevice.getOperateIds()!=null){
|
String operateIds = specialDevice.getOperateIds();
|
String[] operateIdArr = operateIds.split(",");
|
if (operateIdArr.length>0){
|
List<Integer> operateIdList = new ArrayList<>();
|
for (int i = 0; i < operateIdArr.length; i++){
|
operateIdList.add(Integer.parseInt(operateIdArr[i]));
|
}
|
QueryWrapper<ManageAccount> wapper_manageAccount = new QueryWrapper<>();
|
wapper_manageAccount.eq("is_delete",Constants.NOT_DELETE);
|
wapper_manageAccount.in("id",operateIdList);
|
List<ManageAccount> manageAccounts = manageAccountMapper.selectList(wapper_manageAccount);
|
for (ManageAccount manageAccount:manageAccounts) {
|
Map<String,Object> operateMap = new HashMap<>();
|
operateMap.put("id",manageAccount.getId());
|
operateMap.put("name",manageAccount.getUserName());
|
operateList.add(operateMap);
|
}
|
}
|
}
|
specialDeviceMap.put("operates",operateList);
|
Map<String,Object> deviceVersionMap = new HashMap<>();
|
if (!ObjectUtils.isEmpty(specialDevice.getDeviceVersionId()) && specialDevice.getDeviceVersionId()!=null && !"".equals(specialDevice.getDeviceVersionId())){
|
int versionId = Integer.parseInt(specialDevice.getDeviceVersionId().toString());
|
QueryWrapper<Version> wapper_version = new QueryWrapper<>();
|
wapper_version.eq("is_delete",Constants.NOT_DELETE);
|
wapper_version.eq("id",versionId);
|
Version version = versionMapper.selectOne(wapper_version);
|
if (!ObjectUtils.isEmpty(version)){
|
deviceVersionMap.put("id",version.getId());
|
deviceVersionMap.put("name",version.getName());
|
}
|
}
|
specialDeviceMap.put("version",deviceVersionMap);
|
Map<String,Object> specialTypeMap = new HashMap<>();
|
if (!ObjectUtils.isEmpty(specialDevice.getSpecialType()) && specialDevice.getSpecialType()!=null && !"".equals(specialDevice.getSpecialType())){
|
int specialTypeId = Integer.parseInt(specialDevice.getSpecialType().toString());
|
QueryWrapper<SysDictData> wapper_sysDictData = new QueryWrapper<>();
|
wapper_sysDictData.eq("is_delete",Constants.NOT_DELETE);
|
wapper_sysDictData.eq("dict_type_id",27);
|
wapper_sysDictData.eq("dataKey",specialTypeId);
|
SysDictData sysDictData = sysDictDataMapper.selectOne(wapper_sysDictData);
|
if (!ObjectUtils.isEmpty(sysDictData)){
|
specialTypeMap.put("id",sysDictData.getId());
|
specialTypeMap.put("dataKey",sysDictData.getDataKey());
|
specialTypeMap.put("name",sysDictData.getDataValue());
|
}
|
}
|
specialDeviceMap.put("specialType",specialTypeMap);
|
Map<String,Object> organizationMap = new HashMap<>();
|
if (!ObjectUtils.isEmpty(specialDevice.getOrganizationId()) && specialDevice.getOrganizationId()!=null && !"".equals(specialDevice.getOrganizationId())){
|
int organizationId = Integer.parseInt(specialDevice.getOrganizationId().toString());
|
QueryWrapper<Organization> wapper_organization = new QueryWrapper<>();
|
wapper_organization.eq("is_delete",Constants.NOT_DELETE);
|
wapper_organization.eq("id",organizationId);
|
Organization organization = organizationMapper.selectOne(wapper_organization);
|
if (!ObjectUtils.isEmpty(organization)){
|
organizationMap.put("id",organization.getId());
|
organizationMap.put("name",organization.getName());
|
}
|
}
|
specialDeviceMap.put("organization",organizationMap);
|
List<Map<String,Object>> organizationList = new ArrayList<>();
|
QueryWrapper<SpecialDeviceHistory> wapper_specialDeviceHistory = new QueryWrapper<>();
|
wapper_specialDeviceHistory.eq("is_delete",Constants.NOT_DELETE);
|
wapper_specialDeviceHistory.eq("mac",specialDevice.getMac());
|
List<SpecialDeviceHistory> specialDeviceHistories = specialDeviceHistoryMapper.selectList(wapper_specialDeviceHistory);
|
if (!ObjectUtils.isEmpty(specialDeviceHistories)){
|
List organizationIdList = new ArrayList();
|
for (SpecialDeviceHistory specialDeviceHistory:specialDeviceHistories) {
|
organizationIdList.add(specialDeviceHistory.getOrganizationId());
|
}
|
QueryWrapper<Organization> wapper_organizationHistory = new QueryWrapper<>();
|
wapper_organizationHistory.eq("is_delete",Constants.NOT_DELETE);
|
wapper_organizationHistory.in("id",organizationIdList);
|
List<Organization> organizations = organizationMapper.selectList(wapper_organizationHistory);
|
for (Organization organization:organizations) {
|
Map<String,Object> organizationHistoryMap = new HashMap<>();
|
organizationHistoryMap.put("id",organization.getId());
|
organizationHistoryMap.put("name",organization.getName());
|
organizationList.add(organizationHistoryMap);
|
}
|
}
|
specialDeviceMap.put("organizations",organizationList);
|
specialDeviceList.add(specialDeviceMap);
|
}
|
resultMap.put("specialDevices",specialDeviceList);
|
resultMap.put("totalNumber",totalNumber);
|
resultMap.put("current",current);
|
int totalPageNumber = totalNumber/size;
|
if(totalNumber%size != 0){
|
totalPageNumber += 1;
|
}
|
resultMap.put("totalPageNumber",totalPageNumber);
|
return resultMap;
|
}
|
|
@Transactional
|
@Override
|
public Map<String, Object> insert(SpecialDevice specialDevice) {
|
Map<String,Object> resultMap = new HashMap<>();
|
String name = specialDevice.getName();
|
String mac = specialDevice.getMac();
|
int organizationId = specialDevice.getOrganizationId();
|
int deviceVersionId = specialDevice.getDeviceVersionId();
|
String operateIds = specialDevice.getOperateIds();
|
String specialType = specialDevice.getSpecialType();
|
if (ObjectUtils.isEmpty(name) || ObjectUtils.isEmpty(mac) || ObjectUtils.isEmpty(specialType) || ObjectUtils.isEmpty(organizationId) || ObjectUtils.isEmpty(deviceVersionId)){
|
resultMap.put("code",ResponseCodeEnum.PARAMETERS_IS_MISSING.getCode());
|
resultMap.put("msg",ResponseCodeEnum.PARAMETERS_IS_MISSING.getMsg());
|
return resultMap;
|
}
|
if (name.equals("") || mac.equals("") || specialType.equals("")){
|
resultMap.put("code",ResponseCodeEnum.PARAMETERS_NOT_REQUIREMENT.getCode());
|
resultMap.put("msg",ResponseCodeEnum.PARAMETERS_NOT_REQUIREMENT.getMsg());
|
return resultMap;
|
}
|
QueryWrapper<SpecialDevice> wrapper_mac = new QueryWrapper<>();
|
wrapper_mac.eq("is_delete",Constants.NOT_DELETE);
|
wrapper_mac.eq("mac",mac);
|
int macNum = specialDeviceMapper.selectCount(wrapper_mac);
|
if (macNum>0){
|
resultMap.put("code",ResponseCodeEnum.MAC_IS_EXIST.getCode());
|
resultMap.put("msg",ResponseCodeEnum.MAC_IS_EXIST.getMsg());
|
return resultMap;
|
}
|
specialDeviceMapper.insert(specialDevice);
|
QueryWrapper<SpecialDeviceHistory> wrapper_specialDeviceHistory = new QueryWrapper<>();
|
wrapper_specialDeviceHistory.eq("is_delete",Constants.NOT_DELETE);
|
wrapper_specialDeviceHistory.eq("mac",mac);
|
wrapper_specialDeviceHistory.eq("organization_id",organizationId);
|
SpecialDeviceHistory specialDeviceHistory = specialDeviceHistoryMapper.selectOne(wrapper_specialDeviceHistory);
|
SpecialDeviceHistory insertSpecialDeviceHistory = new SpecialDeviceHistory();
|
BeanUtils.copyProperties(specialDevice,insertSpecialDeviceHistory);
|
if (ObjectUtils.isEmpty(specialDeviceHistory)){
|
specialDeviceHistoryMapper.insert(insertSpecialDeviceHistory);
|
}else {
|
/*UpdateWrapper<SpecialDeviceHistory> wrapper_insertSpecialDeviceHistory = new UpdateWrapper<>();
|
wrapper_specialDeviceHistory.eq("is_delete",Constants.NOT_DELETE);
|
wrapper_specialDeviceHistory.eq("mac",mac);
|
wrapper_specialDeviceHistory.eq("organization_id",organizationId);*/
|
specialDeviceHistoryMapper.update(insertSpecialDeviceHistory,wrapper_specialDeviceHistory);
|
}
|
Map<String, Object> deviceInfo = selectDeviceInfoById(specialDevice.getId());
|
//维护组织型号关系表
|
insertOrganizationUnitAlarm(specialDevice.getOrganizationId(), specialDevice.getDeviceVersionId());
|
//新增设备信息存入redis
|
String mac1 = specialDevice.getMac();
|
//从redis中删除设备信息
|
delDeviceInfoFromRedis(mac1);
|
//设备信息存入redis
|
setDeviceInfoToRedis(mac1, deviceInfo);
|
//刷新deviceInfo缓存
|
CacheUtils.refreshSpecialDeviceAlarmInfo();
|
//操作日志记录
|
HttpServletRequest request = ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
|
StringBuilder content = new StringBuilder();
|
content.append("添加了特殊设备：").append(specialDevice.getName()).append(":").append("mac：").append(mac);
|
logUtils.saveOperationForManage(request, content.toString(), Constants.INSERT_OPERATE_TYPE);
|
resultMap.put("code", ResponseCodeEnum.SUCCESS.getCode());
|
resultMap.put("msg", ResponseCodeEnum.SUCCESS.getMsg());
|
return resultMap;
|
}
|
|
@Override
|
public Map<String, Object> selectDeviceInfoById(Integer deviceId) {
|
String mac = specialDeviceMapper.selectById(deviceId).getMac();
|
Map<String, Object> specialDeviceInfo = getDeviceInfoFromRedis(mac);
|
//先从redis中取
|
if (specialDeviceInfo != null) {
|
return specialDeviceInfo;
|
}
|
specialDeviceInfo = new LinkedHashMap<>();
|
//DeviceVO device = deviceMapper.selectDeviceInfoById(deviceId);
|
SpecialDevice specialDevice = specialDeviceMapper.selectById(deviceId);
|
//设备
|
specialDeviceInfo.put("id", specialDevice.getId());
|
specialDeviceInfo.put("name", specialDevice.getName());
|
specialDeviceInfo.put("mac", specialDevice.getMac());
|
specialDeviceInfo.put("createTime", DateUtils.dateToDateString(specialDevice.getCreateTime()));
|
|
//扩展字段
|
//specialDeviceInfo.put("extend", device.getExtend());
|
|
//型号
|
Map<String, Object> versionInfo = new LinkedHashMap<>();
|
Version version = versionMapper.selectById(specialDevice.getDeviceVersionId());
|
versionInfo.put("id", version.getId());
|
versionInfo.put("name", version.getName());
|
specialDeviceInfo.put("version", versionInfo);
|
|
//维护人
|
List<Map<String, Object>> operatorsInfo = new ArrayList<>();
|
String operateIds = specialDevice.getOperateIds();
|
if (!ObjectUtils.isEmpty(operateIds)){
|
String[] operateIdArr = operateIds.split(",");
|
if (operateIdArr.length>0){
|
List<Integer> operateIdList = new ArrayList<>();
|
for (int i = 0; i < operateIdArr.length; i++){
|
operateIdList.add(Integer.parseInt(operateIdArr[i]));
|
}
|
QueryWrapper<ManageAccount> wapper_manageAccount = new QueryWrapper<>();
|
wapper_manageAccount.eq("is_delete",Constants.NOT_DELETE);
|
wapper_manageAccount.in("id",operateIdList);
|
List<ManageAccount> manageAccounts = manageAccountMapper.selectList(wapper_manageAccount);
|
for (ManageAccount manageAccount:manageAccounts) {
|
Map<String,Object> operateMap = new HashMap<>();
|
operateMap.put("id",manageAccount.getId());
|
operateMap.put("name",manageAccount.getUserName());
|
operatorsInfo.add(operateMap);
|
}
|
}
|
}
|
specialDeviceInfo.put("operators", operatorsInfo);
|
|
//组织
|
Map<String, Object> orgInfo = new LinkedHashMap<>();
|
Organization organization = organizationMapper.selectById(specialDevice.getOrganizationId());
|
orgInfo.put("id", organization.getId());
|
orgInfo.put("name", organization.getName());
|
specialDeviceInfo.put("organization", orgInfo);
|
|
setDeviceInfoToRedis(mac, specialDeviceInfo);
|
return specialDeviceInfo;
|
}
|
|
private void insertOrganizationUnitAlarm(Integer orgId, Integer versionId) {
|
QueryWrapper<OrganizationUnitAlarm> queryOrganizationVersionWrapper = new QueryWrapper<>();
|
queryOrganizationVersionWrapper.eq("organization_id", orgId);
|
queryOrganizationVersionWrapper.eq("version_id", versionId);
|
queryOrganizationVersionWrapper.eq("is_delete", Constants.NOT_DELETE);
|
List<OrganizationUnitAlarm> organizationUnitAlarms = organizationUnitAlarmMapper.selectList(queryOrganizationVersionWrapper);
|
if (org.springframework.util.ObjectUtils.isEmpty(organizationUnitAlarms)) {
|
QueryWrapper<VersionSensorUnit> queryVersionSensorUnitWrapper = new QueryWrapper<>();
|
queryVersionSensorUnitWrapper.eq("version_id", versionId);
|
queryVersionSensorUnitWrapper.eq("is_delete", Constants.NOT_DELETE);
|
List<VersionSensorUnit> versionSensorUnits = versionSensorUnitMapper.selectList(queryVersionSensorUnitWrapper);
|
if (!org.springframework.util.ObjectUtils.isEmpty(versionSensorUnits)) {
|
for (VersionSensorUnit versionSensorUnit : versionSensorUnits) {
|
OrganizationUnitAlarm organizationUnitAlarm = new OrganizationUnitAlarm();
|
organizationUnitAlarm.setOrganizationId(orgId);
|
organizationUnitAlarm.setVersionId(versionId);
|
organizationUnitAlarm.setSensorCode(versionSensorUnit.getSensorCode());
|
organizationUnitAlarm.setUnitKey(versionSensorUnit.getUnitKey());
|
organizationUnitAlarm.setShowUnitKey(versionSensorUnit.getUnitKey());
|
organizationUnitAlarmMapper.insert(organizationUnitAlarm);
|
}
|
}
|
}
|
}
|
}
|
