卡项退款-提交

chenjiahe

2023-06-16 949373691bb795099503ec2d9a9d8cffd8d2669c

卡项退款-提交

 phi_platform_common/src/main/java/com/hx/phip/tool/refund/RefundTool.java

@@ -5,6 +5,7 @@
import com.hx.mybatisTool.SqlSentence;
import com.hx.phiappt.common.OrderItemConstants;
import com.hx.phiappt.common.RefundStatus;
import com.hx.phiappt.model.BaseEntity;
import com.hx.phiappt.model.cardItem.CardEquity;
import com.hx.phiappt.model.cardItem.CardItem;
import com.hx.phiappt.model.cardItem.CardItemInfo;
@@ -17,12 +18,14 @@
import com.hx.phip.tool.user.UserCardTool;
import com.hx.phip.vo.order.payment.PayMethodVo;
import com.hx.phip.vo.order.refund.DistributionRedundVo;
import com.hx.phip.vo.order.refund.RefundCardVo;
import com.hx.phip.vo.user.UserCardItemInfoVo;
import com.hx.util.StringUtils;
import com.hz.his.vo.order.refund.RefundUserCardItemVo;
import com.hz.his.vo.order.refund.RefundUserCardVo;
import com.platform.exception.PlatTipsException;
import com.platform.resultTool.PlatformCode;
import org.springframework.beans.BeanUtils;

