wisdomisite-java/src/main/java/com/zhgd/xmgl/task/StandardDevTask.java

package com.zhgd.xmgl.task;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.zhgd.jeecg.common.mybatis.EntityMap;
import com.zhgd.jeecg.common.util.HuaWeiMessageUtils;
import com.zhgd.xmgl.modules.basicdata.entity.Notice;
import com.zhgd.xmgl.modules.basicdata.service.INoticeService;
import com.zhgd.xmgl.modules.project.entity.Project;
import com.zhgd.xmgl.modules.project.mapper.ProjectMapper;
import com.zhgd.xmgl.modules.standard.entity.StandardAlarm;
import com.zhgd.xmgl.modules.standard.entity.StandardContinuityAlarm;
import com.zhgd.xmgl.modules.standard.entity.StandardCurrentData;
import com.zhgd.xmgl.modules.standard.entity.StandardDev;
import com.zhgd.xmgl.modules.standard.mapper.*;
import com.zhgd.xmgl.util.StandardDevUtil;
import lombok.extern.log4j.Log4j;
import lombok.extern.slf4j.Slf4j;
import net.javacrumbs.shedlock.core.SchedulerLock;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @program: wisdomSite
 * @description: 标养室定时任务
 * @author: Mr.Peng
 * @create: 2021-05-12 14:23
 **/
@Slf4j
@Component
@RestController
public class StandardDevTask {

    @Autowired
    private StandardCurrentDataMapper standardCurrentDataMapper;
    @Autowired
    private StandardContinuityAlarmMapper standardContinuityAlarmMapper;
    @Autowired
    private StandardDevMapper standardDevMapper;
    @Autowired
    private INoticeService noticeService;
    @Autowired
    private StandardAlarmMapper standardAlarmMapper;
    @Autowired
    private StandardDevRealTimeDataMapper standardDevRealTimeDataMapper;
    @Autowired
    private ProjectMapper projectMapper;

    @Value("${isGetStandardData}")
    private boolean isGetStandardData;
    @Value("${sms.hw.notice.templateId.standardAlarm}")
    private String templateId;

