package com.hx.phip.service.order.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.hx.common.service.CommonService;
import com.hx.exception.TipsException;
import com.hx.mybatisTool.SqlSentence;
import com.hx.phiappt.common.*;
import com.hx.phiappt.constants.tool.PerformanceInfoTool;
import com.hx.phiappt.constants.tool.RefundToolUtil;
import com.hx.phiappt.constants.tool.order.OrderUtil;
import com.hx.phiappt.model.*;
import com.hx.phiappt.model.activity.ActivityAction;
import com.hx.phiappt.model.activity.ActivityRule;
import com.hx.phiappt.model.coupon.CouponOrderDiscountLog;
import com.hx.phiappt.model.order.*;
import com.hx.phiappt.model.performance.PerformanceInfo;
import com.hx.phiappt.model.refund.*;
import com.hx.phiappt.model.user.UserCard;
import com.hx.phiappt.model.user.UserProjectItem;
import com.hx.phiappt.model.userMoney.UserMoneyUnclaimed;
import com.hx.phip.config.CustomParameter;
import com.hx.phip.dao.mapper.*;
import com.hx.phip.service.CreateNoService;
import com.hx.phip.service.PaymentMethodService;
import com.hx.phip.service.order.OrderRefundService;
import com.hx.phip.service.refund.RefundRecordItemService;
import com.hx.phip.service.refund.RefundRecordMethodService;
import com.hx.phip.service.refund.RefundRecordService;
import com.hx.phip.tool.CreateNo;
import com.hx.phip.tool.refund.OrderRefundCancelTool;
import com.hx.phip.tool.refund.PartialRefundUtil;
import com.hx.phip.tool.refund.PaymentCountTool;
import com.hx.phip.tool.refund.RefundTool;
import com.hx.phip.util.api.ApiOrderUtil;
import com.hx.phip.util.api.SendNoticeUtil;
import com.hx.phip.util.api.UserLevelUtil;
import com.hx.phip.util.api.UserMoneyUtil;
import com.hx.phip.vo.order.payment.PayMethodVo;
import com.hx.phip.vo.order.refund.DistributionRedundMethodVo;
import com.hx.phip.vo.order.refund.DistributionRedundVo;
import com.hx.resultTool.Result;
import com.hx.util.StringUtils;
import com.hz.crm.dto.order.refund.RefundAmountModelDto;
import com.hz.crm.dto.order.refund.RefundDto;
import com.hz.crm.dto.order.refund.RefundReturnDto;
import com.hz.crm.feign.FOderService;
import com.hz.his.dto.aduit.AduitDto;
import com.hz.his.dto.marketing.OrderPartRefundDto;
import com.hz.his.dto.marketing.PartRefundPayDto;
import com.hz.his.dto.marketing.RefundProjectDto;
import com.hz.his.dto.order.*;
import com.hz.his.feign.service.marketing.MOrderService;
import com.hz.his.vo.order.refund.RefundCancelVo;
import com.hz.his.vo.order.refund.RefundUserCardVo;
import com.platform.entity.ThirtApplication;
import com.platform.exception.PlatTipsException;
import com.platform.resultTool.PlatformCode;
import com.platform.resultTool.PlatformResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @Author CJH
 * 重构与2023-03-20
 */
@Transactional
@Service
public class OrderRefundServiceImpl implements OrderRefundService {

    /**log4j日志*/
    private static final Logger logger = LoggerFactory.getLogger(OrderRefundServiceImpl.class.getName());
    @Resource
    private OrdersTotalMapper ordersTotalMapper;
    @Resource
    private OrderItemMapper orderItemMapper;
    @Resource
    private RefundRecordMapper refundRecordMapper;
    @Resource
    private OrderItemSonMapper orderItemSonMapper;
    @Resource
    private RefundNoteMapper refundNoteMapper;
    @Resource
    private RefundNoteItemsMapper refundNoteItemsMapper;

    @Resource
    private CommonService commonService;

    @Resource
    private FOderService fOderService;

    @Resource
    private SystemParameterMapper systemParameterMapper;
    @Resource
    private RefundRecordService refundRecordService;
    @Resource
    private PaymentMethodService paymentMethodService;
    @Resource
    private RefundRecordMethodService refundRecordMethodService;
    @Resource
    private RefundRecordItemService refundRecordItemService;
    @Resource
    private RefundRecordItemSourceMapper refundRecordItemSourceMapper;
    @Resource
    private CustomParameter customParameter;
    @Resource
    private MOrderService mOrderService;

    @Resource
    private CouponOrderDiscountLogMapper couponOrderDiscountLogMapper;
    @Resource
    private RefundRecordCouponMapper refundRecordCouponMapper;
    @Resource
    private CardEquityMapper cardEquityMapper;
    @Resource
    private RefundMethodTransformationMapper refundMethodTransformationMapper;
    @Resource
    private RefundRecordItemMethodMapper refundRecordItemMethodMapper;
    @Resource
    private RefundMapper refundMapper;
    @Resource
    private CreateNoService createNoService;

    /**
     * 获取退款页面详情
     * @param ordersTotal 订单
     * @return 可退款数量详情
     */
    @Override
    public List<Map<String, Object>> refundDetails(OrdersTotal ordersTotal) {

        SqlSentence sqlSentence = new SqlSentence();
        Map<String, Object> sqlMap = new HashMap<>();
        sqlSentence.setM(sqlMap);

        sqlMap.put("isDel", BaseEntity.NO);
        sqlMap.put("orderId", ordersTotal.getId());
        //一级子订单
        sqlSentence.sqlSentence("SELECT * FROM order_item WHERE  orderId = #{m.orderId} AND isDel = #{m.isDel}",sqlMap);
        List<OrderItem> orderItemList = orderItemMapper.selectList(sqlSentence);

        List<Map<String, Object>> orderItems = new ArrayList<>();

        for (OrderItem orderItem : orderItemList) {
            //判断这个项目能不能显示处理
            switch (orderItem.getType()) {
                case OrderItemConstants.TYPE_PROJECT:
                    handleOrderItemIsProject(orderItems,orderItem);
                    break;
                case OrderItemConstants.TYPE_RETAIL:
                    handleOrderItemIsRetail(orderItems,orderItem);
                    break;
                case OrderItemConstants.TYPE_DRUG:
                    handleOrderItemIsRetail(orderItems, orderItem);
                    break;
                case OrderItemConstants.TYPE_CARD:
                    handleOrderItemIsCard(orderItems, orderItem);
                    break;
                case OrderItemConstants.TYPE_PROMOTION:
                    handleOrderItemIsPromotion(orderItems, orderItem);
                    break;
                case OrderItemConstants.CARD_BAG:
                    handleOrderItemIsCardBag(orderItems, orderItem);
                    break;
                default:
                    break;
            }
        }
        return orderItems;
    }
    /**
     * 处理一级是项目的
     */
    public void handleOrderItemIsProject(List<Map<String, Object>> orderItems, OrderItem orderItem) {
        //获取用户项目
        UserProjectItem userProjectItem = PartialRefundUtil.getUserProject(orderItem.getId(),commonService);
        if(userProjectItem == null){
            throw new TipsException("用户项目获取失败！");
        }

        orderItems.add(itemRefandDataPackage(orderItem,null,userProjectItem,null));
    }

    /**订单子项退款信息封装*/
    public Map<String,Object> itemRefandDataPackage(OrderItem orderItem,OrderItemSon orderItemSon,UserProjectItem userProjectItem,List<UserCard> userCardList){

        Map<String,Object> itemData = new HashMap<>();
        if(orderItemSon != null){
            itemData.put("id",orderItemSon.getId());
            itemData.put("type",orderItemSon.getType());
            itemData.put("goodsName",orderItemSon.getGoodsName());
            itemData.put("curPrice",orderItemSon.getCurPrice());
            itemData.put("specs",orderItemSon.getSpecs());
            itemData.put("buyNum",orderItemSon.getBuyNum());
            itemData.put("hasReNum",orderItemSon.getHasReNum());
            itemData.put("notUsedNum",orderItemSon.getBuyNum()-orderItemSon.getHasReNum());
        }else{
            itemData.put("id",orderItem.getId());
            itemData.put("type",orderItem.getType());
            itemData.put("goodsName",orderItem.getGoodsName());
            itemData.put("curPrice",orderItem.getCurPrice());
            itemData.put("specs",orderItem.getSpecs());
            itemData.put("buyNum",orderItem.getBuyNum());
            itemData.put("hasReNum",orderItem.getHasReNum());
            itemData.put("notUsedNum",orderItem.getBuyNum()-orderItem.getHasReNum());
        }

        if(userProjectItem != null){
            itemData.put("notUsedNum",userProjectItem.getNotUsedNum());
        }
        if(userCardList != null){
            itemData.put("notUsedNum",userCardList.size());
        }
        return itemData;
    }

    /**
     * 处理一级是商品的
     */
    public void handleOrderItemIsRetail(List<Map<String, Object>> orderItems, OrderItem orderItem) {
        orderItems.add(itemRefandDataPackage(orderItem,null,null,null));
    }

    /**
     * 处理一级是卡项的
     */
    public void handleOrderItemIsCard(List<Map<String, Object>> orderItems,OrderItem orderItem) {

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

        //获取用户卡项
        List<UserCard> userCardList = PartialRefundUtil.getRefundCard(orderItem.getId(),UserProjectConstants.EFF_STATUS_YES,commonService);

        //信息封装
        Map<String,Object> itemData = itemRefandDataPackage(orderItem,null,null,userCardList);

        //获取卡项的详细条目
        sqlMap.put("commonId",orderItem.getCommonId());
        sqlSentence.sqlSentence(" SELECT groupName,shareMoney FROM card_equity WHERE cardItemId = #{m.commonId} ",sqlMap);
        List<Map<String, Object>> cardEquitys = cardEquityMapper.selectListMap(sqlSentence);

        itemData.put("list", cardEquitys);
        orderItems.add(itemData);

    }

    /**
     * 处理一级是促销的
     */
    public void handleOrderItemIsPromotion(List<Map<String, Object>> orderItems, OrderItem orderItem) {

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

        //封装参数
        Map<String,Object> itemData = itemRefandDataPackage(orderItem,null,null,null);

        //获取二级子订单
        sqlMap.put("orderItemId", orderItem.getId());
        sqlSentence.sqlSentence("SELECT * FROM order_item_source WHERE orderItemId = #{m.orderItemId} AND isDel = 0 ",sqlMap);
        List<OrderItemSon> orderItemSonList = orderItemSonMapper.selectList(sqlSentence);
        System.out.println("orderItemSonList:"+JSON.toJSONString(orderItemSonList));
        if (orderItemSonList == null) {
            return;
        }

        List<Map<String, Object>> promotionList = new ArrayList<>();

        for (OrderItemSon orderItemSon : orderItemSonList) {
            //判断这个项目能不能显示处理
            switch (orderItemSon.getType()) {
                case OrderGoodsConstants.TYPE_PROJECT:
                    handleOrderItemSonIsProject(promotionList, orderItemSon);
                    break;
                case OrderItemConstants.TYPE_RETAIL:
                    handleOrderItemSonIsRetail(promotionList, orderItemSon);
                    break;
                default:
                    break;
            }
        }

        itemData.put("list", promotionList);
        orderItems.add(itemData);
    }
    /**
     * 处理一级是卡包
     */
    public void handleOrderItemIsCardBag(List<Map<String, Object>> orderItems, OrderItem orderItem) {
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> sqlMap = new HashMap<>();

        Map<String,Object> itemData = itemRefandDataPackage(orderItem,null,null,null);

        //二级子订单
        sqlMap.put("orderItemId", orderItem.getId());
        sqlSentence.sqlSentence("SELECT * FROM order_item_source WHERE orderItemId= #{m.orderItemId} and  isDel = 0 ",sqlMap);
        List<OrderItemSon> orderItemSonList = orderItemSonMapper.selectList(sqlSentence);
        if (orderItemSonList == null) {
            return;
        }
        List<Map<String, Object>> promotionList = new ArrayList<>();

        for (OrderItemSon orderItemSon : orderItemSonList) {
            //判断这个项目能不能显示处理
            switch (orderItemSon.getType()) {
                case OrderGoodsConstants.TYPE_PROJECT:
                    handleOrderItemSonIsProject(promotionList, orderItemSon);
                    break;
                case OrderItemConstants.TYPE_RETAIL:
                    handleOrderItemSonIsRetail(promotionList, orderItemSon);
                    break;
                default:
                    break;
            }
        }

        itemData.put("list", promotionList);
        orderItems.add(itemData);
    }

    /**
     * 处理二级是项目的
     */
    public void handleOrderItemSonIsProject(List<Map<String, Object>> promotionList, OrderItemSon orderItemSon) {

        //获取用户项目
        UserProjectItem userProjectItem = PartialRefundUtil.getUserProject(orderItemSon.getId(),commonService);
        if(userProjectItem == null){
            throw new TipsException("用户项目获取失败[24]！");
        }
        Map<String,Object> itemData = itemRefandDataPackage(null,orderItemSon,userProjectItem,null);

        promotionList.add(itemData);
    }


    /**
     * 处理二级是商品的
     */
    public void handleOrderItemSonIsRetail(List<Map<String, Object>> promotionList, OrderItemSon orderItemSon) {
        promotionList.add(itemRefandDataPackage(null,orderItemSon,null,null));
    }

    /**
     * 退款选择退款数量组装金额信息，退款里面这个非常重要
     * @param orderRefundDto 退款数量信息
     * @return 退款金额信息
     */
    @Override
    public OrderRefundDto nextStep(OrdersTotal ordersTotal,OrderRefundDto orderRefundDto) {
        logger.info("退款选择退款数量组装金额信息入参：{}", JSON.toJSONString(orderRefundDto));

        //子单退款
        List<OrderItemRefundDto> refundList = orderRefundDto.getRefundList();
        //支付方式退款数据整合
        List<OrderPayMethodDto> refundPayMethods = new ArrayList<>();
        //可退款总金额
        BigDecimal totalAmount = BigDecimal.ZERO;
        //可退款总积分
        BigDecimal totalIntegral = BigDecimal.ZERO;

        if (OrderTotalConstants.TYPE_RECHARGE.equals(ordersTotal.getType())) {
            ///////充值订单退款
            refundPayMethods = rechargeRefundWay(ordersTotal);
            for (OrderPayMethodDto orderPayMethodDto : refundPayMethods) {
                if(PayMethodTypeConstants.PAY_INTEGRAL.equals(orderPayMethodDto.getPayMethodNo())){
                    totalIntegral = totalIntegral.add(orderPayMethodDto.getPayTotal());
                }else{
                    totalAmount = totalAmount.add(orderPayMethodDto.getPayTotal()).setScale(2,RoundingMode.HALF_UP);
                }
            }
        }else{
            //////其他订单类型
            //整合支付方式退款金额
            Map<String,OrderPayMethodDto> orderPayMethodDtoMap = new HashMap<>();
            OrderPayMethodDto orderPayMethodDto;

            DistributionRedundVo distributionRedundVo;
            OrderItem orderItem;
            //计算每个条目需要退多少钱
            for (OrderItemRefundDto orderItemRefundDto : refundList) {
                if(StringUtils.isEmpty(orderItemRefundDto.getOrderItemId())){
                    throw new PlatTipsException(PlatformCode.ERROR_TIPS,"退款项标识必填");
                }
                orderItem = orderItemMapper.selectOneByKey(orderItemRefundDto.getOrderItemId());
                if (orderItem == null) {
                    throw new PlatTipsException(PlatformCode.ERROR_TIPS,"退款项标识错误");
                }
                if(!orderItem.getOrderId().equals(ordersTotal.getId())){
                    throw new PlatTipsException(PlatformCode.ERROR_TIPS,"未找到退款项[012]");
                }

                //判断这个项目能不能显示处理
                switch (orderItem.getType()) {
                    case OrderItemConstants.TYPE_PROJECT:
                        distributionRedundVo = itemOneRefund(orderItem,orderItemRefundDto);
                        break;
                    case OrderItemConstants.TYPE_RETAIL:
                        distributionRedundVo = itemOneRefund(orderItem,orderItemRefundDto);
                        break;
                    case OrderItemConstants.TYPE_DRUG:
                        distributionRedundVo = itemOneRefund(orderItem,orderItemRefundDto);
                        break;
                    case OrderItemConstants.TYPE_CARD:
                        distributionRedundVo = itemOneRefund(orderItem,orderItemRefundDto);
                        break;
                    case OrderItemConstants.TYPE_PROMOTION:
                        distributionRedundVo = nextStepIsPromotion(orderItem,orderItemRefundDto);
                        break;
                    case OrderItemConstants.CARD_BAG:
                        distributionRedundVo = nextStepIsPromotion(orderItem,orderItemRefundDto);
                        break;
                    default:
                        throw new TipsException("未知商品类型[008]！");
                }

                //数据填充
                orderItemRefundDto.setApproveRefundTotal(distributionRedundVo.getRefundTotal());
                orderItemRefundDto.setType(distributionRedundVo.getGoodsType());
                orderItemRefundDto.setGoodsName(distributionRedundVo.getGoodsName());

                //可退款金额计算
                totalAmount = totalAmount.add(distributionRedundVo.getRefundTotal()).setScale(2,RoundingMode.HALF_UP);
                //可退款积分计算
                totalIntegral = totalIntegral.add(distributionRedundVo.getRefundIntegral());

                //整合可退款方式金额
                for(DistributionRedundMethodVo refundPaymentMethodVo:distributionRedundVo.getDistributionRedundMethodVoList()){
                    orderPayMethodDto = orderPayMethodDtoMap.computeIfAbsent(refundPaymentMethodVo.getNumberNo(),
                            k->new OrderPayMethodDto(refundPaymentMethodVo.getNumberNo(),refundPaymentMethodVo.getName(),BigDecimal.ZERO,refundPaymentMethodVo.getIsMoneyPay(),refundPaymentMethodVo.getIsExecute()));
                    orderPayMethodDto.setPayTotal(orderPayMethodDto.getPayTotal().add(refundPaymentMethodVo.getRefundTotal()).setScale(2,RoundingMode.HALF_UP));
                }
            }

            for(Map.Entry<String, OrderPayMethodDto> entry : orderPayMethodDtoMap.entrySet()) {
                refundPayMethods.add(entry.getValue());
            }
        }

        //支付方式
        orderRefundDto.setPayMethodList(refundPayMethods);
        //可退总金额
        orderRefundDto.setTotalAmount(totalAmount);
        //可退总积分
        orderRefundDto.setTotalIntegral(totalIntegral);
        //优惠券
        List<OrderCouponRefunDto> couponList = nextStepIsCoupon(ordersTotal.getId());
        orderRefundDto.setPayCouponList(couponList);

        return orderRefundDto;
    }

