package com.newfiber.termite.service.impl;


import cn.hutool.core.date.DateUtil;
import cn.hutool.core.img.Img;
import cn.hutool.core.img.ImgUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.http.HttpResponse;
import cn.hutool.http.HttpUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.newfiber.common.core.enums.EBoolean;
import com.newfiber.common.core.exception.ServiceException;
import com.newfiber.common.core.web.page.PageResult;
import com.newfiber.common.core.web.page.PageSupport;
import com.newfiber.common.core.web.service.BaseServiceImpl;
import com.newfiber.termite.config.JingchuResourceConfig;
import com.newfiber.termite.domain.DeviceInfo;
import com.newfiber.termite.domain.DeviceMonitoringData;
import com.newfiber.termite.domain.DeviceMonitoringDataRealtime;
import com.newfiber.termite.domain.OneByOneNow;
import com.newfiber.termite.domain.Termite;
import com.newfiber.termite.domain.dto.PhotoIdentifyDto;
import com.newfiber.termite.domain.dto.SnAlarmStatisticDto;
import com.newfiber.termite.domain.dto.TermiteDataUpRequest;
import com.newfiber.termite.domain.dto.UnitInfoDto;
import com.newfiber.termite.domain.jingchu.JingChuUpload;
import com.newfiber.termite.domain.jingchu.JingchuDeviceConfig;
import com.newfiber.termite.domain.jingchu.JingchuProjectConfig;
import com.newfiber.termite.domain.request.DeviceInfoUpdateRequest;
import com.newfiber.termite.domain.request.TermiteHistoryQueryRequest;
import com.newfiber.termite.domain.request.TermiteInfoQueryRequest;
import com.newfiber.termite.domain.request.TermiteInfoSaveRequest;
import com.newfiber.termite.domain.request.TermiteInfoUpdateyRequest;
import com.newfiber.termite.domain.request.deviceInfo.DeviceInfoStateSyncRequest;
import com.newfiber.termite.domain.request.deviceMonitoringData.DeviceMonitoringDataQueryRequest;
import com.newfiber.termite.domain.response.DataUpResponse;
import com.newfiber.termite.domain.response.DeviceInfoStateSyncResponse;
import com.newfiber.termite.domain.response.TermiteInfoResponse;
import com.newfiber.termite.enums.EDeviceSyncState;
import com.newfiber.termite.enums.EDrugFlag;
import com.newfiber.termite.enums.EExistsAnt;
import com.newfiber.termite.enums.EHeatingFlag;
import com.newfiber.termite.enums.EIdentColle;
import com.newfiber.termite.mapper.TermiteMapper;
import com.newfiber.termite.service.IMonitoringWarnRecordService;
import com.newfiber.termite.service.ITermiteService;
import com.newfiber.termite.service.jingchu.IJingchuDeviceConfigService;
import com.newfiber.termite.service.jingchu.IJingchuProjectConfigService;
import com.newfiber.termite.service.jingchu.IJingchuUploadRecordService;
import com.newfiber.termite.util.CosUtil;
import com.newfiber.termite.util.FileUploadUtils;
import java.awt.Color;
import java.awt.Font;
import java.awt.Image;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.jetbrains.annotations.NotNull;
import org.springframework.beans.BeanUtils;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

@Slf4j
@Service
public class TermiteServiceImpl extends BaseServiceImpl<TermiteMapper, Termite> implements ITermiteService {

    @Resource
    private TermiteMapper termiteMapper;

    @Resource
    private DeviceInfoServiceImpl deviceInfoService;

    @Resource
    private DeviceMonitoringDataServiceImpl deviceMonitoringDataService;

    @Resource
    private DeviceMonitoringDataRealtimeServiceImpl deviceMonitoringDataRealtimeService;

    @Resource
    private IJingchuDeviceConfigService jingchuDeviceConfigService;

    @Resource
    private IJingchuProjectConfigService jingchuProjectConfigService;

    @Resource
    private IJingchuUploadRecordService jingchuUploadRecordService;

    @Resource
    private JingchuResourceConfig jingchuResourceConfig;

    @Resource
    private MongoTemplate mongoTemplate;

//    @Resource
//    private MqttClient mqttClient;

