iden_server/src/main/java/com/care/bms/service/BmsEventOrderService.java

package com.care.bms.service;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.Dict;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.care.bigscreen.service.BigScreenService;
import com.care.client.dto.TemplateDataDTO;
import com.care.common.cache.RedisKeyConstant;
import com.care.common.cache.RedisUtil;
import com.care.common.entity.*;
import com.care.common.enums.*;
import com.care.common.exception.BDException;
import com.care.common.service.*;
import com.care.common.vo.PageReqVO;
import com.care.common.vo.UserLogindConvertVO;
import com.care.common.vo.order.*;
import com.care.common.vo.outcall.CcCallResultVO;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.compress.utils.Lists;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 事件定单表(CareEventOrder)表服务实现类
 *
 * @author makejava
 * @since 2021-05-21 00:08:29
 */
@Service
@Transactional(rollbackFor = Exception.class)
@Slf4j
public class BmsEventOrderService {
    @Resource
    RedisUtil redisUtil;

    @Resource
    private CareEventOrderService careEventOrderService;
    @Resource
    private CareSysUserService careSysUserService;
    @Resource
    private CareEventOrderOlderService careEventOrderOlderService;
    @Resource
    private CareEventOrderChambService careEventOrderChambService;
    @Resource
    private CareEventOrderContactStatusService careEventOrderContactStatusService;
    @Resource
    private CareEventOrderHandleHisService careEventOrderHandleHisService;
    @Resource
    private CareHandleLogService careHandleLogService;
    @Resource
    private CareEventOrderKeyApplyService careEventOrderKeyApplyService;
    @Resource
    private CcCallResultService ccCallResultService;
    @Resource
    private CareHouseService careHouseService;
    @Resource
    private SmsSendService smsSendService;
    @Autowired
    private BmsEventOrderService bmsEventOrderService;

    @Resource
    private BigScreenService bigScreenService;

    @Resource
    private CareDeviceService careDeviceService;
    @Resource
    private CareMemberInfoService careMemberInfoService;

    @Resource
    private CareHouseContactService careHouseContactService;
    @Resource
    private WxNoticSendService wxNoticSendService;
    /**
     * 工单查询
     *
     * @param orderStatus
     * @param olderName
     * @param loginUser
     * @param pageReqVo
     * @return
     */
    public IPage<EventOrderVO> listEvent(String orderStatus, String orderType, String title, String olderName, String chambId, String deviceCode, UserLogindConvertVO loginUser, PageReqVO pageReqVo) {
        IPage<CareEventOrder> page = new Page<>(pageReqVo.getCurrent(), pageReqVo.getPageSize());
        QueryWrapper<CareEventOrder> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(StrUtil.isNotEmpty(orderStatus), CareEventOrder::getStatus, orderStatus)
                .eq(StrUtil.isNotEmpty(orderType), CareEventOrder::getOrderType, orderType)
//                .like(StrUtil.isNotEmpty(title), CareEventOrder::getTitle, title)
                .like(StrUtil.isNotEmpty(olderName), CareEventOrder::getOlderName, olderName)
                .eq(StringUtils.isNotBlank(deviceCode), CareEventOrder::getDevCode, deviceCode)
                .eq(CareEventOrder::getOrgId, loginUser.getOrgId())
                .eq(loginUser.getStationId() != null, CareEventOrder::getStationId, loginUser.getStationId())
                .orderByDesc(CareEventOrder::getCreateTime);

        if (StrUtil.isNotEmpty(title)) {
            queryWrapper.lambda().and(wrapper -> wrapper.like(CareEventOrder::getTitle, title).or().eq(CareEventOrder::getDevCode, title));
        }
        if (StringUtils.isNotBlank(chambId)) {
            queryWrapper.apply("(select chamb_id from care_event_order_chamb where care_event_order_chamb.order_id = care_event_order.id) = " + chambId);
        }

        IPage<CareEventOrder> pageRes = this.careEventOrderService.page(page, queryWrapper);
        IPage<EventOrderVO> results = new Page<>(pageRes.getCurrent(), pageRes.getSize(), pageRes.getTotal());
        if (CollUtil.isNotEmpty(pageRes.getRecords())) {
            List<EventOrderVO> list = new ArrayList<>();
            pageRes.getRecords().forEach(item -> {
                EventOrderVO resVO = new EventOrderVO();
                BeanUtils.copyProperties(item, resVO);
                resVO.setOrderTypeName(OrderTypeEnum.getCodeToName(item.getOrderType()));
                resVO.setStatusName(OrderStatusEnum.getCodeToName(item.getStatus()));
                list.add(resVO);
            });
            results.setRecords(list);
        }
        return results;
    }
    /**
     * 工单查询
     *
     * @param orderStatus
     * @param chambId
     * @param loginUser
     * @param pageReqVo
     * @return
     */
    public IPage<EventOrderVO> listEventByChamb(String orderStatus, String chambId, UserLogindConvertVO loginUser, PageReqVO pageReqVo) {
        IPage<CareEventOrder> page = new Page<>(pageReqVo.getCurrent(), pageReqVo.getPageSize());
        QueryWrapper<CareEventOrder> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(StrUtil.isNotEmpty(orderStatus), CareEventOrder::getStatus, orderStatus)
                .eq(CareEventOrder::getOrgId, loginUser.getOrgId())
                .eq(loginUser.getStationId() != null, CareEventOrder::getStationId, loginUser.getStationId())
                .orderByDesc(CareEventOrder::getCreateTime);
        queryWrapper.apply("(select chamb_id from care_event_order_chamb where care_event_order_chamb.order_id = care_event_order.id) = " + chambId);
        IPage<CareEventOrder> pageRes = this.careEventOrderService.page(page, queryWrapper);
        IPage<EventOrderVO> results = new Page<>(pageRes.getCurrent(), pageRes.getSize(), pageRes.getTotal());
        if (CollUtil.isNotEmpty(pageRes.getRecords())) {
            List<EventOrderVO> list = new ArrayList<>();
            pageRes.getRecords().forEach(item -> {
                EventOrderVO resVO = new EventOrderVO();
                BeanUtils.copyProperties(item, resVO);
                resVO.setOrderTypeName(OrderTypeEnum.getCodeToName(item.getOrderType()));
                resVO.setStatusName(OrderStatusEnum.getCodeToName(item.getStatus()));
                list.add(resVO);
            });
            results.setRecords(list);
        }
        return results;
    }

