humv-farm-env/src/main/java/com/huimv/admin/service/impl/EnvDeviceServiceImpl.java

package com.huimv.admin.service.impl;

import cn.hutool.core.codec.Base64;
import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.huimv.admin.common.utils.DataUill;
import com.huimv.admin.common.utils.Result;
import com.huimv.admin.common.utils.ResultCode;
import com.huimv.admin.entity.*;
import com.huimv.admin.entity.vo.EnvDeviceVo;
import com.huimv.admin.entity.vo.PublicDeployVo;
import com.huimv.admin.mapper.*;
import com.huimv.admin.service.IEnvDeviceService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.client.RestTemplate;

import javax.servlet.http.HttpServletRequest;
import java.text.NumberFormat;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.stream.Collectors;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author author
 * @since 2023-02-13
 */
@Service
public class EnvDeviceServiceImpl extends ServiceImpl<EnvDeviceMapper, EnvDevice> implements IEnvDeviceService {

    @Autowired
    private EnvDeviceMapper envDeviceMapper;
    @Autowired
    private BasePigpenMapper basePigpenMapper;
    @Autowired
    private EnvDataMapper dataMapper;
    @Autowired
    private EnvDeviceRecentlyDataMapper envDeviceRecentlyDataMapper;
    @Autowired
    private EnvCo2Mapper co2Mapper;//CO2
    @Autowired
    private EnvAmmoniaMapper ammoniaMapper;//氨气
    @Autowired
    private EnvTempMapper tempMapper;//温度
    @Autowired
    private EnvHumiMapper humiMapper;//湿度
    @Autowired
    private EnvStiveMapper stiveMapper;//粉尘
    @Autowired
    private EnvPressureMapper pressureMapper;//压力
    @Autowired
    private EnvDeviceFanMapper fanMapper;//风机
    @Autowired
    private EnvDeviceFenestruleMapper fenestruleMapper;//小窗
    @Autowired
    private EnvDeviceOtherMapper otherMapper;//
    @Autowired
    private EnvDevicePadMapper padMapper;//湿帘
    @Autowired
    private EnvDeviceHeaterMapper heaterMapper;//加热器
    @Autowired
    private EnvDeviceFloodlightMapper floodlightMapper;//照明灯
    @Autowired
    private EnvDeviceDeflectorMapper deflectorMapper;//导流板
    @Autowired
    private EnvDeviceAtomizingMapper atomizingMapper;//喷雾
    @Autowired
    private EnvDeviceChuchouMapper envDeviceChuchouMapper;//除臭
    @Autowired
    private EnvDeviceLiaotaMapper envDeviceLiaotaMapper;//料塔
    @Autowired
    private EnvDeviceRecentlyDataMapper recentlyDataMapper;


//    @Autowired
//    private RestTemplate restTemplate;

    @Override
    public Result count(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String farmId = paramsMap.get("farmId");
        QueryWrapper<EnvDevice> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("farm_id", farmId);
        Integer count = envDeviceMapper.selectCount(queryWrapper);
        JSONObject jsonObject = new JSONObject();
        if (count == 0) {
            jsonObject.put("DeviceCount", 0);
            jsonObject.put("OnDeviceCount", 0);
            jsonObject.put("OffDeviceCount", 0);
            jsonObject.put("OnDeviceRate", 0);
        } else {
            QueryWrapper<EnvDevice> queryWrapper1 = new QueryWrapper<>();
            queryWrapper1.eq("device_status", 1);
            Integer count1 = envDeviceMapper.selectCount(queryWrapper1);
            Integer OffDeviceCount = count - count1;
            //创建一个数值格式化对象
            NumberFormat numberFormat = NumberFormat.getInstance();
            //设置精确到小数点后两位
            numberFormat.setMaximumFractionDigits(2);
            String onDeviceRate = numberFormat.format((float) count1 / (float) count * 100) + "%";
            jsonObject.put("DeviceCount", count);
            jsonObject.put("OnDeviceCount", count1);
            jsonObject.put("OffDeviceCount", OffDeviceCount);
            jsonObject.put("OnDeviceRate", onDeviceRate);
        }
        return new Result(ResultCode.SUCCESS, jsonObject);
    }

    @Override
    public Result list(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String farmId = paramsMap.get("farmId");
        String pageSize = paramsMap.get("pageSize");
        String pageNo = paramsMap.get("pageNo");
        if (pageSize == null || pageSize == "") {
            pageSize = "10";
        }
        if (pageNo == null || pageNo == "") {
            pageNo = "1";
        }
        QueryWrapper<EnvDevice> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("farm_id", farmId);
        Page<EnvDevice> page = new Page(Integer.parseInt(pageNo), Integer.parseInt(pageSize));
        return new Result(ResultCode.SUCCESS, envDeviceMapper.selectPage(page, queryWrapper));
    }