    @Resource
    private IMonitoringWarnRecordService monitoringWarnRecordService;

    private final String JINGCHU_UPLOAD_API = "/waterDataTermites/insertDataBatch";

    CountDownLatch countDownLatch = new CountDownLatch(1);

    private final ExecutorService jingchuExecutorService = Executors.newFixedThreadPool(4);

    Font font = new Font("微软雅黑", Font.BOLD, 50);

    @Transactional(rollbackFor = Exception.class)
    public DataUpResponse termiteDataup(TermiteDataUpRequest termiteDateUpRequest, MultipartFile image){
        String date = DateUtil.formatDateTime(new Date());
        log.info("站点{}在{}时刻上传数据", termiteDateUpRequest.getSn(), date);
        String url = CosUtil.putFile(image);

        // 保存实时数据
        deviceMonitoringDataRealtimeService.deleteBySn(termiteDateUpRequest.getSn());
        DeviceMonitoringDataRealtime deviceMonitoringDataRealtime = new DeviceMonitoringDataRealtime();
        BeanUtils.copyProperties(termiteDateUpRequest, deviceMonitoringDataRealtime);
        deviceMonitoringDataRealtime.setRtpitcu(url);
        deviceMonitoringDataRealtime.setYesnoant(EExistsAnt.False.getCode());
        deviceMonitoringDataRealtime.setDruing(EDrugFlag.False.getCode());
        deviceMonitoringDataRealtime.setUptime(new Date());
        deviceMonitoringDataRealtime.setDate(DateUtil.formatDateTime(new Date()));
        deviceMonitoringDataRealtimeService.save(deviceMonitoringDataRealtime);

        mongoTemplate.save(deviceMonitoringDataRealtime, termiteDateUpRequest.getSn());

        // 保存历史数据
        DeviceMonitoringData deviceMonitoringData = new DeviceMonitoringData();
        BeanUtils.copyProperties(deviceMonitoringDataRealtime, deviceMonitoringData);
        deviceMonitoringDataService.save(deviceMonitoringData);

        // 返回是否投药、加热
        DeviceMonitoringData lastDrugingDeviceMonitoringData = deviceMonitoringDataService.lastDruging(termiteDateUpRequest.getSn());
        DeviceMonitoringData lastHeatingDeviceMonitoringData = deviceMonitoringDataService.lastHeating(termiteDateUpRequest.getSn());

        // 更新设备状态
        termiteDateUpRequest.setLastPicTime(new Date());
        deviceInfoService.update(termiteDateUpRequest);

//        mqttClient.publish("termite_mqtt", JSONObject.toJSONBytes(deviceMonitoringData), 1, true);

        return new DataUpResponse(url, lastDrugingDeviceMonitoringData, lastHeatingDeviceMonitoringData);
    }

    @Transactional(rollbackFor = Exception.class)
    public String photoIdentify(PhotoIdentifyDto dataDto, MultipartFile image) throws Exception{
        DeviceMonitoringData existedDeviceMonitoringData = deviceMonitoringDataService.selectDetail(Long.parseLong(dataDto.getId()));
        if(null == existedDeviceMonitoringData){
            log.info("监测数据不存在或未关联项目:{}", dataDto.getId());
            return String.format("监测数据不存在或未关联项目:%s", dataDto.getId());
        }
        log.info("站点{}在{}时刻更新识别结果", existedDeviceMonitoringData.getSn(), DateUtil.formatDateTime(new Date()));
        DeviceInfo deviceInfo = deviceInfoService.selectDetail(existedDeviceMonitoringData.getSn());

        String url = uploadFile(dataDto, image, existedDeviceMonitoringData, deviceInfo);

        DeviceMonitoringData deviceMonitoringData = new DeviceMonitoringData();
        deviceMonitoringData.setId(Long.parseLong(dataDto.getId()));
        deviceMonitoringData.setYesnoant(dataDto.getYesnoant());
        deviceMonitoringData.setIdenpitcu(url);
        deviceMonitoringData.setAntNumber(dataDto.getAntNumber());
        deviceMonitoringData.setOtherAntNumber(dataDto.getOtherAntNumber());
        deviceMonitoringDataService.updateById(deviceMonitoringData);

        Query updateQuery = new Query().addCriteria(Criteria.where("sn").is(existedDeviceMonitoringData.getSn())).
                addCriteria(Criteria.where("date").is(existedDeviceMonitoringData.getDate()));
        Update update = new Update().set("yesnoant", dataDto.getYesnoant()).set("idenpitcu", url);
        mongoTemplate.updateMulti(updateQuery, update, existedDeviceMonitoringData.getSn());

        DeviceMonitoringDataRealtime deviceMonitoringDataRealtime = new DeviceMonitoringDataRealtime();
        BeanUtils.copyProperties(deviceMonitoringData, deviceMonitoringDataRealtime);
        deviceMonitoringDataRealtimeService.updateById(deviceMonitoringDataRealtime);

        // 添加告警记录
        monitoringWarnRecordService.insert(deviceMonitoringDataRealtime, existedDeviceMonitoringData);

        // 上传荆楚平台
        jingchuExecutorService.execute(() -> jingChuUpload(existedDeviceMonitoringData, dataDto.getYesnoant()));

        return url;
    }