    /**
     * 根据实时数据计算每15分钟标养室是否报警
     */
    @Scheduled(cron = "0 0/15 * * * ?")
    @SchedulerLock(name = "totalStandardAlarmTypeTask", lockAtMostFor = 1000 * 60 * 10, lockAtLeastFor = 1000 * 60 * 3)
    public void totalStandardAlarmTypeTask() {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
            String time = sdf.format(new Date());
            List<EntityMap> list = standardCurrentDataMapper.selectStandardCurrentDataTotalAlarmStateList();
            if (list.size() > 0) {
                for (EntityMap map : list) {
                    StandardContinuityAlarm standardContinuityAlarm = new StandardContinuityAlarm();
                    standardContinuityAlarm.setProjectSn(MapUtils.getString(map, "projectSn"));
                    standardContinuityAlarm.setDevSn(MapUtils.getString(map, "devSn"));
                    standardContinuityAlarm.setAlarmState(MapUtils.getInteger(map, "alarmType"));
                    standardContinuityAlarm.setQueryTime(time);
                    standardContinuityAlarmMapper.insert(standardContinuityAlarm);
                }

            }
        } catch (Exception e) {
            log.error("error：", e);
        }
    }

    private void addNotice(StandardDev dev, String alarmPushWorkerId) {
        try {
            if (StringUtils.isNotEmpty(alarmPushWorkerId) && alarmPushWorkerId.length() > 0) {
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                int size = alarmPushWorkerId.split(",").length;
                String title = dev.getLaboratoryName() + "标养室报警";
                String msg = dev.getLaboratoryName() + "标养室报警,请及时处理";
                for (int i = 0; i < size; i++) {
                    Notice notice = new Notice();
                    notice.setAccountId(Long.valueOf(alarmPushWorkerId.split(",")[i]));
                    notice.setMsg(msg);
                    notice.setTitle(title);
                    notice.setSendTime(sdf.format(new Date()));
                    notice.setType("9");
                    noticeService.addNotice(notice, true);
                }
            }
        } catch (Exception e) {
            log.error("error：", e);
        }

    }

    private void sendSms(StandardDev dev, String alarmPushPhone, int hour) {
        try {
            if (StringUtils.isNotEmpty(alarmPushPhone) && alarmPushPhone.length() > 0 && !"[]".equals(alarmPushPhone)) {
                JSONArray array = JSONArray.parseArray(alarmPushPhone);
                String signature = "华为云短信测试";
                //短信模板ID
                //String templateId = "790d907f70594b4893227fc1d97e78bc";
                //模板参数
                String context = dev.getProjectName() + "," + dev.getLaboratoryName() + "," + hour;
                for (int i = 0; i < array.size(); i++) {
                    JSONObject obj = array.getJSONObject(i);
                    String lxPhone = obj.getString("phone");
                    if (StringUtils.isNotEmpty(lxPhone)) {
                        String receiver = "+86" + lxPhone;
                        //催收防欠项目任务负责人负责人提醒
                        HuaWeiMessageUtils.sendNoticeSms(templateId, signature, receiver, context);
                    }
                }
            }
        } catch (Exception e) {
            log.error("error：", e);
        }
    }

    /**
     * 1小时报警推送
     */
    @Scheduled(cron = "0 0 */1 * * ?")
    @SchedulerLock(name = "oneHourTask", lockAtMostFor = 1000 * 60 * 30, lockAtLeastFor = 1000 * 60 * 5)
    public void oneHourTask() {
        try {

            List<StandardDev> list = standardDevMapper.selectContinuityAlarmDev(1);
            log.info("----------------------标养室1小时报警推送---------------------------------任务数：" + list.size());
            if (list != null && list.size() > 0) {
                for (StandardDev dev : list) {
                    addNotice(dev, dev.getOneHourPushWorkerId());
                    sendSms(dev, dev.getOneHourPushPhone(), 1);
                    //添加报警记录
                    addStandardAlarm(dev);
                }
            }
        } catch (Exception e) {
            log.error("error：", e);
        }
    }

    private void addStandardAlarm(StandardDev dev) {
        java.text.DateFormat format1 = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        StandardAlarm standardAlarm = new StandardAlarm();
        standardAlarm.setAlarmTime(format1.format(new Date()));
        standardAlarm.setAlarmType("温湿度异常");
        standardAlarm.setProjectSn(dev.getProjectSn());
        standardAlarm.setDevSn(dev.getDevSn());
        standardAlarmMapper.insert(standardAlarm);
    }

    /**
     * 2小时报警推送
     */
    @Scheduled(cron = "0 0 */2 * * ?")
    @SchedulerLock(name = "twoHourTask", lockAtMostFor = 1000 * 60 * 30, lockAtLeastFor = 1000 * 60 * 5)
    public void twoHourTask() {
        try {
            List<StandardDev> list = standardDevMapper.selectContinuityAlarmDev(2);
            if (list != null && list.size() > 0) {
                for (StandardDev dev : list) {
                    addNotice(dev, dev.getTwoHourPushWorkerId());
                    sendSms(dev, dev.getTwoHourPushPhone(), 2);
                }
            }
        } catch (Exception e) {
            log.error("error：", e);
        }
    }

    /**
     * 3小时报警推送
     */
    @Scheduled(cron = "0 0 */3 * * ?")
    @SchedulerLock(name = "threeHourTask", lockAtMostFor = 1000 * 60 * 30, lockAtLeastFor = 1000 * 60 * 5)
    public void threeHourTask() {
        try {
            List<StandardDev> list = standardDevMapper.selectContinuityAlarmDev(3);
            if (list != null && list.size() > 0) {
                for (StandardDev dev : list) {
                    addNotice(dev, dev.getThreeHourPushWorkerId());
                    sendSms(dev, dev.getThreeHourPushPhone(), 3);
                }
            }
        } catch (Exception e) {
            log.error("error：", e);
        }
    }

    /**
     * 12小时报警推送
     */
    @Scheduled(cron = "0 0 */6 * * ?")
    @SchedulerLock(name = "twelveHourTask", lockAtMostFor = 1000 * 60 * 30, lockAtLeastFor = 1000 * 60 * 5)
    public void twelveHourTask() {
        try {
            List<StandardDev> list = standardDevMapper.selectContinuityAlarmDev(5);
            if (list != null && list.size() > 0) {
                for (StandardDev dev : list) {
                    addNotice(dev, dev.getTwelveHourPushWorkerId());
                    sendSms(dev, dev.getTwelveHourPushPhone(), 12);

                }
            }
        } catch (Exception e) {
            log.error("error：", e);
        }
    }

    /**
     * 6小时报警推送
     */
    @Scheduled(cron = "0 0 */6 * * ?")
    @SchedulerLock(name = "sixHourTask", lockAtMostFor = 1000 * 60 * 30, lockAtLeastFor = 1000 * 60 * 5)
    public void sixHourTask() {
        try {
            List<StandardDev> list = standardDevMapper.selectContinuityAlarmDev(4);
            if (list != null && list.size() > 0) {
                for (StandardDev dev : list) {
                    addNotice(dev, dev.getSixHourPushWorkerId());
                    sendSms(dev, dev.getSixHourPushPhone(), 6);

                }
            }
        } catch (Exception e) {
            log.error("error：", e);
        }
    }

    /**
     * 24小时报警推送
     */
    @Scheduled(cron = "0 0 */24 * * ?")
    @SchedulerLock(name = "twelveFourHourTask", lockAtMostFor = 1000 * 60 * 30, lockAtLeastFor = 1000 * 60 * 5)
    public void twelveFourHourTask() {
        try {
            List<StandardDev> list = standardDevMapper.selectContinuityAlarmDev(6);
            if (list != null && list.size() > 0) {
                for (StandardDev dev : list) {
                    addNotice(dev, dev.getTwelveFourHourPushWorkerId());
                    sendSms(dev, dev.getTwelveFourHourPushPhone(), 24);
                }
            }
        } catch (Exception e) {
            log.error("error：", e);
        }
    }

    /**
     * 定时调用外部接口拉取设备实时数据
     */
    @Scheduled(cron = "0 0/2 * * * ?")
    @SchedulerLock(name = "getStandardData", lockAtMostFor = 1000 * 60 * 2, lockAtLeastFor = 1000 * 60 * 1)
    @RequestMapping("/xmgl/task/getStandardData")
    public void getStandardData() {
        try {
            log.info("------------拉取执行标样室时数据任务开始---------");
            List<Project> projectList = projectMapper.selectList(new LambdaQueryWrapper<Project>()
                    .ne(Project::getJnrzckAccount, "")
                    .isNotNull(Project::getJnrzckAccount)
                    .ne(Project::getJnrzckPw, "")
                    .isNotNull(Project::getJnrzckPw)
            );
            for (Project project : projectList) {
                LambdaQueryWrapper<StandardDev> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(StandardDev::getProjectSn, project.getProjectSn());
                List<StandardDev> list = standardDevMapper.selectList(queryWrapper);
                if (list != null && list.size() > 0) {
                    JSONArray array = StandardDevUtil.getDeviceData("", project.getJnrzckAccount(), project.getJnrzckPw());
                    for (StandardDev dev : list) {
                        List<Double> temperatureList = new ArrayList<>();
                        List<Double> humidityList = new ArrayList<>();
                        if (array != null && array.size() > 0) {
                            for (int i = 0; i < array.size(); i++) {
                                JSONObject obj = array.getJSONObject(i);
                                if (dev.getDevSn().equals(obj.getString("deviceAddr"))) {
                                    //判断设备是否在线
                                    if ("2".equals(obj.getString("deviceStatus"))) {
                                        JSONArray jsonArray = obj.getJSONArray("realTimeData");
                                        if (jsonArray != null && jsonArray.size() > 0) {
                                            for (int a = 0; a < jsonArray.size(); a++) {
                                                JSONObject obj2 = jsonArray.getJSONObject(a);
                                                if (obj2.getString("dataName").indexOf("温度") >= 0) {
                                                    if (StringUtils.isNotEmpty(obj2.getString("dataValue")) && obj2.getDouble("dataValue") != 0d) {
                                                        temperatureList.add(Double.valueOf(obj2.getString("dataValue")));
                                                    }
                                                } else if (obj2.getString("dataName").indexOf("湿度") >= 0) {
                                                    if (StringUtils.isNotEmpty(obj2.getString("dataValue")) && obj2.getDouble("dataValue") != 0d) {
                                                        humidityList.add(Double.valueOf(obj2.getString("dataValue")));
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            //没有数据不插入
                            if (temperatureList.size() > 0 || temperatureList.size() > 0) {
                                DecimalFormat df = new DecimalFormat("#.00");
                                StandardCurrentData standardCurrentData = new StandardCurrentData();
                                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                                standardCurrentData.setReceiveTime(sdf.format(new Date()));
                                standardCurrentData.setProjectSn(dev.getProjectSn());
                                standardCurrentData.setDevSn(dev.getDevSn());
                                if (temperatureList.size() > 0) {
                                    //计算温度平均值
                                    double avg = temperatureList.stream().collect(Collectors.averagingDouble(n -> n));
                                    standardCurrentData.setTemperature(df.format(avg));
                                }
                                if (humidityList.size() > 0) {
                                    //计算湿度平均值
                                    double avg = humidityList.stream().collect(Collectors.averagingDouble(n -> n));
                                    standardCurrentData.setHumidity(df.format(avg));
                                }
                                standardCurrentDataMapper.insert(standardCurrentData);
                                StandardDev tempStandardDev = new StandardDev();
                                tempStandardDev.setId(dev.getId());
                                tempStandardDev.setRealTime(new Date());
                                tempStandardDev.setDevHumidity(standardCurrentData.getHumidity());
                                tempStandardDev.setDevTemperature(standardCurrentData.getTemperature());
                                standardDevMapper.updateById(tempStandardDev);
                            }
                        }
                    }
                }
            }
            log.info("------------拉取执行标样室时数据任务结束---------");
        } catch (Exception e) {
            log.error("error：", e);
        }
    }


    /**
     * 汇总标养室设备实时数据
     */
    @Scheduled(cron = "0 0/2 * * * ?")
    @SchedulerLock(name = "saveStandardRealTimeDataTask", lockAtMostFor = 1000 * 60 * 1, lockAtLeastFor = 1000 * 30)
    public void saveStandardRealTimeDataTask() {
        try {

            QueryWrapper<StandardDev> queryWrapper = new QueryWrapper<>();
            List<StandardDev> list = standardDevMapper.selectList(queryWrapper);
            if (list != null && list.size() > 0) {
                for (StandardDev dev : list) {
                    int dataNum = 0;
                    String temperature = null;
                    String humidity = null;
                    List<Map<String, Object>> dataList = standardDevRealTimeDataMapper.selectDevRealTimeDataCount(dev.getDevSn());
                    if (dataList != null && dataList.size() > 0) {
                        for (Map<String, Object> data : dataList) {
                            if (MapUtils.getString(data, "dataName").indexOf("温度") >= 0) {
                                dataNum = dataNum + MapUtils.getInteger(data, "num");
                                temperature = MapUtils.getString(data, "avgValue");
                            } else if (MapUtils.getString(data, "dataName").indexOf("湿度") >= 0) {
                                dataNum = dataNum + MapUtils.getInteger(data, "num");
                                humidity = MapUtils.getString(data, "avgValue");
                            }
                        }
                    }
                    //没有数据不插入
                    if (dataNum > 0) {
                        StandardCurrentData standardCurrentData = new StandardCurrentData();
                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                        standardCurrentData.setReceiveTime(sdf.format(new Date()));
                        standardCurrentData.setProjectSn(dev.getProjectSn());
                        standardCurrentData.setDevSn(dev.getDevSn());
                        standardCurrentData.setTemperature(temperature);
                        standardCurrentData.setHumidity(humidity);
                        standardCurrentDataMapper.insert(standardCurrentData);
                        StandardDev tempStandardDev = new StandardDev();
                        tempStandardDev.setId(dev.getId());
                        tempStandardDev.setRealTime(new Date());
                        tempStandardDev.setDevHumidity(standardCurrentData.getHumidity());
                        tempStandardDev.setDevTemperature(standardCurrentData.getTemperature());
                        standardDevMapper.updateById(tempStandardDev);
                    }
                }
            }

        } catch (Exception e) {
            log.error("error：", e);
        }
    }
}