    /**
     * 工单查询
     *
     * @param orderStatus
     * @param deviceCode
     * @param loginUser
     * @param pageReqVo
     * @return
     */
    public IPage<EventOrderVO> listEventByDevice(String orderStatus, String deviceCode, UserLogindConvertVO loginUser, PageReqVO pageReqVo) {
        IPage<CareEventOrder> page = new Page<>(pageReqVo.getCurrent(), pageReqVo.getPageSize());
        QueryWrapper<CareEventOrder> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(StrUtil.isNotEmpty(orderStatus), CareEventOrder::getStatus, orderStatus)
                .eq(CareEventOrder::getOrgId, loginUser.getOrgId())
                .eq(StringUtils.isNotBlank(deviceCode), CareEventOrder::getDevCode, deviceCode)
                .eq(loginUser.getStationId() != null, CareEventOrder::getStationId, loginUser.getStationId())
                .orderByDesc(CareEventOrder::getCreateTime);
        IPage<CareEventOrder> pageRes = this.careEventOrderService.page(page, queryWrapper);
        IPage<EventOrderVO> results = new Page<>(pageRes.getCurrent(), pageRes.getSize(), pageRes.getTotal());
        if (CollUtil.isNotEmpty(pageRes.getRecords())) {
            List<EventOrderVO> list = new ArrayList<>();
            pageRes.getRecords().forEach(item -> {
                EventOrderVO resVO = new EventOrderVO();
                BeanUtils.copyProperties(item, resVO);
                resVO.setOrderTypeName(OrderTypeEnum.getCodeToName(item.getOrderType()));
                resVO.setStatusName(OrderStatusEnum.getCodeToName(item.getStatus()));
                list.add(resVO);
            });
            results.setRecords(list);
        }
        return results;
    }

    /**
     * 工单查询
     *
     * @param orderStatus
     * @param olderName
     * @param loginUser
     * @return
     */
    public List<EventOrderVO> listTodoOrder(String orderStatus, String olderName, UserLogindConvertVO loginUser) {
        QueryWrapper<CareEventOrder> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(StrUtil.isNotEmpty(orderStatus), CareEventOrder::getStatus, orderStatus)
                .like(StrUtil.isNotEmpty(olderName), CareEventOrder::getOlderName, olderName)
                .eq(CareEventOrder::getOrgId, loginUser.getOrgId())
                .eq(loginUser.getStationId() != null, CareEventOrder::getStationId, loginUser.getStationId())
                //.last("limit 100")
                .orderByAsc(CareEventOrder::getCreateTime);

        List<CareEventOrder> datas = this.careEventOrderService.list(queryWrapper);
        List<EventOrderVO> results = Lists.newArrayList();
        if (CollUtil.isNotEmpty(datas)) {
            datas.forEach(item -> {
                EventOrderVO resVO = new EventOrderVO();
                BeanUtils.copyProperties(item, resVO);
                resVO.setOrderTypeName(OrderTypeEnum.getCodeToName(item.getOrderType()));
                resVO.setStatusName(OrderStatusEnum.getCodeToName(item.getStatus()));
                results.add(resVO);
            });
        }
        return results;
    }

    /**
     * 工单数量查询
     *
     * @param orderStatus
     * @param olderName
     * @param loginUser
     * @return
     */
    public Integer getTodoOrderCount(String orderStatus, String olderName, UserLogindConvertVO loginUser) {
        QueryWrapper<CareEventOrder> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(StrUtil.isNotEmpty(orderStatus), CareEventOrder::getStatus, orderStatus)
                .like(StrUtil.isNotEmpty(olderName), CareEventOrder::getOlderName, olderName)
                .eq(CareEventOrder::getOrgId, loginUser.getOrgId())
                .eq(loginUser.getStationId() != null, CareEventOrder::getStationId, loginUser.getStationId());

        int count = this.careEventOrderService.count(queryWrapper);

        return count;
    }

    /**
     * 我的处理事件 - 坐席
     *
     * @param orderStatus
     * @param olderName
     * @param loginUser
     * @param pageReqVo
     * @return
     */
    public IPage<EventOrderVO> listEvent4MyDo(String orderStatus, String title, String olderName, UserLogindConvertVO loginUser, PageReqVO pageReqVo) {
        IPage<CareEventOrder> page = new Page<>(pageReqVo.getCurrent(), pageReqVo.getPageSize());
        QueryWrapper<CareEventOrder> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(StrUtil.isNotEmpty(orderStatus), CareEventOrder::getStatus, orderStatus)
                .like(StrUtil.isNotEmpty(title), CareEventOrder::getTitle, title)
                .like(StrUtil.isNotEmpty(olderName), CareEventOrder::getOlderName, olderName)
                .eq(CareEventOrder::getOrgId, loginUser.getOrgId())
                .eq(CareEventOrder::getSeatId, loginUser.getId())
                .orderByAsc(CareEventOrder::getCreateTime);

        IPage<CareEventOrder> pageRes = this.careEventOrderService.page(page, queryWrapper);
        IPage<EventOrderVO> results = new Page<>(pageRes.getCurrent(), pageRes.getSize(), pageRes.getTotal());
        if (CollUtil.isNotEmpty(pageRes.getRecords())) {
            List<EventOrderVO> list = new ArrayList<>();
            pageRes.getRecords().forEach(item -> {
                EventOrderVO resVO = new EventOrderVO();
                BeanUtils.copyProperties(item, resVO);
                resVO.setOrderTypeName(OrderTypeEnum.getCodeToName(item.getOrderType()));
                resVO.setStatusName(OrderStatusEnum.getCodeToName(item.getStatus()));
                QueryWrapper<CareEventOrderHandleHis> queryWrapper2 = new QueryWrapper<>();
                queryWrapper2.select("distinct org_id,station_id,house_id,order_id,log_type,order_type,log_object_id,log_object_name,log_result," +
                        "op_user_role,op_user_id,op_user_name,create_time,relation_type_desc,call_result_id").lambda().eq(CareEventOrderHandleHis::getOrderId, item.getId()).eq(CareEventOrderHandleHis::getLogType, LogTypeEnum.DEV_EVENT.getValue());
                List tmpList = careEventOrderHandleHisService.list(queryWrapper2);
                resVO.setWarnCount(CollUtil.isNotEmpty(tmpList)?tmpList.size():0);
                list.add(resVO);
            });
            results.setRecords(list);
        }
        return results;
    }