    @NotNull
    private String uploadFile(PhotoIdentifyDto dataDto, MultipartFile image, DeviceMonitoringData existedDeviceMonitoringData, DeviceInfo deviceInfo)
            throws IOException {
        String url = "";
        if(EExistsAnt.True.getCode().equals(dataDto.getYesnoant())){
            Image srcImage = ImgUtil.read(image.getInputStream());
            Img img = Img.from(srcImage);
            img.setPositionBaseCentre(false);
            img = img.pressText("项目：" + deviceInfo.getProjectName(), Color.WHITE, font, 0, 900, 1f);
            img = img.pressText("位置：" + deviceInfo.getLocation(), Color.WHITE, font, 0, 1000, 1f);
            img = img.pressText("时间：" + DateUtil.format(existedDeviceMonitoringData.getUptime(), "yyyy-MM-dd HH:mm"), Color.WHITE, font, 0, 1100, 1f);
            url = CosUtil.putFile(ImgUtil.toStream(img.getImg(), FileUtil.extName(image.getName())), FileUploadUtils.extractFilename(image));
        }else{
            url = existedDeviceMonitoringData.getRtpitcu();
        }
        return url;
    }

    private void jingChuUpload(DeviceMonitoringData existedDeviceMonitoringData, String yesnoant) {
        JingchuDeviceConfig jingchuDeviceConfig = jingchuDeviceConfigService.selectDetail(existedDeviceMonitoringData.getSn());
        JingchuProjectConfig jingchuProjectConfig = jingchuProjectConfigService.selectDetail(existedDeviceMonitoringData.getProjectCode());
        if(null != jingchuDeviceConfig && null != jingchuProjectConfig){
            JingChuUpload jingChuUpload = new JingChuUpload();
            jingChuUpload.setMnNo(jingchuProjectConfig.getMnNo());
            jingChuUpload.setObDate(existedDeviceMonitoringData.getDate().replace(" ", "T"));
            jingChuUpload.setObTime(DateUtil.format(DateUtil.parse(existedDeviceMonitoringData.getDate()), "yyMMddHHmm"));
            jingChuUpload.setOrder(jingchuDeviceConfig.getOrder());
            jingChuUpload.setReceiveType(0);
            jingChuUpload.setStationId(jingchuProjectConfig.getStationId());
            jingChuUpload.setStationName(jingchuProjectConfig.getStationName());
            jingChuUpload.setDeviceId(jingchuProjectConfig.getDeviceId());
            jingChuUpload.setDeviceName(jingchuProjectConfig.getDeviceName());

            if(EBoolean.False.getStringValue().equals(jingchuDeviceConfig.getUploadConfirmFlag())){
                jingChuUpload.setStatus(EBoolean.False.getIntValue());
            }else{
//                int status = EExistsAnt.True.getCode().equals(yesnoant) ? 1 : 0;
                jingChuUpload.setStatus(EBoolean.True.getIntValue());
            }

            List<JingChuUpload> jingChuUploadList = new ArrayList<>();
            jingChuUploadList.add(jingChuUpload);
            HttpResponse httpResponse = HttpUtil.createPost(jingchuResourceConfig.getUrl().concat(JINGCHU_UPLOAD_API)).
                    body(JSONObject.toJSONString(jingChuUploadList)).timeout(1000).
                    header("Authorization", jingchuResourceConfig.getToken()).execute();
            jingchuUploadRecordService.insert(jingchuProjectConfig.getProjectCode(), jingchuDeviceConfig.getSn(),
                    jingchuDeviceConfig.getOrder(), JSONObject.toJSONString(jingChuUpload), httpResponse.body());
//            log.info("同步荆楚监测数据.请求:{}，响应:{}", JSONObject.toJSONString(jingChuUpload), httpResponse.body());
        }
    }