    /**获取充值单的退款方式金额*/
    public List<OrderPayMethodDto> rechargeRefundWay(OrdersTotal ordersTotal){

        //获取总支付方式
        List<PayMethodVo> payMethodVoList = refundMapper.getConsumePayGroupByNumberNo(ordersTotal.getId());

        List<OrderPayMethodDto> consumeList = new ArrayList<>();
        OrderPayMethodDto orderPayMethodDto;
        //充值订单只能全退
        for (PayMethodVo payMethodVo:payMethodVoList) {
            //支付方式可退金额
            orderPayMethodDto=new OrderPayMethodDto();
            orderPayMethodDto.setPayMethodNo(payMethodVo.getNumberNo());
            orderPayMethodDto.setPayMethodName(payMethodVo.getName());
            orderPayMethodDto.setRefundNumberNo(payMethodVo.getNumberNo());
            orderPayMethodDto.setRefundNumberName(payMethodVo.getName());
            orderPayMethodDto.setPayTotal(payMethodVo.getSurplusTotal());
            orderPayMethodDto.setMoney(orderPayMethodDto.getPayTotal());
            consumeList.add(orderPayMethodDto);
        }
        return consumeList;
    }

    /**
     * 判断是否有使用优惠卷
     */
    public List<OrderCouponRefunDto> nextStepIsCoupon(String orderId) {
        SqlSentence sqlSentence = new SqlSentence();
        Map<String, Object> sqlMap = new HashMap<>();

        sqlMap.put("isDel", BaseEntity.NO);
        sqlMap.put("orderId", orderId);
        sqlMap.put("status", BaseEntity.NO);
        sqlSentence.sqlSentence("SELECT id,title FROM coupon_order_discount_log WHERE orderId=#{m.orderId} AND status = #{m.status} AND isDel=  #{m.isDel} ",sqlMap);
        List<CouponOrderDiscountLog> couponOrderDiscountLogs = couponOrderDiscountLogMapper.selectList(sqlSentence);
        //拼接返回参数
        List<OrderCouponRefunDto> consumeList=new ArrayList<>();
        OrderCouponRefunDto orderCouponRefunDto;
        for (CouponOrderDiscountLog couponOrderDiscountLog : couponOrderDiscountLogs) {
            orderCouponRefunDto=new OrderCouponRefunDto();
            orderCouponRefunDto.setOrderCouponId(couponOrderDiscountLog.getId());
            orderCouponRefunDto.setOrderCouponTitle(couponOrderDiscountLog.getTitle());
            consumeList.add(orderCouponRefunDto);
        }

        return consumeList;
    }

    /**
     * 一级子单计算可退款金额
     * @param orderItemRefundDto 封装的方法
     * @return 退款金额
     */
    public DistributionRedundVo itemOneRefund(OrderItem orderItem,OrderItemRefundDto orderItemRefundDto) {

        if(orderItemRefundDto.getRefundNum() == null) {
            throw new PlatTipsException(PlatformCode.ERROR_TIPS,"请填写退款数量！");
        }
        if(orderItemRefundDto.getRefundNum() < 1) {
            throw new PlatTipsException(PlatformCode.ERROR_TIPS,"退款数量不能小于1");
        }

        ////算数量，退款用
        //总数量
        Integer buyNum;
        //剩余数量
        Integer surplusNum;

        if(OrderItemConstants.TYPE_PROJECT.equals(orderItem.getType())){
            //////项目
            UserProjectItem userProjectItem = PartialRefundUtil.getUserProject(orderItem.getId(),commonService);
            if(userProjectItem == null){
                throw new TipsException("用户项目获取失败！");
            }
            buyNum = userProjectItem.getUsedTotal();
            surplusNum = userProjectItem.getNotUsedNum();
            if(orderItemRefundDto.getRefundNum() > surplusNum){
                throw new TipsException("退款数量与可退数量不符[01]！");
            }
            //替换成子单的剩余数量
            surplusNum = orderItem.getUsedTotal() - orderItem.getHasReNum();
        }else if(OrderItemConstants.TYPE_CARD.equals(orderItem.getType())){
            ///////卡项
            //获取可退款的卡项次数
            List<UserCard> userCardList = PartialRefundUtil.getRefundCard(orderItem.getId(),UserProjectConstants.EFF_STATUS_YES,commonService);
            buyNum = orderItem.getBuyNum();
            surplusNum = userCardList.size();
            if(orderItemRefundDto.getRefundNum() > surplusNum){
                throw new TipsException("退款数量与可退数量不符[02]！");
            }
            //替换成子单的剩余数量，2023-06-15因为做用户卡包退款原因，先屏掉这个
            //surplusNum = orderItem.getBuyNum() - orderItem.getHasReNum();
        }else{
            buyNum = orderItem.getBuyNum();
            //替换成子单的剩余数量
            surplusNum = orderItem.getBuyNum() - orderItem.getHasReNum();
        }
        if(orderItemRefundDto.getRefundNum() > surplusNum){
            throw new TipsException("退款数量与可退数量不符[03]！");
        }

        //获取该子单的支付方式，相同的支付方式求和返回
        List<PayMethodVo> payMethodVoList = refundMapper.getConsumePayOneGroupByNumberNo(orderItem.getId());

        //获取该子单已退的总金额
        RefundRecordItem refundRecordItem = RefundTool.getOneAlreadyRefundTotal(orderItem.getId(),orderItem.getType(),commonService);

        //计算退款方式金额
        DistributionRedundVo distributionRedundVo = PaymentCountTool.countMakeWay(orderItem.getId(),orderItem.getActualTotal(),refundRecordItem.getOccupyRefundTotal()
                ,refundRecordItem.getOccupyRefundIntegral(),buyNum,surplusNum,null,orderItemRefundDto.getRefundNum(),payMethodVoList,commonService);

        distributionRedundVo.setGoodsType(orderItem.getType());
        distributionRedundVo.setGoodsName(orderItem.getGoodsName());

        return distributionRedundVo;
    }


    /**
     * 二级子单计算可退款金额
     * @param orderItemSourceRefundDto 封装的方法
     * @param goodsType 子单的商品类型
     * @return 退款金额
     */
    public DistributionRedundVo itemTwoRefund(OrderItemSon orderItemSon,OrderItemSourceRefundDto orderItemSourceRefundDto,String goodsType) {

        if(orderItemSourceRefundDto.getRefundNum() == null) {
            throw new PlatTipsException(PlatformCode.ERROR_TIPS,"请填写退款数量！");
        }
        if(orderItemSourceRefundDto.getRefundNum() < 1) {
            throw new PlatTipsException(PlatformCode.ERROR_TIPS,"退款数量不能小于1");
        }

        ////算数量
        //总数量
        Integer buyNum;
        //剩余数量
        Integer surplusNum;

        UserProjectItem userProjectItem;
        if(OrderItemConstants.TYPE_PROJECT.equals(goodsType)){
            //获取用户项目
            userProjectItem = PartialRefundUtil.getUserProject(orderItemSon.getId(),commonService);
            if(userProjectItem == null){
                throw new TipsException("用户项目获取失败！");
            }
            buyNum = userProjectItem.getUsedTotal();
            surplusNum = userProjectItem.getNotUsedNum();
            if(orderItemSourceRefundDto.getRefundNum() > surplusNum){
                throw new TipsException("退款数量与可退数量不符[04]！");
            }
            //替换成子单
            surplusNum = orderItemSon.getUsedTotal() - orderItemSon.getHasReNum();
        }else{
            buyNum = orderItemSon.getBuyNum();
            surplusNum = orderItemSon.getBuyNum() - orderItemSon.getHasReNum();
        }

        if(orderItemSourceRefundDto.getRefundNum() > surplusNum){
            throw new TipsException("退款数量与可退数量不符[05]！");
        }

        //获取该子单的支付方式，相同的支付方式算和返回
        List<PayMethodVo> payMethodVoList = refundMapper.getConsumePayTwoGroupByNumberNo(orderItemSon.getId());

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

        //计算退款方式金额
        DistributionRedundVo distributionRedundVo = PaymentCountTool.countMakeWay(orderItemSon.getId(),orderItemSon.getActualTotal(),refundRecordItemSource.getOccupyRefundTotal()
                ,refundRecordItemSource.getOccupyRefundIntegral(),buyNum,surplusNum,null,orderItemSourceRefundDto.getRefundNum(),payMethodVoList,commonService);

        distributionRedundVo.setGoodsType(orderItemSon.getType());
        distributionRedundVo.setGoodsName(orderItemSon.getGoodsName());
        return distributionRedundVo;
    }

    /**
     * 一级是促销
     */
    public DistributionRedundVo nextStepIsPromotion(OrderItem orderItem,OrderItemRefundDto orderItemRefundDto) {

        List<OrderItemSourceRefundDto> orderItemSourceRefundDtos = orderItemRefundDto.getOrderItemSourceRefundDtos();
        if (orderItemSourceRefundDtos == null) {
            throw new PlatTipsException(PlatformCode.ERROR_TIPS,"退款数量不能小于1");
        }

        //2022-12-29 荣爷说因为优惠卷超过了金额，数据库是负数，所以退款取0
        if(orderItem.getActualTotal().compareTo(BigDecimal.ZERO)<1){
            orderItem.setActualTotal(BigDecimal.ZERO);
        }

        //返回结构
        DistributionRedundVo distributionRedundVo = new DistributionRedundVo();

        //整合当前一级子单的退款金额数据，key值：支付方式编号
        Map<String,DistributionRedundMethodVo> refundPaymentMethodVoMap = new HashMap<>();
        DistributionRedundMethodVo refundPaymentMethodVo;

        DistributionRedundVo distributionRedundVoSon;
        for (OrderItemSourceRefundDto orderItemSourceRefundDto : orderItemSourceRefundDtos) {
            if(StringUtils.isEmpty(orderItemSourceRefundDto.getOrderItemSonId())){
                throw new PlatTipsException(PlatformCode.ERROR_TIPS,"退款项标识必填[54]");
            }

            OrderItemSon orderItemSon = orderItemSonMapper.selectOneByKey(orderItemSourceRefundDto.getOrderItemSonId());
            if (orderItemSon == null) {
                throw new PlatTipsException(PlatformCode.ERROR_TIPS,"退款项标识错误[54]");
            }

            if (!orderItemSon.getOrderItemId().equals(orderItem.getId())) {
                throw new PlatTipsException(PlatformCode.ERROR_TIPS,"未找到退款项[54]");
            }

            switch (orderItemSon.getType()) {
                case OrderGoodsConstants.TYPE_PROJECT:
                    distributionRedundVoSon = itemTwoRefund(orderItemSon,orderItemSourceRefundDto,orderItemSourceRefundDto.getType());
                    break;
                case OrderItemConstants.TYPE_RETAIL:
                    distributionRedundVoSon = itemTwoRefund(orderItemSon,orderItemSourceRefundDto,orderItemSourceRefundDto.getType());
                    break;
                case OrderItemConstants.TYPE_DRUG:
                    distributionRedundVoSon = itemTwoRefund(orderItemSon,orderItemSourceRefundDto,orderItemSourceRefundDto.getType());
                    break;
                default:
                    throw new TipsException("未知商品类型[098]！");
            }

            //数据填充
            orderItemSourceRefundDto.setType(distributionRedundVoSon.getGoodsType());
            orderItemSourceRefundDto.setGoodsName(distributionRedundVoSon.getGoodsName());
            orderItemSourceRefundDto.setApproveRefundTotal(distributionRedundVoSon.getRefundTotal());

            //返回结构金额填充
            distributionRedundVo.setRefundTotal(distributionRedundVo.getRefundTotal().add(distributionRedundVoSon.getRefundTotal()).setScale(2,RoundingMode.HALF_UP));
            distributionRedundVo.setRefundCash(distributionRedundVo.getRefundCash().add(distributionRedundVoSon.getRefundCash()).setScale(2,RoundingMode.HALF_UP));
            distributionRedundVo.setRefundExecute(distributionRedundVo.getRefundExecute().add(distributionRedundVoSon.getRefundExecute()).setScale(2,RoundingMode.HALF_UP));

            //整合退款金额
            for(DistributionRedundMethodVo paymentMethodVo:distributionRedundVoSon.getDistributionRedundMethodVoList()){
                //整合金额，上级用到
                refundPaymentMethodVo = refundPaymentMethodVoMap.computeIfAbsent(paymentMethodVo.getNumberNo()
                        ,k-> new DistributionRedundMethodVo(paymentMethodVo.getNumberNo(),paymentMethodVo.getName(),BigDecimal.ZERO,paymentMethodVo.getIsMoneyPay(),paymentMethodVo.getIsExecute()));
                refundPaymentMethodVo.setRefundTotal(refundPaymentMethodVo.getRefundTotal().add(paymentMethodVo.getRefundTotal()).setScale(2,RoundingMode.HALF_UP));
            }

        }

        //返回结构数据填充
        distributionRedundVo.setGoodsName(orderItem.getGoodsName());
        distributionRedundVo.setGoodsType(orderItem.getType());

        //整合退款金额的数据
        List<DistributionRedundMethodVo> distributionPayList = new ArrayList<>();
        for(Map.Entry<String,DistributionRedundMethodVo> entry : refundPaymentMethodVoMap.entrySet()){
            distributionPayList.add(entry.getValue());
        }
        distributionRedundVo.setDistributionRedundMethodVoList(distributionPayList);

        return distributionRedundVo;
    }

    /**
     * 确认退款处理退款逻辑
     * @param orderRefundDto
     * @return
     */
    @Override
    public PlatformResult partRefund(OrdersTotal ordersTotal, OrderRefundDto orderRefundDto, ThirtApplication thirtApplication) {
        logger.info("退款打印参数：{}", JSON.toJSONString(orderRefundDto));

        if(OrderTotalConstants.PAY_STATUS_SUC != ordersTotal.getPayStatus()){
            throw new PlatTipsException(PlatformCode.ERROR_TIPS,"订单未支付!");
        }
        if(OrderTotalConstants.STATUS_PAY != ordersTotal.getStatus()
                && OrderTotalConstants.STATUS_WAIT_RECEIVE != ordersTotal.getStatus()
                && OrderTotalConstants.STATUS_DONE != ordersTotal.getStatus()){
            throw new PlatTipsException(PlatformCode.ERROR_TIPS,"订单不是已支付状态!");
        }

        if(OrderTotalConstants.STATUS_REFUND_NONE != ordersTotal.getRefundStatus() &&
                OrderTotalConstants.STATUS_REFUND_PART != ordersTotal.getRefundStatus()){
            throw new PlatTipsException(PlatformCode.ERROR_TIPS,"订单退款状态不正确!");
        }

        //先优先改成申请退款中
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> map=new HashMap<>();

        map.put("refundStatus",OrderTotalConstants.STATUS_REFUND_APPLY);
        map.put("isSyncOrder", BaseEntity.NO);
        map.put("id",ordersTotal.getId());
        sqlSentence.sqlSentence(" refundStatus=#{m.refundStatus},isSyncOrder=#{m.isSyncOrder}  WHERE id=#{m.id}   AND refundStatus IN('"+OrderTotalConstants.STATUS_REFUND_NONE+"','"+OrderTotalConstants.STATUS_REFUND_PART+"')  ",map);
        if(ordersTotalMapper.updateWhere(sqlSentence) != 1){
            throw new TipsException("操作失败，当前订单退款状态不能再次发起退款!");
        }

        //校验参数和获取系统参数，非常重要
        orderRefundDto = parameterVerification(ordersTotal,orderRefundDto);

        return handlePartRefund(ordersTotal,orderRefundDto,thirtApplication);
    }