    @Override
    @Transactional
    public Result add(HttpServletRequest httpServletRequest, EnvDevice envDevice) {



        QueryWrapper<BasePigpen> basePigpenQueryWrapper = new QueryWrapper<>();
        basePigpenQueryWrapper.eq("farm_id", envDevice.getFarmId()).eq("id", envDevice.getUnitId());
        BasePigpen basePigpen = basePigpenMapper.selectOne(basePigpenQueryWrapper);
        envDevice.setStageType(basePigpen.getStageCode());

        QueryWrapper<EnvDevice> deviceQueryWrapper = new QueryWrapper<>();
        deviceQueryWrapper.eq("farm_id", envDevice.getFarmId()).eq("unit_id", envDevice.getUnitId());
        EnvDevice device1 = envDeviceMapper.selectOne(deviceQueryWrapper);//一个栋舍只能有一个设备
        if (ObjectUtil.isEmpty(device1)) {
            QueryWrapper<EnvDevice> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("device_name", envDevice.getDeviceName()).eq("farm_id", envDevice.getFarmId())
                    .or().eq("device_code", envDevice.getDeviceCode());
            EnvDevice device = envDeviceMapper.selectOne(queryWrapper);//名字和编码不能重复
            if (ObjectUtil.isEmpty(device)) {
                QueryWrapper<EnvDevice> queryWrapper1 = new QueryWrapper<>();
//                queryWrapper1.eq("farm_id", envDevice.getFarmId());
//                Integer integer = envDeviceMapper.selectCount(queryWrapper1);
              /*  if (integer == 0) {
                    envDevice.setDeviceSortCode("100" + "01");
                    addAll(envDevice);
                } else {*/
                    queryWrapper1.orderByDesc("id").last(" limit 1");
                    EnvDevice envDevice2 = envDeviceMapper.selectOne(queryWrapper1);
                    envDevice.setDeviceSortCode(String.valueOf(Integer.parseInt(envDevice2.getDeviceSortCode()) + 1));
                    addAll(envDevice);
//                }
                envDeviceMapper.insert(envDevice);
                return new Result(10000, "添加成功",true);
            } else {
                return new Result(10001, "添加失败，设备名称或设备编码已存在",false);
            }
        } else {
            return new Result(10001, "添加失败，该栋舍已绑定设备",false);
        }


    }

