代码生成

rk

2 天以前 761d13616d43b147142d7d33da3a646f6ac15397

 server/services/src/main/java/com/doumee/service/business/impl/OrdersServiceImpl.java

@@ -17,6 +17,7 @@
import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.DateUtil;
import com.doumee.core.utils.ID;
import com.doumee.core.utils.geocode.MapUtil;
import com.doumee.core.utils.Utils;
import com.doumee.core.utils.aliyun.AliSmsService;
@@ -237,7 +238,14 @@
                queryWrapper.orderByAsc(sortData.getProperty());
            }
        }
        return PageData.from(ordersMapper.selectJoinPage(page, Orders.class, queryWrapper));
        PageData<Orders> pageData = PageData.from(ordersMapper.selectJoinPage(page, Orders.class, queryWrapper));
        for (Orders o : pageData.getRecords()) {
            if (o.getStatus() != null) {
                Constants.OrderStatus os = Constants.OrderStatus.getByKey(o.getStatus());
                o.setStatusDesc(os != null ? os.getValue() : "");
            }
        }
        return pageData;
    }

    @Override
@@ -698,7 +706,7 @@
                // 无取件门店，校验存件点与自选取件点是否在同一城市
                if (!MapUtil.isSameCity(depositShop.getLatitude(), depositShop.getLongitude(),
                        dto.getTakeLat().doubleValue(), dto.getTakeLgt().doubleValue())) {
                    throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "异地寄存订单存取点不在同一城市，如需请选择同城门店");
                    throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "存取点不在同一城市！");
                }
                takeLat = dto.getTakeLat();
                takeLgt = dto.getTakeLgt();
@@ -785,6 +793,7 @@
            // 异地：取件点信息
            orders.setTakeShopId(dto.getTakeShopId());
            orders.setTakeLocation(takeLocationValue);
            orders.setTakeLocationRemark(takeLocationValue);
            orders.setTakeLat(takeLat);
            orders.setTakeLgt(takeLgt);
            orders.setIsUrgent(dto.getIsUrgent());
@@ -793,6 +802,7 @@
            // 就地：取件点同寄件店铺
            orders.setTakeShopId(dto.getDepositShopId());
            orders.setTakeLocation(depositShop.getAddress());
            orders.setTakeLocationRemark(depositShop.getAddress());
            orders.setTakeLat(BigDecimal.valueOf(depositShop.getLatitude()));
            orders.setTakeLgt(BigDecimal.valueOf(depositShop.getLongitude()));
            orders.setIsUrgent(Constants.ZERO);
@@ -836,6 +846,19 @@

        ordersMapper.insert(orders);
        Integer orderId = orders.getId();

        // 创建订单日志
        OrderLog createLog = new OrderLog();
        createLog.setOrderId(orderId);
        createLog.setTitle(Constants.OrderLogType.createOrder.getTitle());
        createLog.setLogInfo(Constants.OrderLogType.createOrder.format(orderCode));
        createLog.setObjType(Constants.OrderLogType.createOrder.getStatus());
        createLog.setOrderStatus(orders.getStatus());
        createLog.setOptUserId(memberId);
        createLog.setOptUserType(0);
        createLog.setCreateTime(now);
        createLog.setDeleted(Constants.ZERO);
        orderLogService.create(createLog);

        // ========== 7. 创建订单明细 ==========
        for (ItemPriceVO itemVO : priceResult.getItemList()) {
@@ -987,6 +1010,12 @@
        OrderDetailVO vo = new OrderDetailVO();
        vo.setOrder(order);

        // 订单状态描述
        if (order.getStatus() != null) {
            Constants.OrderStatus os = Constants.OrderStatus.getByKey(order.getStatus());
            vo.setStatusDesc(os != null ? os.getValue() : "");
        }

        // 图片路径前缀
        String imgPrefix = getOrdersPrefix();

@@ -1111,19 +1140,6 @@

        String optUserName = getCurrentUserName();

        // 加急费日志
        OrderLog feeLog = new OrderLog();
        feeLog.setOrderId(order.getId());
        feeLog.setTitle(Constants.OrderLogType.urgent.getTitle());
        feeLog.setLogInfo(Constants.OrderLogType.urgent.format(dto.getUrgentFee().toPlainString()));
        feeLog.setObjType(Constants.OrderLogType.urgent.getStatus());
        feeLog.setOrderStatus(order.getStatus());
        feeLog.setOptUserType(3);
        feeLog.setOptUserName(optUserName);
        feeLog.setCreateTime(new Date());
        feeLog.setDeleted(Constants.ZERO);
        orderLogService.create(feeLog);

        // 加急费用 元→分
        long urgentFeeFen = dto.getUrgentFee().multiply(new BigDecimal(100)).longValue();

@@ -1148,9 +1164,30 @@
            updateWrapper.set(Orders::getRemark, dto.getRemark());
        }

        // 指派司机（非必填）
        // 日志：只存一条，有司机用 assignDriver，无司机用 urgent
        if (dto.getDriverId() != null) {
            // 校验司机信息
            DriverInfo driverInfo = driverInfoMapper.selectOne(new QueryWrapper<DriverInfo>().lambda()
                    .eq(DriverInfo::getMemberId, dto.getDriverId())
                    .eq(DriverInfo::getDeleted, Constants.ZERO)
                    .last("limit 1"));
            if (driverInfo == null) {
                throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(), "司机信息不存在");
            }
            if (!Integer.valueOf(3).equals(driverInfo.getAuditStatus())) {
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "司机未支付押金，无法派单");
            }
            if (!Constants.ZERO.equals(driverInfo.getStatus())) {
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "司机已被禁用，无法派单");
            }

            // 更新接单司机信息及订单状态
            Date now = new Date();
            updateWrapper.set(Orders::getAssignDriverId, dto.getDriverId());
            updateWrapper.set(Orders::getAcceptDriver, dto.getDriverId());
            updateWrapper.set(Orders::getAcceptTime, now);
            updateWrapper.set(Orders::getAcceptType, 1); // 1=系统派单
            updateWrapper.set(Orders::getStatus, Constants.OrderStatus.accepted.getStatus());

            Member driver = memberMapper.selectById(dto.getDriverId());
            String driverName = driver != null ? driver.getName() : String.valueOf(dto.getDriverId());
