package com.template.controller;


import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.template.api.HouseNumberStateAPI;
import com.template.common.utils.DateUtil;
import com.template.common.utils.OrderNumber;
import com.template.component.WeiXiaoComponent;
import com.template.config.DoorLockConfig;
import com.template.model.dto.*;
import com.template.model.pojo.*;
import com.template.model.result.CommonResult;
import com.template.model.result.PageUtils;
import com.template.model.vo.*;
import com.template.services.*;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RestController;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.logging.Logger;
import java.util.stream.Collectors;

/**
 * <p>
 * 前端控制器
 * </p>
 *
 * @author ceshi
 * @since 2023-11-20
 */
@RestController
public class HouseNumberStateController implements HouseNumberStateAPI {

    @Autowired
    HouseNumberStateService houseNumberStateService;

    @Autowired
    HouseService houseService;

    @Autowired
    HouseNumberService houseNumberService;

    @Autowired
    HousePriceService housePriceService;

    @Autowired
    HouseOrderService houseOrderService;

    @Autowired
    HouseLockService houseLockService;

    @Autowired
    HouseOrderBillService houseOrderBillService;

    @Autowired
    DoorLockConfig doorLockConfig;

    @Autowired
    PermissionSettingService permissionSettingService;

    @Autowired
    UnlockingService unlockingService;

    @Autowired
    PasswordIssController passwordIssController;

    @Autowired
    private WeiXiaoComponent weiXiaoComponent;

    @Autowired
    UsersService usersService;

    @Autowired
    OperatingRecordService operatingRecordService;

    @Autowired
    AdminService adminService;

    @Autowired
    WaterEquipmentService waterEquipmentService;

    @Autowired
    ElectricEquipmentService electricEquipmentService;

    @Autowired
    ApartmentSettingService apartmentSettingService;

    @Override
    public CommonResult page(String keyWord, String houseType, Integer houseId, Integer buildingId, Integer status) {

//        if (ObjectUtils.isEmpty(page) && page <= 0) {
//            page = 1;
//        }
//
//        if (ObjectUtils.isEmpty(size) && size <= 0) {
//            size = 10;
//        }
        Integer houseNumberStatus = null;
        Integer houseStatus = null;
        if (ObjectUtils.isNotEmpty(status)) {
            if (status == 1) {
                houseNumberStatus = 1;
            } else if (status == 2) {
                houseNumberStatus = 2;
            } else if (status == 3) {
                houseStatus = 3;
            } else if (status == 4) {
                houseStatus = 4;
            } else if (status == 5) {
                houseStatus = 5;
            } else if (status == 6) {
                houseStatus = 6;
            }
        }

//        当时时间
//        Date date = new Date();
        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        List<House> list = houseService.list(new LambdaQueryWrapper<>());
        LocalDateTime start = LocalDateTime.now();
        LocalDateTime end = start.withHour(23).withMinute(59).withSecond(59);
        List<HouseStateVo> pageVo1 = null;

        if (ObjectUtils.isNotEmpty(houseNumberStatus) && 1 == houseNumberStatus) {
            //            有房态的id
            List<Integer> ids3 = houseNumberService.getStateHouseNumber(start, end);

//            ArrayList<Integer> ids3 = new ArrayList<>();
//            for (HouseStateVo houseStateVo : pageVo1) {
//                int houseNumberId = houseStateVo.getHouseNumberId();
//                ids3.add(houseNumberId);
//            }
//            全部房间id
            List<Integer> ids = houseNumberService.getHouseNumberIds();
//            脏房房间id
            List<Integer> ids2 = houseNumberService.getHouserNumberStatusIds(2);
//            空闲房间id
            ArrayList<Integer> integers = new ArrayList<>();
            for (Integer id : ids) {
                if (!ids2.contains(id)) {
                    if (!ids3.contains(id)) {
                        integers.add(id);
                    }
                }
            }
            //      获取当前房型的所有id
            String houseNumberIds = "";
            for (int i = 0; i < integers.size(); i++) {
                Integer id = integers.get(i);
                String houseNumber = String.valueOf(id);
                if (i == 0) {
                    houseNumberIds = houseNumberIds + houseNumber;
                } else {
                    houseNumberIds = houseNumberIds + "," + houseNumber;
                }
            }
            pageVo1 = houseNumberService.houseStateLeisurePage(keyWord, houseType, start, end, houseId, buildingId, houseNumberIds);

        } else {
            pageVo1 = houseNumberService.houseStatePage(keyWord, houseType, start, end, houseId, buildingId, houseStatus, houseNumberStatus);
        }
        HashMap<Integer, HouseStateVo> map = new HashMap<>();
        for (HouseStateVo houseStateVo : pageVo1) {
            Integer houseNumberId = houseStateVo.getHouseNumberId();
            if (map.containsKey(houseNumberId)) {
                String reserveLiveTime = "";

                if (ObjectUtils.isNotEmpty(houseStateVo.getReserveLiveTime())) {
                    reserveLiveTime = houseStateVo.getReserveLiveTime();
                } else {
                    reserveLiveTime = houseStateVo.getStartTime();
                }

                HouseStateVo houseStateVo1 = map.get(houseNumberId);

                String reserveLiveTime1 = "";

                if (ObjectUtils.isNotEmpty(houseStateVo1.getReserveLiveTime())) {
                    reserveLiveTime1 = houseStateVo1.getReserveLiveTime();
                } else {
                    reserveLiveTime1 = houseStateVo1.getStartTime();
                }

                LocalDateTime parse = LocalDateTime.parse(reserveLiveTime, dateTimeFormatter1);

                LocalDateTime parse1 = LocalDateTime.parse(reserveLiveTime1, dateTimeFormatter1);


                if (parse1.isAfter(parse)) {
                    map.put(houseNumberId, houseStateVo);
                }

            } else {
                map.put(houseNumberId, houseStateVo);
            }
        }
        List<HouseStateVo> pageVo = new ArrayList<>();
        Set<Integer> integers = map.keySet();
        for (Integer integer : integers) {
            HouseStateVo houseStateVo = map.get(integer);
            pageVo.add(houseStateVo);
        }

        ArrayList<HouseStateManagementVo> vos = new ArrayList<>();
        for (House house : list) {
            HouseStateManagementVo vo = new HouseStateManagementVo();
            vo.setId(house.getId());
            vo.setName(house.getRoomName());
            vo.setRoomType(house.getRoomType());
            List<HouseStateVo> ownerClasses = pageVo.stream().filter(e -> e.getHouseId().equals(house.getId() + "")).collect(Collectors.toList());
            if (ownerClasses != null && ownerClasses.size() > 0) {
                vo.setVos(ownerClasses);
                long freeCount = ownerClasses.stream().filter(e -> (e.getStatus() != null ? e.getStatus() : e.getHouseStatus() + "").equals("1")).count();
                long useCount = ownerClasses.size() - freeCount;
                vo.setUseCount(useCount);
                vo.setFreeCount(freeCount);
            }
            vos.add(vo);
        }

        return CommonResult.ok(vos);
    }

    @Override
    public CommonResult calendarPage(String dateTime, String keyWord, String houseType, int page, int size, Integer houseId, Integer buildingId) {
        if (ObjectUtils.isEmpty(page) && page <= 0) {
            page = 1;
        }

        if (ObjectUtils.isEmpty(size) && size <= 0) {
            size = 10;
        }

        //        返回格式
        HashMap<String, Object> map = new HashMap<>();

        //        获取当时时间
        LocalDateTime localDateTime;
//        DateTimeFormatter dateTimeFormatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        if (ObjectUtils.isEmpty(dateTime)) {
            localDateTime = LocalDateTime.now();
        } else {
            localDateTime = LocalDateTime.parse(dateTime, dateTimeFormatter1);
        }
//      需获取21天内的所有改价信息
        LocalDateTime endLocalDateTime = localDateTime.plusDays(20);

        //        获取所有房间号
        List<HouseNumber> houseNumberList = houseNumberService.list(new LambdaQueryWrapper<HouseNumber>());

        //      获取当前房型的所有id
        String houseNumberIds = "";
        for (int i = 0; i < houseNumberList.size(); i++) {
            String houseNumber = houseNumberList.get(i).getId() + "";
            if (i == 0) {
                houseNumberIds = houseNumberIds + houseNumber;
            } else {
                houseNumberIds = houseNumberIds + "," + houseNumber;
            }
        }
        System.out.println("houseNumberIds = " + houseNumberIds);

//        通过房型id获取21天内的所有房态状态
        List<HouseNumberState> houseNumberStates = houseNumberStateService.houseNumberStateList(localDateTime, endLocalDateTime, houseNumberIds);
//        房间总数
        int totalCount = houseNumberList.size();

        //        时间日期
        ArrayList<HouseNumberStateDateVo> list = new ArrayList<>();
        for (int i = 0; i < 21; i++) {
            LocalDateTime localDate1 = localDateTime.plusDays(i);
            String format = localDate1.format(dateTimeFormatter1);
            List<Map<String, Object>> useNumbers = houseNumberService.houseStateNumbers(keyWord, houseType, houseId, buildingId, format, 1);
            //0为空闲
            List<Map<String, Object>> freeNumbers = houseNumberService.houseStateNumbers(keyWord, houseType, houseId, buildingId, format, 0);
            HouseNumberStateDateVo houseNumberStateDateVo = new HouseNumberStateDateVo();
            houseNumberStateDateVo.setDate(format);
            int count = totalCount;
            for (HouseNumberState houseNumberState : houseNumberStates) {
                if (houseNumberState.getStatus() != 1) {
//                开始时间
                    String startTime = houseNumberState.getStartTime();
//                结束时间
                    String endTime = houseNumberState.getEndTime();

                    Date startDate = DateUtil.parseDateOnly(startTime);
                    Date endDate = DateUtil.parseDateOnly(endTime);
                    Date date1 = Date.from(localDate1.atZone(ZoneId.systemDefault()).toInstant());
                    boolean effectiveDate = DateUtil.isEffectiveDate(date1, startDate, endDate);
                    if (effectiveDate) {
                        count = count - 1;
                    }
                }
            }
            houseNumberStateDateVo.setCount(count);
            houseNumberStateDateVo.setFreeNumbers(freeNumbers);
            houseNumberStateDateVo.setUseNumbers(useNumbers);
            list.add(houseNumberStateDateVo);
        }
//        时间格式
        map.put("dateTime", list);


        PageUtils<CalendarPageVo> pageVo = houseNumberService.houseStateCalendarPage(keyWord, houseType, page, size, houseId, buildingId);

        List<CalendarPageVo> listVo = pageVo.getList();

        if (ObjectUtils.isEmpty(listVo) && listVo.size() <= 0) {
            map.put("page", pageVo);
            return CommonResult.ok(map);
        }
        //      获取当前房型的所有id
        String houseIds = "";
        for (int i = 0; i < listVo.size(); i++) {
            String id = listVo.get(i).getHouseId();
            if (i == 0) {
                houseIds = houseIds + id;
            } else {
                houseIds = houseIds + "," + id;
            }
        }
        System.out.println("houseIds = " + houseIds);


//        获取在这时间内所属房型的所有改价记录
        List<HousePrice> housePrices = housePriceService.housePrice(localDateTime, endLocalDateTime, houseIds);


