全部代码、数据库提交

无关风月

2024-12-31 0c51a577db337520452022d9d6a22b720ef858d4

 xinquan-modules/xinquan-order/src/main/java/com/xinquan/order/controller/client/ClientOrderController.java

@@ -1,32 +1,70 @@
package com.xinquan.order.controller.client;


import com.alibaba.fastjson2.JSONObject;
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.sun.corba.se.spi.ior.IdentifiableFactory;
import com.xinquan.common.core.constant.SecurityConstants;
import com.xinquan.common.core.domain.R;
import com.xinquan.common.core.utils.JuHeFuUtil;
import com.xinquan.common.core.utils.page.BeanUtils;
import com.xinquan.common.core.utils.page.CollUtils;
import com.xinquan.common.core.utils.page.PageDTO;
import com.xinquan.common.core.web.domain.AjaxResult;
import com.xinquan.common.core.web.domain.BaseModel;
import com.xinquan.common.security.service.TokenService;
import com.xinquan.common.security.utils.SecurityUtils;
import com.xinquan.course.api.domain.Course;
import com.xinquan.course.api.domain.CourseChapter;
import com.xinquan.course.api.feign.RemoteCourseService;
import com.xinquan.meditation.api.domain.Meditation;
import com.xinquan.meditation.api.feign.RemoteMeditationService;
import com.xinquan.order.api.domain.Order;
import com.xinquan.order.api.domain.vo.PayOrderVO;
import com.xinquan.order.domain.OrderPaymentRecord;
import com.xinquan.order.domain.vo.ClientPlaceOrderVO;
import com.xinquan.order.service.OrderPaymentRecordService;
import com.xinquan.order.service.OrderService;
import com.xinquan.course.api.domain.OrderCourseVO;
import com.xinquan.order.utils.OrderUtil;
import com.xinquan.system.api.domain.AppUser;
import com.xinquan.system.api.domain.AppUserCourse;
import com.xinquan.system.api.domain.AppUserWalletRecord;
import com.xinquan.system.api.domain.CommissionRule;
import com.xinquan.system.api.feignClient.SysUserClient;
import com.xinquan.system.api.model.LoginUser;
import com.xinquan.user.api.domain.dto.AppUserDTO;
import com.xinquan.user.api.feign.RemoteAppUserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.math.BigDecimal;
import java.util.List;
import java.security.PublicKey;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.security.interfaces.ECPublicKey;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;


