Code/sms_water/src/main/java/com/huaxu/service/impl/AlarmDetailsServiceImpl.java

package com.huaxu.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.huaxu.client.OperationManagerClient;
import com.huaxu.client.UserCenterClient;
import com.huaxu.dao.AlarmDetailMapper;
import com.huaxu.dto.*;
import com.huaxu.entity.AlarmDetailsEntity;
import com.huaxu.entity.Message;
import com.huaxu.model.LoginUser;
import com.huaxu.service.AlarmDetailsService;
import com.huaxu.util.DatesUtil;
import com.huaxu.util.MessageSendUtil;
import com.huaxu.util.UserUtil;
import lombok.extern.log4j.Log4j2;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @description
 * @auto wangli
 * @data 2020-11-17 15:48
 */
@Service
@Log4j2
public class AlarmDetailsServiceImpl implements AlarmDetailsService {

    @Resource
    private AlarmDetailMapper alarmDetailMapper;
    @Autowired
    private OperationManagerClient operationManagerClient;
    @Autowired
    private UserCenterClient userCenterClient;
    @Autowired
    private MessageSendUtil messageSendUtil;

    @Override
    public AlarmDetailsDto selectById(Integer id) {
        return alarmDetailMapper.selectById(id);
    }

    @Override
    public List<AlarmDetailsDto> selectByDeviceId(Integer deviceId) {
        return alarmDetailMapper.selectByDeviceId(deviceId);
    }

    @Override
    public List<AlarmDetailsRealTimeDto> selectRealTimeByIds(List<Integer> ids) {
        return alarmDetailMapper.selectRealTimeByIds(ids);
    }
    @Override
    public List<AlarmDetailsHistoryDto> selectHistoryByIds(List<Integer> ids) {
        return alarmDetailMapper.selectHistoryByIds(ids);
    }
    @Override
    public Integer insert(AlarmDetailsEntity alarmDetailsEntity) {
        return alarmDetailMapper.insert(alarmDetailsEntity);
    }

    @Override
    public Integer batchInsert(List<AlarmDetailsEntity> alarmDetails) {
        return alarmDetailMapper.batchInsert(alarmDetails);
    }

    @Override
    public Integer deleteById(Integer id) {
        return alarmDetailMapper.deleteById(id);
    }

    @Override
    public Integer batchDelete(List<Integer> ids) {

        return alarmDetailMapper.batchDelete(ids);
    }

    @Override
    public Integer suspendedById(Integer id , Integer opState) {
        LoginUser loginUser = UserUtil.getCurrentUser();
        return alarmDetailMapper.suspendedById(id,opState,new Date(),loginUser.getUsername());
    }

    @Override
    public Integer update(AlarmDetailsEntity alarmDetailsEntity) {
        return alarmDetailMapper.update(alarmDetailsEntity);
    }

    @Override
    public List<AlarmDetailsDto> selectList(AlarmDetailsDto alarmDetailsDto) {
        LoginUser loginUser = UserUtil.getCurrentUser();
        alarmDetailsDto.setTenantId(loginUser.getTenantId());
        alarmDetailsDto.setProgramItems(loginUser.getProgramItemList());
        alarmDetailsDto.setUserType(loginUser.getType());
        //1是公司，2是公司及以下，3部门，4部门及以下，5自定义
        alarmDetailsDto.setPermissonType(loginUser.getPermissonType());
        return alarmDetailMapper.selectList(alarmDetailsDto);
    }

    @Override
    public IPage<AlarmDetailsDto> selectPage(IPage<AlarmDetailsDto> page, AlarmDetailsDto alarmDetailsDto) {
        LoginUser loginUser = UserUtil.getCurrentUser();
        alarmDetailsDto.setTenantId(loginUser.getTenantId());
        alarmDetailsDto.setProgramItems(loginUser.getProgramItemList());
        alarmDetailsDto.setUserType(loginUser.getType());
        //1是公司，2是公司及以下，3部门，4部门及以下，5自定义
        alarmDetailsDto.setPermissonType(loginUser.getPermissonType());
        return alarmDetailMapper.selectPage(page,alarmDetailsDto);
    }

