szwlServer/src/main/java/com/szwl/controller/TEquipmentController.java

package com.szwl.controller;


import cn.afterturn.easypoi.excel.ExcelExportUtil;
import cn.afterturn.easypoi.excel.entity.ExportParams;
import cn.com.crbank.ommo.bean.ResultMessage;
import cn.com.crbank.ommo.esUtil.BeanUtils;
import cn.hutool.core.util.NumberUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.gexin.fastjson.JSON;
import com.qiniu.common.QiniuException;
import com.qiniu.storage.BucketManager;
import com.qiniu.storage.Configuration;
import com.qiniu.storage.Region;
import com.qiniu.storage.model.FileInfo;
import com.qiniu.util.Auth;
import com.szwl.annotation.Audit;
import com.szwl.constant.AuditEnum;
import com.szwl.constant.ConfigConsts;
import com.szwl.constant.ResponseCodesEnum;
import com.szwl.exception.BizException;
import com.szwl.manager.TokenManager;
import com.szwl.model.bean.*;
import com.szwl.model.bo.R;
import com.szwl.model.bo.ResponseModel;
import com.szwl.model.bo.UserDetailBO;
import com.szwl.model.entity.*;
import com.szwl.model.param.EquipmentParam;
import com.szwl.model.param.PasswordParam;
import com.szwl.model.query.StatisticsParam;
import com.szwl.model.utils.DateUtils;
import com.szwl.model.utils.PushUtils;
import com.szwl.model.vo.EquipmentVO;
import com.szwl.service.*;
import com.szwl.util.DownloadUtils;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang.StringUtils;
import org.apache.poi.ss.usermodel.Workbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.*;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

import static com.szwl.constant.ResponseCodesEnum.*;

/**
 * <p>
 * 前端控制器
 * </p>
 *
 * @author wuhs
 * @since 2023-10-25
 */
@Api(value = "/tEquipment", tags = {"设备控制器"})
@RestController
@RequestMapping("/tEquipment")
public class TEquipmentController {

    @Autowired
    TEquipmentService tEquipmentService;

    @Autowired
    TEquipmentDescService equipmentDescService;

    @Autowired
    TAdminService tAdminService;

    @Autowired
    TParametersService parametersService;

    @Autowired
    TAlarmRecordService tAlarmRecordService;

    @Autowired
    TAreaService tAreaService;

    @Autowired
    TOrderService tOrderService;

    @Autowired
    TAdminEquipmentService tAdminEquipmentService;

    @Autowired
    TDiyFlowerService tDiyFlowerService;

    @Autowired
    TLabelService labelService;

    @Autowired
    TokenManager tokenManager;
    /**
     * 超时时间为30秒
     */
    private static final int TIMEOUT = 30000;

    @ApiOperation(value = "根据经纬度获取区域内设备信息")
    @GetMapping("/getEquipmentByLatLon")
    public ResponseModel<List<TEquipment>> getEquipmentByLatLon(String lat1, String lat2, String lon1, String lon2) {

        LambdaQueryWrapper<TEquipment> lqw = Wrappers.lambdaQuery();
        lqw.between(TEquipment::getLatitude, lat1, lat2)
                .between(TEquipment::getLongitude, lon1, lon2)
                .notLike(TEquipment::getClientId, "%xxx");
        List<TEquipment> equipmentList = tEquipmentService.list(lqw);

        return R.ok(equipmentList);
    }


    @ApiOperation(value = "设备是否存在")
    @GetMapping("/getEquipmentBool")
    public ResponseModel<Boolean> getEquipmentBool(String clientId) {
        if (StringUtils.isEmpty(clientId)) {
            return R.fail("clientId参数不能为空");
        }
        LambdaQueryWrapper<TEquipment> lqw = Wrappers.lambdaQuery();
        lqw.eq(TEquipment::getClientId, clientId);
        List<TEquipment> equipmentList = tEquipmentService.list(lqw);
        if (equipmentList.isEmpty()) {
            return R.fail("设备clientId不存在");
        } else if (equipmentList.size() > 1) {
            return R.fail("设备clientId不唯一");
        } else {
            return R.ok(true);
        }
    }

    /**
     * @param adminName     商户的登录名
     * @param equipmentName 机器名称
     * @param areaName      地址名-fullName
     */
    @ApiOperation(value = "查找机器列表")
    @PostMapping("/findList")
    public ResponseModel<IPage<?>> findList(Long id, String clientId, String adminName, String equipmentName,
                                            String areaName, String eqeStatus, String machineType, String equimentType,
                                            String channel, String companyType, String labelId, String todayDate, Long current, Long size) {

        UserDetailBO userDetailBO = Optional.ofNullable(tokenManager.getLoginUserDetails())
                .orElseThrow(() -> new BizException(ResponseCodesEnum.L0001));
        String adminId = userDetailBO.getId().toString();
        int authId = Integer.parseInt(adminId);
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        TAdmin admin = tAdminService.getById(authId);
        // 申泽管理员
        if (authId == 2738) {
            companyType = "0";
        }
        // 七云管理员
        if (authId == 2739) {
            companyType = "1";
        }
        Integer type = admin.getType();
        if (type > 1) {
            if (type == 2) {
                query.eq(TEquipment::getAdminId, authId);
            }
            if (type == 3) {
                // TODO:
//                 查找该商家的所有子账户，一层一层寻找，一个账户只能关联一个账户，
//                 t_admin,
//                 parent_id 指的是子商家的上级 admin_id，
//                 relation_id 指的是关联上级账户的 admin_id，
//                 需要增加一个下级账户的admin_id, sub_account
//                 child_account 孩子账户有多个，不能这样
                //查找属于这个商家子账户的设备 todo
                TAdminEquipment adminEquipment = tAdminEquipmentService.getById(admin.getId());
                if (adminEquipment.getType().equals("0")) {
                    //全部机器
                    query.eq(TEquipment::getAdminId, admin.getParentId());
                } else {
                    String equipmentIds = adminEquipment.getEquipmentIds();
                    String[] strings = equipmentIds.split(",");
                    query.in(TEquipment::getId, strings);
                }
            }
        }
        if (StringUtils.isNotEmpty(clientId)) {
            query.like(TEquipment::getClientId, clientId);
        }
        if (StringUtils.isNotEmpty(adminName) && !"sysMgtAcc".equals(adminName)) {
            LambdaQueryWrapper<TAdmin> adminQuery = Wrappers.lambdaQuery();
            adminQuery.eq(TAdmin::getUsername, adminName);
            List<TAdmin> list = tAdminService.list(adminQuery);
            if (!list.isEmpty()) {
                query.eq(TEquipment::getAdminId, list.get(0).getId());
            }
        }
        if (StringUtils.isNotEmpty(equipmentName)) {
            query.like(TEquipment::getName, equipmentName);
        }
        if (StringUtils.isNotEmpty(areaName)) {
            query.like(TEquipment::getFullName, areaName);
        }
        if (StringUtils.isNotEmpty(eqeStatus)) {
            query.eq(TEquipment::getEqeStatus, eqeStatus);
        }
        if (StringUtils.isNotEmpty(machineType)) {
            query.eq(TEquipment::getMachineType, machineType);
        }
        if (StringUtils.isNotEmpty(equimentType)) {
            query.eq(TEquipment::getEquimentType, equimentType);
        }
        if (StringUtils.isNotEmpty(channel)) {
            query.eq(TEquipment::getChannel, channel);
        }
        // 公司平台
        if (StringUtils.isNotEmpty(companyType)) {
            if (companyType.equals("0")) {
//                query.isNull(TEquipment::getCompanyType)
//                        .or().eq(TEquipment::getCompanyType, companyType);
                query.ne(TEquipment::getCompanyType, "1");
            } else {
                query.eq(TEquipment::getCompanyType, companyType);
            }
        }
        // 分组ID
        if (StringUtils.isNotEmpty(labelId)) {
            if (NumberUtil.isInteger(labelId)) {
                TLabel label = labelService.getById(labelId);
                String equipmentIds = label.getEquipmentIds();
                equipmentIds = equipmentIds.replace("\"", "").replace("[", "").replace("]", "");
                String[] split = equipmentIds.split(",");
                query.in(TEquipment::getId, split);
            } else if (ConfigConsts.ABNORMAL.equals(labelId)) {
                query.eq(TEquipment::getIsAlarm, 1);
            } else if (ConfigConsts.ON.equals(labelId)) {
                query.eq(TEquipment::getEqeStatus, 1);
            } else if (ConfigConsts.OFF.equals(labelId)) {
                query.eq(TEquipment::getEqeStatus, 0);
            }
        }
        query.orderByDesc(TEquipment::getCreateDate);
        Page<TEquipment> page = new Page<>(current, size, true);
        IPage<TEquipment> iPage = tEquipmentService.page(page, query);
        IPage<TEquipmentDTO> iPageDTO = new Page<>(current, size, true);
        iPageDTO.setCurrent(iPage.getCurrent());
        iPageDTO.setPages(iPage.getPages());
        iPageDTO.setSize(iPage.getSize());
        iPageDTO.setTotal(iPage.getTotal());
        List<TEquipment> list = iPage.getRecords();
        List<TEquipmentDTO> equipmentDTOList = list.stream().map(equipment -> {
            TEquipmentDTO equipmentDTO = new TEquipmentDTO();
            BeanUtils.copyPropertiesIgnoreNull(equipment, equipmentDTO, true);
            return equipmentDTO;
        }).collect(Collectors.toList());
        for (TEquipmentDTO equipmentDTO : equipmentDTOList) {
            LocalDateTime dateTime = LocalDateTime.parse(todayDate + "T00:00:00");
            // 获取前一天的0点时间
            LocalDateTime startDateTime = dateTime.minusDays(1).with(LocalTime.MIN);
            // 获取当天的24点时间
            LocalDateTime endDateTime = dateTime.with(LocalTime.MAX);
            LambdaQueryWrapper<TAlarmRecord> query1 = Wrappers.lambdaQuery();
            query1.eq(TAlarmRecord::getEquipmentId, equipmentDTO.getId());
            query1.eq(TAlarmRecord::getIsEliminate, 0);
            query1.gt(TAlarmRecord::getOccurrenceTime, startDateTime);
            query1.le(TAlarmRecord::getOccurrenceTime, endDateTime);
            query1.orderByDesc(TAlarmRecord::getLevel).orderByDesc(TAlarmRecord::getOccurrenceTime);
            List<TAlarmRecord> alarmRecordList = tAlarmRecordService.list(query1);
            if (!alarmRecordList.isEmpty()) {
                equipmentDTO.setHasTodayAlarm(true);
                equipmentDTO.setAlarmList(alarmRecordList);
            } else {
                equipmentDTO.setHasTodayAlarm(false);
            }
            TEquipmentDesc equipmentDesc = equipmentDescService.getById(equipmentDTO.getId());
            if (equipmentDesc != null) {
                equipmentDTO.setRedSugar(equipmentDesc.getRedSugar());
                equipmentDTO.setWasteWater(equipmentDesc.getWasteWater());
                equipmentDTO.setWater(equipmentDesc.getWater());
                equipmentDTO.setYellowSugar(equipmentDesc.getYellowSugar());
                equipmentDTO.setBlueSugar(equipmentDesc.getBlueSugar());
                equipmentDTO.setIsMaterialUse(equipmentDesc.getIsMaterialUse());
                equipmentDTO.setStick(equipmentDesc.getStick());
                equipmentDTO.setWhiteSugar(equipmentDesc.getWhiteSugar());
                equipmentDTO.setSleepDesc(equipmentDesc.getSleepDesc());
                equipmentDTO.setOutDoor(equipmentDesc.getOutDoor());
                equipmentDTO.setInDoor(equipmentDesc.getInDoor());
                equipmentDTO.setCupQuantity(equipmentDesc.getCupQuantity());
                equipmentDTO.setStirTm(equipmentDesc.getStirTm());
                equipmentDTO.setCornGeneratorTm(equipmentDesc.getCornGeneratorTm());
                equipmentDTO.setNumberOne(equipmentDesc.getNumberOne());
                equipmentDTO.setCandyGeneratorTm(equipmentDesc.getCandyGeneratorTm());
                equipmentDTO.setOutsideHd(equipmentDesc.getOutsideHd());
                equipmentDTO.setOutsideTm(equipmentDesc.getOutsideTm());
                equipmentDTO.setDiyFlowerStatus(equipmentDesc.getDiyFlowerStatus());
                equipmentDTO.setWorkingMode(equipmentDesc.getWorkingMode());
                equipmentDTO.setCleanFunction(equipmentDesc.getCleanFunction());
            }

        }
        iPageDTO.setRecords(equipmentDTOList);
        return R.ok(iPageDTO);

    }