    /**
     * 校验参数，拼接参数
     */
    public OrderRefundDto  parameterVerification(OrdersTotal ordersTotal,OrderRefundDto orderRefundDto){

        if(orderRefundDto.getRefundPayMethod() == null){
            throw new TipsException("退款方式结构不能空");
        }

        //怕被获取到项目信息收到被改了项目价格，重新去获取一下项目价格
        orderRefundDto =  nextStep(ordersTotal,orderRefundDto);

        //可退款支付格式，key值：支付编号
        Map<String,OrderPayMethodDto> orderPayMethodDtoMap = new HashMap<>();
        for (OrderPayMethodDto orderPayMethodDto : orderRefundDto.getPayMethodList()) {
            orderPayMethodDtoMap.put(orderPayMethodDto.getPayMethodNo(),orderPayMethodDto);
        }

        //填写退款的总金额
        BigDecimal refundTotal = BigDecimal.ZERO;

        //校验金额
        OrderPayMethodDto payMethodDto;
        //遍历系统获取到的可退款方式
        OrderPayMethodDto orderPayMethodDto;
        for (int i = orderRefundDto.getRefundPayMethod().size()-1; i>=0 ;i--) {
            orderPayMethodDto = orderRefundDto.getRefundPayMethod().get(i);
            //获取是传值过来的金额数据
            payMethodDto = orderPayMethodDtoMap.get(orderPayMethodDto.getPayMethodNo());
            if(payMethodDto == null){
                throw new TipsException("未找到["+orderPayMethodDto.getPayMethodName()+"]支付方式!");
            }
            //判断退款方式
            PaymentMethod refundMethod = paymentMethodService.selectNumberNoUncheckUp(orderPayMethodDto.getRefundNumberNo());
            if(refundMethod==null){
                throw new PlatTipsException(PlatformCode.ERROR_TIPS,"未找到该转换方式:"+orderPayMethodDto.getRefundNumberName()+"["+orderPayMethodDto.getRefundNumberNo()+"]");
            }
            if(orderPayMethodDto.getMoney() == null){
                throw new TipsException("["+orderPayMethodDto.getPayMethodName()+"]退款金额必填!");
            }
            if(orderPayMethodDto.getMoney().compareTo(BigDecimal.ZERO) < 0){
                throw new TipsException("["+orderPayMethodDto.getPayMethodName()+"]退款金额错误!");
            }
            if (orderPayMethodDto.getMoney().compareTo(payMethodDto.getPayTotal()) > 0){
                throw new TipsException("当前退款方式["+orderPayMethodDto.getPayMethodName()+"]金额超出可退金额!");
            }
            //退款金额是0元，去掉退款方式
            if(orderPayMethodDto.getMoney().compareTo(BigDecimal.ZERO) == 0){
                orderRefundDto.getRefundPayMethod().remove(i);
            }
            orderPayMethodDto.setPayMethodName(payMethodDto.getPayMethodName());
            orderPayMethodDto.setPayMethodNo(payMethodDto.getPayMethodNo());
            orderPayMethodDto.setPayTotal(payMethodDto.getPayTotal());

            refundTotal = refundTotal.add(orderPayMethodDto.getMoney()).setScale(2,RoundingMode.HALF_UP);

        }
        orderRefundDto.setRefundTotal(refundTotal);

        if(orderRefundDto.getRefundTotal().compareTo(orderRefundDto.getTotalAmount()) > 0){
            throw new TipsException("退款金额不能大于可退金额[004]！");
        }

        return orderRefundDto;
    }

    /**
     * 处理退款详情
     */
    public PlatformResult handlePartRefund(OrdersTotal ordersTotal,OrderRefundDto orderRefundDto,ThirtApplication thirtApplication){

        //订单节点日志
        OrdersNodeLog ordersNodeLog = new OrdersNodeLog();
        StringBuilder orderNodeBuilder = new StringBuilder();

        orderNodeBuilder.append("开始退款");
        orderNodeBuilder.append("-本次退款项目总金额："+orderRefundDto.getTotalAmount()+",客户选的退款方式总金额："+orderRefundDto.getRefundTotal());

        Map<String, String> operator = ApiOrderUtil.getOperator(commonService, orderRefundDto.getOperatorId());//获取操作人信息
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> map=new HashMap<>();
        sqlSentence.setM(map);
        //退款总记录
        orderNodeBuilder.append("-处理退款总记录");

        //保存退款信息，不是真正的退款，提前扣减用户资金
        RefundRecord refundRecord = insertRefundInfo(orderRefundDto,ordersTotal,orderNodeBuilder,thirtApplication);

        //判断已支付订单是否需要营销助手审批
        //记录取消日志
        CancelOrder cancelOrder = handleCancelOrder(ordersTotal,orderRefundDto);

        if (orderRefundDto.getIsApproval().equals(BaseEntity.YES)){
            //调用审批功能
            return handleApproval(ordersNodeLog,orderNodeBuilder,ordersTotal,cancelOrder,refundRecord);
        }

        //这里开始真正的退款到用户账户的
        Map<String, Object> refund = handleRefundOrder(operator,refundRecord,ordersTotal,ordersNodeLog,orderNodeBuilder,cancelOrder);
        return PlatformResult.success(refund);
    }

    /**保存退款信息
     * 保存退款信息，并没有真正退款
     */
    public RefundRecord insertRefundInfo(OrderRefundDto orderRefundDto,OrdersTotal ordersTotal
            ,StringBuilder orderNodeBuilder, ThirtApplication thirtApplication){

        //操作人
        Employee employee = commonService.selectOneByKey(EmployeeMapper.class,orderRefundDto.getOperatorId());
        if(employee == null){
            throw new TipsException("操作人标识错误！");
        }

        ///////退款总表数据填充
        //生成退款编号
        String totalCode = createNoService.createNo("R",System.currentTimeMillis()+"",8);
        RefundRecord refundRecord=new RefundRecord(totalCode,ordersTotal.getShopId(),ordersTotal.getShopName(),orderRefundDto.getRefundTotal()
                , RefundStatus.STATUS_APPLY_REFUND,0, RefundSoruceConstants.TYPE_SOURCE_ORDER,orderRefundDto.getRemarks(),ordersTotal.getId(),ordersTotal.getUserId());
        //操作人信息
        refundRecord.setOperatorType(RefundRecord.OPERATOR_TYPE_EMPLOYEE);
        refundRecord.setOperatorId(employee.getId());
        refundRecord.setOperatorNo(employee.getEmployeeNo());
        refundRecord.setOperatorName(employee.getCnName());

        refundRecord.setRefundOperationType(orderRefundDto.getRefundOperationType());
        /////退款的备注
        refundRecord.setRemarks(orderRefundDto.getRemarks());
        refundRecord.setRefundReason(orderRefundDto.getRefundReason());
        refundRecord.setOperatorAppId(thirtApplication.getAppId());
        refundRecord.setOperatorAppCode(thirtApplication.getAppIdCode());
        refundRecord.setOperatorAppName(thirtApplication.getName());
        refundRecordService.insert(refundRecord);

        //退款方式处理
        if(orderRefundDto.getRefundPayMethod() !=null && orderRefundDto.getRefundPayMethod().size() > 0){
            handleRefundPayMethod(orderRefundDto,orderNodeBuilder,ordersTotal,refundRecord);
        }

        //退款的子项处理
        if(orderRefundDto.getRefundList()!=null && orderRefundDto.getRefundList().size()>0){
            insertRefundRecordItem(orderRefundDto,orderNodeBuilder,refundRecord);
        }
        //回退的优惠卷处理
        if(orderRefundDto.getCouponList() != null && orderRefundDto.getCouponList().size()>0){
            handleOrderCouponRefunDto(orderRefundDto.getCouponList(),orderNodeBuilder,ordersTotal,refundRecord);
        }

        //*******扣减赠送的账户资金，如果订单有老带新的赠送规则，那么如果申请退款，就优先把老带新的退回来*****
        //获取老带新记录
        oldBlingNewRefund(refundRecord,orderNodeBuilder,commonService);

        //判断是否是充值订单，是的话先冻结储值金，就是扣掉，审批通过就不处理储值金了，不通过还原资金
        if(OrderTotalConstants.TYPE_RECHARGE.equals(ordersTotal.getType())){
            OrderRefundCancelTool.rechargeHandle(ordersTotal,refundRecord,OrderRefundCancelTool.OPT_TYPE_EXECUTE,"申请退款",orderNodeBuilder,commonService);
        }
        //活动处理
        OrderRefundCancelTool.activityRuleHandle(ordersTotal,refundRecord,OrderRefundCancelTool.OPT_TYPE_EXECUTE,"申请退款",orderNodeBuilder,commonService);

        return refundRecord;
    }

    /**老带新的订单退款，佣金处理*/
    public void oldBlingNewRefund(RefundRecord refundRecord,StringBuilder orderNodeBuilder,CommonService commonService){

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

        //查找老带新记录，未删除且有效的，没有退回的
        values.put("operationReason",OperationReasonConstants.OP_REASON_BRING_NEW_USER_GIFT);
        values.put("orderId",refundRecord.getOrderId());
        sqlSentence.sqlSentence("SELECT * FROM user_money_unclaimed mu WHERE mu.isDel = 0 AND mu.isValid = 1 AND mu.operationReason = #{m.operationReason}" +
                " AND mu.orderId = #{m.orderId} AND NOT EXISTS(SELECT * FROM refund_user_assets rua WHERE rua.isDel = 0 AND rua.status = 1" +
                " AND rua.amountStatus IN (1,3) AND rua.userMoneyUnclaimedId = mu.id)",values);
        List<UserMoneyUnclaimed> userMoneyUnclaimedList = commonService.selectList(UserMoneyUnclaimedMapper.class,sqlSentence);
        RefundUserAssets refundUserAssets;
        UserMoney userMoney;
        User user;
        BigDecimal amount;
        for (UserMoneyUnclaimed userMoneyUnclaimed:userMoneyUnclaimedList){
            amount = BigDecimal.ZERO;
            //生成记录
            refundUserAssets = new RefundUserAssets();
            refundUserAssets.setType(userMoneyUnclaimed.getOperationReason());
            refundUserAssets.setStatus(RefundUserAssets.STATUS_NORMAL);
            refundUserAssets.setAmountType(userMoneyUnclaimed.getFundType());
            refundUserAssets.setAmount(userMoneyUnclaimed.getOpNumber().negate());
            refundUserAssets.setOperatorId(refundRecord.getOperatorId());
            refundUserAssets.setOperatorNo(refundRecord.getOperatorNo());
            refundUserAssets.setOperatorName(refundRecord.getOperatorName());
            refundUserAssets.setOrderId(refundRecord.getOrderId());
            refundUserAssets.setRefundRecordId(refundRecord.getId());
            refundUserAssets.setUserMoneyUnclaimedId(userMoneyUnclaimed.getId());
            refundUserAssets.setUserId(userMoneyUnclaimed.getUserId());

            user = commonService.selectOneByKey(UserMapper.class,refundUserAssets.getUserId());
            orderNodeBuilder.append("-退款处理老带新，扣减用户：").append(user.getName()).append("，CIQ：").append(user.getCIQ()).append(",");
            orderNodeBuilder.append(RefundUserAssets.amountTypeName(refundUserAssets.getAmountType())).append(refundUserAssets.getAmount());
            if(userMoneyUnclaimed.getStatus() == UserMoneyUnclaimed.STATUS_WAI){
                refundUserAssets.setAmountStatus(RefundUserAssets.AMOUNT_STATUS_NOT_RECEIVE);
                //用户未领取，那么直接作废，作废是逻辑删除
                values.put("id",userMoneyUnclaimed.getId());
                values.put("status",UserMoneyUnclaimed.STATUS_WAI);
                sqlSentence.sqlUpdate("isDel = 1,isValid = 0 WHERE id = #{m.id} AND isDel = 0 AND isValid = 1 AND status = #{m.status}",values);
                if(commonService.updateWhere(UserMoneyUnclaimedMapper.class,sqlSentence) != 1){
                    throw new TipsException("老带新资产记录状态已变化！");
                }

                orderNodeBuilder.append("，用户未领取，作废领取记录");
            }else if(userMoneyUnclaimed.getStatus() == UserMoneyUnclaimed.STATUS_SUCCEED){
                //用户已经领取了，那么要扣掉，但是，要先判断用户是否够，如果不够，那么也生成记录，显示未操作资金
                values.clear();
                values.put("userId",userMoneyUnclaimed.getUserId());
                sqlSentence.sqlSentence("SELECT * FROM user_money WHERE isDel = 0 AND userId = #{m.userId}",values);
                userMoney = commonService.selectOne(UserMoneyMapper.class,sqlSentence);
                if(userMoneyUnclaimed.getFundType() == UserMoneyUnclaimed.FUND_TYPE_STORED_VALUE_FUND){
                    //储值金
                    if(userMoney.getStoredValueFund() != null){
                        amount = new BigDecimal(userMoney.getStoredValueFund());
                    }
                }else if(userMoneyUnclaimed.getFundType() == UserMoneyUnclaimed.FUND_TYPE_VALUE_ADDED_FUND){
                    //增值金
                    if(userMoney.getValueAddedFund() != null){
                        amount = new BigDecimal(userMoney.getValueAddedFund());
                    }
                }else if(userMoneyUnclaimed.getFundType() == UserMoneyUnclaimed.FUND_TYPE_INTEGRAL){
                    //预定金
                    if(userMoney.getDeposit() != null){
                        amount = new BigDecimal(userMoney.getDeposit());
                    }
                }else if(userMoneyUnclaimed.getFundType() == UserMoneyUnclaimed.FUND_TYPE_DEPOSIT){
                    //积分
                    if(userMoney.getIntegral() != null){
                        amount = new BigDecimal(userMoney.getIntegral());
                    }
                }else{
                    throw new TipsException("老带新资产记录金额类型未知！");
                }
                if(amount.compareTo(refundUserAssets.getAmount()) >= 0){
                    //用户资产够减
                    orderNodeBuilder.append("，扣减成功");
                    refundUserAssets.setAmountStatus(RefundUserAssets.AMOUNT_STATUS_NORMAL);
                }else {
                    orderNodeBuilder.append("，余额不足，扣减失败");
                    //用户资产不够减
                    refundUserAssets.setAmountStatus(RefundUserAssets.AMOUNT_STATUS_NOT);
                }
            }else{
                throw new TipsException("老带新资产记录状态错误！");
            }

            if(refundUserAssets.getAmountStatus() == RefundUserAssets.AMOUNT_STATUS_NORMAL
                    || refundUserAssets.getAmountStatus() == RefundUserAssets.AMOUNT_STATUS_NOT_RECEIVE ){
                //保存记录，正常扣减和未领取才去保存这个记录
                commonService.insert(RefundUserAssetsMapper.class,refundUserAssets);
            }

            //用户资金操作
            if(refundUserAssets.getAmountStatus() == RefundUserAssets.AMOUNT_STATUS_NORMAL){
                UserMoneyUtil.setNewUserMoneyUnclaimed(refundUserAssets.getUserId(),refundRecord.getRemarks(),"退款:老带新资金回退",refundUserAssets.getOperatorId()
                        ,refundRecord.getOrderId(),refundRecord.getOperatorAppCode(),refundUserAssets.getId(),refundUserAssets.getAmount(),refundUserAssets.getAmountType()
                        ,OperationReasonConstants.OP_REASON_BRING_NEW_USER_GIFT_RETRUN,commonService,UserMoneyUnclaimed.YES);
            }

        }

    }