    public void addAll(EnvDevice envDevic) {
        for (int i = 1; i < 24; i++) {
            EnvDeviceRecentlyData data = new EnvDeviceRecentlyData();
            data.setDeviceCode(envDevic.getDeviceSortCode());
            if (i < 10) {
                data.setChipCode(envDevic.getDeviceSortCode() + "140" + i);
            } else {
                data.setChipCode(envDevic.getDeviceSortCode() + "14" + i);
            }
            data.setChipStatus(0);
            data.setChipType(i);
            if (i == 1) {
                data.setChipName("前左温度");
            }
            if (i == 2) {
                data.setChipName("前右温度");
            }
            if (i == 3) {
                data.setChipName("中左温度");
            }
            if (i == 4) {
                data.setChipName("中右温度");
            }
            if (i == 5) {
                data.setChipName("后左温度");
            }
            if (i == 6) {
                data.setChipName("后右温度");
            }
            if (i == 7) {
                data.setChipName("温度7");
            }
            if (i == 8) {
                data.setChipName("温度8");
            }
            if (i == 9) {
                data.setChipName("室外温度");
            }
            if (i == 10) {
                data.setChipName("目标温度");
            }
            if (i == 11) {
                data.setChipName("平均温度");
            }
            if (i == 12) {
                data.setChipName("湿度1");
            }
            if (i == 13) {
                data.setChipName("湿度2");
            }
            if (i == 14) {
                data.setChipName("湿度3");
            }
            if (i == 15) {
                data.setChipName("CO2");
            }
            if (i == 16) {
                data.setChipName("压力");
            }
            if (i == 17) {
                data.setChipName("粉尘");
            }
            if (i == 18) {
                data.setChipName("氨气");
            }
            if (i == 19) {
                data.setChipName("通风级别");
            }
            if (i == 20) {
                data.setChipName("加热");
            }
            if (i == 21) {
                data.setChipName("水暖温度");
            }
            if (i == 22) {
                data.setChipName("室内光照");
            }
            if (i == 23) {
                data.setChipName("体感温度");
            }
            data.setFarmId(envDevic.getFarmId());
            data.setUpdateTime(new Date());
            envDeviceRecentlyDataMapper.insert(data);
        }
        for (int i = 1; i < 9; i++) {
            EnvTemp temp = new EnvTemp();
            temp.setDeviceCode(envDevic.getDeviceSortCode());
            temp.setChipCode(envDevic.getDeviceSortCode() + "140" + i);//温度1-8
            temp.setUnitId(envDevic.getUnitId().toString());
            temp.setFarmId(envDevic.getFarmId());
            tempMapper.insert(temp);
        }
        EnvTemp temp = new EnvTemp();
        temp.setDeviceCode(envDevic.getDeviceSortCode());
        temp.setChipCode(envDevic.getDeviceSortCode() + "1423");//体感温度
        temp.setUnitId(envDevic.getUnitId().toString());
        temp.setFarmId(envDevic.getFarmId());
        tempMapper.insert(temp);

        for (int i = 12; i < 15; i++) {
            EnvHumi humi = new EnvHumi();
            humi.setChipCode(envDevic.getDeviceSortCode() + "14" + i);//湿度
            humi.setDeviceCode(envDevic.getDeviceSortCode());
            humi.setUnitId(envDevic.getUnitId().toString());
            humi.setFarmId(envDevic.getFarmId());
            humiMapper.insert(humi);
        }

        EnvAmmonia ammonia = new EnvAmmonia();
        ammonia.setChipCode(envDevic.getDeviceSortCode() + "1418");//氨气
        ammonia.setDeviceCode(envDevic.getDeviceSortCode());
        ammonia.setUnitId(envDevic.getUnitId().toString());
        ammonia.setFarmId(envDevic.getFarmId());
        ammoniaMapper.insert(ammonia);

        EnvCo2 co2 = new EnvCo2();
        co2.setChipCode(envDevic.getDeviceSortCode() + "1415");//co2
        co2.setDeviceCode(envDevic.getDeviceSortCode());
        co2.setUnitId(envDevic.getUnitId().toString());
        co2.setFarmId(envDevic.getFarmId());
        co2Mapper.insert(co2);

        EnvStive stive = new EnvStive();
        stive.setChipCode(envDevic.getDeviceSortCode() + "1417");//粉尘
        stive.setDeviceCode(envDevic.getDeviceSortCode());
        stive.setUnitId(envDevic.getUnitId().toString());
        stive.setFarmId(envDevic.getFarmId());
        stiveMapper.insert(stive);

        EnvPressure pressure = new EnvPressure();
        pressure.setChipCode(envDevic.getDeviceSortCode() + "1416");//压力
        pressure.setDeviceCode(envDevic.getDeviceSortCode());
        pressure.setUnitId(envDevic.getUnitId().toString());
        pressure.setFarmId(envDevic.getFarmId());
        pressureMapper.insert(pressure);


        for (int i = 1; i < envDevic.getFengJiNum() + 1; i++) {
            EnvDeviceFan fan = new EnvDeviceFan();
            fan.setDeviceCode(envDevic.getDeviceSortCode());
            if (i < 10) {
                fan.setChipCode(envDevic.getDeviceSortCode() + "110" + i);
            } else {
                fan.setChipCode(envDevic.getDeviceSortCode() + "11" + i);
            }
            fan.setChipName("风机" + i);
            fan.setFarmId(envDevic.getFarmId());
            fan.setChipStatus(0);
            fan.setFengType(1);
            fan.setOther1(String.valueOf(i));
            fanMapper.insert(fan);
        }
        int j = 1;
        for (int i = envDevic.getFengJiNum() + 1; i < envDevic.getFengJiNum() + envDevic.getFengJiBianNum() + 1; i++) {
            EnvDeviceFan fan = new EnvDeviceFan();
            fan.setDeviceCode(envDevic.getDeviceSortCode());
            if (i < 10) {
                fan.setChipCode(envDevic.getDeviceSortCode() + "110" + i);
            } else {
                fan.setChipCode(envDevic.getDeviceSortCode() + "11" + i);
            }
            fan.setChipName("变频风机" + j);
            fan.setFarmId(envDevic.getFarmId());
            fan.setChipStatus(0);
            fan.setFengType(2);
            fan.setOther1(String.valueOf(i));
            fanMapper.insert(fan);
            j++;
        }
        if (envDevic.getXiaoChuangNum() != null) {
            for (int i = 1; i < envDevic.getXiaoChuangNum() + 1; i++) {
                EnvDeviceFenestrule fenestrulen = new EnvDeviceFenestrule();
                fenestrulen.setDeviceCode(envDevic.getDeviceSortCode());

                if (i < 10) {
                    fenestrulen.setChipCode(envDevic.getDeviceSortCode() + "120" + i);
                } else {
                    fenestrulen.setChipCode(envDevic.getDeviceSortCode() + "12" + i);
                }
                fenestrulen.setFarmId(envDevic.getFarmId());
                fenestrulen.setChipStatus(0);
                fenestrulen.setChipName("小窗" + i);
                fenestrulen.setOther1(String.valueOf(i));
                fenestruleMapper.insert(fenestrulen);
            }
        }
        if (envDevic.getShiLianNum() != null) {
            for (int i = 1; i < envDevic.getShiLianNum() + 1; i++) {
                EnvDevicePad devicePad = new EnvDevicePad();
                devicePad.setDeviceCode(envDevic.getDeviceSortCode());
                if (i < 10) {
                    devicePad.setChipCode(envDevic.getDeviceSortCode() + "200" + i);
                } else {
                    devicePad.setChipCode(envDevic.getDeviceSortCode() + "20" + i);
                }
                devicePad.setFarmId(envDevic.getFarmId());
                devicePad.setChipStatus(0);
                devicePad.setChipName("湿帘" + i);
                devicePad.setOther1(String.valueOf(i));
                padMapper.insert(devicePad);
            }
        }
        if (envDevic.getDaoLiuBan() != null) {
            for (int i = 1; i < envDevic.getDaoLiuBan() + 1; i++) {
                EnvDeviceDeflector devicePad = new EnvDeviceDeflector();
                devicePad.setDeviceCode(envDevic.getDeviceSortCode());
                if (i < 10) {
                    devicePad.setChipCode(envDevic.getDeviceSortCode() + "210" + i);
                } else {
                    devicePad.setChipCode(envDevic.getDeviceSortCode() + "21" + i);
                }
                devicePad.setFarmId(envDevic.getFarmId());
                devicePad.setChipStatus(0);
                devicePad.setChipName("导流板" + i);
                devicePad.setOther1(String.valueOf(i));
                deflectorMapper.insert(devicePad);
            }
        }
        if (envDevic.getPenWuNum() != null) {
            for (int i = 1; i < envDevic.getPenWuNum() + 1; i++) {
                EnvDeviceAtomizing devicePad = new EnvDeviceAtomizing();
                devicePad.setDeviceCode(envDevic.getDeviceSortCode());
                if (i < 10) {
                    devicePad.setChipCode(envDevic.getDeviceSortCode() + "220" + i);
                } else {
                    devicePad.setChipCode(envDevic.getDeviceSortCode() + "22" + i);
                }
                devicePad.setFarmId(envDevic.getFarmId());
                devicePad.setChipStatus(0);
                devicePad.setChipName("喷雾" + i);
                devicePad.setOther1(String.valueOf(i));
                atomizingMapper.insert(devicePad);
            }
        }
        if (envDevic.getJiaReQiNum() != null) {
            for (int i = 1; i < envDevic.getJiaReQiNum() + 1; i++) {
                EnvDeviceHeater devicePad = new EnvDeviceHeater();
                devicePad.setDeviceCode(envDevic.getDeviceSortCode());
                if (i < 10) {
                    devicePad.setChipCode(envDevic.getDeviceSortCode() + "230" + i);
                } else {
                    devicePad.setChipCode(envDevic.getDeviceSortCode() + "23" + i);
                }
                devicePad.setFarmId(envDevic.getFarmId());
                devicePad.setChipStatus(0);
                devicePad.setChipName("加热器" + i);
                devicePad.setOther1(String.valueOf(i));
                heaterMapper.insert(devicePad);
            }
        }
        if (envDevic.getZhaoMingDengNum() != null) {
            for (int i = 1; i < envDevic.getZhaoMingDengNum() + 1; i++) {
                EnvDeviceFloodlight devicePad = new EnvDeviceFloodlight();
                devicePad.setDeviceCode(envDevic.getDeviceSortCode());
                if (i < 10) {
                    devicePad.setChipCode(envDevic.getDeviceSortCode() + "240" + i);
                } else {
                    devicePad.setChipCode(envDevic.getDeviceSortCode() + "24" + i);
                }
                devicePad.setFarmId(envDevic.getFarmId());
                devicePad.setChipStatus(0);
                devicePad.setChipName("照明灯" + i);
                devicePad.setOther1(String.valueOf(i));
                floodlightMapper.insert(devicePad);
            }
        }
        if (envDevic.getChuChouNum() != null){
            for (int i = 1; i < envDevic.getChuChouNum() + 1; i++) {
                EnvDeviceChuchou devicePad = new EnvDeviceChuchou();
                devicePad.setDeviceCode(envDevic.getDeviceSortCode());
                if (i < 10) {
                    devicePad.setChipCode(envDevic.getDeviceSortCode() + "250" + i);
                } else {
                    devicePad.setChipCode(envDevic.getDeviceSortCode() + "25" + i);
                }
                devicePad.setFarmId(envDevic.getFarmId());
                devicePad.setChipStatus(0);
                devicePad.setChipName("除臭" + i);
                devicePad.setOther1(String.valueOf(i));
                envDeviceChuchouMapper.insert(devicePad);
            }
        }
        if (envDevic.getLiaoTaNum() != null) {

            for (int i = 1; i < envDevic.getLiaoTaNum() + 1; i++) {
                EnvDeviceLiaota devicePad = new EnvDeviceLiaota();
                devicePad.setDeviceCode(envDevic.getDeviceSortCode());
                if (i < 10) {
                    devicePad.setChipCode(envDevic.getDeviceSortCode() + "260" + i);
                } else {
                    devicePad.setChipCode(envDevic.getDeviceSortCode() + "26" + i);
                }
                devicePad.setFarmId(envDevic.getFarmId());
                devicePad.setChipStatus(0);
                devicePad.setChipName("料塔" + i);
                devicePad.setOther1(String.valueOf(i));
                envDeviceLiaotaMapper.insert(devicePad);
            }
        }



        for (int i = 1; i < 6; i++) {
            EnvDeviceOther other = new EnvDeviceOther();
            other.setDeviceCode(envDevic.getDeviceSortCode());
            other.setChipCode(envDevic.getDeviceSortCode() + "13" + i);
            other.setFarmId(envDevic.getFarmId());
            if (i == 1) {
                other.setChipName("照明");
            }
            if (i == 2) {
                other.setChipName("加热");
            }
            if (i == 3) {
                other.setChipName("湿帘");
            }
            if (i == 4) {
                other.setChipName("喷雾");
            }
            if (i == 5) {
                other.setChipName("锅炉");
            }
            other.setChipStatus(0);
            other.setOther1(String.valueOf(i));
            otherMapper.insert(other);
        }


    }