    @ApiOperation(value = "id查找机器详情")
    @PostMapping("/findById")
    public ResponseModel<?> findById(@RequestParam Long id) {
        TEquipment equipment = tEquipmentService.getById(id);
        TEquipmentDTO equipmentDTO = new TEquipmentDTO();
        BeanUtils.copyPropertiesIgnoreNull(equipment, equipmentDTO, true);
        TEquipmentDesc equipmentDesc = equipmentDescService.getById(id);
        if (equipmentDesc != null) {
            equipmentDTO.setCouponStatus(equipmentDesc.getCouponStatus());
            equipmentDTO.setInDoor(equipmentDesc.getInDoor());
            equipmentDTO.setOutDoor(equipmentDesc.getOutDoor());
            if (equipmentDesc.getFlowers() != null) {
                equipmentDTO.setFlowers(equipmentDesc.getFlowers());
            }
            equipmentDTO.setNumberOne(equipmentDesc.getNumberOne());
            equipmentDTO.setCandyGeneratorTm(equipmentDesc.getCandyGeneratorTm());
            equipmentDTO.setOutsideHd(equipmentDesc.getOutsideHd());
            equipmentDTO.setOutsideTm(equipmentDesc.getOutsideTm());
            equipmentDTO.setDiyFlowerStatus(equipmentDesc.getDiyFlowerStatus());
            equipmentDTO.setCleanFunction(equipmentDesc.getCleanFunction());
        }
        String messageReceiver = equipment.getMessageReceiver();
        if (StringUtils.isNotEmpty(messageReceiver)) {
            String[] message = messageReceiver.split(",");
            int i = message.length;
            if (i > 0) {
                equipmentDTO.setMessageReceiver1(message[0]);
            }
            if (i > 1) {
                equipmentDTO.setMessageReceiver2(message[1]);
            }
            if (i > 2) {
                equipmentDTO.setMessageReceiver3(message[2]);
            }
        }
        return R.ok(equipmentDTO);
    }

    @ApiOperation(value = "id查找机器详情")
    @PostMapping("/findById2")
    public ResponseModel<TEquipment> findById2(@RequestParam Long id) {
        TEquipment equipment = tEquipmentService.getById(id);
        return R.ok(equipment);
    }

    @ApiOperation(value = "id查找机器详情")
    @GetMapping("/findEquipmentById")
    public ResponseModel<TEquipment> findEquipmentById(@RequestParam String id) {
        TEquipment equipment = tEquipmentService.getById(id);
        return R.ok(equipment);
    }