        ArrayList<HouseNumberStatePageVo> pageVos = new ArrayList<>();
//        数据组合
        for (CalendarPageVo calendarPageVo : listVo) {
            HouseNumberStatePageVo houseNumberStatePageVo1 = new HouseNumberStatePageVo();
            houseNumberStatePageVo1.setCalendarPageVo(calendarPageVo);
            ArrayList<HouseStustaVo> houseStustaVos = new ArrayList<>();
            for (int i = 0; i < 21; i++) {
                HouseStustaVo houseNumberStatePageVo = new HouseStustaVo();
                LocalDateTime localDate1 = localDateTime.plusDays(i);
                String format = localDate1.format(dateTimeFormatter1);
                houseNumberStatePageVo.setDate(format);
                houseNumberStatePageVo.setPrice(calendarPageVo.getPrice());
//                判断这个时间内是否有
                for (HousePrice housePrice : housePrices) {
                    if (housePrice.getHouseId().equals(calendarPageVo.getHouseId())) {
                        String setDate = housePrice.getSetDate();
                        String[] split = setDate.split(",");
                        Date startDate = DateUtil.parseDateOnly(split[0]);
                        Date endDate = DateUtil.parseDateOnly(split[1]);
                        Date date1 = Date.from(localDate1.atZone(ZoneId.systemDefault()).toInstant());
                        //      判断当前时间是否在[startTime, endTime]区间
                        assert startDate != null;
                        boolean effectiveDate = DateUtil.isEffectiveDate(date1, startDate, endDate);
                        if (effectiveDate) {
                            BigDecimal price = housePrice.getPrice();
                            houseNumberStatePageVo.setPrice(price);
                        }
                    }
                }

                houseNumberStatePageVo.setStatus(calendarPageVo.getHouseStatus());
//                房态数据
                for (HouseNumberState houseNumberState : houseNumberStates) {
                    if (houseNumberState.getHouseNumberId().equals(calendarPageVo.getHouseNumberId())) {
//                开始时间
                        String startTime = houseNumberState.getStartTime();
//                结束时间
                        String endTime = houseNumberState.getEndTime();
                        LocalDateTime start = LocalDateTime.parse(startTime, dateTimeFormatter1);
                        Date startDate = Date.from(start.atZone(ZoneId.systemDefault()).toInstant());
//                        Date startDate = DateUtil.parseDateOnly(startTime);

                        LocalDateTime end = LocalDateTime.parse(endTime, dateTimeFormatter1);
                        Date endDate = Date.from(end.atZone(ZoneId.systemDefault()).toInstant());
//                        Date endDate = DateUtil.parseDateOnly(endTime);

                        Date date1 = Date.from(localDate1.atZone(ZoneId.systemDefault()).toInstant());
                        boolean effectiveDate = DateUtil.isEffectiveDate(date1, startDate, endDate);
                        if (effectiveDate) {
                            houseNumberStatePageVo.setStatus(houseNumberState.getStatus());
                            houseNumberStatePageVo.setHouseNumberStateId(houseNumberState.getId());
//                            判断是否有订单
                            String orderNumber = houseNumberState.getOrderNumber();
                            if (ObjectUtils.isNotEmpty(orderNumber)) {
                                LambdaQueryWrapper<HouseOrder> wrapperHo = new LambdaQueryWrapper<>();
                                wrapperHo.eq(HouseOrder::getOrderNumber, orderNumber);
                                HouseOrder houseOrder = houseOrderService.getOne(wrapperHo);
                                houseNumberStatePageVo.setReserveLiveTime(houseOrder.getReserveLiveTime());
                                houseNumberStatePageVo.setReserveLeaveTime(houseOrder.getReserveLeaveTime());
                                houseNumberStatePageVo.setReserveName(houseOrder.getReserveName());
//                                订单号
                                houseNumberStatePageVo.setOrderNumber(orderNumber);
                            } else {
                                houseNumberStatePageVo.setReserveLiveTime(houseNumberState.getStartTime());
                                houseNumberStatePageVo.setReserveLeaveTime(houseNumberState.getEndTime());
                            }

                        }
                    }
                }
                houseStustaVos.add(houseNumberStatePageVo);
            }

            houseNumberStatePageVo1.setHouseStustaVos(houseStustaVos);
            pageVos.add(houseNumberStatePageVo1);
        }
        Page<HouseNumberStatePageVo> houseNumberStatePageVoPage = new Page<>();
        BeanUtils.copyProperties(pageVo, houseNumberStatePageVoPage);

        houseNumberStatePageVoPage.setTotal(pageVo.getTotalCount());
        houseNumberStatePageVoPage.setPages(pageVo.getTotalPage());

        houseNumberStatePageVoPage.setRecords(pageVos);


        map.put("page", houseNumberStatePageVoPage);