    /**老带新的订单退款不通过或者作废，佣金处理*/
    public void oldBlingNewRefundFail(RefundRecord refundRecord,StringBuilder orderNodeBuilder,CommonService commonService) {

        ////订单退款状态是没有退款才退回
        //获取回退记录
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> values = new HashMap<>();
        values.put("orderId",refundRecord.getOrderId());
        sqlSentence.sqlSentence("SELECT * FROM refund_user_assets rua WHERE rua.isDel = 0 AND rua.status = 1 AND rua.amountStatus IN(1,3) AND rua.orderId = #{m.orderId}",values);
        List<RefundUserAssets> refundUserAssetsList = commonService.selectList(RefundUserAssetsMapper.class,sqlSentence);

        User user;
        for(RefundUserAssets refundUserAssets:refundUserAssetsList){

            user = commonService.selectOneByKey(UserMapper.class,refundUserAssets.getUserId());
            orderNodeBuilder.append("-退款处理老带新，回退资金到用户：").append(user.getName()).append("，CIQ：").append(user.getCIQ()).append(",");
            orderNodeBuilder.append(RefundUserAssets.amountTypeName(refundUserAssets.getAmountType())).append(refundUserAssets.getAmount());

            //是否有扣减用户资产
            if(refundUserAssets.getAmountStatus() == RefundUserAssets.AMOUNT_STATUS_NORMAL){
                orderNodeBuilder.append("，增加成功");
                UserMoneyUtil.setNewUserMoneyUnclaimed(refundUserAssets.getUserId(),refundRecord.getRemarks(),"退款作废:老带新资金回退作废",refundUserAssets.getOperatorId()
                        ,refundRecord.getOrderId(),refundRecord.getOperatorAppCode(),refundUserAssets.getId(),refundUserAssets.getAmount().negate(),refundUserAssets.getAmountType()
                        ,OperationReasonConstants.OP_REASON_BRING_NEW_USER_GIFT_RETRU_CANCEL,commonService,UserMoneyUnclaimed.YES);
            }else if(refundUserAssets.getAmountStatus() == RefundUserAssets.AMOUNT_STATUS_NOT_RECEIVE){
                //用户未领取记录，还原
                orderNodeBuilder.append("，用户未领取，作废的领取记录还原");
                values.clear();
                values.put("id",refundUserAssets.getUserMoneyUnclaimedId());
                values.put("status",UserMoneyUnclaimed.STATUS_WAI);
                sqlSentence.sqlUpdate("isDel = 0,isValid = 1 WHERE id = #{m.id} AND isDel = 1 AND isValid = 0 AND status = #{m.status}",values);
                if(commonService.updateWhere(UserMoneyUnclaimedMapper.class,sqlSentence) != 1){
                    throw new TipsException("老带新资产记录状态已变化[作废]！");
                }
            }

            //记录作废
            values.clear();
            values.put("id",refundUserAssets.getId());
            values.put("status",RefundUserAssets.STATUS_CANCEL);
            values.put("oldStatus",RefundUserAssets.STATUS_NORMAL);
            sqlSentence.sqlSentence("status = #{m.status} WHERE id = #{m.id} AND status = #{m.oldStatus}",values);
            if(commonService.updateWhere(RefundUserAssetsMapper.class,sqlSentence) != 1){
                throw new TipsException("老带新资产退款记录状态已变化[作废]！");
            }
        }

    }

        /**
         * 退款-处理活动规则增值金和积分
         * @param commonService 映射对象
         * @param operationId 操作人标识
         * @param operationNme 操作人名称
         * @param sqlSentence 映射对象
         * @param map 映射对象
         * @param refundRecord 退款记录
         * @param ordersTotal 订单
         * @param optType 操作："0"减 1加
         */
    private static void handActivityRule(CommonService commonService, String operationId, String operationNme, SqlSentence sqlSentence,
                                         Map<String, Object> map, RefundRecord refundRecord, OrdersTotal ordersTotal, OrderInfo orderInfo,int optType) {
        if(orderInfo!=null && StringUtils.noNull(orderInfo.getActivityId())){
            ActivityRule activityRule=commonService.selectOneByKeyBlob(ActivityRuleMapper.class,orderInfo.getActivityId());
            if(activityRule!=null){
                map.put("activityRuleId",activityRule.getId());
                map.put("type", ActivityAction.TYPE_INTEGRAL);
                map.put("type1",ActivityAction.TYPE_VALUEADDEDFUND);
                map.put("type2",ActivityAction.TYPE_COUPON);
                sqlSentence.sqlSentence("select * from activity_action where activityRuleId=#{m.activityRuleId} and (type=#{m.type} or type=#{m.type1} or type=#{m.type2}) and isDel=0",map);
                List<ActivityAction> activityActions = commonService.selectList(ActivityActionMapper.class, sqlSentence);
                if(activityActions!=null && activityActions.size()>0){
                    for (ActivityAction activityAction : activityActions) {
                        if(ActivityAction.TYPE_INTEGRAL.equals(activityAction.getType())){
                            //判断金额不等于0，才执行操作，不然操作余额的时候会爆操作数量或金额不能为0
                            if(new BigDecimal(activityAction.getWorth()).negate().compareTo(BigDecimal.ZERO)!=0){
                                UserMoneyUtil.setNewUserMoneyUnclaimed(refundRecord.getUserId(),refundRecord.getRemarks(),optType==0?"充值单："+ordersTotal.getOrderNo()+" 申请退款，预扣除活动规则赠送储值金金额："+activityAction.getWorth():"充值单："+ordersTotal.getOrderNo()+" 申请退款，拒绝审批，返还赠送储值金预扣除金额："+activityAction.getWorth(),operationId,refundRecord.getOrderId(),ordersTotal.getAppIdCode(),refundRecord.getId(),optType==0?new BigDecimal(activityAction.getWorth()).negate():new BigDecimal(activityAction.getWorth()), UserMoneyUnclaimed.FUND_TYPE_INTEGRAL,OperationReasonConstants.OP_REASON_RECHARGE_REFUND,commonService,UserMoneyUnclaimed.YES);
                            }
                        }else if(ActivityAction.TYPE_VALUEADDEDFUND.equals(activityAction.getType())){
                            //判断金额不等于0，才执行操作，不然操作余额的时候会爆操作数量或金额不能为0
                            if(new BigDecimal(activityAction.getWorth()).negate().compareTo(BigDecimal.ZERO)!=0){
                                UserMoneyUtil.setNewUserMoneyUnclaimed(refundRecord.getUserId(),refundRecord.getRemarks(),optType==0?"充值单："+ordersTotal.getOrderNo()+" 申请退款，预扣除活动规则赠送增值金金额："+activityAction.getWorth():"充值单："+ordersTotal.getOrderNo()+" 申请退款，拒绝审批，返还赠送增值金预扣除金额："+activityAction.getWorth(),operationId,refundRecord.getOrderId(),ordersTotal.getAppIdCode(),refundRecord.getId(),optType==0?new BigDecimal(activityAction.getWorth()).negate():new BigDecimal(activityAction.getWorth()), UserMoneyUnclaimed.FUND_TYPE_VALUE_ADDED_FUND,OperationReasonConstants.OP_REASON_RECHARGE_REFUND,commonService,UserMoneyUnclaimed.YES);
                            }
                        }else if(ActivityAction.TYPE_COUPON.equals(activityAction.getType())){
                            map.put("oldValidState",optType==0?BaseEntity.YES:BaseEntity.NO);
                            map.put("newValidState",optType==0?BaseEntity.NO:BaseEntity.YES);
                            map.put("couponId",activityAction.getCrmCouponId());
                            map.put("commonId",ordersTotal.getId());
                            sqlSentence.sqlSentence(" validState=#{m.newValidState} where couponId=#{m.couponId} and commonId=#{m.commonId} and validState=#{m.oldValidState} ",map);
                            commonService.updateWhere(CouponNumberMapper.class,sqlSentence);
                        }
                    }
                }
            }
        }
    }