    @Override
    public Result edit(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String farmId = paramsMap.get("farmId");
        String id = paramsMap.get("id");
        String DeviceCode = paramsMap.get("deviceCode");
        String DeviceName = paramsMap.get("deviceName");
        String BuildLocation = paramsMap.get("buildLocation");
        String DeviceBrand = paramsMap.get("deviceBrand");
        String remark = paramsMap.get("remark");
        if (remark == null || remark == "") {
            remark = null;
        }

        QueryWrapper<EnvDevice> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("id", id);
        EnvDevice envDevice = envDeviceMapper.selectOne(queryWrapper);
        envDevice.setId(Integer.parseInt(id));
        envDevice.setFarmId(Integer.parseInt(farmId));
        envDevice.setDeviceName(DeviceName);
        envDevice.setDeviceCode(DeviceCode);
        envDevice.setDeviceBrand(DeviceBrand);
        envDevice.setBuildLocation(BuildLocation);
        envDevice.setRemark(remark);

        QueryWrapper<EnvDevice> queryWrapper1 = new QueryWrapper<>();
        queryWrapper1.ne("id", id).and(i -> i.eq("device_name", DeviceName).or().eq("device_code", DeviceCode));
        if (ObjectUtil.isEmpty(envDeviceMapper.selectOne(queryWrapper1))) {
            envDeviceMapper.updateById(envDevice);
            return new Result(ResultCode.SUCCESS, "修改成功");
        } else {
            return new Result(ResultCode.FAIL, "设备名称或者设备编码已存在");
        }

    }

