修改bug

mitao

2024-08-16 d7dc4db8d005a58f51d21d35147317762a16373f

 ruoyi-modules/ruoyi-order/src/main/java/com/ruoyi/order/service/impl/PaylogServiceImpl.java

@@ -1,8 +1,6 @@
package com.ruoyi.order.service.impl;

import static com.ruoyi.order.util.tencent.WXPay.requestRefundService;
import static com.ruoyi.order.util.tencent.WXPay.requestUnifiedorderService;

import com.alibaba.fastjson2.JSON;
import com.alipay.api.AlipayClient;
import com.alipay.api.DefaultAlipayClient;
import com.alipay.api.request.AlipayTradeRefundRequest;
@@ -14,6 +12,7 @@
import com.jpay.weixin.api.WxPayApi;
import com.ruoyi.common.core.constant.SecurityConstants;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.enums.AuctionOrderTypeEnum;
import com.ruoyi.common.core.enums.BondStatusEnum;
import com.ruoyi.common.core.enums.OrderStatusEnum;
import com.ruoyi.common.core.enums.PaymentMethodEnum;
@@ -23,33 +22,45 @@
import com.ruoyi.order.mapper.OrderAuctionBondMapper;
import com.ruoyi.order.mapper.OrderMapper;
import com.ruoyi.order.mapper.PaylogMapper;
import com.ruoyi.order.service.IOrderAuctionBondService;
import com.ruoyi.order.service.IPaylogService;
import com.ruoyi.order.util.MD5AndKL;
import com.ruoyi.order.util.OrderUtil;
import com.ruoyi.order.util.SinataUtil;
import com.ruoyi.order.util.alipay.config.AlipayConfig;
import com.ruoyi.order.util.alipay.util.PayDemoActivity;
import com.ruoyi.order.util.tencent.common.Configure;
import com.ruoyi.order.util.tencent.common.Signature;
import com.ruoyi.order.util.tencent.common.XMLParser;
import com.ruoyi.order.util.tencent.protocol.AppPayReqData;
import com.ruoyi.order.util.tencent.protocol.UnifiedorderReqData;
import com.ruoyi.system.api.domain.AuctionBondJl;
import com.ruoyi.system.api.domain.GoodsGroupPurchase;
import com.ruoyi.system.api.domain.GoodsGroupPurchaseInfo;
import com.ruoyi.system.api.domain.GoodsSku;
import com.ruoyi.system.api.domain.Member;
import com.ruoyi.system.api.domain.Order;
import com.ruoyi.system.api.domain.OrderAuctionBond;
import com.ruoyi.system.api.domain.dto.BondDTO;
import com.ruoyi.system.api.domain.dto.MemberPointsDTO;
import com.ruoyi.system.api.domain.dto.RefundDTO;
import com.ruoyi.system.api.domain.dto.updMembeOneDTO;
import com.ruoyi.system.api.feignClient.AuctionClient;
import com.ruoyi.system.api.feignClient.GoodsSkuClient;
import com.ruoyi.system.api.feignClient.MemberClient;

import java.io.*;
import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.UUID;
import java.util.function.Function;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@@ -57,10 +68,8 @@
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.ruoyi.system.api.feignClient.OrderClient;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;

/**
 * <p>
@@ -70,13 +79,14 @@
 * @author mitao
 * @since 2024-05-22
 */
@Slf4j
@Service
public class PaylogServiceImpl extends ServiceImpl<PaylogMapper, Paylog> implements IPaylogService {



    @Resource
    private OrderMapper OrderMapper;
    private OrderMapper orderMapper;
    @Resource
    private AuctionClient auctionClient;

@@ -88,169 +98,130 @@
    private OrderAuctionBondMapper orderAuctionBondMapper;

    @Resource
    private GoodsSkuClient GoodsSkuClient;
    private GoodsSkuClient goodsSkuClient;

    @Resource
    private PaylogMapper paylogMapper;

