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.sun.org.apache.bcel.internal.generic.NEW;
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.*;
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 com.wechat.pay.java.service.refund.RefundService;
import com.wechat.pay.java.service.refund.model.QueryByOutRefundNoRequest;
import com.wechat.pay.java.service.refund.model.Refund;
import io.swagger.annotations.ApiModelProperty;
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.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.format.TextStyle;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;

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;

    @Autowired
    SubsidySetupService subsidySetupService;

    @Autowired
    ApartmentSettingService apartmentSettingService;

    @Autowired
    BlacklistOrderService blacklistOrderService;

    @Autowired
    BlacklistService blacklistService;

    @Autowired
    BlacklistSettingService blacklistSettingService;

    @Autowired
    ApplicationProcedureTemporaryService applicationProcedureTemporaryService;

    @Autowired
    HouseOrderBillService houseOrderBillService;

    @Override
    public CommonResult getHouseOrderPrice(int houseOrderNumber, String userId, String houseId, String liveTime, String leaveTime, Integer source) {
        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("无此房间，请重新查询");
        }

        //        判断传过来的时间和当前时间比较
        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime now = LocalDateTime.now();
        LocalDateTime date = LocalDateTime.parse(liveTime, dateTimeFormatter1);
        if (now.isAfter(date)) {
            liveTime = now.format(dateTimeFormatter1);
//            establishOrderDto.setReserveLiveTime(reserveLeaveTime);
        }
//        计算总金额
        BigDecimal totalPrice = houseOrderService.getHouseOrderPrice(houseOrderNumber, userId, houseId, liveTime, leaveTime, source);

        return CommonResult.ok(totalPrice);

    }


    @Override
    @Transactional(rollbackFor = Exception.class)//1
    public CommonResult establishOrder(EstablishOrderDto establishOrderDto) {
        if (ObjectUtils.isEmpty(establishOrderDto)) {
            return CommonResult.fail();
        }
        //        判断传过来的时间和当前时间比较
        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

//        需判断当前用户是能定这时间段的房
        String reserveLiveTime = establishOrderDto.getReserveLiveTime();
        System.out.println("reserveLiveTime = " + reserveLiveTime);
        String reserveLeaveTime = establishOrderDto.getReserveLeaveTime();
        System.out.println("reserveLeaveTime = " + reserveLeaveTime);
        Integer source = establishOrderDto.getSource();


//        判断课表,临时人员


        String userId = establishOrderDto.getUserId();

        String houseId = establishOrderDto.getHouseId();

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

//        计算总金额
        BigDecimal totalPrice = houseOrderService.getHouseOrderPrice(establishOrderDto.getHouseOrderNumber(), userId, houseId, establishOrderDto.getReserveLiveTime(), establishOrderDto.getReserveLeaveTime(), source);
        double v = totalPrice.doubleValue();
        Integer roomType = house.getRoomType();
//        当金额不是0时,则判断时间是否为当天
        if (roomType == 1) {

            if (v > 0) {
//                判断是否到13点了
                LocalDateTime now = LocalDateTime.now();
                LocalDateTime localDateTime = now.withHour(13).withMinute(0).withSecond(0);
                if (now.isBefore(localDateTime)) {
                    return CommonResult.fail("未到预定时间");
                }

                LocalDateTime start = now.withHour(0).withMinute(0).withSecond(0);
                LocalDateTime end = start.plusDays(1);
                LocalDateTime end2 = start.plusDays(2);
//            预定时间在start和end之前,离店时间在
                LocalDateTime time = LocalDateTime.parse(reserveLiveTime, dateTimeFormatter1);
                LocalDateTime time2 = LocalDateTime.parse(reserveLeaveTime, dateTimeFormatter1);

                if (!(time.isAfter(start) && time.isBefore(end) && time2.isAfter(end) && time2.isBefore(end2))) {
                    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;
            }
        }


        LocalDateTime now = LocalDateTime.now();
        LocalDateTime date = LocalDateTime.parse(reserveLiveTime, dateTimeFormatter1);
        if (now.isAfter(date)) {
            reserveLiveTime = now.format(dateTimeFormatter1);
//            establishOrderDto.setReserveLiveTime(reserveLeaveTime);
        }

//        获取该时间段内的所有使用的房间
        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 payPrice = establishOrderDto.getPayPrice();
//        返回的结果是int类型,-1表示小于，0是等于，1是大于。
        if (payPrice.compareTo(totalPrice) != 0) {
            return CommonResult.fail("需付金额异常");
        }
//        订单号
//        String orderNumber = UUID.randomUUID().toString();
//        orderNumber = orderNumber.replace("-", "");
        String orderNumber = OrderNumber.getOrderNumber();
        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);
//                LocalDateTime end = LocalDateTime.parse(reserveLeaveTime, dateTimeFormatter1);
//                String startTime = start.format(dateTimeFormatter1);
//                String endTime = end.format(dateTimeFormatter1);
                houseNumberState.setStartTime(reserveLiveTime);
                houseNumberState.setEndTime(reserveLeaveTime);
            } else {
                houseNumberState.setStartTime(establishOrderDto.getReserveLiveTime());
                houseNumberState.setEndTime(reserveLeaveTime);
            }


            houseNumberState.setOrderNumber(orderNumber);
            houseNumberStates.add(houseNumberState);
        }
//        待支付
        houseOrder.setOrderStatus("1");
//        房态id
        houseOrder.setHouseId(houseId);
//        房间号id(可多个房间id)
        houseOrder.setHouseNumberId(houseNumberIds);
        Users users = usersService.getById(userId);
        if (ObjectUtils.isNotEmpty(users)) {
            //        预定人姓名
            houseOrder.setReserveName(users.getUserName());
            log.info("预定人姓名：" + users.getUserName());
//        预定人电话号码
            houseOrder.setReservePhone(users.getPhone());
            log.info("预定人手机号码：" + users.getPhone());
        } else {
            //        预定人姓名
            houseOrder.setReserveName(establishOrderDto.getReserveName());
            log.info("预定人姓名：" + establishOrderDto.getReserveName());
//        预定人电话号码
            houseOrder.setReservePhone(establishOrderDto.getReservePhone());
            log.info("预定人手机号码：" + establishOrderDto.getReservePhone());
        }
//        预定入住时间
        houseOrder.setReserveLiveTime(reserveLiveTime);
//        预定离开时间
        houseOrder.setReserveLeaveTime(reserveLeaveTime);
//        超时时间
        String timeOut = now.plusMinutes(2).format(dateTimeFormatter1);
        houseOrder.setTimeOut(timeOut);

        houseOrder.setSource(source);
        houseOrder.setSourceId(establishOrderDto.getSourceId());


//    单价   全日房  价格单价=总价/房间数/天数
//       钟点房  价格单价=总价/房间数
//        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");

        houseOrderService.save(houseOrder);
        houseNumberStateService.saveBatch(houseNumberStates);
