iHotel_student_houtai/src/main/java/com/template/controller/HouseNumberStateController.java

package com.template.controller;


import com.alibaba.fastjson.JSONObject;
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.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.*;
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 = 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 = houseStateVo.getReserveLiveTime();

                HouseStateVo houseStateVo1 = map.get(houseNumberId);
                String reserveLiveTime1 = houseStateVo1.getReserveLiveTime();

                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);
            }
            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);
            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);
            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, String dateTime) {
        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);


        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.setLiveTime(houseOrder.getReserveLiveTime());
//                    预定离店时间
                    vo.setLeaveTime(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.setLiveTime(houseOrder.getReserveLiveTime());
//                    预定离店时间
                    vo.setLeaveTime(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());

//                    已入住时间
                    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);
//                    电起码，水起码
                    LambdaQueryWrapper<HouseOrderBill> wrapperHOB = new LambdaQueryWrapper<>();
                    wrapperHOB.eq(HouseOrderBill::getHotelOrderId, houseOrder.getId());
                    HouseOrderBill houseOrderBill = houseOrderBillService.getOne(wrapperHOB);
                    if (ObjectUtils.isNotEmpty(houseOrderBill)) {
                        String startOfWater = houseOrderBill.getStartOfWater();
                        vo.setStartWater(startOfWater);
                        String startOfElectric = houseOrderBill.getStartOfElectric();
                        vo.setStartElectric(startOfElectric);
                    }


                }
            } 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)
    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("当前时间不可预定");
            }

        }


        try {
            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)
                    .eq(ObjectUtils.isNotEmpty(cardNumber), Users::getCardNumber, cardNumber);
            Users users = usersService.getOne(wrapperU);

            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);
            int dayOfYear = start.getDayOfYear();
            int dayOfYear1 = end.getDayOfYear();
            int diff = dayOfYear1 - dayOfYear;
            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();
        } catch (Exception e) {
            e.printStackTrace();
            return CommonResult.fail();
        }

    }



    @Override
    @Transactional(rollbackFor = Exception.class)
    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();
        try {

//        判断是否有用户
            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);


//                        入住人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) {
//                return CommonResult.fail("开电失败");
//            }
            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);

            return CommonResult.ok();

        } catch (Exception e) {
            e.printStackTrace();
            return CommonResult.fail();
        }

    }

    @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<HouseNumber> wrapperHn = new LambdaQueryWrapper<>();
//        wrapperHn.eq(HouseNumber::getHouseId, houseNumber.getHouseId());
////       房间必须是净房
//        wrapperHn.eq(HouseNumber::getHouseStatus, 1);
//
//        List<HouseNumber> houseNumberList2 = houseNumberService.list(wrapperHn);
        List<HouseNumberVo> houseNumberList = houseNumberService.roomChangePage(houseNumber.getHouseId());

        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);
            }
        }


        return CommonResult.ok(list);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    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);
        if (ObjectUtils.isEmpty(houseOrder)) {
            return CommonResult.fail("无该订单");
        }
        Date liveTime = houseOrder.getLiveTime();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = sdf.format(liveTime);
        //      判断该房间在该订单的时间内是否有使用
        List<HouseNumberState> houseNumberStateList = houseNumberStateService.beBooked(houseNumberId, format, houseOrder.getReserveLeaveTime());

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

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

            //      获取水电消费金额和额度
//            获取初始房间号的水电表设备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());
//                获取电的消费金额和额度
                JSONObject jsonObjectElectric = electricEquipmentService.roomCostRecord(electricEquipmentRoomId, live, leave);
                BigDecimal costElectric = jsonObjectElectric.getBigDecimal("cost");
                BigDecimal consumeElectric = jsonObjectElectric.getBigDecimal("consume");
                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");
                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);

            }


            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());
//            if (!aBoolean) {
//                return CommonResult.fail("开电失败");
//            }
            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);
            String equipmentState = houseLock.getEquipmentType();

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


//            判断是什么类型的开锁方式
            String lockStatus = unlocking.getLockStatus();
//          添加锁的操作记录

            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);

            return CommonResult.ok();

        } catch (Exception e) {
            e.printStackTrace();
            return CommonResult.fail();
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    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("无该订单");
        }
        try {
            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());
//                获取电的消费金额和额度
                    JSONObject jsonObjectElectric = electricEquipmentService.roomCostRecord(electricEquipmentRoomId, live, leave);
                    BigDecimal costElectric = jsonObjectElectric.getBigDecimal("cost");
                    BigDecimal consumeElectric = jsonObjectElectric.getBigDecimal("consume");
                    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");
                    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);

                }
                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());
