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

package com.template.controller;


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.template.annotation.PassToken;
import com.template.api.HouseOrderAPI;
import com.template.common.utils.*;
import com.template.component.WeiXiaoComponent;
import com.template.config.WeixiaoConfig;
import com.template.config.WxPayV3Config;
import com.template.model.dto.*;
import com.template.model.enumModel.ePayStatu;
import com.template.model.pojo.*;
import com.template.model.result.CommonResult;
import com.template.model.result.PageUtils;
import com.template.model.vo.HouseOrderPageListVo;
import com.template.model.vo.HouseOrderVo;
import com.template.model.vo.OrderPageVo;
import com.template.model.vo.QueryExportVo;
import com.template.model.weixin.PayUtil;
import com.template.model.weixin.WechatPayV3Util;
import com.template.services.*;
import com.wechat.pay.java.core.Config;
import com.wechat.pay.java.core.RSAAutoCertificateConfig;
import com.wechat.pay.java.core.notification.NotificationConfig;
import com.wechat.pay.java.core.notification.NotificationParser;
import com.wechat.pay.java.core.notification.RequestParam;
import com.wechat.pay.java.service.payments.jsapi.JsapiServiceExtension;
import com.wechat.pay.java.service.payments.jsapi.model.*;
import com.wechat.pay.java.service.payments.model.Transaction;
import com.wechat.pay.java.service.payments.nativepay.NativePayService;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

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

import static com.template.common.utils.StrUtils.getUUIDBits;
import static com.wechat.pay.java.service.payments.model.Transaction.TradeStateEnum.NOTPAY;
import static com.wechat.pay.java.service.payments.model.Transaction.TradeStateEnum.SUCCESS;

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

    @Autowired
    HouseOrderService houseOrderService;

    @Autowired
    HouseService houseService;

    @Autowired
    private WeixiaoConfig weixiaoConfig;

    @Autowired
    HouseNumberService houseNumberService;

    @Autowired
    HouseNumberStateService houseNumberStateService;

    @Autowired
    ClassScheduleService classScheduleService;

    @Autowired
    HousePriceService housePriceService;

    @Autowired
    UsersService usersService;

    @Autowired
    HouseLockService houseLockService;

    @Autowired
    WeiXiaoComponent weiXiaoComponent;

    @Autowired
    UnlockingService unlockingService;

    @Autowired
    PasswordIssController passwordIssController;

    @Autowired
    PermissionSettingService permissionSettingService;

    @Autowired
    AdminService adminService;

    @Autowired
    OperatingRecordService operatingRecordService;

    @Autowired
    WaterEquipmentService waterEquipmentService;

    @Autowired
    ElectricEquipmentService electricEquipmentService;

    @Autowired
    private WxPayV3Config wxPayV3Config;

    @Autowired
    PayRecordService payRecordService;

    @Autowired
    RefundRecordService refundRecordService;

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

        //        判断传过来的时间和当前时间比较
        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);
        }

//        获取该时间段内的所有使用的房间
        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);
            Integer roomType = house.getRoomType();
            if (1==roomType) {
//                DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
                LocalDateTime start = LocalDateTime.parse(reserveLiveTime, dateTimeFormatter1).withHour(0).withMinute(0).withSecond(0);
                LocalDateTime end = LocalDateTime.parse(reserveLeaveTime,dateTimeFormatter1).withHour(0).withMinute(0).withSecond(0);
                String startTime = start.format(dateTimeFormatter1);
                String endTime = end.format(dateTimeFormatter1);
                houseNumberState.setStartTime(startTime);
                houseNumberState.setEndTime(endTime);
            }else {
                houseNumberState.setStartTime(reserveLiveTime);
                houseNumberState.setEndTime(reserveLeaveTime);
            }


            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.setReserveUserId(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, String openId) {
        /*try {
            // 支付费用
            HouseOrder houseOrder = houseOrderService.getById(houseOrderId);
            BigDecimal payPrice = houseOrder.getPayPrice();
            double totalPrice = payPrice.doubleValue();
            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(openId);
            String orderNo = houseOrder.getOrderNumber(); // 订单编号
            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) {
                return CommonResult.fail("支付失败");
            }

            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));
                // 保存支付信息
                houseOrder.setPayTime(DateUtil.getFormatPaternDate(new Date()));
//                等收到回调
                houseOrder.setOrderStatus("1");
//              支付方式
                houseOrder.setPayType("微信支付");

                houseOrderService.updateById(houseOrder);
//                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());

                return CommonResult.ok(pay);
            }
        } catch (Exception e) {
//            resultjson.put(B.code, ResultStatusCode.BAD_REQUEST.getStatus());
//            resultjson.put(B.message, e.getMessage());
//            ResponseUtil.writeJson(ServletActionContext.getResponse(), resultjson.toString());
            e.printStackTrace();
            return CommonResult.fail();
        }
        return CommonResult.fail("支付失败");*/

        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);
//              添加锁的操作记录
                OperatingRecord operatingRecord = new OperatingRecord();
                operatingRecord.setRoomNumber(houseNumber.getRoomNumber());
                operatingRecord.setOperatorName(users.getUserName());
                operatingRecord.setDataTime(LocalDateTime.now().format(dateTimeFormatter1));
                operatingRecord.setContent("姓名:" + houseOrder.getLiveName());
                operatingRecord.setType("添加密码钥匙");
                operatingRecordService.save(operatingRecord);

                HouseNumber number = houseNumberService.getById(houseLock.getHouseNumberId());
//                开电
//                Boolean aBoolean = electricEquipmentService.openMeterControl(number.getElectricEquipmentId());
//                if (!aBoolean) {
//                    return CommonResult.fail("开电失败");
//                }
//                设置开电状态
                number.setElectricType("1");
//                房间号设置成脏房需要退房后设置
//                number.setHouseStatus(2);
                houseNumberService.updateById(number);

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

//              修改房态状态
            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();

        } 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) && !houseTypeManagement.contains("6")) {
            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) && !houseTypeManagement.contains("1")) {
            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);
            houseNumberStateService.removeById(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) && !houseTypeManagement.contains("2")) {
            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 adminMenuId = checkIdCardDto.getAdminMenuId();
        PermissionSetting permissionSetting = permissionSettingService.getById(adminMenuId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseOrderManagement();
        if (!"0".equals(houseTypeManagement) && !houseTypeManagement.contains("3")) {
            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::getOrderNumber, orderNumber);
            HouseOrder houseOrder = 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);
                users1.setUserMenuId("4");
                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 houseNumberState1 = houseNumberStateService.getOne(wrapperHns);
            HouseNumberState houseNumberState = new HouseNumberState();
            if (ObjectUtils.isEmpty(houseNumberState1)) {
               return CommonResult.fail();
            } 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.getEquipmentType();

            //      修改房间状态
            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());
//        发放密码
            String lockStatus = checkIdCardDto.getLockStatus();