    @Override
    public DeviceInfoStateSyncResponse syncDeviceState(DeviceInfoStateSyncRequest request) {
        String date = DateUtil.formatDateTime(new Date());
        log.info("站点{}在{}时刻同步设备数据", request.getSn(), date);

        try {
            DeviceInfo deviceInfo = deviceInfoService.selectDetail(request.getSn());

            // 返回是否投药、加热
            DeviceMonitoringData lastDrugingDeviceMonitoringData = deviceMonitoringDataService.lastDruging(request.getSn());
            DeviceMonitoringData lastHeatingDeviceMonitoringData = deviceMonitoringDataService.lastHeating(request.getSn());

            // 返回识别结果
            List<DeviceMonitoringData> deviceMonitoringDataList = null;
            if(null != request.getAntStartDate() && null != request.getAntEndDate()){
                deviceMonitoringDataList = deviceMonitoringDataService.selectList(request.getSn(), request.getAntStartDate(), request.getAntEndDate());
            }

            // 更新设备状态
            deviceInfoService.update(request);

            return new DeviceInfoStateSyncResponse(deviceInfo, lastDrugingDeviceMonitoringData, lastHeatingDeviceMonitoringData, deviceMonitoringDataList);
        }catch (Exception e){
            e.printStackTrace();
            deviceInfoService.update(request.getSn(), EDeviceSyncState.fail);
        }

        return new DeviceInfoStateSyncResponse(request.getSn());
    }

    @Override
    public List<TermiteInfoResponse> querytermiteData(TermiteInfoQueryRequest request){
        return termiteMapper.querytermiteData(request);
    }

    @Override
    public boolean updateMonitorData(TermiteInfoUpdateyRequest request){
        DeviceMonitoringDataRealtime deviceMonitoringDataRealtime = new DeviceMonitoringDataRealtime();
        BeanUtils.copyProperties(request, deviceMonitoringDataRealtime);

        Query updateQuery = new Query().addCriteria(Criteria.where("sn").is(request.getSn())).
                addCriteria(Criteria.where("_id").is(request.getId()));
        Update update = new Update();
        for(Field field : ReflectUtil.getFields(request.getClass())){
            if("id".equals(field.getName())){
                continue;
            }
            Object fieldValue = ReflectUtil.getFieldValue(request, field);
            if(null != fieldValue){
                update.set(field.getName(), fieldValue);
            }
        }

        if(EDrugFlag.True.getCode().equals(request.getDruing())){
            deviceMonitoringDataRealtime.setDruingDatetime(new Date());
            update.set("druingDatetime", new Date());
        }
        if(EHeatingFlag.True.getCode().equals(request.getHeating())){
            deviceMonitoringDataRealtime.setHeatingDatetime(new Date());
            update.set("heatingDatetime", new Date());
        }
        deviceMonitoringDataRealtimeService.updateById(deviceMonitoringDataRealtime);
        mongoTemplate.updateMulti(updateQuery, update, deviceMonitoringDataRealtime.getSn());

        DeviceMonitoringData deviceMonitoringData = new DeviceMonitoringData();
        BeanUtils.copyProperties(deviceMonitoringDataRealtime, deviceMonitoringData);
        deviceMonitoringDataService.updateById(deviceMonitoringData);

        // 更新第一次报警时间
        DeviceInfo deviceInfo = deviceInfoService.selectDetail(request.getSn());
        if(null == deviceInfo.getFirstWarnDatetime() && EIdentColle.True.getCode().equals(request.getIdencolle())){
            DeviceMonitoringDataQueryRequest deviceMonitoringDataQueryRequest = new DeviceMonitoringDataQueryRequest();
            deviceMonitoringDataQueryRequest.setSn(request.getSn());
            deviceMonitoringDataQueryRequest.setYesnoant(EExistsAnt.True.getCode());
            deviceMonitoringDataQueryRequest.setIdencolle(EIdentColle.True.getCode());
            deviceMonitoringDataQueryRequest.setOrderBy("date asc");
            List<DeviceMonitoringData> deviceMonitoringDataList = deviceMonitoringDataService.selectList(deviceMonitoringDataQueryRequest);
            if(deviceMonitoringDataList.size() >= 3){
                deviceInfo.setFirstWarnDatetime(DateUtil.parse(deviceMonitoringDataList.get(0).getDate()));
                deviceInfoService.updateById(deviceInfo);

                // 确认告警后，后续每次数据都传给荆楚
                jingchuDeviceConfigService.updateUploadConfirmFlag(deviceInfo.getSn(), EBoolean.True.getStringValue());
            }
        }
        return true;
    }