    /**
     * 对接审批
     */
    public PlatformResult handleApproval(OrdersNodeLog ordersNodeLog,StringBuilder orderNodeBuilder,OrdersTotal ordersTotal,CancelOrder cancelOrder,RefundRecord refundRecord){
        orderNodeBuilder.append("-退款需要审批，开始对接营销中心");


        OrderPartRefundDto orderPartRefundDto=new OrderPartRefundDto();
        OrdersTotalDto ordersTotalDto=new OrdersTotalDto();
        BeanUtils.copyProperties(ordersTotal, ordersTotalDto);

        orderPartRefundDto.setOrdersTotalDto(ordersTotalDto);//填充主订单信息


        //填充操作人，用户的基本信息
        orderPartRefundDto.setOrdersTotalDto(ordersTotalDto);
        orderPartRefundDto.setOperatorId(cancelOrder.getOperatorId());
        orderPartRefundDto.setOpName(cancelOrder.getOperatorName());
        orderPartRefundDto.setShopId(cancelOrder.getShopId());
        orderPartRefundDto.setShopName(cancelOrder.getShopName());
        orderPartRefundDto.setRoleId(cancelOrder.getRoleId());
        orderPartRefundDto.setRoleUniqueStr(cancelOrder.getRoleStr());
        if(StringUtils.noNull(refundRecord.getRemarks())){
            orderPartRefundDto.setRemark(refundRecord.getRemarks());
        }else{
            orderPartRefundDto.setRemark(cancelOrder.getOperatorName()+"退款，订单号："+ordersTotal.getOrderNo());
        }

        orderPartRefundDto.setUserId(ordersTotal.getUserId());

        //本次退款金额
        orderPartRefundDto.setRefundTotal(refundRecord.getRefundTotal());

        /**本次退款支付方式*/
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> map=new HashMap<>();

        map.put("refundRecordId", refundRecord.getId());
        sqlSentence.sqlSentence("SELECT refundNumberNo AS payMethodNo,refundName AS payMethodName,actualTotal as refundMoney,refundRecordId as payMethodId FROM refund_record_method " +
                " WHERE refundRecordId=#{m.refundRecordId} ",map);
        List<Map<String, Object>> refundMethodList = commonService.selectListMap(RefundRecordMethodMapper.class,sqlSentence);
        if(refundMethodList!=null && refundMethodList.size()!=0){
            JSONArray refundMethodArray=new JSONArray();
            refundMethodArray.addAll(refundMethodList);
            List<PartRefundPayDto> partRefundPayDtoList=refundMethodArray.toJavaList(PartRefundPayDto.class);
            orderPartRefundDto.setPartRefundPayDtoList(partRefundPayDtoList);
        }
        /**本次退款项目*/
        //退款一级项目
        sqlSentence.sqlSentence("SELECT type AS projectType, commonId AS projectId, goodsNo AS projectNo, goodsName AS projectName, refundNum AS refundNum  " +
                " FROM refund_record_item WHERE refundRecordId=#{m.refundRecordId} AND refundNum>0",map);
        List<Map<String, Object>> refundRecordItemList = commonService.selectListMap(RefundRecordItemMapper.class,sqlSentence);
        JSONArray refundProjectDtoArray=new JSONArray();
        if(refundRecordItemList!=null && refundRecordItemList.size()!=0){
            refundProjectDtoArray.addAll(refundRecordItemList);
        }
        //退款二级项目
        sqlSentence.sqlSentence("SELECT type AS projectType, commonId AS projectId, goodsNo AS projectNo, goodsName AS projectName, refundNum AS refundNum " +
                " FROM refund_record_item_source   WHERE refundRecordId=#{m.refundRecordId} AND refundNum>0",map);
        List<Map<String, Object>> refundRecordItemSourceList = commonService.selectListMap(RefundRecordItemSourceMapper.class,sqlSentence);
        if(refundRecordItemSourceList!=null && refundRecordItemSourceList.size()!=0){
            refundProjectDtoArray.addAll(refundRecordItemSourceList);
        }
        if(refundProjectDtoArray.size()>0){
            List<RefundProjectDto> refundProjectDtoList=refundProjectDtoArray.toJavaList(RefundProjectDto.class);
            orderPartRefundDto.setRefundProjectDtoList(refundProjectDtoList);
        }


        logger.info("调用营销中心审批退款入参：{}",JSONObject.toJSONString(orderPartRefundDto));
        Result result= mOrderService.applyPartRefund(orderPartRefundDto);
//        Result result= JSONObject.parseObject("{\"code\":\"100\",\"msg\":\"SUCCESS\",\"data\":{\"applyId\":\"6204eb10753511ed90ed525400b8510a\"}}",Result.class);
        logger.info("调用营销中心审批退款返回：{}",JSONObject.toJSONString(result));
        if (result != null) {
            result.checkTips();
            JSONObject object = JSONObject.parseObject(JSONObject.toJSONString(result.getData()));
            if(!object.isEmpty()){
                String applyId = object.getString("applyId");
                cancelOrder.setApplyId(applyId);
                cancelOrder.setRefundRecordId(refundRecord.getId());
                commonService.updateAll(CancelOrderMapper.class,cancelOrder);

                ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_APPLY);
                commonService.updateAll(OrdersTotalMapper.class,ordersTotal);

//                logger.info("调用营销中心成功，订单开始审核");
                orderNodeBuilder.append("-调用营销中心成功，订单开始审核");
                ordersNodeLog.setCommonType(OrdersNodeLog.TYPE_COMMON_ORDER_REFUND);
                ordersNodeLog.setContent(orderNodeBuilder.toString());
                ordersNodeLog.setOrderId(ordersTotal.getId());
                commonService.insert(OrdersNodeLogMapper.class,ordersNodeLog);

                orderNodeBuilder.append("-调用营销中心成功，订单开始审核");

                return PlatformResult.success("订单正在审核中");
            }else{
                throw new PlatTipsException(PlatformCode.ERROR_TIPS,"请求营销助手审批接口报错,data返回为空!");
            }
        } else {
            throw new PlatTipsException(PlatformCode.ERROR_TIPS,"请求营销助手审批接口报错,返回为空!");
        }
    }

    /**
     * 记录退款订单记录日志
     */
    public CancelOrder handleCancelOrder(OrdersTotal ordersTotal,OrderRefundDto orderRefundDto){
        //记录取消日志
        CancelOrder cancelOrder=new CancelOrder();
        cancelOrder.setOrderId(ordersTotal.getId());
        if(StringUtils.noNull(orderRefundDto.getOperatorId())){
            Employee employee = commonService.selectOneByKey(EmployeeMapper.class,orderRefundDto.getOperatorId());
            if(employee==null){
                throw new TipsException("操作人标识错误！");
            }
            cancelOrder.setOperatorId(employee.getId());
            cancelOrder.setOperatorName(employee.getCnName());
        }

        if(StringUtils.noNull(orderRefundDto.getRoleId())){
            EmployeeRole employeeRole=commonService.selectOneByKey(EmployeeRoleMapper.class,orderRefundDto.getRoleId());
            if(employeeRole==null){
                throw new TipsException("操作角色标识错误！");
            }
            cancelOrder.setRoleId(employeeRole.getRoleTypeId());
            cancelOrder.setRoleStr(employeeRole.getRoleUniqueStr());
            Shop shop=commonService.selectOneByKey(ShopMapper.class,employeeRole.getShopId());
            if(shop==null){
                cancelOrder.setShopId(employeeRole.getShopId());
                cancelOrder.setShopName("找不到对应的门店");
            }else {
                cancelOrder.setShopId(shop.getId());
                cancelOrder.setShopName(shop.getName());
            }
        }

        cancelOrder.setIsApproval(orderRefundDto.getIsApproval());
        cancelOrder.setIsRefund(orderRefundDto.getIsRefund());
        cancelOrder.setPlatformSource(orderRefundDto.getPlatformSource());
        commonService.insert(CancelOrderMapper.class,cancelOrder);

        return cancelOrder;
    }

    /**
     * 处理退款方式记录表
     */
    public List<RefundRecordMethod> handleRefundPayMethod(OrderRefundDto orderRefundDto,StringBuilder orderNodeBuilder,OrdersTotal ordersTotal,RefundRecord refundRecord){
        orderNodeBuilder.append("-记录退款方式：");

        //获取订单可退款方式，就是支付方式总表的信息，已经支付编号求和
        List<PayMethodVo> payMethodVoList = refundMapper.getConsumePayGroupByNumberNo(ordersTotal.getId());

        //用map装载，后面根据支付编号直接获取便可
        Map<String, PayMethodVo> payMethodVoMap = payMethodVoList.stream().collect(Collectors.toMap(PayMethodVo::getNumberNo,(a) -> a));

        List<RefundRecordMethod> refundRecordMethodList = new ArrayList<>();

        PayMethodVo payMethodVo;
        RefundRecordMethod refundRecordMethod;
        for (OrderPayMethodDto orderPayMethodDto : orderRefundDto.getRefundPayMethod()) {

            payMethodVo = payMethodVoMap.get(orderPayMethodDto.getPayMethodNo());
            //判断是不是在支付方式里面的
            if (payMethodVo == null){
                throw new PlatTipsException(PlatformCode.ERROR_TIPS,"可退支付方式未找到:"+orderPayMethodDto.getPayMethodName()+"["+orderPayMethodDto.getPayMethodNo()+"]");
            }
            //判断支付方式
            PaymentMethod payMethod = paymentMethodService.selectNumberNoUncheckUp(orderPayMethodDto.getPayMethodNo());
            if(payMethod == null){
                throw new PlatTipsException(PlatformCode.ERROR_TIPS,"未找到对应的支付:"+orderPayMethodDto.getPayMethodName()+"["+orderPayMethodDto.getPayMethodNo()+"]");
            }
            //判断退款方式
            PaymentMethod refundMethod = paymentMethodService.selectNumberNoUncheckUp(orderPayMethodDto.getRefundNumberNo());
            if(refundMethod==null){
                throw new PlatTipsException(PlatformCode.ERROR_TIPS,"未找到退款方式:"+orderPayMethodDto.getRefundNumberName()+"["+orderPayMethodDto.getRefundNumberNo()+"]");
            }
            if(orderPayMethodDto.getMoney() == null){
                throw new PlatTipsException(PlatformCode.ERROR_TIPS,"请填写退款方式["+orderPayMethodDto.getPayMethodName()+"["+orderPayMethodDto.getPayMethodNo()+"]"+"]金额");
            }
            //判断金额
            if(payMethodVo.getSurplusTotal().compareTo(orderPayMethodDto.getMoney()) < 0){
                throw new PlatTipsException(PlatformCode.ERROR_TIPS,"退款金额错误:"+orderPayMethodDto.getPayMethodName()+"["+orderPayMethodDto.getPayMethodNo()+"]");
            }

            ////退款方式数据填充
            refundRecordMethod = new RefundRecordMethod();
            refundRecordMethod.setType(refundRecord.getSourceType());
            refundRecordMethod.setActualTotal(orderPayMethodDto.getMoney());
            //支付方式信息
            refundRecordMethod.setNumberNo(payMethod.getNumberNo());
            refundRecordMethod.setPaymentMethodId(payMethod.getId());
            refundRecordMethod.setName(payMethod.getName());
            refundRecordMethod.setIsMoneyPay(payMethodVo.getIsMoneyPay());
            refundRecordMethod.setIsExecute(payMethodVo.getIsExecute());
            //退款方式信息
            refundRecordMethod.setRefundNumberNo(refundMethod.getNumberNo());
            refundRecordMethod.setRefundName(refundMethod.getName());
            refundRecordMethod.setRefundMethodId(refundMethod.getId());

            refundRecordMethod.setIsMoneyPayRefund(refundMethod.getIsMoneyPay());
            refundRecordMethod.setIsExecuteRefund(refundMethod.getIsExecute());
            refundRecordMethod.setRefundRecordId(refundRecord.getId());
            refundRecordMethod.setOrderId(ordersTotal.getId());
            refundRecordMethod.setRemarks(orderPayMethodDto.getRemarks());

            refundRecordMethodService.insert(refundRecordMethod);
            refundRecordMethodList.add(refundRecordMethod);
        }
        return refundRecordMethodList;
    }

    /**
     * 退款记录子项
     */
    public void insertRefundRecordItem(OrderRefundDto orderRefundDto,StringBuilder orderNodeBuilder,RefundRecord refundRecord){

        orderNodeBuilder.append("-记录退款详情");

        //计算金额占比，客户选择退款总金额和可退总金额占比
        BigDecimal percentage;
        if(orderRefundDto.getTotalAmount().compareTo(BigDecimal.ZERO) < 1){
            percentage = BigDecimal.ZERO;
        }else {
            percentage = orderRefundDto.getRefundTotal().divide(orderRefundDto.getTotalAmount(),15,RoundingMode.HALF_UP);
        }

        //总退款金额，用于后面计算分摊金额
        BigDecimal refundTotal = refundRecord.getRefundTotal();

        //后面设计分配金额问题，要进行升序排序，避免到最后不够
        List<OrderItemRefundDto> refundList = orderRefundDto.getRefundList();
        refundList = refundList.stream().sorted(Comparator.comparing(OrderItemRefundDto::getApproveRefundTotal)).collect(Collectors.toList());

        /////引用参数
        RefundRecordItem refundRecordItem;
        OrderItemRefundDto orderItemRefundDto;
        OrderItem orderItem;
        for(int i = 0;i < refundList.size();i++){
            orderItemRefundDto = refundList.get(i);

            orderItem = orderItemMapper.selectOneByKey(orderItemRefundDto.getOrderItemId());
            if(orderItem == null){
                throw new PlatTipsException(PlatformCode.ERROR_TIPS,"子订单标识错误！");
            }

            //////数据填充
            refundRecordItem = new RefundRecordItem();
            refundRecordItem.setType(orderItem.getType());
            refundRecordItem.setGoodsNo(orderItem.getGoodsNo());
            refundRecordItem.setGoodsName(orderItem.getGoodsName());
            refundRecordItem.setSpecs(orderItem.getSpecs());
            refundRecordItem.setCommonId(orderItem.getCommonId());
            if(PartialRefundUtil.CONTAIN_SON_TYPE_SET.contains(orderItem.getType())){
                refundRecordItem.setRefundNum(0);
            }else{
                refundRecordItem.setRefundNum(orderItemRefundDto.getRefundNum());
            }
            refundRecordItem.setRefundRecordId(refundRecord.getId());
            refundRecordItem.setOrderItemId(orderItem.getId());
            refundRecordItem.setOccupyRefundTotal(orderItemRefundDto.getApproveRefundTotal());
            ////退款备注
            if(StringUtils.isEmpty(orderItemRefundDto.getRemarks())){
                orderItemRefundDto.setRemarks(refundRecord.getRemarks());
            }
            if(StringUtils.isEmpty(orderItemRefundDto.getRefundReason())){
                orderItemRefundDto.setRefundReason(orderItemRefundDto.getRefundReason());
            }
            refundRecordItem.setRemarks(orderItemRefundDto.getRemarks());
            refundRecordItem.setRefundReason(orderItemRefundDto.getRefundReason());

            //////////分配退款金额
            if(i == refundList.size()-1){
                refundRecordItem.setRefundMoney(refundTotal);
            }else{
                refundRecordItem.setRefundMoney(orderItemRefundDto.getApproveRefundTotal().multiply(percentage).setScale(2,RoundingMode.UP));
            }
            if(refundRecordItem.getRefundMoney().compareTo(orderItemRefundDto.getApproveRefundTotal()) > 0){
                refundRecordItem.setRefundMoney(orderItemRefundDto.getApproveRefundTotal());
            }
            //判断与未分配剩余金额
            if(refundRecordItem.getRefundMoney().compareTo(refundTotal) > 0){
                refundRecordItem.setRefundMoney(refundTotal);
            }

            refundRecordItem.setRealRefundNum(refundRecordItem.getRefundNum());
            refundRecordItem.setRealRefundTotal(refundRecordItem.getRefundMoney());

            refundRecordItemService.insert(refundRecordItem);
            //减去已经分配的退款金额
            refundTotal = refundTotal.subtract(refundRecordItem.getRefundMoney()).setScale(2,RoundingMode.HALF_UP);
            if(PartialRefundUtil.CONTAIN_SON_TYPE_SET.contains(orderItem.getType())){
                //子单子项处理
                insertRefundRecordItemTwo(refundRecordItem,refundRecord,orderItemRefundDto.getOrderItemSourceRefundDtos());
            }
        }

        if(refundTotal.compareTo(BigDecimal.ZERO) > 0){
            throw new TipsException("退款金额分配错误[01]！");
        }

    }

    /**二级子单处理*/
    public void insertRefundRecordItemTwo(RefundRecordItem recordItem,RefundRecord refundRecord,List<OrderItemSourceRefundDto> orderItemSourceRefundDtos){
        if(orderItemSourceRefundDtos == null || orderItemSourceRefundDtos.size() == 0){
            return;
        }

        //计算占比
        BigDecimal percentage;
        if(recordItem.getOccupyRefundTotal().compareTo(BigDecimal.ZERO) > 0){
            percentage = recordItem.getRefundMoney().divide(recordItem.getOccupyRefundTotal(),15,RoundingMode.HALF_UP);
        }else{
            percentage = BigDecimal.ZERO;
        }

        //进行升序排序，避免后面不够
        orderItemSourceRefundDtos = orderItemSourceRefundDtos.stream().sorted(Comparator.comparing(OrderItemSourceRefundDto::getApproveRefundTotal)).collect(Collectors.toList());

        //退款总金额
        BigDecimal refundTotal = recordItem.getRefundMoney();

        OrderItemSon orderItemSon;
        OrderItemSourceRefundDto orderItemSourceRefundDto;
        RefundRecordItemSource refundRecordItemSource;

        for(int i = 0;i<orderItemSourceRefundDtos.size();i++){
            orderItemSourceRefundDto = orderItemSourceRefundDtos.get(i);

            orderItemSon = orderItemSonMapper.selectOneByKey(orderItemSourceRefundDto.getOrderItemSonId());
            if(orderItemSon == null){
                throw new PlatTipsException(PlatformCode.ERROR_TIPS,"子订单标识错误[024]！");
            }

            //////数据填充
            refundRecordItemSource = new RefundRecordItemSource();
            refundRecordItemSource.setType(orderItemSon.getType());
            refundRecordItemSource.setGoodsNo(orderItemSon.getGoodsNo());
            refundRecordItemSource.setGoodsName(orderItemSon.getGoodsName());
            refundRecordItemSource.setSpecs(orderItemSon.getSpecs());
            refundRecordItemSource.setCommonId(orderItemSon.getGoodsId());
            refundRecordItemSource.setRefundNum(orderItemSourceRefundDto.getRefundNum());
            refundRecordItemSource.setRefundRecordId(refundRecord.getId());
            refundRecordItemSource.setOrderItemSonId(orderItemSon.getId());
            refundRecordItemSource.setOccupyRefundTotal(orderItemSourceRefundDto.getApproveRefundTotal());
            refundRecordItemSource.setRefundRecordItemId(recordItem.getId());
            ////退款备注
            if(StringUtils.isEmpty(orderItemSourceRefundDto.getRemarks())){
                orderItemSourceRefundDto.setRemarks(refundRecord.getRemarks());
            }
            if(StringUtils.isEmpty(orderItemSourceRefundDto.getRefundReason())){
                orderItemSourceRefundDto.setRefundReason(refundRecord.getRefundReason());
            }
            refundRecordItemSource.setRemarks(orderItemSourceRefundDto.getRemarks());
            refundRecordItemSource.setRefundReason(orderItemSourceRefundDto.getRefundReason());

            //计算退款金额
            if(i == orderItemSourceRefundDtos.size()-1){
                refundRecordItemSource.setRefundMoney(refundTotal);
            }else{
                refundRecordItemSource.setRefundMoney(orderItemSourceRefundDto.getApproveRefundTotal().multiply(percentage).setScale(2,RoundingMode.UP));
            }
            if(refundRecordItemSource.getRefundMoney().compareTo(orderItemSourceRefundDto.getApproveRefundTotal()) > 0){
                refundRecordItemSource.setRefundMoney(orderItemSourceRefundDto.getApproveRefundTotal());
            }
            if(refundRecordItemSource.getRefundMoney().compareTo(refundTotal) > 0){
                refundRecordItemSource.setRefundMoney(refundTotal);
            }

            refundRecordItemSource.setRealRefundNum(refundRecordItemSource.getRefundNum());
            refundRecordItemSource.setRealRefundTotal(refundRecordItemSource.getRefundMoney());

            refundRecordItemSourceMapper.insert(refundRecordItemSource);
            //减去已经分配退款金额
            refundTotal = refundTotal.subtract(refundRecordItemSource.getRefundMoney()).setScale(2,RoundingMode.HALF_UP);
            System.out.println("refundRecordItemSource.getRefundMoney():"+refundRecordItemSource.getRefundMoney());
        }
        System.out.println("refundTotal:"+refundTotal);
        if(refundTotal.compareTo(BigDecimal.ZERO) > 0){
            throw new TipsException("退款金额分配错误[02]！");
        }

    }

    /**
     * 记录退款记录优惠卷
     */
    public void handleOrderCouponRefunDto(List<OrderCouponRefunDto> couponList,StringBuilder orderNodeBuilder,OrdersTotal ordersTotal,RefundRecord refundRecord){
        CouponOrderDiscountLog couponOrderDiscountLog;
        RefundRecordCoupon refundRecordCoupon;
        orderNodeBuilder.append("-处理退款优惠卷");
        for (OrderCouponRefunDto orderCouponRefunDto : couponList) {
            couponOrderDiscountLog=couponOrderDiscountLogMapper.selectOneByKey(orderCouponRefunDto.getOrderCouponId());
            if( couponOrderDiscountLog == null){
                throw new PlatTipsException(PlatformCode.ERROR_TIPS,"订单优惠卷标识不正确");
            }
            refundRecordCoupon=new  RefundRecordCoupon(ordersTotal.getId(),refundRecord.getId(),ordersTotal.getUserId(),1,1,couponOrderDiscountLog.getId(),
                    couponOrderDiscountLog.getCouponId(),couponOrderDiscountLog.getTitle(),couponOrderDiscountLog.getCouponNumberId());
            refundRecordCouponMapper.insert(refundRecordCoupon);
        }
    }



    /**真正退款，是对钱和状态的回退到账开始操作
     * 进行退款操作，退款用户项目，商品，促销，卡项，卡包
     */
    public Map<String,Object> handleRefundOrder(Map<String, String> operator,RefundRecord refundRecord,OrdersTotal ordersTotal
            ,OrdersNodeLog ordersNodeLog,StringBuilder orderNodeBuilder,CancelOrder cancelOrder ){

        String operationId=operator.get("operatorId");
        String operatorName=operator.get("operatorName");

        orderNodeBuilder.append("-处理退款支付方式，用户待执行项目");
        //处理主业务
        ordersTotal =  PartialRefundUtil.refundProcess(commonService, operationId, operatorName, refundRecord.getId());

        //返回数据
        Map<String,Object> data=new HashMap<>();
        data.put("refundRecordId",refundRecord.getId());
        data.put("refundRecordCode",refundRecord.getCode());

        //处理次业务，报错不影响主业务
        refundRecord = refundRecordService.selectOneByKey(refundRecord.getId());

        /**
         * 用户升降级(调用航爷) 金额=用户支付的实付现金金额(不包含储值金)
         */
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> map=new HashMap<>();
        sqlSentence.setM(map);
        //退款成功
        map.put("refundRecordId", refundRecord.getId());
        sqlSentence.sqlSentence("SELECT CAST(COALESCE(sum(rrm.realRefundTotal),0) as  DECIMAL(11,2))  as total FROM refund_record_method rrm LEFT JOIN payment_method pm ON pm.numberNo=rrm.refundNumberNo " +
                "WHERE rrm.refundRecordId=#{m.refundRecordId} and pm.isMoneyPay=1",map);
        Map<String,Object> totalMap =commonService.selectOneMap(RefundRecordMethodMapper.class,sqlSentence);
        BigDecimal total=new BigDecimal(String.valueOf(totalMap.get("total"))) ;
        if(BigDecimal.ZERO.compareTo(total) < 0){
            try {
                orderNodeBuilder.append("-开始处理用户升降级，金额:").append(total.negate());
                UserLevelUtil.refund(ordersTotal.getUserId(),ordersTotal.getId(),total.negate(),ordersTotal.getAppIdCode());
                orderNodeBuilder.append("-处理用户升降级成功");
            }catch (Exception e){
                String snapshot="处理用户升降级失败";
                orderNodeBuilder.append("-处理用户升降级失败,异常原因:").append(e.getMessage());
                logger.error("处理用户升降级失败：" + e.getMessage());
                //发送企业微信通知给工作人员
                SendNoticeUtil.failOrderSendNotice(ordersTotal,e.getMessage(),snapshot,commonService,customParameter);
            }
        }
        try{
            orderNodeBuilder.append("-开始记录收入确认表");
            PerformanceInfoTool.handRefundPerformanceInfo(commonService,refundRecord);
            orderNodeBuilder.append("-记录收入确认表成功");
        }catch (Exception e){
            orderNodeBuilder.append("-记录收入确认表失败");
            logger.info("记录收入确认表,异常:{}",e.getMessage(),e);
            // 添加错误日志
            PerformanceInfoTool.addErrorLog(commonService, refundRecord.getId(), PerformanceInfo.ASSOCIATION_TYPE_GOODS_REFUND, e.getMessage());
        }

        if(CancelOrderDto.HIS_ASSISTANT.equals(cancelOrder.getPlatformSource())){
            //如果是his自动处理退款单原路退回
            //CRM的操作也在这里
            hisAssistantNoteList(ordersTotal,refundRecord,operationId,orderNodeBuilder);
        }

        //记录操作日志
        orderNodeBuilder.append("-记录操作日志");
        StringBuffer stringBuffer=new StringBuffer("操作人:"+operator.get("operatorName")+",进行退款");
        OrderLog orderLog=new OrderLog(ordersTotal.getId(), OrderLogConstants.LOG_TYPE_REFUND,stringBuffer.toString()
                ,operator.get("operatorName"),operator.get("operatorId"),OrderTotalConstants.STATUS_CANCEL);
        commonService.insert(OrderLogMapper.class,orderLog);

        orderNodeBuilder.append("-结束处理退款");
        ordersNodeLog.setCommonType(OrdersNodeLog.TYPE_COMMON_ORDER_REFUND);
        ordersNodeLog.setContent(orderNodeBuilder.toString());
        ordersNodeLog.setOrderId(ordersTotal.getId());
        commonService.insert(OrdersNodeLogMapper.class,ordersNodeLog);

        return data;
    }
    /**
     * his助手原路退回退款单
     */
    public void hisAssistantNoteList(OrdersTotal ordersTotal,RefundRecord refundRecord,String operationId,StringBuilder orderNodeBuilder){
        OrderRefundNoteListDto orderRefundNoteListDto=new OrderRefundNoteListDto();
        orderRefundNoteListDto.setOperationId(operationId);
        orderRefundNoteListDto.setOrderId(ordersTotal.getId());

        //统一在crm取消订单
        // 没有现金支付， 如果是crm的订单则调用crm取消订单的方法
    /*    if("crm".equals(ordersTotal.getAppIdCode()) && OrderTotalConstants.STATUS_CANCEL == ordersTotal.getStatus()){
            //通知crm
            if(OrderTotalConstants.STATUS_REFUND_FINSH==ordersTotal.getRefundStatus()){
                //全部退款完成
                //通知crm订单取消成功了
                Map<String, String> operator = ApiOrderUtil.getOperator(commonService, orderRefundNoteListDto.getOperationId());//获取操作人信息
                String operatorId= operator.get("operatorId");
                String operatorName=  operator.get("operatorName");
                OrderStatusDto orderStatusDto=new OrderStatusDto();
                orderStatusDto.setId(ordersTotal.getId());
                orderStatusDto.setOpName(operatorName);
                orderStatusDto.setOpId(operatorId);
                orderStatusDto.setCancelInfo("phis取消退款");
                orderStatusDto.setOpDetail("phis取消退款");
                try {
                    logger.info("通知CRM订单号:{}退款成功请求参数：{}",ordersTotal.getOrderNo(),JSONObject.toJSONString(orderStatusDto));
                    Result result=  fOderService.cancelOrder(orderStatusDto);
                    logger.info("通知CRM订单号:{}退款成功返回参数：{}",ordersTotal.getOrderNo(),JSONObject.toJSONString(result));
                    orderNodeBuilder.append("通知crm退款状态返回成功");
                }catch (Exception e){
                    logger.info("通知crm订单号:{}退款成功错误:{}",ordersTotal.getOrderNo(),e.getMessage());
                    orderNodeBuilder.append("通知crm退款状态返回失败");
                }

            }
        }*/

        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> map=new HashMap<>();
        sqlSentence.setM(map);
        map.put("orderId",ordersTotal.getId());
        map.put("refundRecordId",refundRecord.getId());
        sqlSentence.sqlSentence("SELECT * FROM refund_note WHERE orderId=#{m.orderId} and  refundRecordId=#{m.refundRecordId} and isDel=0 ",map);
        List<RefundNote> refundNotes=refundNoteMapper.selectList(sqlSentence);
        if(refundNotes==null || refundNotes.size()==0){
            return;
        }

        List<OrderRefundNoteDto> orderRefundNoteDtos=new ArrayList<>();
        OrderRefundNoteDto orderRefundNoteDto;
        for (RefundNote refundNote : refundNotes) {
            orderRefundNoteDto=new OrderRefundNoteDto();
            BeanUtils.copyProperties(refundNote,orderRefundNoteDto);
            orderRefundNoteDto.setRefundroute(1);
            orderRefundNoteDto.setRefundNumberNo(refundNote.getPaymentNumberNo());
            orderRefundNoteDto.setRefundName(refundNote.getPaymentName());
            orderRefundNoteDtos.add(orderRefundNoteDto);
        }
        orderRefundNoteListDto.setOrderRefundNoteDtos(orderRefundNoteDtos);

        noteConfirm(orderRefundNoteListDto, ordersTotal,refundRecord,orderNodeBuilder);
    }

    public PlatformResult noteConfirm(OrderRefundNoteListDto orderRefundNoteListDto,OrdersTotal ordersTotal,RefundRecord refundRecord
            ,StringBuilder orderNodeBuilder) {
        logger.info("退款单确认打印参数CRM：{}",JSON.toJSONString(orderRefundNoteListDto));
        Map<String, String> operator = ApiOrderUtil.getOperator(commonService, orderRefundNoteListDto.getOperationId());//获取操作人信息
        String operatorId= operator.get("operatorId");
        String operatorName=  operator.get("operatorName");


        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> map=new HashMap<>();
        sqlSentence.setM(map);


        List<OrderRefundNoteDto> orderRefundNoteDtos=orderRefundNoteListDto.getOrderRefundNoteDtos();
        if("crm".equals(ordersTotal.getAppIdCode())){
            //CRM退款
            handleCrmRefundOrder(orderRefundNoteDtos,ordersTotal,refundRecord,operatorId,operatorName,orderNodeBuilder);
        }else {
            sqlSentence.sqlSentence(" refundroute=#{m.refundroute},refundNumberNo=#{m.refundNumberNo},refundName=#{m.refundName}, " +
                    " refundStoredTotal=#{m.refundStoredTotal},refundStatus=#{m.refundStatus},remarks=#{m.remarks},shopId=#{m.shopId}, " +
                    " shopName=#{m.shopName},operationName=#{m.operationName},operationId=#{m.operationId} where id=#{m.id} ",map);

            map.put("shopId",ordersTotal.getShopId());
            map.put("shopName",ordersTotal.getShopName());
            map.put("operationName",operatorName);
            map.put("operationId",operatorId);
            map.put("refundStatus",RefundNote.STATUS_SUCCESS);
            for (OrderRefundNoteDto orderRefundNoteDto : orderRefundNoteDtos) {
                map.put("refundroute",orderRefundNoteDto.getRefundroute());
                map.put("refundNumberNo",orderRefundNoteDto.getRefundNumberNo());
                map.put("refundName",orderRefundNoteDto.getRefundName());
                map.put("refundStoredTotal",orderRefundNoteDto.getRefundStoredTotal());
                map.put("remarks",orderRefundNoteDto.getRemarks());
                map.put("id",orderRefundNoteDto.getId());
                refundNoteMapper.updateWhere(sqlSentence);

                if (!StringUtils.isEmpty(orderRefundNoteDto.getImageList())){
                    String [] imageList= orderRefundNoteDto.getImageList().split(",");
                    for (String s : imageList) {
                        RefundNoteItems refundNoteItems=new RefundNoteItems();
                        refundNoteItems.setRefundNoteId(orderRefundNoteDto.getId());
                        refundNoteItems.setImgUrl(s);
                        refundNoteItemsMapper.insert(refundNoteItems);
                    }
                }
            }
        }


        //记录操作日志
        StringBuffer stringBuffer=new StringBuffer("操作人:"+operator.get("operatorName")+",已支付订单现金支付退款:");
        OrderLog orderLog=new OrderLog(ordersTotal.getId(),OrderLogConstants.LOG_TYPE_CANCEL_ORDER,stringBuffer.toString()
                ,operator.get("operatorName"),operator.get("operatorId"),OrderTotalConstants.STATUS_CANCEL);
        commonService.insert(OrderLogMapper.class,orderLog);

        return PlatformResult.success();
    }
    /**处理crm退款*/
    public void handleCrmRefundOrder(List<OrderRefundNoteDto> orderRefundNoteDtos,OrdersTotal ordersTotal,RefundRecord refundRecord
            ,String operatorId, String operatorName,StringBuilder orderNodeBuilder){
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> map=new HashMap<>();
        sqlSentence.setM(map);

        //待确认
        BigDecimal crmAmount = orderRefundNoteDtos.stream().filter(item->RefundNote.ORIGINAL_ROAD.equals(item.getRefundroute())).map(o->o.getPaymentTotal())
                .reduce(BigDecimal.ZERO,BigDecimal::add);
        List<RefundAmountModelDto> amountModelList=new ArrayList<>();
        RefundAmountModelDto refundAmountModelDto;
        for (OrderRefundNoteDto orderRefundNoteDto : orderRefundNoteDtos) {
            if(RefundNote.ORIGINAL_ROAD.equals(orderRefundNoteDto.getRefundroute())){
                refundAmountModelDto=new RefundAmountModelDto();
                refundAmountModelDto.setRefundType(PayMethodTypeConstants.PAY_CRM_WX.equals(orderRefundNoteDto.getPaymentNumberNo()) ?0:1);
                refundAmountModelDto.setAmountTotal(orderRefundNoteDto.getPaymentTotal());
                amountModelList.add(refundAmountModelDto);
            }

        }
        logger.info("退款金额：{}",crmAmount);
        if(1==crmAmount.compareTo(BigDecimal.ZERO)){
            RefundDto refundDto=new RefundDto();
            refundDto.setRefundOrderType(0);
            refundDto.setOrderId(ordersTotal.getId());
            refundDto.setRefundType(0);
            refundDto.setRefundAmountTotal(crmAmount);
            refundDto.setRefundRecharge(new BigDecimal(0));
            refundDto.setRefundIncrement(new BigDecimal(0));
            refundDto.setRefundIntegral(new BigDecimal(0));
            refundDto.setIsWholeOrder(0);
            refundDto.setRemarks("phis退款单退款,订单号："+ordersTotal.getOrderNo());
            refundDto.setAmountModelList(amountModelList);
            refundDto.setOperatorId(operatorId);
            refundDto.setOperatorName(operatorName);
            if(OrderTotalConstants.STATUS_REFUND_FINSH==ordersTotal.getRefundStatus() &&
                    OrderTotalConstants.STATUS_CANCEL == ordersTotal.getStatus()){
                //全部退款完成则取消订单
                refundDto.setIsCancelOrder(BaseEntity.YES);
            }

            logger.info("调用crm退款入参：{}",JSONObject.toJSONString(refundDto));
            Result result= fOderService.refundOrder(refundDto);;
            logger.info("调用crm退款返回：{}",JSONObject.toJSONString(result));
            if (result != null) {
                result.checkTips();
                if("100".equals(result.getCode())){
                    RefundReturnDto refundReturnDto=JSON.parseObject(JSONObject.toJSONString(result.getData()),RefundReturnDto.class);
                    if (RefundReturnDto.REFUND_STATUS_SUECCESS == refundReturnDto.getRefundStatus()){
                        orderNodeBuilder.append("-调用CRM退款金额："+crmAmount+",返回成功返回流水号："+refundReturnDto.getRefundNo()+",json："+result);
                        logger.info("crm退款成功进行下面操作");
                    }else {
                        throw new PlatTipsException(PlatformCode.ERROR_TIPS,"请求crm退款接口报错,退款失败!退款状态不是成功状态");
                    }
                    //生成CRM回执记录
                    createCrmRefundReceipt(refundReturnDto,refundRecord,commonService);
                }else{
                    throw new PlatTipsException(PlatformCode.ERROR_TIPS,"请求crm退款接口报错,接口返回错误!:code不是100");
                }
            } else {
                throw new PlatTipsException(PlatformCode.ERROR_TIPS,"请求crm退款接口报错,返回为空!");
            }

        }
        logger.info("订单状态为：{}",ordersTotal.getRefundStatus());

        sqlSentence.sqlSentence(" refundroute=#{m.refundroute},refundNumberNo=#{m.refundNumberNo},refundName=#{m.refundName}, " +
                " refundStoredTotal=#{m.refundStoredTotal},refundStatus=#{m.refundStatus},remarks=#{m.remarks},shopId=#{m.shopId}, " +
                " shopName=#{m.shopName},operationName=#{m.operationName},operationId=#{m.operationId} where id=#{m.id} ",map);

        map.put("shopId",ordersTotal.getShopId());
        map.put("shopName",ordersTotal.getShopName());
        map.put("operationName",operatorName);
        map.put("operationId",operatorId);
        map.put("refundStatus",RefundNote.STATUS_SUCCESS);
        for (OrderRefundNoteDto orderRefundNoteDto : orderRefundNoteDtos) {
            map.put("refundroute",orderRefundNoteDto.getRefundroute());
            map.put("refundNumberNo",orderRefundNoteDto.getRefundNumberNo());
            map.put("refundName",orderRefundNoteDto.getRefundName());
            map.put("refundStoredTotal",orderRefundNoteDto.getRefundStoredTotal());
            map.put("remarks",orderRefundNoteDto.getRemarks());
            map.put("id",orderRefundNoteDto.getId());
            refundNoteMapper.updateWhere(sqlSentence);

            if (!StringUtils.isEmpty(orderRefundNoteDto.getImageList())){
                String [] imageList= orderRefundNoteDto.getImageList().split(",");
                for (String s : imageList) {
                    RefundNoteItems refundNoteItems=new RefundNoteItems();
                    refundNoteItems.setRefundNoteId(orderRefundNoteDto.getId());
                    refundNoteItems.setImgUrl(s);
                    refundNoteItemsMapper.insert(refundNoteItems);
                }
            }
        }

        //退款成功发送企业微信给订单开单人
        JSONObject object = new JSONObject();
        object.put("abnormal","订单退款成功，现金支付资产已退回！");
        object.put("orderNo",ordersTotal.getOrderNo());
        User user=commonService.selectOneByKeyBlob(UserMapper.class,ordersTotal.getUserId());
        object.put("userName",user==null?"":user.getName());
        object.put("notificationSubject", NotificationLog.NOTIFICATION_SUBJECT_REFUND_NOTE_PHISKIN_SUC_NOTICE);
        SendNoticeUtil.successOrderSendNotice(commonService, customParameter, ordersTotal,object);

    }

    /**
     * 生成CRM退款回执
     * @param refundReturnDto crm退款返回总结构
     * @param refundRecord 退款总单
     * @param commonService 映射
     */
    public static void createCrmRefundReceipt(RefundReturnDto refundReturnDto,RefundRecord refundRecord,CommonService commonService){
        try{
            if (RefundReturnDto.REFUND_STATUS_SUECCESS==refundReturnDto.getRefundStatus()
                    ||RefundReturnDto.REFUND_STATUS_PART==refundReturnDto.getRefundStatus()){
                StringBuilder crmReturnData = new StringBuilder();
                crmReturnData.append("<p>【CRM退款】</p>");
                crmReturnData.append("<p>CRM退款流水号：").append(refundReturnDto.getRefundNo()).append("</p>");
                crmReturnData.append("<p>已退款总金额:");
                crmReturnData.append(refundReturnDto.getRefundTotal());
                crmReturnData.append("；");
                crmReturnData.append("已退款其他金额:");
                crmReturnData.append(refundReturnDto.getRefundAmountTotal());
                crmReturnData.append("；");
                crmReturnData.append("已退款储值金:");
                crmReturnData.append(refundReturnDto.getRefundRecharge());
                crmReturnData.append("；");
                crmReturnData.append("已退款增值金:");
                crmReturnData.append(refundReturnDto.getRefundIncrement());
                crmReturnData.append("；");
                crmReturnData.append("已退款积分:");
                crmReturnData.append(refundReturnDto.getRefundIntegral());
                crmReturnData.append("</p>");
                crmReturnData.append("<p>退款方式:</p>");
                if(refundReturnDto.getRefundAmountModelDtoList() != null && refundReturnDto.getRefundAmountModelDtoList().size() > 0){
                    for(RefundAmountModelDto refundAmountModelDto1:refundReturnDto.getRefundAmountModelDtoList()){
                        crmReturnData.append("<p>");
                        switch (refundAmountModelDto1.getRefundType()){
                            case RefundAmountModelDto.REFUND_TYPE_WX:
                                crmReturnData.append("微信[CRM]:").append(refundAmountModelDto1.getAmountTotal());
                                break;
                            case RefundAmountModelDto.REFUND_TYPE_ZFB:
                                crmReturnData.append("支付宝[CRM]:").append(refundAmountModelDto1.getAmountTotal());
                                break;
                            default:
                                crmReturnData.append("[").append(refundAmountModelDto1.getRefundType()).append("]");
                                crmReturnData.append("未知方式[CRM]：").append(refundAmountModelDto1.getAmountTotal());
                        }
                        crmReturnData.append("</p>");
                    }
                }
                RefundRecordReceipt refundRecordReceipt = new RefundRecordReceipt();
                refundRecordReceipt.setReceiptSource(RefundRecordReceipt.RECEIPT_SOURCE_CRM);
                refundRecordReceipt.setReceiptSourceNo(refundReturnDto.getRefundNo());
                refundRecordReceipt.setReceiptSourceData(JSON.toJSONString(refundReturnDto));
                refundRecordReceipt.setReceiptType(RefundRecordReceipt.RECEIPT_TYPE_REFUND);
                refundRecordReceipt.setRemarks(crmReturnData.toString());
                refundRecordReceipt.setOperatorId(refundRecord.getOperatorId());
                refundRecordReceipt.setOperatorNo(refundRecord.getOperatorNo());
                refundRecordReceipt.setOperatorName(refundRecord.getOperatorName());
                refundRecordReceipt.setRefundRecordId(refundRecord.getId());
                commonService.insert(RefundRecordReceiptMapper.class,refundRecordReceipt);
            }
        }catch (Exception e){
            logger.error("退款生成CRM回执报错:{}",e);
        }
    }

    /**
     * 营销中心回调审批处理接口
     * @param aduitDto
     * @return
     */
    @Override
    public PlatformResult partRefundApproval(AduitDto aduitDto) {
        logger.info("营销中心审批退款入参：{}",JSON.toJSONString(aduitDto));
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> map=new HashMap<>();
        sqlSentence.setM(map);
        map.put("applyId",aduitDto.getApplyId());
        sqlSentence.sqlSentence("SELECT * FROM cancel_order WHERE applyId=#{m.applyId} and isDel=0 ",map);
        CancelOrder cancelOrder=commonService.selectOne(CancelOrderMapper.class,sqlSentence);
        if( cancelOrder == null ){
            throw new PlatTipsException(PlatformCode.ERROR_TIPS,"未找到该审核标识");
        }
        if(!CancelOrder.PENDING.equals(cancelOrder.getApprovalstatus())){
            throw new PlatTipsException(PlatformCode.ERROR_TIPS,"该条审核标识已经处理过了，不要重复提交");
        }

        Map<String, String> operator=new HashMap<>();
        operator.put("operatorId",cancelOrder.getOperatorId());
        operator.put("operatorName",cancelOrder.getOperatorName());

        //先判断项目的状态是否存在
        OrdersTotal ordersTotal= ordersTotalMapper.selectOneByKey(cancelOrder.getOrderId());
        if(ordersTotal==null){
            logger.info("取消订单流程:未找到总订单信息！订单id：{}",cancelOrder.getOrderId());
            return PlatformResult.failure(PlatformCode.ERROR_TIPS,"取消订单流程:未找到总订单信息！");
        }
        
        cancelOrder.setExamEmplId(aduitDto.getExamEmplId());
        cancelOrder.setExamEmplName(aduitDto.getExamEmplName());

        //获取退款记录
        RefundRecord refundRecord = commonService.selectOneByKey(RefundRecordMapper.class,cancelOrder.getRefundRecordId());
        if(refundRecord==null){
            throw new PlatTipsException(PlatformCode.ERROR_TIPS,"未找到该审核的退款记录");
        }

        //订单节点日志
        OrdersNodeLog ordersNodeLog = new OrdersNodeLog();
        StringBuilder orderNodeBuilder = new StringBuilder();

        if(BaseEntity.NO.equals(aduitDto.getType())){

            orderNodeBuilder.append("审核不通过");
            orderNodeBuilder.append("-最后审核人：").append(aduitDto.getExamEmplName());

            //审核不通过
            cancelOrder.setApprovalstatus(CancelOrder.FAIL);
            cancelOrder.setEditTime(new Date());
            commonService.updateAll(CancelOrderMapper.class,cancelOrder);

            //更改总订单退款状态
            map.put("orderId",ordersTotal.getId());
            sqlSentence.sqlSentence("select * from order_item WHERE  orderId=#{m.orderId} and isDel=0",map);
            List<OrderItem> orderItemList=commonService.selectList(OrderItemMapper.class,sqlSentence);

            List<Integer> collect = orderItemList.stream().map(o -> o.getRefundStatus()).collect(Collectors.toList());
            if(collect.contains(OrderTotalConstants.STATUS_REFUND_PART)){
                ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_PART);
            }else if (collect.contains(OrderTotalConstants.STATUS_REFUND_NONE)
                    && collect.contains(OrderTotalConstants.STATUS_REFUND_FINSH)){
                ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_PART);
            }else if (collect.contains(OrderTotalConstants.STATUS_REFUND_NONE)){
                ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_NONE);
            }else if (collect.contains(OrderTotalConstants.STATUS_REFUND_FINSH)){
                ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_FINSH);
            }else {
                ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_NONE);
            }

            map.put("refundStatus",ordersTotal.getRefundStatus());
            map.put("id",ordersTotal.getId());
            sqlSentence.sqlSentence(" refundStatus=#{m.refundStatus}  WHERE id=#{m.id}  ",map);
            ordersTotalMapper.updateWhere(sqlSentence);

            refundRecord.setRefundStatus(RefundStatus.STATUS_INVALID_REFUND);
            refundRecord.setEditTime(new Date());
            commonService.updateAll(RefundRecordMapper.class,refundRecord);



            //先赋值该作废操作人，后面会用到，注意，这里不存储
            refundRecord.setInvalidId(refundRecord.getOperatorId());
            refundRecord.setInvalidName(refundRecord.getInvalidName());
            refundRecord.setInvalidNo(refundRecord.getOperatorNo());
            refundRecord.setInvalidAppId(refundRecord.getOperatorAppId());
            refundRecord.setInvalidAppName(refundRecord.getOperatorAppName());

            //处理老带新的佣金，没有退款才退
            if(ordersTotal.getRefundStatus() == OrderTotalConstants.STATUS_REFUND_NONE){
                oldBlingNewRefundFail(refundRecord,orderNodeBuilder,commonService);
            }

            //拒绝审批需要还原回去储值金
            //判断是否是充值订单，是的话需要把前面预扣的还原
            if(OrderTotalConstants.TYPE_RECHARGE.equals(ordersTotal.getType())){
                //判断金额不等于0，才执行操作，不然操作余额的时候会爆操作数量或金额不能为0
                //充值金额
                OrderRefundCancelTool.rechargeHandle(ordersTotal,refundRecord,OrderRefundCancelTool.OPT_TYPE_CANCEL,"拒绝审批",orderNodeBuilder,commonService);
            }
            //活动规则退款处理
            OrderRefundCancelTool.activityRuleHandle(ordersTotal,refundRecord,OrderRefundCancelTool.OPT_TYPE_CANCEL,"拒绝审批",orderNodeBuilder,commonService);

            ordersNodeLog.setCommonType(OrdersNodeLog.TYPE_COMMON_ORDER_REFUND);
            ordersNodeLog.setContent(orderNodeBuilder.toString());
            ordersNodeLog.setOrderId(ordersTotal.getId());
            commonService.insert(OrdersNodeLogMapper.class,ordersNodeLog);


            return PlatformResult.success("拒绝取消审核通过");
        }

        cancelOrder.setEditTime(new Date());
        cancelOrder.setApprovalstatus(CancelOrder.SUCCESS);
        commonService.updateAll(CancelOrderMapper.class,cancelOrder);

        orderNodeBuilder.append("审核通过，开始处理退款");


        Map<String, Object>refund =handleRefundOrder(operator,refundRecord,ordersTotal,ordersNodeLog,orderNodeBuilder,cancelOrder);
        return PlatformResult.success(refund);
    }


    /**
     * 全部退款处理退款逻辑
     * @param orderRefundDto
     * @return
     */
    @Override
    public PlatformResult wholeRefund(OrderRefundDto orderRefundDto,ThirtApplication thirtApplication) {

        OrdersTotal ordersTotal = ordersTotalMapper.selectOneByKey(orderRefundDto.getOrderId());

        //获取该笔订单的项目详情
        List<Map<String, Object>> refundDetails=refundDetails(ordersTotal);

        // 退款信息集合
        List<OrderItemRefundDto> refundList=new ArrayList<>();
        //退款二级子订单信息集合
        List<OrderItemSourceRefundDto> orderItemSourceRefundDtos;
        List<Map<String, Object>> refundSonDetails;

        OrderItemRefundDto orderItemRefundDto;
        OrderItemSourceRefundDto orderItemSourceRefundDto;
        for (Map<String, Object> refundDetail : refundDetails) {
            orderItemRefundDto = new OrderItemRefundDto();
            orderItemRefundDto.setOrderItemId(String.valueOf(refundDetail.get("id")));
            orderItemRefundDto.setType(String.valueOf(refundDetail.get("type")));

            ////退款备注
            orderItemRefundDto.setRemarks(orderRefundDto.getRemarks());
            orderItemRefundDto.setRefundReason(orderRefundDto.getRefundReason());

            if(OrderItemConstants.TYPE_PROMOTION.equals(orderItemRefundDto.getType())
                    || OrderItemConstants.CARD_BAG.equals(orderItemRefundDto.getType())){
                orderItemRefundDto.setRefundNum(0);
                refundSonDetails= (List<Map<String, Object>>) refundDetail.get("list");
                orderItemSourceRefundDtos=new ArrayList<>();
                for (Map<String, Object> refundSonDetail : refundSonDetails) {
                    orderItemSourceRefundDto=new OrderItemSourceRefundDto();
                    orderItemSourceRefundDto.setOrderItemSonId(String.valueOf(refundSonDetail.get("id")));
                    orderItemSourceRefundDto.setType(String.valueOf(refundSonDetail.get("type")));
                    orderItemSourceRefundDto.setRefundNum(Integer.parseInt(String.valueOf(refundSonDetail.get("notUsedNum"))));

                    //退款备注
                    orderItemSourceRefundDto.setRemarks(orderRefundDto.getRemarks());
                    orderItemSourceRefundDto.setRefundReason(orderRefundDto.getRefundReason());

                    orderItemSourceRefundDtos.add(orderItemSourceRefundDto);
                }
                orderItemRefundDto.setOrderItemSourceRefundDtos(orderItemSourceRefundDtos);
            }else {
                orderItemRefundDto.setRefundNum(Integer.parseInt(refundDetail.get("notUsedNum").toString()) );
            }
            refundList.add(orderItemRefundDto);
        }
        orderRefundDto.setRefundList(refundList);

        //获取退款资金信息
        OrderRefundDto  parameter= nextStep(ordersTotal,orderRefundDto);

        parameter.setOperatorId(orderRefundDto.getOperatorId());
        parameter.setIsRefund(orderRefundDto.getIsRefund());
        parameter.setIsApproval(orderRefundDto.getIsApproval());
        parameter.setRoleId(orderRefundDto.getRoleId());
        parameter.setPlatformSource(orderRefundDto.getPlatformSource());
        parameter.setRefundOperationType(BaseEntity.NO);
        parameter.setRemarks(orderRefundDto.getRemarks());
        parameter.setRefundReason(orderRefundDto.getRefundReason());
        parameter.setCouponList(parameter.getPayCouponList());

        //退款金额
        List<OrderPayMethodDto> refundPayMethodList = parameter.getPayMethodList();
        for(OrderPayMethodDto orderPayMethodDto:refundPayMethodList){
            orderPayMethodDto.setRefundNumberNo(orderPayMethodDto.getPayMethodNo());
            orderPayMethodDto.setRefundNumberName(orderPayMethodDto.getPayMethodName());
            orderPayMethodDto.setMoney(orderPayMethodDto.getPayTotal());
        }

        parameter.setRefundPayMethod(refundPayMethodList);

        //调用退款处理退款逻辑
        return partRefund(ordersTotal,parameter,thirtApplication);
    }

    /**
     * 伪造退款处理退款逻辑
     * @param orderRefundDto
     * @return
     */
    @Override
    public PlatformResult forgePartRefund(OrderRefundDto orderRefundDto) {
        logger.info("退款打印参数：{}", JSON.toJSONString(orderRefundDto));
        //先判断项目的状态是否存在
        OrdersTotal ordersTotal=null;
        try {
            ordersTotal=ordersTotalMapper.selectOneByKey(orderRefundDto.getOrderId());
            if(ordersTotal==null){
                logger.info("取消订单流程:未找到总订单信息！订单id：{}",orderRefundDto.getOrderId());
                return PlatformResult.failure(PlatformCode.ERROR_TIPS,"取消订单流程:未找到总订单信息！");
            }
        }catch (Exception e){
            logger.info("取消订单流程:根据订单id查询多条总订单信息！订单id：{}",orderRefundDto.getOrderId());
            return PlatformResult.failure(PlatformCode.ERROR_TIPS,"取消订单流程:根据订单id查询多条总订单信息！");
        }

        if(!(OrderTotalConstants.STATUS_REFUND_NONE==ordersTotal.getRefundStatus()) &&
                !(OrderTotalConstants.STATUS_REFUND_PART==ordersTotal.getRefundStatus())){
            throw new TipsException("订单标识错误,订单退款状态不正确!");
        }

//        orderRefundDto=parameterVerification(orderRefundDto);

        return handleforgePartRefund(ordersTotal,orderRefundDto);

    }



    /**
     * 伪造处理退款详情
     */
    public PlatformResult  handleforgePartRefund(OrdersTotal ordersTotal,OrderRefundDto orderRefundDto){

        //订单节点日志
        OrdersNodeLog ordersNodeLog = new OrdersNodeLog();
        StringBuilder orderNodeBuilder = new StringBuilder();

        orderNodeBuilder.append("开始退款(WZ)");

        // 获取退款方式，退款项目，退款优惠卷
        List<OrderPayMethodDto> refundPayMethod=orderRefundDto.getRefundPayMethod();
        List<OrderItemRefundDto> refundList=orderRefundDto.getRefundList();
        List<OrderCouponRefunDto> couponList=orderRefundDto.getCouponList();

        //客户选的退款方式总金额
        BigDecimal sumMoney=refundPayMethod.stream().map(OrderPayMethodDto::getMoney).reduce(BigDecimal.ZERO,BigDecimal::add);
        //本次退款总金额
        BigDecimal refundSumMoney=refundList.stream().map(OrderItemRefundDto::getRefundMoney).reduce(BigDecimal.ZERO,BigDecimal::add);

        if(!OrderTotalConstants.TYPE_RECHARGE.equals(ordersTotal.getType())){
            if(sumMoney.compareTo(refundSumMoney)==1){
                throw new TipsException("退款金额不能大于可退金额!");
            }
            orderNodeBuilder.append("-本次退款项目总金额："+refundSumMoney+",客户选的退款方式总金额："+sumMoney);
        }else {
            orderNodeBuilder.append("-本次退款项目总金额："+ordersTotal.getActualTotal()+",客户选的退款方式总金额："+sumMoney);
        }

        Map<String, String> operator = ApiOrderUtil.getOperator(commonService, orderRefundDto.getOperatorId());//获取操作人信息
        SqlSentence sqlSentence = new SqlSentence();
        Map<String,Object> map=new HashMap<>();
        sqlSentence.setM(map);

        //退款总记录
        orderNodeBuilder.append("-处理退款总记录");
        String totalCode = CreateNo.createTimeNo(systemParameterMapper, "R", 8, "yyyyMMddHHmmss");//总订单编号
        RefundRecord refundRecord=new RefundRecord(totalCode,ordersTotal.getShopId(),ordersTotal.getShopName(),sumMoney, RefundStatus.STATUS_APPLY_REFUND,0, RefundSoruceConstants.TYPE_SOURCE_ORDER,"phis退款",ordersTotal.getId(),ordersTotal.getUserId());
        refundRecord.setOperatorType(RefundRecord.OPERATOR_TYPE_EMPLOYEE);
        Employee employee = commonService.selectOneByKey(EmployeeMapper.class,orderRefundDto.getOperatorId());
        refundRecord.setOperatorId(employee.getId());
        refundRecord.setRefundOperationType(orderRefundDto.getRefundOperationType());
        refundRecord.setOperatorName(employee.getCnName());
        refundRecordService.insert(refundRecord);

        if(refundPayMethod!=null && refundPayMethod.size()>0){
            //处理退款方式记录表
            handleRefundPayMethod(orderRefundDto,orderNodeBuilder,ordersTotal,refundRecord);
        }
        if(refundList!=null && refundList.size()>0){
            //记录本次退款的项目详情
            //分摊比例
            //因为优惠卷抵扣金额可能超过订单的金额，所以不会有支付记录
            BigDecimal percentage;
            if(sumMoney.compareTo(BigDecimal.ZERO)==0){
                percentage=new BigDecimal(1);
            }else {
                percentage=sumMoney.divide(refundSumMoney,10,BigDecimal.ROUND_HALF_UP);
            }

            //handleRefundRecordItem(orderRefundDto,orderNodeBuilder,ordersTotal,refundRecord,percentage);
        }
        if(couponList!=null && couponList.size()>0){
            //处理优惠卷
            handleOrderCouponRefunDto(couponList,orderNodeBuilder,ordersTotal,refundRecord);
        }
        try{
            orderNodeBuilder.append("-开始记录收入确认表");
            PerformanceInfoTool.handRefundPerformanceInfo(commonService,refundRecord);
            orderNodeBuilder.append("-记录收入确认表成功");
        }catch (Exception e){
            orderNodeBuilder.append("-记录收入确认表失败");
            logger.info("记录收入确认表,异常:{}",e.getMessage(),e);
            // 添加错误日志
            PerformanceInfoTool.addErrorLog(commonService, refundRecord.getId(), PerformanceInfo.ASSOCIATION_TYPE_GOODS_REFUND, e.getMessage());
        }
        //记录操作日志
        orderNodeBuilder.append("-记录操作日志");
        StringBuffer stringBuffer=new StringBuffer("操作人:"+operator.get("operatorName")+",进行退款(WZ)");
        OrderLog orderLog=new OrderLog(ordersTotal.getId(), OrderLogConstants.LOG_TYPE_REFUND,stringBuffer.toString()
                ,operator.get("operatorName"),operator.get("operatorId"),OrderTotalConstants.STATUS_CANCEL);
        commonService.insert(OrderLogMapper.class,orderLog);

        orderNodeBuilder.append("-结束处理退款");
        ordersNodeLog.setCommonType(OrdersNodeLog.TYPE_COMMON_ORDER_REFUND);
        ordersNodeLog.setContent(orderNodeBuilder.toString());
        ordersNodeLog.setOrderId(ordersTotal.getId());
        commonService.insert(OrdersNodeLogMapper.class,ordersNodeLog);

        return PlatformResult.success("成功");
    }

    /**
     * 根据订单 重新绑定订单退款状态
     *
     */
    @Override
    public void verifyOrderRefundStatus(OrdersTotal ordersTotalDto) {
        SqlSentence sqlSentence = new SqlSentence();
        Map<String, Object> sqlMap = new HashMap<>();
        sqlSentence.setM(sqlMap);
        sqlMap.put("isDel", BaseEntity.NO);
        sqlMap.put("orderId", ordersTotalDto.getId());
        sqlMap.put("type", OrderItemConstants.TYPE_PROJECT);

        sqlSentence.sqlSentence("SELECT * FROM  orders_total   WHERE 　id = #{m.orderId}  and  isDel = #{m.isDel} ",sqlMap);
        OrdersTotal ordersTotal = ordersTotalMapper.selectOne(sqlSentence);
        if(ordersTotal==null){
            throw new TipsException("订单标识错误,找不到订单!");
        }
        //查询二级订单
        sqlSentence.sqlSentence("SELECT * FROM  order_item_source   WHERE 　orderId = #{m.orderId}  and  type = #{m.type}  and  isDel = #{m.isDel} ",sqlMap);
        List<OrderItemSon> orderItemSonList=orderItemSonMapper.selectList(sqlSentence);


        if(orderItemSonList!=null && orderItemSonList.size()>0){
            int oldRefundStatus;
            int newRefundStatus;
            UserProjectItem userProjectItem;
            for (OrderItemSon orderItemSon : orderItemSonList) {
                if(OrderTotalConstants.STATUS_REFUND_FINSH==orderItemSon.getRefundStatus()){
                    oldRefundStatus=OrderTotalConstants.STATUS_REFUND_FINSH;

                    userProjectItem = PartialRefundUtil.getUserProject(orderItemSon.getId(),commonService);

                    if(userProjectItem.getNotUsedNum()>0){
                        newRefundStatus=OrderTotalConstants.STATUS_REFUND_PART;
                    }else {
                        newRefundStatus=oldRefundStatus;
                    }

                    if(newRefundStatus!=oldRefundStatus){
                        sqlMap.put("refundStatus", newRefundStatus);
                        sqlMap.put("id", orderItemSon.getId());
                        sqlSentence.sqlSentence("　refundStatus = #{m.refundStatus} WHERE id = #{m.id}  ",sqlMap);
                        orderItemSonMapper.updateWhere(sqlSentence);

                        sqlMap.put("refundStatus", newRefundStatus);
                        sqlMap.put("id", orderItemSon.getOrderItemId());
                        sqlSentence.sqlSentence("　refundStatus = #{m.refundStatus} WHERE id = #{m.id}  ",sqlMap);
                        orderItemMapper.updateWhere(sqlSentence);
                    }

                }
            }
            
        }

        //查询二级订单
        sqlSentence.sqlSentence("SELECT * FROM  order_item   WHERE 　orderId = #{m.orderId}  and  type = #{m.type}  and  isDel = #{m.isDel} ",sqlMap);
        List<OrderItem> orderItemList=orderItemMapper.selectList(sqlSentence);
        if(orderItemList!=null && orderItemList.size()>0){
            int oldRefundStatus;
            int newRefundStatus;
            UserProjectItem userProjectItem;
            for (OrderItem orderItem : orderItemList) {
                oldRefundStatus=OrderTotalConstants.STATUS_REFUND_FINSH;

                userProjectItem = PartialRefundUtil.getUserProject(orderItem.getId(),commonService);

                if(userProjectItem.getNotUsedNum()>0){
                    newRefundStatus=OrderTotalConstants.STATUS_REFUND_PART;
                }else {
                    newRefundStatus=oldRefundStatus;
                }

                if(newRefundStatus!=oldRefundStatus){
                    sqlMap.put("refundStatus", newRefundStatus);
                    sqlMap.put("id", orderItem.getId());
                    sqlSentence.sqlSentence("　refundStatus = #{m.refundStatus} WHERE id = #{m.id}  ",sqlMap);
                    orderItemMapper.updateWhere(sqlSentence);
                }

            }
        }


        sqlMap.put("orderId",ordersTotal.getId());
        sqlSentence.sqlSentence("select * from order_item WHERE  orderId=#{m.orderId} and isDel=0",sqlMap);
        List<OrderItem> orderItems=commonService.selectList(OrderItemMapper.class,sqlSentence);

        List<Integer> collect = orderItems.stream().map(o -> o.getRefundStatus()).collect(Collectors.toList());
        if(collect.contains(OrderTotalConstants.STATUS_REFUND_PART)){
            ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_PART);
            ordersTotal.setStatus(OrderTotalConstants.STATUS_PAY);
        }else if (collect.contains(OrderTotalConstants.STATUS_REFUND_NONE) && collect.contains(OrderTotalConstants.STATUS_REFUND_FINSH)){
            ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_PART);
            ordersTotal.setStatus(OrderTotalConstants.STATUS_PAY);
        }else if (collect.contains(OrderTotalConstants.STATUS_REFUND_NONE)){
            ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_NONE);
            ordersTotal.setStatus(OrderTotalConstants.STATUS_PAY);
        }else if (collect.contains(OrderTotalConstants.STATUS_REFUND_FINSH)){
            ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_FINSH);
            ordersTotal.setStatus(OrderTotalConstants.STATUS_CANCEL);
        }else {
            ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_NONE);
            ordersTotal.setStatus(OrderTotalConstants.STATUS_PAY);
        }
        ordersTotal.setEditTime(new Date());
        commonService.updateAll(OrdersTotalMapper.class,ordersTotal);
    }

    /**作废退款*/
    @Override
    public void refundCancel(RefundCancelVo refundCancelVo, RefundRecord refundRecord,Employee employee,EmployeeRole employeeRole
            , ThirtApplication thirtApplication) {

        //判断退款单状态
        if(refundRecord.getRefundStatus() != RefundStatus.STATUS_SUCC_REFUND){
            throw new PlatTipsException(PlatformCode.ERROR_TIPS,"操作失败，退款单状态错误！");
        }

        //获取订单信息
        OrdersTotal ordersTotal = ordersTotalMapper.selectOneByKey(refundRecord.getOrderId());
        if(ordersTotal == null){
            throw new PlatTipsException(PlatformCode.ERROR_TIPS,"操作失败，获取订单信息失败！");
        }

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

        //填充数据，后面会用到
        refundRecord.setInvalidType(RefundRecord.OPERATOR_TYPE_EMPLOYEE);
        refundRecord.setInvalidRemarks(refundCancelVo.getRemarks());

        //****更新退款单信息，更新完退款单再去做剩下的操作
        values.put("refundStatus",RefundStatus.STATUS_REFUND_CANCEL);
        values.put("refundStatusOld",RefundStatus.STATUS_SUCC_REFUND);
        values.put("id",refundRecord.getId());
        values.put("invalidTime",new Date());
        values.put("invalidType",RefundRecord.OPERATOR_TYPE_EMPLOYEE);
        values.put("invalidRemarks",refundCancelVo.getRemarks());
        sql.append("refundStatus = #{m.refundStatus},invalidTime = #{m.invalidTime},invalidRemarks = #{m.invalidRemarks},invalidType = #{m.invalidType}");

        if(employee != null){
            refundRecord.setInvalidId(employee.getId());
            refundRecord.setInvalidNo(employee.getEmployeeNo());
            refundRecord.setInvalidName(employee.getCnName());
            values.put("invalidId",employee.getId());
            values.put("invalidNo",employee.getEmployeeNo());
            values.put("invalidName",employee.getCnName());
            sql.append(",invalidId = #{m.invalidId},invalidNo = #{m.invalidNo},invalidName = #{m.invalidName}");
        }
        if(employeeRole != null){
            refundRecord.setInvalidRoleNo(employeeRole.getRoleUniqueStr());
            refundRecord.setInvalidRoleName(employeeRole.getRoleName());
            values.put("invalidRoleNo",employeeRole.getRoleUniqueStr());
            values.put("invalidRoleName",employeeRole.getRoleName());
            sql.append(",invalidRoleNo = #{m.invalidRoleNo},invalidRoleName = #{m.invalidRoleName}");
        }
        if(thirtApplication != null){
            refundRecord.setInvalidAppId(thirtApplication.getAppId());
            refundRecord.setInvalidAppCode(thirtApplication.getAppIdCode());
            refundRecord.setInvalidAppName(thirtApplication.getName());
            values.put("invalidAppId",thirtApplication.getAppId());
            values.put("invalidAppCode",thirtApplication.getAppIdCode());
            values.put("invalidAppName",thirtApplication.getName());
            sql.append(",invalidAppId = #{m.invalidAppId},invalidAppCode = #{m.invalidAppCode},invalidAppName = #{m.invalidAppName}");
        }
        sql.append(" WHERE id = #{m.id} AND refundStatus = #{m.refundStatusOld}");
        sqlSentence.sqlUpdate(sql.toString(),values);
        if(refundRecordMapper.updateWhere(sqlSentence) != 1){
            throw new PlatTipsException(PlatformCode.ERROR_TIPS,"操作失败，退款单状态已发生变化！");
        }

        //订单系统日志
        StringBuilder orderNodeBuilder = new StringBuilder();
        orderNodeBuilder.append("开始作废退款");

        //判断订单类型
        if(OrderTotalConstants.TYPE_RECHARGE.equals(ordersTotal.getType())){
            //充值订单
            OrderRefundCancelTool.rechargeHandle(ordersTotal,refundRecord,OrderRefundCancelTool.OPT_TYPE_CANCEL,"作废退款",orderNodeBuilder,commonService);
        }else{
            //处理子单
            OrderRefundCancelTool.refundRecordItemHandle(ordersTotal,refundRecord,commonService);
        }

        //处理订单活动
        OrderRefundCancelTool.activityRuleHandle(ordersTotal,refundRecord,OrderRefundCancelTool.OPT_TYPE_CANCEL,"作废退款",orderNodeBuilder,commonService);
        //处理订单优惠券
        OrderRefundCancelTool.handCoupon(ordersTotal,refundRecord,orderNodeBuilder,commonService);
        //处理总退款方式
        List<RefundRecordMethod> refundRecordMethodList= OrderRefundCancelTool.refundRecordMotnedHandle(refundRecord,ordersTotal,orderNodeBuilder,commonService);

        //操作的现金金额
        BigDecimal cashTotal = BigDecimal.ZERO;
        for(RefundRecordMethod refundRecordMethod:refundRecordMethodList){
            if(refundRecordMethod.getIsMoneyPay().equals(RefundRecordMethod.YES)){
                cashTotal = cashTotal.add(refundRecordMethod.getActualTotal());
            }
        }

        //报错订单系统日志

        //****更改总订单退款状态
        values.clear();
        values.put("orderId",ordersTotal.getId());
        sqlSentence.sqlSentence("select * from order_item WHERE orderId=#{m.orderId} and isDel=0",values);
        List<OrderItem> orderItemList=commonService.selectList(OrderItemMapper.class,sqlSentence);

        int oldStatus = ordersTotal.getStatus();
        values.clear();
        values.put("oldStatus",ordersTotal.getStatus());
        values.put("oldRefundStatus",ordersTotal.getRefundStatus());

        List<Integer> collect = orderItemList.stream().map(OrderItem::getRefundStatus).collect(Collectors.toList());
        if(collect.contains(OrderTotalConstants.STATUS_REFUND_PART)){
            ordersTotal.setStatus(OrderTotalConstants.STATUS_PAY);
            ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_PART);
            ordersTotal.setReTotal(orderItemList.stream().map(OrderItem::getReTotal).reduce(BigDecimal.ZERO,BigDecimal::add));
        }else if (collect.contains(OrderTotalConstants.STATUS_REFUND_NONE) && collect.contains(OrderTotalConstants.STATUS_REFUND_FINSH)){
            ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_PART);
            ordersTotal.setStatus(OrderTotalConstants.STATUS_PAY);
            ordersTotal.setReTotal(orderItemList.stream().map(OrderItem::getReTotal).reduce(BigDecimal.ZERO,BigDecimal::add));
        }else if (collect.contains(OrderTotalConstants.STATUS_REFUND_NONE)){
            ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_NONE);
            ordersTotal.setStatus(OrderTotalConstants.STATUS_PAY);
            ordersTotal.setReTotal(BigDecimal.ZERO);
        }else if (collect.contains(OrderTotalConstants.STATUS_REFUND_FINSH)){
            ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_FINSH);
            ordersTotal.setStatus(OrderTotalConstants.STATUS_CANCEL);
            ordersTotal.setReTotal(orderItemList.stream().map(OrderItem::getReTotal).reduce(BigDecimal.ZERO,BigDecimal::add));
        }else {
            if(OrderTotalConstants.TYPE_RECHARGE.equals(ordersTotal.getType())){
                if(ordersTotal.getReTotal().compareTo(refundRecord.getRefundTotal()) == 0){
                    ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_NONE);
                    ordersTotal.setStatus(OrderTotalConstants.STATUS_PAY);
                    ordersTotal.setReTotal(ordersTotal.getReTotal().subtract(refundRecord.getRefundTotal()));
                }else if(ordersTotal.getReTotal().compareTo(refundRecord.getRefundTotal()) > 0){
                    ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_PART);
                    ordersTotal.setStatus(OrderTotalConstants.STATUS_PAY);
                    ordersTotal.setReTotal(ordersTotal.getReTotal().subtract(refundRecord.getRefundTotal()));
                }
            }else{
                ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_NONE);
                ordersTotal.setStatus(OrderTotalConstants.STATUS_PAY);
                ordersTotal.setReTotal(ordersTotal.getReTotal().subtract(refundRecord.getRefundTotal()));
            }
        }
        ordersTotal.setIsSyncOrder(BaseEntity.NO);

        values.put("isSyncOrder",BaseEntity.NO);
        values.put("status",ordersTotal.getStatus());
        values.put("refundStatus",ordersTotal.getRefundStatus());
        values.put("reTotal",ordersTotal.getReTotal());
        values.put("id",ordersTotal.getId());
        sqlSentence.sqlUpdate("isSyncOrder = #{m.isSyncOrder},status = #{m.status},refundStatus = #{m.refundStatus},reTotal = #{m.reTotal}" +
                " WHERE id = #{m.id} AND status = #{m.oldStatus} AND refundStatus = #{m.oldRefundStatus}",values);
        if(commonService.updateWhere(OrdersTotalMapper.class,sqlSentence) != 1){
            throw new TipsException("作废失败，订单状态已发生改变！");
        }

        //初始化初复诊信息
        if(OrderTotalConstants.STATUS_CANCEL == oldStatus
                && oldStatus != ordersTotal.getStatus()){
            OrderUtil.reCalcOderBothTheOneData(commonService, VisitRecordMapper.class,null,ordersTotal.getUserId(), BaseEntity.NO);
        }

        //额外的操作，升降级，收入确认表
        additionalOperate(ordersTotal,refundRecord,cashTotal,orderNodeBuilder,customParameter,commonService);

        //记录日志(处理到具体节点(成功和失败))
        OrdersNodeLog ordersNodeLog = new OrdersNodeLog();
        orderNodeBuilder.append("-作废退款单结束");
        ordersNodeLog.setCommonType(OrdersNodeLog.TYPE_COMMON_ORDER_REFUND_CANCEL);
        ordersNodeLog.setContent(orderNodeBuilder.toString());
        ordersNodeLog.setOrderId(ordersTotal.getId());
        commonService.insert(OrdersNodeLogMapper.class,ordersNodeLog);

    }

    /**
     * 卡项（卡包）部分退款选择退款数量组装金额信息
     */
    @Override
    public OrderRefundDto countUserCardRefund(RefundUserCardVo refundUserCardVo) {
        if(StringUtils.isEmpty(refundUserCardVo.getUserCardId())){
            throw new TipsException("用户卡包标识不能为空！");
        }
        UserCard userCard = commonService.selectOneByKey(UserCardMapper.class,refundUserCardVo.getUserCardId());
        if(userCard == null){
            throw new TipsException("用户卡包标识错误！");
        }
        if(refundUserCardVo.getRefundUserCardItemVoList() == null || refundUserCardVo.getRefundUserCardItemVoList().size() < 1){
            throw new TipsException("请选择需要退款的条目！");
        }


        return null;
    }

    /**额外操作，不影响主流程*/
    public static void additionalOperate(OrdersTotal ordersTotal,RefundRecord refundRecord,BigDecimal total,StringBuilder orderNodeBuilder,CustomParameter customParameter,CommonService commonService){
        if(BigDecimal.ZERO.compareTo(total) < 0){
            try {
                orderNodeBuilder.append("-开始处理用户升降级，金额:").append(total);
                UserLevelUtil.refund(ordersTotal.getUserId(),ordersTotal.getId(),total,refundRecord.getInvalidAppCode()==null?"phiskin":refundRecord.getInvalidAppCode());
                orderNodeBuilder.append("-处理用户升降级成功");
            }catch (Exception e){
                String snapshot="处理用户升降级失败";
                orderNodeBuilder.append("-处理用户升降级失败,异常原因:").append(e.getMessage());
                logger.error("处理用户升降级失败：" + e.getMessage());
                //发送企业微信通知给工作人员
                SendNoticeUtil.failOrderSendNotice(ordersTotal,e.getMessage(),snapshot,commonService,customParameter);
            }
        }
        try{
            orderNodeBuilder.append("-开始记录收入确认表");
            PerformanceInfoTool.refundCancelPerformanceInfo(commonService,refundRecord);
            orderNodeBuilder.append("-记录收入确认表成功");
        }catch (Exception e){
            orderNodeBuilder.append("-记录收入确认表失败");
            logger.info("记录收入确认表,异常:{}",e.getMessage(),e);
            // 添加错误日志
            PerformanceInfoTool.addErrorLog(commonService, refundRecord.getId(), PerformanceInfo.ASSOCIATION_TYPE_GOODS_REFUND, e.getMessage());
        }
    }

}