    @Override
    public List<AlarmDetailsRealTimeDto> selectRealTimeList(AlarmDetailsDto alarmDetailsDto) {
        LoginUser loginUser = UserUtil.getCurrentUser();
        alarmDetailsDto.setTenantId(loginUser.getTenantId());
        alarmDetailsDto.setProgramItems(loginUser.getProgramItemList());
        alarmDetailsDto.setUserType(loginUser.getType());
        //1是公司，2是公司及以下，3部门，4部门及以下，5自定义
        alarmDetailsDto.setPermissonType(loginUser.getPermissonType());
        return alarmDetailMapper.selectRealTimeList(alarmDetailsDto);
    }

    @Override
    public IPage<AlarmDetailsRealTimeDto> selectRealTimePage(IPage<AlarmDetailsRealTimeDto> page, AlarmDetailsDto alarmDetailsDto) {
        LoginUser loginUser = UserUtil.getCurrentUser();
        alarmDetailsDto.setTenantId(loginUser.getTenantId());
        alarmDetailsDto.setProgramItems(loginUser.getProgramItemList());
        alarmDetailsDto.setUserType(loginUser.getType());
        //1是公司，2是公司及以下，3部门，4部门及以下，5自定义
        alarmDetailsDto.setPermissonType(loginUser.getPermissonType());
        return alarmDetailMapper.selectRealTimePage(page,alarmDetailsDto);
    }

    @Override
    public List<AlarmDetailsHistoryDto> selectHistoryList(AlarmDetailsDto alarmDetailsDto) {
        LoginUser loginUser = UserUtil.getCurrentUser();
        alarmDetailsDto.setTenantId(loginUser.getTenantId());
        alarmDetailsDto.setProgramItems(loginUser.getProgramItemList());
        alarmDetailsDto.setUserType(loginUser.getType());
        //1是公司，2是公司及以下，3部门，4部门及以下，5自定义
        alarmDetailsDto.setPermissonType(loginUser.getPermissonType());
        return alarmDetailMapper.selectHistoryList(alarmDetailsDto);
    }

    @Override
    public IPage<AlarmDetailsHistoryDto> selectHistoryPage(IPage<AlarmDetailsHistoryDto> page, AlarmDetailsDto alarmDetailsDto) {
        LoginUser loginUser = UserUtil.getCurrentUser();
        alarmDetailsDto.setTenantId(loginUser.getTenantId());
        alarmDetailsDto.setProgramItems(loginUser.getProgramItemList());
        alarmDetailsDto.setUserType(loginUser.getType());
        //1是公司，2是公司及以下，3部门，4部门及以下，5自定义
        alarmDetailsDto.setPermissonType(loginUser.getPermissonType());
        return alarmDetailMapper.selectHistoryPage(page,alarmDetailsDto);
    }