    /**
     * 历史告警查询
     *
     * @return
     */
    public List<OrderHandleHisVO> listHisWarn(Long orderId) {
        CareEventOrder order = this.careEventOrderService.getById(orderId);
        QueryWrapper<CareEventOrderHandleHis> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("distinct org_id,station_id,house_id,order_id,log_type,order_type,log_object_id,log_object_name,log_result," +
                "op_user_role,op_user_id,op_user_name,create_time,relation_type_desc,call_result_id").lambda().eq(CareEventOrderHandleHis::getOrderId, order.getId()).eq(CareEventOrderHandleHis::getLogType, LogTypeEnum.DEV_EVENT.getValue()).orderByDesc(CareEventOrderHandleHis::getCreateTime);
        List<CareEventOrderHandleHis> list = careEventOrderHandleHisService.list(queryWrapper);
        List<OrderHandleHisVO> listHisWarn = new ArrayList<>();
        if (CollUtil.isNotEmpty(list)) {
            list.forEach(item -> {
                OrderHandleHisVO vo = new OrderHandleHisVO();
                BeanUtil.copyProperties(item, vo);
                vo.setOrderTypeName(OrderTypeEnum.getCodeToName(vo.getOrderType()));
                listHisWarn.add(vo);
            });
        }
        return listHisWarn;
    }


    /**
     * 近期事件查询
     *
     * @param orderStatus
     * @param loginUser
     * @return
     */
    public List<EventOrderVO> listRecentHandle(String orderStatus, UserLogindConvertVO loginUser) {
        QueryWrapper<CareEventOrder> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(StrUtil.isNotEmpty(orderStatus), CareEventOrder::getStatus, orderStatus)
                .eq(CareEventOrder::getOrgId, loginUser.getOrgId())
                .eq(loginUser.getStationId() != null, CareEventOrder::getStationId, loginUser.getStationId())
                .eq(CareEventOrder::getSeatId, loginUser.getId())
                .orderByAsc(CareEventOrder::getCreateTime);

        List<CareEventOrder> datas = this.careEventOrderService.list(queryWrapper);
        List<EventOrderVO> results = Lists.newArrayList();
        if (CollUtil.isNotEmpty(datas)) {
            datas.forEach(item -> {
                EventOrderVO resVO = new EventOrderVO();
                BeanUtils.copyProperties(item, resVO);
                resVO.setOrderTypeName(OrderTypeEnum.getCodeToName(item.getOrderType()));
                resVO.setStatusName(OrderStatusEnum.getCodeToName(item.getStatus()));
                results.add(resVO);
            });
        }
        return results;
    }

    /**
     * 处理工单
     * 使用分布式锁
     *
     * @param orderId
     * @param loginUser
     */
    public void receiveOrder(Long orderId, UserLogindConvertVO loginUser) {
        String key = RedisKeyConstant.DO_ORDER + ":" + orderId;
        boolean result = redisUtil.tryLock(key, 3000);
        try {
            if (result) {
                CareEventOrder order = this.careEventOrderService.getById(orderId);
                //1.判断工单的状态，如果不是未处理状态，则不能处理
                if (OrderStatusEnum.TODO.getValue().equals(order.getStatus())) {
                    UpdateWrapper<CareEventOrder> updateWrapper = new UpdateWrapper<>();
                    updateWrapper.lambda().eq(CareEventOrder::getId, orderId)
                            .set(CareEventOrder::getStatus, OrderStatusEnum.DOING.getValue())
                            .set(CareEventOrder::getSeatId, loginUser.getId())
                            .set(CareEventOrder::getSeatName, loginUser.getName())
                            .set(CareEventOrder::getModifyTime, DateUtil.date());
                    this.careEventOrderService.update(updateWrapper);
                } else {
                    throw new BDException("该工单状态已变化，请刷新");
                }

            } else {
                throw new BDException("该工单已经再被处理");
            }
        } finally {
            redisUtil.releaseLock(key);
        }
    }

    /**
     * @param orderId
     * @return
     */
    public EventOrderVO getOrderInfo(Long orderId) {
        EventOrderVO eventOrderVO = null;
        CareEventOrder order = this.careEventOrderService.getById(orderId);
        if (order != null) {
            eventOrderVO = new EventOrderVO();
            BeanUtil.copyProperties(order, eventOrderVO);
            eventOrderVO.setStatusName(OrderStatusEnum.getCodeToName(eventOrderVO.getStatus()));
            eventOrderVO.setOrderTypeName(OrderTypeEnum.getCodeToName(eventOrderVO.getOrderType()));
            CareHouse house = this.careHouseService.getById(order.getHouseId());
            CareHouseVO houseVO = new CareHouseVO();
            BeanUtil.copyProperties(house, houseVO);
            //houseVO.setRelationTypeDesc("屋主");
            eventOrderVO.setHouse(houseVO);
        }
        return eventOrderVO;
    }

