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

package com.template.controller;


import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.template.api.HouseOrderAPI;
import com.template.common.utils.*;
import com.template.component.WeiXiaoComponent;
import com.template.model.dto.*;
import com.template.model.vo.HouseOrderPageListVo;
import com.template.model.pojo.*;
import com.template.model.result.CommonResult;
import com.template.model.result.PageUtils;
import com.template.model.vo.PriceVo;
import com.template.services.*;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletResponse;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.*;

/**
 * <p>
 * 前端控制器
 * </p>
 *
 * @author ceshi
 * @since 2023-11-21
 */
@RestController
public class HouseOrderController implements HouseOrderAPI {

    @Autowired
    HouseOrderService houseOrderService;

    @Autowired
    HouseService houseService;

    @Autowired
    HouseNumberService houseNumberService;

    @Autowired
    HouseNumberStateService houseNumberStateService;

    @Autowired
    ClassScheduleService classScheduleService;

    @Autowired
    HousePriceService housePriceService;

    @Autowired
    UsersService usersService;

    @Autowired
    HouseLockService houseLockService;

    @Autowired
    private WeiXiaoComponent weiXiaoComponent;

    @Autowired
    UnlockingService unlockingService;

    @Autowired
    PasswordIssController passwordIssController;

    @Autowired
    PermissionSettingService permissionSettingService;

    @Override
    public CommonResult getHouseOrderPrice(int houseOrderNumber, String userId, String houseId, String liveTime, String leaveTime) {
        if (ObjectUtils.isEmpty(userId) && ObjectUtils.isEmpty(houseId) && ObjectUtils.isEmpty(leaveTime) && ObjectUtils.isEmpty(leaveTime) && ObjectUtils.isEmpty(houseOrderNumber) && houseOrderNumber <= 0) {
            return CommonResult.fail();
        }
        House house = houseService.getById(houseId);
        if (house == null) {
            return CommonResult.fail("无此房间，请重新查询");
        }
//        计算总金额
        BigDecimal totalPrice = houseOrderService.getHouseOrderPrice(houseOrderNumber, userId, houseId, liveTime, leaveTime);

        return CommonResult.ok(totalPrice);

    }


