分钟，5分钟，小时表存入非本月数据bug修复

jinpengyong

2021-12-22 9d91dc402f279630eaa100024fd3b1542fbeb41c

 screen-manage/src/main/java/com/moral/api/service/impl/SpecialDeviceServiceImpl.java

@@ -2,26 +2,36 @@

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
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.redisBean.SpecialDeviceInfoDTO;
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.AdjustDataUtils;
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.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.*;

/**
 * <p>
@@ -55,25 +65,37 @@
    @Autowired(required = false)
    private RedisTemplate redisTemplate;

    @Autowired(required = false)
    private OrganizationUnitAlarmMapper organizationUnitAlarmMapper;

    @Autowired(required = false)
    private VersionSensorUnitMapper versionSensorUnitMapper;

    @Autowired(required = false)
    private GovMonitorPointMapper govMonitorPointMapper;

    @Autowired
    private AdjustDataUtils adjustDataUtils;

    /*
     * 从redis获取设备信息
     * */
    private Map<String, Object> getDeviceInfoFromRedis(String mac) {
        return (Map<String, Object>) redisTemplate.opsForHash().get(RedisConstants.DEVICE, mac);
    private SpecialDeviceInfoDTO getDeviceInfoFromRedis(String mac) {
        return (SpecialDeviceInfoDTO) redisTemplate.opsForHash().get(RedisConstants.SPECIAL_DEVICE, mac);
    }

    /*
     * 设备信息存入redis
     */
    private void setDeviceInfoToRedis(String mac, Map<String, Object> deviceInfo) {
        redisTemplate.opsForHash().put(RedisConstants.DEVICE, mac, deviceInfo);
    private void setDeviceInfoToRedis(String mac, SpecialDeviceInfoDTO specialDeviceInfoDTO) {
        redisTemplate.opsForHash().put(RedisConstants.SPECIAL_DEVICE, mac, specialDeviceInfoDTO);
    }

    /*
     * 从redis删除设备信息
     */
    private void delDeviceInfoFromRedis(String mac) {
        redisTemplate.opsForHash().delete(RedisConstants.DEVICE, mac);
        redisTemplate.opsForHash().delete(RedisConstants.SPECIAL_DEVICE, mac);
    }

    @Override
@@ -108,6 +130,20 @@
            String updateTime = SDF.format(specialDevice.getUpdateTime());
            specialDeviceMap.put("createTime",createTime);
            specialDeviceMap.put("updateTime",updateTime);
            Map<String,Object> govMonitorPointMap = new HashMap<>();
            if (!ObjectUtils.isEmpty(specialDevice.getGuid()) && specialDevice.getGuid()!=null && !"".equals(specialDevice.getGuid())){
                String  guid = specialDevice.getGuid().toString();
                QueryWrapper<GovMonitorPoint> wapper_govMonitorPoint = new QueryWrapper<>();
                wapper_govMonitorPoint.eq("is_delete",Constants.NOT_DELETE);
                wapper_govMonitorPoint.eq("guid",guid);
                GovMonitorPoint govMonitorPoint = govMonitorPointMapper.selectOne(wapper_govMonitorPoint);
                if (!ObjectUtils.isEmpty(govMonitorPoint)){
                    govMonitorPointMap.put("id",govMonitorPoint.getId());
                    govMonitorPointMap.put("guid",govMonitorPoint.getGuid());
                    govMonitorPointMap.put("name",govMonitorPoint.getName());
                }
            }
            specialDeviceMap.put("govMonitorPoint",govMonitorPointMap);
            List<Map<String,Object>> operateList = new ArrayList<>();
            if (!ObjectUtils.isEmpty(specialDevice.getOperateIds()) && specialDevice.getOperateIds()!=null){
                String operateIds = specialDevice.getOperateIds();
@@ -120,6 +156,7 @@
                    QueryWrapper<ManageAccount> wapper_manageAccount = new QueryWrapper<>();
                    wapper_manageAccount.eq("is_delete",Constants.NOT_DELETE);
                    wapper_manageAccount.in("id",operateIdList);
                    wapper_manageAccount.select("id", "user_name");
                    List<ManageAccount> manageAccounts = manageAccountMapper.selectList(wapper_manageAccount);
                    for (ManageAccount manageAccount:manageAccounts) {
                        Map<String,Object> operateMap = new HashMap<>();
@@ -245,13 +282,334 @@
        BeanUtils.copyProperties(specialDevice,insertSpecialDeviceHistory);
        if (ObjectUtils.isEmpty(specialDeviceHistory)){
            specialDeviceHistoryMapper.insert(insertSpecialDeviceHistory);
            //操作日志记录
            HttpServletRequest request = ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
            StringBuilder content = new StringBuilder();
            content.append("添加了特殊设备历史数据：").append(insertSpecialDeviceHistory.getName()).append(":").append("mac：").append(insertSpecialDeviceHistory.getMac());
            LogUtils.saveOperationForManage(request, content.toString(), Constants.INSERT_OPERATE_TYPE);
        }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);
            //操作日志记录
            HttpServletRequest request = ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
            StringBuilder content = new StringBuilder();
            content.append("修改了特殊设备：").append(specialDeviceHistory.getId()).append("：");
            Field[] fields = SpecialDevice.class.getDeclaredFields();
            for (Field field : fields) {
                if (field.getName().equals("id")) {
                    continue;
                }
                if ("serialVersionUID".equals(field.getName())) {
                    continue;
                }
                String fieldName = field.getName();
                PropertyDescriptor pd = null;
                try {
                    pd = new PropertyDescriptor(fieldName, SpecialDeviceHistory.class);
                    Method method = pd.getReadMethod();
                    Object o1 = method.invoke(specialDeviceHistory);
                    Object o2 = method.invoke(insertSpecialDeviceHistory);
                    if (o2 != null) {
                        content.append(fieldName).append("：").append(o1).append("-->").append(o2).append(":");
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                }

            }
            LogUtils.saveOperationForManage(request, content.toString(), Constants.UPDATE_OPERATE_TYPE);
        }
        //Map<String, Object> deviceInfo = selectDeviceInfoById(specialDevice.getId());
        SpecialDeviceInfoDTO specialDeviceInfoDTO = selectDeviceInfoDTOById(specialDevice.getId());
        //维护组织型号关系表
        insertOrganizationUnitAlarm(specialDevice.getOrganizationId(), specialDevice.getDeviceVersionId());
        //新增设备信息存入redis
        String mac1 = specialDevice.getMac();
        //从redis中删除设备信息
        delDeviceInfoFromRedis(mac1);
        //设备信息存入redis
        setDeviceInfoToRedis(mac1, specialDeviceInfoDTO);
        //刷新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;
    }

    @Transactional
    @Override
    public void update(SpecialDevice specialDevice) {
        Integer specialDeviceId = specialDevice.getId();
        SpecialDevice oldSpecialDevice = specialDeviceMapper.selectById(specialDeviceId);
        specialDeviceMapper.updateById(specialDevice);
        SpecialDevice updateSpecialDevice = specialDeviceMapper.selectById(specialDeviceId);
        String oleMac = oldSpecialDevice.getMac();
        //维护组织型号关系表
        Integer oldOrgId = oldSpecialDevice.getOrganizationId();
        Integer newOrgId = updateSpecialDevice.getOrganizationId();
        Integer oldVersionId = oldSpecialDevice.getDeviceVersionId();
        Integer newVersionId = updateSpecialDevice.getDeviceVersionId();
        if (!oldOrgId.equals(newOrgId) || !oldVersionId.equals(newVersionId)) {
            deleteOrganizationUnitAlarm(oldOrgId, oldVersionId);
            insertOrganizationUnitAlarm(newOrgId, newVersionId);
        }
        //从redis中删除设备信息
        delDeviceInfoFromRedis(oleMac);
        SpecialDeviceInfoDTO specialDeviceInfoDTO = selectDeviceInfoDTOById(specialDevice.getId());
        //设备信息存入redis
        setDeviceInfoToRedis(updateSpecialDevice.getMac(), specialDeviceInfoDTO);
        //刷新deviceInfo缓存
        CacheUtils.refreshSpecialDeviceAlarmInfo();
        QueryWrapper<SpecialDeviceHistory> wrapper_specialDeviceHistory = new QueryWrapper<>();
        wrapper_specialDeviceHistory.eq("is_delete",Constants.NOT_DELETE);
        wrapper_specialDeviceHistory.eq("mac",updateSpecialDevice.getMac());
        wrapper_specialDeviceHistory.eq("organization_id",updateSpecialDevice.getOrganizationId());
        SpecialDeviceHistory specialDeviceHistory = specialDeviceHistoryMapper.selectOne(wrapper_specialDeviceHistory);
        SpecialDeviceHistory updateSpecialDeviceHistory = new SpecialDeviceHistory();
        BeanUtils.copyProperties(specialDevice,updateSpecialDeviceHistory);
        updateSpecialDeviceHistory.setCreateTime(null);
        updateSpecialDeviceHistory.setUpdateTime(null);
        updateSpecialDeviceHistory.setIsDelete(null);
        if (ObjectUtils.isEmpty(specialDeviceHistory)){
            specialDeviceHistoryMapper.insert(updateSpecialDeviceHistory);
            //操作日志记录
            HttpServletRequest request = ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
            StringBuilder content = new StringBuilder();
            content.append("添加了特殊设备历史数据：").append(updateSpecialDeviceHistory.getName()).append(":").append("mac：").append(updateSpecialDeviceHistory.getMac());
            LogUtils.saveOperationForManage(request, content.toString(), Constants.INSERT_OPERATE_TYPE);
        }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(updateSpecialDeviceHistory,wrapper_specialDeviceHistory);
            //操作日志记录
            HttpServletRequest request = ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
            StringBuilder content = new StringBuilder();
            content.append("修改了历史特殊设备：").append(specialDeviceHistory.getId()).append(";");
            Field[] fields = SpecialDevice.class.getDeclaredFields();
            for (Field field : fields) {
                if (field.getName().equals("id")) {
                    continue;
                }
                if ("serialVersionUID".equals(field.getName())) {
                    continue;
                }
                String fieldName = field.getName();
                PropertyDescriptor pd = null;
                try {
                    pd = new PropertyDescriptor(fieldName, SpecialDeviceHistory.class);
                    Method method = pd.getReadMethod();
                    Object o1 = method.invoke(specialDeviceHistory);
                    Object o2 = method.invoke(updateSpecialDeviceHistory);
                    if (o2 != null) {
                        content.append(fieldName).append("：").append(o1).append("-->").append(o2).append(";");
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                }

            }
            LogUtils.saveOperationForManage(request, content.toString(), Constants.UPDATE_OPERATE_TYPE);
        }
        //操作日志记录
        HttpServletRequest request = ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
        StringBuilder content = new StringBuilder();
        content.append("修改了特殊设备：").append(specialDeviceId).append(";");
        Field[] fields = SpecialDevice.class.getDeclaredFields();
        for (Field field : fields) {
            if (field.getName().equals("id")) {
                continue;
            }
            if ("serialVersionUID".equals(field.getName())) {
                continue;
            }
            String fieldName = field.getName();
            PropertyDescriptor pd = null;
            try {
                pd = new PropertyDescriptor(fieldName, SpecialDevice.class);
                Method method = pd.getReadMethod();
                Object o1 = method.invoke(oldSpecialDevice);
                Object o2 = method.invoke(specialDevice);
                if (o2 != null) {
                    content.append(fieldName).append("：").append(o1).append("-->").append(o2).append(";");
                }

            } catch (Exception e) {
                e.printStackTrace();
            }

        }
        LogUtils.saveOperationForManage(request, content.toString(), Constants.UPDATE_OPERATE_TYPE);
    }

    @Override
    public void delete(Integer specialDeviceId) {
        SpecialDevice specialDevice = specialDeviceMapper.selectById(specialDeviceId);
        UpdateWrapper<SpecialDevice> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("id",specialDeviceId).set("is_delete",Constants.DELETE);
        specialDeviceMapper.update(null,updateWrapper);
        String mac = specialDevice.getMac();
        //从redis中删除设备信息
        delDeviceInfoFromRedis(mac);
        //维护组织型号关系表
        Integer versionId = specialDevice.getDeviceVersionId();
        Integer orgId = specialDevice.getOrganizationId();
        deleteOrganizationUnitAlarm(orgId, versionId);
        //刷新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.DELETE_OPERATE_TYPE);
    }

    @Override
    public Map<String, Object> selectDeviceInfoById(Integer deviceId) {
        return null;
    }

    @Override
    public SpecialDeviceInfoDTO selectDeviceInfoDTOById(Integer deviceId) {
        String mac = specialDeviceMapper.selectById(deviceId).getMac();
        SpecialDeviceInfoDTO specialDeviceInfoDTO = new SpecialDeviceInfoDTO();
        SpecialDeviceInfoDTO specialDeviceInfoDTORedis = getDeviceInfoFromRedis(mac);
        //先从redis中取
        if (specialDeviceInfoDTORedis != null) {
            return specialDeviceInfoDTORedis;
        }

        //存放特殊设备信息
        SpecialDevice specialDeviceInfo = new SpecialDevice();
        SpecialDevice specialDevice = specialDeviceMapper.selectById(deviceId);
        System.out.println(specialDevice);
        /*specialDeviceInfo.setId(specialDevice.getId());
        specialDeviceInfo.setName(specialDevice.getName());
        specialDeviceInfo.setMac(specialDevice.getMac());
        specialDeviceInfo.setCreateTime(specialDevice.getCreateTime());*/
        specialDeviceInfoDTO.setSpecialDevice(specialDevice);

        //存放政府站点信息
        GovMonitorPoint govMonitorPointInfo = new GovMonitorPoint();
        QueryWrapper<GovMonitorPoint> wrapper_govMonitorPoint = new QueryWrapper<>();
        wrapper_govMonitorPoint.eq("is_delete",Constants.NOT_DELETE);
        wrapper_govMonitorPoint.eq("guid",specialDevice.getGuid());
        GovMonitorPoint govMonitorPoint = govMonitorPointMapper.selectOne(wrapper_govMonitorPoint);
        /*govMonitorPointInfo.setId(govMonitorPoint.getId());
        govMonitorPointInfo.setGuid(govMonitorPoint.getGuid());
        govMonitorPointInfo.setName(govMonitorPoint.getName());*/
        specialDeviceInfoDTO.setGovMonitorPoint(govMonitorPoint);

        //存放型号信息
        Version versionInfo = new Version();
        Version version = versionMapper.selectById(specialDevice.getDeviceVersionId());
        /*versionInfo.setId(version.getId());
        versionInfo.setName(version.getName());*/
        specialDeviceInfoDTO.setVersion(version);

        //存放维护人
        List<ManageAccount> 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);
                operatorsInfo = manageAccountMapper.selectList(wapper_manageAccount);
            }
        }
        specialDeviceInfoDTO.setOperates(operatorsInfo);

        //存放组织
        Organization organizationInfo = new Organization();
        organizationInfo = organizationMapper.selectById(specialDevice.getOrganizationId());
        specialDeviceInfoDTO.setOrganization(organizationInfo);

        return specialDeviceInfoDTO;
    }

    @Override
    public Map<String, Object> adjustSpecialDeviceData(Map<String, Object> deviceData) {
        String mac = deviceData.remove("mac").toString();
        //从redis获取校准公式
        Map<String, Object> adjustFormula = redisTemplate.opsForHash().entries(RedisConstants.ADJUST + "_" + mac);
        if (!org.springframework.util.ObjectUtils.isEmpty(adjustFormula)) {
            SpecialDeviceInfoDTO specialDeviceInfo = getDeviceInfoFromRedis(mac);
            if (org.springframework.util.ObjectUtils.isEmpty(specialDeviceInfo)) {
                QueryWrapper<SpecialDevice> queryWrapper = new QueryWrapper<>();
                queryWrapper.eq("mac", mac).eq("is_delete", Constants.NOT_DELETE);
                SpecialDevice specialDevice = specialDeviceMapper.selectOne(queryWrapper);
                if (specialDevice != null) {
                    specialDeviceInfo = selectDeviceInfoDTOById(specialDevice.getId());
                    setDeviceInfoToRedis(mac, specialDeviceInfo);
                }
            }
            //获取设备绑定的国控站信息
            Map<String, Object> govMpInfo = (Map<String, Object>) specialDeviceInfo.getGovMonitorPoint();
            Map<String, Object> aqiMap = null;
            if (govMpInfo.get("guid") != null) {
                aqiMap = (Map<String, Object>) redisTemplate.opsForHash().get(RedisConstants.AQI_DATA, govMpInfo.get("guid").toString());
            }
            return adjustDataUtils.adjust(deviceData, adjustFormula, org.springframework.util.ObjectUtils.isEmpty(aqiMap) ? null : aqiMap);
        }
        deviceData.remove("DataTime");
        return deviceData;
    }

    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);
                }
            }
        }
    }

    private void deleteOrganizationUnitAlarm(Integer orgId, Integer versionId) {
        QueryWrapper<SpecialDevice> queryOrganizationVersionWrapper = new QueryWrapper<>();
        queryOrganizationVersionWrapper.eq("organization_id", orgId);
        queryOrganizationVersionWrapper.eq("device_version_id", versionId);
        queryOrganizationVersionWrapper.eq("is_delete", Constants.NOT_DELETE);
        List<SpecialDevice> specialDevices = specialDeviceMapper.selectList(queryOrganizationVersionWrapper);
        if (org.springframework.util.ObjectUtils.isEmpty(specialDevices)) {//如果为空，则组织没有该型号的设备了。
            UpdateWrapper deleteWrapper = new UpdateWrapper();
            deleteWrapper.eq("organization_id", orgId);
            deleteWrapper.eq("version_id", versionId);
            deleteWrapper.eq("is_delete", Constants.NOT_DELETE);
            deleteWrapper.set("is_delete", Constants.DELETE);
            organizationUnitAlarmMapper.update(null, deleteWrapper);
        }
    }
}