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.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.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 org.apache.commons.compress.utils.Lists;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 事件定单表(CareEventOrder)表服务实现类
 *
 * @author makejava
 * @since 2021-05-21 00:08:29
 */
@Service
@Transactional(rollbackFor = Exception.class)
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 CareEventOrderKeyApplyService careEventOrderKeyApplyService;
    @Resource
    private CcCallResultService ccCallResultService;
    @Resource
    private CareHouseService careHouseService;
    @Resource
    private CareHouseContactService careHouseContactService;
    @Resource
    private CareOlderService careOlderService;
    @Resource
    private SmsSendService smsSendService;

    @Resource
    private BigScreenService bigScreenService;

    @Resource
    private CareDeviceService careDeviceService;

    /**
     * 工单查询
     * @param orderStatus
     * @param olderName
     * @param loginUser
     * @param pageReqVo
     * @return
     */
    public IPage<EventOrderVO> listEvent(String orderStatus, 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(olderName),CareEventOrder::getOlderName,olderName)
                .eq(CareEventOrder::getOrgId,loginUser.getOrgId())
                .eq(loginUser.getStationId()!=null,CareEventOrder::getStationId,loginUser.getStationId())
                .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()));
                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 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(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.lambda().eq(CareEventOrderHandleHis::getOrderId,item.getId()).eq(CareEventOrderHandleHis::getLogType,LogTypeEnum.DEV_EVENT.getValue());
                resVO.setWarnCount(careEventOrderHandleHisService.count(queryWrapper2));
                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.lambda().eq(CareEventOrderHandleHis::getOrderId,order.getId()).eq(CareEventOrderHandleHis::getLogType,LogTypeEnum.DEV_EVENT).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.equals(careEventOrderChamb.getStatus())){
                        mainVO.setSubStatus(ChambSubStatusEnum.DOING.getValue());//处理中
                    } else {
                        mainVO.setSubStatus(ChambSubStatusEnum.BUSY.getValue());//忙碌
                    }
                } else {//主状态不是忙碌时设置子状态和主状态相同
                    mainVO.setSubStatus(mainVO.getStatus());
                }
                mainVO.setSubStatusDesc(ChambStatusEnum.getCodeToName(mainVO.getSubStatus()));
                chambList.add(mainVO);
            } else{ //指派了管家
                //设置主管家子状态和主状态相同：空闲、休假、忙碌
                mainVO.setSubStatus(mainVO.getStatus());

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

            assignVO.setSubStatusDesc(ChambStatusEnum.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.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);
                    }
                }
                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()));
                result.add(contactorVO);
            });
        }
        return  result;
    }

    /**
     * 更新工单状态
     * @param orderId
     * @param orderStatusEnum
     */
    public void updateOrderStatus(Long orderId,OrderStatusEnum orderStatusEnum){
        CareEventOrder order = this.careEventOrderService.getById(orderId);
        UpdateWrapper<CareEventOrder> updateWrapper = new UpdateWrapper<>();
        updateWrapper.lambda().eq(CareEventOrder::getId,orderId)
                .set(CareEventOrder::getStatus,orderStatusEnum.getValue())
                .set(CareEventOrder::getModifyTime,DateUtil.date());
        this.careEventOrderService.update(updateWrapper);
        this.bigScreenService.pushRtEventFlag(order.getStationId().toString(),orderId.toString(),"bigscreenRefresh");
    }

    /**
     * 获取钥匙请求历史
     * @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 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("201室");
        house.setAddr("北太平庄21号院1单元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());
        order.setOrderType(OrderTypeEnum.values()[RandomUtil.randomInt(0,4)].getValue());
        order.setStatus("0");
        order.setCreateTime(DateUtil.date());
        order.setModifyTime(DateUtil.date());
        this.careEventOrderService.saveOrder(order);
    }


    /**
     * 发送短信接口
     * @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 = smsSendService.sendSmsToLianxiren(order.getOrderType(),contactStatus.getContactPhone(),house.getName());
            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) {
        return this.careEventOrderService.statOrder(loginUser.getOrgId(),null);
    }

    /**
     * 查询管家
     * @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,"chanmb").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){
        UpdateWrapper<CareEventOrderChamb> updateWrapper = new UpdateWrapper<>();
        updateWrapper.lambda().eq(CareEventOrderChamb::getOrderId,orderId)
                .set(CareEventOrderChamb::getChambId,chambId)
                .set(CareEventOrderChamb::getModifyTime,DateUtil.date());
        this.careEventOrderChambService.update(updateWrapper);
        return true;
    }

}