@@ -1160,32 +1197,37 @@
            driverLog.setTitle(Constants.OrderLogType.assignDriver.getTitle());
            driverLog.setLogInfo(Constants.OrderLogType.assignDriver.format(driverName, dto.getUrgentFee().toPlainString()));
            driverLog.setObjType(Constants.OrderLogType.assignDriver.getStatus());
            driverLog.setOrderStatus(order.getStatus());
            driverLog.setOrderStatus(Constants.OrderStatus.accepted.getStatus());
            driverLog.setOptUserType(3);
            driverLog.setOptUserName(optUserName);
            driverLog.setCreateTime(new Date());
            driverLog.setCreateTime(now);
            driverLog.setDeleted(Constants.ZERO);
            orderLogService.create(driverLog);

            // 短信通知指派司机（加急派单）
            DriverInfo driverInfo = driverInfoMapper.selectOne(new QueryWrapper<DriverInfo>().lambda()
                    .eq(DriverInfo::getMemberId, dto.getDriverId())
                    .eq(DriverInfo::getDeleted, Constants.ZERO)
                    .last("limit 1"));
            if (driverInfo != null) {
                String address1 = order.getDepositShopAddress() != null ? order.getDepositShopAddress() : order.getDepositShopName();
                String address2 = order.getTakeShopAddress() != null ? order.getTakeShopAddress() :
                        (order.getTakeLocation() != null ? order.getTakeLocation() : "");
                // 配送费 = 司机配送费 + 加急费
                long totalDriverFee = (order.getDriverFee() != null ? order.getDriverFee() : 0L) + urgentFeeFen;
                sendSmsNotify(driverInfo.getTelephone(),
                        Constants.SmsNotify.DRIVER_URGENT_DISPATCH,
                        "orderNo", order.getCode(),
                        "address1", address1,
                        "address2", address2,
                        "money1", String.valueOf(totalDriverFee / 100.0),
                        "money2", String.valueOf(urgentFeeFen / 100.0));
            }
            String address1 = order.getDepositLocationRemark();
            String address2 = order.getTakeLocationRemark();
            long totalDriverFee = (order.getDriverFee() != null ? order.getDriverFee() : 0L) + urgentFeeFen;
            sendSmsNotify(driverInfo.getTelephone(),
                    Constants.SmsNotify.DRIVER_URGENT_DISPATCH,
                    "orderNo", order.getCode(),
                    "address1", address1,
                    "address2", address2,
                    "money1", String.valueOf(totalDriverFee / 100.0),
                    "money2", String.valueOf(urgentFeeFen / 100.0));
        } else {
            // 未指派司机，只记录加急日志
            OrderLog feeLog = new OrderLog();
            feeLog.setOrderId(order.getId());
            feeLog.setTitle(Constants.OrderLogType.urgent.getTitle());
            feeLog.setLogInfo(Constants.OrderLogType.urgent.format(dto.getUrgentFee().toPlainString()));
            feeLog.setObjType(Constants.OrderLogType.urgent.getStatus());
            feeLog.setOrderStatus(order.getStatus());
            feeLog.setOptUserType(3);
            feeLog.setOptUserName(optUserName);
            feeLog.setCreateTime(new Date());
            feeLog.setDeleted(Constants.ZERO);
            orderLogService.create(feeLog);
        }

        ordersMapper.update(updateWrapper);