//            houseNumberService.updateBatchById(houseNumbers);
        System.out.println("创建订单成功");
        return CommonResult.ok(houseOrder);


    }

    @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)//1
    public CommonResult checkIn(String houseOrderId, String userId) {
        if (ObjectUtils.isEmpty(houseOrderId)) {
            return CommonResult.fail();
        }
        Users users = usersService.getById(userId);
        if (ObjectUtils.isEmpty(users)) {
            return CommonResult.fail("用户不存在");
        }
        String department = users.getDepartment();
        if (!"4".equals(department)) {
            return CommonResult.fail("请前往前台办理入住");
        }

        HouseOrder houseOrder = houseOrderService.getById(houseOrderId);

//        判断当然时间是否在入住时间内。是的话则可以入住
        //        判断传过来的时间和当前时间比较
        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime now = LocalDateTime.now();
        String reserveLiveTime = houseOrder.getReserveLiveTime();
        LocalDateTime date2 = LocalDateTime.parse(reserveLiveTime, dateTimeFormatter1);
        if (date2.isAfter(now)) {
            return CommonResult.fail("未到入住时间");
        }

        //        判断当然时间是否在入住时间内。是的话则可以入住
        String reserveLeaveTime = houseOrder.getReserveLeaveTime();
        LocalDateTime date3 = LocalDateTime.parse(reserveLeaveTime, dateTimeFormatter1);
        if (now.isAfter(date3)) {
            return CommonResult.fail("已超过入住时间，请前往前台办理");
        }


//      预定人就是入住人
        String reserveName = houseOrder.getReserveName();
        houseOrder.setLiveName(reserveName);

//      入住时间
        Date date = new Date();
        houseOrder.setLiveTime(date);
//      离店时间=预离店时间
//        String reserveLeaveTime = houseOrder.getReserveLeaveTime();
        Date leaveTime = Date.from(LocalDateTime.parse(reserveLeaveTime, dateTimeFormatter1).atZone(ZoneId.systemDefault()).toInstant());
//        houseOrder.setLiveTime(leaveTime);

//        需先获取所属房间号的门锁型号
        String houseNumberId = houseOrder.getHouseNumberId();
        HouseLock houseLock = houseLockService.getHouseNumberId(houseNumberId);
//        如果没有房锁则需要去前台
        if (ObjectUtils.isEmpty(houseLock)) {
            return CommonResult.fail("请前往前台办理入住,领取钥匙");
        }


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

//            设备id
        //      下发门锁密码
//                设备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();

        houseOrder.setKeyPassWord(passWord);
        houseOrder.setKeyType(1);

        //添加
        unlockingService.save(unlocking);

//                String password = "测试";
        Integer houseNumberId1 = houseLock.getHouseNumberId();
        HouseNumber houseNumber = houseNumberService.getById(houseNumberId1);
//                房间号
        String roomNumber = houseNumber.getRoomNumber();
//              获取工号
        String cardNumber = users.getCardNumber();
        if (ObjectUtils.isEmpty(cardNumber)) {
            return CommonResult.fail("无微校卡号");
        }
        log.info("微校卡号【{}】", cardNumber);
        ArrayList<String> strings = new ArrayList<>();
        strings.add(cardNumber);
        //        获取手机号,酒店名字
        List<ApartmentSetting> list2 = apartmentSettingService.list(new LambdaQueryWrapper<>());
        ApartmentSetting apartmentSetting = list2.get(0);
        String phoneNumber = apartmentSetting.getPhoneNumbr();
        String name = apartmentSetting.getName();
        weiXiaoComponent.sendNotice(strings, "公寓办理入住成功", "办理入住成功", "您的房间号为:" + roomNumber + ",密码是:" + passWord + "离店时间为:" + reserveLeaveTime + ",欢迎您入住" + name + "，我们全体员工很荣幸能为您服务，如有任何需要请致电:" + phoneNumber + "，期待为你服务。祝你生活愉快！", null);
//              添加锁的操作记录
        OperatingRecord operatingRecord = new OperatingRecord();
        operatingRecord.setRoomNumber(houseNumber.getRoomNumber());
        operatingRecord.setHouseNumberId(houseNumber.getId());
        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());
        String msg = "";
        if (!aBoolean) {
            msg = "开电失败";
              //               设置关电状态
            number.setElectricType("2");
        }else {
            //                设置开电状态
            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);
        if (msg.equals("")) {
            return CommonResult.ok();
        } else {
            return CommonResult.ok(msg);
        }


    }

    @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,
                                 String reserveLiveStartTime, String reserveLiveEndTime, String reserveLeaveStartTime, String reserveLeaveEndTime,
                                 String houseId, Integer keyType, Integer giveBack, Integer buildingId, Integer orgId) {
//        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,
                reserveLiveStartTime, reserveLiveEndTime, reserveLeaveStartTime, reserveLeaveEndTime, houseId, keyType, giveBack, buildingId, orgId);
        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);
            String[] arr=(houseOrderPageListVo.getSourceId()==null?"":houseOrderPageListVo.getSourceId()).split(",");
            ArrayList<String> idList = new ArrayList<String>(Arrays.asList(arr)) ;
            if(!StringUtils.hasText(houseOrderPageListVo.getSource())){
                houseOrderPageListVo.setSource("自费");
            }else if ("1".equals(houseOrderPageListVo.getSource())){
                houseOrderPageListVo.setSource("课表");
                List<ClassSchedule> schedules=new ArrayList<>(classScheduleService.listByIds(idList));
                houseOrderPageListVo.setSchedules(schedules);
            } else if ("2".equals(houseOrderPageListVo.getSource())){
                houseOrderPageListVo.setSource("流程");
                List<ApplicationProcedureTemporary> applicationProcedureTemporaries= new ArrayList<>(applicationProcedureTemporaryService.listByIds(idList));
                houseOrderPageListVo.setApplicationProcedureTemporaries(applicationProcedureTemporaries);
            }
        }
        pageList.setList(list);

        return CommonResult.ok(pageList);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)//1
    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();
        }


        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.getId());
        return CommonResult.ok();


    }

    @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("无该订单");
        }
        String liveUsersId = houseOrder.getLiveUsersId();
        HouseOrderParticularsVo vo = new HouseOrderParticularsVo();
        vo.setHouseOrder(houseOrder);
        if (ObjectUtils.isNotEmpty(liveUsersId)) {
            Users users = usersService.getById(liveUsersId);
            if (ObjectUtils.isNotEmpty(users)) {
//                指纹
                String fingerprint = users.getFingerprint();
                vo.setFingerprint(fingerprint);
//                卡号编码idCardInformation
                String idCardInformation = users.getIdCardInformation();
                vo.setIdCardInformation(idCardInformation);
            }
        }
        Unlocking unlocking = unlockingService.getOrderNumber(orderNumber);
        if (ObjectUtils.isNotEmpty(unlocking)) {
            vo.setStartTime(unlocking.getStartTime());
            vo.setEndTime(unlocking.getEndTime());
        }
        String houseNumberId = houseOrder.getHouseNumberId();
        HouseNumber houseNumber = houseNumberService.getById(houseNumberId);
        if (ObjectUtils.isNotEmpty(houseNumber)) {
            vo.setElectricEquipmentMeterName(houseNumber.getElectricEquipmentMeterName());
            vo.setWaterEquipmentMeterName(houseNumber.getWaterEquipmentMeterName());
        }
        SubsidySetup subsidySetup = subsidySetupService.list(new LambdaQueryWrapper<>()).get(0);
        if (ObjectUtils.isNotEmpty(subsidySetup)) {
            vo.setFreeQuotaOfWater(subsidySetup.getFreeQuotaOfWater());
            vo.setFreeQuotaOfElectric(subsidySetup.getFreeQuotaOfElectric());
        }


        return CommonResult.ok(vo);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)//1
    public CommonResult checkIdCard(CheckIdCardDto checkIdCardDto) {
        if (ObjectUtils.isEmpty(checkIdCardDto)) {
            return CommonResult.fail();
        }
        String adminMenuId = checkIdCardDto.getAdminMenuId();
        PermissionSetting permissionSetting = permissionSettingService.getById(adminMenuId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.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();


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

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

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

//            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.setFingerprint(fingerprint);
            users1.setIdCard(idCard);
            users1.setIdCardInformation(idCardInformation);
//                users1.setUserMenuId("4");
            boolean save = usersService.save(users1);
            houseOrder.setLiveUsersId(users1.getId() + "");
        } else {
            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);


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

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

        String roomNumber = houseNumber.getRoomNumber();
        String start = String.valueOf(liveDate.getTime());
        String end = String.valueOf(leaveDate.getTime());
//        发放密码
        Integer lockStatus = checkIdCardDto.getLockStatus();

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

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


        houseOrder.setKeyType(lockStatus);
        if (5 == lockStatus) {
//                默认未归还
            houseOrder.setGiveBack(2);
        } else {
            //        获取设备id
            LambdaQueryWrapper<HouseLock> wrapperHl = new LambdaQueryWrapper<>();
            wrapperHl.eq(HouseLock::getHouseNumberId, houseNumberId);
            HouseLock houseLock = houseLockService.getOne(wrapperHl);
            if (ObjectUtils.isEmpty(houseLock)) {
                return CommonResult.fail("请先绑定门锁设备");
            }
            String equipmentState = houseLock.getEquipmentType();

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

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

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

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

                //                添加锁的操作记录类型
                operatingRecord.setType("添加身份证钥匙");
            }
        }


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

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


    }

    @Override
    @Transactional(rollbackFor = Exception.class)//1
    public CommonResult checkOut(CheckOutDto checkOutDto) {
        int adminId = checkOutDto.getAdminId();
        PermissionSetting permissionSetting = permissionSettingService.getById(adminId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.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("无该订单");
        }

        houseOrder.setOrderStatus("8");


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

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

                Date liveTime = houseOrder.getLiveTime();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String live = sdf.format(liveTime);
                String leave = sdf.format(new Date());
//                获取电的消费金额和额度
                HouseOrderBill houseOrderBill = new HouseOrderBill();

                JSONObject jsonObjectElectric = electricEquipmentService.roomCostRecord(electricEquipmentRoomId, live, leave);
                BigDecimal costElectric = jsonObjectElectric.getBigDecimal("cost");
                BigDecimal consumeElectric = jsonObjectElectric.getBigDecimal("consume");
                houseOrderBill.setElectricCost(costElectric);
                houseOrderBill.setElectricConsume(consumeElectric);


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


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

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


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


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

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

//      修改订单
        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());
//                获取电的消费金额和额度
            HouseOrderBill houseOrderBill = new HouseOrderBill();

            JSONObject jsonObjectElectric = electricEquipmentService.roomCostRecord(electricEquipmentRoomId, live, leave);
            BigDecimal costElectric = jsonObjectElectric.getBigDecimal("cost");
            BigDecimal consumeElectric = jsonObjectElectric.getBigDecimal("consume");
            houseOrderBill.setElectricCost(costElectric);
            houseOrderBill.setElectricConsume(consumeElectric);


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


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

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


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

        }