    @Override
    public boolean updateMonitorDevice(DeviceInfoUpdateRequest request){
        termiteMapper.updateMonitorDevice(request);
        return true;
    }

    @Override
    public PageResult<List<TermiteInfoResponse>> queryhistoryData(TermiteHistoryQueryRequest request){
//        DeviceInfo deviceInfo = deviceInfoService.selectDetail(request.getSn());
//
//        Query query = new Query().with(Sort.by(Sort.Direction.DESC, "date"));
//        Criteria criteria = new Criteria();
//
//        if (null != request.getStarttime()) {
//            criteria.andOperator(Criteria.where("tt").gte(request.getStarttime()));
//        }
//        if (null != request.getEndtime()) {
//            criteria.andOperator(Criteria.where("tt").lte(request.getEndtime()));
//        }
//        if (null != request.getYesnoant()) {
//            criteria.andOperator(Criteria.where("yesnoant").lte(request.getYesnoant()));
//        }
//        if (null != request.getIdencolle()) {
//            criteria.andOperator(Criteria.where("idencolle").lte(request.getIdencolle()));
//        }
//        if (null != request.getDruing()) {
//            criteria.andOperator(Criteria.where("druing").lte(request.getDruing()));
//        }
//
//        Long countNum = mongoTemplate.count(query, request.getSn());
//
//        PageDomain pageDomain = PageSupport.buildPageRequest();
//        Integer pageNum = pageDomain.getPageNum();
//        Integer pageSize = pageDomain.getPageSize();
//        query.skip((pageNum - 1) * pageSize).limit(pageSize);
//
//        List<TermiteInfoResponse> responseList = new ArrayList<>();
//        List<DeviceMonitoringDataRealtime> deviceMonitoringDataRealtimeList = mongoTemplate.find(query, DeviceMonitoringDataRealtime.class, request.getSn());
//        for(DeviceMonitoringDataRealtime realtime : deviceMonitoringDataRealtimeList){
//            TermiteInfoResponse response = new TermiteInfoResponse();
//            BeanUtils.copyProperties(realtime, response);
//            response.setLocation(deviceInfo.getLocation());
//            responseList.add(response);
//        }
//
//        return new PageResult<>(responseList, countNum);
        return PageSupport.pageResult(termiteMapper.queryhistoryData(request));
    }

    @Override
    public boolean insertMonitorDevice(TermiteInfoSaveRequest request){
        DeviceInfo existDeviceInfo = deviceInfoService.selectDetailByCategory(request.getCategory(), request.getSn());
        if(null != existDeviceInfo){
            throw new ServiceException(String.format("站点%s已存在", request.getSn()));
        }

        DeviceInfo deviceInfo = new DeviceInfo();
        BeanUtils.copyProperties(request, deviceInfo);
        deviceInfoService.save(deviceInfo);
        if(!mongoTemplate.collectionExists(request.getSn())){
            mongoTemplate.createCollection(request.getSn());
        }

        return true;
    }

    @Override
    public boolean removeMonitorDevice(String id){
        deviceInfoService.delete(id);
        return true;
    }