@@ -1461,13 +1503,8 @@
                // 物品明细
                vo.setDetailList(buildDetailList(details));

                // 逾期信息（仅待取件状态计算）
                if (Integer.valueOf(Constants.OrderStatus.arrived.getStatus()).equals(o.getStatus())) {
                    OverdueFeeVO overdueInfo = calculateOverdueFeeInternal(o, details);
                    vo.setOverdue(overdueInfo.getOverdue());
                    vo.setOverdueDays(overdueInfo.getOverdueDays());
                    vo.setOverdueFee(overdueInfo.getOverdueFee());
                }
                // 逾期状态
                fillOverdueStatus(vo, o, details);
                voList.add(vo);
            }
        }
@@ -1513,11 +1550,25 @@
                .leftJoin("shop_info s1 on s1.id = t.DEPOSIT_SHOP_ID")
                .leftJoin("shop_info s2 on s2.id = t.TAKE_SHOP_ID")
                .leftJoin("driver_info d on d.id = t.ACCEPT_DRIVER")
                .eq(Orders::getPayStatus, Constants.ONE)
                .and(w -> w.eq(Orders::getDepositShopId, shopId).or().eq(Orders::getTakeShopId, shopId))
                .eq(status != null, Orders::getStatus, status)
                .in(statusList != null, Orders::getStatus, statusList)
                .orderByDesc(Orders::getCreateTime);
                .eq(Orders::getPayStatus, Constants.ONE);

        // 门店待处理订单：按业务环节区分门店角色
        if (combinedStatus != null && Constants.equalsInteger(combinedStatus, Constants.SEVEN)) {
            wrapper.and(w -> w
                    .and(w1 -> w1.eq(Orders::getDepositShopId, shopId)
                            .in(Orders::getStatus, Constants.OrderStatus.waitDeposit.getStatus(),
                                    Constants.OrderStatus.deposited.getStatus()))
                    .or(w2 -> w2.eq(Orders::getTakeShopId, shopId)
                            .in(Orders::getStatus, Constants.OrderStatus.delivering.getStatus(),
                                    Constants.OrderStatus.arrived.getStatus()))
            );
        } else {
            wrapper.and(w -> w.eq(Orders::getDepositShopId, shopId).or().eq(Orders::getTakeShopId, shopId));
        }

        wrapper.eq(status != null, Orders::getStatus, status)
                .in(statusList != null && !Constants.equalsInteger(combinedStatus, Constants.SEVEN), Orders::getStatus, statusList)
                .orderByDesc(Orders::getId);

        IPage<Orders> orderPage = ordersMapper.selectJoinPage(p, Orders.class, wrapper);
        List<MyOrderVO> voList = new ArrayList<>();
@@ -1532,6 +1583,7 @@
                        Constants.equalsInteger(o.getType(), Constants.ZERO)?o.getType():Objects.nonNull(o.getTakeShopId())?Constants.ONE:Constants.TWO)
                );
                vo.setCreateTime(o.getCreateTime());
                vo.setRemark(o.getRemark());
                vo.setExpectedTakeTime(o.getExpectedTakeTime());

                vo.setDepositShopName(o.getDepositShopName());
@@ -1570,12 +1622,16 @@

                vo.setDetailList(buildDetailList(details));

                if (Integer.valueOf(Constants.OrderStatus.arrived.getStatus()).equals(o.getStatus())) {
                    OverdueFeeVO overdueInfo = calculateOverdueFeeInternal(o, details);
                    vo.setOverdue(overdueInfo.getOverdue());
                    vo.setOverdueDays(overdueInfo.getOverdueDays());
                    vo.setOverdueFee(overdueInfo.getOverdueFee());
                }

                // 逾期状态
                fillOverdueStatus(vo, o, details);

//                if (Integer.valueOf(Constants.OrderStatus.arrived.getStatus()).equals(o.getStatus())) {
//                    OverdueFeeVO overdueInfo = calculateOverdueFeeInternal(o, details);
//                    vo.setOverdue(overdueInfo.getOverdue());
//                    vo.setOverdueDays(overdueInfo.getOverdueDays());
//                    vo.setOverdueFee(overdueInfo.getOverdueFee());
//                }
                voList.add(vo);
            }
        }
@@ -1621,7 +1677,7 @@
            }
        }
        if (order == null) {
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(), "订单不存在");
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(), "核销码无效");
        }
        return buildOrderDetailVO(order, false);
    }