//        修改房态

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

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

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

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

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

        return CommonResult.ok();


    }


    @Override
    @Transactional(rollbackFor = Exception.class)//1
    public CommonResult roomChange(RoomChangeDto roomChangeDto) {
        if (ObjectUtils.isEmpty(roomChangeDto)) {
            return CommonResult.fail();
        }
        int adminMenuId = roomChangeDto.getAdminMenuId();
        PermissionSetting permissionSetting = permissionSettingService.getById(adminMenuId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }
//      判断该用户是否拥有权限
        String houseTypeManagement = permissionSetting.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();
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = sdf.format(liveTime);
        String format1 = sdf.format(date);
        //      判断该房间在该订单的时间内是否有使用
        List<HouseNumberState> houseNumberStateList = houseNumberStateService.beBooked(houseNumberId, format1, houseOrder.getReserveLeaveTime());

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


//        修改订单
        houseOrder.setHouseNumberId(houseNumberId);
//        将换房当前时间改为入住时间
        houseOrder.setLiveTime(date);

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

            String live = sdf.format(liveTime);
            String leave = sdf.format(new Date());
//                获取电的消费金额和额度
            HouseOrderBill houseOrderBill = new HouseOrderBill();

            JSONObject jsonObjectElectric = electricEquipmentService.roomCostRecord(electricEquipmentRoomId, live, leave);
            BigDecimal costElectric = jsonObjectElectric.getBigDecimal("cost");
            BigDecimal consumeElectric = jsonObjectElectric.getBigDecimal("consume");
            houseOrderBill.setElectricCost(costElectric);
            houseOrderBill.setElectricConsume(consumeElectric);

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


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

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

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


        }

        houseOrderService.updateById(houseOrder);


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

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

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

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

        houseNumberService.updateById(houseNumber);

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

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

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

            OperatingRecord operatingRecord = new OperatingRecord();
            operatingRecord.setRoomNumber(houseNumber1.getRoomNumber());
            operatingRecord.setHouseNumberId(houseNumber1.getId());
            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 = "";
        if (ObjectUtils.isNotEmpty(houseLock)) {
            equipment = houseLock.getEquipmentType();
        }


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


        if (ObjectUtils.isNotEmpty(unlocking)) {

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

//             添加锁的操作记录
            OperatingRecord operatingRecord = new OperatingRecord();
            operatingRecord.setRoomNumber(houseNumber.getRoomNumber());
            operatingRecord.setHouseNumberId(houseNumber.getId());
            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);
        }
        if (msg.equals("")) {
            return CommonResult.ok();
        } else {
            return CommonResult.ok(msg);
        }

    }

    @Override
    public void 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,
                            String reserveLiveStartTime, String reserveLiveEndTime, String reserveLeaveStartTime, String reserveLeaveEndTime, String houseId, Integer keyType, Integer giveBack, Integer buildingId, Integer orgId) {
//        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, reserveLiveStartTime, reserveLiveEndTime, reserveLeaveStartTime, reserveLeaveEndTime, houseId, keyType, giveBack, buildingId, orgId);

        //        导出
        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("订单金额(元)");
        headerRow.createCell(15).setCellValue("订单状态");
        headerRow.createCell(16).setCellValue("备注");
        headerRow.createCell(17).setCellValue("支付类型");
        headerRow.createCell(18).setCellValue("来源渠道");
        headerRow.createCell(19).setCellValue("支付时间");
        headerRow.createCell(20).setCellValue("退款时间");
        headerRow.createCell(21).setCellValue("取消时间");
        headerRow.createCell(22).setCellValue("来源");
        headerRow.createCell(23).setCellValue("来源详情");

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        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.getHouseNumber());
                Integer roomType = vo.getRoomType();
                String houseSta = "";
                if (ObjectUtils.isNotEmpty(roomType)) {
                    if (2 == roomType) {
                        houseSta = "钟点房";
                    } else if (1 == roomType) {
                        houseSta = "全日房";
                    }
                }

                dataRow1.createCell(1).setCellValue(houseSta);
                dataRow1.createCell(2).setCellValue(vo.getHouseName());
                Integer lockStatus = vo.getLockStatus();
                String lockString = "";
                if (ObjectUtils.isNotEmpty(lockStatus)) {
                    if (1 == lockStatus) {
                        lockString = "密码开锁";
                    } else if (2 == lockStatus) {
                        lockString = "房卡开锁";
                    } else if (3 == lockStatus) {
                        lockString = "指纹开锁";
                    } else if (4 == lockStatus) {
                        lockString = "身份证开锁";
                    } else if (5 == lockStatus) {
                        lockString = "钥匙开锁";
                    }

                }
                dataRow1.createCell(3).setCellValue(lockString);
                Integer giveBack1 = vo.getGiveBack();
                String back = "";
                if (ObjectUtils.isNotEmpty(giveBack1)) {
                    if (1 == giveBack1) {
                        back = "已归还";
                    } else {
                        back = "未归还";
                    }
                }

                dataRow1.createCell(4).setCellValue(back);
                dataRow1.createCell(5).setCellValue(vo.getReserveName());
                dataRow1.createCell(6).setCellValue(vo.getPhone());
                dataRow1.createCell(7).setCellValue(vo.getLiveName());
                dataRow1.createCell(8).setCellValue(vo.getIdCard());
                dataRow1.createCell(9).setCellValue(vo.getOrgName());
                dataRow1.createCell(10).setCellValue(vo.getCardNumber());
                dataRow1.createCell(11).setCellValue(vo.getOrderNumber());
                dataRow1.createCell(12).setCellValue(vo.getLiveTime());
                dataRow1.createCell(13).setCellValue(vo.getLeaveTime());
                BigDecimal orderPrice = vo.getOrderPrice();
                String price = "";
                if (ObjectUtils.isNotEmpty(orderPrice)) {
                    price = orderPrice.toString();
                }
                dataRow1.createCell(14).setCellValue(price);

                //                订单 订单状态 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 = "已取消";
                } else if ("10".equals(orderStart)) {
                    orderName = "已支付未入住";
                }
                dataRow1.createCell(15).setCellValue(orderName);
                dataRow1.createCell(16).setCellValue(vo.getRemark());

                //                pay_type 支付方式（微信支付，现金）
                String payType = vo.getPayType();
                String payName = "";
                if ("1".equals(payType)) {
                    payName = "微信支付";
                } else if ("2".equals(payType)) {
                    payName = "现金";
                }
                dataRow1.createCell(17).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(18).setCellValue(orderChannelName);

                dataRow1.createCell(19).setCellValue(vo.getPayTime());
                Date refundTime = vo.getRefundTime();
                if (ObjectUtils.isEmpty(refundTime)) {
                    dataRow1.createCell(20).setCellValue(refundTime);
                } else {
                    dataRow1.createCell(20).setCellValue(sdf.format(vo.getRefundTime()));
                }
                Date cancelTime = vo.getCancelTime();
                if (ObjectUtils.isEmpty(cancelTime)) {
                    dataRow1.createCell(21).setCellValue(cancelTime);
                } else {
                    dataRow1.createCell(21).setCellValue(sdf.format(cancelTime));
                }
                String[] arr=(vo.getSourceId()==null?"":vo.getSourceId()).split(",");
                ArrayList<String> idList = new ArrayList<String>(Arrays.asList(arr)) ;
                if(!StringUtils.hasText(vo.getSource())){
                    dataRow1.createCell(22).setCellValue("自费");
                    dataRow1.createCell(23).setCellValue("");
                }else if ("1".equals(vo.getSource())){
                    vo.setSource("课表");
                    List<ClassSchedule> schedules=new ArrayList<>(classScheduleService.listByIds(idList));
                    String data = schedules.stream().peek((ClassSchedule u) -> u.setJsxm("姓名："+u.getJsxm()+ ";工号：" + u.getJsgh() + ";课表日期：" + u.getDateTime() + ";备注：" + u.getRemark()+";")).map(ClassSchedule::getJsxm).collect(Collectors.joining("\r\n"));
                    dataRow1.createCell(22).setCellValue("课表");
                    dataRow1.createCell(23).setCellValue(data);
                } else if ("2".equals(vo.getSource())){
                    vo.setSource("流程");
                    List<ApplicationProcedureTemporaryVo> applicationProcedureTemporaries= new ArrayList<>();
                    for (int j = 0; j <idList.size(); j++) {
                        if (StringUtils.hasText(idList.get(j))){
                            applicationProcedureTemporaries.add(applicationProcedureTemporaryService.appletDetail(Integer.valueOf(idList.get(j))));
                        }
                    }
                    String data = applicationProcedureTemporaries.stream().peek((ApplicationProcedureTemporaryVo u) ->
                            u.setUsersName("申请人姓名："+u.getUsersName()+ ";申请人部门" + u.getOrgName() + ";房间数量：" + u.getHouseCount()
                                    + ";开始时间：" + u.getStartTime()+";结束时间"+u.getEndTime()+";审核状态："+u.getStatus()+"(0：已拒绝，1：待审批，2：处理中，3：已同意);")).map(ApplicationProcedureTemporaryVo::getUsersName).collect(Collectors.joining("\r\n"));
                    dataRow1.createCell(22).setCellValue("流程");
                    dataRow1.createCell(23).setCellValue(data);
                }
            }
        }
        // 将工作簿写入文件
        ExcelUtils2.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,String dateBill) {
        PermissionSetting permissionSetting = permissionSettingService.getById(permissionSettingId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }

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

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

        String s = "";
        if ("1".equals(state)) {
            s = "2,3,4,8,10";
        } else {
            s = "5";
        }

        PageUtils<ReportStatisticsVo> pageUtils = houseOrderService.reportStatisticsPage(s, keyWord, startTime, endTime, page, size,dateBill);

        return CommonResult.ok(pageUtils);


    }

    @Override
    public void reportStatisticsExport(HttpServletResponse response, String permissionSettingId, String state, String keyWord, String startTime, String endTime,String dateBill) {
//        PermissionSetting permissionSetting = permissionSettingService.getById(permissionSettingId);
//        if (ObjectUtils.isEmpty(permissionSetting)) {
//            return CommonResult.fail("非法进入");
//        }
//
////      判断该用户是否拥有权限
//        String reportManagement = permissionSetting.getReportManagement();
//        if (!"0".equals(reportManagement) && !reportManagement.contains("2")) {
//            return CommonResult.fail("此账号暂无该权限");
//        }
//
//        if (ObjectUtils.isEmpty(state)) {
//            return CommonResult.fail("参数异常");
//        }

        String s = "";
        if ("1".equals(state)) {
            s = "2,3,4,8,10";
        } else {
            s = "5";
        }

        List<ReportStatisticsExportVo> vos = houseOrderService.reportStatisticsExport(s, keyWord, startTime, endTime,dateBill);

        //        导出
        Workbook workbook = new XSSFWorkbook();
        Sheet sheet = workbook.createSheet("报表统计");
        Row headerRow = sheet.createRow(0);
        headerRow.createCell(0).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("创建时间");



        if (ObjectUtils.isNotEmpty(vos) && vos.size() > 0) {
            if ("5".equals(s)) {
                headerRow.createCell(1).setCellValue("账期");
                headerRow.createCell(11).setCellValue("订单详情");
                //水：2.1元/吨，电：0.62元/度
                BigDecimal waterPrice = new BigDecimal(2.1);
                BigDecimal electricPrice = new BigDecimal(0.62);

                //        获取免费的额度
                SubsidySetup subsidySetup = subsidySetupService.list(new LambdaQueryWrapper<>()).get(0);

                BigDecimal water = subsidySetup.getFreeQuotaOfWater();
                BigDecimal electric = subsidySetup.getFreeQuotaOfElectric();

                for (int i = 0; i < vos.size(); i++) {
                    ReportStatisticsExportVo vo = vos.get(i);
                    Row dataRow1 = sheet.createRow(i + 1);

                    dataRow1.createCell(0).setCellValue(i + 1);
                    dataRow1.createCell(1).setCellValue(vo.getDateBill());
                    dataRow1.createCell(2).setCellValue(vo.getLiveName());
//                房型是房间名称加房间类型
                    String roomName = vo.getRoomName();
                    String roomType = vo.getRoomType();
                    String type = "";
                    if ("1".equals(roomType)) {
                        type = "全";
                    } else {
                        type = "钟";
                    }
                    dataRow1.createCell(3).setCellValue(vo.getOrgName());
                    dataRow1.createCell(4).setCellValue(vo.getCardNumber());
                    if (ObjectUtils.isEmpty(roomName)) {
                        dataRow1.createCell(5).setCellValue(roomName);
                    } else {
                        dataRow1.createCell(5).setCellValue(roomName + "(" + type + ")");
                    }
                    dataRow1.createCell(6).setCellValue(vo.getRoomNumber());
                    dataRow1.createCell(7).setCellValue(vo.getPayPrice().doubleValue());
                    dataRow1.createCell(8).setCellValue(vo.getPayTime());
//                订单状态
                    String orderStatus = vo.getOrderStatus();
                    String orderName = "";
                    if ("1".equals(orderStatus)) {
                        orderName = "待支付";
                    } else if ("2".equals(orderStatus)) {
                        orderName = "已支付";
                    } else if ("3".equals(orderStatus)) {
                        orderName = "待入住";
                    } else if ("4".equals(orderStatus)) {
                        orderName = "已入住";
                    } else if ("5".equals(orderStatus)) {
                        orderName = "待结账";
                    } else if ("6".equals(orderStatus)) {
                        orderName = "退款中";
                    } else if ("7".equals(orderStatus)) {
                        orderName = "已退款";
                    } else if ("8".equals(orderStatus)) {
                        orderName = "已退房";
                    } else if ("9".equals(orderStatus)) {
                        orderName = "已取消";
                    } else if ("10".equals(orderStatus)) {
                        orderName = "已支付未入住";
                    }

                    dataRow1.createCell(9).setCellValue(orderName);
                    dataRow1.createCell(10).setCellValue(vo.getCreateTime());
//                    订单详情
                    List<HouseOrderWaterAndElectricVo> houseOrderWaters=houseOrderService.getWaterAndElectric(vo.getHouseOrderSource());
                    String details="";
                    for (int i2 = 0; i2 < houseOrderWaters.size(); i2++) {
                        HouseOrderWaterAndElectricVo we = houseOrderWaters.get(i2);
                        we.setFreeWater(water);
                        we.setWaterPrice(waterPrice);
//          计算总金额
                        BigDecimal waterConsume = we.getWaterConsume();
                        BigDecimal subtract=waterConsume.subtract(water);
                        if (subtract.doubleValue()<0) {
                            subtract=new BigDecimal(0);
                        }
                        BigDecimal waterTotalPrice=subtract.multiply(waterPrice);
                        we.setWaterTotalPrice(waterTotalPrice);


                        we.setFreeElectric(electric);
                        we.setElectricPrice(electricPrice);
//          计算总金额
                        BigDecimal electricConsume = we.getElectricConsume();
                        BigDecimal subtract2=electricConsume.subtract(electric);
                        if (subtract2.doubleValue()<0) {
                            subtract2=new BigDecimal(0);
                        }
                        BigDecimal electricTotalPrice=subtract2.multiply(electricPrice);
                        we.setElectricTotalPrice(electricTotalPrice);

                        if (i2==0) {
                            details="订单号: "+we.getOrderNumber()+","+"入住时间: "+we.getLiveTime()+","+"离店时间: "+we.getLeaveTime()+","+"房号: "+we.getRoomNumber()
                                    +","+"用水量/吨: "+we.getWaterConsume()+","+"水价/元: "+we.getWaterPrice()+","+"水费补助/吨: "+we.getFreeWater()
                            +","+"产生水费/元: "+we.getWaterTotalPrice()+","+"用电量/度: "+we.getElectricConsume()+","+"电价/元: "+we.getElectricPrice()
                            +","+"电费补助/度: "+we.getFreeElectric()+","+"产生的电费/元: "+we.getElectricTotalPrice();
                        }else {
                            details=details+"\n"
                                    +"订单号: "+we.getOrderNumber()+","+"入住时间: "+we.getLiveTime()+","+"离店时间: "+we.getLeaveTime()+","+"房号: "+we.getRoomNumber()
                                    +","+"用水量/吨: "+we.getWaterConsume()+","+"水价/元: "+we.getWaterPrice()+","+"水费补助/吨: "+we.getFreeWater()
                                    +","+"产生水费/元: "+we.getWaterTotalPrice()+","+"用电量/度: "+we.getElectricConsume()+","+"电价/元: "+we.getElectricPrice()
                                    +","+"电费补助/度: "+we.getFreeElectric()+","+"产生的电费/元: "+we.getElectricTotalPrice();
                        }
                    }

                    dataRow1.createCell(11).setCellValue(details);
                }


            } else {
                headerRow.createCell(1).setCellValue("订单编号");
                for (int i = 0; i < vos.size(); i++) {
                    ReportStatisticsExportVo vo = vos.get(i);
                    Row dataRow1 = sheet.createRow(i + 1);

                    dataRow1.createCell(0).setCellValue(i + 1);
                    dataRow1.createCell(1).setCellValue(vo.getOrderNumber());
                    dataRow1.createCell(2).setCellValue(vo.getLiveName());
//                房型是房间名称加房间类型
                    String roomName = vo.getRoomName();
                    String roomType = vo.getRoomType();
                    String type = "";
                    if ("1".equals(roomType)) {
                        type = "全";
                    } else {
                        type = "钟";
                    }
                    dataRow1.createCell(3).setCellValue(vo.getOrgName());
                    dataRow1.createCell(4).setCellValue(vo.getCardNumber());
                    if (ObjectUtils.isEmpty(roomName)) {
                        dataRow1.createCell(5).setCellValue(roomName);
                    } else {
                        dataRow1.createCell(5).setCellValue(roomName + "(" + type + ")");
                    }
                    dataRow1.createCell(6).setCellValue(vo.getRoomNumber());
                    dataRow1.createCell(7).setCellValue(vo.getPayPrice().doubleValue());
                    dataRow1.createCell(8).setCellValue(vo.getPayTime());
//                订单状态
                    String orderStatus = vo.getOrderStatus();
                    String orderName = "";
                    if ("1".equals(orderStatus)) {
                        orderName = "待支付";
                    } else if ("2".equals(orderStatus)) {
                        orderName = "已支付";
                    } else if ("3".equals(orderStatus)) {
                        orderName = "待入住";
                    } else if ("4".equals(orderStatus)) {
                        orderName = "已入住";
                    } else if ("5".equals(orderStatus)) {
                        orderName = "待结账";
                    } else if ("6".equals(orderStatus)) {
                        orderName = "退款中";
                    } else if ("7".equals(orderStatus)) {
                        orderName = "已退款";
                    } else if ("8".equals(orderStatus)) {
                        orderName = "已退房";
                    } else if ("9".equals(orderStatus)) {
                        orderName = "已取消";
                    } else if ("10".equals(orderStatus)) {
                        orderName = "已支付未入住";
                    }

                    dataRow1.createCell(9).setCellValue(orderName);
                    dataRow1.createCell(10).setCellValue(vo.getCreateTime());

                }
            }
        }

        // 将工作簿写入文件
        ExcelUtils2.excelDownload(workbook, "订单报表.xlsx", response);

//        return CommonResult.ok();
    }

    @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::getReserveUserId, 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());
                orderPageVo.setRoomType(byId.getRoomType());
            }
            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);


        String houseNumberId = houseOrder.getHouseNumberId();
        HouseNumber houseNumber = houseNumberService.getById(houseNumberId);
        if (ObjectUtils.isNotEmpty(houseNumber)) {
            houseOrderVo.setRoomNumber(houseNumber.getRoomNumber());
        }
        String orderNumber = houseOrder.getOrderNumber();
        Unlocking unlocking = unlockingService.getOrderNumber(orderNumber);
        if (ObjectUtils.isNotEmpty(unlocking)) {
            houseOrderVo.setPassWord(unlocking.getPassWord());
        }

        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("openId");
        log.info("openId:" + wxCode);
        if (wxCode == null || wxCode == "") {
            return CommonResult.fail("openId不能为空");
        }
        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("支付失败！");
                    }
                }