    @Override
    public boolean updateModlefirstData(String sn){
        String newphoto = termiteMapper.querynewphoto(sn);
        termiteMapper.updateModlefirstData(sn,newphoto);
        return true;
    }

    @Override
    public UnitInfoDto queryUnitdata(){
        return termiteMapper.queryUnitdata();
    }

     @Override
    public List<SnAlarmStatisticDto> querySnalarmStatistic(String projectCode){
        List<SnAlarmStatisticDto> result = new ArrayList<>();
        //查询所有站点的数据信息
         List<DeviceInfo> deviceInfoList = deviceInfoService.selectList(projectCode);
         List<DeviceInfo> offlineDeviceList = new ArrayList<>();

        AtomicInteger outlineflag = new AtomicInteger(0);
         deviceInfoList.forEach(e->{
            Date date1 = new Date();
            if(e.getLastPicTime() != null){
                Date date2 =e.getLastPicTime();
                double diff = Math.abs(date1.getTime()-date2.getTime());
                double diffdays = diff/(1000l*60l*60l*24l);
                if(diffdays>1){
                    outlineflag.getAndIncrement();
                    offlineDeviceList.add(e);
                }
            }else {
                outlineflag.getAndIncrement();
                offlineDeviceList.add(e);
            }
        });

         List<DeviceInfo> onlineDeviceList = deviceInfoList.stream().filter(t -> !offlineDeviceList.contains(t)).collect(Collectors.toList());
        int onlineflag = deviceInfoList.size()- outlineflag.get();
        SnAlarmStatisticDto snAlarmStatisticDto =new SnAlarmStatisticDto();
        snAlarmStatisticDto.setName("在线");
        snAlarmStatisticDto.setValue(onlineflag);
        snAlarmStatisticDto.setDeviceInfo(onlineDeviceList);
        result.add(snAlarmStatisticDto);
        SnAlarmStatisticDto snAlarmStatisticDto2 =new SnAlarmStatisticDto();
        snAlarmStatisticDto2.setName("离线");
        snAlarmStatisticDto2.setValue(outlineflag.get());
        snAlarmStatisticDto2.setDeviceInfo(offlineDeviceList);
        result.add(snAlarmStatisticDto2);
        SnAlarmStatisticDto snAlarmStatisticDto3 =new SnAlarmStatisticDto();
        snAlarmStatisticDto3.setName("告警");
        snAlarmStatisticDto3.setValue(deviceInfoList.stream().filter(t -> null != t.getFirstWarnDatetime()).count());
        snAlarmStatisticDto3.setDeviceInfo(deviceInfoList.stream().filter(t -> null != t.getFirstWarnDatetime()).collect(Collectors.toList()));
        result.add(snAlarmStatisticDto3);
        return result;
    }

    @Override
    public Object queryNowWeather(){
        String url = "https://gfapi.mlogcn.com/weather/v001/now?areacode=101201403&key=F2hH0eoTQS99jaKr3v4AIWFQkJwRjMAU&output_type=json";

        String forEntity = HttpUtil.get(url);
        JSONObject object = JSONObject.parseObject(forEntity);
        JSONObject result = JSONObject.parseObject(JSON.toJSONString(object.get("result")));
        OneByOneNow oneByOneHours = JSONObject.parseObject(JSONObject.toJSONString(result.get("realtime")),OneByOneNow.class);
        return oneByOneHours;
    }

    @Override
    public void transferMySql2Mongo() {
        List<DeviceInfo> deviceInfoList = deviceInfoService.list();
        for(DeviceInfo deviceInfo : deviceInfoList){
            if(!mongoTemplate.collectionExists(deviceInfo.getSn())){
                mongoTemplate.createCollection(deviceInfo.getSn());
            }

            List<DeviceMonitoringData> deviceMonitoringDataList = deviceMonitoringDataService.selectList(deviceInfo.getSn());
            for(DeviceMonitoringData deviceMonitoringData : deviceMonitoringDataList){

                Query query = new Query().addCriteria(Criteria.where("date").is(deviceMonitoringData.getDate()));
                if(!mongoTemplate.exists(query, deviceInfo.getSn())){
                    mongoTemplate.save(deviceMonitoringDataList, deviceInfo.getSn());
                }
            }

        }
    }

}