    @ApiOperation(value = "ClientId查找设备")
    @GetMapping("/findEquipmentByClientId")
    public ResponseModel<TEquipment> findEquipmentByClientId(@RequestParam String clientId) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
//        query.like(TEquipment::getClientId, clientId);
        // 使用 SQL函数RIGHT来匹配后六位相同
        query.apply("RIGHT(client_id, 6) = {0}", clientId);
        TEquipment equipment = tEquipmentService.getOnly(query);
        return R.ok(equipment);
    }

    @ApiOperation(value = "获取对应的机器id")
    @GetMapping("/getClientIdList")
    public ResponseModel<TAdminEquipment> getClientIdList(@RequestParam String adminId) {
        //查找属于这个商家子账户的设备
        TAdminEquipment adminEquipment = tAdminEquipmentService.getById(adminId);

        return R.ok(adminEquipment);
    }

    @ApiOperation(value = "获取对应的机器编号")
    @GetMapping("/getClientIds")
    public ResponseModel<List<String>> getClientIds(@RequestParam String adminId) {
        //查找属于这个商家子账户的设备
        TAdminEquipment adminEquipment = tAdminEquipmentService.getById(adminId);
        String equipmentIds = adminEquipment.getEquipmentIds();
        // 分割保存在设备ID保存在list
        String[] tEquipmentIds = equipmentIds.split(",");
        List<String> list = Arrays.asList(tEquipmentIds);
        List<String> returnList = new ArrayList<>();
        if (list.size() > 0) {
            for (String id : list) {
                TEquipment equipment = tEquipmentService.getById(id);
                returnList.add(equipment.getClientId());
            }
        }
        return R.ok(returnList);
    }

    @ApiOperation(value = "获取机器列表 分页")
    @GetMapping("/pageEquipment2")
    public ResponseModel<IPage<TEquipment>> pageEquipment2(@RequestParam(value = "current") long current, @RequestParam(value = "size") long size) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        Page<TEquipment> page = new Page<>(current, size, true);
        IPage<TEquipment> iPage = tEquipmentService.page(page, query);
        return R.ok(iPage);
    }

    @ApiOperation(value = "adminId查找设备")
    @GetMapping("/listEquipment")
    public ResponseModel<?> listEquipment(String adminId) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        TAdmin admin = tAdminService.getById(adminId);
        Integer type = admin.getType();
        if (type < 2) {
            query.eq(TEquipment::getAdminId, 238);
        }
        if (type == 2) {
            query.eq(TEquipment::getAdminId, adminId);
        }

        if (type == 3) {
            //查找属于这个商家子账户的设备
            TAdminEquipment adminEquipment = tAdminEquipmentService.getById(admin.getId());
            if (adminEquipment.getType().equals("0")) {
                //全部机器
                query.eq(TEquipment::getAdminId, admin.getParentId());
            } else {
                String equipmentIds = adminEquipment.getEquipmentIds();
                String[] strings = equipmentIds.split(",");
                query.in(TEquipment::getId, strings);
            }
        }
        List<TEquipment> list = tEquipmentService.list(query);
        List<EquipmentVO> equipmentVOs = new ArrayList<>();
        Map<String, String> duplicateNames = new HashMap<>();

        for (TEquipment equipment : list) {
            String name = StringUtils.isEmpty(equipment.getName()) ? equipment.getClientId() : equipment.getName();
            String clientId = equipment.getClientId();
            if (duplicateNames.containsValue(name)) {
                name = clientId;
            }
            duplicateNames.put(String.valueOf(equipment.getId()), name);

            EquipmentVO equipmentVO = new EquipmentVO();
            equipmentVO.setId(equipment.getId());
            equipmentVO.setName(name);
            equipmentVO.setClientId(clientId);
            equipmentVOs.add(equipmentVO);
        }
        return R.ok(equipmentVOs);
    }

    @ApiOperation(value = "查找设备")
    @PostMapping("/getEquipmentByNameAndId")
    public ResponseModel<TEquipment> getEquipmentByNameAndId(@RequestBody TEquipment equipment) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        TAdmin admin = tAdminService.getById(equipment.getId());
        if (admin.getType() == 3) {
            //子账户
            TAdmin parentAdmin = tAdminService.getById(admin.getParentId());
            LambdaQueryWrapper<TEquipment> query1 = Wrappers.lambdaQuery();
            query1.eq(TEquipment::getAdminId, parentAdmin.getId());
            List<TEquipment> list1 = tEquipmentService.list(query1);
            if (list1.size() > 0) {
                for (TEquipment tEquipment : list1) {
                    if (equipment.getName().equals(tEquipment.getName())) {
                        return R.ok(tEquipment);
                    }
                }
            }
        }
        if (admin.getType() < 2) {
            query.eq(TEquipment::getName, equipment.getName());
        }
        if (admin.getType() == 2) {
            query.eq(TEquipment::getAdminId, equipment.getAdminId());
            query.eq(TEquipment::getName, equipment.getName());
        }
        List<TEquipment> list = tEquipmentService.list(query);
        TEquipment tEquipment = list.get(0);
        return R.ok(tEquipment);
    }

    /**
     * 更新
     */
    @ApiOperation(value = "更新机器")
    @RequestMapping(value = "/update", method = RequestMethod.POST)
    public ResponseModel<?> update(@RequestBody TEquipmentDTO equipment) {
        //获取修改前的设备
        TEquipment oldEquipment = tEquipmentService.getById(equipment.getId());
        TEquipmentDesc equipmentDesc = equipmentDescService.getById(equipment.getId());
        if (StringUtils.isNotEmpty(equipment.getSn())) {
            oldEquipment.setSn(equipment.getSn());
        }
        String name = equipment.getName();
        if (StringUtils.isNotEmpty(name) && !name.equals(oldEquipment.getName())) {
            LambdaQueryWrapper<TEquipment> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(TEquipment::getAdminId, oldEquipment.getAdminId());
            queryWrapper.eq(TEquipment::getName, name);
            TEquipment tEquipment = tEquipmentService.getOne(queryWrapper);
            if (tEquipment != null) {
                return R.fail(A0001);
            }
            oldEquipment.setName(equipment.getName());
        }
        if (StringUtils.isNotEmpty(equipment.getSelfName())) {
            oldEquipment.setSelfName(equipment.getSelfName());
        }
        if (equipment.getAreaId() != null) {
            oldEquipment.setAreaId(equipment.getAreaId());
        }
        if (StringUtils.isNotEmpty(equipment.getContactName())) {
            oldEquipment.setContactName(equipment.getContactName());
        }
        if (StringUtils.isNotEmpty(equipment.getContactPhone())) {
            oldEquipment.setContactPhone(equipment.getContactPhone());
        }
        if (StringUtils.isNotEmpty(equipment.getOperationalName())) {
            oldEquipment.setOperationalName(equipment.getOperationalName());
        }
        if (StringUtils.isNotEmpty(equipment.getOperationalPhone())) {
            oldEquipment.setOperationalPhone(equipment.getOperationalPhone());
        }
        if (StringUtils.isNotEmpty(equipment.getOperator())) {
            oldEquipment.setOperator(equipment.getOperator());
        }
        if (StringUtils.isNotEmpty(equipment.getSimNo())) {
            oldEquipment.setSimNo(equipment.getSimNo());
        }
        if (equipment.getTimeRuleId() != null) {
            oldEquipment.setTimeRuleId(equipment.getTimeRuleId());
        }
        if (StringUtils.isNotEmpty(equipment.getPlcVersion())) {
            oldEquipment.setPlcVersion(equipment.getPlcVersion());
        }
        if (StringUtils.isNotEmpty(equipment.getChannel())) {
            oldEquipment.setChannel(equipment.getChannel());
        }
        if (equipment.getPayType() != null) {
            oldEquipment.setPayType(equipment.getPayType());
        }
        if (equipment.getEndDate() != null) {
            oldEquipment.setEndDate(equipment.getEndDate());
        }
        if (equipment.getAreaId() != null) {
            oldEquipment.setFullName(tAreaService.getById(equipment.getAreaId()).getFullName());
        }
        if (StringUtils.isNotEmpty(equipment.getFlowers())) {
            if (StringUtils.isEmpty(oldEquipment.getFlowers())) {
                //发信息
                tEquipmentService.sentMessage(oldEquipment.getClientId(), PushUtils.buildJson("flowers", equipment.getFlowers()).toString());
            }
            if (StringUtils.isNotEmpty(oldEquipment.getFlowers()) && !oldEquipment.getFlowers().equals(equipment.getFlowers())) {
                //发信息
                tEquipmentService.sentMessage(oldEquipment.getClientId(), PushUtils.buildJson("flowers", equipment.getFlowers()).toString());
                // 通知客户
                tEquipmentService.informClient(oldEquipment.getAdminId(), oldEquipment.getClientId());
            }
            if (equipmentDesc != null && StringUtils.isNotEmpty(equipmentDesc.getFlowers()) && !equipmentDesc.getFlowers().equals(equipment.getFlowers())){
                //发信息
                tEquipmentService.sentMessage(oldEquipment.getClientId(), PushUtils.buildJson("flowers", equipment.getFlowers()).toString());
                // 通知客户
                tEquipmentService.informClient(oldEquipment.getAdminId(), oldEquipment.getClientId());
            }
        }
        String[] message = new String[3];
        message[0] = equipment.getMessageReceiver1();
        message[1] = equipment.getMessageReceiver2();
        message[2] = equipment.getMessageReceiver3();
        if (message.length > 0) {
            oldEquipment.setMessageReceiver(message[0] + "," + message[1] + "," + message[2]);
        }
        tEquipmentService.updateById(oldEquipment);
        if (equipment.getPayType() != null) {
            tEquipmentService.sentMessage(oldEquipment.getClientId(), PushUtils.buildJson("payType", oldEquipment.getPayType().toString() + ":" + oldEquipment.getTimeRuleId()).toString());
        }
        if (StringUtils.isNotEmpty(oldEquipment.getContactName()) && StringUtils.isNotEmpty(oldEquipment.getContactPhone())) {
            tEquipmentService.sentMessage(oldEquipment.getClientId(), PushUtils.buildJson("phone", oldEquipment.getContactName() + ":" + oldEquipment.getContactPhone()).toString());
        }
        if (StringUtils.isNotEmpty(oldEquipment.getCompanyPhone())) {
            tEquipmentService.sentMessage(oldEquipment.getClientId(), PushUtils.buildJson("companyPhone", oldEquipment.getCompanyPhone()).toString());
        }
        if (StringUtils.isNotEmpty(oldEquipment.getPlcVersion())) {
            tEquipmentService.sentMessage(oldEquipment.getClientId(), PushUtils.buildJson("plcVersion", oldEquipment.getPlcVersion()).toString());
        }
        if (StringUtils.isNotEmpty(oldEquipment.getSelfName())) {
            tEquipmentService.sentMessage(oldEquipment.getClientId(), PushUtils.buildJson("selfName", oldEquipment.getSelfName()).toString());
        }
        if (oldEquipment.getTimeRuleId() != null) {
            tEquipmentService.sentMessage(oldEquipment.getClientId(), PushUtils.buildJson("pushTimeRule", oldEquipment.getTimeRuleId() + "").toString());
        }
        if (StringUtils.isNotEmpty(oldEquipment.getOperationalName())) {
            tEquipmentService.sentMessage(oldEquipment.getClientId(), PushUtils.buildJson("operational", oldEquipment.getOperationalName() + ":" + oldEquipment.getOperationalPhone()).toString());
        }

        return R.ok("null", "更新成功！");
    }

    @ApiOperation(value = "更新机器 整体")
    @PostMapping("/updateByEquipment")
    public ResponseModel<?> updateByEquipment(@RequestBody TEquipment equipment) {
        if (equipment != null && equipment.getId() != null) {
            equipment.setModifyDate(new Date());
            tEquipmentService.updateById(equipment);
        }
        return R.ok();
    }

    @ApiOperation(value = "查找机器")
    @PostMapping("/getEquipmentListByUser")
    public ResponseEntity<?> getEquipmentListByUser(@RequestBody TAdmin param) {

        List<TAdminDTO> resultList = new ArrayList<>();

        if ("sysMgtAcc".equals(param.getUsername())) { // 管理员查所有商家
            List<TAdmin> adminList = tAdminService.list();
            List<TEquipment> equipmentList = tEquipmentService.list();
            List<TAlarmRecord> alarmRecordList = tAlarmRecordService.list();
            //获取当前用户今天所有机器的所以警报信息
            List<TAlarmRecord> alarmList = tAlarmRecordService.getAlarmList(null);

            resultList = adminList.stream().map(e -> {
                TAdminDTO dto = new TAdminDTO();
                BeanUtils.copyPropertiesIgnoreNull(e, dto, true);

                List<TEquipmentDTO> selList = equipmentList.stream()
                        .filter(equipment -> e.getId().equals(equipment.getAdminId())) // 查对应的设备
                        .map(equipment -> {
                            TEquipmentDTO equipmentDTO = new TEquipmentDTO();
                            BeanUtils.copyPropertiesIgnoreNull(equipment, equipmentDTO, true);
                            Optional<TAlarmRecord> op = alarmRecordList.stream().filter(alarm -> equipment.getClientId().equals(alarm.getClientId())).findFirst();
                            if (op.isPresent()) {
                                equipmentDTO.setAlarmContent(op.get().getAlarmContent());
                                equipmentDTO.setOccurrenceTime(op.get().getOccurrenceTime());
                            }
                            //获取该机器的所有警报信息
                            List<TAlarmRecord> eqAlarmList = alarmList.stream().filter(alarm -> equipment.getClientId().equals(alarm.getClientId())).collect(Collectors.toList());
                            equipmentDTO.setAlarmList(eqAlarmList);
                            if (eqAlarmList.size() > 0) {
                                int i = 0;
                                for (TAlarmRecord alarmRecord : eqAlarmList) {
                                    if (DateUtils.isSameDay(new Date(), alarmRecord.getOccurrenceTime())) {
                                        if (alarmRecord.getIsEliminate() == null || alarmRecord.getIsEliminate() == 0) {
                                            i++;
                                        }
                                    }
                                }
                                if (i > 0) {
                                    equipmentDTO.setHasTodayAlarm(true);
                                } else {
                                    equipmentDTO.setHasTodayAlarm(false);
                                }
                            }
                            return equipmentDTO;
                        }).collect(Collectors.toList());
                dto.setEquipmentList(selList);
                return dto;
            }).collect(Collectors.toList());
        } else { // 只查当前商家的设备列表
            TAdminDTO dto = new TAdminDTO();
            BeanUtils.copyPropertiesIgnoreNull(param, dto, true);
            // 需要区分是否商家子账户
            LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
            query.eq(TEquipment::getAdminId, param.getId());
            List<TEquipment> equipmentList = tEquipmentService.list(query);
            List<TAlarmRecord> alarmRecordList = tAlarmRecordService.getLastAlarmRecord(param.getId());
            //获取当前用户今天所有机器的所以警报信息
            List<TAlarmRecord> alarmList = tAlarmRecordService.getAlarmList(param.getId());

            List<TEquipmentDTO> equipmentDTOList = equipmentList.stream().map(equipment -> {
                TEquipmentDTO equipmentDTO = new TEquipmentDTO();
                BeanUtils.copyPropertiesIgnoreNull(equipment, equipmentDTO, true);
                Optional<TAlarmRecord> op = alarmRecordList.stream().filter(alarm -> equipment.getClientId().equals(alarm.getClientId())).findFirst();
                if (op.isPresent()) {
                    equipmentDTO.setAlarmContent(op.get().getAlarmContent());
                    equipmentDTO.setOccurrenceTime(op.get().getOccurrenceTime());
                }
                //获取该机器的所有警报信息
                List<TAlarmRecord> eqAlarmList = alarmList.stream().filter(alarm -> equipment.getClientId().equals(alarm.getClientId())).collect(Collectors.toList());
                equipmentDTO.setAlarmList(eqAlarmList);
                if (eqAlarmList.size() > 0) {
                    int i = 0;
                    for (TAlarmRecord alarmRecord : eqAlarmList) {
                        if (DateUtils.isSameDay(new Date(), alarmRecord.getOccurrenceTime())) {
                            if (alarmRecord.getIsEliminate() == null || alarmRecord.getIsEliminate() == 0) {
                                i++;
                            }
                        }
                    }
                    equipmentDTO.setHasTodayAlarm(i > 0);
                }
                return equipmentDTO;
            }).collect(Collectors.toList());


            dto.setEquipmentList(equipmentDTOList);
            resultList.add(dto);
        }

        return ResponseEntity.status(HttpStatus.OK)
                .body(new ResultMessage().setCode(true).setData(resultList).setMessage("SUCCESS"));

    }

    @ApiOperation(value = "消除报警")
    @PostMapping("/eliminate")
    public ResponseModel<?> eliminate(@RequestBody TAlarmRecord param) {
        TAlarmRecord tAlarmRecord = tAlarmRecordService.getById(param.getId());
        TEquipment equipment = tEquipmentService.getById(tAlarmRecord.getEquipmentId());
        if (equipment == null) {
            return R.fail(A0001, "设备不存在");
        }
        String machineType = equipment.getMachineType();
        if (StringUtils.isNotEmpty(machineType) && "2".equals(machineType)) {
            // 消除过往的报警
            LambdaUpdateWrapper<TAlarmRecord> wrapper = Wrappers.lambdaUpdate();
            wrapper.eq(TAlarmRecord::getClientId, tAlarmRecord.getClientId());
            wrapper.eq(TAlarmRecord::getIsEliminate, 0);
            wrapper.le(TAlarmRecord::getCreateDate, new Date());
            wrapper.set(TAlarmRecord::getIsEliminate, 1);
            tAlarmRecordService.update(wrapper);
            // 更改机器状态
            equipment.setIsAlarm(false);
            tEquipmentService.updateById(equipment);
        } else {
            JSONObject kindData = new JSONObject();
            kindData.put("id", param.getId());
            kindData.put("content", tAlarmRecord.getAlarmContent());
            tEquipmentService.sentMessage(equipment.getClientId(), PushUtils.buildJson("eliminate", kindData.toString()).toString());
        }
        return R.ok();
    }

    @ApiOperation(value = "修改机器音量")
    @PostMapping("/updateVolume")
    public ResponseEntity<?> updateVolume(@RequestBody TEquipment equipment) {

        if (!StringUtils.isEmpty(equipment.getVolume())) {
            TEquipment tEquipment = tEquipmentService.getById(equipment.getId());
            tEquipmentService.sentMessage(tEquipment.getClientId(), PushUtils.buildJson("volume", equipment.getVolume()).toString());
        }
        return ResponseEntity.status(HttpStatus.OK)
                .body(new ResultMessage().setCode(true).setData(true).setMessage("修改成功"));

    }

    @ApiOperation(value = "修改机器信息")
    @PostMapping("/updateEquipment")
    public ResponseEntity<?> updateEquipment(@RequestBody TEquipment equipment) {
        TEquipment equipment1 = tEquipmentService.getById(equipment.getId());
        Integer type = equipment.getType();
        //修改基本信息
        if (type == 0) {
            equipment1.setName(equipment.getName());
            equipment1.setSimNo(equipment.getSimNo());
            equipment1.setOperator(equipment.getOperator());
        }
        //修改后台密码
        if (type == 1) {
            equipment1.setAdminPwd(equipment.getAdminPwd());
            equipment1.setGuestPwd(equipment.getGuestPwd());
            tEquipmentService.sentMessage(equipment1.getClientId(), PushUtils.buildJson("guestPwd", equipment1.getGuestPwd()).toString());
            tEquipmentService.sentMessage(equipment1.getClientId(), PushUtils.buildJson("adminPwd", equipment1.getAdminPwd()).toString());
//            PushUtils.push(equipment1.getGtClientId(), "【棉花糖】设备管理-更改密码", "修改guest密码", PushUtils.buildJson("guestPwd", equipment1.getGuestPwd()).toString());
//            PushUtils.push(equipment1.getGtClientId(), "【棉花糖】设备管理-更改密码", "修改admin密码", PushUtils.buildJson("adminPwd", equipment1.getAdminPwd()).toString());
        }
        //定时开机
//        if (type == 3) {
//            equipment1.setBootTime(equipment.getBootTime());
//            tEquipmentService.sentMessage(equipment1.getClientId(),PushUtils.buildJson("updateBootTime", equipment.getBootTime()).toString());
//            PushUtils.push(equipment.getGtClientId(), "", "", PushUtils.buildJson("updateBootTime", equipment.getBootTime()).toString());
//        }
        //定时关机
//        if (type == 4) {
//            equipment1.setOffTime(equipment.getOffTime());
//            tEquipmentService.sentMessage(equipment1.getClientId(), PushUtils.buildJson("updateOffTime", equipment.getBootTime()).toString());
//            PushUtils.push(equipment.getGtClientId(), "", "", PushUtils.buildJson("updateOffTime", equipment.getBootTime()).toString());
//        }
        if (type == 5) {
            equipment1.setMessageReceiver(equipment.getMessageReceiver());
        }
        Boolean t = tEquipmentService.updateById(equipment1);
        if (t) {
            return ResponseEntity.status(HttpStatus.OK)
                    .body(new ResultMessage().setCode(true).setData(equipment1).setMessage("修改成功"));
        } else {
            return ResponseEntity.status(HttpStatus.OK)
                    .body(new ResultMessage().setCode(false).setData(t).setMessage("修改失败"));
        }

    }

    @ApiOperation(value = "根据机器id获取用户信息")
    @PostMapping("/findByEquipment")
    public ResponseEntity<?> findByEquipment(@RequestBody TEquipment equipment) {
        TEquipment tEquipment = tEquipmentService.getById(equipment.getId());
        TAdmin tAdmin = tAdminService.getById(tEquipment.getAdminId());
        return ResponseEntity.status(HttpStatus.OK)
                .body(new ResultMessage().setCode(false).setData(tAdmin).setMessage(""));
    }

    @ApiOperation(value = "根据机器编号获取用户信息")
    @PostMapping("/getEquipmentListLikeClientId")
    public ResponseEntity<?> getEquipmentListLikeClientId(@RequestBody TEquipment equipment) {
        if (StringUtils.isEmpty(equipment.getClientId())) {
            return ResponseEntity.status(HttpStatus.OK)
                    .body(new ResultMessage().setCode(false).setData("").setMessage("设备编号为空"));
        }
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.like(TEquipment::getClientId, equipment.getClientId());
        List<TEquipment> list = tEquipmentService.list(query);
        return ResponseEntity.status(HttpStatus.OK)
                .body(new ResultMessage().setCode(true).setData(list).setMessage(""));
    }

    @ApiOperation(value = "脱机")
    @PostMapping("/tuoji")
    @Audit(type = AuditEnum.OFFLINE, content = "#equipment.adminUserName + '对设备' +  #equipment.clientId + '进行了脱机操作'")
    public ResponseEntity<?> tuoji(@RequestBody TEquipment equipment) {
        if (equipment.getId() == null) {
            return ResponseEntity.status(HttpStatus.OK)
                    .body(new ResultMessage().setCode(false).setData("").setMessage(""));
        }
        TEquipment tEquipment = tEquipmentService.getById(equipment.getId());
        tEquipmentService.sentMessage(tEquipment.getClientId(), PushUtils.buildJson("tuoji", "0").toString());
        if ("xxx".equals(tEquipment.getClientId().substring(tEquipment.getClientId().length() - 3))) {
            return ResponseEntity.status(HttpStatus.OK)
                    .body(new ResultMessage().setCode(true).setData("").setMessage("发送成功！"));
        }
        tEquipment.setClientId(tEquipment.getClientId() + "xxx");
        tEquipmentService.updateById(tEquipment);
        return ResponseEntity.status(HttpStatus.OK)
                .body(new ResultMessage().setCode(true).setData("").setMessage("发送成功！"));
    }

    @ApiOperation(value = "一键补料")
    @GetMapping("/buliao")
    public ResponseModel<?> buliao(String equipmentId) {

        TEquipment equipment = tEquipmentService.getById(equipmentId);
        if (equipment == null || equipment.getId() == null) {
            return R.fail(ResponseCodesEnum.A0001, "找不到设备");
        }
        TEquipmentDesc tEquipmentDesc = equipmentDescService.getById(equipment.getId());
        if (tEquipmentDesc != null) {
            tEquipmentDesc.setBlueSugar("100");
            tEquipmentDesc.setRedSugar("100");
            tEquipmentDesc.setStick("100");
            tEquipmentDesc.setWhiteSugar("100");
            tEquipmentDesc.setYellowSugar("100");
            tEquipmentDesc.setWater("100");
            tEquipmentDesc.setWasteWater("0");
            equipmentDescService.updateById(tEquipmentDesc);
            tEquipmentService.sentMessage(equipment.getClientId(), PushUtils.buildJson("buliao", "buliao").toString());
        } else {
            return R.fail(ResponseCodesEnum.A0001, "找不到设备");
        }
        return R.ok(null, "发送请求成功");
    }

    @ApiOperation(value = "修改优惠券开关状态")
    @GetMapping("/updateCouponStatus")
    public ResponseModel<?> updateCouponStatus(String equipmentId, String couponStatus) {
        if (StringUtils.isEmpty(couponStatus) || StringUtils.isEmpty(equipmentId)) {
            return R.fail(ResponseCodesEnum.A0001, "参数有空");
        }
        TEquipment equipment = tEquipmentService.getById(equipmentId);
        if (equipment == null || equipment.getId() == null) {
            return R.fail(ResponseCodesEnum.A0001, "找不到设备");
        }
        TEquipmentDesc tEquipmentDesc = equipmentDescService.getById(equipment.getId());
        if (tEquipmentDesc != null) {
            tEquipmentService.sentMessage(equipment.getClientId(), PushUtils.buildJson("couponStatus", couponStatus).toString());
        } else {
            return R.fail(ResponseCodesEnum.A0001, "找不到设备");
        }
        return R.ok(null, "修改成功");
    }

    @ApiOperation(value = "查找设备")
    @PostMapping("/findEquipment")
    public ResponseEntity<?> findEquipment(@RequestBody TEquipment equipment) {
        TEquipment tEquipment = tEquipmentService.getById(equipment.getId());
        return ResponseEntity.status(HttpStatus.OK)
                .body(new ResultMessage().setCode(false).setData(tEquipment).setMessage(""));
    }

    @ApiOperation(value = "获取机器数量")
    @PostMapping("/getMachineNum")
    public ResponseModel<?> getMachineNum(@RequestBody StatisticsParam param) {
        String machineTotalNum;
        String machineUseNum;
        String equipmentId = param.getEquipmentId();
        String paramAdminId = param.getAdminId();
        TAdmin admin = tAdminService.getById(paramAdminId);
        Integer type = admin.getType();
        if (type < 2) {
            param.setAdminId(null);
        }
        // 公司平台
        // 申泽平台管理员
        if (admin.getId() == 2738) {
            param.setCompanyType("0");
        }
        // 七云平台管理员
        if (admin.getId() == 2739) {
            param.setCompanyType("1");
        }
        //判断是否有机器id传入
        if (equipmentId != null && !equipmentId.equals("")) {
            Long id = Long.valueOf(equipmentId);
            TEquipment equipment = tEquipmentService.getById(id);
            Long adminId = equipment.getAdminId();
            String dminId = String.valueOf(adminId);
            param.setAdminId(dminId);
            // 需要区分是否商家子账户
        }
        // 如果是子账户商家
        if (type == 3) {
            // 查找属于这个子账户的设备
            TAdminEquipment adminEquipment = tAdminEquipmentService.getById(paramAdminId);
            if (!adminEquipment.getType().equals("0")) {
                //全部机器
//            } else {
                String adminEquipmentIds = adminEquipment.getEquipmentIds();
                List<String> equipmentIds = Arrays.asList(adminEquipmentIds.split(","));
                param.setEquipmentIds(equipmentIds);
            }
            param.setAdminId(String.valueOf(admin.getParentId()));
        }
        machineTotalNum = tEquipmentService.findMachineTotalNum(param);
//        machineUseNum = tEquipmentService.findMachineUseNum(param);
        switch (type) {
            case 0:
            case 1:
                machineUseNum = tEquipmentService.findMachineUseNumAdmin(param);
                break;
            case 2:
            case 3:
                machineUseNum = tEquipmentService.findMachineUseNum(param);
                break;
            default:
                throw new IllegalArgumentException("未知等级");
        }
        Map<String, String> map = new HashMap<>();
        map.put("machineTotalNum", machineTotalNum);
        map.put("machineUseNum", machineUseNum);
        List<String> list = new ArrayList<>();
        list.add(machineTotalNum);
        list.add(machineUseNum);
        return R.ok(map, "获取成功");
    }

    @ApiOperation(value = "推送设备密码")
    @PostMapping("/updatePassword")
    public ResponseModel<?> updatePassword(@RequestBody PasswordParam passwordParam) {

        String equipmentId = passwordParam.getEquipmentId();
        String adminPwd = passwordParam.getAdminPwd();
        String guestPwd = passwordParam.getGuestPwd();
        TEquipment tEquipment = tEquipmentService.getById(equipmentId);
        if (tEquipment == null) {
            return R.fail(ResponseCodesEnum.A0001, "找不到设备");
        }
        if (StringUtils.isNotEmpty(guestPwd)) {
            tEquipmentService.sentMessage(tEquipment.getClientId(), PushUtils.buildJson("guestPwd", guestPwd).toString());
            tEquipment.setGuestPwd(guestPwd);
        }
        if (StringUtils.isNotEmpty(adminPwd)) {
            tEquipmentService.sentMessage(tEquipment.getClientId(), PushUtils.buildJson("adminPwd", adminPwd).toString());
            tEquipment.setAdminPwd(adminPwd);
        }
        tEquipmentService.updateById(tEquipment);

        return R.ok(null, "修改成功");
    }

    @ApiOperation(value = "远程开门")
    @PostMapping("/openDoor")
    public ResponseEntity<?> openDoor(@RequestBody StatisticsParam param) {
        String equipmentId = param.getEquipmentId();
        Long id = Long.valueOf(equipmentId);
        TEquipment equipment = tEquipmentService.getById(id);
        tEquipmentService.sentMessage(equipment.getClientId(), PushUtils.buildJson("openDoor", "0").toString());
//        PushUtils.push(equipment.getGtClientId(), "", "", PushUtils.buildJson("openDoor", "0").toString());
        return ResponseEntity
                .status(HttpStatus.OK)
                .body(new ResultMessage()
                        .setCode(true)
                        .setData("SUCCESS")
                        .setMessage("SUCCESS"));
    }

    //修改机器状态  type（类型，0：外门，1：内门）, status（状态：0：关闭，1：开启）
    @ApiOperation(value = "远程开门")
    @GetMapping("/openDoors")
    public ResponseModel<?> openDoor(String equipmentId, String type, String status) {
        if (StringUtils.isEmpty(equipmentId) || StringUtils.isEmpty(type) || StringUtils.isEmpty(status)) {
            return R.fail(ResponseCodesEnum.A0001, "参数有空");
        }
        TEquipment equipment = tEquipmentService.getById(equipmentId);
        if (equipment == null || equipment.getId() == null) {
            return R.fail(ResponseCodesEnum.A0001, "找不到设备");
        }
        if (type.equals("0")) {
            tEquipmentService.sentMessage(equipment.getClientId(), PushUtils.buildJson("outdoor", status).toString());
        } else if (type.equals("1")) {
            tEquipmentService.sentMessage(equipment.getClientId(), PushUtils.buildJson("indoor", status).toString());
        }
        return R.ok(null, "修改成功");
    }

    @ApiOperation(value = "查看是否远程来关机成功")
    @PostMapping("/checkStatus")
    public ResponseEntity<?> checkStatus(@RequestBody StatisticsParam param) {
        String equipmentId = param.getEquipmentId();
        Long id = Long.valueOf(equipmentId);
        TEquipment equipment = tEquipmentService.getById(id);
        String network = equipment.getNetwork();
        Long nowTime2 = getNetworkTime();
        if (network != null) {
            Long old = Long.valueOf(network);
            if (nowTime2 == null) {
                nowTime2 = getNetworkTime();
            }
            if (nowTime2 == null) {
                nowTime2 = System.currentTimeMillis();
            }
            if (nowTime2 - old < 15000) {
                return ResponseEntity
                        .status(HttpStatus.OK)
                        .body(new ResultMessage()
                                .setCode(true)
                                .setData("SUCCESS")
                                .setMessage("网络良好"));
            } else {
                return ResponseEntity
                        .status(HttpStatus.OK)
                        .body(new ResultMessage()
                                .setCode(true)
                                .setData("fail")
                                .setMessage("网络不好，操作失败"));
            }
        } else {
            return ResponseEntity
                    .status(HttpStatus.OK)
                    .body(new ResultMessage()
                            .setCode(true)
                            .setData("SUCCESS")
                            .setMessage("该机器尚未更新系统"));
        }

    }

    public static Long getNetworkTime() {
        Long time = null;
        URL url;//取得资源对象http://time.tianqi.com/
        try {
            url = new URL("http://time.tianqi.com");
            URLConnection uc = url.openConnection();//生成连接对象
            uc.connect(); //发出连接
            long ld = uc.getDate(); //取得网站日期时间
            Date date = new Date(ld); //转换为标准时间对象

            time = date.getTime();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return time;
    }

    @ApiOperation(value = "机器睡眠")
    @PostMapping("/sleep")
    public ResponseEntity<?> sleep(@RequestBody StatisticsParam param) {
        String equipmentId = param.getEquipmentId();
        Long id = Long.valueOf(equipmentId);
        TEquipment equipment = tEquipmentService.getById(id);
        String eqeStatus = "0";
        String code = param.getEqeStatus();
        if (code.equals("1")) {
            eqeStatus = "1";
            equipment.setIsSleep(true);
        } else {
            equipment.setIsSleep(false);
        }


        tEquipmentService.updateById(equipment);
        tEquipmentService.sentMessage(equipment.getClientId(), PushUtils.buildJson("is_sleep", eqeStatus).toString());
        return ResponseEntity
                .status(HttpStatus.OK)
                .body(new ResultMessage()
                        .setCode(true)
                        .setData("SUCCESS")
                        .setMessage("SUCCESS"));
    }

    @ApiOperation(value = "获取机器开关机状态")
    @PostMapping("/onOffStatus")
    public ResponseModel<?> onOffStatus(@RequestBody StatisticsParam param) {
        String equipmentId = param.getEquipmentId();
        Long id = Long.valueOf(equipmentId);
        TEquipment equipments = tEquipmentService.getById(id);
        tEquipmentService.sentMessage(equipments.getClientId(), PushUtils.buildJson("onoffstatus", "0").toString());
        return R.ok();
    }

    @ApiOperation(value = "获取所有机器开关机状态")
    @PostMapping("/equipmentStatus")
    public ResponseModel<?> equipmentStatus(@RequestBody StatisticsParam param) {
        String adminId = param.getAdminId();
        //碧桂园的机器太多，不查
        if (adminId.equals("236") || adminId.equals("31")) {
            return R.ok();
        }
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getAdminId, Long.valueOf(adminId));
        List<TEquipment> equipmentList = tEquipmentService.list(query);
        if (equipmentList.size() > 0) {
            for (TEquipment equipment : equipmentList) {
                tEquipmentService.sentMessage(equipment.getClientId(), PushUtils.buildJson("onoffstatus", "0").toString());
            }
        }
        return R.ok();
    }

    @ApiOperation(value = "检验所有机器是否开机")
    @PostMapping("/checkEquipmentStatus")
    public ResponseModel<?> checkEquipmentStatus(@RequestBody StatisticsParam param) {
        // 通过管理员ID查询所有设备
        String adminId = param.getAdminId();
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getAdminId, Long.valueOf(adminId));
        List<TEquipment> equipmentList = tEquipmentService.list(query);

        // 获取当前时间，并检查设备状态是否过期
        long nowTime = System.currentTimeMillis();
        if (equipmentList.size() > 0) {
            for (TEquipment equipment : equipmentList) {
                // 如果设备的最后修改时间超过310秒前，则清除设备状态信息
                long modifyTime = equipment.getModifyDate().getTime();
                if (nowTime > modifyTime && (nowTime - modifyTime) > 310000) {
                    equipment.setCabinetTm("");
                    equipment.setCabinetHd("");
                    equipment.setFurnaceTm("");
                    equipment.setFurnaceSp("");
                    tEquipmentService.updateById(equipment);
                }
            }
        }
        // 返回操作成功的响应
        return R.ok();
    }

    @ApiOperation(value = "雪糕机机器复位")
    @PostMapping("/machineReset")
    public ResponseModel<?> machineReset(@RequestBody StatisticsParam param) {
        String equipmentId = param.getEquipmentId();
        Long id = Long.valueOf(equipmentId);
        TEquipment equipment = tEquipmentService.getById(id);
        if (equipment == null) {
            return R.fail(F0002, "设备不存在");
        }
        tEquipmentService.sentMessage(equipment.getClientId(), PushUtils.buildJson("machineReset", "machineReset").toString());
        return R.ok();
    }

    @ApiOperation(value = "机器开关机")
    @PostMapping("/onOff")
    public ResponseEntity<?> onOff(@RequestBody StatisticsParam param) {
        String equipmentId = param.getEquipmentId();
        Long id = Long.valueOf(equipmentId);
        TEquipment equipment = tEquipmentService.getById(id);
        String eqeStatus = "1";
        String code = param.getEqeStatus();
        //开机为1，关机为0
        if (code.equals("0")) {
            eqeStatus = "0";
            equipment.setEqeStatus(0);
        } else {
            equipment.setEqeStatus(1);
        }
        Long time = getNetworkTime();
        if (time == null) {
            time = getNetworkTime();
        }
        if (time == null) {
            time = System.currentTimeMillis();
        }
        if (time != null) {
            tEquipmentService.sentMessage(equipment.getClientId(), PushUtils.buildJson("eqeStatus", eqeStatus, String.valueOf(time), "http://time.tianqi.com").toString());
        } else {
            return ResponseEntity
                    .status(HttpStatus.OK)
                    .body(new ResultMessage()
                            .setCode(false)
                            .setData("error")
                            .setMessage("error"));
        }

        return ResponseEntity
                .status(HttpStatus.OK)
                .body(new ResultMessage()
                        .setCode(true)
                        .setData("SUCCESS")
                        .setMessage("SUCCESS"));
    }

    @ApiOperation(value = "获取各省份机器销售情况")
    @PostMapping("/getEquipmentListByProvince")
    public ResponseEntity<?> getEquipmentListByProvince(@RequestBody TAdmin param) {
        List<TAdminDTO> resultList = new ArrayList<>();
        if ("sysMgtAcc".equals(param.getUsername())) { // 管理员查所有商家
            //获取有多少个省份
            List<TArea> list1 = tAreaService.getProvinceList();
            Map<Long, String> map1 = new HashMap<>();
            for (TArea area : list1) {
                String fullname = area.getFullName();
                String provinceName = fullname.substring(0, 3);
                String treePath = area.getTreePath();
                String[] str = treePath.split(",");
                Long s = null;
                if (str.length > 1) {
                    s = Long.valueOf(str[1]);
                }
                if (str.length <= 1) {
                    s = area.getId();
                }
                map1.put(s, provinceName);
            }

            List<Children3> children3List = new ArrayList<>();
            for (Long key : map1.keySet()) {
                Children3 children3 = new Children3();
                children3.setId(key);
//				children3.setName(map1.get(key));
                int pday = 0;
                int pweek = 0;
                int pmonth = 0;
                int pyear = 0;
                Set<Long> province = new HashSet<>();
                //本省有多少个市
                Map<Long, String> cityMap = new HashMap<>();
                for (TArea carea : list1) {
                    String fullName = carea.getFullName();
                    if (fullName.substring(0, 3).equals(map1.get(key))) {
                        province.add(carea.getId());
                        if (key.equals(carea.getParent())) {
                            cityMap.put(carea.getId(), carea.getName());
                        } else {
                            TArea cityArea = tAreaService.getById(carea.getParent());
                            cityMap.put(cityArea.getId(), cityArea.getName());
                        }
                    }
                }
                List<Children2> children2List = new ArrayList<>();
                //有多少个市，市有多少个商家
                for (Long citykey : cityMap.keySet()) {
                    for (TArea area : list1) {

                        String fullName = area.getFullName();
                        if (fullName.substring(0, 3).equals(map1.get(key))) {
                            //市级
                            Children2 children2 = new Children2();
                            //市级下所有商家集合
                            List<Child> Children = new ArrayList<>();
                            //属于这个市的所以设备的areaid
                            Set<Long> city = new HashSet<>();
                            //添加市级
                            if ((area.getId()).equals(citykey) || (area.getParent()).equals(citykey)) {
                                children2.setId(citykey);
                                for (TArea cityArea2 : list1) {
                                    if ((cityArea2.getId()).equals(citykey) || (cityArea2.getParent()).equals(citykey)) {
                                        city.add(cityArea2.getId());
                                    }
                                }
                                children2.setCity(city);
                                int i = 0;
                                for (Children2 children21 : children2List) {
                                    if (children21.getId().equals(citykey)) {
                                        i++;
                                    }
                                }
                                if (i == 0) {
                                    for (Long id : city) {
//                                        List<Childlast> childlasts = new ArrayList<>();
                                        Set<Long> adminIds = new HashSet<>();
//                                        List<TEquipment> equipments = tEquipmentService.findByArea(id);
                                        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
                                        query.eq(TEquipment::getAreaId, id);
                                        List<TEquipment> equipments = tEquipmentService.list(query);
                                        for (TEquipment tEquipment : equipments) {
                                            adminIds.add(tEquipment.getAdminId());
                                        }
                                        for (Long adminId3 : adminIds) {
                                            TAdmin tAdmin = tAdminService.getById(adminId3);
                                            int k = 0;
                                            for (Child child : Children) {
                                                if (child.getId().equals(tAdmin.getId())) {
                                                    k++;
                                                }
                                            }
                                            if (k == 0) {
                                                //new
                                                Child child = new Child();
                                                child.setId(adminId3);
                                                child.setName(tAdmin.getName());

                                                List<Childlast> children = new ArrayList<>();
                                                Childlast childlast1 = new Childlast();
                                                childlast1.setId(adminId3);
                                                childlast1.setName("总销售情况");
                                                children.add(0, childlast1);

//                                                List<TEquipment> tEquipmentList = tEquipmentService.findByAdmin(adminId3);
                                                LambdaQueryWrapper<TEquipment> query1 = Wrappers.lambdaQuery();
                                                query1.eq(TEquipment::getAdminId, adminId3);
                                                List<TEquipment> tEquipmentList = tEquipmentService.list(query1);
                                                for (TEquipment tEquipment : tEquipmentList) {
                                                    Long areaId = tEquipment.getAreaId();
                                                    for (Long idd : city) {
                                                        if (idd.equals(areaId)) {
                                                            Childlast childlast2 = new Childlast();
                                                            childlast2.setId(tEquipment.getId());
                                                            childlast2.setName(tEquipment.getName());
                                                            children.add(childlast2);
                                                        }
                                                    }
                                                }

                                                child.setChildren(children);
                                                Children.add(child);
                                            }

                                        }
                                    }
                                    children2.setChildren(Children);
                                    //这个市的销售数据  日 周 月 年
                                    List<Long> cityIds = new ArrayList();
                                    for (Long cityid : city) {
                                        cityIds.add(cityid);
                                    }
                                    StringBuffer namelast = new StringBuffer();
                                    namelast.append(cityMap.get(citykey)).append("  ");
                                    String day;
                                    String week;
                                    String month;
                                    String year;
                                    //数据为空时要处理
                                    for (int s = 1; s < 5; s++) {
                                        String startDate;
                                        String endDate;
                                        if (s == 1) {
                                            //日
                                            Date date = new Date();
                                            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");
                                            String format = dateFormat.format(date);
                                            startDate = format;
                                            endDate = format;
                                            Map<String, Object> params = new HashMap<>();
                                            params.put("areaIds", cityIds);
                                            params.put("startDate", startDate);
                                            params.put("endDate", endDate);
                                            Double day1 = tOrderService.getAreaPrice(params);
                                            if (day1 != null) {
                                                double ceil = Math.ceil(day1);
                                                int ceil1 = (int) ceil;
                                                pday += ceil1;
                                                day = String.valueOf(ceil1);
                                                namelast.append("-----日:").append(day);
                                            } else {
                                                namelast.append("-----日:0 ");
                                            }
                                        }
                                        if (s == 2) {
                                            //周
                                            Map<String, String> weekDate = getWeekDate();
                                            startDate = weekDate.get("mondayDate");
                                            endDate = weekDate.get("sundayDate");
                                            Map<String, Object> params = new HashMap<>();
                                            params.put("areaIds", cityIds);
                                            params.put("startDate", startDate);
                                            params.put("endDate", endDate);
                                            Double day1 = tOrderService.getAreaPrice(params);
                                            if (day1 != null) {
                                                double ceil = Math.ceil(day1);
                                                int ceil1 = (int) ceil;
                                                pweek += ceil1;
                                                week = String.valueOf(ceil1);
                                                namelast.append(" 周:").append(week);
                                            } else {
                                                namelast.append(" 周:0 ");
                                            }
                                        }
                                        if (s == 3) {
                                            //月
                                            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");
                                            //获取当前月第一天：
                                            Calendar c = Calendar.getInstance();
                                            c.add(Calendar.MONTH, 0);
                                            c.set(Calendar.DAY_OF_MONTH, 1);//设置为1号,当前日期既为本月第一天
                                            String first = dateFormat.format(c.getTime());
                                            //获取当前月最后一天
                                            Calendar ca = Calendar.getInstance();
                                            ca.set(Calendar.DAY_OF_MONTH, ca.getActualMaximum(Calendar.DAY_OF_MONTH));
                                            String last = dateFormat.format(ca.getTime());
                                            startDate = first;
                                            endDate = last;
                                            Map<String, Object> params = new HashMap<>();
                                            params.put("areaIds", cityIds);
                                            params.put("startDate", startDate);
                                            params.put("endDate", endDate);
                                            Double day1 = tOrderService.getAreaPrice(params);
                                            if (day1 != null) {
                                                double ceil = Math.ceil(day1);
                                                int ceil1 = (int) ceil;
                                                pmonth += ceil1;
                                                month = String.valueOf(ceil1);
                                                namelast.append(" 月:").append(month);
                                            } else {
                                                namelast.append(" 月:0 ");
                                            }
                                        }
                                        if (s == 4) {
                                            //年
//                                            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");
                                            Calendar cale = Calendar.getInstance();
                                            int year1 = cale.get(Calendar.YEAR);
                                            String y = String.valueOf(year1);
                                            StringBuffer st = new StringBuffer();
                                            st.append(y).append("/01/01");
                                            startDate = st.toString();
                                            StringBuffer e = new StringBuffer();
                                            e.append(y).append("/12/30");
                                            endDate = e.toString();
                                            Map<String, Object> params = new HashMap<>();
                                            params.put("areaIds", cityIds);
                                            params.put("startDate", startDate);
                                            params.put("endDate", endDate);
                                            Double day1 = tOrderService.getAreaPrice(params);
                                            if (day1 != null) {
                                                double ceil = Math.ceil(day1);
                                                int ceil1 = (int) ceil;
                                                pyear += ceil1;
                                                year = String.valueOf(ceil1);
                                                namelast.append(" 年:").append(year);
                                            } else {
                                                namelast.append(" 年:0 ");
                                            }
                                        }
                                    }
                                    children2.setName(namelast.toString());
                                    children2List.add(children2);
                                } else {
                                    i = 0;
                                }
                            }
                        }
                    }
                }
                children3.setChildren(children2List);
                children3.setProvince(province);

                StringBuffer pnameLast = new StringBuffer();
                pnameLast.append(map1.get(key)).append("-----日:").append(pday).append(" 周:").append(pweek).append(" 月:").append(pmonth).append(" 年:").append(pyear);
                children3.setName(pnameLast.toString());
                children3List.add(children3);

            }
            return ResponseEntity.status(HttpStatus.OK)
                    .body(new ResultMessage().setCode(true).setData(children3List).setMessage("SUCCESS"));

        } else { // 只查当前商家的设备列表
            return ResponseEntity.status(HttpStatus.OK)
                    .body(new ResultMessage().setCode(true).setData(resultList).setMessage("SUCCESS"));
        }

//		return ResponseEntity.status(HttpStatus.OK)
//				.body(new ResultMessage().setCode(true).setData(resultList).setMessage("SUCCESS"));

    }

    public static Map<String, String> getWeekDate() {
        Map<String, String> map = new HashMap();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");

        Calendar cal = Calendar.getInstance();
        // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
        cal.setFirstDayOfWeek(Calendar.MONDAY);
        // 获得当前日期是一个星期的第几天
        int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
        if (dayWeek == 1) {
            dayWeek = 8;
        }
        // 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
        cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - dayWeek);
        Date mondayDate = cal.getTime();
        String weekBegin = sdf.format(mondayDate);


        cal.add(Calendar.DATE, 4 + cal.getFirstDayOfWeek());
        Date sundayDate = cal.getTime();
        String weekEnd = sdf.format(sundayDate);

        map.put("mondayDate", weekBegin);
        map.put("sundayDate", weekEnd);
        return map;
    }


    /**
     * 推送设备共同以及/设备参数
     *
     * @param
     * @return
     */
    @PostMapping("/updateParameters")
    public ResponseModel<?> updateCommonParam(@RequestBody CommonParamVo commonParamVo) {
        String equipmentId = commonParamVo.getId();
        TEquipment equipment = tEquipmentService.getById(Long.valueOf(equipmentId));
        tEquipmentService.sentMessage(equipment.getClientId(), PushUtils.buildJson("Param", commonParamVo.getName() + ":" + commonParamVo.getVal()).toString());
        return R.ok();
    }

    /**
     * 推送设备共同以及/设备参数  湿度
     *
     * @param
     * @return
     */
    @PostMapping("/humidityParameters")
    public ResponseModel<?> humidityParameters(@RequestBody CommonParamVo commonParamVo) {
        String equipmentId = commonParamVo.getId();
        TEquipment equipment = tEquipmentService.getById(equipmentId);
        tEquipmentService.sentMessage(equipment.getClientId(), PushUtils.buildJson("humidityParameters", commonParamVo.getName() + ":" + commonParamVo.getVal()).toString());
        return R.ok();
    }

    /**
     * 下载日志
     *
     * @param equipmentId 设备id
     * @param day         日期
     * @param response    响应
     */
    @ApiOperation(value = "下载日志")
    @GetMapping("/downloadLog")
    public ResponseModel<?> downloadLog(String equipmentId, String day, HttpServletResponse response) throws IOException, InterruptedException {
        // 1、发送MQ到安卓端上传日志
        if (StringUtils.isEmpty(equipmentId)) {
            return R.fail(A0001);
        }
        TEquipment tEquipment = tEquipmentService.getById(equipmentId);
        if (tEquipment == null) {
            return R.fail(A0001, "该设备不存在");
        }
        String clientId = tEquipment.getClientId();
        String kind = day + "-" + clientId;
        String filepath = "/home/hboxs/log/" + kind + ".txt";
        // 1.1 如果文件已存在，直接下载
        if (Files.exists(Paths.get(filepath))) {
            try {
                Files.delete(Paths.get(filepath));
                return R.ok();
            } catch (IOException e) {
                e.printStackTrace();
                return R.fail(B0004, "请重试");
            }
        }
        String channel = tEquipment.getChannel();
        String equimentType = tEquipment.getEquimentType();
        if (StringUtils.isEmpty(channel) || channel.equals("1") || StringUtils.isEmpty(equimentType)) {
            //用个推
            PushUtils.push(tEquipment.getGtClientId(), "", "", PushUtils.buildJson("log", kind).toString());
        }
        if (StringUtils.isNotEmpty(channel) && channel.equals("2") && StringUtils.isNotEmpty(equimentType)) {
            //用Mq
            tEquipmentService.sentMessage(tEquipment.getClientId(), PushUtils.buildJson("log", kind).toString());
        }
        // 2、设置定时器查看日志是否已上传
        ScheduledExecutorService exec = Executors.newScheduledThreadPool(1);
        long startTime = System.currentTimeMillis();
        ScheduledFuture<?> future = exec.schedule(() -> {
            // 超时处理逻辑
            if (Files.exists(Paths.get(filepath))) {
                return null;
            } else {
                throw new RuntimeException("找不到日志");
            }
        }, TIMEOUT, TimeUnit.MILLISECONDS);

        while (true) {
            if (Files.exists(Paths.get(filepath))) {
                // 文件存在，取消定时器
                future.cancel(false);
                break;
            } else {
                Thread.sleep(1000);
                if (System.currentTimeMillis() - startTime >= TIMEOUT) {
                    // 超过最大等待时间，抛出异常
                    future.cancel(false);
                    throw new RuntimeException("等待文件生成超时");
                }
            }
        }
        // 3、从服务器下载文件
        DownloadUtils.downloadFile(filepath, response);
        return R.ok();
    }

    //查找设备
    @ApiOperation(value = "获取对应的机器编号")
    @GetMapping("/findEquipmentByClientIds")
    public ResponseModel<List<TEquipment>> findEquipmentByClientIds(@RequestParam("clientIds") List<String> clientIds) {

        LambdaQueryWrapper<TEquipment> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(TEquipment::getClientId, clientIds);
        List<TEquipment> list = tEquipmentService.list(wrapper);
        return R.ok(list);
    }

    @ApiOperation(value = "修改DIY花型功能开关状态")
    @GetMapping("/updateDIYFlowerStatus")
    public ResponseModel<?> updateDIYFlowerStatus(String equipmentId, String DIYFlowerStatus) {
        if (StringUtils.isEmpty(DIYFlowerStatus) || StringUtils.isEmpty(equipmentId)) {
            return R.fail(ResponseCodesEnum.A0001, "参数有空");
        }
        TEquipment equipment = tEquipmentService.getById(equipmentId);
        if (equipment == null || equipment.getId() == null) {
            return R.fail(ResponseCodesEnum.A0001, "找不到设备");
        }
        TEquipmentDesc tEquipmentDesc = equipmentDescService.getById(equipment.getId());
        if (tEquipmentDesc != null) {
            tEquipmentService.sentMessage(equipment.getClientId(), PushUtils.buildJson("DIYFlowerStatus", DIYFlowerStatus).toString());
        } else {
            return R.fail(ResponseCodesEnum.A0001, "找不到设备");
        }
        return R.ok(null, "发送成功");
    }

    @ApiOperation(value = "修改DIY花型的形状或是否显示")
    @PostMapping("/updateDIYProductShow")
    public ResponseModel<?> updateDIYProductShow(@RequestBody String productList) {
        JSONObject jsonObject = JSONObject.parseObject(productList);
        List<TDiyFlower> products = JSONObject.parseArray(jsonObject.get("productList").toString(), TDiyFlower.class);
        if (products.size() > 0) {
            TDiyFlower diyFlower = products.get(0);
            if (diyFlower == null && diyFlower.getEquipmentId() == null) {
                return R.fail(ResponseCodesEnum.A0001, "找不到当前设备");
            }
        }
        TEquipment equipment = tEquipmentService.getById(products.get(0).getEquipmentId());
        if (equipment == null) {
            return R.fail(ResponseCodesEnum.A0001, "请退出重试");
        }
        List<TProductBean> list = new ArrayList<>();
        for (TDiyFlower product : products) {
            TProductBean productBean = new TProductBean();
            if (product != null && product.getId() != null) {
                productBean.setShowType(product.getShowType());
                if (StringUtils.isEmpty(product.getShowType())) {
                    productBean.setShowType("1");
                }
                productBean.setProductName(product.getName());
                list.add(productBean);
            }
        }
        tEquipmentService.sentMessage(equipment.getClientId(), PushUtils.buildJson("updateDIYProductShow", JSON.toJSONString(list)).toString());
        return R.ok(null, "修改请求发送成功");
    }

    @ApiOperation(value = "查询DIY花型列表信息")
    @GetMapping("/selectDIYFlowers")
    public ResponseModel<?> selectDIYFlowers(String equipmentId) {
        if (StringUtils.isEmpty(equipmentId)) {
            return R.fail(ResponseCodesEnum.A0001, "参数有空");
        }
        LambdaQueryWrapper<TDiyFlower> query = Wrappers.lambdaQuery();
        query.eq(TDiyFlower::getEquipmentId, Long.valueOf(equipmentId));
        List<TDiyFlower> list = tDiyFlowerService.list(query);
        return R.ok(list);
    }

    @ApiOperation(value = "远程修改锁机状态，锁机：1，解锁：0")
    @GetMapping("/updateLockStatus")
    public ResponseModel<?> updateLockStatus(String equipmentId, String status) {
        if (StringUtils.isEmpty(equipmentId) || StringUtils.isEmpty(status)) {
            return R.fail(ResponseCodesEnum.A0001, "参数有空");
        }
        TEquipment equipment = tEquipmentService.getById(equipmentId);
        tEquipmentService.sentMessage(equipment.getClientId(), PushUtils.buildJson("block", status).toString());
        return R.ok();
    }

    /**
     * 上传日志
     *
     * @param equipmentId 设备ID，用于标识上传日志的设备
     * @param day         日期，指定要上传日志的日期
     * @return 返回操作结果，成功则返回成功信息，失败则返回失败原因
     */
    @ApiOperation(value = "上传日志")
    @GetMapping("/uploadLog")
    public ResponseModel<?> uploadLog(String equipmentId, String day) {
        // 检查设备ID是否为空
        if (StringUtils.isEmpty(equipmentId)) {
            return R.fail(A0001);
        }
        // 根据设备ID查询设备信息
        TEquipment tEquipment = tEquipmentService.getById(equipmentId);
        // 检查设备信息是否存在
        if (tEquipment == null) {
            return R.fail(A0001, "该设备不存在");
        }
        // 组装日志信息的标识
        String clientId = tEquipment.getClientId();
        String kind = day + "-" + clientId;
        // 获取设备的渠道号和类型
        String channel = tEquipment.getChannel();
        String equimentType = tEquipment.getEquimentType();
        // 如果渠道号为空或为"1"，或设备类型为空，则使用个推推送日志
        if (StringUtils.isEmpty(channel) || channel.equals("1") || StringUtils.isEmpty(equimentType)) {
            PushUtils.push(tEquipment.getGtClientId(), "", "", PushUtils.buildJson("log", kind).toString());
        }
        // 如果渠道号为"2"且设备类型不为空，则使用MQ发送日志
        if (StringUtils.isNotEmpty(channel) && channel.equals("2") && StringUtils.isNotEmpty(equimentType)) {
            tEquipmentService.sentMessage(tEquipment.getClientId(), PushUtils.buildJson("log", kind).toString());
        }
        // 返回操作成功信息
        return R.ok();
    }


    /**
     * 查询指定设备在指定日期的日志是否已上传至七牛云。
     *
     * @param equipmentId 设备ID，用于查询日志所属设备。
     * @param day         日期，格式为"yyyy-MM-dd"，用于指定要查询的日志日期。
     * @return 返回一个响应模型对象，如果日志已上传则返回成功信息和日志文件名，否则返回失败信息。
     */
    @ApiOperation(value = "查询日志是否上传成功")
    @GetMapping("/queryLog")
    public ResponseModel<?> queryLog(String equipmentId, String day) {
        // 检查设备ID是否为空
        if (StringUtils.isEmpty(equipmentId)) {
            return R.fail(A0001);
        }
        // 根据设备ID查询设备信息
        TEquipment tEquipment = tEquipmentService.getById(equipmentId);
        if (tEquipment == null) {
            return R.fail(A0001, "该设备不存在");
        }
        // 根据设备ID和日期构造日志文件名
        String clientId = tEquipment.getClientId();
        String key = "log/" + day + "-" + clientId + ".txt";

        // 配置七牛云连接
        Configuration cfg = new Configuration(Region.region2());
        Auth auth = Auth.create(ConfigConsts.QINIU_CLOUD_ACCESS_KEY, ConfigConsts.QINIU_CLOUD_SECRET_KEY);
        BucketManager bucketManager = new BucketManager(auth, cfg);

        boolean flag = true;
        try {
            // 尝试获取指定文件信息，判断文件是否存在
            FileInfo fileInfo = bucketManager.stat(ConfigConsts.QINIU_CLOUD_BUCKET, key);
        } catch (QiniuException ex) {
            System.err.println(ex.response.error);
            flag = false;
        }

        // 根据文件是否存在返回相应结果
        if (flag) {
            return R.ok(key);
        }
        return R.fail(F0002);
    }

    /**
     * 修改DIY功能使用的密码
     *
     * @param diyPassword 新的DIY功能密码
     * @return 返回操作结果，成功返回成功标志，失败返回错误代码
     */
    @ApiOperation(value = "修改diy功能使用密码")
    @GetMapping("/updateDIYPassword")
    public ResponseModel<?> updateDIYPassword(String diyPassword) {
        // 检查传入的DIY密码是否为空
        if (StringUtils.isEmpty(diyPassword)) {
            return R.fail(A0001);
        }
        // 获取管理员对象
        TAdmin admin = tAdminService.getById(1L);
        // 设置新的DIY密码
        admin.setDiyPassword(diyPassword);
        // 更新管理员信息
        tAdminService.updateById(admin);
        // 返回操作成功标志
        return R.ok();
    }


    @ApiOperation(value = "远程开启触摸屏")
    @GetMapping("/openScreen")
    public ResponseModel<?> openScreen(String equipmentId) {
        // 检查设备ID是否为空
        if (StringUtils.isEmpty(equipmentId)) {
            return R.fail(A0001);
        }
        // 根据设备ID查询设备信息
        TEquipment equipment = tEquipmentService.getById(equipmentId);
        if (equipment == null) {
            return R.fail(A0001, "该设备不存在");
        }
        // 远程开启触摸屏
        String clientId = equipment.getClientId();
        tEquipmentService.sentMessage(clientId, PushUtils.buildJson("restartAndroid", "restartAndroid").toString());
        return R.ok();
    }

    @ApiOperation(value = "远程切换雪糕机工作模式")
    @GetMapping("/updateWorkingMode")
    public ResponseModel<?> updateWorkingMode(String equipmentId, Integer workingMode) {
        if (StringUtils.isEmpty(equipmentId) || workingMode == null) {
            return R.fail(ResponseCodesEnum.A0001, "参数有空");
        }
        TEquipment equipment = tEquipmentService.getById(equipmentId);
        TEquipmentDesc equipmentDesc = equipmentDescService.getById(equipmentId);
        if (equipmentDesc == null || equipment == null) {
            return R.fail(ResponseCodesEnum.A0001, "设备不存在");
        }
        equipmentDesc.setWorkingMode(workingMode);
        equipmentDescService.updateById(equipmentDesc);
        // 发送消息给设备
        tEquipmentService.sentMessage(equipment.getClientId(), PushUtils.buildJson("workingMode", workingMode.toString()).toString());
        return R.ok();
    }

    @ApiOperation("获取设备总数")
    @GetMapping("/getEquipmentTotal")
    public ResponseModel<String> getEquipmentTotal(String adminId) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getAdminId, adminId);
        List<TEquipment> list = tEquipmentService.list(query);
        return R.ok(String.valueOf(list.size()));
    }

    @ApiOperation("导出设备列表")
    @GetMapping("/exportEquipment")
    public void exportEquipment(HttpServletResponse response) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.between(TEquipment::getLastUpdateTime, "2024-10-01", "2024-11-08");
        List<TEquipment> list = tEquipmentService.list(query);
        ExportParams exportParams = new ExportParams("设备列表", "sheet1");
        List<EquipmentParam> orderByAdminTargetList = list.stream().map(tEquipment -> {
            EquipmentParam equipmentParam = new EquipmentParam();
            equipmentParam.setEquipmentName(tEquipment.getName());
            equipmentParam.setAreaName(tEquipment.getFullName());
            equipmentParam.setClientId(tEquipment.getClientId());
            return equipmentParam;
        }).collect(Collectors.toList());
        Workbook workbook = ExcelExportUtil.exportExcel(exportParams, EquipmentParam.class, orderByAdminTargetList);
        if (workbook != null) {
            OutputStream os = null;
            try {
                os = response.getOutputStream();
                response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode("设备列表" + ".xls", "UTF-8"));
                workbook.write(os);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    os.close();
                    workbook.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}