//              金额为0为待入住
                ho.setOrderStatus("3");
//               支付时间
                ho.setPayTime(LocalDateTime.now().format(dateTimeFormatter));
//                支付渠道
                ho.setOrderChannel("1");
//                支付人
                ho.setPayUserId(ru.getId() + "");

                Boolean updateHouseOrder = houseOrderService.updateById(ho);
                if (!updateHouseOrder) {
                    throw new Exception("支付失败！");
                }
                log.info("金额为0，待入住成功");
                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.getReserveUserId()));
            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";
        //改为直接传openId
        String openId = wxCode;
        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 {
            log.info("请求支付参数：" + requestpay.toString());
            responseSdk = service.prepayWithRequestPayment(requestpay);
            log.info("请求支付参数返回：" + responseSdk.toString());
        } catch (Exception e) {
            log.info("请求支付异常返回：" + e);
            return CommonResult.fail(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("3");
                    one.setPayTime(TimeExchange.utcToString(transaction.getSuccessTime()));
                    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("3");
                    one.setPayTime(TimeExchange.utcToString(transaction.getSuccessTime()));
                    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)//1
    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("无该订单");
        }

//        判断是是否是房卡和钥匙开门，是的话则需要去前台办理
        Integer keyType = houseOrder.getKeyType();
        if (keyType == 2) {
            return CommonResult.fail("未归还房卡，请前往前台办理退房");
        } else if (keyType == 5) {
            return CommonResult.fail("未归还钥匙，请前往前台办理退房");
        }


        houseOrder.setOrderStatus("8");


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

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

                Date liveTime = houseOrder.getLiveTime();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String live = sdf.format(liveTime);
                String leave = sdf.format(new Date());
//                获取电的消费金额和额度
                HouseOrderBill houseOrderBill = new HouseOrderBill();

                JSONObject jsonObjectElectric = electricEquipmentService.roomCostRecord(electricEquipmentRoomId, live, leave);
                BigDecimal costElectric = jsonObjectElectric.getBigDecimal("cost");
                BigDecimal consumeElectric = jsonObjectElectric.getBigDecimal("consume");
                houseOrderBill.setElectricCost(costElectric);
                houseOrderBill.setElectricConsume(consumeElectric);


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


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

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


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

            }

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

            houseOrderService.updateById(houseOrder);
            return CommonResult.ok("该时间段已超过退房时间，已修改其订单状态");
        }