    public void checkStateAlarm(){
        //所有设备数据
        List<DeviceCheckAlarmDto> deviceCheckAlarmDtos = alarmDetailMapper.selectDeviceForCheckAlarm(null,"状态报警");
        //根据设置筛选出离线设备
        List<DeviceCheckAlarmDto>  alarmlist = deviceCheckAlarmDtos.stream().filter(deviceCheckAlarmDto -> deviceCheckAlarmDto.checkdeviceOffLine()).collect(Collectors.toList());
        //系统中已存在的离线报警
        List<AlarmDetailsDto> alarmDetailsDtos = alarmDetailMapper.selectStateAlarm(null,"状态报警");
        //已存在的报警信息转为map方便匹配
        Map<Integer,AlarmDetailsDto> alarmDetailsDtoMap = alarmDetailsDtos.stream().collect(Collectors.toMap(AlarmDetailsDto::getAlarmSettingId, a -> a,(k1, k2)->k1));
        //需要新增的
        List<AlarmDetailsEntity>  deviceStateAlarmDtoNews =alarmlist.stream()
                .filter(deviceCheckAlarmDto -> !alarmDetailsDtoMap.containsKey(deviceCheckAlarmDto.getAlarmSettingId()))
                .map(d ->{
                    AlarmDetailsEntity alarmDetailsEntity = new AlarmDetailsEntity();
                    alarmDetailsEntity.setDateUpdate(new Date());
                    alarmDetailsEntity.setDateCreate(new Date());
                    alarmDetailsEntity.setStatus(1);
                    alarmDetailsEntity.setOpState(1);
                    alarmDetailsEntity.setState(1);
                    alarmDetailsEntity.setParentSceneId(d.getParentSceneId());
                    alarmDetailsEntity.setParentSceneName(d.getParentSceneName());
                    alarmDetailsEntity.setSceneId(d.getSceneId());
                    alarmDetailsEntity.setSceneName(d.getSceneName());
                    alarmDetailsEntity.setAlarmStartTime(new Date());
                    alarmDetailsEntity.setAlarmContent(d.getDeviceName()+"离线时间"+d.getAlarmCondition() +d.getAlarmValue()+"分钟");
                    alarmDetailsEntity.setAlarmValue(d.getDuration());
                    alarmDetailsEntity.setAttributeId(d.getAttributeId());
                    alarmDetailsEntity.setAlarmType("状态报警");
                    alarmDetailsEntity.setDeptOrgId(d.getDeptOrgId());
                    alarmDetailsEntity.setCompanyOrgId(d.getCompanyOrgId());
                    alarmDetailsEntity.setDeviceId(d.getDeviceId());
                    alarmDetailsEntity.setTenantId(d.getTenantId());
                    alarmDetailsEntity.setAlarmSettingId(d.getAlarmSettingId());

                    Message message=new Message();
                    message.setStatus(1);
                    message.setTenantId(d.getTenantId());
                    message.setMessageId(UUID.randomUUID().toString());
                    JSONObject jsonObject = new JSONObject();
                    //${场景名称}${设备名称}${状态}${报警规则}【${数值单位}】
                    jsonObject.put("场景名称",d.getSceneName());
                    jsonObject.put("设备名称",d.getDeviceName());
                    jsonObject.put("状态","离线");
                    jsonObject.put("报警规则",d.getAlarmCondition() +d.getAlarmValue());
                    jsonObject.put("数值单位","分钟");
                    message.setMessageContent(jsonObject.toJSONString());  //消息内容，如果需要动态使用，配合模板使用{key:value}
                    message.setMessageType(2); //消息类型
                    message.setMessageTemplateId(2);   //模板id
                    message.setChannel(0);   //渠道
                    Integer companyOrgId = d.getCompanyOrgId();
                    Integer departmentOrgId = d.getDeptOrgId();
                    List<Integer> taskUsers = userCenterClient.findUserIdsByPermissonOrg(d.getTenantId(),companyOrgId,departmentOrgId);
                    try{
                        if(taskUsers!=null){
                            taskUsers.forEach(id->{
                                message.setUserId(id);
                                messageSendUtil.send(message);
                            });
                        }
                    }catch(Exception e){
                        e.printStackTrace();
                        log.info("推送报警消息失败：{}"+e.getMessage());
                    }
                    return alarmDetailsEntity;
                })
                .collect(Collectors.toList());
        if(deviceStateAlarmDtoNews.size()>0){
            alarmDetailMapper.batchInsert(deviceStateAlarmDtoNews);
        }

        //需要更新的
        List<AlarmDetailsEntity>  deviceStateAlarmDtoOlds =alarmlist.stream()
                .filter(deviceCheckAlarmDto -> alarmDetailsDtoMap.containsKey(deviceCheckAlarmDto.getAlarmSettingId()))
                .map(d ->{
                    AlarmDetailsDto alarmDetailsDto = alarmDetailsDtoMap.get(d.getAlarmSettingId());
                    alarmDetailsDto.setDateUpdate(new Date());
                    alarmDetailsDto.setAlarmContent(d.getDeviceName()+"离线时间"+d.getAlarmCondition() +d.getAlarmValue()+"分钟");
                    alarmDetailsDto.setAlarmValue(d.getDuration());
                    alarmDetailMapper.update(alarmDetailsDto);//直接更新
                    alarmDetailsDtoMap.remove(d.getAlarmSettingId());//更新完成后从集合中移除，只剩下未处理的
                    return alarmDetailsDto;
                })
                .collect(Collectors.toList());
        //集合中剩下未处理的需要修改状态
        Long currentTime =System.currentTimeMillis();
        for(AlarmDetailsDto alarmDetailsDto:alarmDetailsDtoMap.values()){
            alarmDetailsDto.setDateUpdate(new Date());
            //从对象中拿到时间
            Long startTime = alarmDetailsDto.getAlarmStartTime().getTime();
            Long diff=(currentTime-startTime)/1000/60;
            alarmDetailsDto.setAlarmValue(diff.doubleValue());
            alarmDetailsDto.setAlarmEndTime(new Date());
            alarmDetailsDto.setState(0);
            alarmDetailMapper.update(alarmDetailsDto);//直接更新
        }

        //报警恢复的删除工单
        Map<Integer,AlarmDetailsEntity> AlarmDtoNewsMap =  deviceStateAlarmDtoNews.stream().collect(Collectors.toMap(AlarmDetailsEntity::getDeviceId, a -> a,(k1, k2)->k1));
        Map<Integer,AlarmDetailsEntity> AlarmDtoOldsMap =  deviceStateAlarmDtoOlds.stream().collect(Collectors.toMap(AlarmDetailsEntity::getDeviceId, a -> a,(k1, k2)->k1));
        Set<Long> deviceIds = alarmDetailsDtoMap.values().stream()
                .filter(a -> !(AlarmDtoNewsMap.containsKey(a.getDeviceId())||AlarmDtoOldsMap.containsKey(a.getDeviceId())))
                .map(a -> a.getDeviceId().longValue())
                .collect(Collectors.toSet());
        if(deviceIds.size()>0){
            operationManagerClient.batchDeleteByAlarms(new ArrayList<>(deviceIds));
        }
    }