@@ -1724,41 +1780,8 @@
                        .eq(OrdersDetail::getDeleted, Constants.ZERO));
        vo.setDetailList(buildDetailList(details));

        // 逾期状态：0=无逾期 1=存在逾期 2=待支付逾期 3=逾期已支付
        if (Constants.equalsInteger(order.getOverdueStatus(), Constants.TWO)) {
            // 订单标记已支付逾期
            vo.setOverdueStatus(Constants.THREE);
            vo.setOverdue(true);
            vo.setOverdueDays(order.getOverdueDays());
            vo.setOverdueFee(order.getOverdueAmount());
        } else if (Constants.equalsInteger(order.getOverdueStatus(), Constants.ONE)) {
            // 订单标记待支付逾期
            vo.setOverdueStatus(Constants.TWO);
            vo.setOverdue(true);
            vo.setOverdueDays(order.getOverdueDays());
            vo.setOverdueFee(order.getOverdueAmount());
        } else if (order.getConfirmArriveTime() != null) {
            // 已确认到店，无逾期
            vo.setOverdueStatus(Constants.ZERO);
            vo.setOverdue(false);
            vo.setOverdueDays(0);
            vo.setOverdueFee(0L);
        } else {
            // 未确认到店，计算实际逾期
            OverdueFeeVO overdueInfo = calculateOverdueFeeInternal(order, details);
            if (overdueInfo.getOverdue() != null && overdueInfo.getOverdue()
                    && overdueInfo.getOverdueFee() != null && overdueInfo.getOverdueFee() > 0) {
                vo.setOverdueStatus(Constants.ONE);
                vo.setOverdue(true);
                vo.setOverdueDays(overdueInfo.getOverdueDays());
                vo.setOverdueFee(overdueInfo.getOverdueFee());
            } else {
                vo.setOverdueStatus(Constants.ZERO);
                vo.setOverdue(false);
                vo.setOverdueDays(0);
                vo.setOverdueFee(0L);
            }
        }
        // 逾期状态：0=未到店未逾期 1=未到店存在逾期 2=已到店未逾期 3=已到店待支付逾期 4=逾期已支付
        fillOverdueStatus(vo, order, details);

        // 退款信息（status=99取消时返回）
        if (order.getStatus() != null &&
@@ -1907,9 +1930,10 @@
                    Constants.SmsNotify.MEMBER_CANCELLED, "orderNo", order.getCode());

            // 调用微信退款V3，全额退款
            String outRefundNo = ID.nextGUID();
            com.wechat.pay.java.service.refund.model.Refund refundResult;
            try {
                refundResult = wxPayV3Service.refund(order.getOutTradeNo(), order.getPayAmount(), order.getPayAmount(),
                refundResult = wxPayV3Service.refund(outRefundNo, order.getOutTradeNo(), order.getPayAmount(), order.getPayAmount(),
                        "订单退款", wxPayProperties.getV3RefundNotifyUrl());
            } catch (Exception e) {
                log.error("待寄存订单退款调用异常, orderId={}", orderId, e);
@@ -1927,7 +1951,7 @@
            refund.setDeleted(Constants.ZERO);
            refund.setBeforeStatus(Constants.OrderStatus.waitDeposit.getStatus());
            refund.setRefundAmount(order.getPayAmount());
            refund.setRefundCode(refundResult.getOutRefundNo());
            refund.setRefundCode(outRefundNo);

            if (com.wechat.pay.java.service.refund.model.Status.SUCCESS.equals(refundStatus)) {
                // 退款成功
@@ -1969,7 +1993,8 @@
                    .set(Orders::getTakeLocation, order.getDepositLocation())
                    .set(Orders::getTakeLocationRemark, order.getDepositLocationRemark())
                    .set(Orders::getTakeLat, order.getDepositLat())
                    .set(Orders::getTakeLgt, order.getDepositLgt());
                    .set(Orders::getTakeLgt, order.getDepositLgt())
                    .set(Orders::getExpectedTakeTime, new Date());
            if (Constants.equalsInteger(status, Constants.OrderStatus.accepted.getStatus())) {
                updateWrapper.lambda()
                        .set(Orders::getAcceptDriver, null)
@@ -2135,6 +2160,20 @@
            }
        }
        ordersMapper.updateById(order);

        // 支付成功日志
        OrderLog payLog = new OrderLog();
        payLog.setOrderId(order.getId());
        payLog.setTitle(Constants.OrderLogType.payOrder.getTitle());
        payLog.setLogInfo(Constants.OrderLogType.payOrder.format(
                String.valueOf(order.getTotalAmount() != null ? order.getTotalAmount() / 100.0 : 0)));
        payLog.setObjType(Constants.OrderLogType.payOrder.getStatus());
        payLog.setOrderStatus(order.getStatus());
        payLog.setOptUserId(order.getMemberId());
        payLog.setOptUserType(0);
        payLog.setCreateTime(now);
        payLog.setDeleted(Constants.ZERO);
        orderLogService.create(payLog);

        // 通知会员：订单待核验
        sendOrderNotice(order.getMemberId(), Constants.MemberOrderNotify.WAIT_VERIFY, order.getId(),
@@ -2638,6 +2677,186 @@

    @Override
    @Transactional(rollbackFor = {Exception.class, BusinessException.class})
    public void verifyOrder(String verifyCode, Integer shopId, List<String> images, String remark) {
        if (StringUtils.isBlank(verifyCode)) {
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "核销码不能为空");
        }
        // 先查会员核销码
        Orders query = new Orders();
        query.setMemberVerifyCode(verifyCode);
        query.setDeleted(Constants.ZERO);
        Orders byMemberCode = findOne(query);
        if (byMemberCode != null) {
            shopVerifyOrder(verifyCode, shopId, images, remark);
        } else {
            driverVerifyOrder(verifyCode, images, remark, shopId);
        }
    }

    @Override
    @Transactional(rollbackFor = {Exception.class, BusinessException.class})
    public void verifyOrderByShopId(Integer orderId, Integer shopId, List<String> images, String remark) {
        if (orderId == null) {
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "订单主键不能为空");
        }
        // 根据订单主键查找订单
        Orders order = ordersMapper.selectOne(new QueryWrapper<Orders>().lambda()
                .eq(Orders::getId, orderId)
                .eq(Orders::getDeleted, Constants.ZERO)
                .last("limit 1"));
        if (order == null) {
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(), "订单不存在");
        }

        // 查询门店名称用于日志
        String shopName = "";
        ShopInfo shopInfo = shopInfoMapper.selectById(shopId);
        if (shopInfo != null) {
            shopName = shopInfo.getName() != null ? shopInfo.getName() : "";
        }

        Integer status = order.getStatus();
        Date now = new Date();
        if (Constants.equalsInteger(status, Constants.OrderStatus.waitDeposit.getStatus())) {
            // 待寄存(1) → 已寄存(2)，两种类型通用
            // 校验当前门店是否为订单的存件门店
            if (!shopId.equals(order.getDepositShopId())) {
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "该订单不属于当前门店，无法核销");
            }
            order.setStatus(Constants.equalsInteger(order.getType(),Constants.ZERO)?Constants.OrderStatus.arrived.getStatus():Constants.OrderStatus.deposited.getStatus());
            order.setDepositTime(now);
            // 释放当前核销码，生成新的核销码供取件时使用
            String verifyCode = order.getMemberVerifyCode();
            if (StringUtils.isNotBlank(verifyCode)) {
                releaseVerifyCode(verifyCode);
            }
            order.setMemberVerifyCode(generateVerifyCode());
            ordersMapper.updateById(order);
            // 保存寄存图片（obj_type=2 订单寄存图片，最多3张）
            saveVerifyImages(order.getId(), images, Constants.FileType.ORDER_DEPOSIT.getKey(), shopId);
            // 记录订单日志
            saveShopVerifyLog(order, Constants.OrderLogType.shopDeposit, Constants.OrderLogType.shopDeposit.format(shopName), remark, shopId);
            // 通知会员：门店核销成功
            if (Constants.equalsInteger(order.getType(), Constants.ONE)) {
                // 异地寄存 → 待抢单
                sendOrderNotice(order.getMemberId(), Constants.MemberOrderNotify.WAIT_GRAB, order.getId(),
                        "orderNo", order.getCode());
            } else {
                // 就地寄存 → 待取件提醒
                sendOrderNotice(order.getMemberId(), Constants.MemberOrderNotify.WAIT_PICKUP_REMIND, order.getId(),
                        "orderNo", order.getCode(), "shopName", shopName);
            }
        } else if (Constants.equalsInteger(status, Constants.OrderStatus.arrived.getStatus())) {
            // 异地寄存 + 无取件门店 → 无法核销（客户自取，无门店操作）
            if (Constants.equalsInteger(order.getType(), Constants.ONE) && order.getTakeShopId() == null) {
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "该订单无取件门店，无法核销");
            }
            // 校验取件门店与当前登录门店一致
            if (!shopId.equals(order.getTakeShopId())) {
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "该订单不属于当前门店，无法核销");
            }
            // 校验是否已确认顾客到店
            if (order.getConfirmArriveTime() == null) {
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "请先确认顾客到店");
            }
            // 校验是否存在待处理的逾期费用
            if (Constants.equalsInteger(order.getOverdueStatus(), Constants.ONE)) {
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "存在逾期费用待处理，请先完成逾期费用支付");
            }
            // 待取件(5) → 已完成(7)
            order.setStatus(Constants.OrderStatus.finished.getStatus());
            order.setConfirmArriveTime(now);
            ordersMapper.updateById(order);
            // 订单完成，释放核销码
            String verifyCode = order.getMemberVerifyCode();
            if (StringUtils.isNotBlank(verifyCode)) {
                releaseVerifyCode(verifyCode);
            }
            // 保存出库图片（obj_type=13 门店出库图片，最多3张）
            saveVerifyImages(order.getId(), images, Constants.FileType.STORE_OUT.getKey(), shopId);
            // 生成收益记录
            calculateAndSaveOrderFees(order.getId());
            generateRevenueRecords(order.getId());
            // 记录订单日志
            saveShopVerifyLog(order, Constants.OrderLogType.shopTake, Constants.OrderLogType.shopTake.format(shopName), remark, shopId);
            // 通知会员：订单已完成
            sendOrderNotice(order.getMemberId(), Constants.MemberOrderNotify.FINISHED, order.getId(),
                    "orderNo", order.getCode());
            // 通知存件门店和取件门店：订单已完成
            String settleDays = operationConfigBiz.getConfig().getSettlementDate();
            notifyBothShops(order, Constants.ShopOrderNotify.FINISHED,
                    "orderNo", order.getCode(),
                    "settleDays", settleDays != null ? settleDays : "7");
            // 通知司机：订单已完成
            if (order.getAcceptDriver() != null) {
                sendDriverNotice(order.getAcceptDriver(), Constants.DriverOrderNotify.FINISHED, order.getId(),
                        "orderNo", order.getCode(),
                        "settleDays", settleDays != null ? settleDays : "7");
            }
        }else if(Constants.equalsInteger(order.getStatus(), Constants.OrderStatus.delivering.getKey())){
            // 仅异地寄存 + 有取件门店 + 派送中(4) 可核销
            if (!Constants.equalsInteger(order.getType(), Constants.ONE)) {
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "仅异地寄存订单支持司机核销");
            }
            if (order.getTakeShopId() == null) {
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "该订单无取件门店，无需司机核销");
            }
            if (!Constants.equalsInteger(order.getStatus(), Constants.OrderStatus.delivering.getStatus())) {
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "当前订单状态不允许核销");
            }
            // 校验取件门店与当前登录门店一致
            if (!shopId.equals(order.getTakeShopId())) {
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "该订单不属于当前门店，无法核销");
            }
            // 派送中(4) → 已到店(5)
            order.setStatus(Constants.OrderStatus.arrived.getStatus());
            order.setArriveTime(new Date());
            if (StringUtils.isNotBlank(remark)) {
                order.setRemark(remark);
            }
            ordersMapper.updateById(order);

            // 释放司机核销码
            releaseVerifyCode(order.getDriverVerifyCode());

            // 保存附件（obj_type=3 门店入库图片，最多3张）
            saveVerifyImages(order.getId(), images, Constants.FileType.ORDER_TAKE.getKey(), order.getAcceptDriver());

            // 通知会员：订单已送达
            String destination = order.getTakeShopAddress() != null ? order.getTakeShopAddress() : "";
            if (order.getMemberVerifyCode() != null) {
                sendOrderNotice(order.getMemberId(), Constants.MemberOrderNotify.ARRIVED_HAS_SHOP, order.getId(),
                        "orderNo", order.getCode(),
                        "destination", destination,
                        "pickupCode", order.getMemberVerifyCode());
            } else {
                sendOrderNotice(order.getMemberId(), Constants.MemberOrderNotify.ARRIVED_NO_SHOP, order.getId(),
                        "orderNo", order.getCode(),
                        "destination", destination);
            }

            // 通知取件门店：订单已送达
            if (order.getTakeShopId() != null) {
                sendShopNotice(order.getTakeShopId(), Constants.ShopOrderNotify.ARRIVED, order.getId(),
                        "orderNo", order.getCode(),
                        "destination", destination);
            }

            // 短信通知会员：行李已送达
            Member arrivedMember = memberMapper.selectById(order.getMemberId());
            if (arrivedMember != null) {
                sendSmsNotify(arrivedMember.getTelephone(), Constants.SmsNotify.MEMBER_ARRIVED,
                        "orderNo", order.getCode(),
                        "address", destination,
                        "code", order.getMemberVerifyCode() != null ? order.getMemberVerifyCode() : "");
            }
        }else {
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "当前订单状态不允许核销");
        }
    }

    @Override
    @Transactional(rollbackFor = {Exception.class, BusinessException.class})
    public void shopVerifyOrder(String verifyCode, Integer shopId, List<String> images, String remark) {
        if (StringUtils.isBlank(verifyCode)) {
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "核销码不能为空");
@@ -2694,6 +2913,14 @@
            // 校验取件门店与当前登录门店一致
            if (!shopId.equals(order.getTakeShopId())) {
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "该订单不属于当前门店，无法核销");
            }
            // 校验是否已确认顾客到店
            if (order.getConfirmArriveTime() == null) {
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "请先确认顾客到店");
            }
            // 校验是否存在待处理的逾期费用
            if (Constants.equalsInteger(order.getOverdueStatus(), Constants.ONE)) {
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "存在逾期费用待处理，请先完成逾期费用支付");
            }
            // 待取件(5) → 已完成(7)
            order.setStatus(Constants.OrderStatus.finished.getStatus());