//            }

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

//      修改订单
        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());
//                获取电的消费金额和额度
            HouseOrderBill houseOrderBill = new HouseOrderBill();
            JSONObject jsonObjectElectric = electricEquipmentService.roomCostRecord(electricEquipmentRoomId, live, leave);
            BigDecimal costElectric = jsonObjectElectric.getBigDecimal("cost");
            BigDecimal consumeElectric = jsonObjectElectric.getBigDecimal("consume");
            houseOrderBill.setElectricCost(costElectric);
            houseOrderBill.setElectricConsume(consumeElectric);


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

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

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


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

        }


//        修改房态

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

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

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

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

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

        return CommonResult.ok();

    }


    @Override
    @Transactional(rollbackFor = Exception.class)//1
    public CommonResult cancelApplet(CancelAppletDto cancelAppletDto, HttpServletRequest request) throws Exception {
        String houseNumberId = cancelAppletDto.getHouseNumberId();
        String orderNumber = cancelAppletDto.getOrderNumber();
        String ua = request.getHeader("User-Agent");
        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("无该订单");
        }

        LambdaQueryWrapper<HouseNumberState> wrapperHns = new LambdaQueryWrapper<>();
        wrapperHns.eq(HouseNumberState::getHouseNumberId, houseNumberId)
                .eq(HouseNumberState::getOrderNumber, orderNumber);
        HouseNumberState houseNumberState = houseNumberStateService.getOne(wrapperHns);
        if (ObjectUtils.isEmpty(houseNumberState)) {
            return CommonResult.ok("无该订单房态");
        }
        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())) {
            return CommonResult.fail("现金退款请往前台办理");
        }
        String orderStatus = houseOrder.getOrderStatus();
        //        判断是否付款，已支付则是退款，未支付则是取消

        if ("2".equals(orderStatus) || "3".equals(orderStatus)) {
            //        判断当然时间是否在预定时间内。是的话则可以退款
            //        判断传过来的时间和当前时间比较
            DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            LocalDateTime now = LocalDateTime.now();
            String reserveLiveTime = houseOrder.getReserveLiveTime();
            LocalDateTime date = LocalDateTime.parse(reserveLiveTime, dateTimeFormatter1);
            if (now.isAfter(date) && HttpUtils.checkAgentIsMobile(ua)) {
                log.info("User-Agent移动端：" + ua);
                return CommonResult.fail("已超过退款时间，如需退款请前往前台办理");
            }

            //        退款订单号
            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);
                RefundRecord rpr = new RefundRecord();
                rpr.setHouseOrderId(houseOrder.getId());
                rpr.setRefundNo(refund_no);
                rpr.setUserId(Integer.valueOf(houseOrder.getReserveUserId()));
                rpr.setRefundPrice(new BigDecimal(total).divide(new BigDecimal("100")).setScale(2));
                rpr.setIsSuccess(0);
                rpr.setRemark("发起微信支付退款金额：" + total + "- " + TimeExchange.getTime());
                houseOrder.setOrderStatus("6");
                houseOrderService.updateById(houseOrder);
                refundRecordService.save(rpr);
                houseNumberStateService.updateById(houseNumberState);
                return CommonResult.ok(h5Refund);
            }
        }
        houseOrder.setOrderStatus("9");
        houseOrderService.updateById(houseOrder);
//            houseNumberStateService.updateById(houseNumberState);
        houseNumberStateService.removeById(houseNumberState.getId());
        return CommonResult.ok();


    }

    @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();
                // 获取 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);
                PayRecord payRecord = payRecordService.getOne(new QueryWrapper<PayRecord>().eq("pay_no", outTradeNo));
                HouseOrder rr = houseOrderService.getById(payRecord.getHouseOrderId());
                LambdaQueryWrapper<RefundRecord> wrapperRr = new LambdaQueryWrapper<>();
                wrapperRr.eq(RefundRecord::getHouseOrderId, rr.getId());
                RefundRecord rpr = refundRecordService.getOne(wrapperRr);
                if (tradeState.equals("SUCCESS")) {
                    if (rpr == null) {
                        // 保存支付信息
                        rpr = new RefundRecord();
                        rpr.setHouseOrderId(rr.getId());
                        rpr.setUserId(Integer.valueOf(rr.getReserveUserId()));
                        rpr.setRefundNo(outRefundNo);
                        rpr.setWxNo(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.setRefundNo(outRefundNo);
                        rpr.setWxNo(refundId);
                        System.out.println("回调的金额：" + total_fee);
                        rpr.setRefundPrice(new BigDecimal(total_fee).divide(new BigDecimal("100")).setScale(2));
                        rpr.setIsSuccess(1);
                        rpr.setRemark(rpr.getRemark() + "|微信支付退款成功金额：" + total_fee + "--" + TimeExchange.getTime());
                        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("7");
//                    退款时间
                    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 {
                    if (rpr != null) {
                        rpr.setRefundNo(outRefundNo);
                        rpr.setWxNo(refundId);
                        rpr.setIsSuccess(2);
                        rpr.setRemark(rpr.getRemark() + "|微信支付退款失败：" + tradeState + "--" + TimeExchange.getTime());

                    } else {
                        rpr = new RefundRecord();
                        rpr.setHouseOrderId(rr.getId());
                        rpr.setUserId(Integer.valueOf(rr.getReserveUserId()));
                        rpr.setRefundNo(outRefundNo);
                        rpr.setWxNo(refundId);
//                        System.out.println("回调的金额：" + total_fee);
//                        rpr.setRefundPrice(new BigDecimal(total_fee).divide(new BigDecimal("100")).setScale(2));
                        rpr.setIsSuccess(2);
                        rpr.setRemark("微信支付退款失败");
                        Boolean insertRpr = refundRecordService.save(rpr);
                    }
                    // 订单状态改为失败
                    rr.setOrderStatus("10");
//                    退款时间
                    rr.setRefundTime(new Date());
                    Boolean updateHouseOrder = houseOrderService.updateById(rr);
                    //更新成功返回200
                    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());
                }
            }
        } 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");
            one.setPayTime(TimeExchange.getTime());
            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.setPayPrice(BigDecimal.valueOf(price));
            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);
    }

    @Override
    public CommonResult queryRefundById(String refundNo) {
        Refund refund = new Refund();
        Map<String, Object> result = new HashMap<>();
        HouseOrder one = houseOrderService.getById(refundNo);
        RefundRecord reFundRecord = refundRecordService.getOne(new QueryWrapper<RefundRecord>().eq("house_order_id", refundNo));
        if (reFundRecord == null || reFundRecord.getId() == null) {
            result.put("code", "1001");
            result.put("message", "该订单没有退款记录");
            one.setOrderStatus("9");
            one.setRefundTime(new Date());
            houseOrderService.updateById(one);
            return CommonResult.ok(result);
        }
        if (reFundRecord.getIsSuccess() == 1) {
            result.put("code", "200");
            result.put("message", "退款已完成");
            one.setOrderStatus("7");
            one.setRefundTime(new Date());
            houseOrderService.updateById(one);
            return CommonResult.ok(result);
        }
        if (reFundRecord.getIsSuccess() == 2) {
            one.setOrderStatus("10");
            one.setRefundTime(new Date());
            houseOrderService.updateById(one);
            result.put("code", "1002");
            result.put("message", "退款失败，原因:" + reFundRecord.getRemark());
            //失败不更新订房单
            return CommonResult.ok(result);
        }
        //退款中状态去微信查
        if (reFundRecord.getIsSuccess() == 0) {
            QueryByOutRefundNoRequest queryByOutRefundNoRequest = new QueryByOutRefundNoRequest();
            // 调用request.setXxx(val)设置所需参数，具体参数可见Request定义
//            queryOrderByIdRequest.setSubMchid(wxPayV3Config.getMchId());
            queryByOutRefundNoRequest.setOutRefundNo(reFundRecord.getRefundNo());
            log.info("微信支付查询订单入参：" + queryByOutRefundNoRequest.toString());
            Config config =
                    new RSAAutoCertificateConfig.Builder()
                            .merchantId(wxPayV3Config.getMchId())
                            .privateKeyFromPath(wxPayV3Config.getKeyPath())
                            .merchantSerialNumber(wxPayV3Config.getSerialNum())
                            .apiV3Key(wxPayV3Config.getApiKey3())
                            .build();
            RefundService service = new RefundService.Builder()
                    .config(config)
                    .build();
            try {
                refund = service.queryByOutRefundNo(queryByOutRefundNoRequest);
                log.info("微信退款查询订单出参：" + refund.toString());
                switch (refund.getStatus()) {
                    case SUCCESS:
                        one.setOrderStatus("7");
                        one.setRefundTime(new Date());
                        reFundRecord.setRefundNo(refund.getOutRefundNo());
                        reFundRecord.setWxNo(refund.getRefundId());
                        reFundRecord.setRefundPrice(new BigDecimal(refund.getAmount().getPayerRefund()).divide(new BigDecimal("100")).setScale(2));
                        reFundRecord.setIsSuccess(1);
                        reFundRecord.setRemark(reFundRecord.getRemark() + "|微信支付退款成功金额：" + refund.getAmount().getPayerRefund() + "--" + TimeExchange.getTime() + "-" + refund.getUserReceivedAccount());
                        result.put("code", "200");
                        result.put("message", "退款成功");
                        break;
                    case PROCESSING:
                        result.put("code", "1003");
                        result.put("message", "退款处理中，请稍后再查询:" + reFundRecord.getRemark());
                        break;
                    case CLOSED:
                        one.setOrderStatus("10");
                        one.setRefundTime(new Date());
                        reFundRecord.setIsSuccess(2);
                        reFundRecord.setRemark(reFundRecord.getRemark() + "|退款处理失败，退款订单被关闭，联系商户处理：" + TimeExchange.getTime());
                        result.put("code", "1004");
                        result.put("message", "退款处理失败，退款订单被关闭，联系商户处理");
                        break;
                    case ABNORMAL:
                        reFundRecord.setIsSuccess(2);
                        one.setOrderStatus("10");
                        one.setRefundTime(new Date());
                        reFundRecord.setRemark(reFundRecord.getRemark() + "|退款处理失败，退款异常，联系商户处理：" + TimeExchange.getTime());
                        result.put("code", "1005");
                        result.put("message", "退款处理失败，退款异常，联系商户处理");
                        break;
                }
                boolean a = houseOrderService.updateById(one);
                boolean b = refundRecordService.updateById(reFundRecord);
                if (!a || !b) {
                    throw new Exception("更新支付状态失败");
                }
            } catch (Exception e) {
                e.printStackTrace();
                return CommonResult.fail(e.getMessage());
            }
        }
        return CommonResult.ok(result);
    }

    @Override
    public CommonResult appletReserveHour(String houseNumberId, String startTime, Integer liveTime) {
        //        获取钟点房可用时间段
        List<ApartmentSetting> list = apartmentSettingService.list(new LambdaQueryWrapper<>());
        ApartmentSetting apartmentSetting = list.get(0);
        String hourTime = apartmentSetting.getHourTime();

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

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

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

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

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

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

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

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

                }

            }

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

            reserveDayVos.add(reserveDayVo);
        }


        return CommonResult.ok(reserveDayVos);
    }

    @Override
    public CommonResult getPayOpenId(String wxcode) throws Exception {
        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查询失败:" + tokenResponse);
        }
        return CommonResult.ok(openId);
    }

    @Override
    public CommonResult ifGiveBack(String houseOrderId, Integer giveBack) {
        LambdaQueryWrapper<HouseOrder> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(HouseOrder::getOrderNumber, houseOrderId);
        HouseOrder houseOrder = houseOrderService.getOne(wrapper);
        if (ObjectUtils.isEmpty(houseOrder)) {
            return CommonResult.fail("订单异常");
        }
        houseOrder.setGiveBack(giveBack);

        houseOrderService.updateById(houseOrder);

        return CommonResult.ok();
    }

    @Override
    public CommonResult saveRemark(Integer houseOrderId, String remark) {
        HouseOrder houseOrder = houseOrderService.getById(houseOrderId);

        if (ObjectUtils.isEmpty(houseOrder)) {
            return CommonResult.fail("订单不存在");
        }

        houseOrder.setRemark(remark);

        houseOrderService.updateById(houseOrder);

        return CommonResult.ok();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)//1
    public CommonResult payNotCheckIn(CancelDto cancelDto) {
        int adminId = cancelDto.getAdminId();
        PermissionSetting permissionSetting = permissionSettingService.getById(adminId);
        if (ObjectUtils.isEmpty(permissionSetting)) {
            return CommonResult.fail("非法进入");
        }

        String houseNumberId = cancelDto.getHouseNumberId();
        String orderNumber = cancelDto.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);