    /**
     * 主管家改派管家列表查询
     *
     * @param orderId
     * @return
     */
    public List<ChamberlainVO> queryChambList(Long orderId) {
        List<ChamberlainVO> chambList = new ArrayList<>();

        ChamberlainVO mainVO = null;
        ChamberlainVO assignVO = null;

        CareEventOrder order = this.careEventOrderService.getById(orderId);
        CareDevice dev = this.careDeviceService.getById(order.getDevId());
        if (dev != null) {
            CareSysUser careSysUser = this.careSysUserService.getById(dev.getChambId());
            if (careSysUser != null) {
                mainVO = new ChamberlainVO();
                BeanUtil.copyProperties(careSysUser, mainVO);
                mainVO.setIsMain(TrueFalseEnum.TRUE.getValue());
                mainVO.setStatusDesc(ChambStatusEnum.getCodeToName(mainVO.getStatus()));
            }
        }
        CareEventOrderChamb careEventOrderChamb = this.careEventOrderChambService.getChambOrderByOrderId(orderId);
        if (careEventOrderChamb != null) {
            CareSysUser careSysUser = this.careSysUserService.getById(careEventOrderChamb.getChambId());
            if (careSysUser != null) {
                assignVO = new ChamberlainVO();
                BeanUtil.copyProperties(careSysUser, assignVO);
                assignVO.setIsMain(TrueFalseEnum.FALSE.getValue());
                assignVO.setStatusDesc(ChambStatusEnum.getCodeToName(mainVO.getStatus()));
            }
        }

        if (mainVO != null && assignVO != null) {
            if (mainVO.getId().equals(assignVO.getId())) { //没有指派管家
                if (ChambStatusEnum.BUSY.getValue().equals(mainVO.getStatus())) { //主状态是忙碌时拆分子状态
                    if (ChambOrderStatusEnum.DOING.getValue().equals(careEventOrderChamb.getStatus())) {
                        mainVO.setSubStatus(ChambSubStatusEnum.DOING.getValue());//处理中
                    } else {
                        mainVO.setSubStatus(ChambSubStatusEnum.BUSY.getValue());//忙碌
                    }
                } else {//主状态不是忙碌时设置子状态和主状态相同
                    mainVO.setSubStatus(mainVO.getStatus());
                }
                mainVO.setSubStatusDesc(ChambSubStatusEnum.getCodeToName(mainVO.getSubStatus()));
                chambList.add(mainVO);
            } else { //指派了管家
                //设置主管家子状态和主状态相同：空闲、休假、忙碌
                mainVO.setSubStatus(mainVO.getStatus());

                //设置指派管家状态
                if (ChambStatusEnum.BUSY.getValue().equals(assignVO.getStatus())) { //指派管家的主状态是忙碌时拆分子状态
                    if (ChambOrderStatusEnum.DOING.getValue().equals(careEventOrderChamb.getStatus())) {
                        assignVO.setSubStatus(ChambSubStatusEnum.DOING.getValue());//处理中
                    } else {
                        assignVO.setSubStatus(ChambSubStatusEnum.BUSY.getValue());//忙碌
                    }
                } else {//指派管家的主状态不是忙碌时设置子状态和主状态相同
                    assignVO.setSubStatus(assignVO.getStatus());
                }
                mainVO.setSubStatusDesc(ChambSubStatusEnum.getCodeToName(mainVO.getSubStatus()));
                chambList.add(mainVO);
                assignVO.setSubStatusDesc(ChambSubStatusEnum.getCodeToName(assignVO.getSubStatus()));
                chambList.add(assignVO);
            }
        } else if (mainVO == null && assignVO != null) {
            //设置指派管家状态
            if (ChambStatusEnum.BUSY.getValue().equals(assignVO.getStatus())) { //指派管家的主状态是忙碌时拆分子状态
                if (ChambOrderStatusEnum.DOING.getValue().equals(careEventOrderChamb.getStatus())) {
                    assignVO.setSubStatus(ChambSubStatusEnum.DOING.getValue());//处理中
                } else {
                    assignVO.setSubStatus(ChambSubStatusEnum.BUSY.getValue());//忙碌
                }
            } else {//指派管家的主状态不是忙碌时设置子状态和主状态相同
                assignVO.setSubStatus(assignVO.getStatus());
            }

            assignVO.setSubStatusDesc(ChambSubStatusEnum.getCodeToName(assignVO.getSubStatus()));
            chambList.add(assignVO);
        }

        return chambList;
    }

    /**
     * 查询老人列表
     *
     * @param orderId
     * @return
     */
    public List<OrderOlderVO> queryOrderOlderList(Long orderId) {
        List<OrderOlderVO> orderOlderVOList = Lists.newArrayList();
//        CareEventOrder order = this.careEventOrderService.getById(orderId);
        QueryWrapper<CareEventOrderOlder> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(CareEventOrderOlder::getOrderId, orderId);
        List<CareEventOrderOlder> ceoos = this.careEventOrderOlderService.list(queryWrapper);
        if (CollUtil.isNotEmpty(ceoos)) {
//            ChamberlainVO chamberlainVO = new ChamberlainVO();
//            CareHouse house = this.careHouseService.getById(order.getHouseId());
//            if (house!=null){
//                CareSysUser user = this.careSysUserService.getById(house.getChambId());
//                if (user!= null){
//                    BeanUtil.copyProperties(user,chamberlainVO);
//                }
//            }
            ceoos.forEach(item -> {
                OrderOlderVO orderOlderVO = new OrderOlderVO();
                BeanUtil.copyProperties(item, orderOlderVO);
                orderOlderVO.setStatusDesc(OrderOlderStatusEnum.getCodeToName(orderOlderVO.getStatus()));
                //orderOlderVO.setChamberlain(chamberlainVO);
                orderOlderVOList.add(orderOlderVO);
            });

        }
        return orderOlderVOList;
    }

    /**
     * 查询事件处理历史
     *
     * @param orderId
     * @return
     */
    public List<OrderHandleHisVO> queryOrderHandleHis(Long orderId) {
        List<OrderHandleHisVO> result = Lists.newArrayList();
        QueryWrapper<CareEventOrderHandleHis> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("distinct org_id,station_id,house_id,order_id,log_type,order_type,log_object_id,log_object_name,log_result," +
                "op_user_role,op_user_id,op_user_name,create_time,relation_type_desc,call_result_id,voice_call_status,voice_failure_reason,log_step").lambda().eq(CareEventOrderHandleHis::getOrderId, orderId)
                .orderByDesc(CareEventOrderHandleHis::getCreateTime);
        List<CareEventOrderHandleHis> datas = this.careEventOrderHandleHisService.list(queryWrapper);
        if (CollUtil.isNotEmpty(datas)) {
            datas.forEach(item -> {
                OrderHandleHisVO hisVO = new OrderHandleHisVO();
                BeanUtil.copyProperties(item, hisVO);
                hisVO.setHasAudioUrl(false);
                if (hisVO.getCallResultId() != null) {
                    CcCallResultVO callResultVO = this.ccCallResultService.getCallResult(hisVO.getCallResultId());
                    if (StrUtil.isNotEmpty(callResultVO.getAudioUrl())) {
                        hisVO.setHasAudioUrl(true);
                    }
                }
                if (hisVO.getLogObjectName() == null){
                    hisVO.setLogObjectName("");
                }
                result.add(hisVO);
            });
        }
        return result;
    }