@@ -2801,12 +3028,13 @@
            ordersRefundMapper.insert(refundRecord);

            // 调用微信退款V3（放在最后，确保前置操作全部成功）
            String outRefundNo2 = ID.nextGUID();
            Refund refundResult = wxPayV3Service.refund(
                    order.getOutTradeNo(), order.getPayAmount(), order.getRefundAmount(),
                    outRefundNo2, order.getOutTradeNo(), order.getPayAmount(), order.getRefundAmount(),
                    "订单退款", wxPayProperties.getV3RefundNotifyUrl());

            // 退款成功后回填退款单号，标记退款中
            refundRecord.setRefundCode(refundResult.getOutRefundNo());
            refundRecord.setRefundCode(outRefundNo2);
            refundRecord.setStatus(Constants.ZERO); // 退款中
            ordersRefundMapper.updateById(refundRecord);
        }
@@ -3275,6 +3503,62 @@
    }

    /**
    /**
     * 填充逾期状态到 VO（MyOrderVO）
     * overdueStatus: 0=未到店未逾期 1=未到店存在逾期 2=已到店未逾期 3=已到店待支付逾期 4=逾期已支付
     */
    private void fillOverdueStatus(MyOrderVO vo, Orders order, List<OrdersDetail> details) {
        Integer[] result = calcOverdueStatus(order, details);
        vo.setOverdueStatus(result[0]);
        vo.setOverdue(result[1] == 1);
        vo.setOverdueDays(result[2]);
        vo.setOverdueFee(result[3].longValue());
    }

    /**
     * 填充逾期状态到 VO（MyOrderDetailVO）
     */
    private void fillOverdueStatus(MyOrderDetailVO vo, Orders order, List<OrdersDetail> details) {
        Integer[] result = calcOverdueStatus(order, details);
        vo.setOverdueStatus(result[0]);
        vo.setOverdue(result[1] == 1);
        vo.setOverdueDays(result[2]);
        vo.setOverdueFee(result[3].longValue());
    }

    /**
     * 计算逾期状态
     * @return [overdueStatus, isOverdue(0/1), overdueDays, overdueFee]
     */
    private Integer[] calcOverdueStatus(Orders order, List<OrdersDetail> details) {
        // 4=逾期已支付（订单 overdueStatus=2）
        if (Constants.equalsInteger(order.getOverdueStatus(), Constants.TWO)) {
            return new Integer[]{4, 1, order.getOverdueDays(), order.getOverdueAmount() != null ? order.getOverdueAmount().intValue() : 0};
        }
        // 3=已到店待支付逾期（订单 overdueStatus=1）
        if (Constants.equalsInteger(order.getOverdueStatus(), Constants.ONE)) {
            return new Integer[]{3, 1, order.getOverdueDays(), order.getOverdueAmount() != null ? order.getOverdueAmount().intValue() : 0};
        }
        // 计算实时逾期
        OverdueFeeVO overdueInfo = calculateOverdueFeeInternal(order, details);
        boolean hasOverdue = overdueInfo.getOverdue() != null && overdueInfo.getOverdue()
                && overdueInfo.getOverdueFee() != null && overdueInfo.getOverdueFee() > 0;
        if (order.getConfirmArriveTime() != null) {
            // 已到店
            int days = hasOverdue ? overdueInfo.getOverdueDays() : 0;
            long fee = hasOverdue ? overdueInfo.getOverdueFee() : 0L;
            return new Integer[]{2, hasOverdue ? 1 : 0, days, (int) fee};
        } else {
            // 未到店
            if (hasOverdue) {
                return new Integer[]{1, 1, overdueInfo.getOverdueDays(), overdueInfo.getOverdueFee().intValue()};
            } else {
                return new Integer[]{0, 0, 0, 0};
            }
        }
    }

    /**
     * 逾期费用内部计算（不查库，接受预查询的数据）
     * 供分页等已查询明细的业务场景复用，避免重复查询
     */