// 修改订单状态
        houseOrder.setOrderStatus("10");
//  设置取消时间
        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.getId());
        return CommonResult.ok();


    }

    @Override
    public CommonResult remainFree(String userId, String liveTime, String leaveTime) {
        log.info("查询该用户是否能免费订房,userId: " + userId + " liveTime: " + liveTime + " leaveTime: " + leaveTime);
        Users users = usersService.getById(userId);
        if (ObjectUtils.isEmpty(users)) {
            return CommonResult.fail("该用户未授权");
        }
        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        //        判断传过来的时间和当前时间比较
        LocalDateTime now = LocalDateTime.now();
        LocalDateTime date = LocalDateTime.parse(liveTime, dateTimeFormatter1);
        if (now.isAfter(date)) {
            liveTime = now.format(dateTimeFormatter1);
//            establishOrderDto.setReserveLiveTime(reserveLeaveTime);
        }

        LocalDateTime stateTime = LocalDateTime.parse(liveTime, dateTimeFormatter1);
        LocalDateTime endTime = LocalDateTime.parse(leaveTime, dateTimeFormatter1);
        long day = stateTime.toLocalDate().until(endTime.toLocalDate(), ChronoUnit.DAYS);
        if (day > 2) {
            return CommonResult.fail("超过限制的时间段");
        }


        ArrayList<RemainFreeVo> vos = new ArrayList<>();
        RemainFreeVo vo = new RemainFreeVo();
        vo.setName("课表值班预定");
        vo.setSource(1);
        RemainFreeVo vo1 = new RemainFreeVo();
        vo1.setName("流程预定");
        vo1.setSource(2);

        //        先判断是否在黑名单中
        LambdaQueryWrapper<Blacklist> wrapperB = new LambdaQueryWrapper<>();
        wrapperB.eq(Blacklist::getReserveUserId, userId);
        Blacklist one = blacklistService.getOne(wrapperB);
        if (ObjectUtils.isNotEmpty(one)) {
            vo.setCount(0);
            vos.add(vo);
            vo1.setCount(0);
            vos.add(vo1);
            return CommonResult.fail("您本月预订成功后未入住次数已达到上限，已被加入黑名单,无法免费入住。");
        }


//        获取课表


        LocalDate state = stateTime.toLocalDate();
        LocalDate end = endTime.toLocalDate();


        //        获取预定时间的开始星期和结束星期
        String chineseDayOfWeek = state.getDayOfWeek().getDisplayName(TextStyle.FULL, Locale.CHINA);
        Integer week = 0;
        if ("星期一".equals(chineseDayOfWeek)) {
            week = 1;
        } else if ("星期二".equals(chineseDayOfWeek)) {
            week = 2;
        } else if ("星期三".equals(chineseDayOfWeek)) {
            week = 3;
        } else if ("星期四".equals(chineseDayOfWeek)) {
            week = 4;
        } else if ("星期五".equals(chineseDayOfWeek)) {
            week = 5;
        } else if ("星期六".equals(chineseDayOfWeek)) {
            week = 6;
        } else {
            week = 7;
        }
        DateTimeFormatter dateTimeFormatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        LocalDate localDate = state.minusDays(week - 1);
        String stateTimeXq = localDate.format(dateTimeFormatter2);
        LocalDate localEnd = localDate.plusDays(6);
        String endTimeXq = localEnd.format(dateTimeFormatter2);
//        查询该星期是否满足有2天的订单
        LambdaQueryWrapper<HouseOrder> wrapperHO = new LambdaQueryWrapper<>();
        wrapperHO.between(HouseOrder::getReserveLiveTime, stateTimeXq + " 00:00:00", endTimeXq + " 23:59:59")
                .eq(HouseOrder::getReserveUserId, userId)
                .eq(HouseOrder::getSource, 1)
                .eq(HouseOrder::getPayPrice, 0)
                .in(HouseOrder::getOrderStatus, 1, 2, 3, 4, 8);
        List<HouseOrder> orderList = houseOrderService.list(wrapperHO);

        long dayDiff = 0;

        for (HouseOrder houseOrder : orderList) {
            String reserveLiveTime = houseOrder.getReserveLiveTime();
            String reserveLeaveTime = houseOrder.getReserveLeaveTime();
            LocalDateTime stateTime2 = LocalDateTime.parse(reserveLiveTime, dateTimeFormatter1);
            LocalDateTime endTime2 = LocalDateTime.parse(reserveLeaveTime, dateTimeFormatter1);
            LocalDate state1 = stateTime2.toLocalDate();
            LocalDate end2 = endTime2.toLocalDate();
            //   计算2个时间差
            long until = state1.until(end2, ChronoUnit.DAYS);
            dayDiff = dayDiff + until;
        }

        //   计算2个时间差
        long until = state.until(end, ChronoUnit.DAYS);

        Integer count = 1;
        List<String> idList =new ArrayList<>();
        if (dayDiff + until > 2) {
            count = 0;
        } else {
            for (int i = 0; i < until; i++) {
                LocalDateTime dateTime1 = stateTime.plusDays(i);
                LocalDateTime startS = dateTime1.withHour(0).withMinute(0).withSecond(0);
                LocalDateTime endS = dateTime1.withHour(23).withMinute(59).withSecond(59);
                LambdaQueryWrapper<ClassSchedule> wrapperCS = new LambdaQueryWrapper<>();
                wrapperCS.eq(ClassSchedule::getJsgh, users.getCardNumber())
                        .between(ClassSchedule::getDateTime, startS, endS);
                List<ClassSchedule> scheduleList = classScheduleService.list(wrapperCS);
//            只要有一天是空的就不是免费
                if (ObjectUtils.isEmpty(scheduleList)) {
                    count = 0;
                    break;
                } else {
                    //        有课表就查询是否已经有该订单了
                    List<HouseOrder> list = houseOrderService.getDate(dateTime1, userId, 1);
                    if (ObjectUtils.isNotEmpty(list)) {
                        count = 0;
                        break;
                    }
                    idList.add(scheduleList.get(0).getId());
                }

            }
        }
        vo.setCount(count);
        vo.setSourceId(StringUtils.collectionToCommaDelimitedString(idList));
        vo.setDays((int) (until-dayDiff));
        if (count > 0) {
            vos.add(vo);
        }


//        获取流程
        List<ApplicationProcedureTemporary> aptList = applicationProcedureTemporaryService.getApt(state, end, userId);
        if (ObjectUtils.isEmpty(aptList)) {
            vo1.setCount(0);
        } else {
            //可申请天数
            long dayApt=0;
            List<Integer> aptIdList =new ArrayList<>();
            for (int i = 0; i <aptList.size() ; i++) {
                ApplicationProcedureTemporary applicationProcedureTemporary = aptList.get(0);
                String houseCount = applicationProcedureTemporary.getHouseCount();
                String startTime = applicationProcedureTemporary.getStartTime();
                String endTime1 = applicationProcedureTemporary.getEndTime();
//            计算开始到结束时间有多少订单
                LambdaQueryWrapper<HouseOrder> wrapper = new LambdaQueryWrapper<>();
                wrapper.eq(HouseOrder::getReserveUserId, userId)
                        .eq(HouseOrder::getSource, 2)
                        .between(HouseOrder::getReserveLiveTime, startTime, endTime1)
                        .eq(HouseOrder::getPayPrice, 0)
                        .in(HouseOrder::getOrderStatus, 1, 2, 3, 4, 8);
                List<HouseOrder> list = houseOrderService.list(wrapper);
                Integer count2 = Integer.valueOf(houseCount);
                count2 = count2 - list.size();
                if(count2==0){
                    break;
                }
                aptIdList.add(applicationProcedureTemporary.getId());
                LocalDateTime stateTimeApt = LocalDateTime.parse(startTime, dateTimeFormatter1);
                LocalDateTime endTimeApt = LocalDateTime.parse(endTime1, dateTimeFormatter1);
                dayApt =dayApt+stateTimeApt.toLocalDate().until(endTimeApt.toLocalDate(), ChronoUnit.DAYS);
                vo1.setCount(count2);
            }
            vo1.setDays((int) dayApt);
            vo1.setSourceId(StringUtils.collectionToCommaDelimitedString(aptIdList));
        }
        if (vo1.getCount() > 0) {
            vos.add(vo1);
        }

        log.info("最终免费结果：" + vos);

        return CommonResult.ok(vos);
    }

    @Override
    public CommonResult reportStatisticsParticulars(Integer id) {
        HouseOrder houseOrder = houseOrderService.getById(id);
        if (ObjectUtils.isEmpty(houseOrder)) {
            return CommonResult.fail("不存在该订单");
        }
        String houseOrderSource = houseOrder.getHouseOrderSource();
        List<HouseOrderWaterVo> houseOrderWaters=houseOrderService.getWater(houseOrderSource);
        List<HouseOrderElectricVo> houseOrderElectrics=houseOrderService.getElectric(houseOrderSource);

        //水：2.1元/吨，电：0.62元/度
        BigDecimal waterPrice = new BigDecimal(2.1);
        BigDecimal electricPrice = new BigDecimal(0.62);

        //        获取免费的额度
        BigDecimal water = houseOrder.getFreeWater();
        BigDecimal electric = houseOrder.getFreeElectric();

        for (int i = 0; i < houseOrderWaters.size(); i++) {
            HouseOrderWaterVo houseOrderWaterVo = houseOrderWaters.get(i);
            houseOrderWaterVo.setFreeWater(water);
            houseOrderWaterVo.setWaterPrice(waterPrice);
//          计算总金额
            BigDecimal waterConsume = houseOrderWaterVo.getWaterConsume();
            BigDecimal subtract=waterConsume.subtract(water);
            if (subtract.doubleValue()<0) {
                subtract=new BigDecimal(0);
            }
            BigDecimal waterTotalPrice=subtract.multiply(waterPrice);
            houseOrderWaterVo.setWaterTotalPrice(waterTotalPrice);
        }

        for (int i = 0; i < houseOrderElectrics.size(); i++) {
            HouseOrderElectricVo houseOrderElectricVo = houseOrderElectrics.get(i);
            houseOrderElectricVo.setFreeElectric(electric);
            houseOrderElectricVo.setElectricPrice(electricPrice);
//          计算总金额
            BigDecimal electricConsume = houseOrderElectricVo.getElectricConsume();
            BigDecimal subtract=electricConsume.subtract(electric);
            if (subtract.doubleValue()<0) {
                subtract=new BigDecimal(0);
            }
            BigDecimal electricTotalPrice=subtract.multiply(electricPrice);
            houseOrderElectricVo.setElectricTotalPrice(electricTotalPrice);
        }

        ReportStatisticsParticularsVo vo = new ReportStatisticsParticularsVo();
        vo.setHouseOrder(houseOrder);
        vo.setWaterVos(houseOrderWaters);
        vo.setElectricVos(houseOrderElectrics);

        return CommonResult.ok(vo);
    }

    @Override
    public CommonResult dateBillType() {
        List<String> dateBillTypeList=houseOrderService.dateBillType();

        return CommonResult.ok(dateBillTypeList);
    }


    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);