/**
 * <p>
@@ -50,6 +88,95 @@
    private RemoteCourseService remoteCourseService;
    @Resource
    private RemoteMeditationService remoteMeditationService;
    @Resource
    private RemoteAppUserService remoteAppUserService;
    @Resource
    private SysUserClient sysUserClient;
    @Autowired
    private TokenService tokenService;

    @ResponseBody
    @PostMapping("/queryPayment")
    @ApiOperation(value = "查询订单支付状态", tags = "查询订单支付状态")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "orderId", value = "订单id", dataType = "String", required = true),
    })
    public R<String> queryPayment(@RequestParam(value = "orderId") String orderId) throws Exception {
        JSONObject jsonObject = JuHeFuUtil.queryPayment(orderId);
        return R.ok(jsonObject.getString("status"));
    }
    @GetMapping("/getMeditationIsBuy/{id}/{meditationId}")
    public R<Integer> getMeditationIsBuy(@PathVariable("id")Long id,@PathVariable("meditationId")Long meditationId) {
        List<Order> list = orderService.lambdaQuery().eq(Order::getBusinessId, meditationId)
                .eq(Order::getAppUserId, id)
                .eq(Order::getOrderFrom, 1)
                .eq(Order::getPaymentStatus, 2)
                .ne(Order::getRefundStatus, 3).list();
        if (list.isEmpty()){
            return R.ok(2);
        }else{
            return R.ok(1);
        }
    }
    @PostMapping("/payOrder")
    @ApiOperation(value = "已购详情-待支付状态-页面数据",tags = "我的已购")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "订单id", dataType = "Long", required = true),
            @ApiImplicitParam(name = "type", value = "1=android 2=ios", dataType = "Integer", required = true),
    })
    public R<PayOrderVO> payOrder(Long id,Integer type) {
        Order byId = orderService.getById(id);
        PayOrderVO payOrderVO = new PayOrderVO();
        if (byId==null){
            return R.fail("订单失效");
        }
        if (byId.getGiveUserId()!=null){
            AppUser data1 = remoteAppUserService.getAppUserById(byId.getGiveUserId() + "").getData();
            payOrderVO.setPhone(data1.getCellPhone());
        }
        AppUser data1 = remoteAppUserService.getAppUserById(byId.getAppUserId() + "").getData();
        payOrderVO.setBalance(data1.getBalance());
        payOrderVO.setOrderId(id);
        if (byId.getOrderFrom()==1){
            Meditation data = remoteMeditationService.getMeditationById(byId.getBusinessId()).getData();
            payOrderVO.setTitle(data.getMeditationTitle());
            payOrderVO.setOrderFrom(1);
            payOrderVO.setCoverUrl(data.getCoverUrl());
            payOrderVO.setId(data.getId());
            switch (type){
                case 1:
                    payOrderVO.setAmount(data.getGeneralPrice());
                    break;
                case 2:
                    payOrderVO.setAmount(data.getIosPrice());
                    break;
            }
            if (byId.getChangePrice()!=null){
                payOrderVO.setAmount(payOrderVO.getAmount().add(byId.getChangePrice()));
            }
        }else if (byId.getOrderFrom() == 2){
            Course data = remoteCourseService.getCourseById(byId.getBusinessId()).getData();
            payOrderVO.setTitle(data.getCourseTitle());
            payOrderVO.setTutor(data.getTutor());
            payOrderVO.setOrderFrom(2);
            payOrderVO.setCoverUrl(data.getCoverUrl());
            payOrderVO.setId(data.getId());
            switch (type){
                case 1:
                    payOrderVO.setAmount(data.getGeneralPrice());
                    break;
                case 2:
                    payOrderVO.setAmount(data.getIosPrice());
                    break;
            }
            if (byId.getChangePrice()!=null){
                payOrderVO.setAmount(payOrderVO.getAmount().add(byId.getChangePrice()));
            }
        }
        payOrderVO.setAmount(byId.getRealPayAmount());
        return R.ok(payOrderVO);
    }

    @PostMapping("/myOrderCourse")
    @ApiOperation(value = "我的已购",tags = "我的已购")
    @ApiImplicitParams({
@@ -57,39 +184,107 @@
            @ApiImplicitParam(name = "pageCurr", value = "分页参数，当前页码", dataType = "Integer", required = true),
            @ApiImplicitParam(name = "pageSize", value = "分页参数，每页数量", dataType = "Integer", required = true)
    })
    public R<PageDTO<OrderCourseVO>> balanceList(Integer state, Integer pageCurr, Integer pageSize) {
        Long userId = SecurityUtils.getUserId();
        if (userId==0)return R.tokenError("登录失效");
        Page<Order> page = orderService.lambdaQuery()
                .eq(Order::getAppUserId, userId)
    public R<List<OrderCourseVO>> balanceList(Integer state, Integer pageCurr, Integer pageSize) {
        LoginUser loginUser = tokenService.getLoginUser();
        if (loginUser==null){
            return R.tokenError("登录失效");
        }
        Long userId = loginUser.getUserid();
        List<OrderCourseVO> res = new ArrayList<>();
        List<Order> page = orderService.lambdaQuery()
                .eq(Order::getOrderFrom, state)
                .ne(Order::getPaymentStatus, 3)
                .orderByDesc(BaseModel::getCreateTime).page(new Page<>(pageCurr, pageSize));
        if (CollUtils.isEmpty(page.getRecords())){
            PageDTO<OrderCourseVO> empty = PageDTO.empty(page);
            return R.ok(empty);
                .orderByDesc(BaseModel::getCreateTime).list();
        for (Order order : page) {
            OrderCourseVO orderCourseVO = new OrderCourseVO();
            orderCourseVO.setId(order.getId());
            orderCourseVO.setOrderFrom(order.getOrderFrom());
            orderCourseVO.setBusinessId(order.getBusinessId());
            if (order.getAppUserId().equals(userId)){
                BeanUtils.copyProperties(order, orderCourseVO);
                orderCourseVO.setBusinessId(order.getBusinessId());
                res.add(orderCourseVO);
            }
            if (order.getGiveUserId()!=null&&order.getGiveUserId().equals(userId)&&order.getPaymentStatus()==2){
                BeanUtils.copyProperties(order, orderCourseVO);
                orderCourseVO.setBusinessId(order.getBusinessId());
                res.add(orderCourseVO);
            }
        }
        PageDTO<OrderCourseVO> res = PageDTO.of(page, OrderCourseVO.class);
        for (OrderCourseVO orderCourseVO : res.getList()) {
            switch (orderCourseVO.getChargeType()){
        List<OrderCourseVO> res1 = new ArrayList<>();
        for (OrderCourseVO orderCourseVO : res) {
            switch (orderCourseVO.getOrderFrom()){
                case 1:
                    Meditation data1 = remoteMeditationService.getMeditationById(orderCourseVO.getBusinessId()).getData();
                    if (data1==null)continue;
                    orderCourseVO.setCourseTitle(data1.getMeditationTitle());
                    orderCourseVO.setDescription(data1.getCoverDescription());
                    orderCourseVO.setCoverUrl(data1.getCoverUrl());
                    orderCourseVO.setGeneralPrice(data1.getGeneralPrice());
                    orderCourseVO.setIosPrice(data1.getIosPrice());
                    Order byId = orderService.getById(orderCourseVO.getId());
                    orderCourseVO.setGeneralPrice(byId.getRealPayAmount());
                    orderCourseVO.setIosPrice(byId.getRealPayAmount());
                    orderCourseVO.setCount(data1.getRealLearnedNum()+data1.getVirtualLearnedNum());
                    orderCourseVO.setChargeType(data1.getChargeType());
                    orderCourseVO.setCoverDescription(data1.getCoverDescription());
                    res1.add(orderCourseVO);
                    break;
                case 2:
                    OrderCourseVO data = remoteCourseService.getCourseCategoryList(orderCourseVO).getData();
                    OrderCourseVO data = remoteCourseService.getCourseByIdAny(orderCourseVO).getData();
                    if (data==null)continue;
                    BeanUtils.copyProperties(data, orderCourseVO);
                    Course data4 = remoteCourseService.getCourseById(data.getBusinessId()).getData();
                    List<CourseChapter> data2 = remoteCourseService.getChapterByCourseId(orderCourseVO.getBusinessId() + "").getData();
                    int temp = 0 ;
                    int b = 0 ;
                    for (CourseChapter courseChapter : data2) {
                        temp+=courseChapter.getVirtualLearnedNum();
                        Long data9 = remoteAppUserService.getCourseChapterHistoryCount(courseChapter.getId()).getData();
                        b+=data9;
                    }
                    Order byId1 = orderService.getById(orderCourseVO.getId());
                    orderCourseVO.setGeneralPrice(byId1.getRealPayAmount());
                    orderCourseVO.setIosPrice(byId1.getRealPayAmount());
                    orderCourseVO.setCount(b+temp);
                    if (data4!=null){
                        orderCourseVO.setCourseTitle(data4.getCourseTitle());
                        orderCourseVO.setCoverUrl(data4.getCoverUrl());
                        orderCourseVO.setBusinessId(data4.getId());
                    }
                    res1.add(orderCourseVO);
                    break;

            }

        }
        return R.ok(res);
        List<OrderCourseVO> orderCourseVOS = new ArrayList<>();
        List<Long> longs1 = new ArrayList<>();
        for (OrderCourseVO orderCourseVO : res1) {
            if (!longs1.contains(orderCourseVO.getBusinessId())){
                longs1.add(orderCourseVO.getBusinessId());
                orderCourseVOS.add(orderCourseVO);
            }
        }
        List<OrderCourseVO> testing = testing(orderCourseVOS.size(), pageCurr, pageSize, orderCourseVOS);
        return R.ok(testing);
    }
    public static List<OrderCourseVO> testing(long total, long current, long size, List<OrderCourseVO> str){
        List<OrderCourseVO> result = new ArrayList<>();
        //获取初始化分页结构
        Page<OrderCourseVO> page = new Page<>(current - 1, size, total);
        //获取集合下标初始值
        long startIndex = (current - 1) * size;
        //获取集合下标结束值
        long endInddex = 0;
        if(startIndex + page.getCurrent() >= total || size > total){
            endInddex = total;
        }else {
            endInddex = Math.min(startIndex + page.getSize(), total);
        }
        //如果输入的开始查询下标大于集合大小，则查询为空值
        if(startIndex > total){
            result = Collections.emptyList();
        }else{
            result = str.subList((int)startIndex,(int)endInddex);
        }
        return result;
    }
    /**
     * 根据邀请用户ids 查询对应佣金
@@ -122,28 +317,830 @@
     * @return 下单返回数据视图对象
     * @see com.xinquan.order.domain.vo.ClientPlaceOrderVO
     */
  
    @PostMapping("/placeOrder")
    @ApiOperation(value = "创建待支付订单", notes = "微信|支付宝")
    @ApiOperation(value = "创建支付订单", notes = "微信|支付宝")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "targetId", value = "目标id", dataType = "Long", required = true),
            @ApiImplicitParam(name = "targetId", value = "目标id 订单类型为会员和充值时不传", dataType = "Long", required = false),
            @ApiImplicitParam(name = "type", value = "类型 用于判断苹果支付还是安卓支付", dataType = "Long", required = false),
            @ApiImplicitParam(name = "orderId", value = "订单id 待支付时传", dataType = "Long", required = false),
            @ApiImplicitParam(name = "orderFrom", value = "订单来源 1=冥想音频 2=课程 3=购买会员 4充值", dataType = "Integer", required = true),
            @ApiImplicitParam(name = "receiverId", value = "被赠送课程APP用户id", dataType = "Long", required = false),
            @ApiImplicitParam(name = "balanceFlag", value = "是否使用余额抵扣 1=是 2=否", dataType = "Integer", required = false),
            @ApiImplicitParam(name = "payType", value = "支付方式 1=微信 2=支付宝", dataType = "Integer", required = false)
            @ApiImplicitParam(name = "payType", value = "支付方式 1=微信 2=支付宝", dataType = "Integer", required = false),
            @ApiImplicitParam(name = "amount", value = "购买会员的金额/充值金额", dataType = "BigDecimal", required = false),
            @ApiImplicitParam(name = "vipType", value = "订单类型为会员时 必传 会员类型 1月度 2季度 3年度", dataType = "Integer", required = false),
    })
    public R<ClientPlaceOrderVO> placeOrder(
            @RequestParam(value = "targetId") Long targetId,
            @RequestParam(value = "targetId", required = false) Long targetId,
            @RequestParam(value = "type", required = false) Integer type,
            @RequestParam(value = "orderId", required = false) Long orderId,
            @RequestParam(value = "orderFrom") Integer orderFrom,
            @RequestParam(value = "receiverId", required = false) Long receiverId,
            @RequestParam(value = "balanceFlag") Integer balanceFlag,
            @RequestParam(value = "payType") Integer payType) {
            @RequestParam(value = "balanceFlag", required = false) Integer balanceFlag,
            @RequestParam(value = "payType") Integer payType,
            @RequestParam(value = "amount", required = false) BigDecimal amount,
            @RequestParam(value = "vipType", required = false) Integer vipType)

    {
        LoginUser loginUser = tokenService.getLoginUser();
        if (loginUser==null){
            return R.tokenError("登录失效");
        }
        Long userId = loginUser.getUserid();
        try {
            if (orderId!=null){
                Order order = orderService.getById(orderId);
                if (order.getRealPayAmount().compareTo(new BigDecimal("0")) == 0 ){
                    // 无需付款
                    switch (orderFrom){
                        case 1:
                            Meditation data1 = remoteMeditationService.getMeditationById(targetId).getData();
                            order.setBuyContent("购买疗愈【"+data1.getMeditationTitle()+"】");
                            switch (payType){
                                case 1:
                                    order.setTotalAmount(data1.getGeneralPrice());

                                    break;
                                case 2:
                                    order.setTotalAmount(data1.getIosPrice());
                                    break;
                            }
                            break;
                        case 2:
                            Course data = remoteCourseService.getCourseById(targetId).getData();

                            order.setBuyContent("购买课程【"+data.getCourseTitle()+"】");
                            switch (payType){
                                case 1:
                                    order.setTotalAmount(data.getGeneralPrice());

                                    break;
                                case 2:
                                    order.setTotalAmount(data.getIosPrice());
                                    break;
                            }
                            if (receiverId!=null){
                                remoteAppUserService.addNotice(receiverId + "", data.getId() + "",
                                        userId + "", order.getTotalAmount() + "");
                            }

                            break;
                    }
                    orderService.updateById(order);
                    switch (orderFrom){
                        case 2:
                            if (receiverId!=null){
                                remoteAppUserService.addAppUserCourse(order.getBusinessId(),order.getGiveUserId(),order.getId(),1);
                                remoteAppUserService.addNotice(receiverId+"",order.getBusinessId()+"",order.getAppUserId()+"",order.getTotalAmount()+"");
                            }else{
                                // 自己购买
                                remoteAppUserService.addAppUserCourse(order.getBusinessId(),order.getAppUserId(),order.getId(),2);
                            }
                            break;
                    }

                    // 删除原有非余额支付详细记录
                    OrderPaymentRecord two = orderPaymentRecordService.lambdaQuery().eq(OrderPaymentRecord::getOrderId, order.getId())
                            .ne(OrderPaymentRecord::getPaymentType, 4).one();
                    if (two!=null){
                        orderPaymentRecordService.removeById(two.getId());
                    }
                    List<OrderPaymentRecord> one = orderPaymentRecordService.lambdaQuery().eq(OrderPaymentRecord::getOrderId, order.getId())
                            .eq(OrderPaymentRecord::getPaymentType, 4).list();
                    if (!one.isEmpty()){
                        for (OrderPaymentRecord orderPaymentRecord : one) {
                            orderPaymentRecordService.removeById(orderPaymentRecord);
                        }
                        OrderPaymentRecord orderPaymentRecord = new OrderPaymentRecord();
                        orderPaymentRecord.setOrderId(order.getId());
                        orderPaymentRecord.setPaymentType(4);
                        orderPaymentRecord.setPayAmount(new BigDecimal("0"));
                        orderPaymentRecord.setPaymentStatus(2);
                        orderPaymentRecordService.save(orderPaymentRecord);
                    }else{
                        OrderPaymentRecord orderPaymentRecord = new OrderPaymentRecord();
                        orderPaymentRecord.setOrderId(order.getId());
                        orderPaymentRecord.setPaymentType(4);
                        orderPaymentRecord.setPayAmount(new BigDecimal("0"));
                        orderPaymentRecord.setPaymentStatus(2);
                        orderPaymentRecordService.save(orderPaymentRecord);
                    }
                    ClientPlaceOrderVO clientPlaceOrderVO = new ClientPlaceOrderVO();
                    clientPlaceOrderVO.setId(order.getId());
                    clientPlaceOrderVO.setOrderNo(order.getBizOrderNo());
                    order.setRealPayAmount(new BigDecimal("0"));
                    order.setPayType(4);
                    orderService.updateById(order);
                    return R.ok(clientPlaceOrderVO);
            }
            }
            ClientPlaceOrderVO clientPlaceOrderVO = orderService.placeOrder(targetId, orderFrom, receiverId, orderId,
                    balanceFlag, payType, amount, vipType,type);
            System.err.println("支付返回参数"+clientPlaceOrderVO);
            return R.ok(
                    orderService.placeOrder(targetId, orderFrom, receiverId,
                            balanceFlag, payType));
                    clientPlaceOrderVO);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    @ResponseBody
    @PostMapping("/refund")
    @ApiOperation(value = "退款", tags = "管理后台-订单列表管理")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "uid", value = "订单id", dataType = "String", required = false),
            @ApiImplicitParam(name = "remark", value = "退款备注", dataType = "String", required = false),
    })
    public R refund(@RequestParam(value = "uid") String uid,
                    @RequestParam(value = "remark") String remark) throws Exception {
        Order byId = orderService.getById(uid);
        String refund = orderService.refund(Long.valueOf(uid));
        if (refund!=null && (!refund.equals("success"))){
            return  R.fail(refund);
        }
        byId.setRefundStatus(3);
        byId.setRefundRemark(remark);
        byId.setPaymentStatus(3);
        byId.setRefundTime(LocalDateTime.now());
        orderService.updateById(byId);

        return R.ok();
    }
    @ResponseBody
    @PostMapping("/placeOrderApple")
    @ApiOperation(value = "苹果支付", notes = "苹果支付")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "targetId", value = "目标id 订单类型为会员和充值时不传", dataType = "Long", required = false),
            @ApiImplicitParam(name = "orderFrom", value = "订单来源 1=冥想音频 2=课程 3=购买会员 4充值", dataType = "Integer", required = true),
            @ApiImplicitParam(name = "receiverId", value = "被赠送课程APP用户id", dataType = "Long", required = false),
            @ApiImplicitParam(name = "balanceFlag", value = "是否使用余额抵扣 1=是 2=否", dataType = "Integer", required = false),
            @ApiImplicitParam(name = "amount", value = "购买会员的金额/充值金额", dataType = "BigDecimal", required = false),
            @ApiImplicitParam(name = "transactionIdentifier", value = "苹果订单id"),
            @ApiImplicitParam(name = "vipType", value = "订单类型为会员时 必传 会员类型 1月度 2季度 3年度", dataType = "Integer", required = false),
    })
    public R placeOrderApple(
            @RequestParam(value = "targetId", required = false) Long targetId,
            @RequestParam(value = "orderFrom") Integer orderFrom,
            @RequestParam(value = "receiverId", required = false) Long receiverId,
            @RequestParam(value = "balanceFlag", required = false) Integer balanceFlag,
            @RequestParam(value = "amount", required = false) BigDecimal amount,
            @RequestParam(value = "vipType", required = false) Integer vipType,
            @RequestParam(value = "transactionIdentifier")String transactionIdentifier)
            throws Exception {


        return R.ok(orderService.placeOrderApple(targetId, orderFrom, receiverId,
                balanceFlag,amount,vipType,transactionIdentifier));
    }
    @ResponseBody
    @PostMapping("/gvieCourse")
    @ApiOperation(value = "购买疗愈/课程-纯余额支付", notes = "赠送课程-纯余额支付")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "targetId", value = "目标id 订单类型为会员和充值时不传", dataType = "Long", required = false),
            @ApiImplicitParam(name = "orderFrom", value = "订单来源 1=冥想音频 2=课程", dataType = "Integer", required = true),
            @ApiImplicitParam(name = "receiverId", value = "被赠送课程APP用户id",dataType = "Long", required = false),
            @ApiImplicitParam(name = "payType", value = "1安卓 2ios", dataType = "Long", required = false),
            @ApiImplicitParam(name = "amount", value = "金额", dataType = "BigDecimal", required = false)
    })
    public R placeOrderApple(
            @RequestParam(value = "targetId") Long targetId,
            @RequestParam(value = "orderFrom") Integer orderFrom,
            @RequestParam(value = "receiverId",required = false) Long receiverId,
            @RequestParam(value = "amount",required = false) BigDecimal amount,
            @RequestParam(value = "payType") Integer payType
            ){
        LoginUser loginUser = tokenService.getLoginUser();
        if (loginUser==null){
            return R.tokenError("登录失效");
        }
        Long userId = loginUser.getUserid();
        Order order = new Order();
        String orderNo = OrderUtil.getOrderNoForPrefix("MX");
        order.setBizOrderNo(orderNo);
        order.setAppUserId(userId);
        order.setBusinessId(targetId);
        order.setGiveUserId(receiverId);
        order.setOrderFrom(orderFrom);
        order.setPaymentStatus(2);
        order.setPayType(4);
        order.setPaymentTime(LocalDateTime.now());
        switch (orderFrom){
            case 1:
                Meditation data1 = remoteMeditationService.getMeditationById(targetId).getData();
                order.setBuyContent("购买疗愈【"+data1.getMeditationTitle()+"】");
                switch (payType){
                    case 1:
                        order.setTotalAmount(data1.getGeneralPrice());
                        order.setRealPayAmount(data1.getGeneralPrice());

                        break;
                    case 2:
                        order.setTotalAmount(data1.getIosPrice());
                        order.setRealPayAmount(data1.getIosPrice());
                        break;
                }


                break;
            case 2:
                Course data = remoteCourseService.getCourseById(targetId).getData();

                order.setBuyContent("购买课程【"+data.getCourseTitle()+"】");
                switch (payType){
                    case 1:
                        order.setTotalAmount(data.getGeneralPrice());
                        order.setRealPayAmount(data.getGeneralPrice());

                        break;
                    case 2:
                        order.setTotalAmount(data.getIosPrice());
                        order.setRealPayAmount(data.getIosPrice());
                        break;
                }
                if (receiverId!=null){
                    remoteAppUserService.addNotice(receiverId + "", data.getId() + "",
                            userId + "", order.getTotalAmount() + "");
                }

                break;
        }
        Order one = new Order();
        if (receiverId==null){
            one = orderService.lambdaQuery().eq(Order::getBusinessId, order.getBusinessId())
                    .eq(Order::getAppUserId,userId)
                    .isNull(Order::getGiveUserId)
                    .eq(Order::getPaymentStatus, 1).one();
        }else{
            one = orderService.lambdaQuery().eq(Order::getBusinessId, order.getBusinessId())
                    .eq(Order::getAppUserId,userId)
                    .eq(Order::getGiveUserId,receiverId)
                    .eq(Order::getPaymentStatus, 1).one();
        }

        if (one!=null){
            AppUser data = remoteAppUserService.getAppUserById(one.getAppUserId()+"").getData();
            if (data.getBalance().compareTo(one.getRealPayAmount())<0){
                return R.fail("余额不足");
            }
            one.setPayType(4);
            one.setPaymentStatus(2);
            orderService.updateById(one);
            // 删除原有的支付详细数据
            List<OrderPaymentRecord> list = orderPaymentRecordService.lambdaQuery().eq(OrderPaymentRecord::getOrderId, one.getId()).list();
            for (OrderPaymentRecord orderPaymentRecord : list) {
                orderPaymentRecordService.removeById(orderPaymentRecord.getId());
            }
            OrderPaymentRecord orderPaymentRecord = new OrderPaymentRecord();
            orderPaymentRecord.setOrderId(one.getId());
            orderPaymentRecord.setPaymentType(4);
            orderPaymentRecord.setPayAmount(one.getRealPayAmount());
            orderPaymentRecord.setPaymentStatus(2);
            orderPaymentRecordService.save(orderPaymentRecord);
            // 增加用户余额购买流水记录
            AppUserWalletRecord appUserWalletRecord1 = new AppUserWalletRecord();
            appUserWalletRecord1.setAppUserId(one.getAppUserId());
            appUserWalletRecord1.setChangeType(2);
            appUserWalletRecord1.setReason(one.getBuyContent());
            appUserWalletRecord1.setAmount(one.getRealPayAmount());
            appUserWalletRecord1.setChildAppUserId(one.getAppUserId());
            appUserWalletRecord1.setOrderId(one.getId());
            remoteAppUserService.addBalanceRecord(appUserWalletRecord1);
            if (one.getOrderFrom() == 2) {
                if (receiverId != null) {
                    remoteAppUserService.addAppUserCourse(one.getBusinessId(), one.getGiveUserId(), one.getId(), 1);
                    remoteAppUserService.addNotice(receiverId + "", one.getBusinessId() + "", one.getAppUserId() + "", one.getTotalAmount() + "");
                } else {
                    // 自己购买
                    remoteAppUserService.addAppUserCourse(one.getBusinessId(), one.getAppUserId(), one.getId(), 2);
                }
            }
        }else{
            AppUser data = remoteAppUserService.getAppUserById(order.getAppUserId()+"").getData();
            if (data.getBalance().compareTo(order.getRealPayAmount())<0){
                return R.fail("余额不足");
            }
            orderService.save(order);
            OrderPaymentRecord orderPaymentRecord = new OrderPaymentRecord();
            orderPaymentRecord.setOrderId(order.getId());
            orderPaymentRecord.setPaymentType(4);
            orderPaymentRecord.setPayAmount(order.getTotalAmount());
            orderPaymentRecord.setPaymentStatus(2);
            orderPaymentRecordService.save(orderPaymentRecord);
            // 增加用户余额购买流水记录
            AppUserWalletRecord appUserWalletRecord1 = new AppUserWalletRecord();
            appUserWalletRecord1.setAppUserId(order.getAppUserId());
            appUserWalletRecord1.setChangeType(2);
            appUserWalletRecord1.setReason(order.getBuyContent());
            appUserWalletRecord1.setAmount(order.getRealPayAmount());
            appUserWalletRecord1.setChildAppUserId(order.getAppUserId());
            appUserWalletRecord1.setOrderId(order.getId());
            remoteAppUserService.addBalanceRecord(appUserWalletRecord1);
            if (order.getOrderFrom() == 2) {
                if (receiverId != null) {
                    remoteAppUserService.addAppUserCourse(order.getBusinessId(), order.getGiveUserId(), order.getId(), 1);
                    remoteAppUserService.addNotice(receiverId + "", order.getBusinessId() + "", order.getAppUserId() + "", order.getTotalAmount() + "");
                } else {
                    // 自己购买
                    remoteAppUserService.addAppUserCourse(order.getBusinessId(), order.getAppUserId(), order.getId(), 2);
                }
            }
        }



        // 判断订单所属用户是否有上级 是否需要做分佣处理
        AppUser data = remoteAppUserService.getAppUserById(order.getAppUserId() + "").getData();

        if (data.getInviteUserId()!=null) {
            if (order.getOrderFrom() == 1 || order.getOrderFrom() == 2 || order.getOrderFrom() == 3) {
//                // 查询实际支付价格 不包含余额抵扣价格
//                OrderPaymentRecord one1 = orderPaymentRecordService.lambdaQuery().eq(OrderPaymentRecord::getOrderId, order.getId())
//                        .one();
//                // 分佣给上级 先远程查询分佣比例
//                CommissionRule data1 = sysUserClient.getCommission().getData();
//                if (data1 != null) {
//                    if (data1.getProportion() != null) {
//
//                        BigDecimal bigDecimal = one1.getPayAmount().multiply(data1.getProportion()).divide(new BigDecimal("100"))
//                                .setScale(2, BigDecimal.ROUND_DOWN);
//                        // 上级获取的分佣金额
//                        AppUser appUserById = remoteAppUserService.getAppUserById(data.getInviteUserId() + "").getData();
//                        // 更新用户余额
//                        remoteAppUserService.updateAppUser(
//                                AppUserDTO.builder().balance(
//                                                appUserById.getBalance().add(bigDecimal))
//                                        .build(), SecurityConstants.INNER);
//                        // 新增分佣流水明细
//                        AppUserWalletRecord appUserWalletRecord = new AppUserWalletRecord();
//                        appUserWalletRecord.setAppUserId(data.getInviteUserId());
//                        appUserWalletRecord.setChangeType(1);
//                        appUserWalletRecord.setReason("分佣收益");
//                        appUserWalletRecord.setAmount(bigDecimal);
//                        appUserWalletRecord.setChildAppUserId(order.getAppUserId());
//                        appUserWalletRecord.setOrderId(order.getId());
//                        remoteAppUserService.addBalanceRecord(appUserWalletRecord);
//                        order.setCommissionAmount(bigDecimal);
//                        order.setCommissionId(data.getInviteUserId());
//                        orderService.updateById(order);
//                    }
//                }
            }
        }
        return R.ok();
    }
    /**
     * 三方支付统一回调
     *
     * @param request
     * @param response
     */
    @ResponseBody
    @PostMapping("/base/callback")
    public void callback(HttpServletRequest request, HttpServletResponse response) {
        try {
            System.err.println("请求"+request);
            BufferedReader reader = request.getReader();
            String string1 = reader.toString();
            System.err.println("请求reader"+string1);
            StringBuilder requestBody = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                requestBody.append(line);
            }
            System.err.println("全部请求体"+requestBody);
            com.alibaba.fastjson2.JSONObject jsonObject = JSONObject.parseObject(requestBody.toString());
            System.err.println("json串"+jsonObject);
            if (jsonObject.getString("type").equals("payment.succeeded")){
                String string9 = jsonObject.getString("resCipher");
                String decrypt = decrypt(string9);
                System.err.println(decrypt);
                JSONObject jsonObject1 = JSONObject.parseObject(decrypt);

                // 系统订单号
                String string = jsonObject1.getString("order_no");
                // 流水号
                String string2 = jsonObject1.getString("payment_id");
                // 支付金额
                String string3 = jsonObject1.getString("pay_fee");
                Order one = orderService.lambdaQuery().eq(Order::getBizOrderNo, string).one();
                if (one.getPaymentStatus()!=1){
                    return;
                }
                one.setPaymentStatus(2);
                one.setPaymentTime(LocalDateTime.now());
                OrderPaymentRecord one2 = orderPaymentRecordService.lambdaQuery().eq(OrderPaymentRecord::getOrderId, one.getId())
                        .ne(OrderPaymentRecord::getPaymentType, 4)
                        .eq(OrderPaymentRecord::getPayOrderNo,string2).one();
                if (one2!=null){
                    one2.setPaymentStatus(2);
                    one2.setPayOrderNo(string2);
                    orderPaymentRecordService.updateById(one2);
                }
                // 实际支付金额
                BigDecimal realPayAmount = one.getRealPayAmount();
                // 判断订单所属用户是否有上级 是否需要做分佣处理
                AppUser data = remoteAppUserService.getAppUserById(one.getAppUserId() + "").getData();
                if (one.getGiveUserId()!=null){
                    remoteAppUserService.addNotice(one.getGiveUserId() + "", one.getBusinessId() + "",
                            one.getAppUserId() + "", realPayAmount + "");
                }
                if (data.getInviteUserId()!=null) {
                    if (one.getOrderFrom() == 1 || one.getOrderFrom() == 2 || one.getOrderFrom() == 3) {
                        // 查询实际支付价格 不包含余额抵扣价格
                        OrderPaymentRecord one1 = orderPaymentRecordService.lambdaQuery().eq(OrderPaymentRecord::getOrderId, one.getId())
                                .ne(OrderPaymentRecord::getPaymentType, 4).one();
                        // 分佣给上级 先远程查询分佣比例
                    CommissionRule data1 = sysUserClient.getCommission().getData();
                    if (data1 != null) {
                        if (data1.getProportion() != null) {
                            BigDecimal bigDecimal = one1.getPayAmount().add(one.getChangePrice()!=null?one.getChangePrice():new BigDecimal("0")).multiply(data1.getProportion()).divide(new BigDecimal("100"))
                                    .setScale(2, BigDecimal.ROUND_DOWN);
                            // 上级获取的分佣金额
                            AppUser appUserById = remoteAppUserService.getAppUserById(data.getInviteUserId() + "").getData();
                            // 更新用户余额
//                            remoteAppUserService.updateAppUser(
//                                    AppUserDTO.builder().balance(
//                                                    appUserById.getBalance().add(bigDecimal))
//                                            .build(), SecurityConstants.INNER);
                            // 新增分佣流水明细
                            if (bigDecimal.compareTo(new BigDecimal("0"))>0){
                                AppUserWalletRecord appUserWalletRecord = new AppUserWalletRecord();
                                appUserWalletRecord.setAppUserId(data.getInviteUserId());
                                appUserWalletRecord.setChangeType(1);
                                appUserWalletRecord.setReason("分佣收益");
                                appUserWalletRecord.setAmount(bigDecimal);
                                appUserWalletRecord.setChildAppUserId(one.getAppUserId());
                                appUserWalletRecord.setOrderId(one.getId());
                                remoteAppUserService.addBalanceRecord(appUserWalletRecord);
                                one.setCommissionAmount(bigDecimal);
                                one.setCommissionId(data.getInviteUserId());
                            }
                            orderService.updateById(one);
                        }
                    }
                    }
                }
                if (one.getPayType() == 4 ||one.getPayType() == 5 ||one.getPayType() == 6 ||one.getPayType() == 7){
                    // 涉及到余额支付 新增一条余额支付记录
                    OrderPaymentRecord one1 = orderPaymentRecordService.lambdaQuery().eq(OrderPaymentRecord::getOrderId, one.getId())
                            .eq(OrderPaymentRecord::getPaymentType, 4).one();
                    AppUserWalletRecord appUserWalletRecord = new AppUserWalletRecord();
                    appUserWalletRecord.setAppUserId(one.getAppUserId());
                    String reason=null;
                    switch (one.getOrderFrom()){
                        case 1:
                            Meditation data1 = remoteMeditationService.getMeditationById(one.getBusinessId()).getData();
                            appUserWalletRecord.setChangeType(2);
                            reason = "购买疗愈【"+data1.getMeditationTitle()+"】";
                            break;
                        case 2:
                            Course data2 = remoteCourseService.getCourseById(one.getBusinessId()).getData();
                            reason = "购买课程【"+data2.getCourseTitle()+"】";
                            appUserWalletRecord.setChangeType(2);
                            // 增加用户与课程的关系表
                            if (one.getGiveUserId()!=null){
                                remoteAppUserService.addAppUserCourse(one.getBusinessId(),one.getGiveUserId(),one.getId(),1);
                            }else{
                                // 自己购买
                                remoteAppUserService.addAppUserCourse(one.getBusinessId(),one.getAppUserId(),one.getId(),2);
                            }
                            break;
                        case 3:
                            // 会员
                            reason = "购买会员【"+one.getBuyContent()+"】";
                            appUserWalletRecord.setChangeType(2);
                            break;
                        case 4:
                            // 充值
                            reason = "充值";
                            appUserWalletRecord.setChangeType(1);
                            break;
                    }
                    appUserWalletRecord.setReason(reason);
                    appUserWalletRecord.setAmount(one1.getPayAmount());
                    appUserWalletRecord.setOrderId(one.getId());
                    remoteAppUserService.addBalanceRecord(appUserWalletRecord);
                }else{
                    switch (one.getOrderFrom()){
                        case 2:
                            Course data2 = remoteCourseService.getCourseById(one.getBusinessId()).getData();
                            // 增加用户与课程的关系表
                            if (one.getGiveUserId()!=null){
                                remoteAppUserService.addAppUserCourse(one.getBusinessId(),one.getGiveUserId(),one.getId(),1);
                            }else{
                                // 自己购买
                                remoteAppUserService.addAppUserCourse(one.getBusinessId(),one.getAppUserId(),one.getId(),2);
                            }
                            break;
                        case 3:
                            // 会员
                            if (one.getBuyContent().contains("月")){

                                remoteAppUserService.addVipExpireTime(one.getAppUserId(),1);
                            }else if (one.getBuyContent().contains("季")){
                                remoteAppUserService.addVipExpireTime(one.getAppUserId(),2);
                            }else if (one.getBuyContent().contains("年")){
                                remoteAppUserService.addVipExpireTime(one.getAppUserId(),3);
                            }
                            break;
                        case 4:
                            remoteAppUserService.addBalance(one.getAppUserId(),one.getRealPayAmount());
                            AppUserWalletRecord appUserWalletRecord = new AppUserWalletRecord();
                            appUserWalletRecord.setAppUserId(one.getAppUserId());
                            appUserWalletRecord.setChangeType(1);
                            appUserWalletRecord.setReason("充值");
                            appUserWalletRecord.setAmount(one.getRealPayAmount());
                            appUserWalletRecord.setChildAppUserId(one.getAppUserId());
                            appUserWalletRecord.setOrderId(one.getId());
                            remoteAppUserService.addBalanceRecord(appUserWalletRecord);
                            break;
                    }
                }
                orderService.updateById(one);
                PrintWriter out = response.getWriter();
                out.write("succeeded");
                out.flush();
                out.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private static final String AES_KEY = "6d548eb01bad44bbbb4a23743e733103";
    public static String decrypt(String strToDecrypt) {
        try {
            SecretKeySpec secretKey = new SecretKeySpec(AES_KEY.getBytes(), "AES");
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(Cipher.DECRYPT_MODE, secretKey);
            return new String(cipher.doFinal(Base64.getDecoder().decode(strToDecrypt)));
        } catch (Exception e) {
            System.out.println("Error while decrypting: " + e.toString());
        }
        return null;}
    /**
     * 购买套餐微信支付回调
     *
     * @param request
     * @param response
     */
    @ResponseBody
    @PostMapping("/base/testApple")
    public void testApple(HttpServletRequest request, HttpServletResponse response) {
        try {
            Map<String, String> params = new HashMap<String, String>();
            System.err.println("请求"+request);
            BufferedReader reader = request.getReader();
            String string1 = reader.toString();
            System.err.println("请求reader"+string1);
            StringBuilder requestBody = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                requestBody.append(line);
            }
            System.err.println("全部请求体"+requestBody);
            org.json.JSONObject jsonObject1 = new org.json.JSONObject(requestBody.toString());
            System.err.println("json串"+jsonObject1);
            String o = jsonObject1.getString("signedPayload");
            com.alibaba.fastjson.JSONObject payload = verifyAndGet(o);
            String notificationType = payload.get("notificationType").toString();
            com.alibaba.fastjson.JSONObject data = payload.getJSONObject("data");
            String signedTransactionInfo = data.get("signedTransactionInfo").toString();
            String environment = data.get("environment").toString();
            com.alibaba.fastjson.JSONObject transactionInfo = verifyAndGet(signedTransactionInfo);
            String transactionId = transactionInfo.get("transactionId").toString();
            String originalTransactionId = transactionInfo.get("originalTransactionId").toString();
            String productId = transactionInfo.get("productId").toString();
            System.err.println("json串"+transactionInfo);
            System.err.println("data"+data);
            // 苹果流水号
            String string = transactionInfo.getString("originalTransactionId");
            System.err.println("苹果流水号"+string);
            OrderPaymentRecord two = orderPaymentRecordService.lambdaQuery()
                    .eq(OrderPaymentRecord::getPayOrderNo, string).ne(OrderPaymentRecord::getPaymentStatus, 2).one();
            if (two!=null){
                Order one = orderService.getById(two.getOrderId());
                if (one.getPaymentStatus()==2){
                    return;
                }
                one.setPaymentStatus(2);
                one.setPaymentTime(LocalDateTime.now());
                orderService.updateById(one);
                OrderPaymentRecord one2 = orderPaymentRecordService.lambdaQuery().eq(OrderPaymentRecord::getOrderId, one.getId())
                        .ne(OrderPaymentRecord::getPaymentType, 4).one();
                if (one2!=null){
                    one2.setPaymentStatus(2);
                    orderPaymentRecordService.updateById(one2);
                }
                // 实际支付金额
                BigDecimal realPayAmount = one.getRealPayAmount();
                // 判断订单所属用户是否有上级 是否需要做分佣处理
                AppUser data9 = remoteAppUserService.getAppUserById(one.getAppUserId() + "").getData();
                if (one.getGiveUserId()!=null){
                    remoteAppUserService.addNotice(one.getGiveUserId() + "", one.getBusinessId() + "",
                            one.getAppUserId() + "", one.getTotalAmount() + "");
                }

                if (data9.getInviteUserId()!=null) {

                    if (one.getOrderFrom() == 1 || one.getOrderFrom() == 2 || one.getOrderFrom() == 3) {
                        // 查询实际支付价格 不包含余额抵扣价格
                        OrderPaymentRecord one1 = orderPaymentRecordService.lambdaQuery().eq(OrderPaymentRecord::getOrderId, one.getId())
                                .ne(OrderPaymentRecord::getPaymentType, 4).one();
                        // 分佣给上级 先远程查询分佣比例
                        CommissionRule data1 = sysUserClient.getCommission().getData();
                        if (data1 != null) {
                            if (data1.getProportion() != null) {

                                BigDecimal bigDecimal = one1.getPayAmount().multiply(data1.getProportion()).divide(new BigDecimal("100"))
                                        .setScale(2, BigDecimal.ROUND_DOWN);
                                // 上级获取的分佣金额
                                AppUser appUserById = remoteAppUserService.getAppUserById(data9.getInviteUserId() + "").getData();
                                // 更新用户余额
//                            remoteAppUserService.updateAppUser(
//                                    AppUserDTO.builder().balance(
//                                                    appUserById.getBalance().add(bigDecimal))
//                                            .build(), SecurityConstants.INNER);
                                // 新增分佣流水明细
                                AppUserWalletRecord appUserWalletRecord = new AppUserWalletRecord();
                                appUserWalletRecord.setAppUserId(data9.getInviteUserId());
                                appUserWalletRecord.setChangeType(1);
                                appUserWalletRecord.setReason("分佣收益");
                                appUserWalletRecord.setAmount(bigDecimal);
                                appUserWalletRecord.setChildAppUserId(one.getAppUserId());
                                appUserWalletRecord.setOrderId(one.getId());
                                remoteAppUserService.addBalanceRecord(appUserWalletRecord);
                                one.setCommissionAmount(bigDecimal);
                                one.setCommissionId(data9.getInviteUserId());
                                orderService.updateById(one);
                            }
                        }
                    }
                }
                if (one.getPayType() == 4 ||one.getPayType() == 5 ||one.getPayType() == 6 ||one.getPayType() == 7){
                    // 涉及到余额支付 新增一条余额支付记录
                    OrderPaymentRecord one1 = orderPaymentRecordService.lambdaQuery().eq(OrderPaymentRecord::getOrderId, one.getId())
                            .eq(OrderPaymentRecord::getPaymentType, 4).one();
                    AppUserWalletRecord appUserWalletRecord = new AppUserWalletRecord();
                    appUserWalletRecord.setAppUserId(data9.getInviteUserId());
                    String reason=null;
                    switch (one.getOrderFrom()){
                        case 1:
                            Meditation data1 = remoteMeditationService.getMeditationById(one.getBusinessId()).getData();
                            appUserWalletRecord.setChangeType(2);
                            reason = "购买疗愈【"+data1.getMeditationTitle()+"】";

                            break;
                        case 2:
                            Course data2 = remoteCourseService.getCourseById(one.getBusinessId()).getData();
                            reason = "购买课程【"+data2.getCourseTitle()+"】";
                            appUserWalletRecord.setChangeType(2);
                            // 增加用户与课程的关系表
                            if (one.getGiveUserId()!=null){
                                remoteAppUserService.addAppUserCourse(one.getBusinessId(),one.getGiveUserId(),one.getId(),1);
                            }else{
                                // 自己购买
                                remoteAppUserService.addAppUserCourse(one.getBusinessId(),one.getAppUserId(),one.getId(),2);
                            }
                            break;
                        case 3:
                            // 会员
                            reason = "购买会员【"+one.getBuyContent()+"】";
                            appUserWalletRecord.setChangeType(2);
                            break;
                        case 4:
                            // 充值
                            reason = "充值";
                            appUserWalletRecord.setChangeType(1);
                            break;
                    }
                    appUserWalletRecord.setReason(reason);
                    appUserWalletRecord.setAmount(one1.getPayAmount());
                    appUserWalletRecord.setChildAppUserId(one.getAppUserId());
                    appUserWalletRecord.setOrderId(one.getId());
                    remoteAppUserService.addBalanceRecord(appUserWalletRecord);
                }else{
                    switch (one.getOrderFrom()){
                        case 2:
                            Course data2 = remoteCourseService.getCourseById(one.getBusinessId()).getData();
                            // 增加用户与课程的关系表
                            if (one.getGiveUserId()!=null){
                                remoteAppUserService.addAppUserCourse(one.getBusinessId(),one.getGiveUserId(),one.getId(),1);
                            }else{
                                // 自己购买
                                remoteAppUserService.addAppUserCourse(one.getBusinessId(),one.getAppUserId(),one.getId(),2);
                            }
                            break;
                        case 3:
                            // 会员
                            if (one.getBuyContent().contains("月")){

                                remoteAppUserService.addVipExpireTime(one.getAppUserId(),1);
                            }else if (one.getBuyContent().contains("季")){
                                remoteAppUserService.addVipExpireTime(one.getAppUserId(),2);
                            }else if (one.getBuyContent().contains("年")){
                                remoteAppUserService.addVipExpireTime(one.getAppUserId(),3);
                            }
                            break;
                        case 4:
                            System.err.println("进入充值");
                            remoteAppUserService.addBalance(one.getAppUserId(),one.getTotalAmount());
                            AppUserWalletRecord appUserWalletRecord = new AppUserWalletRecord();
                            appUserWalletRecord.setAppUserId(one.getAppUserId());
                            appUserWalletRecord.setChangeType(1);
                            appUserWalletRecord.setReason("充值");
                            appUserWalletRecord.setAmount(one.getTotalAmount());
                            appUserWalletRecord.setChildAppUserId(one.getAppUserId());
                            appUserWalletRecord.setOrderId(one.getId());
                            remoteAppUserService.addBalanceRecord(appUserWalletRecord);
                            break;
                    }
                }
                PrintWriter out = response.getWriter();
                out.write("succeeded");
                out.flush();
                out.close();
            }
//            Recharge orderNumber = rechargeService.selectOne(new EntityWrapper<Recharge>()
//                    .eq("orderNumber", string));
//            if (orderNumber!=null){
//                if (orderNumber.getState()!=2){
//                    // 进入
//                    orderNumber.setState(2);
//                    orderNumber.setPayTime(new Date());
//                    rechargeService.updateById(orderNumber);
//                    BigDecimal amount = orderNumber.getAmount();
//                    AppUser appUser = appUserService.selectById(orderNumber.getUserId());
//                    BigDecimal add = appUser.getBalance().add(amount);
//                    appUser.setBalance(add);
//                    appUserService.updateById(appUser);
//                }
//            }
            PrintWriter out = response.getWriter();
            out.write("success");
            out.flush();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static com.alibaba.fastjson.JSONObject verifyAndGet(String jws) throws CertificateException {
        DecodedJWT decodedJWT = JWT.decode(jws);
        // 拿到 header 中 x5c 数组中第一个
        String header = new String(java.util.Base64.getDecoder().decode(decodedJWT.getHeader()));
        String x5c = com.alibaba.fastjson.JSONObject.parseObject(header).getJSONArray("x5c").getString(0);

        // 获取公钥
        PublicKey publicKey = getPublicKeyByX5c(x5c);

        // 验证 token
        Algorithm algorithm = Algorithm.ECDSA256((ECPublicKey) publicKey, null);

        try {
            algorithm.verify(decodedJWT);
        } catch (SignatureVerificationException e) {
            throw new RuntimeException("签名验证失败");
        }
        // 解析数据
        return com.alibaba.fastjson.JSONObject.parseObject(new String(java.util.Base64.getDecoder().decode(decodedJWT.getPayload())));
    }
    /**
     * 获取公钥
     * @param x5c
     * @return
     * @throws
     */
    private static PublicKey getPublicKeyByX5c(String x5c) throws CertificateException {
        byte[] x5c0Bytes = java.util.Base64.getDecoder().decode(x5c);
        CertificateFactory fact = CertificateFactory.getInstance("X.509");
        X509Certificate cer = (X509Certificate) fact.generateCertificate(new ByteArrayInputStream(x5c0Bytes));
        return cer.getPublicKey();
    }
    /**
     * 获取请求内容
     *
     * @param request
     * @return
     * @throws IOException
     */
    private String getParam(HttpServletRequest request) throws IOException {
        // 读取参数
        InputStream inputStream;
        StringBuilder sb = new StringBuilder();
        inputStream = request.getInputStream();
        String s;
        BufferedReader in = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
        while ((s = in.readLine()) != null) {
            sb.append(s);
        }
        in.close();
        inputStream.close();
        return sb.toString();
    }
    @ResponseBody
    @PostMapping("/testCallback")
    public void wechatPaymentGameCallback(HttpServletRequest request, HttpServletResponse response) throws Exception {
        System.err.println("进入回调");

    }
    /**
     * 远程调用 根据用户id 查询充值金额
@@ -163,27 +1160,36 @@
     */
    @PostMapping("/getOrderById/{orderId}")
    public R<Order> getOrderById(@PathVariable("orderId") Long orderId) {
        Long userId = SecurityUtils.getUserId();
        if (userId==0)return R.tokenError("登录失效");
        Long userId = tokenService.getLoginUser().getUserid();
        if(userId ==null || userId == 0)return R.tokenError("登录失效");
        Order one = orderService.lambdaQuery()
                .eq(Order::getId, orderId).one();
        if (one!=null){
            OrderPaymentRecord two = orderPaymentRecordService.lambdaQuery()
                    .eq(OrderPaymentRecord::getOrderId, orderId)
                    .ne(OrderPaymentRecord::getPaymentType, 4)
                    .eq(OrderPaymentRecord::getPaymentStatus, 2).one();
                    .ne(OrderPaymentRecord::getPaymentStatus, 1).one();
            OrderPaymentRecord three = orderPaymentRecordService.lambdaQuery()
                    .eq(OrderPaymentRecord::getOrderId, orderId)
                    .eq(OrderPaymentRecord::getPaymentType, 4)
                    .ne(OrderPaymentRecord::getPaymentStatus, 1).one();
            if (two==null){
                one.setRemark("余额支付");
                one.setBalance(one.getTotalAmount());
            }else{
                switch (two.getPaymentType()){
                    case 1:
                        one.setRemark("微信支付");
                switch (one.getPayType()){
                    case 5:
                        one.setRemark("微信支付+余额");
                        break;
                    case 2:
                        one.setRemark("支付宝支付");
                    case 6:
                        one.setRemark("支付宝支付+余额");
                        break;
                    case 3:
                        one.setRemark("苹果内购");
                    case 7:
                        one.setRemark("苹果内购+余额");
                }
                one.setPayOrderNo(two.getPayOrderNo());
                if (three!=null){
                    one.setBalance(three.getPayAmount());
                }
            }
            if (one.getCommissionId()!=null){
@@ -200,6 +1206,7 @@
                        one.setRemark("充值");
                }
            }

            return R.ok(one);
        }
        return R.ok();