    @Override
    public R<Map<String, Object>> getPayInfo(Integer uid, Integer type, String orderNO,String openId, HttpServletRequest request) {
    public R<Map<String, Object>> getPayInfo(Long uid, Integer type, String orderNO, String openId,
            HttpServletRequest request) {
        PaymentMethodEnum paymentMethodEnum =
                type == 1 ? PaymentMethodEnum.ALIPAY : PaymentMethodEnum.WECHAT;
        Member member = memberClient.getMembeOne(uid, SecurityConstants.INNER).getData();
        openId = member.getMiniOpenid();
        String zfbOpenid = member.getZfbOpenid();
        Double price = 0.0;
        String subject;
        String body;
        try {
            if(judgeContainsStr(orderNO)){


                if (orderNO.contains("BO")) {
                    LambdaQueryWrapper<OrderAuctionBond> wrapper1= Wrappers.lambdaQuery();
                    wrapper1.eq(OrderAuctionBond::getOrderNo,orderNO);
                    wrapper1.eq(OrderAuctionBond::getDelFlag,0);
                    OrderAuctionBond one1 = orderAuctionBondMapper.selectOne(wrapper1);
        if (judgeContainsStr(orderNO)) {
            if (orderNO.contains("BO")) {
                LambdaQueryWrapper<OrderAuctionBond> wrapper1 = Wrappers.lambdaQuery();
                wrapper1.eq(OrderAuctionBond::getOrderNo, orderNO);
                wrapper1.eq(OrderAuctionBond::getDelFlag, 0);
                OrderAuctionBond one1 = orderAuctionBondMapper.selectOne(wrapper1);
                if (one1.getBond() == null || one1.getBond().compareTo(new BigDecimal(0)) == 0) {
                    one1.setBoundStatus(BondStatusEnum.PAID);
                    one1.setPaymentMethod(PaymentMethodEnum.WECHAT);
                    orderAuctionBondMapper.updateById(one1);
                    Map<String, Object> returnMap = new HashMap<>();
                    // Type 1是否需要支付
                    returnMap.put("Type", 1);
                    return R.ok(returnMap);
                }

                }else{
                    LambdaQueryWrapper<Order> wrapper1= Wrappers.lambdaQuery();
                    wrapper1.eq(Order::getOrderNo,orderNO);
                    wrapper1.eq(Order::getDelFlag,0);
                    Order page1 = OrderMapper.selectOne(wrapper1);
            } else {
                LambdaQueryWrapper<Order> wrapper1 = Wrappers.lambdaQuery();
                wrapper1.eq(Order::getOrderNo, orderNO);
                wrapper1.eq(Order::getDelFlag, 0);
                Order page1 = orderMapper.selectOne(wrapper1);
                if (page1.getTotalAmount().compareTo(new BigDecimal(0)) == 0) {
                    Map<String, Object> returnMap = new HashMap<>();
                    returnMap.put("Type", 1);
                    page1.setOrderStatus(OrderStatusEnum.TO_BE_SHIPPED);
                    page1.setPaymentMethod(PaymentMethodEnum.WECHAT);
                    page1.setPaymentMethod(paymentMethodEnum);
                    page1.setPayTime(LocalDateTime.now());
                    OrderMapper.updateById(page1);

                    if(page1.getOrderNo().contains("SP")){
                        GoodsSku goodsSku =new GoodsSku();
                    orderMapper.updateById(page1);
                    if (page1.getOrderNo().contains("SP")) {
                        GoodsSku goodsSku = new GoodsSku();
                        goodsSku.setId(page1.getGoodsSkuId());
                        goodsSku.setSoldQuantity(page1.getGoodsQuantity());
                        GoodsSkuClient.updGoods(goodsSku, SecurityConstants.INNER);
                        goodsSkuClient.updGoods(goodsSku, SecurityConstants.INNER);
                    }

                    if(page1.getOrderNo().contains("MS")){
                        GoodsSku goodsSku =new GoodsSku();
                        goodsSku.setId(page1.getGoodsSkuId());
                        goodsSku.setSoldQuantity(page1.getGoodsQuantity());
                        GoodsSkuClient.updGoodsSeckill1(goodsSku, SecurityConstants.INNER);
                    }

                    MemberPointsDTO memberPointsDTO=new MemberPointsDTO();
                    return R.ok(returnMap);
                }
                if (page1.getPoints() != 0) {
                    MemberPointsDTO memberPointsDTO = new MemberPointsDTO();
                    memberPointsDTO.setMemberId(page1.getMemberId());
                    memberPointsDTO.setPointsType(1);
                    memberPointsDTO.setPointsStatus(PointStatusEnum.INCREASE);
                    memberPointsDTO.setPoints(page1.getPoints());
                    memberClient.addMemberPoints(memberPointsDTO);
                    updMembeOneDTO MembeOneDTO=new updMembeOneDTO();
                    MembeOneDTO.setType(1);
                    MembeOneDTO.setMemberId(page1.getMemberId());
                    MembeOneDTO.setMoney(page1.getTotalAmount());
                    MembeOneDTO.setTotalPoints(page1.getPoints());
                    memberClient.updMembeOne(MembeOneDTO, SecurityConstants.INNER);
                }



                /*if (orderNO.contains("BO")) {
                    LambdaQueryWrapper<OrderAuctionBond> wrapper1= Wrappers.lambdaQuery();
                    wrapper1.eq(OrderAuctionBond::getOrderNo,orderNO);
                    wrapper1.eq(OrderAuctionBond::getDelFlag,0);
                    OrderAuctionBond one1 = orderAuctionBondMapper.selectOne(wrapper1);
                    if (one1.getBond().compareTo(new BigDecimal(0))==0){
                        one1.setBoundStatus(BondStatusEnum.PAID);
                        Map<String, Object> returnMap = new HashMap<>();
                        returnMap.put("Type",1);
                       return R.ok(returnMap);
                    }


                }else{
                    LambdaQueryWrapper<Order> wrapper1= Wrappers.lambdaQuery();
                    wrapper1.eq(Order::getOrderNo,orderNO);
                    wrapper1.eq(Order::getDelFlag,0);
                    Order page1 = OrderMapper.selectOne(wrapper1);
                    if (page1.getTotalAmount().compareTo(new BigDecimal(0))==0){
                        page1.setOrderStatus(OrderStatusEnum.TO_BE_SHIPPED);
                        page1.setPayTime(LocalDateTime.now());
                        OrderMapper.updateById(page1);
                        Map<String, Object> returnMap = new HashMap<>();
                        returnMap.put("Type",1);


                        page1.setOrderStatus(OrderStatusEnum.TO_BE_SHIPPED);
                        page1.setPayTime(LocalDateTime.now());
                        OrderMapper.updateById(page1);

                        if(page1.getOrderNo().contains("SP")){
                            GoodsSku goodsSku =new GoodsSku();
                            goodsSku.setId(page1.getGoodsSkuId());
                            goodsSku.setSoldQuantity(page1.getGoodsQuantity());
                            GoodsSkuClient.updGoods(goodsSku, SecurityConstants.INNER);
                        }

                        if(page1.getOrderNo().contains("MS")){
                            GoodsSku goodsSku =new GoodsSku();
                            goodsSku.setId(page1.getGoodsSkuId());
                            goodsSku.setSoldQuantity(page1.getGoodsQuantity());
                            GoodsSkuClient.updGoodsSeckill1(goodsSku, SecurityConstants.INNER);
                        }


                        MemberPointsDTO memberPointsDTO=new MemberPointsDTO();
                        memberPointsDTO.setMemberId(page1.getMemberId());
                        memberPointsDTO.setPointsType(1);
                        memberPointsDTO.setPointsStatus(PointStatusEnum.INCREASE);
                        memberPointsDTO.setPoints(page1.getPoints());
                        memberClient.addMemberPoints(memberPointsDTO);

                        updMembeOneDTO MembeOneDTO=new updMembeOneDTO();
                        MembeOneDTO.setType(1);
                        MembeOneDTO.setMemberId(page1.getMemberId());
                        MembeOneDTO.setMoney(page1.getTotalAmount());
                        MembeOneDTO.setTotalPoints(page1.getPoints());
                        memberClient.updMembeOne(MembeOneDTO, SecurityConstants.INNER);


                        return R.ok(returnMap);
                    }



                }*/

                if (orderNO.contains("BO")) {
                    LambdaQueryWrapper<OrderAuctionBond> wrapper1= Wrappers.lambdaQuery();
                    wrapper1.eq(OrderAuctionBond::getOrderNo,orderNO);
                    wrapper1.eq(OrderAuctionBond::getDelFlag,0);
                    OrderAuctionBond one = orderAuctionBondMapper.selectOne(wrapper1);
                    price=one.getBond().doubleValue();
                    body = " 订单支付";
                    subject = " 订单支付";
                    if (type == 1) {
                        // 支付宝预下单
                        return this.alipay(orderNO, subject, body, price, request);
                    } if (type == 2){
                        // 微信预下单
                        return this.wxpay(2, orderNO, body, openId, price, request);
                    }
                }else{
                    LambdaQueryWrapper<Order> wrapper1= Wrappers.lambdaQuery();
                    wrapper1.eq(Order::getOrderNo,orderNO);
                    wrapper1.eq(Order::getDelFlag,0);
                    Order page1 = OrderMapper.selectOne(wrapper1);
                    price=page1.getTotalAmount().doubleValue();
                    body = " 订单支付";
                    subject = " 订单支付";
                    Map<String, Object> map = new HashMap<String, Object>();
                    if (type == 1) {
                        // 支付宝预下单
                        return this.alipay(orderNO, subject, body, price, request);
                    } if (type == 2) {
                        // 微信预下单
                        return this.wxpay(2,page1.getOrderTimeSx(), orderNO, body,openId, price, request);
                    }
                }

                updMembeOneDTO MembeOneDTO = new updMembeOneDTO();
                MembeOneDTO.setType(1);
                MembeOneDTO.setMemberId(page1.getMemberId());
                MembeOneDTO.setMoney(page1.getTotalAmount());
                MembeOneDTO.setTotalPoints(page1.getPoints());
                memberClient.updMembeOne(MembeOneDTO, SecurityConstants.INNER);
            }
        } catch (Exception e) {
            e.printStackTrace();

            if (orderNO.contains("BO")) {
                LambdaQueryWrapper<OrderAuctionBond> wrapper1 = Wrappers.lambdaQuery();
                wrapper1.eq(OrderAuctionBond::getOrderNo, orderNO);
                wrapper1.eq(OrderAuctionBond::getDelFlag, 0);
                OrderAuctionBond one = orderAuctionBondMapper.selectOne(wrapper1);
                price = one.getBond().doubleValue();
                body = " 订单支付";
                subject = " 订单支付";
                if (type == 1) {
                    // 支付宝预下单
                    return this.alipay(zfbOpenid, orderNO, subject, body, price, request);
                }
                if (type == 2) {
                    // 微信预下单
                    R<Map<String, Object>> wxpayR = this.wxpay(2, orderNO, body, openId, price,
                            request);
                    Map<String, Object> wxpay = wxpayR.getData();
                    if (wxpay.get(
                            "result_code").equals("FAIL") && wxpay.get("err_code_des")
                            .equals("201 商户订单号重复")) {
                        one.setOrderNo(OrderUtil.getOrderNoForPrefix("BO"));
                        orderAuctionBondMapper.updateById(one);
                        wxpayR = this.wxpay(2, one.getOrderNo(), body, openId, price,
                                request);
                    }
                    return wxpayR;
                }
            } else {
                LambdaQueryWrapper<Order> wrapper1 = Wrappers.lambdaQuery();
                wrapper1.eq(Order::getOrderNo, orderNO);
                wrapper1.eq(Order::getDelFlag, 0);
                Order page1 = orderMapper.selectOne(wrapper1);
                price = page1.getTotalAmount().doubleValue();
                body = " 订单支付";
                subject = " 订单支付";
                Map<String, Object> map = new HashMap<String, Object>();
                if (type == 1) {
                    // 支付宝预下单
                    return this.alipay(zfbOpenid, orderNO, subject, body, price, request);
                }
                if (type == 2) {
                    // 微信预下单
                    R<Map<String, Object>> wxpayR = this.wxpay(2, orderNO, body, openId, price,
                            request);
                    Map<String, Object> wxpay = wxpayR.getData();
                    if (wxpay.get("result_code").equals("FAIL") && wxpay.get("err_code_des")
                            .equals("201 商户订单号重复")) {
                        String prefix = page1.getOrderNo().substring(0, 2);
                        page1.setOrderNo(OrderUtil.getOrderNoForPrefix(prefix));
                        orderMapper.updateById(page1);
                        wxpayR = this.wxpay(2, page1.getOrderNo(), body, openId, price,
                                request);
                    }
                    return wxpayR;
                }
            }
        }
        return R.fail("获取异常");
    }
@@ -264,6 +235,7 @@
     */
    @Override
    public void notifyUrl(HttpServletRequest request, HttpServletResponse res) {
        log.info("=============================支付宝回调=============================");
        HttpServletResponse response = (HttpServletResponse) res;
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out;
@@ -305,47 +277,109 @@
                            wrapper1.eq(OrderAuctionBond::getOrderNo,paylog1.getOutTradeNo());
                            wrapper1.eq(OrderAuctionBond::getDelFlag,0);
                            OrderAuctionBond one1 = orderAuctionBondMapper.selectOne(wrapper1);

                            if (one1.getBondType().equals(AuctionOrderTypeEnum.REGULAR_ITEMS) &&
                                    one1.getOrderTimeSx().isBefore(LocalDateTime.now())) {
                                boolean bo = refundForAlipay(paylog1.getOutTradeNo(), paylog1.getTradeNo(), paylog1.getPayMoney());
                            }

                            one1.setBoundStatus(BondStatusEnum.PAID);
                            orderAuctionBondMapper.updateById(one1);
                            AuctionOrderTypeEnum bondType = one1.getBondType();
                            AuctionBondJl auctionBondJl = null;
                            if (bondType.equals(AuctionOrderTypeEnum.AUCTION_ITEMS)) {
                                auctionBondJl = auctionClient.getAuctionBondJLByTargetId(
                                                one1.getAuctionSalesroomId(), one1.getMemberId(),
                                                bondType.getCode(), SecurityConstants.INNER)
                                        .getData();
                                log.info("保证金支付回调，添加拍卖参与记录开始进行");
                                if (Objects.isNull(auctionBondJl)) {
                                    auctionBondJl = new AuctionBondJl();
                                    auctionBondJl.setAuctionSalesroomId(
                                            one1.getAuctionSalesroomId());
                                    auctionBondJl.setIsState(0);
                                    auctionBondJl.setBondType(bondType.getCode());
                                    auctionBondJl.setMemberId(
                                            one1.getMemberId());
                                } else {
                                    auctionBondJl.setIsState(0);
                                }
                            } else {
                                auctionBondJl = auctionClient.getAuctionBondJLByTargetId(
                                                one1.getAuctionGoodsId(), one1.getMemberId(),
                                                bondType.getCode(), SecurityConstants.INNER)
                                        .getData();
                                if (Objects.isNull(auctionBondJl)) {
                                    auctionBondJl = new AuctionBondJl();
                                    auctionBondJl.setAuctionGoodsId(one1.getAuctionGoodsId());
                                    auctionBondJl.setIsState(0);
                                    auctionBondJl.setBondType(bondType.getCode());
                                    auctionBondJl.setMemberId(
                                            one1.getMemberId());
                                } else {
                                    auctionBondJl.setIsState(0);
                                }
                            }
                            auctionClient.saveOrUpdateAuctionBondJl(auctionBondJl,
                                    SecurityConstants.INNER);
                            log.info("保证金支付回调，添加拍卖参与记录结束");
                        }else{
                            LambdaQueryWrapper<Order> wrapper1= Wrappers.lambdaQuery();
                            wrapper1.eq(Order::getOrderNo,paylog1.getOutTradeNo());
                            wrapper1.eq(Order::getDelFlag,0);
                            Order page1 = OrderMapper.selectOne(wrapper1);
                            Order page1 = orderMapper.selectOne(wrapper1);

                            page1.setOrderStatus(OrderStatusEnum.TO_BE_SHIPPED);
                            page1.setPaymentMethod(PaymentMethodEnum.ALIPAY);
                            page1.setPayTime(LocalDateTime.now());
                            orderMapper.updateById(page1);
                            if(page1.getOrderNo().contains("SP")){
                                GoodsSku goodsSku =new GoodsSku();
                                goodsSku.setId(page1.getGoodsSkuId());
                                goodsSku.setSoldQuantity(page1.getGoodsQuantity());
                                GoodsSkuClient.updGoods(goodsSku, SecurityConstants.INNER);
                                goodsSkuClient.updGoods(goodsSku, SecurityConstants.INNER);
                            }

                            if(page1.getOrderNo().contains("MS")){
                                GoodsSku goodsSku =new GoodsSku();
                                goodsSku.setId(page1.getGoodsSkuId());
                                goodsSku.setSoldQuantity(page1.getGoodsQuantity());
                                GoodsSkuClient.updGoodsSeckill1(goodsSku, SecurityConstants.INNER);
                                goodsSkuClient.updGoodsSeckill1(goodsSku, SecurityConstants.INNER);
                            }
                            page1.setOrderStatus(OrderStatusEnum.TO_BE_SHIPPED);
                            page1.setPayTime(LocalDateTime.now());
                            OrderMapper.updateById(page1);

                            MemberPointsDTO memberPointsDTO=new MemberPointsDTO();
                            memberPointsDTO.setMemberId(page1.getMemberId());
                            memberPointsDTO.setPointsType(1);
                            memberPointsDTO.setPointsStatus(PointStatusEnum.INCREASE);
                            memberPointsDTO.setPoints(page1.getPoints());
                            memberClient.addMemberPoints(memberPointsDTO);
                            updMembeOneDTO MembeOneDTO=new updMembeOneDTO();
                            MembeOneDTO.setType(1);
                            MembeOneDTO.setMemberId(page1.getMemberId());
                            MembeOneDTO.setMoney(page1.getTotalAmount());
                            MembeOneDTO.setTotalPoints(page1.getPoints());
                            memberClient.updMembeOne(MembeOneDTO, SecurityConstants.INNER);
                            if(page1.getOrderNo().contains("TG")){
                                log.info(
                                        "===================================开始处理团购回调===================================");
                                GoodsGroupPurchase goodsSeckiGoodsGroupPurchaseOne = goodsSkuClient.getGoodsSeckiGoodsGroupPurchaseOne(page1.getGoodsSkuId(), SecurityConstants.INNER).getData();
                                GoodsGroupPurchaseInfo goodsSeckiGoodsGroupPurchaseInfo = goodsSkuClient.getGoodsSeckiGoodsGroupPurchaseInfo(page1.getGoodsSkuId(), SecurityConstants.INNER).getData();
                                if (goodsSeckiGoodsGroupPurchaseInfo!=null){
                                    log.info("==================已有待成团团购================");
                                    page1.setGroupNo(goodsSeckiGoodsGroupPurchaseInfo.getMubre());
                                    orderMapper.updateById(page1);
                                    Integer i= goodsSeckiGoodsGroupPurchaseInfo.getPurchaseNum()+page1.getGoodsQuantity();
                                    goodsSeckiGoodsGroupPurchaseInfo.setPurchaseNum(i);
                                    goodsSkuClient.updgoodsGroupPurchaseInfo(goodsSeckiGoodsGroupPurchaseInfo, SecurityConstants.INNER);

                                }else{
                                    log.info("==================开启一个新团================");
                                    UUID uuid = UUID.randomUUID();
                                    page1.setGroupNo(uuid.toString());
                                    orderMapper.updateById(page1);
                                    GoodsGroupPurchaseInfo goodsGroupPurchaseInfo=new GoodsGroupPurchaseInfo();
                                    goodsGroupPurchaseInfo.setGroupSize(goodsSeckiGoodsGroupPurchaseOne.getGroupSize());
                                    goodsGroupPurchaseInfo.setCurrentNumber(1);
                                    goodsGroupPurchaseInfo.setPurchaseNum(page1.getGoodsQuantity());
                                    goodsGroupPurchaseInfo.setMubre(uuid.toString());
                                    goodsGroupPurchaseInfo.setGroupPurchaseId(goodsSeckiGoodsGroupPurchaseOne.getId());
                                    goodsGroupPurchaseInfo.setGroupStatus(0);
                                    goodsSkuClient.updgoodsGroupPurchaseInfo(goodsGroupPurchaseInfo, SecurityConstants.INNER);

                                }
                            }

                        }

                    }



                    // ——请根据您的业务逻辑来编写程序（以上代码仅作参考）——
                    log.debug("AlipayController.notifyUrl__回调处理：success");
@@ -357,7 +391,7 @@
                    log.debug("AlipayController.notifyUrl__回调逻辑代码处理异常！fail");
                    // 返回失败
                    out.println("fail");
                    e.printStackTrace();
                    log.error("AlipayController.notifyUrl__回调逻辑代码处理异常！fail", e);
                }
                // ////////////////////////////////////////////////////////////////////////////////////////
            } else {// 验证失败
@@ -367,7 +401,7 @@
        } catch (
                IOException e) {
            log.debug("AlipayController.notifyUrl__支付宝服务器异步通知数据处理失败！");
            e.printStackTrace();
            log.error("AlipayController.notifyUrl__支付宝服务器异步通知数据处理失败！", e);
        }
    }

@@ -394,97 +428,166 @@
            System.out.println("WxpayController.notify__notityXml：\n" + notityXml);

            // 验证签名
                Map<String, Object> map = XMLParser.getMapFromXML(notityXml.toString());
                // log.debug("WxpayController.notify__map：\n" + map);
                // 接口返回状态
                String result_code = (String) map.get("result_code");
                if ("SUCCESS".equals(result_code)) {
                    // // 商户订单号
                    String out_trade_no = (String) map.get("out_trade_no");
                    // // 微信支付交易号
                    String trade_no = (String) map.get("transaction_id");
                    // // 金额,以分为单位
                    String total_fee = (String) map.get("total_fee");
                    // // 优惠金额
                    // String discount = (String) map.get("discount");
                    // // 支付完成时间
                    String time_end = (String) map.get("time_end");
                    // // 支付者唯一Id（对应买家账号的一个加密串 ）
                    String buyer_id = (String) map.get("buyer_id");
            Map<String, Object> map = XMLParser.getMapFromXML(notityXml.toString());
            // log.debug("WxpayController.notify__map：\n" + map);
            // 接口返回状态
            String result_code = (String) map.get("result_code");
            if ("SUCCESS".equals(result_code)) {
                // // 商户订单号
                String out_trade_no = (String) map.get("out_trade_no");
                // // 微信支付交易号
                String trade_no = (String) map.get("transaction_id");
                // // 金额,以分为单位
                String total_fee = (String) map.get("total_fee");
                // // 优惠金额
                // String discount = (String) map.get("discount");
                // // 支付完成时间
                String time_end = (String) map.get("time_end");
                // // 支付者唯一Id（对应买家账号的一个加密串 ）
                String buyer_id = (String) map.get("buyer_id");

                    ///////////////////////////// 这里程序处理支付回调逻辑
                    ///////////////////////////// ////////////////////
                ///////////////////////////// 这里程序处理支付回调逻辑
                ///////////////////////////// ////////////////////

                    LambdaQueryWrapper<Paylog> wrapper = Wrappers.lambdaQuery();
                    wrapper.eq(Paylog::getOutTradeNo,out_trade_no);
                    Paylog one = this.getOne(wrapper);
                    if(SinataUtil.isEmpty(one)) {
                        Paylog paylog = new Paylog();
                        paylog.setOutTradeNo(out_trade_no);
                        paylog.setPayType(2);
                        paylog.setBuyerId(buyer_id);
                        paylog.setTradeNo(trade_no);
                        paylog.setPayMoney(Double.parseDouble(total_fee) / 100);
                        paylog.setState(1);
                        System.out.println("支付完成时间" + time_end);
                        paylog.setAddTime(LocalDateTime.now());
                        this.save(paylog);
                        if (paylog.getOutTradeNo().contains("BO")) {
                            LambdaQueryWrapper<OrderAuctionBond> wrapper1= Wrappers.lambdaQuery();
                            wrapper1.eq(OrderAuctionBond::getOrderNo,paylog.getOutTradeNo());
                            wrapper1.eq(OrderAuctionBond::getDelFlag,0);
                            OrderAuctionBond one1 = orderAuctionBondMapper.selectOne(wrapper1);
                            one1.setBoundStatus(BondStatusEnum.PAID);
                            one1.setPaymentMethod(PaymentMethodEnum.WECHAT);
                            orderAuctionBondMapper.updateById(one1);
                LambdaQueryWrapper<Paylog> wrapper = Wrappers.lambdaQuery();
                wrapper.eq(Paylog::getOutTradeNo,out_trade_no);
                Paylog one = this.getOne(wrapper);
                if(SinataUtil.isEmpty(one)) {
                    Paylog paylog = new Paylog();
                    paylog.setOutTradeNo(out_trade_no);
                    paylog.setPayType(2);
                    paylog.setBuyerId(buyer_id);
                    paylog.setTradeNo(trade_no);
                    paylog.setPayMoney(Double.parseDouble(total_fee) / 100);
                    paylog.setState(1);
                    System.out.println("支付完成时间" + time_end);
                    paylog.setAddTime(LocalDateTime.now());
                    this.save(paylog);
                    if (paylog.getOutTradeNo().contains("BO")) {
                        LambdaQueryWrapper<OrderAuctionBond> wrapper1= Wrappers.lambdaQuery();
                        wrapper1.eq(OrderAuctionBond::getOrderNo,paylog.getOutTradeNo());
                        wrapper1.eq(OrderAuctionBond::getDelFlag,0);
                        OrderAuctionBond one1 = orderAuctionBondMapper.selectOne(wrapper1);
                        if (one1.getBondType().equals(AuctionOrderTypeEnum.REGULAR_ITEMS)
                                && one1.getOrderTimeSx().isBefore(LocalDateTime.now())) {
                            String refundMoney = SinataUtil.doubleRetainTwo(paylog.getPayMoney() * 100d);
                            Integer refundFee = Integer.parseInt(refundMoney.substring(0, refundMoney.length() - 3));
                            String money = SinataUtil.doubleRetainTwo(paylog.getPayMoney() * 100d);
                            Integer totalFee = Integer.parseInt(money.substring(0, money.length() - 3));
                            refundFee = Integer.parseInt(money.substring(0, money.length() - 3));

                        }else{
                            LambdaQueryWrapper<Order> wrapper1= Wrappers.lambdaQuery();
                            wrapper1.eq(Order::getOrderNo,paylog.getOutTradeNo());
                            wrapper1.eq(Order::getDelFlag,0);
                            Order page1 = OrderMapper.selectOne(wrapper1);
                            page1.setOrderStatus(OrderStatusEnum.TO_BE_SHIPPED);
                            page1.setPaymentMethod(PaymentMethodEnum.WECHAT);
                            page1.setPayTime(LocalDateTime.now());
                            OrderMapper.updateById(page1);

                            if(page1.getOrderNo().contains("SP")){
                                GoodsSku goodsSku =new GoodsSku();
                                goodsSku.setId(page1.getGoodsSkuId());
                                goodsSku.setSoldQuantity(page1.getGoodsQuantity());
                                GoodsSkuClient.updGoods(goodsSku, SecurityConstants.INNER);
                            }

                            if(page1.getOrderNo().contains("MS")){
                                GoodsSku goodsSku =new GoodsSku();
                                goodsSku.setId(page1.getGoodsSkuId());
                                goodsSku.setSoldQuantity(page1.getGoodsQuantity());
                                GoodsSkuClient.updGoodsSeckill1(goodsSku, SecurityConstants.INNER);
                            }

                            MemberPointsDTO memberPointsDTO=new MemberPointsDTO();
                            memberPointsDTO.setMemberId(page1.getMemberId());
                            memberPointsDTO.setPointsType(1);
                            memberPointsDTO.setPointsStatus(PointStatusEnum.INCREASE);
                            memberPointsDTO.setPoints(page1.getPoints());
                            memberClient.addMemberPoints(memberPointsDTO);
                            updMembeOneDTO MembeOneDTO=new updMembeOneDTO();
                            MembeOneDTO.setType(1);
                            MembeOneDTO.setMemberId(page1.getMemberId());
                            MembeOneDTO.setMoney(page1.getTotalAmount());
                            MembeOneDTO.setTotalPoints(page1.getPoints());
                            memberClient.updMembeOne(MembeOneDTO, SecurityConstants.INNER);
                            String regEx = "[^0-9]";
                            Pattern p = Pattern.compile(regEx);
                            Matcher m = p.matcher(paylog.getOutTradeNo());
                            String ma = m.replaceAll("").trim();
                            refundForWxpay(4, paylog.getTradeNo(), paylog.getOutTradeNo(), "R" + ma, totalFee, refundFee, "2");
                        }

                        log.debug("WxpayController.notify__回调处理成功：SUCCESS");
                        response.getOutputStream().print("success");
                        one1.setBoundStatus(BondStatusEnum.PAID);
                        one1.setPaymentMethod(PaymentMethodEnum.WECHAT);
                        orderAuctionBondMapper.updateById(one1);
                        AuctionOrderTypeEnum bondType = one1.getBondType();
                        AuctionBondJl auctionBondJl = null;
                        if (bondType.equals(AuctionOrderTypeEnum.AUCTION_ITEMS)) {
                            auctionBondJl = auctionClient.getAuctionBondJLByTargetId(
                                            one1.getAuctionSalesroomId(), one1.getMemberId(),
                                            bondType.getCode(), SecurityConstants.INNER)
                                    .getData();
                            log.info("保证金支付回调，添加拍卖参与记录开始进行");
                            if (Objects.isNull(auctionBondJl)) {
                                auctionBondJl = new AuctionBondJl();
                                auctionBondJl.setAuctionSalesroomId(
                                        one1.getAuctionSalesroomId());
                                auctionBondJl.setIsState(0);
                                auctionBondJl.setBondType(bondType.getCode());
                                auctionBondJl.setMemberId(
                                        one1.getMemberId());
                            } else {
                                auctionBondJl.setIsState(0);
                            }
                        } else {
                            auctionBondJl = auctionClient.getAuctionBondJLByTargetId(
                                            one1.getAuctionGoodsId(), one1.getMemberId(),
                                            bondType.getCode(), SecurityConstants.INNER)
                                    .getData();
                            if (Objects.isNull(auctionBondJl)) {
                                auctionBondJl = new AuctionBondJl();
                                auctionBondJl.setAuctionGoodsId(one1.getAuctionGoodsId());
                                auctionBondJl.setIsState(0);
                                auctionBondJl.setBondType(bondType.getCode());
                                auctionBondJl.setMemberId(
                                        one1.getMemberId());
                            } else {
                                auctionBondJl.setIsState(0);
                            }
                        }
                        auctionClient.saveOrUpdateAuctionBondJl(auctionBondJl,
                                SecurityConstants.INNER);
                        log.info("保证金支付回调，添加拍卖参与记录结束");
                    }else{
                        LambdaQueryWrapper<Order> wrapper1= Wrappers.lambdaQuery();
                        wrapper1.eq(Order::getOrderNo,paylog.getOutTradeNo());
                        wrapper1.eq(Order::getDelFlag,0);
                        Order page1 = orderMapper.selectOne(wrapper1);
                        page1.setOrderStatus(OrderStatusEnum.TO_BE_SHIPPED);
                        page1.setPaymentMethod(PaymentMethodEnum.WECHAT);
                        page1.setPayTime(LocalDateTime.now());
                        orderMapper.updateById(page1);

                        if(page1.getOrderNo().contains("SP")){
                            GoodsSku goodsSku =new GoodsSku();
                            goodsSku.setId(page1.getGoodsSkuId());
                            goodsSku.setSoldQuantity(page1.getGoodsQuantity());
                            goodsSkuClient.updGoods(goodsSku, SecurityConstants.INNER);
                        }

                        if(page1.getOrderNo().contains("MS")){
                            GoodsSku goodsSku =new GoodsSku();
                            goodsSku.setId(page1.getGoodsSkuId());
                            goodsSku.setSoldQuantity(page1.getGoodsQuantity());
                            goodsSkuClient.updGoodsSeckill1(goodsSku, SecurityConstants.INNER);
                        }
                        if(page1.getOrderNo().contains("TG")){
                            log.info(
                                    "===================================开始处理团购回调===================================");
                            GoodsGroupPurchase goodsSeckiGoodsGroupPurchaseOne = goodsSkuClient.getGoodsSeckiGoodsGroupPurchaseOne(page1.getGoodsSkuId(), SecurityConstants.INNER).getData();
                            GoodsGroupPurchaseInfo goodsSeckiGoodsGroupPurchaseInfo = goodsSkuClient.getGoodsSeckiGoodsGroupPurchaseInfo(page1.getGoodsSkuId(), SecurityConstants.INNER).getData();
                            if (goodsSeckiGoodsGroupPurchaseInfo!=null){
                                log.info("==================已有待成团团购================");
                                page1.setGroupNo(goodsSeckiGoodsGroupPurchaseInfo.getMubre());
                                orderMapper.updateById(page1);
                                Integer i= goodsSeckiGoodsGroupPurchaseInfo.getPurchaseNum()+page1.getGoodsQuantity();
                                goodsSeckiGoodsGroupPurchaseInfo.setPurchaseNum(i);
                                goodsSkuClient.updgoodsGroupPurchaseInfo(goodsSeckiGoodsGroupPurchaseInfo, SecurityConstants.INNER);

                            }else{
                                log.info("==================开启一个新团================");
                                UUID uuid = UUID.randomUUID();
                                page1.setGroupNo(uuid.toString());
                                orderMapper.updateById(page1);
                                GoodsGroupPurchaseInfo goodsGroupPurchaseInfo=new GoodsGroupPurchaseInfo();
                                goodsGroupPurchaseInfo.setGroupSize(goodsSeckiGoodsGroupPurchaseOne.getGroupSize());
                                goodsGroupPurchaseInfo.setCurrentNumber(1);
                                goodsGroupPurchaseInfo.setPurchaseNum(page1.getGoodsQuantity());
                                goodsGroupPurchaseInfo.setMubre(uuid.toString());
                                goodsGroupPurchaseInfo.setGroupPurchaseId(goodsSeckiGoodsGroupPurchaseOne.getId());
                                goodsGroupPurchaseInfo.setGroupStatus(0);
                                goodsSkuClient.updgoodsGroupPurchaseInfo(goodsGroupPurchaseInfo, SecurityConstants.INNER);

                            }
                        }

                    }

                    log.debug("WxpayController.notify__回调处理成功：SUCCESS");
                    response.getOutputStream().print("success");
                } else {
                    log.debug("WxpayController.notify__回调处理：验证状态错误！" + result_code);
                    System.out.println("验证状态错误！" + result_code);
                }
                log.debug("WxpayController.notify__回调处理成功：SUCCESS");
                response.getOutputStream().print("success");
            } else {
                log.debug("WxpayController.notify__回调处理：验证状态错误！" + result_code);
                System.out.println("验证状态错误！" + result_code);
            }

        } catch (Exception e) {
            e.printStackTrace();
@@ -518,6 +621,7 @@
                    + "\", " + "\"refund_amount\":" + refund_amount + ", " + "\"refund_reason\":\"正常退款\","
                    + "\"out_request_no\":\"HZ01RF001\"" + "}");
            AlipayTradeRefundResponse response = alipayClient.execute(request);
            log.info("支付宝退款response:" + response.getBody());
            // 调用成功，则处理业务逻辑
            if (response.isSuccess()) {
                return true;
@@ -538,20 +642,24 @@
     * @param request
     * @return
     */
    public R<Map<String, Object>> alipay(String orderNo, String subject, String body, Double price,
    public R<Map<String, Object>> alipay(String zfbOpenid, String orderNo, String subject,
            String body, Double price,
                                         HttpServletRequest request) {
        try {
            // 接口封装支付宝请求参数
            // Map<String, Object> mData = new HashMap<String, Object>();

            // 构建请求支付签名参数
            Map<String, Object> pay = PayDemoActivity.appPay(subject, body, price, orderNo);
            // Map<String, Object> pay = PayDemoActivity.appPay(subject, body, price, orderNo);
            Map<String, Object> pay = PayDemoActivity.jsApiPay(subject, body, price, orderNo,
                    zfbOpenid);
            /*
             * Set<Entry<String, String>> entrySet = pay.entrySet();
             * Iterator<Entry<String, String>> iterator = entrySet.iterator();
             * while (iterator.hasNext()) { Entry<String, String> next =
             * iterator.next(); mData.put(next.getKey(), next.getValue()); }
             */
            log.info("支付宝预支付信息：{}", JSON.toJSONString(pay));
            return R.ok(pay);
        } catch (Exception e) {
            e.printStackTrace();
@@ -570,7 +678,7 @@
     * @param request
     * @return
     */
    public static R<Map<String, Object>> wxpay(Integer apptype,LocalDateTime  sx,String outTradeNo, String body,String openId, Double price,
    public static R<Map<String, Object>> wxpay(Integer apptype,String outTradeNo, String body,String openId, Double price,
                                               HttpServletRequest request) {
        // 获取预支付接口返回参数
        Map<String, Object> map1 = new HashMap<String, Object>();
@@ -610,14 +718,12 @@
            paraMap.put("body", body);
            //设置请求参数(商户订单号)
            paraMap.put("out_trade_no", outTradeNo);
            if (sx!=null){
                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
                paraMap.put("time_expire",sx.format(formatter));
            }
            //设置请求参数(总金额)

            String money=SinataUtil.doubleRetainTwo(price*100d);
           Integer price1 = Integer.parseInt(money.substring(0,money.length()-3));
            Integer price1 = Integer.parseInt(money.substring(0,money.length()-3));
            log.info(
                    "============================>WxpayController.createOrder__price1：\n" + price1);
            paraMap.put("total_fee", price1.toString());
            //设置请求参数(通知地址)
            paraMap.put("notify_url", Configure.wx_notify_url);
@@ -631,12 +737,16 @@
            String sign = PaymentKit.createSign(paraMap, "HSCEWrfSYiwxR6sesZ6De91Xh3m447sh");
            paraMap.put("sign", sign);
            //统一下单,向微信api发送数据
            log.info(
                    "============================>WxpayController.paraMap：\n" + paraMap);
            //转成xml
            String xmlResult = WxPayApi.pushOrder(false, paraMap);
            Map<String, String> map = PaymentKit.xmlToMap(xmlResult);
            log.info(
                    "============================>WxpayController.map：\n" + map);
            //返回状态码
            String returnCode = map.get("return_code");
      /*      Assert.isTrue("SUCCESS".equals(returnCode), getMsgByCode(returnCode));*/
            /*      Assert.isTrue("SUCCESS".equals(returnCode), getMsgByCode(returnCode));*/

            //返回给小程序端需要的参数
            Map<String, Object> returnMap = new HashMap<>(20);
@@ -655,6 +765,7 @@

            returnMap.put("sign", signature);
            returnMap.put("Type",2);
            returnMap.put("result_code", map.get("result_code"));
            returnMap.put("err_code_des", map.get("err_code_des"));
            // 对获取预支付返回接口参数进行封装（生成支付订单接口数据）
            return R.ok(returnMap);
@@ -671,6 +782,7 @@
            List<Map.Entry<String, Object>> infoIds = new ArrayList<Map.Entry<String, Object>>(entries);
            // 对所有传入参数按照字段名的 ASCII 码从小到大排序（字典序）
            Collections.sort(infoIds, new Comparator<Map.Entry<String, Object>>() {
                @Override
                public int compare(Map.Entry<String, Object> o1, Map.Entry<String, Object> o2) {
                    return (o1.getKey()).toString().compareTo(o2.getKey());
                }
@@ -740,10 +852,9 @@
        System.out.println("证书: " + Configure.getCertLocalPath_2());

        String xmlResult = WxPayApi.orderRefund(false, paraMap,Configure.getCertLocalPath_2(), Configure.getMchid());

        System.out.println("微信退款结果: " + xmlResult);
        return true;
    }

    /**
     * 获取支付宝
     *
@@ -752,7 +863,7 @@
     * @throws Exception
     */
    private Paylog getPayLog_alipay(HttpServletRequest request) throws IOException {
        //////// 获取支付宝的通知返回参数，可参考技术文档中页面跳转同步通知参数列表(以下仅供参考)////////
        //////// 获取支付宝的通知返回参数，可参考技术文档中页面跳转步通知同参数列表(以下仅供参考)////////
        // 商户订单号
        String out_trade_no = new String(request.getParameter("out_trade_no").getBytes("ISO-8859-1"), "UTF-8");
        // 支付宝交易号
@@ -760,12 +871,12 @@
        // 交易状态
        String trade_status = new String(request.getParameter("trade_status").getBytes("ISO-8859-1"), "UTF-8");
        // 支付者唯一Id
        String buyer_id = new String(request.getParameter("buyer_id").getBytes("ISO-8859-1"), "UTF-8");
        // String buyer_id = new String(request.getParameter("buyer_id").getBytes("ISO-8859-1"), "UTF-8");
        // 支付帐号
        String buyer_email = "";
        if (SinataUtil.isNotEmpty(request.getParameter("buyer_logon_id"))) {
            buyer_email = new String(request.getParameter("buyer_logon_id").getBytes("ISO-8859-1"), "UTF-8");
        }
        // String buyer_email = "";
        // if (SinataUtil.isNotEmpty(request.getParameter("buyer_logon_id"))) {
        //     buyer_email = new String(request.getParameter("buyer_logon_id").getBytes("ISO-8859-1"), "UTF-8");
        // }
        // 支付金额
        String total_fee = new String(request.getParameter("total_amount").getBytes("ISO-8859-1"), "UTF-8");
        // 支付时间
@@ -775,7 +886,7 @@
        Paylog paylog = new Paylog();
        paylog.setOutTradeNo(out_trade_no);
        paylog.setPayType(1);
        paylog.setBuyerId(buyer_id);
        // paylog.setBuyerId(buyer_id);
        paylog.setTradeNo(trade_no);
        paylog.setPayMoney(Double.parseDouble(total_fee));
        paylog.setState(1);
@@ -784,18 +895,23 @@
        return paylog;
    }

        public boolean judgeContainsStr(String cardNum) {
            String regex=".*[a-zA-Z]+.*";
            Matcher m= Pattern.compile(regex).matcher(cardNum);
            return m.matches();
        }
    public boolean judgeContainsStr(String cardNum) {
        String regex=".*[a-zA-Z]+.*";
        Matcher m= Pattern.compile(regex).matcher(cardNum);
        return m.matches();
    }

    /**
     * @param refundDTOS 退款数据传输对象
     * @return Map<String, Object> key ：orderNo value 退款结果
     */
    @Override
    public Map<String, Object> refund(List<RefundDTO> refundDTOS) {
        log.info("开始退款，入参：{}", refundDTOS);
        Map<String, Object> map = new HashMap<>();
        Set<String> orderNoList = refundDTOS.stream().map(RefundDTO::getOrderNo)
                .collect(Collectors.toSet());
        if (StringUtils.isNotEmpty(orderNoList)) {
        if (StringUtils.isNotEmpty(refundDTOS)) {
            Set<String> orderNoList = refundDTOS.stream().map(RefundDTO::getOrderNo)
                    .collect(Collectors.toSet());
            Map<String, Paylog> paylogMap = this.lambdaQuery()
                    .in(Paylog::getOutTradeNo, orderNoList).eq(Paylog::getState, 1).list().stream()
                    .collect(Collectors.toMap(Paylog::getOutTradeNo, Function.identity()));
@@ -818,12 +934,52 @@
        return map;
    }

    @Override
    public void refund1(RefundDTO refundDTOS) {

        LambdaQueryWrapper<Paylog> paylogEntityWrapper = Wrappers.lambdaQuery();
        paylogEntityWrapper.eq(Paylog::getOutTradeNo, refundDTOS.getOrderNo());
        Paylog paylog = paylogMapper.selectOne(paylogEntityWrapper);


        if (paylog.getPayType()  ==1) {//支付宝
            //获取支付信息

            if (paylog != null) {
                boolean bo = this.refundForAlipay(paylog.getOutTradeNo(), paylog.getTradeNo(), paylog.getPayMoney());
                if (!bo) {
                    System.out.println("支付宝退款失败");
                }
            }

        } else if (paylog.getPayType()  ==2) {//微信
            //获取支付信息
            if (paylog != null) {
                String refundMoney = SinataUtil.doubleRetainTwo(paylog.getPayMoney() * 100d);
                Integer refundFee = Integer.parseInt(refundMoney.substring(0, refundMoney.length() - 3));
                String money = SinataUtil.doubleRetainTwo(paylog.getPayMoney() * 100d);
                Integer totalFee = Integer.parseInt(money.substring(0, money.length() - 3));
                refundFee = Integer.parseInt(money.substring(0, money.length() - 3));

                String regEx = "[^0-9]";
                Pattern p = Pattern.compile(regEx);
                Matcher m = p.matcher(refundDTOS.getOrderNo());
                String ma = m.replaceAll("").trim();
                boolean bo = this.refundForWxpay(4, paylog.getTradeNo(), paylog.getOutTradeNo(), "R" + ma, totalFee, refundFee, "2");
                if (!bo) {
                    System.out.println("微信退款失败");
                }

            }
        }
    }

    private Boolean handleRefund(Paylog paylog, BigDecimal amount,
            String orderNo) {
                                 String orderNo) {
        boolean res = false;
        if (StringUtils.isNotNull(paylog)) {
            if (paylog.getPayType() == 1) {
                res = this.refundForAlipay(paylog.getOutTradeNo(),
                res = refundForAlipay(paylog.getOutTradeNo(),
                        paylog.getTradeNo(), amount.doubleValue());
            }
            if (paylog.getPayType() == 2) {
@@ -834,9 +990,9 @@
                String money = SinataUtil.doubleRetainTwo(paylog.getPayMoney() * 100d);
                Integer totalFee = Integer.parseInt(
                        money.substring(0, money.length() - 3));
                res = this.refundForWxpay(2, paylog.getTradeNo(),
                res = refundForWxpay(1, paylog.getTradeNo(),
                        paylog.getOutTradeNo(), orderNo, totalFee,
                        refundFee, "4");
                        refundFee, "2");
            }
        }
        return res;