    /**
     * 查询工单的相关联系人
     *
     * @param orderId
     * @return
     */
    public List<OrderContactorVO> queryContactList(Long orderId) {
        List<OrderContactorVO> result = Lists.newArrayList();
        QueryWrapper<CareEventOrderContactStatus> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(CareEventOrderContactStatus::getOrderId, orderId).orderByAsc(CareEventOrderContactStatus::getContactLevel);
        List<CareEventOrderContactStatus> ceocs = this.careEventOrderContactStatusService.list(queryWrapper);
        if (CollUtil.isNotEmpty(ceocs)) {
            ceocs.forEach(item -> {
                OrderContactorVO contactorVO = new OrderContactorVO();
                BeanUtil.copyProperties(item, contactorVO);
                contactorVO.setStatusDesc(ContactorStatusEnum.getCodeToName(item.getStatus()));
                if (contactorVO.getContactName() == null){
                    contactorVO.setContactName("");
                }
                result.add(contactorVO);
            });
        }
        return result;
    }

    /**
     * 更新工单状态
     *
     * @param orderId
     * @param loginUser
     */
    public void complete(Long orderId, UserLogindConvertVO loginUser) {
        CareEventOrder order = this.careEventOrderService.getById(orderId);
        UpdateWrapper<CareEventOrder> updateWrapper = new UpdateWrapper<>();
        updateWrapper.lambda().eq(CareEventOrder::getId, orderId)
                .set(CareEventOrder::getStatus, OrderStatusEnum.COMPLETE.getValue())
                .set(CareEventOrder::getModifyTime, DateUtil.date());
        this.careEventOrderService.update(updateWrapper);
        CareEventOrderHandleHis log = new CareEventOrderHandleHis();
        log.setOrgId(order.getOrgId());
        log.setStationId(order.getStationId());
        log.setOrderId(order.getId());
        log.setLogType(LogTypeEnum.CLOSE.getValue());
        log.setLogObjectId(loginUser.getId());
        log.setLogObjectName(loginUser.getName());
        log.setLogResult("完成工单");
        log.setOpUserRole(UserRoleEnum.SEAT.getValue());
        log.setCreateTime(DateUtil.date());
        log.setRelationTypeDesc(UserRoleEnum.getCodeToName(loginUser.getRole()));
        this.careEventOrderHandleHisService.save(log);
        this.bigScreenService.pushRtEventFlag(order.getOrgId(), order.getStationId(), orderId.toString(), "bigscreenRefresh");
    }

    /**
     * 更新工单状态
     *
     * @param orderIds
     * @param loginUser
     */
    public boolean completeByIds(List orderIds, UserLogindConvertVO loginUser) {
        if (CollectionUtils.isEmpty(orderIds)) {
            return false;
        }
        List<Dict> pushRecords = Lists.newArrayList();
        for (Object orderId : orderIds) {
            CareEventOrder order = this.careEventOrderService.getById(NumberUtils.toLong(Objects.toString(orderId)));
            if (OrderStatusEnum.TODO.getValue().equals(order.getStatus()) || OrderStatusEnum.DOING.getValue().equals(order.getStatus())){
                UpdateWrapper<CareEventOrder> updateWrapper = new UpdateWrapper<>();
                updateWrapper.lambda().eq(CareEventOrder::getId, orderId)
                        .set(CareEventOrder::getStatus, OrderStatusEnum.COMPLETE.getValue())
                        .set(CareEventOrder::getSeatId,loginUser.getId())
                        .set(CareEventOrder::getSeatName,loginUser.getName())
                        .set(CareEventOrder::getModifyTime, DateUtil.date());
                this.careEventOrderService.update(updateWrapper);
                CareEventOrderHandleHis log = new CareEventOrderHandleHis();
                log.setOrgId(order.getOrgId());
                log.setStationId(order.getStationId());
                log.setOrderId(order.getId());
                log.setLogType(LogTypeEnum.CLOSE.getValue());
                log.setLogObjectId(loginUser.getId());
                log.setLogObjectName(loginUser.getName());
                log.setLogResult("完成工单");
                log.setOpUserRole(UserRoleEnum.SEAT.getValue());
                log.setCreateTime(DateUtil.date());
                log.setRelationTypeDesc(UserRoleEnum.getCodeToName(loginUser.getRole()));
                boolean saved = this.careEventOrderHandleHisService.save(log);
                if (!saved) {
                    throw new BDException("事件归档出现错误, 请稍后重试");
                }
                pushRecords.add(Dict.create()
                        .set("orgId", order.getOrgId())
                        .set("stationId", order.getStationId())
                        .set("orderId", orderId));
            }
        }
        for (Dict dict : pushRecords) {
            this.bigScreenService.pushRtEventFlag(dict.getLong("orgId"), dict.getLong("stationId"), dict.getStr("orderId"), "bigscreenRefresh");
        }
        for (Dict dict : pushRecords) {
            //this.bmsEventOrderService.sendSmsToMemberAndLianxiren(dict.getLong("orderId"),"工单完成");
        }
        return true;
    }

    /**
     * 获取钥匙请求历史
     *
     * @param orderId
     * @return
     */
    public List<OrderKeyApplyVO> queryKeyAuthList(Long orderId) {
        List<OrderKeyApplyVO> result = Lists.newArrayList();
        QueryWrapper<CareEventOrderKeyApply> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(CareEventOrderKeyApply::getOrderId, orderId).orderByDesc(CareEventOrderKeyApply::getCreateTime);
        List<CareEventOrderKeyApply> ceocs = this.careEventOrderKeyApplyService.list(queryWrapper);
        if (CollUtil.isNotEmpty(ceocs)) {
            ceocs.forEach(item -> {
                OrderKeyApplyVO keyApplyVO = new OrderKeyApplyVO();
                BeanUtil.copyProperties(item, keyApplyVO);
                result.add(keyApplyVO);
            });
        }
        return result;
    }