import java.math.BigDecimal;
import java.math.RoundingMode;
@@ -77,39 +80,42 @@
    }

    /**获取一级退款子单已退金额
     * 主要查询，单个数量分配的退款金额，因为目前是按照数量来分配金额退款的
     * @param orderItemId 一级退款子单关联标识
     * @param goodsType 商品类型
     * @param commonService 映射
     * @return 已退金额
     */
    public static RefundRecordItem getOneAlreadyRefundTotal(String orderItemId,String goodsType, CommonService commonService ){

        //查找正常退款的
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> values = new HashMap<>();

        //获取已退款的金额
        StringBuilder sql = new StringBuilder();
        //获取已退款的金额，剔除掉用户卡项的部分退
        values.put("orderItemId",orderItemId);
        sqlSentence.sqlSentence("SELECT ROUND(SUM(rri.occupyRefundTotal),2) AS occupyRefundTotal,ROUND(SUM(rri.occupyRefundIntegral),2) AS occupyRefundIntegral FROM refund_record_item rri" +
                " JOIN refund_record rr ON rr.id = rri.refundRecordId AND rr.isDel = 0 AND rr.refundStatus IN(0,2)" +
                " WHERE rri.isDel = 0 AND rri.orderItemId = #{m.orderItemId} AND rri.userCardId IS NULL",values);
        sql.append("SELECT ROUND(SUM(rri.occupyRefundTotal),2) AS occupyRefundTotal,ROUND(SUM(rri.occupyRefundIntegral),2) AS occupyRefundIntegral");
        sql.append(" FROM refund_record_item rri");
        sql.append(" JOIN refund_record rr ON rr.id = rri.refundRecordId AND rr.isDel = 0 AND rr.refundStatus IN(0,2)");
        sql.append(" WHERE rri.isDel = 0 AND rri.orderItemId = #{m.orderItemId} AND rri.userCardId IS NULL");
        sqlSentence.sqlSentence(sql.toString(),values);
        RefundRecordItem refundRecordItem = commonService.selectOne(RefundRecordItemMapper.class,sqlSentence);

        if(refundRecordItem == null || refundRecordItem.getOccupyRefundTotal() == null){
        if(refundRecordItem == null){
            //设置没有找到
            refundRecordItem.setIsDel(BaseEntity.YES);
            refundRecordItem = new RefundRecordItem();
        }
        //用户卡包退款，系统退款总金额，按照退款数量来算的，记录到用户卡包里面了

        //用户卡包退款，系统退款总金额，按照退款数量来算的，用户卡包部分退，要特殊查找
        if(OrderItemConstants.TYPE_CARD.equals(goodsType)){
            //查找有没有这个卡包部分退款的记录
            values.clear();
            values.put("orderItemId",orderItemId);
            sqlSentence.sqlSentence("SELECT uc.* FROM refund_record_item rri" +
                    " JOIN refund_record rr ON rr.id = rri.refundRecordId" +
                    " JOIN user_card uc ON uc.id = rri.userCardId" +
                    " AND rr.isDel = 0 AND rr.refundStatus IN(0,2)" +
                    " WHERE rri.isDel = 0 AND rri.orderItemId = #{m.orderItemId} AND rri.userCardId IS NOT NULL",values);
            List<UserCard> userCardList = commonService.selectList(UserCardMapper.class,sqlSentence);
            for(UserCard userCard:userCardList){
                refundRecordItem.setOccupyRefundTotal(refundRecordItem.getOccupyRefundTotal().add(userCard.getOccupyRefundTotal()));
                refundRecordItem.setOccupyRefundIntegral(refundRecordItem.getOccupyRefundIntegral().add(userCard.getOccupyRefundIntegral()));
            List<RefundRecordItem> refundRecordItemList = findRefundUserCard(orderItemId,null,commonService);
            if(refundRecordItemList.size() > 0){
                refundRecordItem.setIsDel(BaseEntity.NO);
            }
            for(RefundRecordItem refundRecordItem1:refundRecordItemList){
                refundRecordItem.setOccupyRefundTotal(refundRecordItem.getOccupyRefundTotal().add(refundRecordItem1.getOccupyRefundTotal()));
                refundRecordItem.setOccupyRefundIntegral(refundRecordItem.getOccupyRefundIntegral().add(refundRecordItem1.getOccupyRefundIntegral()));
            }
        }

@@ -117,22 +123,27 @@
    }

    /**获取二级退款子单已退金额
     * @param orderItemSonId 二级退款子单关联标识
     * @param orderItemSonId 二级退款子单关联标识/关联卡项条目的id
     * @param commonService 映射
     * @return 已退金额
     */
    public static RefundRecordItemSource getTwoAlreadyRefundTotal(String orderItemSonId, CommonService commonService ){
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> values = new HashMap<>();
        StringBuilder sql = new StringBuilder();

        //获取已退款的金额
        values.put("orderItemSonId",orderItemSonId);
        sqlSentence.sqlSentence("SELECT ROUND(SUM(rris.occupyRefundTotal),2) AS occupyRefundTotal,ROUND(SUM(rris.occupyRefundIntegral),2) AS occupyRefundIntegral FROM refund_record_item_source rris" +
                " JOIN refund_record rr ON rr.id = rris.refundRecordId AND rr.isDel = 0 AND rr.refundStatus IN(0,2)" +
                " WHERE rris.isDel = 0 AND rris.orderItemSonId = #{m.orderItemSonId}",values);
        sql.append("SELECT ROUND(SUM(rris.occupyRefundTotal),2) AS occupyRefundTotal,ROUND(SUM(rris.occupyRefundIntegral),2) AS occupyRefundIntegral");
        sql.append(" FROM refund_record_item_source rris");
        sql.append(" JOIN refund_record rr ON rr.id = rris.refundRecordId AND rr.isDel = 0 AND rr.refundStatus IN(0,2)");
        sql.append(" WHERE rris.isDel = 0 AND rris.orderItemSonId = #{m.orderItemSonId}");
        //获取已退款的金额
        sqlSentence.sqlSentence(sql.toString(),values);
        RefundRecordItemSource refundRecordItemSource = commonService.selectOne(RefundRecordItemSourceMapper.class,sqlSentence);

        if(refundRecordItemSource == null || refundRecordItemSource.getOccupyRefundTotal() == null){
        if(refundRecordItemSource == null){
            //设置是没有找到
            refundRecordItemSource.setIsDel(BaseEntity.YES);
            return new RefundRecordItemSource();
        }else{
            return refundRecordItemSource;
@@ -141,9 +152,15 @@

    /**计算用户卡包条目退款金额*/
    public static void userCardRefundCount(UserCard userCard,RefundUserCardVo refundUserCardVo, CommonService commonService, RefundMapper refundMapper){

        ////算出金额：
        //1、算出“单次抵扣金额”，再乘以数量得出“抵扣总金额”
        //2、用“抵扣总金额”算出占用整个卡项总金额的“比例”
        //1、算出该卡可退总金额
        //2、算出卡项条目总金额，就是占订单支付金额的钱
        //3、算出单条目的权益占用金额
        //4、获取该条目已退款金额
        //5、算出“单次抵扣金额”，再乘以数量得出“抵扣总金额”
        //6、用“抵扣总金额”算出占用整个卡项总金额的“比例”
        //7、比较金额，得出可退金额，注意最后一次要全部退掉

        //获取卡项
        CardItem cardItem = commonService.selectOneByKey(CardItemMapper.class,userCard.getCardItemId());
@@ -157,37 +174,28 @@
            throw new TipsException("获取订单子单失败[210]！");
        }

        //整个用户卡包可退款结构体
        DistributionRedundVo distributionRedundVo;
        //公用对象
        RefundRecordItemSource itemSource;

        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> values = new HashMap<>();

        //--------获取用户卡包的总金额
        //查找有没有这个卡包部分退款的记录
        values.clear();
        values.put("orderItemId",orderItem.getId());
        values.put("userCardId",userCard.getId());
        sqlSentence.sqlSentence("SELECT uc.* FROM refund_record_item rri" +
                " JOIN refund_record rr ON rr.id = rri.refundRecordId" +
                " JOIN user_card uc ON uc.id = rri.userCardId" +
                " AND rr.isDel = 0 AND rr.refundStatus IN(0,2)" +
                " WHERE rri.isDel = 0 AND rri.orderItemId = #{m.orderItemId} AND rri.userCardId IS NOT NULL LIMIT 1",values);
        UserCard oldUserCard = commonService.selectOne(UserCardMapper.class,sqlSentence);
        if(oldUserCard == null){
            //用户卡包没有退过款，那么就按照正常的流程获取可退款金额
            distributionRedundVo = UserCardTool.userCardPay(userCard,orderItem,commonService,refundMapper);
        }else{
            distributionRedundVo = new DistributionRedundVo();
            distributionRedundVo.setRefundTotal(oldUserCard.getOccupyRefundTotal());
            distributionRedundVo.setRefundIntegral(oldUserCard.getOccupyRefundTotal());
        }
        //用户卡项分配可退总金额
        RefundCardVo refundCard = new RefundCardVo();

        CardItemInfo cardItemInfo;
        CardEquity cardEquity;
        //条目金额计算
        BigDecimal sumCardBagMoney;
        //条目积分计算
        BigDecimal sumCardBagIntegral;

        //获取卡项的权益数量
        int cardEquityNum = UserCardTool.getCardEquityCount(userCard.getCardItemId(),commonService);

        //存储权益分配的退款金额
        Map<String,RefundCardVo> cardEquityMap = new HashMap<>();

        //比例
        RefundCardVo refundCardEquity;
        RefundCardVo refundCardInfo;
        BigDecimal proportion;
        for(RefundUserCardItemVo refundUserCardItemVo:refundUserCardVo.getRefundUserCardItemVoList()){
            if(StringUtils.isEmpty(refundUserCardItemVo.getCardItemInfoId())){
@@ -204,7 +212,7 @@
            if(cardEquity == null){
                throw new TipsException("获取卡项权益信息失败[210]！");
            }

            //-----校验
            //获取可用剩余使用次数
            UserCardItemInfoVo uerCardItemInfoVo = UserCardTool.getSurplusNumber(userCard,cardItemInfo,cardEquity,commonService);
            //获取当前需要抵扣的次数
@@ -216,11 +224,38 @@
                throw new PlatTipsException(PlatformCode.ERROR_TIPS,"卡项退款提示:卡项的【"+cardItemInfo.getCommonName()+"】次数不够");
            }

            refundCardInfo = new RefundCardVo();

            //-----算出权益分配到金额
            //查看权益是否已经分配好了的
            refundCardEquity = getCardEquityData(orderItem,userCard,cardItem,cardEquity,refundCard,cardEquityNum,cardEquityMap,commonService,refundMapper);
            //判断是不是最后一个条目
            if(CardEquity.EQUITY_TYPE_TIME_CARD.equals(cardEquity.getEquityType())){
                //次卡，权益有总次数，所有条目使用的总次数不能大于权益的总次数
                //判断数量
                if(uerCardItemInfoVo.getSurplusNum() < refundUserCardItemVo.getRefundQuantity()){
                    //最后的次数
                    refundCardInfo.setOccupyRefundTotal(refundCardEquity.getSurplusTotal());
                    refundCardInfo.setOccupyRefundIntegral(refundCardEquity.getSurplusIntegral());
                }else{

                }
                refundCardInfo.setSurplusTotal(refundCardEquity.getSurplusTotal());
                refundCardInfo.setSurplusIntegral(refundCardEquity.getSurplusIntegral());
            }else if(CardEquity.EQUITY_TYPE_N_M.equals(cardEquity.getEquityType())){
                //判断条目数量，再判断数量


            }else{
                //固定或者其他
                userCardItemInfoVo.setSurplusNum(cardItemInfo.getMaxNum() - cardItemInfoUseMap.computeIfAbsent(cardItemInfo.getId(),k->0));
            }

            //-----算出单次划扣金额
            //获取单次价格金额
            sumCardBagMoney = UserCardTool.countOneMoney(cardItemInfo);
            //计算抵扣总的分摊明细
            sumCardBagMoney = sumCardBagMoney.multiply(BigDecimal.valueOf(refundUserCardItemVo.getRefundQuantity()).setScale(2,RoundingMode.DOWN));

            //算比例
            if(cardItem.getTotal() != null && cardItem.getTotal().compareTo(BigDecimal.ZERO) > 0){
                proportion = sumCardBagMoney.divide(cardItem.getTotal(),20,RoundingMode.HALF_UP);
@@ -228,10 +263,250 @@
                proportion = BigDecimal.ZERO;
            }

            //算出占用购买卡项订单时候金额（分摊模式）
            sumCardBagMoney = occupyRefundTotal.multiply(proportion);
            sumCardBagIntegral = occupyRefundIntegral.multiply(proportion);

            //获取卡项条目已退款金额
            refundRecordItemSource = getTwoAlreadyRefundTotal(cardItemInfo.getId(),null,null,commonService);

            //

            //不能超过卡项条目的分摊总金额

        }

    }

}
    /**查找部分退款的用户卡包信息，根据用户卡包标识去重了
     * @param orderItemId 子单标识
     * @param userCardId 用户卡包标识
     * @param commonService 映射
     */
    public static List<RefundRecordItem> findRefundUserCard(String orderItemId,String userCardId,CommonService commonService){
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> values = new HashMap<>();

        StringBuilder sql = new StringBuilder();

        //--------获取用户卡包的总金额
        //查找有没有这个卡包部分退款的记录
        sql.append("SELECT rri.occupyRefundTotal,rri.occupyRefundIntegral,rri.userCardId FROM refund_record_item rri");
        sql.append(" JOIN refund_record rr ON rr.id = rri.refundRecordId");
        sql.append(" JOIN user_card uc ON uc.id = rri.userCardId");
        sql.append(" AND rr.isDel = 0 AND rr.refundStatus IN(0,2)");
        sql.append(" WHERE rri.isDel = 0");
        if(StringUtils.noNull(orderItemId)){
            values.put("orderItemId",orderItemId);
            sql.append(" AND rri.orderItemId = #{m.orderItemId}");
        }
        if(StringUtils.noNull(userCardId)){
            values.put("userCardId",userCardId);
            sql.append(" AND rri.userCardId = #{m.userCardId}");
        }else{
            sql.append(" AND rri.userCardId IS NOT NULL");
        }
        sql.append(" GROUP BY rri.userCardId");

        sqlSentence.sqlSentence(sql.toString(),values);
        return commonService.selectList(UserCardMapper.class,sqlSentence);
    }

    /**获取卡包已分配的金额（权益分配的金额）
     * @param userCardId 用户卡项标识，主要获取用户卡项分配的金额
     * @param commonService 映射
     * @return 已退金额
     */
    public static RefundRecordItemSource getCardRealRefund(String userCardId, CommonService commonService ){
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> values = new HashMap<>();
        StringBuilder sql = new StringBuilder();

        values.put("userCardId",userCardId);
        sql.append("SELECT rris.occupyEqRefundTotal,rris.occupyEqRefundIntegral");
        sql.append(" FROM refund_record_item_source rris");
        sql.append(" JOIN refund_record rr ON rr.id = rris.refundRecordId AND rr.isDel = 0 AND rr.refundStatus IN(0,2)");
        sql.append(" WHERE rris.isDel = 0 AND rris.userCardId = #{m.userCardId} GROUP BY rris.cardEquityId");

        List<RefundRecordItemSource> refundRecordItemSourceList = commonService.selectList(RefundRecordItemSourceMapper.class,sqlSentence);

        RefundRecordItemSource source = new RefundRecordItemSource();
        if(refundRecordItemSourceList.size()==0){
            source.setIsDel(BaseEntity.YES);
            return source;
        }
        for(RefundRecordItemSource refundRecordItemSource:refundRecordItemSourceList){
            //计算有多少个权益参与了退款
            refundRecordItemSource.setRealRefundNum(refundRecordItemSource.getRealRefundNum()+1);
            source.setOccupyRefundTotal(source.getOccupyRefundTotal().add(refundRecordItemSource.getOccupyEqRefundTotal()));
            source.setOccupyRefundIntegral(source.getOccupyRefundIntegral().add(refundRecordItemSource.getOccupyEqRefundIntegral()));
        }
        return source;
    }

    /**获取卡包权益已退款金额（条目分配的金额）
     * @param cardEquityId 卡项权益标识，主要获取卡项权益分配的金额
     * @param commonService 映射
     * @return 已退金额
     */
    public static RefundRecordItemSource getCardEquityRealRefund(String cardEquityId, CommonService commonService ){
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> values = new HashMap<>();
        StringBuilder sql = new StringBuilder();

        values.put("cardEquityId",cardEquityId);
        sql.append("SELECT rris.occupyItemRefundTotal,rris.occupyItemRefundIntegral,rris.occupyEqRefundTotal,rris.occupyEqRefundIntegral");
        sql.append(" FROM refund_record_item_source rris");
        sql.append(" JOIN refund_record rr ON rr.id = rris.refundRecordId AND rr.isDel = 0 AND rr.refundStatus IN(0,2)");
        sql.append(" WHERE rris.isDel = 0 AND rris.cardEquityId = #{m.cardEquityId} GROUP BY orderItemSonId");

        List<RefundRecordItemSource> refundRecordItemSourceList = commonService.selectList(RefundRecordItemSourceMapper.class,sqlSentence);

        RefundRecordItemSource source = new RefundRecordItemSource();
        if(refundRecordItemSourceList.size()==0){
            source.setIsDel(BaseEntity.YES);
            return source;
        }
        for(RefundRecordItemSource refundRecordItemSource:refundRecordItemSourceList){
            //计算有多少个条目参与了退款
            source.setRealRefundNum(refundRecordItemSource.getRealRefundNum()+1);
            source.setRefundMoney(source.getRefundMoney().add(refundRecordItemSource.getOccupyItemRefundTotal()));
            source.setRefundIntegral(source.getRefundIntegral().add(refundRecordItemSource.getOccupyItemRefundIntegral()));
            source.setOccupyEqRefundTotal(refundRecordItemSource.getOccupyEqRefundTotal());
            source.setOccupyEqRefundIntegral(refundRecordItemSource.getOccupyEqRefundIntegral());
        }
        return source;
    }

    /**获取卡包条目已退款金额（条目分配的金额）
     * @param cardInfoId 卡项条目标识，主要获取卡项条目分配的金额
     * @param commonService 映射
     * @return 已退金额
     */
    public static RefundCardVo getCardInfoData(String cardInfoId,CommonService commonService){

        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> values = new HashMap<>();
        StringBuilder sql = new StringBuilder();

        values.put("orderItemSonId",cardInfoId);
        sql.append("SELECT SUM(rris.occupyRefundTotal) AS occupyRefundTotal,SUM(rris.occupyRefundIntegral) AS occupyRefundIntegral");
        sql.append(",SUM(rris.realRefundNum) AS realRefundNum,rris.occupyItemRefundTotal,rris.occupyItemRefundIntegral");
        sql.append(" FROM refund_record_item_source rris");
        sql.append(" JOIN refund_record rr ON rr.id = rris.refundRecordId AND rr.isDel = 0 AND rr.refundStatus IN(0,2)");
        sql.append(" WHERE rris.isDel = 0 AND rris.orderItemSonId = #{m.orderItemSonId} GROUP BY orderItemSonId");

        RefundRecordItemSource itemSource = commonService.selectOne(RefundRecordItemSourceMapper.class,sqlSentence);

        RefundCardVo refundCardInfo = new RefundCardVo();

        if(itemSource != null){
            refundCardInfo.setJoinRefund(true);
            refundCardInfo.setRefundNum(itemSource.getRealRefundNum());
            refundCardInfo.setOccupyRefundTotal(itemSource.getOccupyItemRefundTotal());
            refundCardInfo.setOccupyRefundIntegral(itemSource.getOccupyItemRefundIntegral());
            refundCardInfo.setSurplusTotal(itemSource.getOccupyItemRefundTotal().subtract(itemSource.getOccupyRefundTotal()));
            refundCardInfo.setSurplusIntegral(itemSource.getOccupyItemRefundIntegral().subtract(itemSource.getOccupyRefundIntegral()));

        }
        return refundCardInfo;


    }


    /**获取用户卡项的参数，分配金额和剩余可退金额*/
    public static RefundCardVo getUserCardData(OrderItem orderItem,UserCard userCard,CommonService commonService,RefundMapper refundMapper){

        RefundCardVo refundCard = new RefundCardVo();
        //--------获取用户卡包分配的的可退款总金额（包含已经部分退的金额在里面）
        //查找有没有这个卡包部分退款的记录
        List<RefundRecordItem> refundRecordItemList = findRefundUserCard(orderItem.getId(),userCard.getId(),commonService);
        if(refundRecordItemList.size() == 0){
            //用户卡包没有分配总金额，那么就按照正常的流程获取可退款金额
            DistributionRedundVo distributionRedundVo = UserCardTool.userCardPay(userCard,orderItem,commonService,refundMapper);
            refundCard.setOccupyRefundTotal(distributionRedundVo.getRefundTotal());
            refundCard.setOccupyRefundIntegral(distributionRedundVo.getRefundIntegral());
        }else{
            refundCard.setJoinRefund(true);
            RefundRecordItem refundRecordItem = refundRecordItemList.get(0);
            refundCard.setOccupyRefundTotal(refundRecordItem.getOccupyRefundTotal());
            refundCard.setOccupyRefundIntegral(refundRecordItem.getOccupyRefundIntegral());
        }

        //-----计算剩余可分配给权益退款的金额
        //查找该卡包已部分退款的金额
        RefundRecordItemSource itemSource = getCardRealRefund(userCard.getId(),commonService);
        //计算该用户卡包剩余可退金额和积分，就是可分配给权益退款的金额
        refundCard.setSurplusTotal(refundCard.getOccupyRefundTotal().subtract(itemSource.getOccupyRefundTotal()));
        refundCard.setSurplusIntegral(refundCard.getOccupyRefundIntegral().subtract(itemSource.getOccupyRefundIntegral()));
        refundCard.setRefundNum(itemSource.getRealRefundNum());

        return refundCard;
    }

    /**获取用户卡项权益的参数，分配金额和剩余可退金额*/
    public static RefundCardVo getCardEquityData(OrderItem orderItem,UserCard userCard,CardItem cardItem,CardEquity cardEquity,RefundCardVo refundCard,int cardEquityNum
            ,Map<String,RefundCardVo> cardEquityMap,CommonService commonService,RefundMapper refundMapper){

        //-----算出权益分配到金额
        //查看权益是否已经分配好了的
        BigDecimal proportion;
        RefundCardVo refundCardEquity = cardEquityMap.get(cardEquity.getId());
        if(refundCardEquity == null){
            refundCardEquity = new RefundCardVo();

            //获取卡项权益已退款金额和分配的金额
            RefundRecordItemSource cardEquityRealRefund = getCardEquityRealRefund(cardEquity.getId(),commonService);
            if(cardEquityRealRefund.getIsDel().equals(BaseEntity.YES)){
                //没有找到已经分配好的，进行新的分配
                //获取用户卡包分配金额
                if(!refundCard.isJoinRefund()){
                    BeanUtils.copyProperties(getUserCardData(orderItem,userCard,commonService,refundMapper),refundCard);
                    refundCard.setJoinRefund(true);
                }

                if(cardEquityNum>=refundCard.getRefundNum()+1){
                    //是最后一个
                    refundCardEquity.setOccupyRefundTotal(refundCard.getSurplusTotal());
                    refundCardEquity.setOccupyRefundIntegral(refundCard.getSurplusIntegral());
                }else{
                    //不是最后一个，通过比例来算金额
                    if(cardItem.getTotal().compareTo(BigDecimal.ZERO) > 0){
                        proportion = cardEquity.getShareMoney().divide(cardItem.getTotal(),20,RoundingMode.HALF_UP);
                    }else{
                        proportion = BigDecimal.ZERO;
                    }
                    refundCardEquity.setOccupyRefundTotal(refundCard.getOccupyRefundTotal().multiply(proportion).setScale(2,RoundingMode.HALF_UP));
                    refundCardEquity.setOccupyRefundIntegral(refundCard.getOccupyRefundIntegral().multiply(proportion).setScale(2,RoundingMode.HALF_UP));

                    //判断不能大于权益设置的金额
                    if(refundCardEquity.getOccupyRefundTotal().compareTo(cardEquity.getShareMoney()) > 0){
                        refundCardEquity.setOccupyRefundTotal(cardEquity.getShareMoney());
                    }
                    //判断不能大于剩下的可退金额
                    if(refundCardEquity.getOccupyRefundTotal().compareTo(refundCard.getSurplusTotal()) > 0){
                        refundCardEquity.setOccupyRefundTotal(refundCard.getSurplusTotal());
                    }
                    //判断不能大于剩下的可退积分
                    if(refundCardEquity.getOccupyRefundIntegral().compareTo(refundCard.getSurplusIntegral()) > 0){
                        refundCardEquity.setOccupyRefundIntegral(refundCard.getSurplusIntegral());
                    }
                }
                refundCardEquity.setSurplusTotal(refundCardEquity.getOccupyRefundTotal());
                refundCardEquity.setSurplusIntegral(refundCardEquity.getOccupyRefundIntegral());
            }else{
                refundCardEquity.setJoinRefund(true);
                refundCardEquity.setRefundNum(cardEquityRealRefund.getRealRefundNum());
                refundCardEquity.setOccupyRefundTotal(cardEquityRealRefund.getOccupyEqRefundTotal());
                refundCardEquity.setOccupyRefundIntegral(cardEquityRealRefund.getOccupyEqRefundIntegral());
                refundCardEquity.setSurplusTotal(cardEquityRealRefund.getOccupyEqRefundTotal().subtract(cardEquityRealRefund.getRefundMoney()));
                refundCardEquity.setSurplusIntegral(cardEquityRealRefund.getOccupyEqRefundIntegral().subtract(cardEquityRealRefund.getRefundIntegral()));
            }
            cardEquityMap.put(cardEquity.getId(),refundCardEquity);
        }
        return refundCardEquity;
    }


}

 phi_platform_common/src/main/java/com/hx/phip/tool/user/UserCardTool.java

@@ -208,6 +208,8 @@
        //计算退款方式金额
        distributionRedundVo = PaymentCountTool.countMakeWay(orderItem.getId(),orderItem.getActualTotal(),refundRecordItem.getOccupyRefundTotal()
                ,refundRecordItem.getOccupyRefundIntegral(),orderItem.getBuyNum(),userCardList.size(),null,1,payMethodVoList,commonService);
        distributionRedundVo.setGoodsType(orderItem.getType());
        distributionRedundVo.setGoodsName(orderItem.getGoodsName());

        return distributionRedundVo;
    }
@@ -222,8 +224,32 @@
        //获取用户卡项
        sqlMap.put("sourceId",sourceId);
        sqlMap.put("effectiveStatus", UserProjectConstants.EFF_STATUS_CANCEL);
        sqlSentence.sqlSentence("SELECT * FROM user_card WHERE isDel = 0 AND sourceId = #{m.sourceId} AND effectiveStatus != #{m.effectiveStatus}",sqlMap);
        return commonService.selectList(UserCardMapper.class,sqlSentence);
        sqlSentence.sqlSentence("SELECT * FROM user_card WHERE isDel = 0 AND sourceId = #{m.sourceId} AND effectiveStatus != #{m.effectiveStatus} AND turnAddId IS NULL",sqlMap);
        List<UserCard> userCardList = commonService.selectList(UserCardMapper.class,sqlSentence);
        if(userCardList.size() == 0){
            return userCardList;
        }
        //获取已经部分退的用户卡包数量
        List<RefundRecordItem> refundRecordItemList = RefundTool.findRefundUserCard(sourceId,null,commonService);
        //过滤掉没有使用但有部分退款
        if(refundRecordItemList.size() == 0){
            return userCardList;
        }

        Map<String,UserCard> userCardMap = new HashMap<>();
        for(UserCard userCard:userCardList){
            userCardMap.put(userCard.getId(),userCard);
        }
        //去除掉参与部分退款的用户卡包
        for(RefundRecordItem refundRecordItem:refundRecordItemList){
            userCardMap.remove(refundRecordItem.getUserCardId());
        }
        userCardList = new ArrayList<>();
        for (Map.Entry<String,UserCard> entry : userCardMap.entrySet()) {
            userCardList.add(entry.getValue());
        }

        return userCardList;
    }

    /**计算卡包条目单次抵扣的金额
@@ -244,5 +270,17 @@
        }
    }

    /**获取卡项的权益数量*/
    public static int getCardEquityCount(String cardId,CommonService commonService){
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> values = new HashMap<>();

        values.put("cardItemId",cardId);
        sqlSentence.sqlSentence("SELECT * FROM card_equity WHERE isDel = 0 AND cardItemId = #{m.cardItemId}" +
                " AND equityType != 4",values);

        return commonService.selectCountSql(CardEquityMapper.class,sqlSentence);
    }


}

 phi_platform_common/src/main/java/com/hx/phip/vo/order/refund/RefundCardVo.java