    @Override
    @Transactional(rollbackFor = Exception.class)
    public CommonResult establishOrder(EstablishOrderDto establishOrderDto) {
        if (ObjectUtils.isEmpty(establishOrderDto)) {
            return CommonResult.fail();
        }

        String userId = establishOrderDto.getUserId();

        String houseId = establishOrderDto.getHouseId();

        House house = houseService.getById(houseId);
        if (house == null) {
            return CommonResult.fail("无此房间，请重新查询");
        }

        if (house.getNumber() < Func.parseInt(establishOrderDto.getHouseOrderNumber())) {
            return CommonResult.fail("超出限定房间数量");
        }


        LambdaQueryWrapper<HouseNumber> wrapperHn = new LambdaQueryWrapper<>();
        wrapperHn.eq(HouseNumber::getHouseId, houseId);
        //       房间必须是净房
        wrapperHn.eq(HouseNumber::getHouseStatus, 1);
        List<HouseNumber> houseNumberList = houseNumberService.list(wrapperHn);
//        获取该房态下可使用房间号
        String ids = "";
        for (int i = 0; i < houseNumberList.size(); i++) {
            HouseNumber houseNumber = houseNumberList.get(i);
            String id = houseNumber.getId() + "";
            if (i == 0) {
                ids = id;
            } else {
                ids = ids + "," + id;
            }
        }
        String reserveLiveTime = establishOrderDto.getReserveLiveTime();
        String reserveLeaveTime = establishOrderDto.getReserveLeaveTime();
//        获取该时间段内的所有使用的房间
        List<HouseNumberState> houseNumberStateList = houseNumberStateService.beBooked(ids, reserveLiveTime, reserveLeaveTime);

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


        if (list.size() < establishOrderDto.getHouseOrderNumber()) {
            return CommonResult.fail("超出可订购房间数量");
        }

        HouseOrder houseOrder = new HouseOrder();

//        计算总金额
        BigDecimal totalPrice = houseOrderService.getHouseOrderPrice(establishOrderDto.getHouseOrderNumber(), userId, houseId, establishOrderDto.getReserveLiveTime(), establishOrderDto.getReserveLeaveTime());

        BigDecimal payPrice = establishOrderDto.getPayPrice();
//        返回的结果是int类型,-1表示小于，0是等于，1是大于。
        if (payPrice.compareTo(totalPrice) != 0) {
            return CommonResult.fail("需付金额异常");
        }
//        订单号
        String orderNumber = UUID.randomUUID().toString();
        orderNumber = orderNumber.replace("-", "");
        houseOrder.setOrderNumber(orderNumber);

        ArrayList<HouseNumber> houseNumbers = new ArrayList<>();
        ArrayList<HouseNumberState> houseNumberStates = new ArrayList<>();
//        随机匹配房间
        int houseOrderNumber = establishOrderDto.getHouseOrderNumber();
        String houseNumberIds = "";
        for (int i = 0; i < houseOrderNumber; i++) {
            HouseNumber houseNumber = list.get(i);
            String id = houseNumber.getId() + "";
////            判断预定的时间是否是今天,是今天则在使用,否则则不在使用
//            houseNumber.setStatus(2);
            if (i == 0) {
                houseNumberIds = id;
            } else {
                houseNumberIds = houseNumberIds + "," + id;
            }
            //        修改房间表，
//            houseNumbers.add(houseNumber);
//            修改房间状态表,判断预定时间是否在
            HouseNumberState houseNumberState = new HouseNumberState();
            houseNumberState.setHouseNumberId(id);
            houseNumberState.setStatus(3);
            houseNumberState.setStartTime(establishOrderDto.getReserveLiveTime());
            houseNumberState.setEndTime(establishOrderDto.getReserveLeaveTime());
            houseNumberState.setOrderNumber(orderNumber);
            houseNumberStates.add(houseNumberState);
        }
//        待支付
        houseOrder.setOrderStatus("1");
//        房态id
        houseOrder.setHouseId(houseId);
//        房间号id(可多个房间id)
        houseOrder.setHouseNumberId(houseNumberIds);
//        预定人姓名
        houseOrder.setReserveName(establishOrderDto.getReserveName());
//        预定人电话号码
        houseOrder.setReservePhone(establishOrderDto.getReservePhone());
//        预定入住时间
        houseOrder.setReserveLiveTime(establishOrderDto.getReserveLiveTime());
//        预定离开时间
        houseOrder.setReserveLeaveTime(establishOrderDto.getReserveLeaveTime());
//    单价   全日房  价格单价=总价/房间数/天数
//       钟点房  价格单价=总价/房间数
        Integer roomType = house.getRoomType();
        BigDecimal price;
        if (roomType == 1) {
            price = payPrice.divide(new BigDecimal(houseOrderNumber), 2, BigDecimal.ROUND_HALF_UP).divide(new BigDecimal(establishOrderDto.getLiveDay()), 2, BigDecimal.ROUND_HALF_UP);
        } else {
            price = payPrice.divide(new BigDecimal(houseOrderNumber), 2, BigDecimal.ROUND_HALF_UP);
        }
        houseOrder.setPrice(price);
//      订房数量
        houseOrder.setHouseOrderNumber(houseOrderNumber);
//      入住天数
        houseOrder.setLiveDay(establishOrderDto.getLiveDay());

//      付款金额
        houseOrder.setPayPrice(payPrice);
//        入住人id
        houseOrder.setLiveUsersId(userId);

//        创建人
        houseOrder.setCreateUser(userId);
//        更新人
        houseOrder.setUpdateUser(userId);
//      订单渠道  订单渠道（1：线上，2：线下）
        houseOrder.setOrderChannel("1");

        try {
            houseOrderService.save(houseOrder);
            houseNumberStateService.saveBatch(houseNumberStates);
//            houseNumberService.updateBatchById(houseNumbers);
            System.out.println("创建订单成功");
            return CommonResult.ok(houseOrder);
        } catch (Exception e) {
            e.printStackTrace();
            return CommonResult.fail("创建订单异常");
        }

    }