    /**
     * 钥匙授权
     *
     * @param applyId
     * @return
     */
    public boolean keyAuth(Long applyId, UserLogindConvertVO loginUser) {
        CareEventOrderKeyApply apply = this.careEventOrderKeyApplyService.getById(applyId);
        UpdateWrapper<CareEventOrderKeyApply> updateWrapper = new UpdateWrapper<>();
        updateWrapper.lambda().eq(CareEventOrderKeyApply::getId, applyId)
                .set(CareEventOrderKeyApply::getKeyPass, RandomUtil.randomNumbers(6))
                .set(CareEventOrderKeyApply::getStatus, KeyAuthEnum.AUTHED.getValue());
        CareEventOrderHandleHis his = new CareEventOrderHandleHis();
        his.setOrgId(apply.getOrgId());
        his.setStationId(apply.getStationId());
        his.setOrderId(apply.getOrderId());
        his.setLogType(LogTypeEnum.KEY.getValue());
        his.setLogObjectId(apply.getApplyUserId());
        his.setLogObjectName(apply.getApplyUserName());
        his.setLogResult("获得钥匙");
        his.setOpUserRole(UserRoleEnum.SEAT.getValue());
        his.setOpUserId(loginUser.getId());
        his.setOpUserName(loginUser.getName());
        his.setCreateTime(DateUtil.date());
        his.setRelationTypeDesc(apply.getRelationTypeDesc());
        this.careEventOrderHandleHisService.save(his);
        return this.careEventOrderKeyApplyService.update(updateWrapper);
    }

    /**
     * 修改联系人状态
     *
     * @param orderContactId
     * @param status
     * @return
     */
    public boolean updateOrderContactStatus(Long orderContactId, Integer status, UserLogindConvertVO loginUser) {
        CareEventOrderContactStatus contact = this.careEventOrderContactStatusService.getById(orderContactId);
        UpdateWrapper<CareEventOrderContactStatus> updateWrapper = new UpdateWrapper<>();
        updateWrapper.lambda().eq(CareEventOrderContactStatus::getId, orderContactId)
                .set(CareEventOrderContactStatus::getStatus, status);

        CareEventOrderHandleHis his = new CareEventOrderHandleHis();
        his.setOrgId(contact.getOrgId());
        his.setStationId(contact.getStationId());
        his.setOrderId(contact.getOrderId());
        his.setLogType(LogTypeEnum.OUT_CALL.getValue());
        his.setLogObjectId(contact.getContactId());
        his.setLogObjectName(contact.getContactName());
        his.setLogResult(ContactorStatusEnum.getCodeToName(status));
        his.setOpUserRole(UserRoleEnum.SEAT.getValue());
        his.setOpUserId(loginUser.getId());
        his.setOpUserName(loginUser.getName());
        his.setCreateTime(DateUtil.date());
        his.setRelationTypeDesc(contact.getRelationTypeDesc());
        this.careEventOrderHandleHisService.save(his);
        return this.careEventOrderContactStatusService.update(updateWrapper);
    }

    /**
     * 语音通知回调后修改联系人状态
     *
     * @param orderId
     * @param status
     * @return
     */
    public boolean updateOrderContactStatus4Callback(String callId, Long orderId,String phone, Integer status,String failureReason) {

        //联系人的，care_event_order_contact_status只有联系人，没有管家
        UpdateWrapper<CareEventOrderContactStatus> updateWrapper = new UpdateWrapper<>();
        updateWrapper.lambda().eq(CareEventOrderContactStatus::getOrderId, orderId).eq(CareEventOrderContactStatus::getContactPhone,phone)
                .set(CareEventOrderContactStatus::getStatus, status);

        //历史表的
        UpdateWrapper<CareEventOrderHandleHis> updateWrapper2 = new UpdateWrapper<>();
        updateWrapper2.lambda().eq(CareEventOrderHandleHis::getVoiceCallId,callId)
                .set(CareEventOrderHandleHis::getVoiceCallStatus, status)
                .set(CareEventOrderHandleHis::getVoiceFailureReason, failureReason);
        this.careEventOrderHandleHisService.update(updateWrapper2);

        //管家的
        UpdateWrapper<CareEventOrderChamb> updateWrapper3 = new UpdateWrapper<>();
        updateWrapper3.lambda().eq(CareEventOrderChamb::getOrderId,orderId).eq(CareEventOrderChamb::getPhone,phone)
                .set(CareEventOrderChamb::getVoiceCallStatus, status);
        this.careEventOrderChambService.update(updateWrapper3);

        return this.careEventOrderContactStatusService.update(updateWrapper);
    }


    /**
     * 获取通话结果
     *
     * @param hisId
     */
    public CcCallResultVO getCallRadio(Long hisId) {
        CareEventOrderHandleHis his = this.careEventOrderHandleHisService.getById(hisId);
        if (his.getCallResultId() != null) {
            return this.ccCallResultService.getCallResult(his.getCallResultId());
        } else {
            return null;
        }

    }

    public void insertTestData() {
        List<CareHouse> houses = Lists.newArrayList();
        CareHouse house = new CareHouse();
        house.setId(1L);
        house.setName("北太平庄21号院1单元201室");
        house.setAddr("北太平庄21号院1单元");
        house.setHouseNumber("201室");
        houses.add(house);
        CareEventOrder order = new CareEventOrder();
        order.setOrgId(1L);
        order.setOrgName("测试机构");
        order.setStationId(1L);
        order.setStationName("站点1");
        order.setHouseId(1L);
        order.setDevId(1L);
        order.setDevName("卧室");
        order.setHouseName(house.getName());
        order.setTitle(house.getAddr() + house.getHouseNumber());
        order.setOrderType(OrderTypeEnum.values()[RandomUtil.randomInt(0, 4)].getValue());
        order.setStatus("0");
        order.setCreateTime(DateUtil.date());
        order.setModifyTime(DateUtil.date());
        order.setTid(1);
        this.careEventOrderService.saveOrder(order);
    }