//                获取电的消费金额和额度
                JSONObject jsonObjectElectric = electricEquipmentService.roomCostRecord(electricEquipmentRoomId, live, leave);
                BigDecimal costElectric = jsonObjectElectric.getBigDecimal("cost");
                BigDecimal consumeElectric = jsonObjectElectric.getBigDecimal("consume");
                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");
                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);

            }


//      修改订单
            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();
        } catch (Exception e) {
            e.printStackTrace();
            return CommonResult.fail();
        }

    }

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

    @Override
    @Transactional(rollbackFor = Exception.class)
    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());
//        if (!aBoolean) {
//            return CommonResult.fail("开电失败");
//        }
        //        开电
        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);

        return CommonResult.ok();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    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());
//        if (!aBoolean) {
//            return CommonResult.fail("开电失败");
//        }
        //        开电
        houseNumber.setElectricType("1");

        houseNumber.setHouseStatus(2);

        houseNumberService.updateById(houseNumber);

        return CommonResult.ok();
    }

    @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);
//        关电
        houseNumber.setElectricType("2");
//        关电
//        Boolean aBoolean = electricEquipmentService.closeMeterControl(houseNumber.getElectricEquipmentId());
//        if (!aBoolean) {
//            return CommonResult.fail("关电失败");
//        }

        houseNumberService.updateById(houseNumber);

        return CommonResult.ok();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    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) && !"9".equals(houseTypeManagement)) {
            return CommonResult.fail("此账号暂无该权限");
        }
        List<String> list = dirtyRoomDtos.getHouseNumberIds();
        try {
            for (String s : list) {
                HouseNumber houseNumber = houseNumberService.getById(s);
                if (ObjectUtils.isEmpty(houseNumber)) {
                    return CommonResult.fail("房间异常");
                }
//                开电
//                Boolean aBoolean = electricEquipmentService.openMeterControl(houseNumber.getElectricEquipmentId());
//                if (!aBoolean) {
//                    return CommonResult.fail("开电失败");
//                }
                //        开电
                houseNumber.setElectricType("1");
                houseNumber.setHouseStatus(2);

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

        return CommonResult.ok();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    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();
        try {
            for (String houseNumberId : houseNumberIds) {
                HouseNumber houseNumber = houseNumberService.getById(houseNumberId);
                if (ObjectUtils.isEmpty(houseNumber)) {
                    return CommonResult.fail("房间异常");
                }

                houseNumber.setHouseStatus(1);
//        关电
                houseNumber.setElectricType("2");
//         关电
//                Boolean aBoolean = electricEquipmentService.closeMeterControl(houseNumber.getElectricEquipmentId());
//                if (!aBoolean) {
//                    return CommonResult.fail("关电失败");
//                }

                boolean update = houseNumberService.updateById(houseNumber);
                if (!update) {
                    return CommonResult.fail();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            return CommonResult.fail();
        }
        return CommonResult.ok();
    }

    @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)
    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);
//        关电
        houseNumber.setElectricType("2");
//        关电
//        Boolean aBoolean = electricEquipmentService.closeMeterControl(houseNumber.getElectricEquipmentId());
//        if (!aBoolean) {
//            return CommonResult.fail("关电失败");
//        }
        houseNumberService.updateById(houseNumber);

        return CommonResult.ok();
    }

    @Override
    public CommonResult shutDropDownShow() {
        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.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> 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.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<>();
        for (String houseNumberId : houseNumberIds) {
            HouseNumber houseNumber = houseNumberService.getById(houseNumberId);
//        关电
            houseNumber.setElectricType("2");
//        关电
//            Boolean aBoolean = electricEquipmentService.closeMeterControl(houseNumber.getElectricEquipmentId());
//            if (!aBoolean) {
//                return CommonResult.fail("关电失败");
//            }
            list.add(houseNumber);
        }
        houseNumberService.updateBatchById(list);

        return CommonResult.ok();

    }

    @Override
    public CommonResult openERooms(OpenRoomsDto openRoomsDto) {
        List<String> houseNumberIds = openRoomsDto.getHouseNumberIds();
        ArrayList<HouseNumber> list = new ArrayList<>();
        for (String houseNumberId : houseNumberIds) {
            HouseNumber houseNumber = houseNumberService.getById(houseNumberId);
//            开电
//            Boolean aBoolean = electricEquipmentService.openMeterControl(houseNumber.getElectricEquipmentId());
//            if (!aBoolean) {
//                return CommonResult.fail("开电失败");
//            }
            houseNumber.setElectricType("1");
            list.add(houseNumber);
        }
        houseNumberService.updateBatchById(list);

        return CommonResult.ok();
    }


}