//        String a="第一个订单"+"\n"+"第二个订单";
//        System.out.println(a);


        //      入住天数
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime start = LocalDateTime.parse("2024-12-31 15:17:27", dateTimeFormatter);
        LocalDateTime end = LocalDateTime.parse("2025-01-01 13:00:00", dateTimeFormatter);

        LocalDate startDate = start.toLocalDate();
        LocalDate endDate = end.toLocalDate();

        int daysBetween = (int) startDate.until(endDate, ChronoUnit.DAYS);
        System.out.println("daysBetween = " + daysBetween);
    }

    /**
     * 每2个小时查询一次到时间没有点退房的订单，并自动退房
     */
    @Scheduled(cron = "0 0 0/2 * * ? ")
//    @Scheduled(cron = "0 0/1 * * * ?")
    @Transactional(rollbackFor = Exception.class)//1
    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);

        ArrayList<HouseOrder> houseOrders = new ArrayList<>();
        ArrayList<HouseNumber> houseNumbers = new ArrayList<>();
        if (ObjectUtils.isNotEmpty(list) && list.size() > 0) {
            log.info("开始自动退房");
            for (HouseOrder houseOrder : list) {
                houseOrder.setOrderStatus("8");
                houseOrder.setLeaveTime(new Date());
                String houseNumberId = houseOrder.getHouseNumberId();
                HouseNumber houseNumber = houseNumberService.getById(houseNumberId);

                String orderNumber = houseOrder.getOrderNumber();
                LambdaQueryWrapper<Unlocking> wrapperU = new LambdaQueryWrapper<>();
                wrapperU.eq(Unlocking::getOrderNumber, orderNumber)
                        .eq(Unlocking::getHouseNumberId, houseNumberId);
                Unlocking unlocking = unlockingService.getOne(wrapperU);
                if (ObjectUtils.isNotEmpty(unlocking)) {
//                删除房间密码
                    try {
                    passwordIssController.deleteLockUser(unlocking.getLuid(), unlocking.getLockUserId());
                    unlockingService.removeById(unlocking);
                    }catch (Exception e){
                        log.info("房间id是"+houseNumberId+": "+e);
                    }
                }

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

                        Date liveTime = houseOrder.getLiveTime();
                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                        String live = sdf.format(liveTime);
                        String leave = sdf.format(new Date());
//                获取电的消费金额和额度
                        HouseOrderBill houseOrderBill = new HouseOrderBill();

                        JSONObject jsonObjectElectric = electricEquipmentService.roomCostRecord(electricEquipmentRoomId, live, leave);
                        BigDecimal costElectric = jsonObjectElectric.getBigDecimal("cost");
                        BigDecimal consumeElectric = jsonObjectElectric.getBigDecimal("consume");
                        houseOrderBill.setElectricCost(costElectric);
                        houseOrderBill.setElectricConsume(consumeElectric);


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


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

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


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

                    }

//          将房间设置成脏房
                    houseNumber.setHouseStatus(2);

                    houseOrders.add(houseOrder);
                    houseNumbers.add(houseNumber);
                }


            }
        }

        if (ObjectUtils.isNotEmpty(houseOrders)) {
            houseOrderService.updateBatchById(houseOrders);
        }
        if (ObjectUtils.isNotEmpty(houseNumbers)) {
            houseNumberService.updateBatchById(houseNumbers);
        }


    }

    //    @Scheduled(cron = "0 0/1 * * * ?")
    public void pay() {
        //        计算上个免费的订单
        LocalDateTime end = LocalDateTime.now().withDayOfMonth(1).withHour(0).withMinute(0).withSecond(0);
        LocalDateTime start = end.minusMonths(1);

        LambdaQueryWrapper<HouseOrder> wrapper = new LambdaQueryWrapper<>();
        wrapper/*.between(HouseOrder::getLeaveTime, start, end)*/
                .eq(HouseOrder::getPayPrice, 0)
                .eq(HouseOrder::getOrderStatus, 8);
        List<HouseOrder> list = houseOrderService.list(wrapper);
        //        重新计算订单
        for (int i = 0; i < list.size(); i++) {
            HouseOrder houseOrder = list.get(i);
            String houseNumberId = houseOrder.getHouseNumberId();
            //      获取水电消费金额和额度
            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();
                Date leaveTime = houseOrder.getLeaveTime();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String live = sdf.format(liveTime);
                String leave = sdf.format(leaveTime);
//                获取电的消费金额和额度
                JSONObject jsonObjectElectric = electricEquipmentService.roomCostRecord(electricEquipmentRoomId, live, leave);
                BigDecimal costElectric = jsonObjectElectric.getBigDecimal("cost");
                BigDecimal consumeElectric = jsonObjectElectric.getBigDecimal("consume");
                houseOrder.setElectricCost(costElectric);
                houseOrder.setElectricConsume(consumeElectric);
//                获取水的消费金额和额度
                JSONObject jsonObjectWater = waterEquipmentService.roomCostRecord(waterEquipmentRoomId, live, leave);
                BigDecimal costWater = jsonObjectWater.getBigDecimal("cost");
                BigDecimal consumeWater = jsonObjectWater.getBigDecimal("consume");
                houseOrder.setWaterCost(costWater);
                houseOrder.setWaterConsume(consumeWater);
            }

        }
        houseOrderService.updateBatchById(list);
    }

    //    计算一个月内每个人的免费入住所消费的水电
    @Scheduled(cron = "0 0 1 1 * ? ")