    /**
     * 给用户和联系人发送工单完成短信
     *
     * @param orderId
     * @return
     */
    public void sendSmsToMemberAndLianxiren(Long orderId, String content) {
        CareEventOrder order = this.careEventOrderService.getById(orderId);
        if (order == null) {
            return;
        }
        CareHouse house = this.careHouseService.getById(order.getHouseId());
        if (house == null){
            return;
        }
        sendWXToMember(order, house, content);
        Object switchSms = redisUtil.get(RedisKeyConstant.SWITCH_SMS);
        if (switchSms != null) {
            sendSmsToMember(order, house, content);
            sendSmsToLianxirenList(order, house, content);
        }
    }

    /**
     * 给用户发送工单完成短信
     *
     * @param order
     * @return
     */
    private void sendSmsToMember(CareEventOrder order,CareHouse house, String content) {
        if (order.getMemberId() == null || order.getMemberId() == 0L) {
            return;
        }
        CareMemberInfo careMemberInfo = this.careMemberInfoService.getById(order.getMemberId());
        if (careMemberInfo == null) {
            return;
        }
        String[] params = {house.getName(), OrderTypeEnum.getCodeToName(order.getOrderType())};
        boolean smsResult = smsSendService.sendSmsToLianxirenOrMember(SmsTemplateTypeEnum.ORDER_COMPLETE, careMemberInfo.getPhone(), params);
        if (smsResult) {
            CareEventOrderHandleHis log = new CareEventOrderHandleHis();
            log.setOrgId(order.getOrgId());
            log.setStationId(order.getStationId());
            log.setOrderId(order.getId());
            log.setLogType(LogTypeEnum.SMS.getValue());
            log.setLogObjectId(order.getMemberId());
            String name = careMemberInfo.getPhone();
            if (StrUtil.isNotEmpty(careMemberInfo.getName())){
                name = careMemberInfo.getName();
            }else if (StrUtil.isNotEmpty(careMemberInfo.getNickname())){
                name = careMemberInfo.getNickname();
            }

            log.setLogObjectName(name);
            log.setLogResult(content+"短信通知");
            log.setOpUserRole(UserRoleEnum.SEAT.getValue());
            log.setCreateTime(DateUtil.date());
            log.setRelationTypeDesc("用户");
            this.careEventOrderHandleHisService.save(log);
        }
    }
    /**
     * 给用户发送工单完成短信
     *
     * @param order
     * @return
     */
    private void sendWXToMember(CareEventOrder order,CareHouse house, String content) {
        if (order.getMemberId() == null || order.getMemberId() == 0L) {
            return;
        }
        CareMemberInfo careMemberInfo = this.careMemberInfoService.getById(order.getMemberId());
        if (careMemberInfo == null) {
            return;
        }
        if (StrUtil.isNotEmpty(careMemberInfo.getOpenId())){
            Map<String, TemplateDataDTO> data = new HashMap<>();
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            data.put("first", new TemplateDataDTO("安全事件处理完成", "#ff5200"));
            data.put("keyword1", new TemplateDataDTO(OrderTypeEnum.getCodeToName(order.getOrderType())+"报警已处理完成", "#000000"));
            data.put("keyword2", new TemplateDataDTO(simpleDateFormat.format(new Date()), "#000000"));
            data.put("keyword3", new TemplateDataDTO(house.getAddr(), "#000000"));
            // data.put("remark", new TemplateDataDTO("请尽快联系您的被监护人, 确认现场情况", "#ff5200"));
            boolean smsResult = this.wxNoticSendService.sendWhenHappen(careMemberInfo.getOpenId(),data);
            log.info("发送WX消息模板: openId: " + careMemberInfo.getOpenId() + ", ORDER: " + order.getId() + " 状态: " + smsResult);
            if (smsResult) {
                CareEventOrderHandleHis log = new CareEventOrderHandleHis();
                log.setOrgId(order.getOrgId());
                log.setStationId(order.getStationId());
                log.setOrderId(order.getId());
                log.setLogType(LogTypeEnum.WX.getValue());
                log.setLogObjectId(order.getMemberId());
                String name = careMemberInfo.getPhone();
                if (StrUtil.isNotEmpty(careMemberInfo.getName())){
                    name = careMemberInfo.getName();
                }else if (StrUtil.isNotEmpty(careMemberInfo.getNickname())){
                    name = careMemberInfo.getNickname();
                }

                log.setLogObjectName(name);
                log.setLogResult(content+"微信通知");
                log.setOpUserRole(UserRoleEnum.SYSTEM.getValue());
                log.setCreateTime(DateUtil.date());
                log.setRelationTypeDesc("用户");
                this.careEventOrderHandleHisService.save(log);
            }
        }
    }
    /**
     * 给所有联系人发送工单完成短信
     *
     * @param order
     * @return
     */
    private void sendSmsToLianxirenList(CareEventOrder order, CareHouse house, String content) {
        List<OrderContactorVO> orderContactorVOList = queryContactList(order.getId());
        if (CollUtil.isEmpty(orderContactorVOList)) {
          return;
        }

        for(OrderContactorVO orderContactorVO : orderContactorVOList) {
            CareHouseContact careHouseContact = this.careHouseContactService.getById(orderContactorVO.getContactId());
            if (careHouseContact == null) {
                continue;
            }
            String[] params = {house.getName(), OrderTypeEnum.getCodeToName(order.getOrderType())};
            boolean smsResult = smsSendService.sendSmsToLianxirenOrMember(SmsTemplateTypeEnum.ORDER_COMPLETE, orderContactorVO.getContactPhone(), params);

            if (smsResult) {
                CareEventOrderHandleHis log = new CareEventOrderHandleHis();
                log.setOrgId(order.getOrgId());
                log.setStationId(order.getStationId());
                log.setOrderId(order.getId());
                log.setLogType(LogTypeEnum.SMS.getValue());
                log.setLogObjectId(order.getMemberId());
                log.setLogObjectName(orderContactorVO.getContactName());
                log.setLogResult(content+"短信通知");
                log.setOpUserRole(UserRoleEnum.SEAT.getValue());
                log.setCreateTime(DateUtil.date());
                log.setRelationTypeDesc("联系人");
                this.careEventOrderHandleHisService.save(log);
            }
        }

    }