    @Override
    public Result delete(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String farmId = paramsMap.get("farmId");
        String id = paramsMap.get("id");
        QueryWrapper<EnvDevice> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("id", id).eq("farm_id", farmId);
        EnvDevice envDevice = envDeviceMapper.selectOne(queryWrapper);
        String deviceCode = envDevice.getDeviceSortCode();
        QueryWrapper<EnvDeviceRecentlyData> queryWrapper1 = new QueryWrapper<>();
        queryWrapper1.eq("device_code", deviceCode).eq("farm_id", farmId);
        envDeviceRecentlyDataMapper.delete(queryWrapper1);//实时数据
        QueryWrapper<EnvTemp> queryWrapper2 = new QueryWrapper<>();
        queryWrapper2.eq("device_code", deviceCode).eq("farm_id", farmId);
        tempMapper.delete(queryWrapper2);//温度
        QueryWrapper<EnvHumi> queryWrapper3 = new QueryWrapper<>();
        queryWrapper3.eq("device_code", deviceCode).eq("farm_id", farmId);
        humiMapper.delete(queryWrapper3);//湿度
        QueryWrapper<EnvAmmonia> queryWrapper4 = new QueryWrapper<>();
        queryWrapper4.eq("device_code", deviceCode).eq("farm_id", farmId);
        ammoniaMapper.delete(queryWrapper4);//氨气
        QueryWrapper<EnvCo2> queryWrapper5 = new QueryWrapper<>();
        queryWrapper5.eq("device_code", deviceCode).eq("farm_id", farmId);
        co2Mapper.delete(queryWrapper5);//co2
        QueryWrapper<EnvStive> queryWrapper6 = new QueryWrapper<>();
        queryWrapper6.eq("device_code", deviceCode).eq("farm_id", farmId);
        stiveMapper.delete(queryWrapper6);//粉尘
        QueryWrapper<EnvPressure> queryWrapper7 = new QueryWrapper<>();
        queryWrapper7.eq("device_code", deviceCode).eq("farm_id", farmId);
        pressureMapper.delete(queryWrapper7);//压力
        QueryWrapper<EnvDeviceFan> queryWrapper8 = new QueryWrapper<>();
        queryWrapper8.eq("device_code", deviceCode).eq("farm_id", farmId);
        fanMapper.delete(queryWrapper8);//风机
        QueryWrapper<EnvDeviceFenestrule> queryWrapper9 = new QueryWrapper<>();
        queryWrapper9.eq("device_code", deviceCode).eq("farm_id", farmId);
        fenestruleMapper.delete(queryWrapper9);//小窗

        QueryWrapper<EnvDevicePad> queryWrapper11 = new QueryWrapper<>();
        queryWrapper11.eq("device_code", deviceCode).eq("farm_id", farmId);
        padMapper.delete(queryWrapper11);//湿帘
        QueryWrapper<EnvDeviceDeflector> queryWrapper12 = new QueryWrapper<>();
        queryWrapper12.eq("device_code", deviceCode).eq("farm_id", farmId);
        deflectorMapper.delete(queryWrapper12);//导流板
        QueryWrapper<EnvDeviceAtomizing> queryWrapper13 = new QueryWrapper<>();
        queryWrapper13.eq("device_code", deviceCode).eq("farm_id", farmId);
        atomizingMapper.delete(queryWrapper13);//喷雾
        QueryWrapper<EnvDeviceHeater> queryWrapper14 = new QueryWrapper<>();
        queryWrapper14.eq("device_code", deviceCode).eq("farm_id", farmId);
        heaterMapper.delete(queryWrapper14);//加热器
        QueryWrapper<EnvDeviceFloodlight> queryWrapper15 = new QueryWrapper<>();
        queryWrapper15.eq("device_code", deviceCode).eq("farm_id", farmId);
        floodlightMapper.delete(queryWrapper15);//照明灯
        QueryWrapper<EnvDeviceRecentlyData> queryWrapper16 = new QueryWrapper<>();
        queryWrapper16.eq("device_code", deviceCode).eq("farm_id", farmId);
        recentlyDataMapper.delete(queryWrapper16);//

        QueryWrapper<EnvDeviceChuchou> queryWrapper17 = new QueryWrapper<>();
        queryWrapper17.eq("device_code", deviceCode).eq("farm_id", farmId);
        envDeviceChuchouMapper.delete(queryWrapper17);//除臭

        QueryWrapper<EnvDeviceLiaota> queryWrapper18 = new QueryWrapper<>();
        queryWrapper18.eq("device_code", deviceCode).eq("farm_id", farmId);
        envDeviceLiaotaMapper.delete(queryWrapper18);//料塔

        QueryWrapper<EnvDeviceOther> queryWrapper10 = new QueryWrapper<>();
        queryWrapper10.eq("device_code", deviceCode).eq("farm_id", farmId);
        otherMapper.delete(queryWrapper10);//其他

        envDeviceMapper.delete(queryWrapper);
        return new Result(ResultCode.SUCCESS, "删除成功");
    }