New file
@@ -0,0 +1,25 @@
package com.hx.phip.vo.order.refund;

import lombok.Data;

import java.math.BigDecimal;

@Data
public class RefundCardVo {

    /**是否存在退款*/
    private boolean joinRefund = false;
    /**已参与了退款数量*/
    private int refundNum = 0;

    /**分配金额*/
    private BigDecimal occupyRefundTotal = BigDecimal.ZERO;
    /**分配积分*/
    private BigDecimal occupyRefundIntegral = BigDecimal.ZERO;

    /**剩余可分配总金额*/
    private BigDecimal surplusTotal = BigDecimal.ZERO;
    /**剩余可分配总金额*/
    private BigDecimal surplusIntegral = BigDecimal.ZERO;

}

 phi_platform_user/src/main/java/com/hx/phip/service/order/impl/OrderRefundServiceImpl.java

@@ -552,8 +552,8 @@
            if(orderItemRefundDto.getRefundNum() > surplusNum){
                throw new TipsException("退款数量与可退数量不符[02]！");
            }
            //替换成子单的剩余数量
            surplusNum = orderItem.getBuyNum() - orderItem.getHasReNum();
            //替换成子单的剩余数量，2023-06-15因为做用户卡包退款原因，先屏掉这个
            //surplusNum = orderItem.getBuyNum() - orderItem.getHasReNum();
        }else{
            buyNum = orderItem.getBuyNum();
            //替换成子单的剩余数量
@@ -628,7 +628,7 @@
        List<PayMethodVo> payMethodVoList = refundMapper.getConsumePayTwoGroupByNumberNo(orderItemSon.getId());

        //获取该子单已退的总金额
        RefundRecordItemSource refundRecordItemSource = RefundTool.getTwoAlreadyRefundTotal(orderItemSon.getId(),commonService);
        RefundRecordItemSource refundRecordItemSource = RefundTool.getTwoAlreadyRefundTotal(orderItemSon.getId(),null,null,commonService);

        //计算退款方式金额
        DistributionRedundVo distributionRedundVo = PaymentCountTool.countMakeWay(orderItemSon.getId(),orderItemSon.getActualTotal(),refundRecordItemSource.getOccupyRefundTotal()

 phi_platform_user/src/main/java/com/hx/phip/tool/refund/PartialRefundUtil.java

@@ -1640,7 +1640,32 @@
        sqlMap.put("effectiveStatus",effectiveStatus);
        sqlSentence.sqlSentence("SELECT * FROM user_card WHERE isDel = 0 AND sourceId = #{m.sourceId} AND status = #{m.status}" +
                " AND effectiveStatus = #{m.effectiveStatus} AND turnAddId IS NULL",sqlMap);
        return commonService.selectList(UserCardMapper.class,sqlSentence);
        List<UserCard> userCardList = commonService.selectList(UserCardMapper.class,sqlSentence);
        if(userCardList.size() == 0){
            return userCardList;
        }
        //获取已经部分退的用户卡包数量
        List<RefundRecordItem> refundRecordItemList = RefundTool.findRefundUserCard(sourceId,null,commonService);
        //过滤掉没有使用但有部分退款
        if(refundRecordItemList.size() == 0){
            return userCardList;
        }

        Map<String,UserCard> userCardMap = new HashMap<>();
        for(UserCard userCard:userCardList){
            userCardMap.put(userCard.getId(),userCard);
        }
        //去除掉参与部分退款的用户卡包
        for(RefundRecordItem refundRecordItem:refundRecordItemList){
            userCardMap.remove(refundRecordItem.getUserCardId());
        }

        userCardList = new ArrayList<>();
        for (Map.Entry<String,UserCard> entry : userCardMap.entrySet()) {
            userCardList.add(entry.getValue());
        }

        return userCardList;

    }