    @Override
    public CommonResult payOrder(String houseOrderId) {
//        try {
//            // 支付费用
//            double totalPrice = booking.getHouseTotalPrice() ;
//            int totalfee = Func.parseInt(totalPrice * 100);
//
//            WechatUnifiedOrder w = new WechatUnifiedOrder();
//            w.setAppid(WeiXinUtil.appid_c);
//            w.setAttach("chuanghai");
//            w.setBody("chuanghai");
//            w.setMch_id(WeiXinUtil.account);
//            w.setNonce_str(PayWxUtil.getNonceStr());// 随机支付串
//            w.setNotify_url(WeiXinUtil.ip_h + "/abkpayResulet.action");// 支付结果回调地址
//            w.setOpenid(this.open_id);
//            String orderNo = booking.getOrderNum(); // 订单编号
//            w.setOut_trade_no(orderNo);
//            w.setSpbill_create_ip(WeiXinUtil.ip);
//            w.setTotal_fee(totalfee);
//            w.setTrade_type("JSAPI");
//            Map<String, String> params = new HashMap<String, String>();
//            params.put("attach", w.getAttach());
//            params.put("appid", w.getAppid());
//            params.put("mch_id", w.getMch_id());
//            params.put("nonce_str", w.getNonce_str());
//            params.put("body", w.getBody());
//            params.put("out_trade_no", w.getOut_trade_no());
//            params.put("total_fee", Func.parseStr(w.getTotal_fee()));
//            params.put("spbill_create_ip", w.getSpbill_create_ip());
//            params.put("notify_url", w.getNotify_url());
//            params.put("trade_type", w.getTrade_type());
//            params.put("openid", w.getOpenid());
//            w.setSign(PayWxUtil.getSign(params, WeiXinUtil.key));
//            params.put("sign", w.getSign());
//            String retXml = JaxbUtil.getRequestXml(params);
//            String msg = HttpUtils.post("https://api.mch.weixin.qq.com/pay/unifiedorder", retXml);
//            System.out.println(msg);
//            // 支付失败
//            if (msg.indexOf("FAIL") > -1) {
//                resultjson.put("code", "205");
//                resultjson.put("message", "支付异常205");
//                ResUtil.write(resultjson, ServletActionContext.getResponse());
//                return null;
//            }
//
//            JaxbUtil requestBinder = new JaxbUtil(TongYiReturn.class, JaxbUtil.CollectionWrapper.class);
//            TongYiReturn to = requestBinder.fromXml(msg);
//            // 支付成功
//            if (to.getReturn_code().equals("SUCCESS") && to.getResult_code().equals("SUCCESS")) {
//                EndPay pay = new EndPay();
//                pay.setAppId(WeiXinUtil.appid_c);
//                pay.setSignType("MD5");
//                pay.setTimeStamp(System.currentTimeMillis() / 1000 + "");
//                pay.setPrepay_id(to.getPrepay_id());
//                pay.setNonceStr(PayWxUtil.getNonceStr());
//                Map<String, String> requestMap = new HashMap<String, String>();
//                requestMap.put("appId", pay.getAppId());
//                requestMap.put("timeStamp", pay.getTimeStamp());
//                requestMap.put("nonceStr", pay.getNonceStr());
//                requestMap.put("package", "prepay_id=" + pay.getPrepay_id());
//                requestMap.put("signType", "MD5");
//                pay.setPaySign(PayWxUtil.getSign(requestMap, WeiXinUtil.key));
//                // 保存支付信息
//                booking.setUpdateTime(DateUtil.getFormatPaternDate(new Date()));
//                booking.setOrderStatus(Func.parseStr(PayEnum.待支付.getNum()));
//                //booking.setPayAccount(0);
//                booking.setPayWay(OrderEnum.微信支付.toString());
//                bookService.updateBooking(booking);
//
//                //用户开启支付，写入数据操作
//                bookinglogService.addBooklog("用户点击订单，进行支付"  ,booking);
//
//
//
//                resultjson.put(B.code, ResultStatusCode.OK.getStatus());
//                resultjson.put(B.message, "返回成功");
//                resultjson.put(B.data, pay);
//                ResponseUtil.writeJson(ServletActionContext.getResponse(), resultjson.toString());
//            }
//        } catch (Exception e) {
//            resultjson.put(B.code, ResultStatusCode.BAD_REQUEST.getStatus());
//            resultjson.put(B.message, e.getMessage());
//            ResponseUtil.writeJson(ServletActionContext.getResponse(), resultjson.toString());
//        }
        return null;


    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public CommonResult checkIn(String houseOrderId, String userId) {
        if (ObjectUtils.isEmpty(houseOrderId)) {
            return CommonResult.fail();
        }
        HouseOrder houseOrder = houseOrderService.getById(houseOrderId);
//      预定人就是入住人
        String reserveName = houseOrder.getReserveName();
        houseOrder.setLiveName(reserveName);

//      入住时间
        Date date = new Date();
        houseOrder.setLiveTime(date);
//      离店时间=预离店时间
        String reserveLeaveTime = houseOrder.getReserveLeaveTime();
        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        Date leaveTime = Date.from(LocalDateTime.parse(reserveLeaveTime, dateTimeFormatter1).atZone(ZoneId.systemDefault()).toInstant());
//        houseOrder.setLiveTime(leaveTime);


//        下发门锁密码
//        需先获取所属房间号的门锁型号
        String houseNumberId = houseOrder.getHouseNumberId();
        List<HouseLock> houseLocks = houseLockService.getHouseNumberId(houseNumberId);

        try {
            long start = date.getTime();
            long end = leaveTime.getTime();

//            设备id
            for (int i = 0; i < houseLocks.size(); i++) {
                HouseLock houseLock = houseLocks.get(i);
//                设备id
                String equipmentType = houseLock.getEquipmentType();
                PasswordDto pr = new PasswordDto();
                pr.setLuid(equipmentType);
                pr.setStartTime(String.valueOf(start));
                pr.setEndTime(String.valueOf(end));
                pr.setHouseNumberId(houseNumberId);
                pr.setOrderNumber(houseOrder.getOrderNumber());
                Unlocking unlocking = passwordIssController.addPassword(pr);

                String passWord = unlocking.getPassWord();
                //添加
                unlockingService.save(unlocking);

//                String password = "测试";
                Integer houseNumberId1 = houseLock.getHouseNumberId();
                HouseNumber houseNumber = houseNumberService.getById(houseNumberId1);
//                房间号
                String roomNumber = houseNumber.getRoomNumber();
//              获取工号
                Users users = usersService.getById(userId);
                String cardNumber = users.getCardNumber();
                ArrayList<String> strings = new ArrayList<>();
                strings.add(cardNumber);
                weiXiaoComponent.sendNotice(strings, "公寓办理入住成功", "办理入住成功", "您的房间号为:" + roomNumber + ",密码是:" + passWord + "离店时间为:" + reserveLeaveTime + ",欢迎您入住张玉玲酒店，我们全体员工很荣幸能为您服务，如有任何需要请致电张玉玲，期待为你服务。祝你生活愉快！", null);
//                开电表(暂无)
                HouseNumber number = houseNumberService.getById(houseLock.getHouseNumberId());
//                设置开电
                number.setElectricType("2");
//                房间号设置成脏房需要退房后设置
//                number.setHouseStatus(2);
                houseNumberService.updateById(number);

            }
//                修改订单状态
//                订单状态 1.待支付，2.已支付，3.待入住，4.已入住，5.待结账，6.退款中，7.已退款，8.已退房，9.已取消，超时
            houseOrder.setOrderStatus("4");
            houseOrderService.updateById(houseOrder);

//            todo  获取电起码，水起码（暂无）

//              修改房态状态
            LambdaQueryWrapper<HouseNumberState> wrapperHns = new LambdaQueryWrapper<>();
            wrapperHns.eq(HouseNumberState::getOrderNumber, houseOrder.getOrderNumber());
            List<HouseNumberState> list = houseNumberStateService.list(wrapperHns);
            ArrayList<HouseNumberState> houseNumberStates = new ArrayList<>();
            for (HouseNumberState houseNumberState : list) {
//                    状态 1空闲、2脏房，3预定、4入住、5锁定、6维修
                houseNumberState.setStatus(4);
                houseNumberStates.add(houseNumberState);
            }
            houseNumberStateService.updateBatchById(houseNumberStates);
            return CommonResult.ok();

//              todo  //开电表
//                waterElectricComponent.remoteDisconnect(roomThird.getElectricId(), OpenElectricStatuEnum.OPEN.getCode());
//


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

    }

    @Override
    public CommonResult pageList(int adminId,int page, int size, String keyWord, String houseType, String orderStatus, String payPriceStartTime, String payPriceEndTime, String refundStartTime, String refundEndTime, String cancelStartTime, String cancelEndTime, String liveStartTime, String liveEndTime, String leaveStartTime, String leaveEndTime) {
        PermissionSetting permissionSetting = permissionSettingService.getById(adminId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseOrderManagement();
        if (!"0".equals(houseTypeManagement) && !"6".equals(houseTypeManagement)) {
            return CommonResult.fail("此账号暂无该权限");
        }

        if (ObjectUtils.isEmpty(page) && page <= 0) {
            page = 1;
        }

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

        PageUtils<HouseOrderPageListVo> pageList = houseOrderService.pageList(page, size, keyWord, houseType, orderStatus, payPriceStartTime, payPriceEndTime, refundStartTime, refundEndTime, cancelStartTime, cancelEndTime, liveStartTime, liveEndTime, leaveStartTime, leaveEndTime);
        List<HouseOrderPageListVo> list = pageList.getList();
        for (int i = 0; i < list.size(); i++) {
            HouseOrderPageListVo houseOrderPageListVo = list.get(i);
            String orderStart = houseOrderPageListVo.getOrderStart();
            String choiceBox = "";
            if ("1".equals(orderStart)) {
                choiceBox = "1,6";
            } else if ("2".equals(orderStart)) {
                choiceBox = "2,6";
            } else if ("3".equals(orderStart)) {
                choiceBox = "2,3,6";
            } else if ("4".equals(orderStart)) {
                choiceBox = "2,4,5,6";
            } else if ("5".equals(orderStart)) {
                choiceBox = "6";
            } else if ("6".equals(orderStart)) {
                choiceBox = "6";
            } else if ("7".equals(orderStart)) {
                choiceBox = "6";
            } else if ("8".equals(orderStart)) {
                choiceBox = "6";
            } else if ("9".equals(orderStart)) {
                choiceBox = "6";
            }
            houseOrderPageListVo.setChoiceBox(choiceBox);
        }
        pageList.setList(list);

        return CommonResult.ok(pageList);
    }

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


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

            LambdaQueryWrapper<HouseOrder> wrapperHo = new LambdaQueryWrapper<>();
            wrapperHo.eq(HouseOrder::getOrderNumber, orderNumber);
            HouseOrder houseOrder = houseOrderService.getOne(wrapperHo);
            String orderStatus = houseOrder.getOrderStatus();
            if (!"1".equals(orderStatus)) {
                return CommonResult.fail("该订单不是待支付，不能直接取消");
            }

// 修改订单状态
            houseOrder.setOrderStatus("9");
//  设置取消时间
            houseOrder.setCancelTime(new Date());

            LambdaQueryWrapper<HouseNumberState> wrapperHns = new LambdaQueryWrapper<>();
            wrapperHns.eq(HouseNumberState::getHouseNumberId, houseNumberId)
                    .eq(HouseNumberState::getOrderNumber, orderNumber);
            HouseNumberState houseNumberState = houseNumberStateService.getOne(wrapperHns);
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            houseNumberState.setEndTime(sdf.format(new Date()));

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

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

    }

    @Override
    public CommonResult particulars(String orderNumber,int adminId) {
        PermissionSetting permissionSetting = permissionSettingService.getById(adminId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseOrderManagement();
        if (!"0".equals(houseTypeManagement) && !"2".equals(houseTypeManagement)) {
            return CommonResult.fail("此账号暂无该权限");
        }
        if (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("无该订单");
        }
//      todo 水电明细

        return CommonResult.ok(houseOrder);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public CommonResult checkIdCard(CheckIdCardDto checkIdCardDto) {
        if (ObjectUtils.isEmpty(checkIdCardDto)) {
            return CommonResult.fail();
        }
        String adminId = checkIdCardDto.getAdminId();
        PermissionSetting permissionSetting = permissionSettingService.getById(adminId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseOrderManagement();
        if (!"0".equals(houseTypeManagement) && !"3".equals(houseTypeManagement)) {
            return CommonResult.fail("此账号暂无该权限");
        }
        String houseNumberId = checkIdCardDto.getHouseNumberId();
        String cardNumber = checkIdCardDto.getCardNumber();
        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::getUserName, liveName)
                    .eq(Users::getPhone, phone)
                    .eq(ObjectUtils.isNotEmpty(cardNumber), Users::getCardNumber, cardNumber);
            Users users = usersService.getOne(wrapperU);

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

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

            HouseOrder houseOrder = new HouseOrder();
            if (ObjectUtils.isEmpty(houseOrder1)) {
                //        订单号
                String orderNumber1 = UUID.randomUUID().toString();
                orderNumber1 = orderNumber1.replace("-", "");
                houseOrder.setOrderNumber(orderNumber1);
                houseOrder.setHouseId(houseId);
                houseOrder.setHouseNumberId(houseNumberId);
                houseOrder.setReserveName(liveName);
                houseOrder.setReservePhone(phone);
                houseOrder.setReserveLiveTime(liveTime);
                houseOrder.setReserveLeaveTime(leaveTime);
                houseOrder.setPrice(priceVo.getPrice());
                houseOrder.setPayPrice(priceVo.getTotalPrice());
                houseOrder.setHouseOrderNumber(1);
                houseOrder.setLiveDay(checkIdCardDto.getLiveDay() + "");
                houseOrder.setOrderChannel("2");

            } else {
                BeanUtils.copyProperties(houseOrder1, houseOrder);
            }
            //            入住人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);
                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);
//  todo 获取电起码，水起码

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

            HouseNumberState houseNumberState1 = houseNumberStateService.getOne(wrapperHns);
            HouseNumberState houseNumberState = new HouseNumberState();
            if (ObjectUtils.isEmpty(houseNumberState1)) {
                houseNumberState.setHouseNumberId(houseNumberId);
                houseNumberState.setEndTime(leaveTime);
                houseNumberState.setOrderNumber(houseOrder.getOrderNumber());
            } else {
                BeanUtils.copyProperties(houseNumberState1, houseNumberState);
            }
            houseNumberState.setStatus(4);
            houseNumberState.setStartTime(liveTime);

//        获取设备id
            LambdaQueryWrapper<HouseLock> wrapperHl = new LambdaQueryWrapper<>();
            wrapperHl.eq(HouseLock::getHouseNumberId, houseNumberId);
            HouseLock houseLock = houseLockService.getOne(wrapperHl);
            String equipmentState = houseLock.getEquipmentState();

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

//        todo 开电
            houseNumber.setElectricType("1");

            String roomNumber = houseNumber.getRoomNumber();
            String start = String.valueOf(liveDate.getTime());
            String end = String.valueOf(leaveDate.getTime());
//        发放密码
            String lockStatus = checkIdCardDto.getLockStatus();
            if ("1".equals(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);
                unlockingService.save(unlocking);

                String passWord = unlocking.getPassWord();
                ArrayList<String> strings = new ArrayList<>();
                strings.add(cardNumber);
                weiXiaoComponent.sendNotice(strings, "公寓办理入住成功", "办理入住成功", "您的房间号为:" + roomNumber + ",密码是:" + passWord + "离店时间为:" + liveTime + ",欢迎您入住张玉玲酒店，我们全体员工很荣幸能为您服务，如有任何需要请致电张玉玲，期待为你服务。祝你生活愉快！", null);
            } else if ("2".equals(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);
            } else if ("3".equals(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);
            }


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

            houseNumberService.updateById(houseNumber);

            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.getHouseOrderManagement();
        if (!"0".equals(houseTypeManagement) && !"5".equals(houseTypeManagement)) {
            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) {
            HouseNumberState houseNumberStateData=houseNumberStateService.getData(new Date(),houseNumberId);
            if (ObjectUtils.isNotEmpty(houseNumberStateData)) {
                houseOrder.setLeaveTime(Date.from(LocalDateTime.parse(reserveLeaveTime, dateTimeFormatter).atZone(ZoneId.systemDefault()).toInstant()));
                houseOrderService.updateById(houseOrder);
                return CommonResult.ok("该时间段已超过退房时间，已修改其订单状态");
            }
//            }

            //      todo 获取水电止码


//      修改订单
            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);



            houseOrderService.updateById(houseOrder);
            houseNumberStateService.updateById(houseNumberState);
            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 roomChange(RoomChangeDto roomChangeDto) {
        if (ObjectUtils.isEmpty(roomChangeDto)) {
            return CommonResult.fail();
        }
        int adminId = roomChangeDto.getAdminId();
        PermissionSetting permissionSetting = permissionSettingService.getById(adminId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseOrderManagement();
        if (!"0".equals(houseTypeManagement) && !"8".equals(houseTypeManagement)) {
            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);
//            todo 结算水电 如是免费订单额度则加入
//            todo 获取新房间的水起码和电起码
            houseOrderService.updateById(houseOrder);


//        添加状态表，修改状态表
            HouseNumberState houseNumberState = new HouseNumberState();
            houseNumberState.setStatus(3);
            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);

//        修改换的房间
            HouseNumber houseNumber = houseNumberService.getById(houseNumberId);
//        房间置脏需退房后
//            houseNumber.setHouseStatus(2);
//        todo 开电
            houseNumber.setElectricType("1");
            houseNumberService.updateById(houseNumber);

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

//            todo 旧房间密码删除，添加新房间密码
            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());
            }
            LambdaQueryWrapper<HouseLock> wrapperHl = new LambdaQueryWrapper<>();
            wrapperHl.eq(HouseLock::getHouseNumberId, houseNumberId);
            HouseLock houseLock = houseLockService.getOne(wrapperHl);
            String equipmentState = houseLock.getEquipmentState();

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


//            判断是什么类型的开锁方式
            String lockStatus = unlocking.getLockStatus();
            if ("1".equals(lockStatus)) {
                PasswordDto pr = new PasswordDto();
                pr.setLuid(houseLock.getEquipmentType());
//            开始时间
                pr.setStartTime(String.valueOf(liveTime.getTime()));
//            结束时间
                String reserveLeaveTime = houseOrder.getReserveLeaveTime();
                DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
                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);


            } 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();
                DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
                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);
            } 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();
                DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
                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);
            }

            return CommonResult.ok();

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

    @Override
    public void queryExport(HttpServletResponse response, int adminId, int page, int size, String keyWord, String houseType, String orderStatus, String payPriceStartTime, String payPriceEndTime, String refundStartTime, String refundEndTime, String cancelStartTime, String cancelEndTime, String liveStartTime, String liveEndTime, String leaveStartTime, String leaveEndTime) {

    }


    /**
     * 每天12点查询一次到时间没有点退房的订单，并自动退房
     */
    @Scheduled(cron = "0 0 12 * * ? ")
    @Transactional(rollbackFor = Exception.class)
    public void getOrder() {
        LambdaQueryWrapper<HouseOrder> wrapperHo = new LambdaQueryWrapper<>();
        wrapperHo.eq(HouseOrder::getOrderStatus, 4);
//        小于等于当前时间
        wrapperHo.le(HouseOrder::getReserveLeaveTime, new Date());

        List<HouseOrder> list = houseOrderService.list(wrapperHo);
        try {
            ArrayList<HouseOrder> houseOrders = new ArrayList<>();
            ArrayList<HouseNumber> houseNumbers = new ArrayList<>();
            for (HouseOrder houseOrder : list) {
                houseOrder.setOrderStatus("8");
                houseOrder.setLeaveTime(new Date());
                String houseNumberId = houseOrder.getHouseNumberId();
//            todo 获取水电止码
                HouseNumber houseNumber = houseNumberService.getById(houseNumberId);
//          将房间设置成脏房
                houseNumber.setHouseStatus(2);

                houseOrders.add(houseOrder);
                houseNumbers.add(houseNumber);
            }
            houseOrderService.updateBatchById(houseOrders);
            houseNumberService.updateBatchById(houseNumbers);

        } catch (Exception e) {
            e.printStackTrace();
        }

    }


}