//            添加锁的操作记录
            Admin byId = adminService.getById(checkIdCardDto.getAdminId());

            OperatingRecord operatingRecord = new OperatingRecord();
            operatingRecord.setRoomNumber(houseNumber.getRoomNumber());
            operatingRecord.setOperatorName(byId.getName());
            operatingRecord.setDataTime(LocalDateTime.now().format(dateTimeFormatter1));
            operatingRecord.setContent("姓名:" + houseOrder.getLiveName());


            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);
                operatingRecord.setType("添加密码钥匙");
            } 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);
                operatingRecord.setType("添加卡片钥匙");
            } 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);
                operatingRecord.setType("添加指纹钥匙");
            }


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

            houseNumberService.updateById(houseNumber);
            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.getHouseOrderManagement();
        if (!"0".equals(houseTypeManagement) && !houseTypeManagement.contains("5")) {
            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("该时间段已超过退房时间，已修改其订单状态");
            }
//            }


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

            //      获取水电消费金额和额度
            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);

            }


//        修改房态

            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);
            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 adminMenuId = roomChangeDto.getAdminMenuId();
        PermissionSetting permissionSetting = permissionSettingService.getById(adminMenuId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getHouseOrderManagement();
        if (!"0".equals(houseTypeManagement) && !houseTypeManagement.contains("8")) {
            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(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);
            houseNumberStateService.removeById(one);

//        修改换的房间
            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());

                OperatingRecord operatingRecord = new OperatingRecord();
                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 equipment = houseLock.getEquipmentType();

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


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

//             添加锁的操作记录
            OperatingRecord operatingRecord = new OperatingRecord();
            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(equipment);
                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(equipment);
                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
    public CommonResult queryExport(HttpServletResponse response, int adminId, 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) && !houseTypeManagement.contains("9")) {
            return CommonResult.fail("此账号暂无该权限");
        }

        List<QueryExportVo> vos = houseOrderService.queryExport(keyWord, houseType, orderStatus, payPriceStartTime, payPriceEndTime, refundStartTime, refundEndTime, cancelStartTime, cancelEndTime, liveStartTime, liveEndTime, leaveStartTime, leaveEndTime);

        //        导出
        Workbook workbook = new XSSFWorkbook();
        Sheet sheet = workbook.createSheet("订单表");
        Row headerRow = sheet.createRow(0);
        headerRow.createCell(0).setCellValue("订单号");
        headerRow.createCell(1).setCellValue("入住时间");
        headerRow.createCell(2).setCellValue("离店时间");
        headerRow.createCell(3).setCellValue("用户人名称");
        headerRow.createCell(4).setCellValue("入住人名称");
        headerRow.createCell(5).setCellValue("手机号码");
        headerRow.createCell(6).setCellValue("房型");
        headerRow.createCell(7).setCellValue("房间号");
        headerRow.createCell(8).setCellValue("订单金额");
        headerRow.createCell(9).setCellValue("支付方式");
        headerRow.createCell(10).setCellValue("订单渠道");
        headerRow.createCell(11).setCellValue("订单状态");
        headerRow.createCell(12).setCellValue("支付时间");
        headerRow.createCell(13).setCellValue("退款时间");
        headerRow.createCell(14).setCellValue("取消时间");

        if (ObjectUtils.isNotEmpty(vos) && vos.size() > 0) {
            for (int i = 0; i < vos.size(); i++) {
                QueryExportVo vo = vos.get(i);
                Row dataRow1 = sheet.createRow(i + 1);
                dataRow1.createCell(0).setCellValue(vo.getOrderNumber());
                dataRow1.createCell(1).setCellValue(vo.getLiveTime());
                dataRow1.createCell(2).setCellValue(vo.getLeaveTime());
                dataRow1.createCell(3).setCellValue(vo.getReserveName());
                dataRow1.createCell(4).setCellValue(vo.getLiveName());
                dataRow1.createCell(5).setCellValue(vo.getPhone());
                dataRow1.createCell(6).setCellValue(vo.getHouseName());
                dataRow1.createCell(7).setCellValue(vo.getHouseNumber());
                BigDecimal orderPrice = vo.getOrderPrice();
                String price = "";
                if (ObjectUtils.isNotEmpty(orderPrice)) {
                    price = orderPrice.toString();
                }
                dataRow1.createCell(8).setCellValue(price);
                //                pay_type 支付方式（微信支付，现金）
                String payType = vo.getPayType();
                String payName = "";
                if ("1".equals(payType)) {
                    payName = "微信支付";
                } else if ("2".equals(payType)) {
                    payName = "现金";
                }
                dataRow1.createCell(9).setCellValue(payName);
                //                order_channel 订单渠道（1：线上，2：线下）
                String orderChannelType = vo.getOrderChannelType();
                String orderChannelName = "";
                if ("1".equals(orderChannelType)) {
                    orderChannelName = "线上";
                } else if ("2".equals(orderChannelType)) {
                    orderChannelName = "线下";
                }
                dataRow1.createCell(10).setCellValue(orderChannelName);
                //                订单 订单状态 1.待支付，2.已支付，3.待入住，4.已入住，5.待结账，6.退款中，7.已退款，8.已退房，9.已取消，超时
                String orderStart = vo.getOrderStart();
                String orderName = "";
                if ("1".equals(orderStart)) {
                    orderName = "待支付";
                } else if ("2".equals(orderStart)) {
                    orderName = "已支付";
                } else if ("3".equals(orderStart)) {
                    orderName = "待入住";
                } else if ("4".equals(orderStart)) {
                    orderName = "已入住";
                } else if ("5".equals(orderStart)) {
                    orderName = "待结账";
                } else if ("6".equals(orderStart)) {
                    orderName = "退款中";
                } else if ("7".equals(orderStart)) {
                    orderName = "已退款";
                } else if ("8".equals(orderStart)) {
                    orderName = "已退房";
                } else if ("9".equals(orderStart)) {
                    orderName = "已取消";
                }
                dataRow1.createCell(11).setCellValue(orderName);
                dataRow1.createCell(12).setCellValue(vo.getPayTime());
                dataRow1.createCell(13).setCellValue(vo.getRefundTime());
                dataRow1.createCell(14).setCellValue(vo.getCancelTime());
            }
        }
        // 将工作簿写入文件
        ExcelUtils.excelDownload(workbook, "订单表.xlsx", response);

        return CommonResult.ok();
    }

    @Override
    public CommonResult reportStatistics(String permissionSettingId, String state, String keyWord, String startTime, String endTime, int page, int size) {
        PermissionSetting permissionSetting = permissionSettingService.getById(permissionSettingId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }

//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.getDoorLockManagement();
        if (!"0".equals(houseTypeManagement) && !houseTypeManagement.contains("14")) {
            return CommonResult.fail("此账号暂无该权限");
        }

        if (ObjectUtils.isEmpty(state)) {
            return CommonResult.fail("参数异常");
        }

        ArrayList<String> strings = new ArrayList<>();
        if ("1".equals(state)) {
            strings.add("2");
            strings.add("3");
            strings.add("4");
            strings.add("8");
        } else {
            strings.add("1");
            strings.add("5");
        }


        LambdaQueryWrapper<HouseOrder> wrapper = new LambdaQueryWrapper<>();
        wrapper.between(ObjectUtils.isNotEmpty(startTime) && ObjectUtils.isNotEmpty(endTime), HouseOrder::getCreateTime, startTime, endTime)
                .like(ObjectUtils.isNotEmpty(keyWord), HouseOrder::getOrderNumber, keyWord)
                .in(HouseOrder::getOrderStatus, strings)
                .or()
                .between(ObjectUtils.isNotEmpty(startTime) && ObjectUtils.isNotEmpty(endTime), HouseOrder::getCreateTime, startTime, endTime)
                .like(ObjectUtils.isNotEmpty(keyWord), HouseOrder::getLiveName, keyWord)
                .in(HouseOrder::getOrderStatus, strings)
        ;
        IPage<HouseOrder> page1 = houseOrderService.page(new Page<>(page, size), wrapper);

        return CommonResult.ok(page1);


    }


    @Override
    public CommonResult orderPage(String userId, int page, int size, String status) {

        if (ObjectUtils.isEmpty(userId)) {
            return CommonResult.fail("参数异常");
        }

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

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


        LambdaQueryWrapper<HouseOrder> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(HouseOrder::getLiveUsersId, userId)
                .orderByDesc(HouseOrder::getCreateTime);

        if (ObjectUtils.isEmpty(status)) {
            ArrayList<String> strings = new ArrayList<>();
            strings.add("1");
            strings.add("3");
            strings.add("4");
            strings.add("5");
            strings.add("8");
            strings.add("9");
            wrapper.in(HouseOrder::getOrderStatus, strings);
        } else {
            wrapper.eq(HouseOrder::getOrderStatus, status);
        }

        IPage<HouseOrder> page1 = houseOrderService.page(new Page<>(page, size), wrapper);

        List<HouseOrder> records = page1.getRecords();
        ArrayList<OrderPageVo> orderPageVos = new ArrayList<>();
        for (HouseOrder record : records) {
            OrderPageVo orderPageVo = new OrderPageVo();
            BeanUtils.copyProperties(record, orderPageVo);
            String orderStatus = record.getOrderStatus();
            if ("1".equals(orderStatus)) {
//                取消,支付
                orderPageVo.setType("1,2");
            } else if ("3".equals(orderStatus)) {
//                取消,入住
                orderPageVo.setType("1,3");
            } else if ("4".equals(orderStatus)) {
//                退房
                orderPageVo.setType("4");

            } else if ("5".equals(orderStatus)) {
//                支付
                orderPageVo.setType("2");
            } else if ("8".equals(orderStatus)) {
//                再次预定
                orderPageVo.setType("5");
            } else if ("9".equals(orderStatus)) {
//                再次预定
                orderPageVo.setType("5");
            }
//            找到对应订单的房间图片和房间号
            String houseId = record.getHouseId();
            House byId = houseService.getById(houseId);
            if (ObjectUtils.isNotEmpty(byId)) {
                orderPageVo.setUrl(byId.getRoomPicture());
            }
            String houseNumberId = record.getHouseNumberId();
            HouseNumber byId1 = houseNumberService.getById(houseNumberId);
            if (ObjectUtils.isNotEmpty(byId1)) {
                orderPageVo.setRoomNumber(byId1.getRoomNumber());
            }

            orderPageVos.add(orderPageVo);

        }

        IPage<OrderPageVo> orderPageVoIPage = new Page<>();

        BeanUtils.copyProperties(page1, orderPageVoIPage);

        orderPageVoIPage.setRecords(orderPageVos);


        return CommonResult.ok(orderPageVoIPage);

    }

    @Override
    public CommonResult getHouseOrder(String houseOrderId) {
        if (ObjectUtils.isEmpty(houseOrderId)) {
            return CommonResult.fail("参数异常");
        }

        HouseOrder houseOrder = houseOrderService.getById(houseOrderId);
        if (ObjectUtils.isEmpty(houseOrder)) {
            return CommonResult.fail();
        }

        String houseId = houseOrder.getHouseId();

        House house = houseService.getById(houseId);

        HouseOrderVo houseOrderVo = new HouseOrderVo();
        houseOrderVo.setHouseOrder(houseOrder);
        houseOrderVo.setHouse(house);

        return CommonResult.ok(houseOrderVo);
    }

    private CloseableHttpClient httpClient;

    /**
     * 订单支付
     *
     * @param wpd
     * @param bindingResult
     * @return
     * @throws Exception
     */
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public CommonResult pay(WxPayDto wpd, BindingResult bindingResult, HttpServletRequest request) throws Exception {
        System.out.println(TimeExchange.getTime() + "微信支付参数====：" + JSON.toJSON(wpd));
        String wxCode= request.getHeader("code");
        if(wxCode==null||wxCode==""){
            return CommonResult.fail("code不能为空");
        }
        if (bindingResult.hasErrors()) {
            String st = paramUtils.getParamError(bindingResult);
            return CommonResult.fail(st);
        }

        HouseOrder ho = houseOrderService.getById(wpd.getHouseOrderId());
        if (ObjectUtils.isEmpty(ho)) {
            return CommonResult.fail("订单已失效，支付失败");
        }
        BigDecimal payPrice = ho.getPayPrice();
        if (wpd.getTotalPrice().compareTo(payPrice) != 0) {
            return CommonResult.fail("支付金额与订单金额不一致");
        }

        //查看该订单是否支付过
        LambdaQueryWrapper<PayRecord> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(PayRecord::getHouseOrderId, wpd.getHouseOrderId());
        PayRecord oldPr = payRecordService.getOne(wrapper);
        if (oldPr != null && oldPr.getIsSuccess().equals(ePayStatu.Paysuccess.getValue())) {
            return CommonResult.fail("该订单已支付，请勿重复操作");
        }

        Users ru = usersService.getById(wpd.getUsersId());
        if (ru == null) {
            return CommonResult.fail("用户信息不合法，支付失败");
        }

        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        try {
            log.info(TimeExchange.getTime() + "微信支付判断全部通过");
            //返回0表示等于0，返回1表示大于0，返回-1表示小于0
            if (wpd.getTotalPrice().compareTo(BigDecimal.ZERO) < 0 || wpd.getTotalPrice().compareTo(BigDecimal.ZERO) == 0) {
                if (oldPr == null) {
                    PayRecord pr = new PayRecord();
                    pr.setHouseOrderId(wpd.getHouseOrderId());
                    pr.setUserId(ru.getId());
                    pr.setPayNo(getUUIDBits(15));
                    pr.setPayPrice(BigDecimal.ZERO);
                    pr.setIsSuccess(ePayStatu.Paysuccess.getValue());
                    pr.setRemark("支付金额为0，不用走微信支付");
                    boolean save = payRecordService.save(pr);
                    if (!save) {
                        throw new Exception("支付失败！");
                    }
                } else {
                    oldPr.setRemark(oldPr.getRemark() + "后续支付：支付金额为0，不用走微信支付");
                    oldPr.setPayPrice(BigDecimal.ZERO);
                    oldPr.setIsSuccess(ePayStatu.Paysuccess.getValue());
                    boolean update = payRecordService.updateById(oldPr);
                    if (!update) {
                        throw new Exception("支付失败！");
                    }
                }
//              已支付
                ho.setOrderStatus("2");
//               支付时间
                ho.setPayTime(LocalDateTime.now().format(dateTimeFormatter));
//                支付渠道
                ho.setOrderChannel("1");
//                支付人
                ho.setPayUserId(ru.getId() + "");

                Boolean updateHouseOrder = houseOrderService.updateById(ho);
                if (!updateHouseOrder) {
                    throw new Exception("支付失败！");
                }
                return CommonResult.ok("支付金额为0，不用走微信支付");
            }
        } catch (Exception e) {
            throw new Exception("支付失败！");
        }
        //微信支付以分为单位
        int totalfee = (wpd.getTotalPrice().multiply(new BigDecimal(100))).intValue();
        //查询是否有未支付订单，有则调用关闭更新支付订单号重新生成支付订单
        List<PayRecord> houseOrderId = payRecordService.list(new QueryWrapper<PayRecord>().eq("house_order_id", ho.getId()));
        log.info("支付订单houseOrderId=="+houseOrderId.toString());
        PayRecord payRecord=houseOrderId.size()>0?houseOrderId.get(0):new PayRecord();
        if (StringUtils.hasText(payRecord.getPayNo())){
            try {
                this.closeOrderById(payRecord.getPayNo());
            } catch (Exception e) {
                return CommonResult.fail("关闭已生成支付订单失败返回:"+e.getMessage());
            }
            payRecord.setPayNo(CommonUtil.generateUUID());
            payRecord.setRemark("更新订单");
            boolean a =payRecordService.updateById(payRecord);
            if (!a){
                return CommonResult.fail("生成支付订单失败");
            }
        }else{
            payRecord.setPayNo(CommonUtil.generateUUID());
            payRecord.setHouseOrderId(ho.getId());
            payRecord.setUserId(Integer.valueOf(ho.getPayUserId()));
            payRecord.setPayPrice(BigDecimal.valueOf(totalfee));
            payRecord.setIsSuccess(1);
            payRecord.setRemark("新订单");
            boolean a=payRecordService.save(payRecord);
            if (!a){
                return CommonResult.fail("创建支付订单失败");
            }
        }

        // jsapi支付
        //获取openid
        String tokenUrl = "https://api.weixin.qq.com/sns/oauth2/access_token";
        tokenUrl=tokenUrl+"?code="+wxCode+"&appid="+wxPayV3Config.getAppId()+"&secret="+wxPayV3Config.getSecret()+"&grant_type=authorization_code";
        RestTemplate client = new RestTemplate();
        String tokenResponse = client.postForObject(tokenUrl, null, String.class);
        log.info("获取openid结果"+tokenResponse);
        JSONObject jsonObject1 =JSONObject.parseObject(tokenResponse);
        String openId = (String) jsonObject1.getString("openid");
        if(openId==null||openId==""){
            return CommonResult.fail("openid查询失败");
        }
//        String openId = "okdUu5xZ2ICm3RuMUHbpJi4DUyzw";
        PrepayRequest requestpay = new PrepayRequest();
        requestpay.setAppid(wxPayV3Config.getAppId());
        requestpay.setMchid(wxPayV3Config.getMchId());
        requestpay.setDescription("智慧公寓");
        Amount amount2 = new Amount();
        amount2.setTotal(totalfee);
        requestpay.setNotifyUrl(wxPayV3Config.getDomain()+"/auto/house-order/returnPay");
        requestpay.setAmount(amount2);
        Payer payer1=new Payer();
        payer1.setOpenid(openId);
        requestpay.setPayer(payer1);
//        requestpay.setOutTradeNo(TimeExchange.DateToTimestamp(new Date())+"");
        requestpay.setOutTradeNo(payRecord.getPayNo());
        Config config = new RSAAutoCertificateConfig.Builder()
                        .merchantId( wxPayV3Config.getMchId())
                        .privateKeyFromPath(wxPayV3Config.getKeyPath())
                        .merchantSerialNumber(wxPayV3Config.getSerialNum())
                        .apiV3Key(wxPayV3Config.getApiKey3())
                        .build();
        JsapiServiceExtension  service =new JsapiServiceExtension.Builder()
                .config(config)
                .signType("RSA") // 不填默认为RSA
                .build();

        PrepayWithRequestPaymentResponse responseSdk= null;
        try {
            responseSdk = service.prepayWithRequestPayment(requestpay);
            log.info("请求支付参数返回："+responseSdk.toString());
        } catch (Exception e) {
            log.info("请求支付异常返回："+e);
            return CommonResult.ok(e.getMessage());
        }
        return CommonResult.ok(responseSdk);
    }

    /**
     * 微信支付订单号查询订单
     *
     * @param outTradeNo
     * @return
     * @throws Exception
     */
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public CommonResult queryOrderById(String outTradeNo) throws Exception{
        Transaction transaction= new Transaction();
        HouseOrder one = houseOrderService.getOne(new QueryWrapper<HouseOrder>().eq("order_number",outTradeNo));
        if("2".equals(one.getOrderStatus())&&"2".equals(one.getPayType())){
            transaction.setTradeState(SUCCESS);
            transaction.setTradeStateDesc("现金支付完成");
            return CommonResult.ok(transaction);
        }
        PayRecord payRecord=payRecordService.getOne(new QueryWrapper<PayRecord>().eq("house_order_id",one.getId()));
        if(payRecord==null||payRecord.getPayNo()==null){
            transaction.setTradeState(NOTPAY);
            transaction.setTradeStateDesc("该订单尚未支付");
            return CommonResult.ok(transaction);
        }
        QueryOrderByOutTradeNoRequest queryOrderByIdRequest = new QueryOrderByOutTradeNoRequest();
        // 调用request.setXxx(val)设置所需参数，具体参数可见Request定义
        queryOrderByIdRequest.setMchid(wxPayV3Config.getMchId());
        queryOrderByIdRequest.setOutTradeNo(payRecord.getPayNo());
        // 调用接口
//        JsapiService service = new JsapiService.Builder().config(config).build();
        log.info("微信支付查询订单入参："+queryOrderByIdRequest.toString());
        Config config =
                new RSAAutoCertificateConfig.Builder()
                        .merchantId( wxPayV3Config.getMchId())
                        .privateKeyFromPath(wxPayV3Config.getKeyPath())
                        .merchantSerialNumber(wxPayV3Config.getSerialNum())
                        .apiV3Key(wxPayV3Config.getApiKey3())
                        .build();
        JsapiServiceExtension  service =new JsapiServiceExtension.Builder()
                .config(config)
                .signType("RSA") // 不填默认为RSA
                .build();

        try {
            transaction = service.queryOrderByOutTradeNo(queryOrderByIdRequest);
            switch (transaction.getTradeState()){
                case SUCCESS:
                    payRecord.setIsSuccess(2);
                    payRecord.setRemark(transaction.getTradeStateDesc());
                    one.setOrderStatus("2");
                    break;
                case PAYERROR:
                    payRecord.setRemark(transaction.getTradeStateDesc());
                    payRecord.setIsSuccess(3);
                    break;
            }
            boolean a=houseOrderService.updateById(one);
            boolean b=payRecordService.updateById(payRecord);
            if (!a||!b){
                throw new Exception("更新支付状态失败");
            }
            log.info("微信支付查询订单出参："+transaction.toString());
        } catch (Exception e) {
            e.printStackTrace();
            return CommonResult.fail(e.getMessage());
        }
        return CommonResult.ok(transaction);
    }

    /**
     * 微信支付关闭订单
     *
     * @param outTradeNo
     * @return
     * @throws Exception
     */
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public CommonResult closeOrder(String outTradeNo) {
        HouseOrder one = houseOrderService.getOne(new QueryWrapper<HouseOrder>().eq("order_number",outTradeNo));
        PayRecord payRecord=payRecordService.getOne(new QueryWrapper<PayRecord>().eq("house_order_id",one.getId()));
        if(payRecord==null){
            return CommonResult.ok("没有可关闭支付订单,无需关闭");
        }
        try {
            this.closeOrderById(payRecord.getPayNo());
        } catch (Exception e) {
            e.printStackTrace();
            return CommonResult.fail("关闭订单失败"+e.getMessage());
        }
        return CommonResult.ok("关闭成功");
    }

    public void closeOrderById(String outTradeNo) throws Exception{

        CloseOrderRequest closeOrderRequest = new CloseOrderRequest();
        // 调用request.setXxx(val)设置所需参数，具体参数可见Request定义
        closeOrderRequest.setMchid(wxPayV3Config.getMchId());
        closeOrderRequest.setOutTradeNo(outTradeNo);
        // 调用接口
//        JsapiService service = new JsapiService.Builder().config(config).build();
        log.info("微信支付关闭订单入参："+closeOrderRequest.toString());
        Config config =
                new RSAAutoCertificateConfig.Builder()
                        .merchantId( wxPayV3Config.getMchId())
                        .privateKeyFromPath(wxPayV3Config.getKeyPath())
                        .merchantSerialNumber(wxPayV3Config.getSerialNum())
                        .apiV3Key(wxPayV3Config.getApiKey3())
                        .build();
        JsapiServiceExtension  service =new JsapiServiceExtension.Builder()
                .config(config)
                .signType("RSA") // 不填默认为RSA
                .build();
        service.closeOrder(closeOrderRequest);
    }
    /**
     * 支付成功后回调,推送消息给商家
     *
     * @param request  请求参数
     * @param response 响应参数
     * @throws Exception
     */
    @Override
    @Transactional(rollbackFor = {Exception.class})
    @PassToken
    public void returnPay(HttpServletRequest request, HttpServletResponse response) throws Exception {
        System.out.println(TimeExchange.getTime() + "进入支付回调====");
        // 构造 RequestParam
        String readData = PayUtil.readData(request);
        RequestParam requestParam = new RequestParam.Builder()
                .serialNumber(request.getHeader("Wechatpay-Serial"))
                .nonce(request.getHeader("Wechatpay-Nonce"))
                .signature(request.getHeader("Wechatpay-Signature"))
                .timestamp(request.getHeader("Wechatpay-Timestamp"))
                .body(readData)
                .build();
        NotificationConfig config = new RSAAutoCertificateConfig.Builder()
                .merchantId(wxPayV3Config.getMchId())
                .privateKeyFromPath(wxPayV3Config.getKeyPath())
                .merchantSerialNumber(wxPayV3Config.getSerialNum())
                .apiV3Key(wxPayV3Config.getApiKey3())
                .build();
//         初始化 NotificationParser
        NotificationParser parser = new NotificationParser((NotificationConfig) config);
        try {
            // 以支付通知回调为例，验签、解密并转换成 Transaction
            Transaction transaction = parser.parse(requestParam, Transaction.class);
            PayRecord payRecord=payRecordService.getOne(new QueryWrapper<PayRecord>().eq("pay_no",transaction.getOutTradeNo()));
            HouseOrder one = houseOrderService.getById(payRecord.getHouseOrderId());
            switch (transaction.getTradeState()){
                case SUCCESS:
                    payRecord.setIsSuccess(2);
                    payRecord.setRemark(transaction.getTradeStateDesc());
                    one.setOrderStatus("2");
                    break;
                case PAYERROR:
                    payRecord.setRemark(transaction.getTradeStateDesc());
                    payRecord.setIsSuccess(3);
                    break;
                default:
                    payRecord.setRemark(transaction.getTradeStateDesc());
                    break;
            }
            boolean a=houseOrderService.updateById(one);
            boolean b=payRecordService.updateById(payRecord);
            if (!a||!b){
                throw new Exception("更新支付状态失败");
            }
            log.info("支付回调请求返回"+transaction.toString());
            //回调成功业务没写
        } catch (Exception e) {
            // 签名验证失败，返回 401 UNAUTHORIZED 状态码
            log.error("支付回调请求失败", e);
        }
        Map<String, String> map = new HashMap<>();
        boolean isHandleSuccess = true;
// 如果处理失败，应返回 4xx/5xx 的状态码，例如 500 INTERNAL_SERVER_ERROR
        if (isHandleSuccess) {
            response.setStatus(200);
            map.put("code", "SUCCESS");
            map.put("message", "SUCCESS");
        } else {
            response.setStatus(500);
            map.put("code", "ERROR");
            map.put("message", "签名错误");
        }

// 处理成功，返回 200 OK 状态码
//        response.setHeader("Content-type", "application/json");
//        ObjectMapper mapper = new ObjectMapper();
//        response.getOutputStream().write(mapper.writeValueAsString(map).getBytes(StandardCharsets.UTF_8));
//        response.flushBuffer();
//
//        String inputLine = "";
//        String notityXml = "";
//        try {
//
//            String timestamp = request.getHeader("Wechatpay-Timestamp");
//            String nonce = request.getHeader("Wechatpay-Nonce");
//            String serialNo = request.getHeader("Wechatpay-Serial");
//            String signature = request.getHeader("Wechatpay-Signature");
//
//            // 通知密文
//            String result = PayUtil.readData(request);
//
//            // 需要通过证书序列号查找对应的证书，verifyNotify 中有验证证书的序列号，获取通知明文
//            String plainText = WechatPayV3Util.verifyNotify(serialNo, result, signature, nonce, timestamp,
//                    wxPayV3Config.getApiKey3(), wxPayV3Config.getPlatformCertPath());
//
//
//            log.info("微信支付异步通知：【{}】", plainText);
//
//            while ((inputLine = request.getReader().readLine()) != null) {
//                notityXml += inputLine;
//            }
//            //关闭流
//            request.getReader().close();
//            System.out.println("微信回调内容信息：" + notityXml);
//            //解析成json
//            JSONObject data = JSONObject.parseObject(notityXml);
//            //判断 支付是否成功
//            if ("TRANSACTION.SUCCESS".equals(data.get("event_type"))) {
//
//                // 在这里处理接收到的支付结果通知数据
//                Map<String, Object> resourceMap = handlePaymentNotification(data);
//
//                // 获取 trade_state 值
//                String tradeState = resourceMap.get("trade_state").toString();
//                if (tradeState.equals("SUCCESS")) {
//                    // 获取 amount 字段
//                    Map<String, Object> amountMap = (Map<String, Object>) resourceMap.get("amount");
//                    //获得 返回的商户订单号
//                    String outTradeNo = resourceMap.get("out_trade_no").toString();
////                    微信支付订单号
//                    String transactionId = resourceMap.get("transaction_id").toString();
//
//                    String attach = resourceMap.get("attach").toString();
//                    String total_fee = amountMap.get("payer_total").toString();
//                    //业务逻辑------------
//                    LambdaQueryWrapper<HouseOrder> wrapperHo = new LambdaQueryWrapper<>();
//                    wrapperHo.eq(HouseOrder::getHouseOrderNumber, outTradeNo);
//                    HouseOrder rr = houseOrderService.getOne(wrapperHo);
//                    if (ObjectUtils.isNotEmpty(rr)) {
//                        LambdaQueryWrapper<PayRecord> wrapperPr = new LambdaQueryWrapper<>();
//                        wrapperPr.eq(PayRecord::getHouseOrderId, rr.getId());
//                        PayRecord rpr = payRecordService.getOne(wrapperPr);
//                        if (rpr == null) {
//                            // 保存支付信息
//                            rpr = new PayRecord();
//                            rpr.setHouseOrderId(rr.getId());
//                            rpr.setUserId(Integer.valueOf(rr.getReserveUserId()));
//                            rpr.setPayNo(transactionId);
//                            System.out.println("回调的金额：" + total_fee);
//                            rpr.setPayPrice(new BigDecimal(total_fee).divide(new BigDecimal("100")).setScale(2));
//                            rpr.setIsSuccess(ePayStatu.Paysuccess.getValue());
//                            rpr.setRemark("微信支付支付成功");
//                            Boolean insertRpr = payRecordService.save(rpr);
//                            if (!insertRpr) {
//                                response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
//                                JSONObject jsonObject = new JSONObject();
//                                jsonObject.put("code", "FAIL");
//                                jsonObject.put("message", "失败");
//                                response.getWriter().write(jsonObject.toJSONString());
//                            }
//
//                        } else if (rpr.getIsSuccess() != ePayStatu.Paysuccess.getValue()) {
//                            rpr.setPayNo(transactionId);
//                            System.out.println("回调的金额：" + total_fee);
//                            rpr.setPayPrice(new BigDecimal(total_fee).divide(new BigDecimal("100")).setScale(2));
//                            rpr.setIsSuccess(ePayStatu.Paysuccess.getValue());
//                            rpr.setRemark(rpr.getRemark() + "微信支付支付成功");
//                            Boolean updateRpr = payRecordService.updateById(rpr);
//                            if (!updateRpr) {
//                                response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
//                                JSONObject jsonObject = new JSONObject();
//                                jsonObject.put("code", "FAIL");
//                                jsonObject.put("message", "失败");
//                                response.getWriter().write(jsonObject.toJSONString());
//                            }
//                        }
//
//                    }
//
//                    // 返回成功响应
//                    rr.setOrderStatus("2");
////                    支付时间
//                    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
//                    rr.setPayTime(LocalDateTime.now().format(dateTimeFormatter));
////                    支付渠道
//                    rr.setOrderChannel("1");
////                    支付人
//                    rr.setPayUserId(rr.getReserveUserId());
//                    Boolean updateHouseOrder = houseOrderService.updateById(rr);
//                    if (!updateHouseOrder) {
//                        response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
//                        JSONObject jsonObject = new JSONObject();
//                        jsonObject.put("code", "FAIL");
//                        jsonObject.put("message", "失败");
//                        response.getWriter().write(jsonObject.toJSONString());
//                    }
//
//                    response.setStatus(HttpServletResponse.SC_OK);
//                    response.getWriter().write("OK");
//
//                } else {
//                    response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
//                    JSONObject jsonObject = new JSONObject();
//                    jsonObject.put("code", "FAIL");
//                    jsonObject.put("message", "失败");
//                    response.getWriter().write(jsonObject.toJSONString());
//                }
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//            response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
//            JSONObject jsonObject = new JSONObject();
//            jsonObject.put("code", "FAIL");
//            jsonObject.put("message", "失败");
//            response.getWriter().write(jsonObject.toJSONString());
//        }


    }

    private Map<String, Object> handlePaymentNotification(JSONObject data) {
        System.out.println("进入解析resource：" + data.toString());
        Map<String, Object> resourceMap = null;
        // 在这里解析和处理接收到的支付结果通知数据
        System.out.println("接收到支付结果通知：" + data.toJSONString());
        //解密resource中的通知数据
        String resource = data.get("resource").toString();

        resourceMap = WechatPayApiV3Util.decryptFromResource(resource, "e10adc3949ba59abbe56e057f20f883e", 1);
        System.out.println("解析resource结果：" + resourceMap);
        return resourceMap;
    }


    @Override
    @Transactional(rollbackFor = Exception.class)
    public CommonResult checkOutApplet(CheckOutAppletDto checkOutAppletDto) {

        String houseNumberId = checkOutAppletDto.getHouseNumberId();
        String orderNumber = checkOutAppletDto.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("该时间段已超过退房时间，已修改其订单状态");
            }