   public void saveWorkOrderManageInfo(){
       List<DeviceAlarmInfoForOrder> deviceAlarmInfoForOrders = alarmDetailMapper.getAlarmInfoForWorkOrderManage();
       if(deviceAlarmInfoForOrders.size()>0){

           //获取已经存在的设备工单
           Set<Long> deviceIdSet = deviceAlarmInfoForOrders.stream().map(DeviceAlarmInfoForOrder::getDeviceId).collect(Collectors.toSet());
           List<WorkOrderManageByAlarmDto> workOrders = operationManagerClient.findWorkOrderByDeviceIds(new ArrayList<>(deviceIdSet));
           Map<Long,WorkOrderManageByAlarmDto> workOrderMap = workOrders.stream().collect(Collectors.toMap(WorkOrderManageByAlarmDto::getDeviceId, Function.identity(), (key1, key2) -> key2));

           List<WorkOrderManageByAlarmDto> workOrderManageByAlarms = new ArrayList<>();
           List<WorkOrderManageByAlarmDto> updates = new ArrayList<>();
           List<DeviceAlarmInfoForOrder> errData= new ArrayList<>();

           //组合工单，并发送消息
           for(DeviceAlarmInfoForOrder deviceAlarmInfoForOrder : deviceAlarmInfoForOrders){
               if(workOrderMap.containsKey(deviceAlarmInfoForOrder.getDeviceId()) && workOrderMap.get(deviceAlarmInfoForOrder.getDeviceId()) != null){
                   WorkOrderManageByAlarmDto orderManageByAlarmDto = workOrderMap.get(deviceAlarmInfoForOrder.getDeviceId());
                   orderManageByAlarmDto.setTaskDesc(orderManageByAlarmDto.getTaskDesc()+";"+deviceAlarmInfoForOrder.getTaskDesc());
                   updates.add(orderManageByAlarmDto);
                   continue;
               }
               WorkOrderManageByAlarmDto workOrderManageByAlarm = new WorkOrderManageByAlarmDto();
               workOrderManageByAlarm.setTaskNo(DatesUtil.formatDate(new Date(),"yyyyMMddHHmmssSSS")+((int) (Math.random()*(9999-1000)+1000)));
               workOrderManageByAlarm.setTenantId(deviceAlarmInfoForOrder.getTenantId());
               workOrderManageByAlarm.setParentSceneId(deviceAlarmInfoForOrder.getParentSceneId());
               workOrderManageByAlarm.setParentSceneName(deviceAlarmInfoForOrder.getParentSceneName());
               workOrderManageByAlarm.setDeviceId(deviceAlarmInfoForOrder.getDeviceId());
               workOrderManageByAlarm.setDeviceName(deviceAlarmInfoForOrder.getDeviceName());
               workOrderManageByAlarm.setCompanyOrgId(deviceAlarmInfoForOrder.getCompanyOrgId());
               workOrderManageByAlarm.setDepartmentOrgId(deviceAlarmInfoForOrder.getDepartmentOrgId());
               workOrderManageByAlarm.setAddress(deviceAlarmInfoForOrder.getAddress());
               workOrderManageByAlarm.setGeo(deviceAlarmInfoForOrder.getGeo());
               workOrderManageByAlarm.setOrderTime(deviceAlarmInfoForOrder.getOrderTime());
               workOrderManageByAlarm.setTaskDesc(deviceAlarmInfoForOrder.getTaskDesc());


               Message message=new Message();
               message.setStatus(1);
               message.setTenantId(deviceAlarmInfoForOrder.getTenantId());
               message.setMessageId(UUID.randomUUID().toString());
               JSONObject jsonObject = new JSONObject();
               jsonObject.put("工单类型"," ");
               jsonObject.put("工单编号",workOrderManageByAlarm.getTaskNo());
               message.setMessageContent(jsonObject.toJSONString());  //消息内容，如果需要动态使用，配合模板使用{key:value}
               message.setMessageType(7); //消息类型
               message.setMessageTemplateId(7);   //模板id
               message.setChannel(0);   //渠道
               Integer companyOrgId = null;
               Integer departmentOrgId = null;
               if(StringUtils.isNotBlank(workOrderManageByAlarm.getCompanyOrgId())){
                   companyOrgId=Integer.valueOf(workOrderManageByAlarm.getCompanyOrgId());
               }
               if(StringUtils.isNotBlank(workOrderManageByAlarm.getDepartmentOrgId())){
                   departmentOrgId=Integer.valueOf(workOrderManageByAlarm.getDepartmentOrgId());
               }
               try{
                   List<Integer> taskUsers = userCenterClient.findUserIdsByPermissonOrg(workOrderManageByAlarm.getTenantId(),companyOrgId,departmentOrgId);
                   if(taskUsers!=null){
                       taskUsers.forEach(id->{
                           message.setUserId(id);
                           messageSendUtil.send(message);
                       });
                   }
                   workOrderManageByAlarms.add(workOrderManageByAlarm);
               }catch (Exception e){
                   e.printStackTrace();
                   errData.add(deviceAlarmInfoForOrder);
               }
           }
           //去掉推送失败的数据
           if(errData.size()>0){
               deviceAlarmInfoForOrders.removeAll(errData);
           }
           //保存工单
           if(workOrderManageByAlarms.size()>0){
                operationManagerClient.saveByAlarms(workOrderManageByAlarms);
           }
           if(updates.size()>0){
                operationManagerClient.updateByAlarms(updates);
           }
           if(deviceAlarmInfoForOrders.size()>0){
               //标记报警已生成工单
               alarmDetailMapper.updateAlarmSendMessageState(deviceAlarmInfoForOrders);
           }
       }
   }


}