    @Override
    public Result listPigpen(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String farmId = paramsMap.get("farmId");
        String id = paramsMap.get("id");//楼层id

        JSONArray jsonArray = new JSONArray();
        QueryWrapper<BasePigpen> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("farm_id", farmId);
        if (id == null || id == "") {
            queryWrapper.eq("parent_id", 3);
        } else {
            queryWrapper.like("other2", id);
        }
        List<BasePigpen> basePigpens = basePigpenMapper.selectList(queryWrapper);//得到栋舍单元
        for (int i = 0; i < basePigpens.size(); i++) {
           /* QueryWrapper<EnvDevice> queryWrapper1 = new QueryWrapper<>();
            queryWrapper1.eq("unit_name",basePigpens.get(i).getId());
            EnvDevice envDevice = envDeviceMapper.selectOne(queryWrapper1);//找到栋舍绑定的设备，利用单元id*/

            QueryWrapper<EnvData> queryWrapper2 = new QueryWrapper<>();
            queryWrapper2.eq("unit_id", basePigpens.get(i).getId()).orderByDesc("create_time").last(" limit 1");//通过设备id来拿取数据
            EnvData envData = dataMapper.selectOne(queryWrapper2);
            JSONObject jsonObject = new JSONObject();
            if (ObjectUtil.isEmpty(envData)) {
                jsonObject.put("temp", 0);//温度
                jsonObject.put("hum", 0);//湿度
                jsonObject.put("location", basePigpens.get(i).getBuildName());
                jsonObject.put("unit_id", 0);//单元id
            } else {
                jsonObject.put("temp", envData.getEnvTemp());//温度
                jsonObject.put("hum", envData.getEnvHum());//湿度
                jsonObject.put("location", basePigpens.get(i).getBuildName());
                jsonObject.put("unit_id", envData.getUnitId());//单元id
            }
            jsonArray.add(jsonObject);
        }
        return new Result(ResultCode.SUCCESS, jsonArray);
    }

    @Override
    public Result listEnv(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String farmId = paramsMap.get("farmId");
        String id = paramsMap.get("id");//单元id
        String type = paramsMap.get("type");//查询类型
        String startTime = paramsMap.get("startTime");
        String endTime = paramsMap.get("endTime");

        if (type == null || type == "") {
            type = "1";
        }

        QueryWrapper<BasePigpen> basePigpenQueryWrapper = new QueryWrapper<>();
        basePigpenQueryWrapper.eq("farm_id", farmId).eq("id", id);
        BasePigpen basePigpen = basePigpenMapper.selectOne(basePigpenQueryWrapper);

        QueryWrapper<EnvData> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("unit_id", id).eq("farm_id", farmId);

        Map map = new HashMap<>();
        //自定义查询
        if ("4".equals(type)) {
            startTime = startTime + " 00:00:00";
            endTime = endTime + " 23:59:59";
            queryWrapper.between("create_time", startTime, endTime);
            List<EnvData> envData = dataMapper.listDay(queryWrapper);
            map.put("location", basePigpen.getBuildName());
            map.put("data", envData);
        }

        //本月
        else if ("3".equals(type)) {
            Date timesMonthmorning = DataUill.getTimesMonthmorning();
            queryWrapper.ge("create_time", timesMonthmorning);
            List<EnvData> envData = dataMapper.listDay(queryWrapper);
            map.put("location", basePigpen.getBuildName());
            map.put("data", envData);

        }

        //本周
        else if ("2".equals(type)) {
            Calendar calendar = Calendar.getInstance();
            calendar.set(Calendar.DATE, calendar.get(Calendar.DATE) - 7);
            queryWrapper.ge("create_time", calendar.getTime());
            List<EnvData> envData = dataMapper.listDay(queryWrapper);
            map.put("location", basePigpen.getBuildName());
            map.put("data", envData);
        }

        //今日
        else if ("1".equals(type)) {
            Date timesmorning = DataUill.getTimesmorning();
            queryWrapper.ge("create_time", timesmorning);
            List<EnvData> envData = dataMapper.listDay(queryWrapper);
            map.put("location", basePigpen.getBuildName());
            map.put("data", envData);
        }
        return new Result(ResultCode.SUCCESS, map);
    }