    /**
     * 给联系人发送短信
     * @param orderContactId
     * @return
     */
    public boolean sendSmsToLianxiren(Long orderContactId){

        CareEventOrderContactStatus contactStatus = this.careEventOrderContactStatusService.getById(orderContactId);
        if (contactStatus!=null){
            CareEventOrder order = this.careEventOrderService.getById(contactStatus.getOrderId());
            CareHouse house = this.careHouseService.getById(contactStatus.getHouseId());
            boolean smsResult = false;
            String[] params = {house.getName()};
            if (OrderTypeEnum.JIU_ZHI.getValue().equals(order.getOrderType())){
                 smsResult = smsSendService.sendSmsToLianxirenOrMember(SmsTemplateTypeEnum.JIU_ZHI,contactStatus.getContactPhone(),params);
            }else if(OrderTypeEnum.DIE_DAO.getValue().equals(order.getOrderType())){
                 smsResult = smsSendService.sendSmsToLianxirenOrMember(SmsTemplateTypeEnum.DIE_DAO,contactStatus.getContactPhone(),params);
            }
            if (smsResult){
                CareEventOrderHandleHis his = new CareEventOrderHandleHis();
                his.setOrgId(contactStatus.getOrgId());
                his.setStationId(contactStatus.getStationId());
                his.setOrderId(contactStatus.getOrderId());
                his.setLogType(LogTypeEnum.SMS.getValue());
                his.setLogObjectId(contactStatus.getContactId());
                his.setLogObjectName(contactStatus.getContactName());
                his.setLogResult("短信通知");
                his.setOpUserRole(UserRoleEnum.SEAT.getValue());
                his.setCreateTime(DateUtil.date());
                his.setRelationTypeDesc(contactStatus.getRelationTypeDesc());
                this.careEventOrderHandleHisService.save(his);
                return true;
            }else {
                return false;
            }

        }else{
            return false;
        }
    }

    /**
     * 统计机构下的事件数量
     * @param loginUser
     * @return
     */
    public  EventStaVO statOrder(UserLogindConvertVO loginUser, Long chambId, String deviceCode) {
        return this.careEventOrderService.statOrder(loginUser.getOrgId(),null, chambId, deviceCode);
    }

    /**
     * 查询管家
     * @param orderId
     * @return
     */
    public CareEventOrderChamb queryChamberlain(Long orderId){
        CareEventOrderChamb data = new CareEventOrderChamb();
        QueryWrapper<CareEventOrderChamb> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(CareEventOrderChamb::getOrderId,orderId);
        List<CareEventOrderChamb> datas = this.careEventOrderChambService.list(queryWrapper);
        if (CollUtil.isNotEmpty(datas)){
            data = datas.get(0);
        }
        return data ;
    }

    public String getSmsTemplate(Long orderId){
        CareEventOrder order =   this.careEventOrderService.getById(orderId);
        if (order!=null){
            CareHouse house = this.careHouseService.getById(order.getHouseId());
            return house.getName()+"的老人发生跌倒/久滞事情";
        }
        return null;
    }

    /**
     * 获取3D监控页面URL
     * @return
     */
    public String getRealTimeMonitorUrl(Long orderId){
        CareEventOrder order =   this.careEventOrderService.getById(orderId);
        if (order!=null){
            Map<String,String> map =  this.careDeviceService.get3dUrl(order.getDevId());
            return  map.get("toBms");
        }
        return null;
    }

    /**
     * 获取空闲管家
     * @return
     */
    public List<ChamberlainVO>  getFreeChamberlainList(Long orderId){
        List<ChamberlainVO> freeChamberlainList = new ArrayList<>();
        CareEventOrder order =   this.careEventOrderService.getById(orderId);

        QueryWrapper<CareSysUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(CareSysUser::getStatus,ChambStatusEnum.FREE.getValue()).eq(CareSysUser::getRole,UserRoleEnum.CHANMB.getValue()).eq(CareSysUser::getOrgId,order.getOrgId()).eq(CareSysUser::getStationId,order.getStationId());
        List<CareSysUser> list = this.careSysUserService.list(queryWrapper);
        if(CollUtil.isNotEmpty(list)){
            List<ChamberlainVO> tmp = new ArrayList<>();
            list.forEach(item->{
                ChamberlainVO chamberlainVO = new ChamberlainVO();
                BeanUtil.copyProperties(item,chamberlainVO);
                chamberlainVO.setStatusDesc(ChambStatusEnum.getCodeToName(chamberlainVO.getStatus()));
                CareDevice careDevice = this.careDeviceService.getById(order.getDevId());
                if(careDevice != null && chamberlainVO.getId().equals(careDevice.getChambId())) {
                    chamberlainVO.setIsMain(TrueFalseEnum.TRUE.getValue());
                    freeChamberlainList.add(chamberlainVO);
                } else {
                    chamberlainVO.setIsMain(TrueFalseEnum.FALSE.getValue());
                    tmp.add(chamberlainVO);
                }
            });
            freeChamberlainList.addAll(tmp);
        }

        return freeChamberlainList;
    }

    /**
     * 更新管家工单
     * @param orderId
     * @param chambId
     */
    public boolean updateCareEventOrderChamb(Long orderId,Long chambId){
        CareSysUser careSysUser = this.careSysUserService.getById(chambId);
        UpdateWrapper<CareEventOrderChamb> updateWrapper = new UpdateWrapper<>();
        updateWrapper.lambda().eq(CareEventOrderChamb::getOrderId,orderId)
                .set(CareEventOrderChamb::getChambId,chambId)
                .set(CareEventOrderChamb::getChambName,careSysUser.getName())
                .set(CareEventOrderChamb::getPhone,careSysUser.getPhone())
                .set(CareEventOrderChamb::getModifyTime,DateUtil.date());
        this.careEventOrderChambService.update(updateWrapper);
        return true;
    }

}