//    @Scheduled(cron = "0 0/1 * * * ?")
    public void payHouseOrder() {
//        获取免费的额度
        SubsidySetup subsidySetup = subsidySetupService.list(new LambdaQueryWrapper<>()).get(0);

        BigDecimal water = subsidySetup.getFreeQuotaOfWater();
        BigDecimal electric = subsidySetup.getFreeQuotaOfElectric();

        //水：2.1元/吨，电：0.62元/度
        BigDecimal waterPrice = new BigDecimal(2.1);
        BigDecimal electricPrice = new BigDecimal(0.62);

//        water = water.multiply(waterPrice);
//        electric = electric.multiply(electricPrice);

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

//        计算上个免费的订单
        LocalDateTime end = LocalDateTime.now().withDayOfMonth(1).withHour(0).withMinute(0).withSecond(0);
        LocalDateTime start = end.minusMonths(1);

        String dateBill=start.toLocalDate().format(dateTimeFormatter2);


        LambdaQueryWrapper<HouseOrder> wrapper = new LambdaQueryWrapper<>();
        wrapper.between(HouseOrder::getLeaveTime, start, end)
                .eq(HouseOrder::getPayPrice, 0)
                .eq(HouseOrder::getOrderStatus, 8);
        List<HouseOrder> list = houseOrderService.list(wrapper);


//       获取上个月哪些人有免费订单
        List<String> userList = houseOrderService.payHouseOrderUser(start, end);

        ArrayList<HouseOrder> houseOrders = new ArrayList<>();
        for (String user : userList) {
            List<HouseOrder> ownerClasses = list.stream().filter(e -> e.getReserveUserId().equals(user)).collect(Collectors.toList());

//            总能耗
            BigDecimal waterTotal = new BigDecimal(0);
//            总金额
            BigDecimal waterCostTotal = new BigDecimal(0);
            BigDecimal electricTotal = new BigDecimal(0);
            BigDecimal electricCostTotal = new BigDecimal(0);

            String houseOrderSource = "";


            for (int i = 0; i < ownerClasses.size(); i++) {
                HouseOrder ownerClass = ownerClasses.get(i);
                String id = ownerClass.getId()+"";
                if (i==0) {
                    houseOrderSource=id;
                }else {
                    houseOrderSource=houseOrderSource+","+id;
                }

//                金额
//                BigDecimal electricCost = ownerClass.getElectricCost();

//                能耗
                BigDecimal electricConsume = ownerClass.getElectricConsume();

                if (electricConsume.subtract(electric).doubleValue() > 0) {
//                    超出的能耗
                    BigDecimal decimal = electricConsume.subtract(electric);
//                    超出的总能耗
                    electricTotal = electricTotal.add(decimal);

//                    超出的金额
                    BigDecimal multiply = decimal.multiply(electricPrice);
//                    超出的总金额
                    electricCostTotal = electricCostTotal.add(multiply);
                }


//                BigDecimal waterCost = ownerClass.getWaterCost();
                BigDecimal waterConsume = ownerClass.getWaterConsume();
                if (waterConsume.subtract(water).doubleValue() > 0) {
//                     超出的能耗
                    BigDecimal decimal = waterConsume.subtract(water);
//                     超出的总能耗
                    waterTotal = waterTotal.add(decimal);

//                    超出的金额
                    BigDecimal multiply = decimal.multiply(waterPrice);
//                    超出的总金额
                    waterCostTotal = waterCostTotal.add(multiply);
                }

            }

//            需支付金额=电费+水费
            BigDecimal payPrice = waterCostTotal.add(electricCostTotal);


            if (payPrice.doubleValue() > 0) {
                HouseOrder houseOrder = new HouseOrder();
                //        订单号
//                String orderNumber = UUID.randomUUID().toString();
//                orderNumber = orderNumber.replace("-", "");
                String orderNumber = OrderNumber.getOrderNumber();
                houseOrder.setOrderNumber(orderNumber);
//                订单状态
                houseOrder.setOrderStatus("5");

                Users users = usersService.getById(user);
//                入住人
                houseOrder.setLiveName(users.getUserName());
//                预定人
                houseOrder.setReserveName(users.getUserName());
//                预定人电话
                houseOrder.setReservePhone(users.getPhone());
//                预定人id
                houseOrder.setReserveUserId(user);
//                入住人id
                houseOrder.setLiveUsersId(user);
//              居住天数
                houseOrder.setLiveDay(ownerClasses.size() + "");

//                渠道
                houseOrder.setOrderChannel("1");
//                订单金额
                houseOrder.setPayPrice(payPrice);

                houseOrder.setElectricCost(electricCostTotal);
                houseOrder.setElectricConsume(electricTotal);
                houseOrder.setWaterCost(waterCostTotal);
                houseOrder.setWaterConsume(waterTotal);

                houseOrder.setReserveLiveTime(start.format(dateTimeFormatter1));
                houseOrder.setReserveLeaveTime(end.format(dateTimeFormatter1));
                houseOrder.setLiveTime(Date.from(start.atZone(ZoneId.systemDefault()).toInstant()));
                houseOrder.setLeaveTime(Date.from(end.atZone(ZoneId.systemDefault()).toInstant()));
                houseOrder.setHouseOrderSource(houseOrderSource);
                houseOrder.setFreeElectric(electric);
                houseOrder.setFreeWater(water);

//                结账日期
                houseOrder.setDateBill(dateBill);

                houseOrders.add(houseOrder);
            }

        }
        houseOrderService.saveBatch(houseOrders);
    }


    //    到时间超时还未付款则取消
    @Scheduled(cron = "0 0/5 * * * ? ")
    public void getTimeOut() {

//        当前时间
        LocalDateTime now = LocalDateTime.now();
        LambdaQueryWrapper<HouseOrder> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(HouseOrder::getOrderStatus, 1)
                .le(HouseOrder::getTimeOut, now);
        List<HouseOrder> list = houseOrderService.list(wrapper);

        ArrayList<HouseOrder> houseOrders = new ArrayList<>();
        for (HouseOrder houseOrder : list) {
            String orderNumber = houseOrder.getOrderNumber();
            String houseNumberId = houseOrder.getHouseNumberId();

            LambdaQueryWrapper<HouseNumberState> wrapperHns = new LambdaQueryWrapper<>();
            wrapperHns.eq(HouseNumberState::getHouseNumberId, houseNumberId)
                    .eq(HouseNumberState::getOrderNumber, orderNumber);
            HouseNumberState houseNumberState = houseNumberStateService.getOne(wrapperHns);
            if (ObjectUtils.isNotEmpty(houseNumberState)) {
                houseNumberStateService.removeById(houseNumberState.getId());
            }

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

            houseOrders.add(houseOrder);
        }

        if (houseOrders.size() > 0) {
            houseOrderService.updateBatchById(houseOrders);
        }

    }

    /**
     * 每天13点
     * 计算当天当前时间超过待入住.已支付订单的预离时间
     */
//    @Scheduled(cron = "0 0 13 * * ? ")
    @Scheduled(cron = "0 0 0 * * ? ")
    @Transactional(rollbackFor = Exception.class)//1
    public void getBlacklist() {
//        获取预离时间是当天的待入住,已支付订单
        LocalDateTime startTime = LocalDateTime.now().withHour(0).withMinute(0).withSecond(0).minusDays(1);
        LocalDateTime endTime = startTime.withHour(23).withMinute(59).withSecond(59);

        LambdaQueryWrapper<HouseOrder> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(HouseOrder::getOrderStatus, 2, 3)
                .between(HouseOrder::getReserveLeaveTime, startTime, endTime)
                .eq(HouseOrder::getPayPrice, 0);
        List<HouseOrder> list = houseOrderService.list(wrapper);

        if (list.size() > 0) {
            ArrayList<BlacklistOrder> blacklistOrders = new ArrayList<>();

            for (HouseOrder houseOrder : list) {
                BlacklistOrder blacklistOrder = new BlacklistOrder();

                blacklistOrder.setHouseOrderId(houseOrder.getId());
                blacklistOrder.setOrderNumber(houseOrder.getOrderNumber());
                blacklistOrder.setOrderStatus(houseOrder.getOrderStatus());
                blacklistOrder.setReserveUserId(houseOrder.getReserveUserId());
                blacklistOrder.setReserveName(houseOrder.getReserveName());
                blacklistOrder.setReservePhone(houseOrder.getReservePhone());

                Users users = usersService.getById(houseOrder.getReserveUserId());
                if (ObjectUtils.isNotEmpty(users)) {
                    blacklistOrder.setCardNumber(users.getCardNumber());
                }

                blacklistOrder.setReserveLiveTime(houseOrder.getReserveLiveTime());
                blacklistOrder.setReserveLeaveTime(houseOrder.getReserveLeaveTime());
                blacklistOrders.add(blacklistOrder);

//                将订单状态改成取消,空出房间
                // 修改订单状态,已支付待入住
                houseOrder.setOrderStatus("10");
//  设置取消时间
                houseOrder.setCancelTime(new Date());

                LambdaQueryWrapper<HouseNumberState> wrapperHns = new LambdaQueryWrapper<>();
                wrapperHns.eq(HouseNumberState::getHouseNumberId, houseOrder.getHouseNumberId())
                        .eq(HouseNumberState::getOrderNumber, houseOrder.getOrderNumber());
                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.removeById(houseNumberState.getId());


            }


            blacklistOrderService.saveBatch(blacklistOrders);

            BlacklistSetting blacklistSetting = blacklistSettingService.list(new LambdaQueryWrapper<>()).get(0);
            Integer count = blacklistSetting.getCount();

            List<BlacklistVo> vos = blacklistOrderService.getBlacklist(count);
            if (vos.size() > 0) {
                ArrayList<Blacklist> blacklists = new ArrayList<>();
                for (BlacklistVo vo : vos) {
                    Integer id1 = vo.getId();
                    Users users = usersService.getById(id1);
//                        通过预定id找到对应的黑名单预定人id
                    LambdaQueryWrapper<Blacklist> wrapperB = new LambdaQueryWrapper<>();
                    wrapperB.eq(Blacklist::getReserveUserId, id1);
                    Blacklist one = blacklistService.getOne(wrapperB);
                    if (ObjectUtils.isNotEmpty(one)) {
                        one.setCount(vo.getCount());
                        blacklists.add(one);
                    } else {
                        if (ObjectUtils.isNotEmpty(users)) {
                            Blacklist blacklist = new Blacklist();
                            blacklist.setReserveUserId(id1);
                            blacklist.setReserveName(users.getUserName());
                            blacklist.setPhone(users.getPhone());
                            blacklist.setCardNumber(users.getCardNumber());
                            blacklist.setCount(vo.getCount());
                            blacklists.add(blacklist);
                        }
                    }
                }
                if (blacklists.size() > 0) {
                    blacklistService.saveOrUpdateBatch(blacklists);
                }
            }


        }


    }

}