    @Override
    public Result listDeviceCount(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String farmId = paramsMap.get("farmId");
        Integer offCount = 0;
        Integer onCount = 0;
        QueryWrapper<BasePigpen> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("farm_id", farmId).eq("parent_id", 0);
        List<BasePigpen> basePigpens = basePigpenMapper.selectList(queryWrapper);//得到所有的栋
        JSONArray jsonArray = new JSONArray();
        for (int i = 0; i < basePigpens.size(); i++) {
            QueryWrapper<BasePigpen> queryWrapper1 = new QueryWrapper<>();
            queryWrapper1.like("other2", basePigpens.get(i).getId());
            List<BasePigpen> basePigpens1 = basePigpenMapper.selectList(queryWrapper1);//得到所有的楼层
            for (int j = 0; j < basePigpens1.size(); j++) {
                QueryWrapper<EnvDevice> deviceQueryWrapper = new QueryWrapper<>();
                deviceQueryWrapper.eq("unit_id", basePigpens1.get(j).getId());
                EnvDevice envDevice = envDeviceMapper.selectOne(deviceQueryWrapper);
                if (ObjectUtil.isNotEmpty(envDevice)) {
                    if (envDevice.getDeviceStatus() == 0) {
                        offCount++;
                    } else {
                        onCount++;
                    }
                }

            }
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("location", basePigpens.get(i).getBuildName());
            jsonObject.put("onDevice", onCount);
            jsonObject.put("offDevice", offCount);
            jsonArray.add(jsonObject);
            offCount = 0;
            onCount = 0;
        }
        return new Result(ResultCode.SUCCESS, jsonArray);
    }

    @Override
    public Result selectList(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String farmId = paramsMap.get("farmId");
        String name = paramsMap.get("name");
        String pageNum = paramsMap.get("pageNum");
        String pageSize = paramsMap.get("pageSize");
        if (pageNum == null || pageNum == "") {
            pageNum = "1";
        }
        if (pageSize == null || pageSize == "") {
            pageSize = "20";
        }

        QueryWrapper<EnvDevice> queryWrapper = new QueryWrapper<>();
        if (name == "" || name == null) {
            queryWrapper.eq("farm_id", farmId);
        } else {
            queryWrapper.eq("farm_id", farmId);
            queryWrapper.like("d.device_code", name).or().like("d.device_name", name);
        }
        Page<EnvDeviceVo> page = new Page(Integer.parseInt(pageNum), Integer.parseInt(pageSize));
        IPage<EnvDeviceVo> list = envDeviceMapper.list(page, queryWrapper);
        return new Result(ResultCode.SUCCESS, list);
    }

//    @Override
//    @Transactional
//    public Result sync(Map<String, String> params) throws Exception {
//        String farmId = params.get("farmId");
//        //获取所有栏舍
//        Map<String, Object> map = new HashMap<String, Object>();
//        String s = HttpClientSSLUtils.doPost("https://yzwlw.loongk.com/mobile/login?username=江西增鑫&password=21218cca77804d2ba1922c33e0151105", JSON.toJSONString(map));
//        System.out.println("登录带栏舍："+s);
//        LoginDto loginDto = JSONUtil.toBean(s, LoginDto.class);
//        DataToken token = loginDto.getData().getToken();
//        String encode = Base64.encode(token.getUserId() + "_" + token.getToken());
//        HttpHeaders headers = new HttpHeaders();
//        headers.add("Authorization",encode);
//        HttpEntity<String> requestEntity = new HttpEntity<>(null, headers);
//        List<DataShacks> shacks = loginDto.getData().getShacks();
//        // 不能删除，需做比较
//        List<String> zengXinDeviceId = shacks.stream().map(DataShacks::getId).collect(Collectors.toList());
//        List<String> huatongDeviceId = envDeviceMapper.selectDeviceCodeByfarmId(Integer.parseInt(farmId));
//
//        CopyOnWriteArrayList<String> zengXinDeviceIdCopy = ListUtil.toCopyOnWriteArrayList(zengXinDeviceId);
//        CopyOnWriteArrayList<String> huatongDeviceIdCopy = ListUtil.toCopyOnWriteArrayList(huatongDeviceId);
//        //新增的设备
//        zengXinDeviceIdCopy.removeAll(huatongDeviceId);
//        //新增
//        if (zengXinDeviceIdCopy.size() >0){
//            for (String deviceId : zengXinDeviceIdCopy) {
//                syncConfig(deviceId,requestEntity,farmId);
//            }
//        }
//        //需要删除的设备
//        huatongDeviceIdCopy.removeAll(zengXinDeviceId);
//        if (huatongDeviceIdCopy.size() >0){
//            this.remove(new QueryWrapper<EnvDevice>().in("device_code",huatongDeviceIdCopy));
//        }
//        System.out.println("zengxin:"+zengXinDeviceIdCopy);
//        System.out.println(huatongDeviceIdCopy);
//        return new Result(10000,"同步成功",false);
//    }