@@ -3376,26 +3660,20 @@

    /**
     * 就地寄存逾期天数计算
     * 过了预计取件时间当天的24:00（次日00:00）后才算第一天
     * 过了预计取件日期的次日（只比较年月日）后开始计逾期天数
     */
    private int calcLocalOverdueDays(Date now, Date expectedTakeTime) {
        if (expectedTakeTime == null || !now.after(expectedTakeTime)) {
        if (expectedTakeTime == null) {
            return 0;
        }
        // 基准时间 = 预计取件日期的次日 00:00（即当天24:00）
        // 只取年月日
        Calendar baseCal = Calendar.getInstance();
        baseCal.setTime(expectedTakeTime);
        baseCal.set(Calendar.HOUR_OF_DAY, 0);
        baseCal.set(Calendar.MINUTE, 0);
        baseCal.set(Calendar.SECOND, 0);
        baseCal.set(Calendar.MILLISECOND, 0);
        baseCal.add(Calendar.DAY_OF_MONTH, 1); // 次日00:00 = 当天24:00
        Date baseTime = baseCal.getTime();

        if (!now.after(baseTime)) {
            return 0;
        }
        // 逾期天数 = 当前日期 - 基准日期（按天取差）
        Calendar nowCal = Calendar.getInstance();
        nowCal.setTime(now);
        nowCal.set(Calendar.HOUR_OF_DAY, 0);
@@ -3403,40 +3681,31 @@
        nowCal.set(Calendar.SECOND, 0);
        nowCal.set(Calendar.MILLISECOND, 0);

        Calendar baseDateCal = Calendar.getInstance();
        baseDateCal.setTime(baseTime);
        baseDateCal.set(Calendar.HOUR_OF_DAY, 0);
        baseDateCal.set(Calendar.MINUTE, 0);
        baseDateCal.set(Calendar.SECOND, 0);
        baseDateCal.set(Calendar.MILLISECOND, 0);

        long diffMs = nowCal.getTimeInMillis() - baseDateCal.getTimeInMillis();
        int days = (int) (diffMs / (1000 * 60 * 60 * 24));
        return Math.max(days, 0);
        // 基准日期 = 预计取件日期的次日，当天及之前不算逾期
        if (nowCal.before(baseCal)) {
            return 0;
        }
        // 逾期天数 = 当前日期 - 基准日期
        long diffMs = nowCal.getTimeInMillis() - baseCal.getTimeInMillis();
        return (int) (diffMs / (1000 * 60 * 60 * 24));
    }

    /**
     * 异地寄存逾期天数计算
     * 过了转移到店时间当天的晚上12点（24:00）后才算第一天
     * 过了转移到店日期的次日（只比较年月日）后开始计逾期天数
     */
    private int calcRemoteOverdueDays(Date now, Date arriveTime) {
        if (arriveTime == null || !now.after(arriveTime)) {
        if (arriveTime == null) {
            return 0;
        }
        // 基准时间 = 转移到店日期的次日 00:00（即当天24:00）
        // 只取年月日
        Calendar baseCal = Calendar.getInstance();
        baseCal.setTime(arriveTime);
        baseCal.set(Calendar.HOUR_OF_DAY, 0);
        baseCal.set(Calendar.MINUTE, 0);
        baseCal.set(Calendar.SECOND, 0);
        baseCal.set(Calendar.MILLISECOND, 0);
        baseCal.add(Calendar.DAY_OF_MONTH, 1); // 次日00:00 = 当天24:00
        Date baseTime = baseCal.getTime();

        if (!now.after(baseTime)) {
            return 0;
        }
        // 逾期天数 = 当前日期 - 基准日期
        Calendar nowCal = Calendar.getInstance();
        nowCal.setTime(now);
        nowCal.set(Calendar.HOUR_OF_DAY, 0);
@@ -3444,16 +3713,14 @@
        nowCal.set(Calendar.SECOND, 0);
        nowCal.set(Calendar.MILLISECOND, 0);

        Calendar baseDateCal = Calendar.getInstance();
        baseDateCal.setTime(baseTime);
        baseDateCal.set(Calendar.HOUR_OF_DAY, 0);
        baseDateCal.set(Calendar.MINUTE, 0);
        baseDateCal.set(Calendar.SECOND, 0);
        baseDateCal.set(Calendar.MILLISECOND, 0);

        long diffMs = nowCal.getTimeInMillis() - baseDateCal.getTimeInMillis();
        int days = (int) (diffMs / (1000 * 60 * 60 * 24));
        return Math.max(days, 0);
        // 基准日期 = 到店日期的次日，当天及之前不算逾期
        baseCal.add(Calendar.DAY_OF_MONTH, 1);
        if (nowCal.before(baseCal)) {
            return 0;
        }
        // 逾期天数 = 当前日期 - 基准日期
        long diffMs = nowCal.getTimeInMillis() - baseCal.getTimeInMillis();
        return (int) (diffMs / (1000 * 60 * 60 * 24));
    }

    @Override
@@ -3472,6 +3739,7 @@
        ActiveOrderTipVO vo = new ActiveOrderTipVO();
        vo.setOrderId(order.getId());
        vo.setStatus(order.getStatus());
        vo.setStatusDesc(Constants.OrderStatus.getDescByKey(order.getStatus(), order.getType()));

        // 构建提示文案
        boolean isLocal = Constants.equalsInteger(order.getType(), Constants.ZERO);