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

package com.szwl.controller;


import cn.com.crbank.ommo.bean.ResultMessage;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.szwl.constant.ResponseCodesEnum;
import com.szwl.model.bo.R;
import com.szwl.model.bo.ResponseModel;
import com.szwl.model.entity.TAlarmClock;
import com.szwl.model.entity.TAlarmClockItem;
import com.szwl.model.entity.TEquipment;
import com.szwl.model.utils.PushUtils;
import com.szwl.service.TAlarmClockItemService;
import com.szwl.service.TAlarmClockService;
import com.szwl.service.TEquipmentService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.*;

/**
 * <p>
 * 闹钟列表 前端控制器
 * </p>
 *
 * @author wuhs
 * @since 2022-06-02
 */
@Api(value = "/tAlarmClock", tags = {"闹钟"})
@RestController
@RequestMapping("/tAlarmClock")
public class TAlarmClockController {
    @Autowired
    TAlarmClockService tAlarmClockService;
    @Autowired
    TAlarmClockItemService tAlarmClockItemService;
    @Autowired
    TEquipmentService tEquipmentService;
    @ApiOperation(value = "查询闹钟列表信息")
    @GetMapping("/list")
    public ResponseEntity<?> list(String adminId){
        LambdaQueryWrapper<TAlarmClock> query = Wrappers.lambdaQuery();
        query.eq(TAlarmClock::getAdminId,Long.valueOf(adminId));
        List<TAlarmClock> alarmClockList = tAlarmClockService.list(query);
        if(alarmClockList.size()==0){
            return ResponseEntity.status(HttpStatus.OK)
                    .body(new ResultMessage().setCode(false).setData(null).setMessage("尚未设置闹钟"));
        }
        return ResponseEntity.status(HttpStatus.OK)
                .body(new ResultMessage().setCode(true).setData(alarmClockList).setMessage("SUCCESS"));
    }
    @ApiOperation(value = "添加闹钟")
    @PostMapping("/add")
    public ResponseEntity<?> add(@RequestBody TAlarmClock alarmClock){
        if(alarmClock==null|| StringUtils.isEmpty(alarmClock.getWeek())||StringUtils.isEmpty(alarmClock.getEquipmentIds())){
            return ResponseEntity.status(HttpStatus.OK)
                    .body(new ResultMessage().setCode(false).setData(null).setMessage("数据为空"));
        }
        Date date = new Date();
        alarmClock.setCreateDate(date);
        alarmClock.setModifyDate(date);
        alarmClock.setEquipmentIds(alarmClock.getEquipmentIds()+",");
        alarmClock.setWeek(alarmClock.getWeek()+",");
        alarmClock.setHour(alarmClock.getHour()+":00");
        tAlarmClockService.save(alarmClock);
//		sentMessageToEquiment(alarmClock.getType(),alarmClock.getEquipmentIds(),alarmClock.getAdminId());
        //避免返回大量数据
//		alarmClock.setEquipmentIds(null);
        Long alarmClockItemId = alarmClock.getId();
        String equipmentIds = alarmClock.getEquipmentIds();
        String[] eids = equipmentIds.split(",");

        for (int i = 0;i < eids.length;i++){
            TAlarmClockItem alarmClockItem = new TAlarmClockItem();
            alarmClockItem.setAdminId(alarmClock.getAdminId());
            alarmClockItem.setEquipmentId(Long.valueOf(eids[i]));
            alarmClockItem.setClockId(alarmClockItemId);
            alarmClockItem.setHour(alarmClock.getHour());
            alarmClockItem.setWeek(alarmClock.getWeek());
            alarmClockItem.setStatus(alarmClock.getStatus());
            alarmClockItem.setType(alarmClock.getType());
//                alarmClockItem.setIsCirculate(alarmClocka1.getIsCirculate());
            alarmClockItem.setModifyDate(alarmClock.getModifyDate());
            alarmClockItem.setCreateDate(alarmClock.getCreateDate());
            tAlarmClockItemService.save(alarmClockItem);
        }
        for (int i = 0;i < eids.length;i++){
            TEquipment equipment = tEquipmentService.getById(Long.valueOf(eids[i]));
            LambdaQueryWrapper<TAlarmClockItem> query = Wrappers.lambdaQuery();
            query.eq(TAlarmClockItem::getEquipmentId,Long.valueOf(eids[i]));
            query.eq(TAlarmClockItem::getType,alarmClock.getType());
            query.eq(TAlarmClockItem::getStatus,"1");
            List<TAlarmClockItem> tAlarmClockItems = tAlarmClockItemService.list(query);
            Map<String,String> map = new HashMap<>();
            List<String> list = new ArrayList<>();
            if(tAlarmClockItems.size()>0){
                for(TAlarmClockItem alarmClockItem:tAlarmClockItems){
                    list.add(alarmClockItem.getWeek()+":"+alarmClockItem.getHour());

                }
                JSONObject kindData = new JSONObject();
                kindData.put("type" ,alarmClock.getType());
                kindData.put("data" , list);
                tEquipmentService.sentMessage(equipment.getClientId(), PushUtils.buildJson("alarmClock", kindData.toString()).toString());
//                    PushUtils.push(equipment.getGtClientId(), "", "", PushUtils.buildJson("alarmClock", kindData.toString()).toString());
            }
        }
        return ResponseEntity.status(HttpStatus.OK)
                .body(new ResultMessage().setCode(true).setData(alarmClock).setMessage("SUCCESS"));
    }
    @ApiOperation(value = "闹钟详情")
    @PostMapping("/selectOne")
    public ResponseEntity<?> selectOne(@RequestBody TAlarmClock alarmClock){
        if(alarmClock.getId()==null){
            return ResponseEntity.status(HttpStatus.OK)
                    .body(new ResultMessage().setCode(false).setData(null).setMessage("数据为空"));
        }
        TAlarmClock tAlarmClock = tAlarmClockService.getById(alarmClock.getId());
        tAlarmClock.setWeek(tAlarmClock.getWeek().substring(0,tAlarmClock.getWeek().length()-1));
        return ResponseEntity.status(HttpStatus.OK)
                .body(new ResultMessage().setCode(true).setData(tAlarmClock).setMessage("SUCCESS"));
    }
    @ApiOperation(value = "修改闹钟")
    @PostMapping("/updata")
    public ResponseEntity<?> updata(@RequestBody TAlarmClock alarmClock){
        if(alarmClock==null||StringUtils.isEmpty(alarmClock.getHour())){
            return ResponseEntity.status(HttpStatus.OK)
                    .body(new ResultMessage().setCode(false).setData(null).setMessage("数据为空"));
        }
        if(StringUtils.isEmpty(alarmClock.getEquipmentIds())){
            return ResponseEntity.status(HttpStatus.OK)
                    .body(new ResultMessage().setCode(false).setData(null).setMessage("机器为空"));
        }
        if(StringUtils.isEmpty(alarmClock.getWeek())){
            return ResponseEntity.status(HttpStatus.OK)
                    .body(new ResultMessage().setCode(false).setData(null).setMessage("星期为空"));
        }

        //要确认修改了什么状态，机器的增减情况
        TAlarmClock oldAlarmClock = tAlarmClockService.getById(alarmClock.getId());
        oldAlarmClock.setName(alarmClock.getName());
        tAlarmClockService.updateById(oldAlarmClock);
        //是否启用状态  0：未开启，1：已开启
        if(!oldAlarmClock.getStatus().equals(alarmClock.getStatus())){
            //修改了状态
            //是否改变了闹钟的类型
            if(!oldAlarmClock.getType().equals(alarmClock.getType())){
                //修改了类型
                //1，修改原有类型的闹钟及删除其对应的单个机器的数据，再重新创建。要把改变前和改变后的机器都通知一遍，要注意分类型推送
                //修改类型
                oldAlarmClock.setStatus(alarmClock.getStatus());
                String oldAlarmClockType = oldAlarmClock.getType();
                oldAlarmClock.setType(alarmClock.getType());
                String oldEquipmentIds = oldAlarmClock.getEquipmentIds();
                oldAlarmClock.setEquipmentIds(alarmClock.getEquipmentIds()+",");
                oldAlarmClock.setModifyDate(new Date());
                oldAlarmClock.setHour(alarmClock.getHour()+":00");
                oldAlarmClock.setWeek(alarmClock.getWeek()+",");
                tAlarmClockService.updateById(oldAlarmClock);
                //删除其对应的单个机器的数据
                LambdaQueryWrapper<TAlarmClockItem> query = Wrappers.lambdaQuery();
                query.eq(TAlarmClockItem::getClockId,oldAlarmClock.getId());
                List<TAlarmClockItem> list = tAlarmClockItemService.list(query);
                if(list.size()>0){
                    for(TAlarmClockItem tAlarmClockItem:list){
                        tAlarmClockItemService.removeById(tAlarmClockItem.getId());
                    }
                }
                //新增其对应的单个机器的数据
                addItemList(oldAlarmClock);
                //旧类型通知
                sentMessageToEquiment(oldAlarmClockType,oldEquipmentIds,oldAlarmClock.getAdminId());
                //新类型通知
                sentMessageToEquiment(alarmClock.getType(),alarmClock.getEquipmentIds(),alarmClock.getAdminId());
            }else{
                //没有修改了类型  判断机器有没有做改变
                String oldEquipmentIds = oldAlarmClock.getEquipmentIds();
                String nowEquipmentIds = alarmClock.getEquipmentIds()+",";
                Boolean b = changIds(oldEquipmentIds,nowEquipmentIds);
                //b=true 机器改变  b=false 机器没有改变
                if(b){
                    //b=true 机器改变
                    //修改t_alarm_clock的机器ids及删除其对应的单个机器的数据，再重新创建。要把改变前和改变后的机器都通知一遍
                    //修改类型t_alarm_clock的机器ids
                    oldAlarmClock.setStatus(alarmClock.getStatus());
                    oldAlarmClock.setEquipmentIds(oldAlarmClock.getEquipmentIds());
                    oldAlarmClock.setModifyDate(new Date());
                    oldAlarmClock.setHour(alarmClock.getHour()+":00");
                    oldAlarmClock.setWeek(alarmClock.getWeek()+",");
                    tAlarmClockService.updateById(oldAlarmClock);
                    //删除其对应的单个机器的数据

                    LambdaQueryWrapper<TAlarmClockItem> query = Wrappers.lambdaQuery();
                    query.eq(TAlarmClockItem::getClockId,oldAlarmClock.getId());
                    List<TAlarmClockItem> list = tAlarmClockItemService.list(query);
                    if(list.size()>0){
                        for(TAlarmClockItem tAlarmClockItem:list){
                            tAlarmClockItemService.removeById(tAlarmClockItem.getId());
                        }
                    }
                    //新增其对应的单个机器的数据
                    addItemList(oldAlarmClock);
                    //旧机器通知
                    sentMessageToEquiment(alarmClock.getType(),oldEquipmentIds,oldAlarmClock.getAdminId());
                    //新机器通知
                    sentMessageToEquiment(alarmClock.getType(),nowEquipmentIds,alarmClock.getAdminId());
                }else{
                    //b=false 机器没有改变  修改了状态  没有修改了类型
                    //判断星期有没有改变
                    Boolean aBoolean = changIds(oldAlarmClock.getWeek(), alarmClock.getWeek()+",");
                    if(aBoolean){
                        //week星期有改变
                        //修改t_alarm_clock的机器week及删除其对应的单个机器的数据，再重新创建。要把机器通知一遍
                        oldAlarmClock.setStatus(alarmClock.getStatus());
                        oldAlarmClock.setModifyDate(new Date());
                        oldAlarmClock.setHour(alarmClock.getHour()+":00");
                        oldAlarmClock.setWeek(alarmClock.getWeek()+",");
                        tAlarmClockService.updateById(oldAlarmClock);
                        //删除其对应的单个机器的数据
//                        TAlarmClockItemExample itemExample = new TAlarmClockItemExample();
//                        TAlarmClockItemExample.Criteria criteria = itemExample.createCriteria();
//                        criteria.andClockIdEqualTo(oldAlarmClock.getId());
//                        tAlarmClockItemService.deleteByOption(itemExample);
                        LambdaQueryWrapper<TAlarmClockItem> query = Wrappers.lambdaQuery();
                        query.eq(TAlarmClockItem::getClockId,oldAlarmClock.getId());
                        List<TAlarmClockItem> list = tAlarmClockItemService.list(query);
                        if(list.size()>0){
                            for(TAlarmClockItem tAlarmClockItem:list){
                                tAlarmClockItemService.removeById(tAlarmClockItem.getId());
                            }
                        }
                        //新增其对应的单个机器的数据
                        addItemList(oldAlarmClock);
                        //机器通知
                        sentMessageToEquiment(alarmClock.getType(),oldEquipmentIds,oldAlarmClock.getAdminId());
                    }else {
                        //week星期没有改变  修改了状态  没有修改了类型
                        //判断时间有没有改变
                        if(!oldAlarmClock.getHour().equals(alarmClock.getHour()+":00")){
                            //有改变
                            //修改t_alarm_clock的机器hour及删除其对应的单个机器的数据，再重新创建。要把机器通知一遍
                            oldAlarmClock.setStatus(alarmClock.getStatus());
                            oldAlarmClock.setModifyDate(new Date());
                            oldAlarmClock.setHour(alarmClock.getHour()+":00");
                            tAlarmClockService.updateById(oldAlarmClock);
                            //删除其对应的单个机器的数据
//                            TAlarmClockItemExample itemExample = new TAlarmClockItemExample();
//                            TAlarmClockItemExample.Criteria criteria = itemExample.createCriteria();
//                            criteria.andClockIdEqualTo(oldAlarmClock.getId());
//                            tAlarmClockItemService.deleteByOption(itemExample);
                            LambdaQueryWrapper<TAlarmClockItem> query = Wrappers.lambdaQuery();
                            query.eq(TAlarmClockItem::getClockId,oldAlarmClock.getId());
                            List<TAlarmClockItem> list = tAlarmClockItemService.list(query);
                            if(list.size()>0){
                                for(TAlarmClockItem tAlarmClockItem:list){
                                    tAlarmClockItemService.removeById(tAlarmClockItem.getId());
                                }
                            }
                            //新增其对应的单个机器的数据
                            addItemList(oldAlarmClock);
                            //机器通知
                            sentMessageToEquiment(alarmClock.getType(),oldEquipmentIds,oldAlarmClock.getAdminId());
                        }else{
                            //没改变
                            oldAlarmClock.setStatus(alarmClock.getStatus());
                            oldAlarmClock.setModifyDate(new Date());
                            tAlarmClockService.updateById(oldAlarmClock);
                            //删除其对应的单个机器的数据
//                            TAlarmClockItemExample itemExample = new TAlarmClockItemExample();
//                            TAlarmClockItemExample.Criteria criteria = itemExample.createCriteria();
//                            criteria.andClockIdEqualTo(oldAlarmClock.getId());
//                            tAlarmClockItemService.deleteByOption(itemExample);
                            LambdaQueryWrapper<TAlarmClockItem> query = Wrappers.lambdaQuery();
                            query.eq(TAlarmClockItem::getClockId,oldAlarmClock.getId());
                            List<TAlarmClockItem> list = tAlarmClockItemService.list(query);
                            if(list.size()>0){
                                for(TAlarmClockItem tAlarmClockItem:list){
                                    tAlarmClockItemService.removeById(tAlarmClockItem.getId());
                                }
                            }
                            //新增其对应的单个机器的数据
                            addItemList(oldAlarmClock);
                            //机器通知
                            sentMessageToEquiment(alarmClock.getType(),oldEquipmentIds,oldAlarmClock.getAdminId());
                        }
                    }
                }
            }

        }else{
            //没有修改状态
            //是否改变了闹钟的类型
            if(!oldAlarmClock.getType().equals(alarmClock.getType())){
                //修改了类型
                //1，修改原有类型的闹钟及删除其对应的单个机器的数据，再重新创建。要把改变前和改变后的机器都通知一遍，要注意分类型推送
                //修改类型
                oldAlarmClock.setStatus(alarmClock.getStatus());
                String oldAlarmClockType = oldAlarmClock.getType();
                oldAlarmClock.setType(alarmClock.getType());
                String oldEquipmentIds = oldAlarmClock.getEquipmentIds();
                oldAlarmClock.setEquipmentIds(alarmClock.getEquipmentIds()+",");
                oldAlarmClock.setModifyDate(new Date());
                oldAlarmClock.setHour(alarmClock.getHour()+":00");
                oldAlarmClock.setWeek(alarmClock.getWeek()+",");
                tAlarmClockService.updateById(oldAlarmClock);
                //删除其对应的单个机器的数据
//                TAlarmClockItemExample itemExample = new TAlarmClockItemExample();
//                TAlarmClockItemExample.Criteria criteria = itemExample.createCriteria();
//                criteria.andClockIdEqualTo(oldAlarmClock.getId());
//                tAlarmClockItemService.deleteByOption(itemExample);
                LambdaQueryWrapper<TAlarmClockItem> query = Wrappers.lambdaQuery();
                query.eq(TAlarmClockItem::getClockId,oldAlarmClock.getId());
                List<TAlarmClockItem> list = tAlarmClockItemService.list(query);
                if(list.size()>0){
                    for(TAlarmClockItem tAlarmClockItem:list){
                        tAlarmClockItemService.removeById(tAlarmClockItem.getId());
                    }
                }
                //新增其对应的单个机器的数据
                addItemList(oldAlarmClock);
                //旧类型通知
                sentMessageToEquiment(oldAlarmClockType,oldEquipmentIds,oldAlarmClock.getAdminId());
                //新类型通知
                sentMessageToEquiment(alarmClock.getType(),alarmClock.getEquipmentIds(),alarmClock.getAdminId());
            }else{
                //没有修改类型  判断机器有没有做改变
                String oldEquipmentIds = oldAlarmClock.getEquipmentIds();
                String nowEquipmentIds = alarmClock.getEquipmentIds()+",";
                Boolean b = changIds(oldEquipmentIds,nowEquipmentIds);
                //b=true 机器改变  b=false 机器没有改变
                if(b){
                    //b=true 机器改变
                    //修改t_alarm_clock的机器ids及删除其对应的单个机器的数据，再重新创建。要把改变前和改变后的机器都通知一遍
                    //修改类型t_alarm_clock的机器ids
                    oldAlarmClock.setEquipmentIds(alarmClock.getEquipmentIds()+",");
                    oldAlarmClock.setModifyDate(new Date());
                    oldAlarmClock.setHour(alarmClock.getHour()+":00");
                    oldAlarmClock.setWeek(alarmClock.getWeek()+",");
                    tAlarmClockService.updateById(oldAlarmClock);
                    //删除其对应的单个机器的数据
//                    TAlarmClockItemExample itemExample = new TAlarmClockItemExample();
//                    TAlarmClockItemExample.Criteria criteria = itemExample.createCriteria();
//                    criteria.andClockIdEqualTo(oldAlarmClock.getId());
//                    tAlarmClockItemService.deleteByOption(itemExample);
                    LambdaQueryWrapper<TAlarmClockItem> query = Wrappers.lambdaQuery();
                    query.eq(TAlarmClockItem::getClockId,oldAlarmClock.getId());
                    List<TAlarmClockItem> list = tAlarmClockItemService.list(query);
                    if(list.size()>0){
                        for(TAlarmClockItem tAlarmClockItem:list){
                            tAlarmClockItemService.removeById(tAlarmClockItem.getId());
                        }
                    }
                    //新增其对应的单个机器的数据
                    addItemList(oldAlarmClock);
                    //旧机器通知
                    sentMessageToEquiment(alarmClock.getType(),oldEquipmentIds,oldAlarmClock.getAdminId());
                    //新机器通知
                    sentMessageToEquiment(alarmClock.getType(),nowEquipmentIds,alarmClock.getAdminId());
                }else{
                    //b=false 机器没有改变 没有修改状态 没有修改类型
                    //判断星期有没有改变
                    Boolean aBoolean = changIds(oldAlarmClock.getWeek(), alarmClock.getWeek()+",");
                    if(aBoolean){
                        //week星期有改变
                        //修改t_alarm_clock的机器week及删除其对应的单个机器的数据，再重新创建。要把机器通知一遍
                        oldAlarmClock.setStatus(alarmClock.getStatus());
                        oldAlarmClock.setModifyDate(new Date());
                        oldAlarmClock.setHour(alarmClock.getHour()+":00");
                        oldAlarmClock.setWeek(alarmClock.getWeek()+",");
                        tAlarmClockService.updateById(oldAlarmClock);
                        //删除其对应的单个机器的数据
//                        TAlarmClockItemExample itemExample = new TAlarmClockItemExample();
//                        TAlarmClockItemExample.Criteria criteria = itemExample.createCriteria();
//                        criteria.andClockIdEqualTo(oldAlarmClock.getId());
//                        tAlarmClockItemService.deleteByOption(itemExample);
                        LambdaQueryWrapper<TAlarmClockItem> query = Wrappers.lambdaQuery();
                        query.eq(TAlarmClockItem::getClockId,oldAlarmClock.getId());
                        List<TAlarmClockItem> list = tAlarmClockItemService.list(query);
                        if(list.size()>0){
                            for(TAlarmClockItem tAlarmClockItem:list){
                                tAlarmClockItemService.removeById(tAlarmClockItem.getId());
                            }
                        }
                        //新增其对应的单个机器的数据
                        addItemList(oldAlarmClock);
                        //机器通知
                        sentMessageToEquiment(alarmClock.getType(),oldEquipmentIds,oldAlarmClock.getAdminId());
                    }else {
                        //week星期没有改变  修改了状态  没有修改了类型
                        //判断时间有没有改变
                        if(!oldAlarmClock.getHour().equals(alarmClock.getHour()+":00")){
                            //有改变
                            //修改t_alarm_clock的机器hour及删除其对应的单个机器的数据，再重新创建。要把机器通知一遍
                            oldAlarmClock.setStatus(alarmClock.getStatus());
                            oldAlarmClock.setModifyDate(new Date());
                            oldAlarmClock.setHour(alarmClock.getHour()+":00");
                            tAlarmClockService.updateById(oldAlarmClock);
                            //删除其对应的单个机器的数据
//                            TAlarmClockItemExample itemExample = new TAlarmClockItemExample();
//                            TAlarmClockItemExample.Criteria criteria = itemExample.createCriteria();
//                            criteria.andClockIdEqualTo(oldAlarmClock.getId());
//                            tAlarmClockItemService.deleteByOption(itemExample);
                            LambdaQueryWrapper<TAlarmClockItem> query = Wrappers.lambdaQuery();
                            query.eq(TAlarmClockItem::getClockId,oldAlarmClock.getId());
                            List<TAlarmClockItem> list = tAlarmClockItemService.list(query);
                            if(list.size()>0){
                                for(TAlarmClockItem tAlarmClockItem:list){
                                    tAlarmClockItemService.removeById(tAlarmClockItem.getId());
                                }
                            }
                            //新增其对应的单个机器的数据
                            addItemList(oldAlarmClock);
                            //机器通知
                            sentMessageToEquiment(alarmClock.getType(),oldEquipmentIds,oldAlarmClock.getAdminId());

                        }
                    }
                }
            }

        }
        return ResponseEntity.status(HttpStatus.OK)
                .body(new ResultMessage().setCode(true).setData(null).setMessage("SUCCESS"));
    }
    //机器及星期是否改变
    private Boolean changIds(String oldEquipmentIds, String nowEquipmentIds) {
        Boolean b = true;
        String[] olds = oldEquipmentIds.split(",");
        Long[] a = new Long[olds.length];
        for(int i=0;i<olds.length;i++){
            a[i] = Long.valueOf(olds[i]);
        }
        Arrays.sort(a);
        StringBuffer old = new StringBuffer();
        for(int i=0;i<a.length;i++){
            old.append(a[i]+",");
        }
        String[] newIds = nowEquipmentIds.split(",");
        Long[] c = new Long[newIds.length];
        for(int i=0;i<newIds.length;i++){
            c[i] = Long.valueOf(newIds[i]);
        }
        Arrays.sort(c);
        StringBuffer now = new StringBuffer();
        for(int i=0;i<c.length;i++){
            now.append(c[i]+",");
        }
        if(old.toString().equals(now.toString())){
            b=false;
        }
        return b;
    }
    @ApiOperation(value = "删除闹钟")
    @PostMapping("/delete")
    public ResponseModel<?> delete(@RequestBody TAlarmClock alarmClock){
        if(alarmClock.getId()==null){
            return R.fail(ResponseCodesEnum.A0001);
        }
        LambdaQueryWrapper<TAlarmClockItem> query = Wrappers.lambdaQuery();
        query.eq(TAlarmClockItem::getClockId,alarmClock.getId());
        List<TAlarmClockItem> list = tAlarmClockItemService.list(query);
        if(!list.isEmpty()){
            for(TAlarmClockItem tAlarmClockItem:list){
                tAlarmClockItemService.removeById(tAlarmClockItem.getId());
            }
        }
        tAlarmClockService.removeById(alarmClock.getId());
        return R.ok();
    }
    // 添加对应单个机器的列表
    private void addItemList(TAlarmClock alarmClock) {
        Long alarmClockItemId = alarmClock.getId();
        String equipmentIds = alarmClock.getEquipmentIds();
        String[] eids = equipmentIds.split(",");
        for (int i = 0;i < eids.length;i++){
            TAlarmClockItem alarmClockItem = new TAlarmClockItem();
            alarmClockItem.setAdminId(alarmClock.getAdminId());
            alarmClockItem.setEquipmentId(Long.valueOf(eids[i]));
            alarmClockItem.setClockId(alarmClockItemId);
            alarmClockItem.setHour(alarmClock.getHour());
            alarmClockItem.setWeek(alarmClock.getWeek());
            alarmClockItem.setStatus(alarmClock.getStatus());
            alarmClockItem.setType(alarmClock.getType());
            alarmClockItem.setModifyDate(new Date());
            alarmClockItem.setCreateDate(new Date());
            tAlarmClockItemService.save(alarmClockItem);
        }

    }
    // type 0：炉头开启，1：炉头关闭，2：开始休眠，3：结束休眠
    private void sentMessageToEquiment(String type,String ids,Long adminId) {
        String[] eids = ids.split(",");
        if(eids.length>0){
            for (int i = 0;i < eids.length;i++){
                TEquipment equipment = tEquipmentService.getById(Long.valueOf(eids[i]));
                LambdaQueryWrapper<TAlarmClockItem> query = Wrappers.lambdaQuery();
                query.eq(TAlarmClockItem::getEquipmentId,Long.valueOf(eids[i]));
                query.eq(TAlarmClockItem::getType,type);
                query.eq(TAlarmClockItem::getAdminId,adminId);
                query.eq(TAlarmClockItem::getStatus,"1");

                List<TAlarmClockItem> tAlarmClockItems = tAlarmClockItemService.list(query);
                JSONObject kindData = new JSONObject();
                kindData.put("type" ,type);
                List<String> list = new ArrayList<>();
                if(tAlarmClockItems.size()>0){
                    for(TAlarmClockItem alarmClockItem:tAlarmClockItems){
                        list.add(alarmClockItem.getWeek()+":"+alarmClockItem.getHour());

                    }
                }
                kindData.put("data" , list);
                tEquipmentService.sentMessage(equipment.getClientId(),PushUtils.buildJson("alarmClock", kindData.toString()).toString());

            }
        }

    }
}