//            }


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

            //      获取水电消费金额和额度
            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);

            }


//        修改房态

            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);
            houseNumberService.updateById(houseNumber);

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


    @Override
    @Transactional(rollbackFor = Exception.class)
    public CommonResult cancelApplet(CancelAppletDto cancelAppletDto) {
        String houseNumberId = cancelAppletDto.getHouseNumberId();
        String orderNumber = cancelAppletDto.getOrderNumber();
        int usersId = cancelAppletDto.getUsersId();

        if (ObjectUtils.isEmpty(houseNumberId) && ObjectUtils.isEmpty(orderNumber) && ObjectUtils.isEmpty(usersId) && usersId > 0) {
            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 {
            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()));
            // 修改订单状态
//            houseOrder.setOrderStatus("9");
            //  设置取消时间
            houseOrder.setCancelTime(new Date());

            //现金支付直接修改未已退款
            if("2".equals(houseOrder.getPayType())){
                houseOrder.setOrderStatus("9");
                houseOrderService.updateById(houseOrder);
                houseNumberStateService.removeById(houseNumberState);
                return CommonResult.ok("现金支付订单取消成功");
            }
            String orderStatus = houseOrder.getOrderStatus();
            //        判断是否付款，已支付则是退款，未支付则是取消

            if ("2".equals(orderStatus) || "3".equals(orderStatus)) {
                //        退款订单号
                String refund_no = UUID.randomUUID().toString();
                refund_no = "R" + refund_no.replace("-", "");

                //查看该订单是否退款过
                LambdaQueryWrapper<RefundRecord> wrapperRr = new LambdaQueryWrapper<>();
                wrapperRr.eq(RefundRecord::getHouseOrderId, houseOrder.getId());
                RefundRecord refundRecord = refundRecordService.getOne(wrapperRr);


//            待支付，带入住
//           todo 需退款
                System.out.println("退款");

                //返回0表示等于0，返回1表示大于0，返回-1表示小于0
                if (houseOrder.getPayPrice().compareTo(BigDecimal.ZERO) < 0 || houseOrder.getPayPrice().compareTo(BigDecimal.ZERO) == 0) {
//                    退款时间
                    houseOrder.setRefundTime(new Date());
                    if (refundRecord == null) {
                        RefundRecord rr = new RefundRecord();
                        rr.setHouseOrderId(houseOrder.getId());
                        rr.setUserId(usersId);
                        rr.setRefundPrice(BigDecimal.ZERO);
                        rr.setIsSuccess(1);
                        rr.setRemark("退款金额为0，不用走微信退款");
                        boolean save = refundRecordService.save(rr);
                        if (!save) {
                            throw new Exception("退款失败！");
                        }
                    } else {
                        refundRecord.setRemark(refundRecord.getRemark() + "后续支付：退款金额为0，不用走微信退款");
                        refundRecord.setRefundPrice(BigDecimal.ZERO);
                        refundRecord.setIsSuccess(1);
                        boolean update = refundRecordService.updateById(refundRecord);
                        if (!update) {
                            throw new Exception("退款失败！");
                        }
                    }
                }else {
//                    当有金额需要退款时，状态不变，等收到回调后在改变
                    houseOrder.setOrderStatus(houseOrder.getOrderStatus());
                    PayRecord payRecord= payRecordService.getOne(new QueryWrapper<PayRecord>().eq("house_order_id", houseOrder.getId()));

                    JSONObject jsonObject = new JSONObject();
                    //商户订单号;
                    jsonObject.put("out_trade_no", payRecord.getPayNo()==null?orderNumber:payRecord.getPayNo());
                    //商户退款单号
                    jsonObject.put("out_refund_no", refund_no);
//退款原因
                    jsonObject.put("reason", "取消入住");
//                退款结果回调url todo
                    jsonObject.put("notify_url", wxPayV3Config.getDomain()+"/auto/house-order/returnRefund");
//              订单金额信息
                    JSONObject amount = new JSONObject();
//                退款金额
                    int total = houseOrder.getPayPrice().multiply(new BigDecimal(100)).intValue();
                    amount.put("refund", total);
//                原订单金额
                    amount.put("total", total);
                    amount.put("currency", "CNY");

                    jsonObject.put("amount", amount);
                    RestTemplate client = new RestTemplate();
                    HttpHeaders httpHeaders = new HttpHeaders();
                    // 签名，获取authStr
                    String authStr = WechatPayV3Util.buildAuthorization(HttpMethod.POST,
                            "/v3/refund/domestic/refunds",
                            wxPayV3Config.getMchId(),
                            wxPayV3Config.getSerialNum(),
                            wxPayV3Config.getKeyPath(),
                            JSONObject.toJSONString(jsonObject));
                    log.info("退款签名值"+authStr);
                    httpHeaders.add("Accept", "application/json");
                    httpHeaders.add("Authorization", authStr);
//                    httpHeaders.add("User-Agent", "WeChatPay-HttpClient/null (Windows 10/10.0) Java/1.8.0_171");
                    httpHeaders.add("Content-Type", "application/json");
                    HttpEntity<JSONObject> fromEntity = new HttpEntity<>(jsonObject, httpHeaders);
                    log.info("退款请求入参"+fromEntity.toString());
                    String msg = client.postForObject("https://api.mch.weixin.qq.com/v3/refund/domestic/refunds", fromEntity, String.class);
                    log.info("退款请求出参"+msg);

                    JSONObject h5Refund = JSONObject.parseObject(msg);

                    System.out.println(TimeExchange.getTime() + "微信退款返回的信息：" + h5Refund);

                    houseOrderService.updateById(houseOrder);
                    houseNumberStateService.updateById(houseNumberState);
                    return CommonResult.ok(h5Refund);
                }
            }
            houseOrder.setOrderStatus("9");
            houseOrderService.updateById(houseOrder);
//            houseNumberStateService.updateById(houseNumberState);
            houseNumberStateService.removeById(houseNumberState);
            return CommonResult.ok();

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

    @Override
    public void returnRefund(HttpServletRequest request, HttpServletResponse response) throws Exception {
        String inputLine = "";
        String notityXml = "";
        String timestamp = request.getHeader("Wechatpay-Timestamp");
        String nonce = request.getHeader("Wechatpay-Nonce");
        String serialNo = request.getHeader("Wechatpay-Serial");
        String signature = request.getHeader("Wechatpay-Signature");
        try {
            while ((inputLine = request.getReader().readLine()) != null) {
                notityXml += inputLine;
            }
            //关闭流
            request.getReader().close();
            //解析成json
            JSONObject data = JSONObject.parseObject(notityXml);
            //判断 支付是否成功
            log.info("退款回调入参"+timestamp+"==="+nonce+"===="+serialNo+"======"+signature+"======="+notityXml);
            if ("REFUND.SUCCESS".equals(data.get("event_type"))) {

                String plainText = WechatPayV3Util.verifyNotify(serialNo, notityXml, signature, nonce, timestamp,
                        wxPayV3Config.getApiKey3(), wxPayV3Config.getPlatformCertPath());
                log.info("退款回调明文"+plainText);
                // 在这里处理接收到的支付结果通知数据
                JSONObject resourceMap = JSONObject.parseObject(plainText);
                // 获取 trade_state 值
                String tradeState = resourceMap.get("refund_status").toString();
                if (tradeState.equals("SUCCESS")) {

                    // 获取 amount 字段
                    Map<String, Object> amountMap = (Map<String, Object>) resourceMap.get("amount");
                    //获得 返回的商户订单号
                    String outTradeNo = resourceMap.get("out_trade_no").toString();
//                    微信支付订单号
                    String transactionId = resourceMap.get("transaction_id").toString();
//                    商户退款单号
                    String outRefundNo = resourceMap.get("out_refund_no").toString();
//                    微信支付退款单号
                    String refundId = resourceMap.get("refund_id").toString();
//                    退款成功时间
                    String success_time = resourceMap.get("success_time").toString();

//                    用户退款金额
                    String total_fee = amountMap.get("payer_refund").toString();
                    //业务逻辑------------
                    LambdaQueryWrapper<HouseOrder> wrapperHo = new LambdaQueryWrapper<>();
                    wrapperHo.eq(HouseOrder::getOrderNumber, outTradeNo);
                    HouseOrder rr = houseOrderService.getOne(wrapperHo);
                    if (ObjectUtils.isNotEmpty(rr)) {
                        LambdaQueryWrapper<RefundRecord> wrapperRr = new LambdaQueryWrapper<>();
                        wrapperRr.eq(RefundRecord::getHouseOrderId, rr.getId());
                        RefundRecord rpr = refundRecordService.getOne(wrapperRr);
                        if (rpr == null) {
                            // 保存支付信息
                            rpr = new RefundRecord();
                            rpr.setHouseOrderId(rr.getId());
                            rpr.setUserId(Integer.valueOf(rr.getReserveUserId()));
                            rpr.setWxNo(outRefundNo);
                            rpr.setRefundNo(refundId);
                            System.out.println("回调的金额：" + total_fee);
                            rpr.setRefundPrice(new BigDecimal(total_fee).divide(new BigDecimal("100")).setScale(2));
                            rpr.setIsSuccess(1);
                            rpr.setRemark("微信支付退款成功");
                            Boolean insertRpr = refundRecordService.save(rpr);
                            if (!insertRpr) {
                                response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                                JSONObject jsonObject = new JSONObject();
                                jsonObject.put("code", "FAIL");
                                jsonObject.put("message", "失败");
                                response.getWriter().write(jsonObject.toJSONString());
                            }

                        } else if (rpr.getIsSuccess() != ePayStatu.Paysuccess.getValue()) {
                            rpr.setWxNo(outRefundNo);
                            rpr.setRefundNo(refundId);
                            System.out.println("回调的金额：" + total_fee);
                            rpr.setRefundPrice(new BigDecimal(total_fee).divide(new BigDecimal("100")).setScale(2));
                            rpr.setIsSuccess(1);
                            rpr.setRemark("微信支付退款成功");
                            Boolean updateRpr = refundRecordService.updateById(rpr);
                            if (!updateRpr) {
                                response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                                JSONObject jsonObject = new JSONObject();
                                jsonObject.put("code", "FAIL");
                                jsonObject.put("message", "失败");
                                response.getWriter().write(jsonObject.toJSONString());
                            }
                        }

                    }

                    // 订单状态
                    rr.setOrderStatus("9");
//                    退款时间
                    rr.setRefundTime(new Date());

                    Boolean updateHouseOrder = houseOrderService.updateById(rr);
                    if (!updateHouseOrder) {
                        response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                        JSONObject jsonObject = new JSONObject();
                        jsonObject.put("code", "FAIL");
                        jsonObject.put("message", "失败");
                        response.getWriter().write(jsonObject.toJSONString());
                    }

                    response.setStatus(HttpServletResponse.SC_OK);
                    JSONObject jsonObject = new JSONObject();
                    jsonObject.put("code", "SUCCESS");
                    jsonObject.put("message", "SUCCESS");
                    response.getWriter().write(jsonObject.toJSONString());


                } else {
                    response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                    JSONObject jsonObject = new JSONObject();
                    jsonObject.put("code", "FAIL");
                    jsonObject.put("message", "失败");
                    response.getWriter().write(jsonObject.toJSONString());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
//            response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
//            JSONObject jsonObject = new JSONObject();
//            jsonObject.put("code", "FAIL");
//            jsonObject.put("message", "失败");
//            response.getWriter().write(jsonObject.toJSONString());
            response.setStatus(HttpServletResponse.SC_OK);
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("code", "SUCCESS");
            jsonObject.put("message", "SUCCESS");
            response.getWriter().write(jsonObject.toJSONString());
        }


    }

    @Override
    public CommonResult payOrderPrice(HouseOrderPriceDto houseOrderPriceDto) {
        Double price = houseOrderPriceDto.getPrice();
        String payType =houseOrderPriceDto.getPayType()+"";
        if (price<=0) {
            return CommonResult.fail("金额异常");
        }
        if(!StringUtils.hasText(payType)){
            return CommonResult.fail("支付类型异常");
        }

        String orderNumber = houseOrderPriceDto.getOrderNumber();

        LambdaQueryWrapper<HouseOrder> wrapper=new LambdaQueryWrapper<>();
        wrapper.eq(HouseOrder::getOrderNumber,orderNumber);
        HouseOrder one = houseOrderService.getOne(wrapper);
        one.setPayPrice(BigDecimal.valueOf(price));
        one.setPayType(payType);
        if(!"1".equals(one.getOrderStatus())){
            return CommonResult.fail("订单状态不为待支付");
        }
        //查询是否有未支付订单，有则调用关闭更新支付订单号重新生成支付订单
        List<PayRecord> houseOrderId = payRecordService.list(new QueryWrapper<PayRecord>().eq("house_order_id", one.getId()));
        //现金支付流程
        if("2".equals(payType)){
            if(houseOrderId.size()>0){
                try {
                    this.closeOrderById(houseOrderId.get(0).getPayNo());
                } catch (Exception e) {
                    return CommonResult.fail("关闭已生成支付订单失败返回，请查询订单支付状态:"+e.getMessage());
                }
            }
            one.setOrderStatus("2");
            boolean oneFlag=houseOrderService.updateById(one);
            if(!oneFlag){
                return CommonResult.fail("订单现金支付失败");
            }
            return CommonResult.ok("订单现金支付完成");
        }
        boolean oneFlag=houseOrderService.updateById(one);
        if(!oneFlag){
            return CommonResult.fail("订单价格修改失败");
        }
        PayRecord payRecord=houseOrderId.size()>0?houseOrderId.get(0):new PayRecord();
        if (StringUtils.hasText(payRecord.getPayNo())){
            try {
                this.closeOrderById(payRecord.getPayNo());
            } catch (Exception e) {
                return CommonResult.fail("关闭已生成支付订单失败返回:"+e.getMessage());
            }
            payRecord.setPayNo(CommonUtil.generateUUID());
            payRecord.setRemark("更新订单");
            payRecordService.updateById(payRecord);
        }else{
            payRecord.setPayNo(CommonUtil.generateUUID());
            payRecord.setHouseOrderId(one.getId());
            payRecord.setUserId(StringUtils.hasText(one.getPayUserId())?Integer.valueOf(one.getPayUserId()):0);
            payRecord.setPayPrice(BigDecimal.valueOf(price));
            payRecord.setIsSuccess(1);
            payRecord.setRemark("新订单");
            payRecordService.save(payRecord);
        }
        Config config =
                new RSAAutoCertificateConfig.Builder()
                        .merchantId(wxPayV3Config.getMchId())
                        .privateKeyFromPath(wxPayV3Config.getKeyPath())
                        .merchantSerialNumber(wxPayV3Config.getSerialNum())
                        .apiV3Key(wxPayV3Config.getApiKey3())
                        .build();
        // 构建service
        NativePayService service = new NativePayService.Builder().config(config).build();
        // request.setXxx(val)设置所需参数，具体参数可见Request定义
        com.wechat.pay.java.service.payments.nativepay.model.PrepayRequest request = new com.wechat.pay.java.service.payments.nativepay.model.PrepayRequest();
        com.wechat.pay.java.service.payments.nativepay.model.Amount amount = new com.wechat.pay.java.service.payments.nativepay.model.Amount();
        request.setAppid(wxPayV3Config.getAppId());
        request.setMchid(wxPayV3Config.getMchId());
        request.setDescription("测试商品标题");
        amount.setTotal((int) (price*100));
        request.setAmount(amount);
        request.setOutTradeNo(payRecord.getPayNo());
        request.setNotifyUrl(wxPayV3Config.getDomain()+"/auto/house-order/returnPay");
        // 调用下单方法，得到应答
        com.wechat.pay.java.service.payments.nativepay.model.PrepayResponse response = null;
        try {
            response = service.prepay(request);
            log.info("CodeUrl()========"+response.getCodeUrl());
        } catch (Exception e) {
            e.printStackTrace();
            return CommonResult.fail(e.getMessage());
        }
        return CommonResult.ok(response);
    }

    public static void main(String[] args) throws Exception {
//        获取签名
        //        随机字符串
        String nonceStr = WxUtil.getWxNonceStr();
        // 时间戳
        long timestamp = System.currentTimeMillis() / 1000;
//        构造签名串
        String qmc="GET"+"\n"
                +"/v3/pay/transactions/h5"+"\n"
                +timestamp+"\n"
                +nonceStr+"\n"
                ;
//      使用商户私钥对待签名串进行SHA256 with RSA签名，并对签名结果进行Base64编码得到签名值
        Signature sign = Signature.getInstance("SHA256withRSA");
//        sign.initSign(privateKey);
        sign.update(qmc.getBytes());
        String signature = RSATest.sign("KReLfbAgGZKc3slfEW9Jnhn7RLKqyrGF", qmc);
        System.out.println("signature = " + signature);



    }




    /**
     * 每天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<>();
            if (ObjectUtils.isNotEmpty(list) && list.size() > 0) {
                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();
        }

    }

}