        return CommonResult.ok(map);


    }


    @Override
    public CommonResult particular(String houseNumberId, Integer houseNumberStateId) {
        if (ObjectUtils.isEmpty(houseNumberId)) {
            return CommonResult.fail("参数异常");
        }

        HouseNumber houseNumber = houseNumberService.getById(houseNumberId);

        ParticularHouseNumberStatusVo vo = new ParticularHouseNumberStatusVo();
        vo.setHouseNumber(houseNumber.getRoomNumber());

        House house = houseService.getById(houseNumber.getHouseId());

        vo.setHouseName(house.getRoomName());
        vo.setHouseType(house.getRoomType());

//          状态 1.空闲 2.正在使用
//        LambdaQueryWrapper<HouseNumberState> wrapperHNS = new LambdaQueryWrapper<>();
//        wrapperHNS.eq(HouseNumberState::getHouseNumberId, houseNumberId)
//                .le(HouseNumberState::getStartTime, dateTime)
//                .ge(HouseNumberState::getEndTime, dateTime);
//        HouseNumberState houseNumberState = houseNumberStateService.getOne(wrapperHNS);
        HouseNumberState houseNumberState = houseNumberStateService.getById(houseNumberStateId);


        if (ObjectUtils.isNotEmpty(houseNumberState)) {

//            状态 1空闲、2脏房、3预定、4入住、5锁定、6维修
            Integer status1 = houseNumberState.getStatus();
//            订单号
            String bookingId = houseNumberState.getOrderNumber();
            vo.setHouseStatus(status1);
//            预定
            if (status1 == 3) {
//                预定
                String statusBar = "2,5,11";
                vo.setStatusBar(statusBar);
                if (ObjectUtils.isNotEmpty(bookingId)) {
                    LambdaQueryWrapper<HouseOrder> wrapperHo = new LambdaQueryWrapper<>();
                    wrapperHo.eq(HouseOrder::getOrderNumber, bookingId);
                    HouseOrder houseOrder = houseOrderService.getOne(wrapperHo);
                    String reserveName = houseOrder.getReserveName();
                    vo.setName(reserveName);
//                    预定入住时间
                    vo.setReserveLiveTime(houseOrder.getReserveLiveTime());
//                    预定离店时间
                    vo.setReserveLeaveTime(houseOrder.getReserveLeaveTime());
                    vo.setOrderNumber(houseOrder.getOrderNumber());
                }
            } else if (status1 == 4) {
//                入住
                if (ObjectUtils.isNotEmpty(bookingId)) {
                    LambdaQueryWrapper<HouseOrder> wrapperHo = new LambdaQueryWrapper<>();
                    wrapperHo.eq(HouseOrder::getOrderNumber, bookingId);
                    HouseOrder houseOrder = houseOrderService.getOne(wrapperHo);
                    String liveName = houseOrder.getLiveName();
                    vo.setName(liveName);
                    String statusBar = "7,8,9,10,11";
                    vo.setStatusBar(statusBar);
                    Date liveTime = houseOrder.getLiveTime();
//                    预定入住时间
                    vo.setReserveLiveTime(houseOrder.getReserveLiveTime());
//                    预定离店时间
                    vo.setReserveLeaveTime(houseOrder.getReserveLeaveTime());
//                  付款
                    vo.setPayPrice(houseOrder.getPayPrice());
//                  密码
                    vo.setPassWord(houseOrder.getKeyPassWord());
//                   钥匙类型
                    vo.setLockStatus(houseOrder.getKeyType());
//                  是否归还
                    vo.setGiveBack(houseOrder.getGiveBack());
//                   超时时间
                    vo.setTimeOut(houseOrder.getTimeOut());
//                    订单id
                    vo.setHouseOrderId(houseOrder.getId());
//                    订单号
                    vo.setOrderNumber(houseOrder.getOrderNumber());
                    vo.setLiveTime(houseOrder.getLiveTime());
                    vo.setLeaveTime(houseOrder.getLeaveTime());

//                    已入住时间
                    LocalDateTime now = LocalDateTime.now();
                    LocalDateTime stateEnd = LocalDateTime.ofInstant(liveTime.toInstant(), ZoneId.systemDefault());
                    Duration duration = Duration.between(stateEnd, now);
                    long l = duration.toMinutes();
                    Double m = Double.valueOf(l);
                    Integer days = (int) (m / (60 * 24)); //天
                    Integer hours = (int) (m / (60) - days * 24); //小时
                    Integer minutes = (int) (m - hours * 60 - days * 24 * 60); //分钟
                    String checkTime = days + "天" + hours + "小时" + minutes + "分钟";
                    vo.setCheckTime(checkTime);

                }
            } else if (status1 == 2) {
//                脏房
                String statusBar = "11,12";
                vo.setStatusBar(statusBar);
            } else if (status1 == 5) {
//                锁定
                String statusBar = "6,11";
                vo.setStatusBar(statusBar);
                String startTime = houseNumberState.getStartTime();
                String endTime = houseNumberState.getEndTime();
//              开始时间，结束时间
                vo.setStateTime(startTime);
                vo.setEndTime(endTime);
            } else if (status1 == 6) {
//                维修
                String statusBar = "5,11";
                vo.setStatusBar(statusBar);
                String startTime = houseNumberState.getStartTime();
                String endTime = houseNumberState.getEndTime();
//              开始时间，结束时间
                vo.setStateTime(startTime);
                vo.setEndTime(endTime);

            }


        } else {
//            空闲
            String statusBar = "1,2,3,4,11,13";
            vo.setStatusBar(statusBar);
            vo.setHouseStatus(1);
        }


//        获取该房间电量
        LambdaQueryWrapper<HouseLock> wrapperHL = new LambdaQueryWrapper<>();
        wrapperHL.eq(HouseLock::getHouseNumberId, houseNumberId);
        HouseLock houseLock = houseLockService.getOne(wrapperHL);
//        String battery = "";
        if (ObjectUtils.isNotEmpty(houseLock)) {
            String equipmentType = houseLock.getEquipmentType();

            String battery = passwordIssController.getDeviceInfo(equipmentType);
            vo.setElectricQuantity(battery + "%");
        }

//        HashMap<String, String> map = new HashMap<>();
//        map.put("categoryId", doorLockConfig.getCategoryId());//"d0c248256f8346d2a19afa296562b319");//设备分类ID 所有蓝牙wifi锁默认统一值
//        map.put("luid", equipmentType);//"047863CA78E0"
//
//        String jsonContent = JSONObject.toJSONString(map);
//
//
//        JSONObject jsonObject = null;
//        try {
//            jsonObject = queryData(jsonContent, PasswordUrlEnum.Device_Info.getUrl());
//        } catch (Exception e) {
//            throw new RuntimeException(e);
//        }
//
//        JSONObject data = jsonObject.getJSONObject("data");
//          电量
//        String battery = data.getString("battery");


        return CommonResult.ok(vo);


    }

    @Override
    public CommonResult reserveDay(String houseNumberId, String startTime, String endTime, int adminId) {
        if (ObjectUtils.isEmpty(houseNumberId) && ObjectUtils.isEmpty(startTime) && ObjectUtils.isEmpty(endTime)) {
            return CommonResult.fail();
        }
        PermissionSetting permissionSetting = permissionSettingService.getById(adminId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseStatusManagement();
        if (!"0".equals(houseTypeManagement) && !houseTypeManagement.contains("1")) {
            return CommonResult.fail("此账号暂无该权限");
        }

//        获取预定时间和离店时间
        List<ApartmentSetting> list = apartmentSettingService.list(new LambdaQueryWrapper<>());
        ApartmentSetting apartmentSetting = list.get(0);
        String liveTime = apartmentSetting.getLiveTime();
        String leaveTime = apartmentSetting.getLeaveTime();

        startTime = startTime + " " + liveTime;
        endTime = endTime + " " + leaveTime;

        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime start = LocalDateTime.parse(startTime, dateTimeFormatter1);
        LocalDateTime end = LocalDateTime.parse(endTime, dateTimeFormatter1);


        ArrayList<ReserveDayVo> reserveDayVos = new ArrayList<>();
        for (int i = 0; i <= 8; i++) {
            LocalDateTime localDateTime = null;
            if (i == 0) {
                //        判断传过来的时间和当前时间比较
                LocalDateTime now = LocalDateTime.now();
                if (now.isAfter(start)) {
                    localDateTime = now;
                } else {
                    localDateTime = start.plusDays(i);
                }
            } else {
                localDateTime = start.plusDays(i);
            }

            ReserveDayVo reserveDayVo = new ReserveDayVo();
//            LocalDateTime localDateTime = start.plusDays(i);
            LocalDateTime localDateTime2 = end.plusDays(i);
            String format = localDateTime.format(dateTimeFormatter1);
            String format2 = localDateTime2.format(dateTimeFormatter1);
            reserveDayVo.setDate(format + "至" + format2);
            //        获取该时间段内的房态的使用情况
            List<HouseNumberState> houseNumberStateList = houseNumberStateService.beBooked(houseNumberId, format, format2);
            if (ObjectUtils.isNotEmpty(houseNumberStateList) && houseNumberStateList.size() > 0) {
                reserveDayVo.setStatus("不可用");
            } else {
                reserveDayVo.setStatus("可用");
            }
            reserveDayVos.add(reserveDayVo);
        }


        return CommonResult.ok(reserveDayVos);
    }

    @Override
    public CommonResult reservePrice(String houseId, String cardNumber, String liveTime, String leaveTime) {
        if (ObjectUtils.isEmpty(houseId) && ObjectUtils.isEmpty(liveTime) && ObjectUtils.isEmpty(leaveTime)) {
            return CommonResult.fail();
        }
        House house = houseService.getById(houseId);
        if (ObjectUtils.isEmpty(house)) {
            return CommonResult.fail("无该房型");
        }

        //       管理端 计算总金额
        PriceVo priceVo = houseOrderService.reservePrice(houseId, cardNumber, liveTime, leaveTime);

        return CommonResult.ok(priceVo);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)//1
    public CommonResult reserve(ReserveDto reserveDto) {
        if (ObjectUtils.isEmpty(reserveDto)) {
            return CommonResult.fail();
        }
        int adminId = reserveDto.getAdminId();
        PermissionSetting permissionSetting = permissionSettingService.getById(adminId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseStatusManagement();
        if (!"0".equals(houseTypeManagement) && !houseTypeManagement.contains("1")) {
            return CommonResult.fail("此账号暂无该权限");
        }


        String cardNumber = reserveDto.getCardNumber();
        String reserveLiveTime = reserveDto.getReserveLiveTime();
        String reserveLeaveTime = reserveDto.getReserveLeaveTime();
        String houseId = reserveDto.getHouseId();

//        判断传过来的时间和当前时间比较
        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime now = LocalDateTime.now();
        LocalDateTime date = LocalDateTime.parse(reserveLiveTime, dateTimeFormatter1);
        if (now.isAfter(date)) {
            reserveLiveTime = now.format(dateTimeFormatter1);
        }

//       管理端 计算总金额
        PriceVo priceVo = houseOrderService.reservePrice(houseId, cardNumber, reserveLiveTime, reserveLeaveTime);
        BigDecimal totalPrice = priceVo.getTotalPrice();

        BigDecimal payPrice = reserveDto.getPayPrice();
//        返回的结果是int类型,-1表示小于，0是等于，1是大于。
        if (payPrice.compareTo(totalPrice) != 0) {
            return CommonResult.fail("需付金额异常");
        }

//        获取房间号
        String houseNumberId = reserveDto.getHouseNumberId();
//        判断房型是钟点房还是全日房
        House house = houseService.getById(houseId);
        if (ObjectUtils.isEmpty(house)) {
            return CommonResult.fail("无该房型");
        }
        Integer roomType = house.getRoomType();
        if (roomType == 1) {
            //        获取该时间段内的该房间的使用情况
            List<HouseNumberState> houseNumberStateList = houseNumberStateService.beBooked(houseNumberId, reserveLiveTime, reserveLeaveTime);


            if (ObjectUtils.isNotEmpty(houseNumberStateList) && houseNumberStateList.size() > 0) {
                return CommonResult.fail("该时间段无法预定");
            }
        } else {
            LocalDateTime localDateTime = LocalDateTime.parse(reserveLiveTime, dateTimeFormatter1);
            LocalDateTime localDateTime2 = LocalDateTime.parse(reserveLeaveTime, dateTimeFormatter1);

            //            先判断时间是否在可用时间范围内
            LocalDateTime start1 = localDateTime.withHour(23).withMinute(59).withSecond(59);
            String format3 = start1.format(dateTimeFormatter1);

            String[] s1 = reserveLiveTime.split(" ");
            String startStr = s1[0];

            String[] s2 = reserveLeaveTime.split(" ");
            String endStr = s2[0];

            //        获取钟点房可用时间段
            List<ApartmentSetting> list = apartmentSettingService.list(new LambdaQueryWrapper<>());
            ApartmentSetting apartmentSetting = list.get(0);
            String hourTime = apartmentSetting.getHourTime();
            String[] split = hourTime.split(",");
            Integer status = 1;
            for (int j = 0; j < split.length; j++) {
                String s = split[j];
                String[] split1 = s.split("-");
                String start2 = split1[0];
                String end2 = split1[1];
                String start3 = startStr + " " + start2;
                String end3 = startStr + " " + end2;
                LocalDateTime localStart = LocalDateTime.parse(start3, dateTimeFormatter1);
                LocalDateTime localEnd = LocalDateTime.parse(end3, dateTimeFormatter1);

//            该天最后时间小于结束时间则需要分为2个时间段
                if (start1.isBefore(localDateTime2)) {
                    String start4 = endStr + " " + start2;
                    String end4 = endStr + " " + end2;
                    LocalDateTime localStart4 = LocalDateTime.parse(start4, dateTimeFormatter1);
                    LocalDateTime localEnd4 = LocalDateTime.parse(end4, dateTimeFormatter1);

                    if ((localStart.isBefore(localDateTime) || reserveLiveTime.equals(start3)) && (start1.isBefore(localEnd) || format3.equals(end3)) && (localStart4.isBefore(start1) || start4.equals(format3)) && (start1.isBefore(localEnd4) || end4.equals(format3))) {
//                        可用
                        status = 2;
                        break;
                    }

                } else {
                    if ((localStart.isBefore(localDateTime) || reserveLiveTime.equals(start3)) && (localDateTime2.isBefore(localEnd) || reserveLeaveTime.equals(end3))) {
//                        可用
                        status = 2;
                        break;
                    }

                }
            }
            if (status == 2) {
                //        获取该时间段内的房态的使用情况
                List<HouseNumberState> houseNumberStateList = houseNumberStateService.beBooked(houseNumberId, reserveLiveTime, reserveLeaveTime);
                if (ObjectUtils.isNotEmpty(houseNumberStateList) && houseNumberStateList.size() > 0) {
                    return CommonResult.fail("该时间段无法预定");
                }
            } else {
                return CommonResult.fail("当前时间不可预定");
            }

        }


        HouseOrder houseOrder = new HouseOrder();
//            判断是否存在该用户，不存在则添加
        String name = reserveDto.getName();
        String phone = reserveDto.getPhone();
        LambdaQueryWrapper<Users> wrapperU = new LambdaQueryWrapper<>();
        wrapperU.eq(Users::getUserName, name)
                .eq(Users::getPhone, phone);
        List<Users> usersList = usersService.list(wrapperU);
        Users users = null;
        if (usersList.size() > 0) {
            users = usersList.get(0);
        }

        if (ObjectUtils.isEmpty(users)) {
            Users users1 = new Users();
            users1.setUserName(name);
            users1.setPhone(phone);
            users1.setCardNumber(cardNumber);
//                users1.setUserMenuId("4");
            users1.setDepartment("7");
            boolean save = usersService.save(users1);
            houseOrder.setReserveUserId(users1.getId() + "");
        } else {
            houseOrder.setReserveUserId(users.getId() + "");
        }


        //        订单号
//            String orderNumber = UUID.randomUUID().toString();
//            orderNumber = orderNumber.replace("-", "");
        String orderNumber = OrderNumber.getOrderNumber();
        houseOrder.setOrderNumber(orderNumber);
//        待支付状态
        houseOrder.setOrderStatus("1");

        houseOrder.setHouseId(houseId);
        houseOrder.setHouseNumberId(houseNumberId);
        houseOrder.setReserveName(reserveDto.getName());
        houseOrder.setReservePhone(reserveDto.getPhone());
        houseOrder.setReserveLiveTime(reserveLiveTime);
        houseOrder.setReserveLeaveTime(reserveLeaveTime);
        houseOrder.setHouseOrderNumber(1);
//        需支付金额
        houseOrder.setPayPrice(payPrice);
//      入住天数
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime start = LocalDateTime.parse(reserveLiveTime, dateTimeFormatter);
        LocalDateTime end = LocalDateTime.parse(reserveLeaveTime, dateTimeFormatter);

        LocalDate startDate = start.toLocalDate();
        LocalDate endDate = end.toLocalDate();
        long diff = startDate.until(endDate, ChronoUnit.DAYS);
        houseOrder.setLiveDay(String.valueOf(diff));
//        房间单价
        houseOrder.setPrice(priceVo.getPrice());
//        订单渠道
        houseOrder.setOrderChannel("2");
//            超时时间
        houseOrder.setTimeOut(reserveDto.getTimeOut());

//        添加房态表
        HouseNumberState houseNumberState = new HouseNumberState();
        houseNumberState.setOrderNumber(orderNumber);
        houseNumberState.setHouseNumberId(houseNumberId);
        houseNumberState.setStatus(3);
        houseNumberState.setStartTime(reserveLiveTime);
        houseNumberState.setEndTime(reserveLeaveTime);


        houseOrderService.save(houseOrder);
        houseNumberStateService.save(houseNumberState);
        return CommonResult.ok();


    }


    @Override
    @Transactional(rollbackFor = Exception.class)//1
    public CommonResult checkIdCard(CheckIdCardDto checkIdCardDto) {
        if (ObjectUtils.isEmpty(checkIdCardDto)) {
            return CommonResult.fail();
        }
        String adminMenuId = checkIdCardDto.getAdminMenuId();
        PermissionSetting permissionSetting = permissionSettingService.getById(adminMenuId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseStatusManagement();
        if (!"0".equals(houseTypeManagement) && !houseTypeManagement.contains("8")) {
            return CommonResult.fail("此账号暂无该权限");
        }
        String houseNumberId = checkIdCardDto.getHouseNumberId();

        String houseId = checkIdCardDto.getHouseId();
        String liveTime = checkIdCardDto.getLiveTime();
        String leaveTime = checkIdCardDto.getLeaveTime();
//        //       管理端 计算总金额
//        PriceVo priceVo = houseOrderService.reservePrice(houseId, cardNumber, liveTime, leaveTime);
//        BigDecimal totalPrice = priceVo.getTotalPrice();
//
//        BigDecimal payPrice = checkIdCardDto.getPayPrice();
////        返回的结果是int类型,-1表示小于，0是等于，1是大于。
//        if (payPrice.compareTo(totalPrice) != 0) {
//            return CommonResult.fail("需付金额异常");
//        }

        //        获取该时间段内的该房间的使用情况
//        List<HouseNumberState> houseNumberStateList = houseNumberStateService.beBooked(houseNumberId, liveTime, leaveTime);
//        if (ObjectUtils.isNotEmpty(houseNumberStateList) && houseNumberStateList.size() > 0) {
//            return CommonResult.fail("该时间段无法预定");
//        }


//        入住人
        String liveName = checkIdCardDto.getLiveName();
//        电话
//        String phone = checkIdCardDto.getPhone();

//        指纹特殊编码
        String fingerprint = checkIdCardDto.getFingerprint();
//        身份证
        String idCard = checkIdCardDto.getIdCard();
//        身份证特殊编码
        String idCardInformation = checkIdCardDto.getIdCardInformation();
        String msg = "";

//        判断是否有用户
        LambdaQueryWrapper<Users> wrapperU = new LambdaQueryWrapper<>();
        wrapperU.eq(Users::getIdCard, idCard);
        Users users = usersService.getOne(wrapperU);

//        判断是否有订单，没有订单需先添加订单
        String orderNumber = checkIdCardDto.getOrderNumber();

        LambdaQueryWrapper<HouseOrder> wrapperHo = new LambdaQueryWrapper<>();
        wrapperHo.eq(HouseOrder::getOrderNumber, orderNumber);
        HouseOrder houseOrder = houseOrderService.getOne(wrapperHo);

//            判断订单是否支付
        if (ObjectUtils.isEmpty(houseOrder)) {
            return CommonResult.fail("不存在该订单");
        }

        String orderStatus = houseOrder.getOrderStatus();
        if ((!"2".equals(orderStatus)) && (!"3".equals(orderStatus))) {
            return CommonResult.fail("订单未支付");
        }


//                        入住人id
        if (ObjectUtils.isEmpty(users)) {
            Users users1 = new Users();
            users1.setUserName(liveName);
//                users1.setPhone(phone);
//                users1.setCardNumber(cardNumber);
            users1.setFingerprint(fingerprint);
            users1.setIdCard(idCard);
            users1.setIdCardInformation(idCardInformation);
//                users1.setUserMenuId("1");
            boolean save = usersService.save(users1);
            houseOrder.setLiveUsersId(users1.getId() + "");
        } else {
//                users.setCardNumber(cardNumber);
            users.setFingerprint(fingerprint);
            users.setIdCard(idCard);
            users.setIdCardInformation(idCardInformation);
            usersService.updateById(users);
            houseOrder.setLiveUsersId(users.getId() + "");
        }

        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        Date liveDate = Date.from(LocalDateTime.parse(liveTime, dateTimeFormatter1).atZone(ZoneId.systemDefault()).toInstant());
        Date leaveDate = Date.from(LocalDateTime.parse(leaveTime, dateTimeFormatter1).atZone(ZoneId.systemDefault()).toInstant());

        //            订单状态  入住状态
        houseOrder.setOrderStatus("4");
        houseOrder.setLiveTime(liveDate);
        houseOrder.setLeaveTime(leaveDate);
        houseOrder.setLiveName(liveName);
//  退房时才获取电起码，水起码

//        添加房态或修改房态
        LambdaQueryWrapper<HouseNumberState> wrapperHns = new LambdaQueryWrapper<>();
        wrapperHns.eq(HouseNumberState::getOrderNumber, houseOrder.getOrderNumber())
                .eq(HouseNumberState::getHouseNumberId, houseNumberId);

        HouseNumberState houseNumberState = houseNumberStateService.getOne(wrapperHns);
        if (ObjectUtils.isEmpty(houseNumberState)) {
            return CommonResult.fail("缺少入住房态");
        }
        houseNumberState.setStatus(4);
        houseNumberState.setStartTime(liveTime);


        //      修改房间状态
        HouseNumber houseNumber = houseNumberService.getById(houseNumberId);

//         开电
        Boolean aBoolean = electricEquipmentService.openMeterControl(houseNumber.getElectricEquipmentId());
        if (!aBoolean) {
            msg = "开电失败";
            //               设置关电状态
            houseNumber.setElectricType("2");
        } else {
            //                设置开电状态
            houseNumber.setElectricType("1");
        }


        String roomNumber = houseNumber.getRoomNumber();
        String start = String.valueOf(liveDate.getTime());
        String end = String.valueOf(leaveDate.getTime());
//        发放密码
        Integer lockStatus = checkIdCardDto.getLockStatus();
//        添加锁的操作记录
        Admin byId = adminService.getById(checkIdCardDto.getAdminId());

        OperatingRecord operatingRecord = new OperatingRecord();

        operatingRecord.setHouseNumberId(houseNumber.getId());
        operatingRecord.setRoomNumber(roomNumber);
        operatingRecord.setOperatorName(byId.getName());
        operatingRecord.setDataTime(LocalDateTime.now().format(dateTimeFormatter1));
        operatingRecord.setContent("姓名:" + liveName);
        houseOrder.setKeyType(lockStatus);
        if (5 == lockStatus) {
//                默认未归还
            houseOrder.setGiveBack(2);
        } else {
            //        获取设备id
            LambdaQueryWrapper<HouseLock> wrapperHl = new LambdaQueryWrapper<>();
            wrapperHl.eq(HouseLock::getHouseNumberId, houseNumberId);
            HouseLock houseLock = houseLockService.getOne(wrapperHl);
            if (ObjectUtils.isEmpty(houseLock)) {
                return CommonResult.fail("请先绑定门锁设备");
            }
            String equipmentState = houseLock.getEquipmentType();

            if (1 == lockStatus) {
                PasswordDto pr = new PasswordDto();
                pr.setLuid(equipmentState);
                pr.setStartTime(start);
                pr.setEndTime(end);
                pr.setHouseNumberId(houseNumberId);
                pr.setOrderNumber(houseOrder.getOrderNumber());
                Unlocking unlocking = passwordIssController.addPassword(pr);
//                添加锁的操作记录类型
                operatingRecord.setType("添加密码钥匙");

                unlockingService.save(unlocking);
                String passWord = unlocking.getPassWord();
                houseOrder.setKeyPassWord(passWord);
//                ArrayList<String> strings = new ArrayList<>();
                // strings.add(cardNumber);
                // weiXiaoComponent.sendNotice(strings, "公寓办理入住成功", "办理入住成功", "您的房间号为:" + roomNumber + ",密码是:" + passWord + "离店时间为:" + liveTime + ",欢迎您入住张玉玲酒店，我们全体员工很荣幸能为您服务，如有任何需要请致电张玉玲，期待为你服务。祝你生活愉快！", null);
            } else if (2 == lockStatus) {
                CardInfoDto cid = new CardInfoDto();
                cid.setCard(idCardInformation);
                cid.setLuid(equipmentState);
                cid.setCardType(0);
                cid.setStartTime(start);
                cid.setEndTime(end);
                cid.setHouseNumberId(houseNumberId);
                cid.setOrderNumber(houseOrder.getOrderNumber());
                Unlocking unlocking = passwordIssController.addCardInfo(cid);
                unlockingService.save(unlocking);

                //                添加锁的操作记录类型
                operatingRecord.setType("添加卡片钥匙");
                //                默认未归还
                houseOrder.setGiveBack(2);

            } else if (3 == lockStatus) {
                FingerprintDataDto fd = new FingerprintDataDto();
                fd.setLuid(equipmentState);
                fd.setHouseNumberId(houseNumberId);
                fd.setOrderNumber(houseOrder.getOrderNumber());
                fd.setStartTime(start);
                fd.setEndTime(end);
                fd.setFingerprintData(fingerprint);
                Unlocking unlocking = passwordIssController.addFingerprintData(fd);
                unlockingService.save(unlocking);
                //                添加锁的操作记录类型
                operatingRecord.setType("添加指纹钥匙");
            } else if (4 == lockStatus) {
                CardInfoDto cid = new CardInfoDto();
                cid.setCard(idCardInformation);
                cid.setLuid(equipmentState);
                cid.setCardType(1);
                cid.setStartTime(start);
                cid.setEndTime(end);
                cid.setHouseNumberId(houseNumberId);
                cid.setOrderNumber(houseOrder.getOrderNumber());
                Unlocking unlocking = passwordIssController.addCardInfo(cid);
                unlockingService.save(unlocking);

                //                添加锁的操作记录类型
                operatingRecord.setType("添加身份证钥匙");
                //                默认未归还
                houseOrder.setGiveBack(2);
            }
        }

        houseOrderService.updateById(houseOrder);
        houseNumberStateService.updateById(houseNumberState);

        houseNumberService.updateById(houseNumber);

        operatingRecordService.save(operatingRecord);

        if (msg.equals("")) {
            return CommonResult.ok();
        } else {
            return CommonResult.ok(msg);
        }

    }

    @Override
    public CommonResult roomChangePage(String liveTime, String leaveTime, String houseNumberId, int adminId) {
        if (ObjectUtils.isEmpty(leaveTime) && ObjectUtils.isEmpty(leaveTime) && ObjectUtils.isEmpty(houseNumberId)) {
            return CommonResult.fail();
        }

        PermissionSetting permissionSetting = permissionSettingService.getById(adminId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseStatusManagement();
        if (!"0".equals(houseTypeManagement) && !houseTypeManagement.contains("11")) {
            return CommonResult.fail("此账号暂无该权限");
        }


        HouseNumber houseNumber = houseNumberService.getById(houseNumberId);
        if (ObjectUtils.isEmpty(houseNumber)) {
            return CommonResult.fail("该房间不存在");
        }


//        查找所有的上线的房型
        LambdaQueryWrapper<House> wrapperH = new LambdaQueryWrapper<>();
        wrapperH.eq(House::getIsAdded, 1);
        List<House> houses = houseService.list(wrapperH);

        String houseId = "";
        for (int i = 0; i < houses.size(); i++) {
            House house = houses.get(i);
            String id = house.getId() + "";
            if (i == 0) {
                houseId = id;
            } else {
                houseId = houseId + "," + id;
            }
        }


        List<HouseNumberVo> houseNumberList = houseNumberService.roomChangePage(houseId);

        String houseNumberIds = "";
        for (int i = 0; i < houseNumberList.size(); i++) {
            HouseNumberVo number = houseNumberList.get(i);

            String id = number.getId() + "";
            if (i == 0) {
                houseNumberIds = id;
            } else {
                houseNumberIds = houseNumberIds + "," + id;
            }
        }
//      该时间段内使用的房间号
        List<HouseNumberState> houseNumberStateList = houseNumberStateService.beBooked(houseNumberIds, liveTime, leaveTime);

        //        重新组合没有使用过的房间
        ArrayList<HouseNumberVo> list = new ArrayList<>();
        for (HouseNumberVo houseNumber2 : houseNumberList) {
            String id = houseNumber2.getId() + "";
            if (!houseNumberStateList.stream().anyMatch(houseNumberState -> houseNumberState.getHouseNumberId().equals(id))) {
                list.add(houseNumber2);
            }
        }
        ArrayList<RoomChangePageVo> vos = new ArrayList<>();
        for (House house : houses) {
            RoomChangePageVo vo = new RoomChangePageVo();
            String hoId = house.getId() + "";

            List<HouseNumberVo> datas = list.stream().filter(e -> e.getHouseId().equals(hoId)).collect(Collectors.toList());
            vo.setName(house.getRoomName());
            vo.setChildren(datas);
            vos.add(vo);
        }

        return CommonResult.ok(vos);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)//1
    public CommonResult roomChange(RoomChangeDto roomChangeDto) {
        if (ObjectUtils.isEmpty(roomChangeDto)) {
            return CommonResult.fail();
        }
        int adminMenuId = roomChangeDto.getAdminMenuId();
        PermissionSetting permissionSetting = permissionSettingService.getById(adminMenuId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseStatusManagement();
        if (!"0".equals(houseTypeManagement) && !houseTypeManagement.contains("11")) {
            return CommonResult.fail("此账号暂无该权限");
        }

//      初始房间号
        String initialHouseNumberId = roomChangeDto.getInitialHouseNumberId();
//      换的房间号
        String houseNumberId = roomChangeDto.getHouseNumberId();
//      订单号
        String orderNumber = roomChangeDto.getOrderNumber();

        LambdaQueryWrapper<HouseOrder> wrapperHo = new LambdaQueryWrapper<>();
        wrapperHo.eq(HouseOrder::getOrderNumber, orderNumber);

        HouseOrder houseOrder = houseOrderService.getOne(wrapperHo);

        String orderStatus = houseOrder.getOrderStatus();
        if ("4".equals(orderStatus)) {

            Date liveTime = houseOrder.getLiveTime();


//        判断当前时间到预离店时间是否有房间
            Date date = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String format = sdf.format(liveTime);
            String format1 = sdf.format(date);
            //      判断该房间在该订单的时间内是否有使用
            List<HouseNumberState> houseNumberStateList = houseNumberStateService.beBooked(houseNumberId, format1, houseOrder.getReserveLeaveTime());

            if (ObjectUtils.isNotEmpty(houseNumberStateList) && houseNumberStateList.size() > 0) {
                return CommonResult.fail("此时间段内，该房间已被使用");
            }

//        修改订单
            houseOrder.setHouseNumberId(houseNumberId);

//        换房后，当前时间为入住时间
            houseOrder.setLiveTime(date);

            //      获取水电消费金额和额度
//            获取初始房间号的水电表设备id
            HouseNumber initialHouseNumber = houseNumberService.getById(initialHouseNumberId);
            String electricEquipmentId = initialHouseNumber.getElectricEquipmentId();
            String waterEquipmentId = initialHouseNumber.getWaterEquipmentId();
            ElectricEquipment electricEquipment = electricEquipmentService.getById(electricEquipmentId);
            WaterEquipment waterEquipment = waterEquipmentService.getById(waterEquipmentId);
            if (ObjectUtils.isNotEmpty(electricEquipment) && ObjectUtils.isNotEmpty(waterEquipment)) {
                String electricEquipmentRoomId = electricEquipment.getRoomId();
                String waterEquipmentRoomId = waterEquipment.getRoomId();

                String live = sdf.format(liveTime);
                String leave = sdf.format(new Date());
//                获取电的消费金额和额度
                HouseOrderBill houseOrderBill = new HouseOrderBill();
                JSONObject jsonObjectElectric = electricEquipmentService.roomCostRecord(electricEquipmentRoomId, live, leave);
                BigDecimal costElectric = jsonObjectElectric.getBigDecimal("cost");
                BigDecimal consumeElectric = jsonObjectElectric.getBigDecimal("consume");
                houseOrderBill.setElectricCost(costElectric);
                houseOrderBill.setElectricConsume(consumeElectric);


                BigDecimal electricCost = houseOrder.getElectricCost();
                if (ObjectUtils.isNotEmpty(electricCost)) {
                    costElectric = costElectric.add(electricCost);
                }
                BigDecimal electricConsume = houseOrder.getElectricConsume();

                if (ObjectUtils.isNotEmpty(electricConsume)) {
                    consumeElectric = consumeElectric.add(electricConsume);
                }
                houseOrder.setElectricCost(costElectric);
                houseOrder.setElectricConsume(consumeElectric);
//                获取水的消费金额和额度
                JSONObject jsonObjectWater = waterEquipmentService.roomCostRecord(waterEquipmentRoomId, live, leave);
                BigDecimal costWater = jsonObjectWater.getBigDecimal("cost");
                BigDecimal consumeWater = jsonObjectWater.getBigDecimal("consume");
                houseOrderBill.setWaterCost(costWater);
                houseOrderBill.setWaterConsume(consumeWater);


                BigDecimal waterCost = houseOrder.getWaterCost();
                if (ObjectUtils.isNotEmpty(waterCost)) {
                    costWater = costWater.add(waterCost);
                }
                BigDecimal waterConsume = houseOrder.getWaterConsume();
                if (ObjectUtils.isNotEmpty(waterConsume)) {
                    consumeWater = consumeWater.add(waterConsume);
                }

                houseOrder.setWaterCost(costWater);
                houseOrder.setWaterConsume(consumeWater);


                houseOrderBill.setHouseOrderId(houseOrder.getId());
                houseOrderBill.setHouseNumberId(initialHouseNumberId);
                houseOrderBill.setLiveTime(liveTime);
                houseOrderBill.setLeaveTime(date);
                houseOrderBillService.save(houseOrderBill);

            }


            houseOrderService.updateById(houseOrder);


//        添加状态表，修改状态表
            HouseNumberState houseNumberState = new HouseNumberState();
            houseNumberState.setStatus(4);
            houseNumberState.setHouseNumberId(houseNumberId);
            houseNumberState.setStartTime(format);
            houseNumberState.setEndTime(houseOrder.getReserveLeaveTime());
            houseNumberState.setOrderNumber(orderNumber);
            houseNumberStateService.save(houseNumberState);

//       找到订单之前的房态，并修改
            LambdaQueryWrapper<HouseNumberState> wrapperHns = new LambdaQueryWrapper<>();
            wrapperHns.eq(HouseNumberState::getOrderNumber, orderNumber)
                    .eq(HouseNumberState::getHouseNumberId, initialHouseNumberId);
            HouseNumberState one = houseNumberStateService.getOne(wrapperHns);
            one.setEndTime(sdf.format(new Date()));

//            houseNumberStateService.updateById(one);
            houseNumberStateService.removeById(one.getId());

//        修改换的房间
            HouseNumber houseNumber = houseNumberService.getById(houseNumberId);
//        房间置脏需退房后
//            houseNumber.setHouseStatus(2);
//         开电
            Boolean aBoolean = electricEquipmentService.openMeterControl(houseNumber.getElectricEquipmentId());
            String msg = "";
            if (!aBoolean) {
                msg = "开电失败";
                //               设置关电状态
                houseNumber.setElectricType("2");
            } else {
                //                设置开电状态
                houseNumber.setElectricType("1");
            }

            houseNumberService.updateById(houseNumber);

//        之前的房间需要置脏，不需要关电，置净才需要关电
            HouseNumber houseNumber1 = houseNumberService.getById(initialHouseNumberId);
//            房间置脏
            houseNumber1.setHouseStatus(2);
            houseNumberService.updateById(houseNumber1);

//             旧房间密码删除，添加新房间密码
            Admin byId = adminService.getById(roomChangeDto.getAdminId());

            LambdaQueryWrapper<Unlocking> wrapperU = new LambdaQueryWrapper<>();
            wrapperU.eq(Unlocking::getOrderNumber, orderNumber)
                    .eq(Unlocking::getHouseNumberId, initialHouseNumberId);
            Unlocking unlocking = unlockingService.getOne(wrapperU);
            if (ObjectUtils.isNotEmpty(unlocking)) {
//                删除房间密码
                passwordIssController.deleteLockUser(unlocking.getLuid(), unlocking.getLockUserId());
                unlockingService.removeById(unlocking);
                OperatingRecord operatingRecord = new OperatingRecord();

                operatingRecord.setHouseNumberId(houseNumber1.getId());
                operatingRecord.setRoomNumber(houseNumber1.getRoomNumber());
                operatingRecord.setOperatorName(byId.getName());
                DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
                operatingRecord.setDataTime(LocalDateTime.now().format(dateTimeFormatter1));
                operatingRecord.setContent("姓名:" + houseOrder.getLiveName());
                operatingRecord.setType("删除锁钥匙");
                operatingRecordService.save(operatingRecord);
            }
            LambdaQueryWrapper<HouseLock> wrapperHl = new LambdaQueryWrapper<>();
            wrapperHl.eq(HouseLock::getHouseNumberId, houseNumberId);
            HouseLock houseLock = houseLockService.getOne(wrapperHl);
            if (ObjectUtils.isNotEmpty(unlocking)) {


                if (ObjectUtils.isNotEmpty(houseLock)) {


                    String equipmentState = houseLock.getEquipmentType();

//            入住人id
                    String liveUsersId = houseOrder.getLiveUsersId();
                    Users users = usersService.getById(liveUsersId);


//            判断是什么类型的开锁方式
                    String lockStatus = unlocking.getLockStatus();
                    if (ObjectUtils.isNotEmpty(unlocking)) {


//          添加锁的操作记录

                        OperatingRecord operatingRecord = new OperatingRecord();

                        operatingRecord.setHouseNumberId(houseNumber.getId());
                        operatingRecord.setRoomNumber(houseNumber.getRoomNumber());
                        operatingRecord.setOperatorName(byId.getName());
                        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
                        operatingRecord.setDataTime(LocalDateTime.now().format(dateTimeFormatter1));
                        operatingRecord.setContent("姓名:" + houseOrder.getLiveName());

                        if ("1".equals(lockStatus)) {
                            PasswordDto pr = new PasswordDto();
                            pr.setLuid(houseLock.getEquipmentType());
//            开始时间
                            pr.setStartTime(String.valueOf(liveTime.getTime()));
//            结束时间
                            String reserveLeaveTime = houseOrder.getReserveLeaveTime();
                            Date leaveTime = Date.from(LocalDateTime.parse(reserveLeaveTime, dateTimeFormatter1).atZone(ZoneId.systemDefault()).toInstant());
                            pr.setEndTime(String.valueOf(leaveTime.getTime()));
                            pr.setHouseNumberId(houseNumberId);
                            pr.setOrderNumber(orderNumber);
                            Unlocking unlocking1 = passwordIssController.addPassword(pr);
                            unlockingService.save(unlocking1);

                            String passWord = unlocking1.getPassWord();

                            ArrayList<String> strings = new ArrayList<>();
                            strings.add(users.getCardNumber());
                            weiXiaoComponent.sendNotice(strings, "公寓办理入住成功", "办理入住成功", "您的房间号为:" + houseNumber.getRoomNumber() + ",密码是:" + passWord + "离店时间为:" + liveTime + ",欢迎您入住张玉玲酒店，我们全体员工很荣幸能为您服务，如有任何需要请致电张玉玲，期待为你服务。祝你生活愉快！", null);
                            operatingRecord.setType("添加密码钥匙");

                        } else if ("2".equals(lockStatus)) {
                            CardInfoDto cid = new CardInfoDto();
                            cid.setCard(users.getIdCardInformation());
                            cid.setLuid(equipmentState);
                            cid.setCardType(1);
                            cid.setStartTime(String.valueOf(liveTime.getTime()));
                            //            结束时间
                            String reserveLeaveTime = houseOrder.getReserveLeaveTime();
                            Date leaveTime = Date.from(LocalDateTime.parse(reserveLeaveTime, dateTimeFormatter1).atZone(ZoneId.systemDefault()).toInstant());

                            cid.setEndTime(String.valueOf(leaveTime.getTime()));
                            cid.setHouseNumberId(houseNumberId);
                            cid.setOrderNumber(houseOrder.getOrderNumber());
                            Unlocking unlocking1 = passwordIssController.addCardInfo(cid);
                            unlockingService.save(unlocking1);
                            operatingRecord.setType("添加卡片钥匙");
                        } else if ("3".equals(lockStatus)) {
                            FingerprintDataDto fd = new FingerprintDataDto();
                            fd.setLuid(equipmentState);
                            fd.setHouseNumberId(houseNumberId);
                            fd.setOrderNumber(houseOrder.getOrderNumber());
                            fd.setStartTime(String.valueOf(liveTime.getTime()));
                            //            结束时间
                            String reserveLeaveTime = houseOrder.getReserveLeaveTime();
                            Date leaveTime = Date.from(LocalDateTime.parse(reserveLeaveTime, dateTimeFormatter1).atZone(ZoneId.systemDefault()).toInstant());

                            fd.setEndTime(String.valueOf(leaveTime.getTime()));

                            fd.setFingerprintData(users.getFingerprint());
                            Unlocking unlocking1 = passwordIssController.addFingerprintData(fd);
                            unlockingService.save(unlocking1);
                            operatingRecord.setType("添加指纹钥匙");
                        }

                        operatingRecordService.save(operatingRecord);
                    }
                }
            }
            if (msg.equals("")) {
                return CommonResult.ok();
            } else {
                return CommonResult.ok(msg);
            }
        } else {

            String reserveLiveTime = houseOrder.getReserveLiveTime();
            String reserveLeaveTime = houseOrder.getReserveLeaveTime();

            //      判断该房间在该订单的时间内是否有使用
            List<HouseNumberState> houseNumberStateList = houseNumberStateService.beBooked(houseNumberId, reserveLiveTime, reserveLeaveTime);

            if (ObjectUtils.isNotEmpty(houseNumberStateList) && houseNumberStateList.size() > 0) {
                return CommonResult.fail("此时间段内，该房间已被使用");
            }

//        修改订单
            houseOrder.setHouseNumberId(houseNumberId);

            houseOrderService.updateById(houseOrder);

            //       找到订单之前的房态，并修改
            LambdaQueryWrapper<HouseNumberState> wrapperHns = new LambdaQueryWrapper<>();
            wrapperHns.eq(HouseNumberState::getOrderNumber, orderNumber)
                    .eq(HouseNumberState::getHouseNumberId, initialHouseNumberId);
            HouseNumberState one = houseNumberStateService.getOne(wrapperHns);

            one.setHouseNumberId(houseNumberId);

            houseNumberStateService.updateById(one);

            return CommonResult.ok();
        }

    }

    @Override
    @Transactional(rollbackFor = Exception.class)//1
    public CommonResult checkOut(CheckOutDto checkOutDto) {
        int adminId = checkOutDto.getAdminId();
        PermissionSetting permissionSetting = permissionSettingService.getById(adminId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseStatusManagement();
        if (!"0".equals(houseTypeManagement) && !houseTypeManagement.contains("2")) {
            return CommonResult.fail("此账号暂无该权限");
        }

        String houseNumberId = checkOutDto.getHouseNumberId();
        String orderNumber = checkOutDto.getOrderNumber();
        if (ObjectUtils.isEmpty(houseNumberId) && ObjectUtils.isEmpty(orderNumber)) {
            return CommonResult.fail();
        }

        LambdaQueryWrapper<HouseOrder> wrapperHo = new LambdaQueryWrapper<>();
        wrapperHo.eq(HouseOrder::getOrderNumber, orderNumber);
        HouseOrder houseOrder = houseOrderService.getOne(wrapperHo);
        if (ObjectUtils.isEmpty(houseOrder)) {
            return CommonResult.fail("无该订单");
        }

        houseOrder.setOrderStatus("8");

//      判断退房在不在预定的时间段中，不在的话则判断是否有人在使用，没有的话按之前的步骤走，有的话则只改订单状态。
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String reserveLeaveTime = houseOrder.getReserveLeaveTime();
//            Date liveTime = houseOrder.getLiveTime();
//            LocalDateTime localDateTime = LocalDateTime.parse(reserveLeaveTime, dateTimeFormatter).plusMinutes(30);
//            Date endTime = Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());

//            boolean effectiveDate = DateUtil.isEffectiveDate(new Date(), liveTime, endTime);
//            if (!effectiveDate) {
        List<HouseNumberState> houseNumberStateData = houseNumberStateService.getData(new Date(), houseNumberId);
        if (ObjectUtils.isEmpty(houseNumberStateData)) {
            houseOrder.setLeaveTime(Date.from(LocalDateTime.parse(reserveLeaveTime, dateTimeFormatter).atZone(ZoneId.systemDefault()).toInstant()));
            //      获取水电消费金额和额度
            HouseNumber houseNumber = houseNumberService.getById(houseNumberId);
            String electricEquipmentId = houseNumber.getElectricEquipmentId();
            String waterEquipmentId = houseNumber.getWaterEquipmentId();
            ElectricEquipment electricEquipment = electricEquipmentService.getById(electricEquipmentId);
            WaterEquipment waterEquipment = waterEquipmentService.getById(waterEquipmentId);
            if (ObjectUtils.isNotEmpty(electricEquipment) && ObjectUtils.isNotEmpty(waterEquipment)) {
                String electricEquipmentRoomId = electricEquipment.getRoomId();
                String waterEquipmentRoomId = waterEquipment.getRoomId();

                Date liveTime = houseOrder.getLiveTime();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String live = sdf.format(liveTime);
                String leave = sdf.format(new Date());
//                获取电的消费金额和额度
                HouseOrderBill houseOrderBill = new HouseOrderBill();
                JSONObject jsonObjectElectric = electricEquipmentService.roomCostRecord(electricEquipmentRoomId, live, leave);
                BigDecimal costElectric = jsonObjectElectric.getBigDecimal("cost");
                BigDecimal consumeElectric = jsonObjectElectric.getBigDecimal("consume");
                houseOrderBill.setElectricCost(costElectric);
                houseOrderBill.setElectricConsume(consumeElectric);


                BigDecimal electricCost = houseOrder.getElectricCost();
                if (ObjectUtils.isNotEmpty(electricCost)) {
                    costElectric = costElectric.add(electricCost);
                }
                BigDecimal electricConsume = houseOrder.getElectricConsume();
                if (ObjectUtils.isNotEmpty(electricConsume)) {
                    consumeElectric = consumeElectric.add(electricConsume);
                }
                houseOrder.setElectricCost(costElectric);
                houseOrder.setElectricConsume(consumeElectric);
//                获取水的消费金额和额度
                JSONObject jsonObjectWater = waterEquipmentService.roomCostRecord(waterEquipmentRoomId, live, leave);
                BigDecimal costWater = jsonObjectWater.getBigDecimal("cost");
                BigDecimal consumeWater = jsonObjectWater.getBigDecimal("consume");
                houseOrderBill.setWaterCost(costWater);
                houseOrderBill.setWaterConsume(consumeWater);


                BigDecimal waterCost = houseOrder.getWaterCost();
                if (ObjectUtils.isNotEmpty(waterCost)) {
                    costWater = costWater.add(waterCost);
                }
                BigDecimal waterConsume = houseOrder.getWaterConsume();
                if (ObjectUtils.isNotEmpty(waterConsume)) {
                    consumeWater = consumeWater.add(waterConsume);
                }

                houseOrder.setWaterCost(costWater);
                houseOrder.setWaterConsume(consumeWater);

                houseOrderBill.setHouseOrderId(houseOrder.getId());
                houseOrderBill.setHouseNumberId(houseNumberId);
                houseOrderBill.setLiveTime(liveTime);
                houseOrderBill.setLeaveTime(new Date());
                houseOrderBillService.save(houseOrderBill);


            }

            LambdaQueryWrapper<Unlocking> wrapperU = new LambdaQueryWrapper<>();
            wrapperU.eq(Unlocking::getOrderNumber, orderNumber)
                    .eq(Unlocking::getHouseNumberId, houseNumberId);
            Unlocking unlocking = unlockingService.getOne(wrapperU);
            if (ObjectUtils.isNotEmpty(unlocking)) {
//                删除房间密码
                passwordIssController.deleteLockUser(unlocking.getLuid(), unlocking.getLockUserId());
                unlockingService.removeById(unlocking);
            }
            houseOrderService.updateById(houseOrder);
            return CommonResult.ok("该时间段已超过退房时间，已修改其订单状态");
        }
//            }
        LambdaQueryWrapper<Unlocking> wrapperU = new LambdaQueryWrapper<>();
        wrapperU.eq(Unlocking::getOrderNumber, orderNumber)
                .eq(Unlocking::getHouseNumberId, houseNumberId);
        Unlocking unlocking = unlockingService.getOne(wrapperU);
        if (ObjectUtils.isNotEmpty(unlocking)) {
//                删除房间密码
            passwordIssController.deleteLockUser(unlocking.getLuid(), unlocking.getLockUserId());
            unlockingService.removeById(unlocking);
        }


        //      获取水电消费金额和额度
        HouseNumber houseNumber = houseNumberService.getById(houseNumberId);
        String electricEquipmentId = houseNumber.getElectricEquipmentId();
        String waterEquipmentId = houseNumber.getWaterEquipmentId();
        ElectricEquipment electricEquipment = electricEquipmentService.getById(electricEquipmentId);
        WaterEquipment waterEquipment = waterEquipmentService.getById(waterEquipmentId);
        if (ObjectUtils.isNotEmpty(electricEquipment) && ObjectUtils.isNotEmpty(waterEquipment)) {
            String electricEquipmentRoomId = electricEquipment.getRoomId();
            String waterEquipmentRoomId = waterEquipment.getRoomId();

            Date liveTime = houseOrder.getLiveTime();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String live = sdf.format(liveTime);
            String leave = sdf.format(new Date());
//                获取电的消费金额和额度
            HouseOrderBill houseOrderBill = new HouseOrderBill();
            JSONObject jsonObjectElectric = electricEquipmentService.roomCostRecord(electricEquipmentRoomId, live, leave);
            BigDecimal costElectric = jsonObjectElectric.getBigDecimal("cost");
            BigDecimal consumeElectric = jsonObjectElectric.getBigDecimal("consume");
            houseOrderBill.setElectricCost(costElectric);
            houseOrderBill.setElectricConsume(consumeElectric);


            BigDecimal electricCost = houseOrder.getElectricCost();
            if (ObjectUtils.isNotEmpty(electricCost)) {
                costElectric = costElectric.add(electricCost);
            }
            BigDecimal electricConsume = houseOrder.getElectricConsume();
            if (ObjectUtils.isNotEmpty(electricConsume)) {
                consumeElectric = consumeElectric.add(electricConsume);
            }
            houseOrder.setElectricCost(costElectric);
            houseOrder.setElectricConsume(consumeElectric);
//                获取水的消费金额和额度
            JSONObject jsonObjectWater = waterEquipmentService.roomCostRecord(waterEquipmentRoomId, live, leave);
            BigDecimal costWater = jsonObjectWater.getBigDecimal("cost");
            BigDecimal consumeWater = jsonObjectWater.getBigDecimal("consume");
            houseOrderBill.setWaterCost(costWater);
            houseOrderBill.setWaterConsume(consumeWater);


            BigDecimal waterCost = houseOrder.getWaterCost();
            if (ObjectUtils.isNotEmpty(waterCost)) {
                costWater = costWater.add(waterCost);
            }
            BigDecimal waterConsume = houseOrder.getWaterConsume();
            if (ObjectUtils.isNotEmpty(waterConsume)) {
                consumeWater = consumeWater.add(waterConsume);
            }

            houseOrder.setWaterCost(costWater);
            houseOrder.setWaterConsume(consumeWater);


            houseOrderBill.setHouseOrderId(houseOrder.getId());
            houseOrderBill.setHouseNumberId(houseNumberId);
            houseOrderBill.setLiveTime(liveTime);
            houseOrderBill.setLeaveTime(new Date());
            houseOrderBillService.save(houseOrderBill);


        }


//      修改订单
        houseOrder.setLeaveTime(new Date());


//        修改房态

        LambdaQueryWrapper<HouseNumberState> wrapperHns = new LambdaQueryWrapper<>();
        wrapperHns.eq(HouseNumberState::getOrderNumber, orderNumber);
        wrapperHns.eq(HouseNumberState::getHouseNumberId, houseNumberId);
        HouseNumberState houseNumberState = houseNumberStateService.getOne(wrapperHns);

        if (ObjectUtils.isEmpty(houseNumberState)) {
            return CommonResult.fail("房间号有误");
        }
        dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
//        设置房态的结束时间
//            houseNumberState.setEndTime(LocalDateTime.now().format(dateTimeFormatter));

//         修改房间状态（置脏）
//            HouseNumber houseNumber = houseNumberService.getById(houseNumberId);
        houseNumber.setHouseStatus(2);

        //            判断该房间是否免费的房间，是则需要支付水电费，并改成带结账状态
//            BigDecimal payPrice = houseOrder.getPayPrice();
//            if (ObjectUtils.isNotEmpty(payPrice) && payPrice.doubleValue() <= 0) {
//                houseOrder.setOrderStatus("5");
//                BigDecimal electricCost = houseOrder.getElectricCost();
//                BigDecimal waterCost = houseOrder.getWaterCost();
//                BigDecimal total = electricCost.add(waterCost);
//                houseOrder.setPayPrice(total);
//            }


        houseOrderService.updateById(houseOrder);
//            houseNumberStateService.updateById(houseNumberState);
        houseNumberStateService.removeById(houseNumberState.getId());
        houseNumberService.updateById(houseNumber);

        return CommonResult.ok();


    }

    @Override
    public CommonResult refund() {
        return null;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)//1
    public CommonResult maintain(MaintainDto maintainDto) {
        int adminId = maintainDto.getAdminId();
        PermissionSetting permissionSetting = permissionSettingService.getById(adminId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseStatusManagement();
        if (!"0".equals(houseTypeManagement) && !houseTypeManagement.contains("3")) {
            return CommonResult.fail("此账号暂无该权限");
        }

        String startTime = maintainDto.getStartTime();
        String endTime = maintainDto.getEndTime();
        String houseNumberId = maintainDto.getHouseNumberId();
        if (ObjectUtils.isEmpty(startTime) && ObjectUtils.isEmpty(endTime) && ObjectUtils.isEmpty(houseNumberId)) {
            return CommonResult.fail();
        }
        List<HouseNumberState> houseNumberStates = houseNumberStateService.beBooked(houseNumberId, startTime, endTime);

        if (ObjectUtils.isNotEmpty(houseNumberStates) && houseNumberStates.size() > 0) {
            return CommonResult.fail("该时间断内已有其他状态");
        }
        HouseNumber houseNumber = houseNumberService.getById(houseNumberId);


        if (ObjectUtils.isEmpty(houseNumber)) {
            return CommonResult.fail("无该房间");
        }

        //                开电
        Boolean aBoolean = electricEquipmentService.openMeterControl(houseNumber.getElectricEquipmentId());
        String msg = "";
        if (!aBoolean) {
            msg = "开电失败";
            //               设置关电状态
            houseNumber.setElectricType("2");
        } else {
            //                设置开电状态
            houseNumber.setElectricType("1");
        }


        houseNumberService.updateById(houseNumber);


//        添加房态
        HouseNumberState houseNumberState = new HouseNumberState();
        houseNumberState.setHouseNumberId(houseNumberId);
        houseNumberState.setStartTime(startTime);
        houseNumberState.setEndTime(endTime);
        houseNumberState.setStatus(6);
        houseNumberStateService.save(houseNumberState);

        if (msg.equals("")) {
            return CommonResult.ok();
        } else {
            return CommonResult.ok(msg);
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)//1
    public CommonResult lockRoom(LockRoomDto lockRoomDto) {
        int adminId = lockRoomDto.getAdminId();
        PermissionSetting permissionSetting = permissionSettingService.getById(adminId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseStatusManagement();
        if (!"0".equals(houseTypeManagement) && !houseTypeManagement.contains("9")) {
            return CommonResult.fail("此账号暂无该权限");
        }

        String startTime = lockRoomDto.getStartTime();
        String endTime = lockRoomDto.getEndTime();
        String houseNumberId = lockRoomDto.getHouseNumberId();
        if (ObjectUtils.isEmpty(startTime) && ObjectUtils.isEmpty(endTime) && ObjectUtils.isEmpty(houseNumberId)) {
            return CommonResult.fail();
        }
        List<HouseNumberState> houseNumberStates = houseNumberStateService.beBooked(houseNumberId, startTime, endTime);

        if (ObjectUtils.isNotEmpty(houseNumberStates) && houseNumberStates.size() > 0) {
            return CommonResult.fail("该时间断内已有其他状态");
        }

//        添加房态
        HouseNumberState houseNumberState = new HouseNumberState();
        houseNumberState.setHouseNumberId(houseNumberId);
        houseNumberState.setStartTime(startTime);
        houseNumberState.setEndTime(endTime);
        houseNumberState.setStatus(5);
        houseNumberStateService.save(houseNumberState);

        return CommonResult.ok();
    }

    @Override
    public CommonResult dirtyRoom(DirtyRoomDto dirtyRoomDto) {
        int adminId = dirtyRoomDto.getAdminId();
        PermissionSetting permissionSetting = permissionSettingService.getById(adminId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseStatusManagement();
//        if (!"0".equals(houseTypeManagement) && !"9".equals(houseTypeManagement)) {
//            return CommonResult.fail("此账号暂无该权限");
//        }
        String houseNumberId = dirtyRoomDto.getHouseNumberId();

        HouseNumber houseNumber = houseNumberService.getById(houseNumberId);


        if (ObjectUtils.isEmpty(houseNumber)) {
            return CommonResult.fail("无该房间");
        }

        //                开电
        Boolean aBoolean = electricEquipmentService.openMeterControl(houseNumber.getElectricEquipmentId());
        String msg = "";
        if (!aBoolean) {
            msg = "开电失败";
            //               设置关电状态
            houseNumber.setElectricType("2");
        } else {
            //                设置开电状态
            houseNumber.setElectricType("1");
        }


        houseNumber.setHouseStatus(2);

        houseNumberService.updateById(houseNumber);

        if (msg.equals("")) {
            return CommonResult.ok();
        } else {
            return CommonResult.fail(msg);
        }
    }

    //    Boolean aBoolean=true;
    @Override
    public CommonResult cleanRoom(CleanRoomDto cleanRoomDto) {
        int adminId = cleanRoomDto.getAdminId();
        PermissionSetting permissionSetting = permissionSettingService.getById(adminId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseStatusManagement();
        if (!"0".equals(houseTypeManagement) && !houseTypeManagement.contains("9")) {
            return CommonResult.fail("此账号暂无该权限");
        }
        String houseNumberId = cleanRoomDto.getHouseNumberId();

        HouseNumber houseNumber = houseNumberService.getById(houseNumberId);
        if (ObjectUtils.isEmpty(houseNumber)) {
            return CommonResult.fail("无该房间");
        }

        houseNumber.setHouseStatus(1);

//        关电
        String msg = "";

//        多线程关电
//        MyGlobalThreadPool.execute(()->{
//        try(
        Boolean aBoolean = electricEquipmentService.closeMeterControl(houseNumber.getElectricEquipmentId());
//        )catch (Exception e) {
//                    log.error("置净失败，失败原因：{}", e);
//                }
//        });

        if (!aBoolean) {
            msg = "关电失败";
            //        开电状态
            houseNumber.setElectricType("1");
        } else {
//            //        关电
            houseNumber.setElectricType("2");
        }

        houseNumberService.updateById(houseNumber);
        if (msg.equals("")) {
            return CommonResult.ok();
        } else {
            return CommonResult.fail(msg);
        }

    }

    @Override
    @Transactional(rollbackFor = Exception.class)//1
    public CommonResult dirtyRooms(DirtyRoomDtos dirtyRoomDtos) {
        int adminId = dirtyRoomDtos.getAdminId();
        PermissionSetting permissionSetting = permissionSettingService.getById(adminId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseStatusManagement();
        if (!"0".equals(houseTypeManagement) && !houseTypeManagement.contains("9")) {
            return CommonResult.fail("此账号暂无该权限");
        }
        List<String> list = dirtyRoomDtos.getHouseNumberIds();
        String msg = "";
        for (String s : list) {
            HouseNumber houseNumber = houseNumberService.getById(s);
            if (ObjectUtils.isEmpty(houseNumber)) {
                return CommonResult.fail("房间异常");
            }
//                开电
            Boolean aBoolean = electricEquipmentService.openMeterControl(houseNumber.getElectricEquipmentId());
            if (!aBoolean) {
                msg = "开电失败";
                //               设置关电状态
                houseNumber.setElectricType("2");
            } else {
                //                设置开电状态
                houseNumber.setElectricType("1");
            }

            houseNumber.setHouseStatus(2);

            boolean update = houseNumberService.updateById(houseNumber);
            if (!update) {
                return CommonResult.fail();
            }
        }


        if (msg.equals("")) {
            return CommonResult.ok();
        } else {
            return CommonResult.fail(msg);
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)//1
    public CommonResult cleanRooms(CleanRoomDtos cleanRoomDtos) {
        int adminId = cleanRoomDtos.getAdminId();
        PermissionSetting permissionSetting = permissionSettingService.getById(adminId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseStatusManagement();
        if (!"0".equals(houseTypeManagement) && !houseTypeManagement.contains("9")) {
            return CommonResult.fail("此账号暂无该权限");
        }
        List<String> houseNumberIds = cleanRoomDtos.getHouseNumberIds();
        String msg = "";

        for (String houseNumberId : houseNumberIds) {
            HouseNumber houseNumber = houseNumberService.getById(houseNumberId);
            if (ObjectUtils.isEmpty(houseNumber)) {
                return CommonResult.fail("房间异常");
            }

            houseNumber.setHouseStatus(1);

//         关电
            Boolean aBoolean = electricEquipmentService.closeMeterControl(houseNumber.getElectricEquipmentId());

            if (!aBoolean) {
                msg = "关电失败";
                //        开电状态
                houseNumber.setElectricType("1");
            } else {
                //        关电
                houseNumber.setElectricType("2");
            }
            boolean update = houseNumberService.updateById(houseNumber);
            if (!update) {
                return CommonResult.fail();
            }
        }
        if (msg.equals("")) {
            return CommonResult.ok();
        } else {
            return CommonResult.fail(msg);
        }
    }

    @Override
    public CommonResult lockRoom(LockRoomDtos lockRoomDtos) {
        int adminId = lockRoomDtos.getAdminId();
        PermissionSetting permissionSetting = permissionSettingService.getById(adminId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseStatusManagement();
        if (!"0".equals(houseTypeManagement) && !houseTypeManagement.contains("9")) {
            return CommonResult.fail("此账号暂无该权限");
        }

        List<String> houseNumberIds = lockRoomDtos.getHouseNumberIds();

        LocalDateTime start = LocalDateTime.now();
        LocalDateTime end = start.plusYears(100);
        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String startTime = start.format(dateTimeFormatter1);
        String endTime = end.format(dateTimeFormatter1);

        ArrayList<HouseNumberState> list = new ArrayList<>();
        for (String houseNumberId : houseNumberIds) {
            List<HouseNumberState> houseNumberStates = houseNumberStateService.beBooked(houseNumberId, startTime, endTime);

            if (ObjectUtils.isNotEmpty(houseNumberStates) && houseNumberStates.size() > 0) {
                return CommonResult.fail("所选房间已有其他状态");
            }

//        添加房态
            HouseNumberState houseNumberState = new HouseNumberState();
            houseNumberState.setHouseNumberId(houseNumberId);
            houseNumberState.setStartTime(startTime);
            houseNumberState.setEndTime(endTime);
            houseNumberState.setStatus(5);
            list.add(houseNumberState);
        }


        houseNumberStateService.saveBatch(list);

        return CommonResult.ok();
    }

    @Override
    public CommonResult openRooms(OpenRoomsDto openRoomsDto) {
        int adminId = openRoomsDto.getAdminId();
        PermissionSetting permissionSetting = permissionSettingService.getById(adminId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseStatusManagement();
        if (!"0".equals(houseTypeManagement) && !houseTypeManagement.contains("12")) {
            return CommonResult.fail("此账号暂无该权限");
        }

        List<String> houseNumberIds = openRoomsDto.getHouseNumberIds();
        LocalDateTime now = LocalDateTime.now();
        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String format = now.format(dateTimeFormatter1);
        ArrayList<HouseNumberState> list = new ArrayList<>();
        for (String houseNumberId : houseNumberIds) {
            //        查找房间对应的锁房状态
            HouseNumberState houseNumberState = houseNumberStateService.getLockHouseNumberState(houseNumberId, now);
            if (ObjectUtils.isNotEmpty(houseNumberState)) {
                houseNumberState.setEndTime(format);
                list.add(houseNumberState);
            }
        }
        if (ObjectUtils.isEmpty(list) || list.size() <= 0) {
            return CommonResult.fail("无锁定房间");
        }
        houseNumberStateService.updateBatchById(list);
        ArrayList<Integer> ids = new ArrayList<>();
        for (HouseNumberState houseNumberState : list) {
            ids.add(houseNumberState.getId());
        }
        houseNumberStateService.removeByIds(ids);


        return CommonResult.ok();
    }

    @Override
    public CommonResult reserveHour(String houseNumberId, String startTime, int liveTime, int adminId) {
        if (ObjectUtils.isEmpty(houseNumberId) && ObjectUtils.isEmpty(startTime) && ObjectUtils.isEmpty(liveTime)) {
            return CommonResult.fail();
        }
        PermissionSetting permissionSetting = permissionSettingService.getById(adminId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseStatusManagement();
        if (!"0".equals(houseTypeManagement) && !houseTypeManagement.contains("1")) {
            return CommonResult.fail("此账号暂无该权限");
        }
        //        获取钟点房可用时间段
        List<ApartmentSetting> list = apartmentSettingService.list(new LambdaQueryWrapper<>());
        ApartmentSetting apartmentSetting = list.get(0);
        String hourTime = apartmentSetting.getHourTime();

        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime start = LocalDateTime.parse(startTime, dateTimeFormatter1);

        start = start.withSecond(0).withMinute(0);
        LocalDateTime end = start.plusHours(liveTime);
        String endTime = end.format(dateTimeFormatter1);
        String[] split = hourTime.split(",");
        ArrayList<ReserveDayVo> reserveDayVos = new ArrayList<>();
        for (int i = 0; i < 13; i++) {
            LocalDateTime localDateTime = null;
            LocalDateTime localDateTime2 = null;
            if (i == 0) {
                localDateTime = LocalDateTime.parse(startTime, dateTimeFormatter1);
                localDateTime2 = localDateTime.plusHours(liveTime);
            } else {
                localDateTime = start.plusHours(i);
                localDateTime2 = end.plusHours(i);
            }
//            LocalDateTime localDateTime = start.plusHours(i);
//            LocalDateTime  localDateTime2 = end.plusHours(i);
            ReserveDayVo reserveDayVo = new ReserveDayVo();
//            LocalDateTime localDateTime = start.plusHours(i);
//            LocalDateTime localDateTime2 = end.plusHours(i);
            String format = localDateTime.format(dateTimeFormatter1);
            String format2 = localDateTime2.format(dateTimeFormatter1);
            reserveDayVo.setDate(format + "至" + format2);
//            先判断时间是否在可用时间范围内
            LocalDateTime start1 = localDateTime.withHour(23).withMinute(59).withSecond(59);
            String format3 = start1.format(dateTimeFormatter1);

            String[] s1 = format.split(" ");
            String startStr = s1[0];

            String[] s2 = format2.split(" ");
            String endStr = s2[0];

            Integer status = 1;
            for (int j = 0; j < split.length; j++) {
                String s = split[j];
                String[] split1 = s.split("-");
                String start2 = split1[0];
                String end2 = split1[1];
                String start3 = startStr + " " + start2;
                String end3 = startStr + " " + end2;
                LocalDateTime localStart = LocalDateTime.parse(start3, dateTimeFormatter1);
                LocalDateTime localEnd = LocalDateTime.parse(end3, dateTimeFormatter1);

//            该天最后时间小于结束时间则需要分为2个时间段
                if (start1.isBefore(localDateTime2)) {
                    String start4 = endStr + " " + start2;
                    String end4 = endStr + " " + end2;
                    LocalDateTime localStart4 = LocalDateTime.parse(start4, dateTimeFormatter1);
                    LocalDateTime localEnd4 = LocalDateTime.parse(end4, dateTimeFormatter1);

                    if ((localStart.isBefore(localDateTime) || format.equals(start3)) && (start1.isBefore(localEnd) || format3.equals(end3)) && (localStart4.isBefore(start1) || start4.equals(format3)) && (start1.isBefore(localEnd4) || end4.equals(format3))) {
//                        可用
                        status = 2;
                        break;
                    }

                } else {
                    if ((localStart.isBefore(localDateTime) || format.equals(start3)) && (localDateTime2.isBefore(localEnd) || format2.equals(end3))) {
//                        可用
                        status = 2;
                        break;
                    }

                }

            }

            if (status == 2) {
                //        获取该时间段内的房态的使用情况
                List<HouseNumberState> houseNumberStateList = houseNumberStateService.beBooked(houseNumberId, format, format2);
                if (ObjectUtils.isNotEmpty(houseNumberStateList) && houseNumberStateList.size() > 0) {
                    reserveDayVo.setStatus("不可用");
                } else {
                    reserveDayVo.setStatus("可用");
                }
            } else {
                reserveDayVo.setStatus("不可用");
            }

            reserveDayVos.add(reserveDayVo);
        }


        return CommonResult.ok(reserveDayVos);
    }

    @Override
    public CommonResult checkInShow(String orderNumber) {

        HouseOrderCheckInShowVo vo = houseOrderService.getOrderNumbre(orderNumber);


        return CommonResult.ok(vo);
    }

    @Override
    public CommonResult freeDropDownShow() {
        List<House> houses = houseService.list(new LambdaQueryWrapper<>());
        Date date = new Date();
//        获取已被订阅的房间
        List<Integer> ids = houseNumberService.getNumberState(date);
//        查询所有房间
        List<HouseNumber> houseNumberList = houseNumberService.list(new LambdaQueryWrapper<>());

        //        重新组合没有使用过的房间
        ArrayList<HouseNumber> list = new ArrayList<>();
        for (HouseNumber houseNumber : houseNumberList) {
            Integer houseNumberId = houseNumber.getId();
            if (!ids.stream().anyMatch(id -> id.equals(houseNumberId))) {
                list.add(houseNumber);
            }
        }

        String houseNumberIds = "";
        for (int i = 0; i < list.size(); i++) {
            HouseNumber number = list.get(i);

            String id = number.getId() + "";
            if (i == 0) {
                houseNumberIds = id;
            } else {
                houseNumberIds = houseNumberIds + "," + id;
            }
        }

        List<FreeVo> freeVos = houseNumberService.freeDropDownShow(houseNumberIds);


        ArrayList<FreeDropDownShowVo> vos = new ArrayList<>();

        for (int i = 0; i < houses.size(); i++) {
            House house = houses.get(i);
            Integer id = house.getId();
            FreeDropDownShowVo vo = new FreeDropDownShowVo();
            vo.setId(id + 1000000);
            vo.setName(house.getRoomName());
            vo.setRoomType(house.getRoomType());
            List<FreeVo> ownerClasses = freeVos.stream().filter(e -> e.getHouseId().equals(id + "")).collect(Collectors.toList());
            if (ownerClasses != null && ownerClasses.size() > 0) {
                vo.setVos(ownerClasses);
            }
            vos.add(vo);
        }


        return CommonResult.ok(vos);
    }

    @Override
    public CommonResult dirtyDropDownShow() {
        List<House> houses = houseService.list(new LambdaQueryWrapper<>());
        List<FreeVo> freeVos = houseNumberService.dirtyDropDownShow();
        ArrayList<FreeDropDownShowVo> vos = new ArrayList<>();
        for (int i = 0; i < houses.size(); i++) {
            House house = houses.get(i);
            Integer id = house.getId();
            FreeDropDownShowVo vo = new FreeDropDownShowVo();
            vo.setId(id + 1000000);
            vo.setName(house.getRoomName());
            vo.setRoomType(house.getRoomType());
            List<FreeVo> ownerClasses = freeVos.stream().filter(e -> e.getHouseId().equals(id + "")).collect(Collectors.toList());
            if (ownerClasses != null && ownerClasses.size() > 0) {
                vo.setVos(ownerClasses);
            }
            vos.add(vo);
        }
        return CommonResult.ok(vos);
    }

    @Override
    public CommonResult lockDropDownShow() {
        List<House> houses = houseService.list(new LambdaQueryWrapper<>());

        Date date = new Date();
//        获取已被锁定的房间
        List<FreeVo> freeVos = houseNumberService.lockDropDownShow(date);

        ArrayList<FreeDropDownShowVo> vos = new ArrayList<>();
        for (int i = 0; i < houses.size(); i++) {
            House house = houses.get(i);
            Integer id = house.getId();
            FreeDropDownShowVo vo = new FreeDropDownShowVo();
            vo.setId(id + 1000000);
            vo.setName(house.getRoomName());
            vo.setRoomType(house.getRoomType());
            List<FreeVo> ownerClasses = freeVos.stream().filter(e -> e.getHouseId().equals(id + "")).collect(Collectors.toList());
            if (ownerClasses != null && ownerClasses.size() > 0) {
                vo.setVos(ownerClasses);
            }
            vos.add(vo);
        }
        return CommonResult.ok(vos);

    }

    @Override
    @Transactional(rollbackFor = Exception.class)//1
    public CommonResult cancelMaintain(CancelMaintainDto cancelMaintainDto) {
        int permissionSettingId = cancelMaintainDto.getPermissionSettingId();
        PermissionSetting permissionSetting = permissionSettingService.getById(permissionSettingId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseStatusManagement();
        if (!"0".equals(houseTypeManagement) && !houseTypeManagement.contains("3")) {
            return CommonResult.fail("此账号暂无该权限");
        }
        String houseNumberId = cancelMaintainDto.getHouseNumberId();
        HouseNumber houseNumber = houseNumberService.getById(houseNumberId);
        if (ObjectUtils.isEmpty(houseNumber)) {
            return CommonResult.fail("房间不存在");
        }
        LocalDateTime date = LocalDateTime.now();
        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String format = date.format(dateTimeFormatter1);
        //        查找房间对应的维修房状态
        HouseNumberState houseNumberState = houseNumberStateService.getMaintainHouseNumberState(houseNumberId, date);

        if (ObjectUtils.isEmpty(houseNumberState)) {
            return CommonResult.fail("无维修房间");
        }
        houseNumberState.setEndTime(format);
//        houseNumberStateService.updateById(houseNumberState);
        houseNumberStateService.removeById(houseNumberState.getId());

        houseNumber.setHouseStatus(1);

//        关电
        Boolean aBoolean = electricEquipmentService.closeMeterControl(houseNumber.getElectricEquipmentId());
        String msg = "";
        if (!aBoolean) {
            msg = "关电失败";
            //        开电状态
            houseNumber.setElectricType("1");
        } else {
            //        关电
            houseNumber.setElectricType("2");
        }
        houseNumberService.updateById(houseNumber);

        if (msg.equals("")) {
            return CommonResult.ok();
        } else {
            return CommonResult.ok(msg);
        }
    }

    @Override
    public CommonResult shutDropDownShow() {
        List<House> houses = houseService.list(new LambdaQueryWrapper<>());
//        Date date = new Date();
//        获取已被订阅的房间
//        List<Integer> ids = houseNumberService.getNumberState(date);
//        查询所有房间
        List<HouseNumber> list = houseNumberService.list(new LambdaQueryWrapper<>());

        //        重新组合没有使用过的房间
//        ArrayList<HouseNumber> list = new ArrayList<>();
//        for (HouseNumber houseNumber : houseNumberList) {
//            Integer houseNumberId = houseNumber.getId();
//            if (!ids.stream().anyMatch(id -> id.equals(houseNumberId))) {
//                list.add(houseNumber);
//            }
//        }

//        为了防止入住开电失败不能在单独开电修改
        String houseNumberIds = "";
        for (int i = 0; i < list.size(); i++) {
            HouseNumber number = list.get(i);

            String id = number.getId() + "";
            if (i == 0) {
                houseNumberIds = id;
            } else {
                houseNumberIds = houseNumberIds + "," + id;
            }
        }


        List<FreeVo> freeVos = houseNumberService.shutDropDownShow(houseNumberIds);

        ArrayList<FreeDropDownShowVo> vos = new ArrayList<>();
        for (int i = 0; i < houses.size(); i++) {
            House house = houses.get(i);
            Integer id = house.getId();
            FreeDropDownShowVo vo = new FreeDropDownShowVo();
            vo.setId(id + 1000000);
            vo.setName(house.getRoomName());
            vo.setRoomType(house.getRoomType());
            List<FreeVo> ownerClasses = freeVos.stream().filter(e -> e.getHouseId().equals(id + "")).collect(Collectors.toList());
            if (ownerClasses != null && ownerClasses.size() > 0) {
                vo.setVos(ownerClasses);
            }
            vos.add(vo);
        }
        return CommonResult.ok(vos);
    }

    @Override
    public CommonResult openDropDownShow() {
        List<House> houses = houseService.list(new LambdaQueryWrapper<>());
//        Date date = new Date();
//        获取已被订阅的房间
//        List<Integer> ids = houseNumberService.getNumberState(date);
//        查询所有房间
        List<HouseNumber> list = houseNumberService.list(new LambdaQueryWrapper<>());

        //        重新组合没有使用过的房间
//        ArrayList<HouseNumber> list = new ArrayList<>();
//        for (HouseNumber houseNumber : houseNumberList) {
//            Integer houseNumberId = houseNumber.getId();
//            if (!ids.stream().anyMatch(id -> id.equals(houseNumberId))) {
//                list.add(houseNumber);
//            }
//        }

        String houseNumberIds = "";
        for (int i = 0; i < list.size(); i++) {
            HouseNumber number = list.get(i);

            String id = number.getId() + "";
            if (i == 0) {
                houseNumberIds = id;
            } else {
                houseNumberIds = houseNumberIds + "," + id;
            }
        }


        List<FreeVo> freeVos = houseNumberService.opneDropDownShow(houseNumberIds);

        ArrayList<FreeDropDownShowVo> vos = new ArrayList<>();
        for (int i = 0; i < houses.size(); i++) {
            House house = houses.get(i);
            Integer id = house.getId();
            FreeDropDownShowVo vo = new FreeDropDownShowVo();
            vo.setId(id + 1000000);
            vo.setName(house.getRoomName());
            vo.setRoomType(house.getRoomType());
            List<FreeVo> ownerClasses = freeVos.stream().filter(e -> e.getHouseId().equals(id + "")).collect(Collectors.toList());
            if (ownerClasses != null && ownerClasses.size() > 0) {
                vo.setVos(ownerClasses);
            }
            vos.add(vo);
        }
        return CommonResult.ok(vos);
    }

    @Override
    public CommonResult shutRooms(LockRoomDtos dtos) {
        List<String> houseNumberIds = dtos.getHouseNumberIds();

        ArrayList<HouseNumber> list = new ArrayList<>();
        String msg = "";
        for (String houseNumberId : houseNumberIds) {
            HouseNumber houseNumber = houseNumberService.getById(houseNumberId);

//        关电
            Boolean aBoolean = electricEquipmentService.closeMeterControl(houseNumber.getElectricEquipmentId());

            if (!aBoolean) {
                msg = "关电失败";
                //        开电状态
                houseNumber.setElectricType("1");
            } else {
                //        关电
                houseNumber.setElectricType("2");
            }
            list.add(houseNumber);
        }
        houseNumberService.updateBatchById(list);

        if (msg.equals("")) {
            return CommonResult.ok();
        } else {
            return CommonResult.fail(msg);
        }

    }

    @Override
    public CommonResult openERooms(OpenRoomsDto openRoomsDto) {
        List<String> houseNumberIds = openRoomsDto.getHouseNumberIds();
        ArrayList<HouseNumber> list = new ArrayList<>();
        String msg = "";
        for (String houseNumberId : houseNumberIds) {
            HouseNumber houseNumber = houseNumberService.getById(houseNumberId);
//            开电
            Boolean aBoolean = electricEquipmentService.openMeterControl(houseNumber.getElectricEquipmentId());

            if (!aBoolean) {
                msg = "开电失败";
                //               设置关电状态
                houseNumber.setElectricType("2");
            } else {
                //                设置开电状态
                houseNumber.setElectricType("1");
            }

            list.add(houseNumber);
        }
        houseNumberService.updateBatchById(list);

        if (msg.equals("")) {
            return CommonResult.ok();
        } else {
            return CommonResult.fail(msg);
        }
    }


}