    @Override
    public Result bandingUnitId(HttpServletRequest httpServletRequest, EnvDevice envDevice) {
        Integer unitId = envDevice.getUnitId();
        int count = this.count(new QueryWrapper<EnvDevice>().eq("unit_id", unitId));
        if (count > 0) {
            return new Result(10001, "绑定失败，该栋舍已有设备", false);
        }
        this.updateById(envDevice);
        return new Result(10000, "绑定成功", true);
    }

    @Override
    public Result listPigpenAll(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String farmId = paramsMap.get("farmId");
        List objects = new ArrayList<>();
        List<BasePigpen> basePigpens = basePigpenMapper.selectList(new QueryWrapper<BasePigpen>().eq("farm_id", farmId).eq("f_type", 3));
        for (BasePigpen basePigpen : basePigpens) {
            Integer id = basePigpen.getId();
            EnvData envData = dataMapper.selectOne(new QueryWrapper<EnvData>().eq("unit_id", id).orderByDesc("id").last("limit 1"));
            JSONObject jsonObject = new JSONObject();
            if (ObjectUtil.isNotEmpty(envData)) {
                jsonObject.put("temp", envData.getEnvTemp());//温度
                jsonObject.put("hum", envData.getEnvHum());//湿度
                jsonObject.put("location", basePigpen.getBuildName());
                jsonObject.put("unit_id", basePigpen.getId());//单元id
            } else {
                jsonObject.put("temp", 0);//温度
                jsonObject.put("hum", 0);//湿度
                jsonObject.put("location", basePigpen.getBuildName());
                jsonObject.put("unit_id", basePigpen.getId());//单元id
            }
            objects.add(jsonObject);
        }
        return new Result(ResultCode.SUCCESS, objects);
    }

    @Override
    public Result listDetail(Map<String, String> paramsMap) {
        String deviceCode = paramsMap.get("deviceCode");
        String farmId = paramsMap.get("farmId");
        Map map = new HashMap();
        Integer sensorNum = envDeviceRecentlyDataMapper.selectCount(new QueryWrapper<EnvDeviceRecentlyData>().eq("device_code", deviceCode).eq("farm_Id", farmId));
        Integer fanNum = fanMapper.selectCount(new QueryWrapper<EnvDeviceFan>().eq("device_code", deviceCode).eq("farm_Id", farmId));
        Integer fenestruleNum = fenestruleMapper.selectCount(new QueryWrapper<EnvDeviceFenestrule>().eq("device_code", deviceCode).eq("farm_Id", farmId));
        Integer lightNum = otherMapper.selectCount(new QueryWrapper<EnvDeviceOther>().eq("device_code", deviceCode).eq("other1", 1).eq("farm_Id", farmId));
        Integer heatNum = otherMapper.selectCount(new QueryWrapper<EnvDeviceOther>().eq("device_code", deviceCode).eq("other1", 2).eq("farm_Id", farmId));
        if (ObjectUtil.isNull(sensorNum)) {
            sensorNum = 0;
        }
        if (ObjectUtil.isNull(fanNum)) {
            fanNum = 0;
        }
        if (ObjectUtil.isNull(fenestruleNum)) {
            fenestruleNum = 0;
        }
        if (ObjectUtil.isNull(lightNum)) {
            lightNum = 0;
        }
        if (ObjectUtil.isNull(heatNum)) {
            heatNum = 0;
        }
        map.put("sensorNum", sensorNum);
        map.put("fanNum", fanNum);
        map.put("fenestruleNum", fenestruleNum);
        map.put("lightNum", lightNum);
        map.put("heatNum", heatNum);

        return new Result(ResultCode.SUCCESS, map);
    }

//    //添加新的设备
//    private void syncConfig(String shackId,HttpEntity httpEntity,String farmId) {
//        try {
//            ResponseEntity<String> exchangePeizhi = restTemplate.exchange("https://yzwlw.loongk.com/mobile/loadShackConfig/"+shackId, HttpMethod.GET, httpEntity, String.class);
//            String peizhibody = exchangePeizhi.getBody();
//            ShackConfigDto shackConfigDto = JSONUtil.toBean(peizhibody, ShackConfigDto.class);
//            ShackConfigData data = shackConfigDto.getData();
//            List<ShackConfigDataSensors> sensors = data.getSensors();
//            if (ObjectUtil.isNotEmpty(sensors)){
//                EnvDevice envDevice =new EnvDevice();
//                envDevice.setFarmId(Integer.parseInt(farmId));
//                envDevice.setDeviceBrand("增鑫");
//                envDevice.setDeviceCode(data.getId());
//                envDevice.setDeviceName(data.getName());
//                for (ShackConfigDataSensors sensor : sensors) {
//                    if ("TEMPERATURE".equals(sensor.getType())){
//                        envDevice.setOhter1(sensor.getId());
//                    }
//                    if ("HUMIDITY".equals(sensor.getType())){
//                        envDevice.setOhter2(sensor.getId());
//                    }
//                }
//                envDeviceMapper.insert(envDevice);
//            }
//        }catch (Exception e){
//            System.out.println("设备同步异常：" + e +"  deviceId"+shackId);
//        }
//
//    }


}