modify

Helius

2020-09-01 f0a0d795d8e2f911fe543a09b4b9fe527fdacb96

 src/main/java/com/xcong/excoin/modules/contract/service/impl/OrderWebsocketServiceImpl.java

@@ -1,18 +1,25 @@
package com.xcong.excoin.modules.contract.service.impl;

import cn.hutool.core.collection.CollUtil;
import com.alibaba.fastjson.JSONObject;
import com.xcong.excoin.common.contants.AppContants;
import com.xcong.excoin.modules.coin.dao.MemberAccountFlowEntityDao;
import com.xcong.excoin.modules.coin.entity.MemberAccountFlowEntity;
import com.xcong.excoin.modules.contract.dao.ContractEntrustOrderDao;
import com.xcong.excoin.modules.contract.dao.ContractHoldOrderDao;
import com.xcong.excoin.modules.contract.entity.ContractEntrustOrderEntity;
import com.xcong.excoin.modules.contract.entity.ContractHoldOrderEntity;
import com.xcong.excoin.modules.contract.entity.ContractOrderEntity;
import com.xcong.excoin.modules.contract.mapper.ContractEntrustOrderEntityMapper;
import com.xcong.excoin.modules.contract.mapper.ContractHoldOrderEntityMapper;
import com.xcong.excoin.modules.contract.service.ContractEntrustOrderService;
import com.xcong.excoin.modules.contract.service.ContractHoldOrderService;
import com.xcong.excoin.modules.contract.service.ContractOrderService;
import com.xcong.excoin.modules.member.dao.AgentReturnDao;
import com.xcong.excoin.modules.member.dao.MemberSettingDao;
import com.xcong.excoin.modules.member.entity.AgentReturnEntity;
import com.xcong.excoin.modules.member.entity.MemberEntity;
import com.xcong.excoin.modules.member.entity.MemberSettingEntity;
import com.xcong.excoin.modules.member.entity.MemberWalletContractEntity;
import com.xcong.excoin.modules.member.parameter.vo.NeedMoneyMemberVo;
import com.xcong.excoin.modules.member.service.MemberService;
@@ -20,10 +27,11 @@
import com.xcong.excoin.modules.platform.entity.PlatformTradeSettingEntity;
import com.xcong.excoin.rabbit.pricequeue.OrderModel;
import com.xcong.excoin.rabbit.producer.OrderProducer;
import com.xcong.excoin.utils.CacheSettingUtils;
import com.xcong.excoin.utils.CalculateUtil;
import com.xcong.excoin.utils.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
@@ -33,6 +41,7 @@
/**
 * @author helius
 */
@Slf4j
@Service
public class OrderWebsocketServiceImpl {

@@ -62,6 +71,14 @@

    @Resource
    private MemberAccountFlowEntityDao memberAccountFlowEntityDao;
    @Resource
    private MemberSettingDao memberSettingDao;
    @Resource
    private ContractHoldOrderDao contractHoldOrderDao;
    @Resource
    private ContractEntrustOrderDao contractEntrustOrderDao;
    @Resource
    private RedisUtils redisUtils;


    public void dealOrderFromMq(List<OrderModel> list, Integer type) {
@@ -118,9 +135,27 @@
        }
    }


    /**
     * 止盈/止损后删除全仓委托平仓单
     *
     * @param orderNo
     */
    private void deleteEntrustCloseOrder(String orderNo) {
        // 若平掉所有张数，若存在委托平仓，则删除委托平仓记录
        List<ContractEntrustOrderEntity> entrustOrders = contractEntrustOrderDao.selectEntrustOrderByOrderNo(orderNo);
        if (CollUtil.isNotEmpty(entrustOrders)) {
            for (ContractEntrustOrderEntity entrustOrder : entrustOrders) {
                contractEntrustOrderDao.deleteById(entrustOrder.getId());
            }
        }
    }


    /**
     * 开多止盈
     */
    @Transactional(rollbackFor = Exception.class)
    public void dealForMoreStopPro(List<ContractHoldOrderEntity> orderList, List<OrderModel> list) {
        if (CollectionUtils.isNotEmpty(orderList)) {
            Map<Long, BigDecimal> modelMap = new HashMap<Long, BigDecimal>();
@@ -129,28 +164,34 @@
            }
            for (ContractHoldOrderEntity order : orderList) {
                Long orderId = order.getId();
                System.out.println("开多止盈订单号：" + order.getOrderNo());
                System.out.println("传来的止盈价格：" + modelMap.get(order.getId()));
                log.info("开多止盈订单号：" + order.getOrderNo());
                log.info("传来的止盈价格：" + modelMap.get(order.getId()));
                if (null != order.getStopProfitPrice()) {
                    BigDecimal closePrice = order.getStopProfitPrice();
                    BigDecimal queuePrice = modelMap.get(order.getId());
                    System.out.println("订单的止盈价格：" + closePrice);
                    log.info("订单的止盈价格：" + closePrice);
                    // 判断 保留七位是为了忽略以为小数 防止不精确导致的不相等
                    if (queuePrice.compareTo(closePrice) != 0) {

                        // 不能止盈
                        System.out.println("数据库价格：" + queuePrice.toPlainString() + "--价格不能止盈：" + closePrice);
                        log.info("数据库价格：" + queuePrice.toPlainString() + "--价格不能止盈：" + closePrice);
                        //更新数据
                        contractHoldOrderService.updateOrderIsCanClosingAndBatchNoById(orderId);
                        continue;
                    }
                    System.out.println("执行操作");
                    log.info("执行操作");
                    // 止盈价
                    String symbol = order.getSymbol();
                    // 本次需要退回的预付款
                    BigDecimal prePrice = order.getPrePaymentAmount();
                    // 本次需要退回的保证金
                    BigDecimal prePrice = order.getBondAmount();
                    Long memberId = order.getMemberId();
                    MemberWalletContractEntity wallet = memberWalletContractService.findWalletContractByMemberIdAndSymbol(memberId, "USDT");
                    MemberWalletContractEntity wallet;
                    if (order.getPositionType() == ContractEntrustOrderEntity.POSITION_TYPE_ADD) {
                        wallet = memberWalletContractService.findWalletContractByMemberIdAndSymbol(memberId, "USDT");
                    } else {
                        wallet = memberWalletContractService.findWalletContractByMemberIdAndSymbol(memberId, CoinTypeConvert.convertContractTypeToCoin(order.getSymbol()));
                    }

                    if (wallet != null) {
                        // 历史订单
                        ContractOrderEntity contractOrderEntity = ContractHoldOrderEntityMapper.INSTANCE.holdOrderToOrder(order);
@@ -163,41 +204,52 @@
                        // 盈亏额度= (当前的币种的平仓价-下单时的建仓价)*购买的手数/规格*倍率
                        BigDecimal profitLossPrice = (closePrice
                                .subtract(order.getOpeningPrice()))
                                .multiply(new BigDecimal(currentFlat + ""))
                                .multiply(new BigDecimal(currentFlat))
                                .multiply(symbolSku).setScale(8, BigDecimal.ROUND_DOWN);
                        MemberEntity memberEntity = memberService.getById(memberId);

                        MemberSettingEntity memberSettingEntity = memberSettingDao.selectMemberSettingByMemberId(memberId);
                        log.info("划点前:{}", profitLossPrice);
                        profitLossPrice = profitLossPrice.multiply(BigDecimal.ONE.subtract(memberSettingEntity.getClosingSpread().divide(BigDecimal.valueOf(100), 4, BigDecimal.ROUND_DOWN)));
                        log.info("划点后:{}", profitLossPrice);
                        if (memberEntity.getIsProfit() == 1) {
                            PlatformTradeSettingEntity tradeSetting = cacheSettingUtils.getTradeSetting();
                            if (profitLossPrice.compareTo(BigDecimal.ZERO) > 0) {
                                profitLossPrice = profitLossPrice.multiply(BigDecimal.ONE.subtract(tradeSetting.getProfitParam()));
                            } else {
                                profitLossPrice = profitLossPrice.multiply(BigDecimal.ONE.add(tradeSetting.getProfitParam()));
//                                profitLossPrice = profitLossPrice.multiply(BigDecimal.ONE.add(tradeSetting.getProfitParam()));
                            }
                        }
                        //回报率
                        BigDecimal returnRate = profitLossPrice.divide((order.getPrePaymentAmount().subtract(contractOrderEntity.getClosingFeeAmount())), 8, BigDecimal.ROUND_DOWN);
                        // 回报率
                        BigDecimal returnRate = profitLossPrice.divide((order.getBondAmount().subtract(contractOrderEntity.getOpeningFeeAmount())), 8, BigDecimal.ROUND_DOWN);
                        contractOrderEntity.setRewardAmount(profitLossPrice);
                        contractOrderEntity.setRewardRatio(returnRate);
                        contractOrderEntity.setClosingFeeAmount(order.getOpeningFeeAmount());
                        contractOrderEntity.setClosingPrice(closePrice);
                        contractOrderEntity.setClosingType(6);
                        contractOrderEntity.setOrderType(ContractOrderEntity.ORDER_TYPE_CLOSE_MORE);
                        BigDecimal totalReturn = BigDecimal.ZERO;
                        contractOrderService.save(contractOrderEntity);

                        contractHoldOrderService.removeById(order.getId());
                        // 将需要退回的减去手续费
                        BigDecimal needReturn = prePrice.add(profitLossPrice);
                        //总退回金额=保证金+收益-手续费
                        totalReturn = needReturn.subtract(contractOrderEntity.getClosingFeeAmount());
                        // 更新钱包
                        // 总的是收益-平仓手续费
                        BigDecimal totalBalance = profitLossPrice.subtract(contractOrderEntity.getClosingFeeAmount());
                        memberWalletContractService.increaseWalletContractBalanceById(totalBalance, totalReturn, null, wallet.getId());

                        memberWalletContractService.increaseWalletContractBalanceById(totalReturn, totalBalance, null, wallet.getId());

                        // 流水记录 TODO 531e
                        insertAccountFlow(order, wallet, profitLossPrice, "止盈平仓");

                        //返佣
                        calYj(order.getMemberId(), order.getOpeningFeeAmount(), contractOrderEntity, 2);
                        ThreadPoolUtils.calReturnMoney(order.getMemberId(), order.getOpeningFeeAmount(), contractOrderEntity, AgentReturnEntity.ORDER_TYPE_CLOSE);

                        // 全仓模式，止盈/止损 删除委托平仓
                        if (ContractEntrustOrderEntity.POSITION_TYPE_ALL == order.getPositionType()) {
                            deleteEntrustCloseOrder(order.getOrderNo());
                        }
                    }
                }
            }
@@ -208,6 +260,7 @@
    /**
     * 开空止盈
     */
    @Transactional(rollbackFor = Exception.class)
    public void dealForLessStopPro(List<ContractHoldOrderEntity> orderList, List<OrderModel> list) {
        //List<CoinsCoinsOrder> orderList = orderMapper.selectOrderByBatchNo(batchno);
        //System.out.println("开空止盈订单batchno：" + batchno);
@@ -235,9 +288,14 @@
                    System.out.println("执行操作");
                    String symbol = order.getSymbol();
                    // 本次需要退回的预付款
                    BigDecimal prePrice = order.getPrePaymentAmount();
                    BigDecimal prePrice = order.getBondAmount();
                    Long memberId = order.getMemberId();
                    MemberWalletContractEntity wallet = memberWalletContractService.findWalletContractByMemberIdAndSymbol(memberId, "USDT");
                    MemberWalletContractEntity wallet;
                    if (order.getPositionType() == ContractEntrustOrderEntity.POSITION_TYPE_ADD) {
                        wallet = memberWalletContractService.findWalletContractByMemberIdAndSymbol(memberId, "USDT");
                    } else {
                        wallet = memberWalletContractService.findWalletContractByMemberIdAndSymbol(memberId, CoinTypeConvert.convertContractTypeToCoin(order.getSymbol()));
                    }
                    if (wallet != null) {
                        // 历史订单
                        ContractOrderEntity contractOrderEntity = ContractHoldOrderEntityMapper.INSTANCE.holdOrderToOrder(order);
@@ -253,24 +311,30 @@
                                .multiply(new BigDecimal(currentFlat + ""))
                                .multiply(symbolSku).setScale(8, BigDecimal.ROUND_DOWN);
                        MemberEntity memberEntity = memberService.getById(memberId);

                        MemberSettingEntity memberSettingEntity = memberSettingDao.selectMemberSettingByMemberId(memberId);
                        log.info("划点前:{}", profitLossPrice);
                        profitLossPrice = profitLossPrice.multiply(BigDecimal.ONE.subtract(memberSettingEntity.getClosingSpread().divide(BigDecimal.valueOf(100), 4, BigDecimal.ROUND_DOWN)));
                        log.info("划点后:{}", profitLossPrice);
                        if (memberEntity.getIsProfit() == 1) {
                            PlatformTradeSettingEntity tradeSetting = cacheSettingUtils.getTradeSetting();
                            if (profitLossPrice.compareTo(BigDecimal.ZERO) > 0) {
                                profitLossPrice = profitLossPrice.multiply(BigDecimal.ONE.subtract(tradeSetting.getProfitParam()));
                            } else {
                                profitLossPrice = profitLossPrice.multiply(BigDecimal.ONE.add(tradeSetting.getProfitParam()));
//                                profitLossPrice = profitLossPrice.multiply(BigDecimal.ONE.add(tradeSetting.getProfitParam()));
                            }
                        }
                        //回报率
                        BigDecimal returnRate = profitLossPrice.divide((order.getPrePaymentAmount().subtract(contractOrderEntity.getClosingFeeAmount())), 8, BigDecimal.ROUND_DOWN);
                        BigDecimal returnRate = profitLossPrice.divide((order.getBondAmount().subtract(contractOrderEntity.getOpeningFeeAmount())), 8, BigDecimal.ROUND_DOWN);
                        contractOrderEntity.setRewardAmount(profitLossPrice);
                        contractOrderEntity.setRewardRatio(returnRate);
                        contractOrderEntity.setClosingFeeAmount(order.getOpeningFeeAmount());
                        contractOrderEntity.setClosingPrice(closePrice);
                        contractOrderEntity.setClosingType(7);
                        contractOrderEntity.setOrderType(ContractOrderEntity.ORDER_TYPE_CLOSE_LESS);
                        BigDecimal totalReturn = BigDecimal.ZERO;
                        contractOrderService.save(contractOrderEntity);

                        contractHoldOrderService.removeById(order.getId());
                        // 将需要退回的减去手续费
                        BigDecimal needReturn = prePrice.add(profitLossPrice);
                        //总退回金额=保证金+收益-手续费
@@ -278,13 +342,18 @@
                        // 更新钱包
                        // 总的是收益-平仓手续费
                        BigDecimal totalBalance = profitLossPrice.subtract(contractOrderEntity.getClosingFeeAmount());
                        memberWalletContractService.increaseWalletContractBalanceById(totalBalance, totalReturn, null, wallet.getId());

                        memberWalletContractService.increaseWalletContractBalanceById(totalReturn, totalBalance, null, wallet.getId());

                        insertAccountFlow(order, wallet, profitLossPrice, "止盈平仓");

                        //返佣
                        calYj(order.getMemberId(), order.getOpeningFeeAmount(), contractOrderEntity, 2);
                        ThreadPoolUtils.calReturnMoney(order.getMemberId(), order.getOpeningFeeAmount(), contractOrderEntity, AgentReturnEntity.ORDER_TYPE_CLOSE);

                        // 全仓模式，止盈/止损 删除委托平仓
                        if (ContractEntrustOrderEntity.POSITION_TYPE_ALL == order.getPositionType()) {
                            deleteEntrustCloseOrder(order.getOrderNo());
                        }
                    }
                }
            }
@@ -297,6 +366,7 @@
     *
     * @param
     */
    @Transactional(rollbackFor = Exception.class)
    public void dealForMoreLoss(List<ContractHoldOrderEntity> orderList, List<OrderModel> list) {
        //List<CoinsCoinsOrder> orderList = orderMapper.selectOrderByBatchNo(batchno);
        //System.out.println("开多止损批次号batchno：" + batchno);
@@ -324,8 +394,13 @@
                    String symbol = order.getSymbol();
                    Long memberId = order.getMemberId();
                    // 本次需要退回的预付款
                    BigDecimal prePrice = order.getPrePaymentAmount();
                    MemberWalletContractEntity wallet = memberWalletContractService.findWalletContractByMemberIdAndSymbol(memberId, "USDT");
                    BigDecimal prePrice = order.getBondAmount();
                    MemberWalletContractEntity wallet;
                    if (order.getPositionType() == ContractEntrustOrderEntity.POSITION_TYPE_ADD) {
                        wallet = memberWalletContractService.findWalletContractByMemberIdAndSymbol(memberId, "USDT");
                    } else {
                        wallet = memberWalletContractService.findWalletContractByMemberIdAndSymbol(memberId, CoinTypeConvert.convertContractTypeToCoin(order.getSymbol()));
                    }

                    if (wallet != null) {
                        // 历史订单
@@ -348,18 +423,21 @@
                            if (profitLossPrice.compareTo(BigDecimal.ZERO) > 0) {
                                profitLossPrice = profitLossPrice.multiply(BigDecimal.ONE.subtract(tradeSetting.getProfitParam()));
                            } else {
                                profitLossPrice = profitLossPrice.multiply(BigDecimal.ONE.add(tradeSetting.getProfitParam()));
//                                profitLossPrice = profitLossPrice.multiply(BigDecimal.ONE.add(tradeSetting.getProfitParam()));
                            }
                        }
                        //回报率
                        BigDecimal returnRate = profitLossPrice.divide((order.getPrePaymentAmount().subtract(contractOrderEntity.getClosingFeeAmount())), 8, BigDecimal.ROUND_DOWN);
                        BigDecimal returnRate = profitLossPrice.divide((order.getBondAmount().subtract(contractOrderEntity.getOpeningFeeAmount())), 8, BigDecimal.ROUND_DOWN);
                        contractOrderEntity.setRewardAmount(profitLossPrice);
                        contractOrderEntity.setRewardRatio(returnRate);
                        contractOrderEntity.setClosingFeeAmount(order.getOpeningFeeAmount());
                        contractOrderEntity.setClosingPrice(closePrice);
                        contractOrderEntity.setOrderType(ContractOrderEntity.ORDER_TYPE_CLOSE_MORE);
                        contractOrderEntity.setClosingType(8);
                        BigDecimal totalReturn = BigDecimal.ZERO;
                        contractOrderService.save(contractOrderEntity);

                        contractHoldOrderService.removeById(order.getId());
                        // 将需要退回的减去手续费
                        BigDecimal needReturn = prePrice.add(profitLossPrice);
                        //总退回金额=保证金+收益-手续费
@@ -367,12 +445,18 @@
                        // 更新钱包
                        // 总的是收益-平仓手续费
                        BigDecimal totalBalance = profitLossPrice.subtract(contractOrderEntity.getClosingFeeAmount());
                        memberWalletContractService.increaseWalletContractBalanceById(totalBalance, totalReturn, null, wallet.getId());

                        memberWalletContractService.increaseWalletContractBalanceById(totalReturn, totalBalance, null, wallet.getId());

                        insertAccountFlow(order, wallet, profitLossPrice, "开多止损平仓");

                        //返佣
                        calYj(order.getMemberId(), order.getOpeningFeeAmount(), contractOrderEntity, 2);
                        ThreadPoolUtils.calReturnMoney(order.getMemberId(), order.getOpeningFeeAmount(), contractOrderEntity, AgentReturnEntity.ORDER_TYPE_CLOSE);

                        // 全仓模式，止盈/止损 删除委托平仓
                        if (ContractEntrustOrderEntity.POSITION_TYPE_ALL == order.getPositionType()) {
                            deleteEntrustCloseOrder(order.getOrderNo());
                        }
                    }
                }
            }
@@ -384,6 +468,7 @@
     *
     * @param
     */
    @Transactional(rollbackFor = Exception.class)
    public void dealForLessLoss(List<ContractHoldOrderEntity> orderList, List<OrderModel> list) {
        // List<CoinsCoinsOrder> orderList = orderMapper.selectOrderByBatchNo(batchno);
        //System.out.println("开空止损批次号batchno：" + batchno);
@@ -411,8 +496,13 @@
                    String symbol = order.getSymbol();
                    Long memberId = order.getMemberId();
                    // 本次需要退回的预付款
                    BigDecimal prePrice = order.getPrePaymentAmount();
                    MemberWalletContractEntity wallet = memberWalletContractService.findWalletContractByMemberIdAndSymbol(memberId, "USDT");
                    BigDecimal prePrice = order.getBondAmount();
                    MemberWalletContractEntity wallet;
                    if (order.getPositionType() == ContractEntrustOrderEntity.POSITION_TYPE_ADD) {
                        wallet = memberWalletContractService.findWalletContractByMemberIdAndSymbol(memberId, "USDT");
                    } else {
                        wallet = memberWalletContractService.findWalletContractByMemberIdAndSymbol(memberId, CoinTypeConvert.convertContractTypeToCoin(order.getSymbol()));
                    }

                    if (wallet != null) {
                        // 历史订单
@@ -435,18 +525,22 @@
                            if (profitLossPrice.compareTo(BigDecimal.ZERO) > 0) {
                                profitLossPrice = profitLossPrice.multiply(BigDecimal.ONE.subtract(tradeSetting.getProfitParam()));
                            } else {
                                profitLossPrice = profitLossPrice.multiply(BigDecimal.ONE.add(tradeSetting.getProfitParam()));
//                                profitLossPrice = profitLossPrice.multiply(BigDecimal.ONE.add(tradeSetting.getProfitParam()));
                            }
                        }
                        //回报率
                        BigDecimal returnRate = profitLossPrice.divide((order.getPrePaymentAmount().subtract(contractOrderEntity.getClosingFeeAmount())), 8, BigDecimal.ROUND_DOWN);
                        BigDecimal returnRate = profitLossPrice.divide((order.getBondAmount().subtract(contractOrderEntity.getOpeningFeeAmount())), 8, BigDecimal.ROUND_DOWN);
                        contractOrderEntity.setRewardAmount(profitLossPrice);
                        contractOrderEntity.setRewardRatio(returnRate);
                        contractOrderEntity.setClosingFeeAmount(order.getOpeningFeeAmount());
                        contractOrderEntity.setClosingPrice(closePrice);
                        contractOrderEntity.setClosingType(9);
                        contractOrderEntity.setOrderType(ContractOrderEntity.ORDER_TYPE_CLOSE_LESS);
                        BigDecimal totalReturn = BigDecimal.ZERO;
                        contractOrderService.save(contractOrderEntity);

                        contractHoldOrderService.removeById(order.getId());

                        // 将需要退回的减去手续费
                        BigDecimal needReturn = prePrice.add(profitLossPrice);
                        //总退回金额=保证金+收益-手续费
@@ -454,13 +548,17 @@
                        // 更新钱包
                        // 总的是收益-平仓手续费
                        BigDecimal totalBalance = profitLossPrice.subtract(contractOrderEntity.getClosingFeeAmount());
                        memberWalletContractService.increaseWalletContractBalanceById(totalBalance, totalReturn, null, wallet.getId());
                        memberWalletContractService.increaseWalletContractBalanceById(totalReturn, totalBalance, null, wallet.getId());

                        insertAccountFlow(order, wallet, profitLossPrice, "开空止损平仓");

                        //返佣
                        calYj(order.getMemberId(), order.getOpeningFeeAmount(), contractOrderEntity, 2);
                        ThreadPoolUtils.calReturnMoney(order.getMemberId(), order.getOpeningFeeAmount(), contractOrderEntity, AgentReturnEntity.ORDER_TYPE_CLOSE);

                        // 全仓模式，止盈/止损 删除委托平仓
                        if (ContractEntrustOrderEntity.POSITION_TYPE_ALL == order.getPositionType()) {
                            deleteEntrustCloseOrder(order.getOrderNo());
                        }
                    }
                }
            }
@@ -486,33 +584,36 @@
     * @param
     */
    public void dealLimitBuyOrder(List<ContractEntrustOrderEntity> orderList) {

        //List<CoinsCoinsOrder> orderList = orderMapper.selectOrderByBatchNo(batchno);
        if (CollectionUtils.isNotEmpty(orderList)) {
            ContractHoldOrderEntity contractHoldOrderEntity = null;
            for (ContractEntrustOrderEntity coinsCoinsOrder : orderList) {
                // 全仓委托
                if (coinsCoinsOrder.getPositionType() == ContractEntrustOrderEntity.POSITION_TYPE_ALL) {
                    wholeEntrustOrder(coinsCoinsOrder);
                    continue;
                }

                MemberWalletContractEntity wallet = memberWalletContractService.findWalletContractByMemberIdAndSymbol(coinsCoinsOrder.getMemberId(), "USDT");
                if (wallet == null) {
                    continue;
                }

                contractHoldOrderEntity = new ContractHoldOrderEntity();
                // 委托单bean转换为持仓单bean
                contractHoldOrderEntity = ContractEntrustOrderEntityMapper.INSTANCE.entrustOrderToHoldOrder(coinsCoinsOrder);
                contractHoldOrderEntity.setId(null);
                Long memId = coinsCoinsOrder.getMemberId();
                MemberEntity memberEntity = memberService.getById(memId);
                BigDecimal entrustPrice = coinsCoinsOrder.getEntrustPrice();
                int symbolCnt = coinsCoinsOrder.getSymbolCnt();
                int type = coinsCoinsOrder.getEntrustType();
                //开仓价
                // Double openPrice = coinsCoinsOrder.getOpenPrice().doubleValue();
                //委托价
                // Double markPrice = coinsCoinsOrder.getMarkPrice();

                if (type == 1) {
                    // 开多
                    contractHoldOrderEntity.setOpeningType(ContractHoldOrderEntity.OPENING_TYPE_MORE);
                } else {
                    // 开空
                    contractHoldOrderEntity.setOpeningType(ContractHoldOrderEntity.OPENING_TYPE_LESS);

                }

                //持仓单赋值
@@ -534,38 +635,146 @@
                contractHoldOrderEntity.setForceClosingPrice(forceSetPrice);
                contractHoldOrderEntity.setLeverRatio(coinsCoinsOrder.getLeverRatio());
                contractHoldOrderEntity.setOpeningPrice(entrustPrice);
                contractHoldOrderEntity.setTradeType(ContractHoldOrderEntity.TRADE_TYPE_LIMIT);
                contractHoldOrderEntity.setOperateNo(1);
                contractHoldOrderService.save(contractHoldOrderEntity);

                // 需要一个历史插入
                ContractOrderEntity contractOrderEntity = ContractHoldOrderEntityMapper.INSTANCE.holdOrderToOrder(contractHoldOrderEntity);
                contractOrderEntity.setEntrustOpeningPrice(coinsCoinsOrder.getEntrustPrice());
                contractOrderEntity.setEntrustTime(coinsCoinsOrder.getCreateTime());
                contractOrderEntity.setOpeningTime(new Date());

                contractOrderEntity.setId(null);
                contractOrderService.save(contractOrderEntity);
                // 发送爆仓的队列
                // 市价
                if (coinsCoinsOrder.getEntrustType() == 1) {
                    // 开多
                    OrderModel model = new OrderModel(contractHoldOrderEntity.getId(), 6, contractHoldOrderEntity.getForceClosingPrice().setScale(8, RoundingMode.HALF_UP).toPlainString(), coinsCoinsOrder.getSymbol(), 1);
                    OrderModel model = new OrderModel(contractHoldOrderEntity.getId(), 6, contractHoldOrderEntity.getForceClosingPrice().setScale(8, RoundingMode.HALF_UP).toPlainString(), coinsCoinsOrder.getSymbol(), 1, coinsCoinsOrder.getMemberId());
                    producer.sendPriceOperate(JSONObject.toJSONString(model));
                } else {
                    // 开空
                    OrderModel model = new OrderModel(contractHoldOrderEntity.getId(), 7, contractHoldOrderEntity.getForceClosingPrice().setScale(8, RoundingMode.HALF_UP).toPlainString(), coinsCoinsOrder.getSymbol(), 1);
                    OrderModel model = new OrderModel(contractHoldOrderEntity.getId(), 7, contractHoldOrderEntity.getForceClosingPrice().setScale(8, RoundingMode.HALF_UP).toPlainString(), coinsCoinsOrder.getSymbol(), 1, coinsCoinsOrder.getMemberId());
                    producer.sendPriceOperate(JSONObject.toJSONString(model));
                }
                // 扣除手续费
                //double totalBalance = wallet.getTotalBalance() - coinsCoinsOrder.getClosingPrice();
                BigDecimal totalBalance = openFeePrice.negate();
                contractEntrustOrderService.removeById(coinsCoinsOrder.getId());
                memberWalletContractService.increaseWalletContractBalanceById(null, totalBalance, coinsCoinsOrder.getBondAmount().negate(), wallet.getId());

                /** TradeSetting tradeSetting = tradeSettingCache.getTradeSetting();

                 Double totalPayPrice = new BigDecimal(coinsCoinsOrder.getPrePrice()).add(new BigDecimal(coinsCoinsOrder.getClosingPrice())).add(new BigDecimal(coinsCoinsOrder.getClosingPrice()))
                 .setScale(8, BigDecimal.ROUND_HALF_UP).doubleValue();
                 totalBalance =  totalBalance+(-totalPayPrice*(Double.valueOf(tradeSetting.getSpread())/10000));*/

                memberWalletContractService.increaseWalletContractBalanceById(null, totalBalance, null, wallet.getId());
                // TODO 531 待写
                calYj(memId, contractOrderEntity.getClosingFeeAmount(), contractOrderEntity, 1);
                //返佣
                ThreadPoolUtils.calReturnMoney(memberEntity.getId(), openFeePrice, contractOrderEntity, AgentReturnEntity.ORDER_TYPE_OPEN);
            }
        }
    }

    private void wholeEntrustOrder(ContractEntrustOrderEntity entrustOrder) {
        log.info("全仓委托逻辑处理:{}", entrustOrder.getOrderNo());

        int i = 1;
        while (true) {
            List<Object> types = redisUtils.lGet(AppContants.MEMBER_TYPE + entrustOrder.getMemberId(), 0, -1);
            if (CollUtil.isEmpty(types)) {
                break;
            }
            log.info("存在止盈/止损/爆仓/委托平仓，等待 -- {}", i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            i++;
        }
        MemberWalletContractEntity wallet = memberWalletContractService.findWalletContractByMemberIdAndSymbol(entrustOrder.getMemberId(), CoinTypeConvert.convertContractTypeToCoin(entrustOrder.getSymbol()));

        PlatformTradeSettingEntity tradeSettingEntity = cacheSettingUtils.getTradeSetting();
        MemberEntity member = memberService.getById(entrustOrder.getMemberId());

        // 手续费
        BigDecimal openFeePrice = CalculateUtil.getOpenFeePrice(entrustOrder.getEntrustPrice(), entrustOrder.getSymbolSku(), entrustOrder.getSymbolCnt(), tradeSettingEntity.getFeeRatio());

        ContractHoldOrderEntity wholeHoldOrder = contractHoldOrderDao.selectWholeHoldOrderByOrderType(entrustOrder.getMemberId(), entrustOrder.getEntrustType(), entrustOrder.getSymbol());
        // 判断持仓是否存在，若不存在则创建新的持仓订单
        if (wholeHoldOrder == null) {
            log.info("持仓不存在");
            ContractHoldOrderEntity holdOrderEntity = ContractEntrustOrderEntityMapper.INSTANCE.entrustOrderToHoldOrder(entrustOrder);

            int type = entrustOrder.getEntrustType();
            if (type == 1) {
                // 开多
                holdOrderEntity.setOpeningType(ContractHoldOrderEntity.OPENING_TYPE_MORE);
            } else {
                // 开空
                holdOrderEntity.setOpeningType(ContractHoldOrderEntity.OPENING_TYPE_LESS);
            }

            holdOrderEntity.setTradeType(ContractHoldOrderEntity.TRADE_TYPE_LIMIT);
            holdOrderEntity.setSymbolCntSale(holdOrderEntity.getSymbolCnt());
            holdOrderEntity.setOpeningFeeAmount(openFeePrice);
            holdOrderEntity.setOpeningPrice(entrustOrder.getEntrustPrice());
            holdOrderEntity.setMarkPrice(entrustOrder.getEntrustPrice());
            holdOrderEntity.setIsCanClosing(ContractHoldOrderEntity.ORDER_CAN_CLOSING_N);
            holdOrderEntity.setOperateNo(1);
            // 设置合约类型
            holdOrderEntity.setContractType(ContractOrderEntity.CONTRACTTYPE_NORMAL);

            ContractOrderEntity contractOrderEntity = ContractHoldOrderEntityMapper.INSTANCE.holdOrderToOrder(holdOrderEntity);
            contractOrderEntity.setOpeningTime(new Date());
            contractHoldOrderDao.insert(holdOrderEntity);

            boolean isSuccess = contractOrderService.save(contractOrderEntity);

            if (isSuccess) {
                contractEntrustOrderService.removeById(entrustOrder.getId());
                memberWalletContractService.increaseWalletContractBalanceById(null, openFeePrice.negate(), entrustOrder.getBondAmount().negate(), wallet.getId());

                // 发送强平价
                ThreadPoolUtils.sendWholeForceClosingPrice(entrustOrder.getSymbol(), member);

                //返佣
                ThreadPoolUtils.calReturnMoney(member.getId(), openFeePrice, contractOrderEntity, AgentReturnEntity.ORDER_TYPE_OPEN);
            }

            return;
        }

        log.info("持仓存在");
        ContractOrderEntity contractOrderEntity = ContractHoldOrderEntityMapper.INSTANCE.holdOrderToOrder(wholeHoldOrder);
        contractOrderEntity.setBondAmount(entrustOrder.getBondAmount().add(openFeePrice));
        contractOrderEntity.setOpeningPrice(entrustOrder.getEntrustPrice());
        contractOrderEntity.setSymbolCnt(entrustOrder.getSymbolCnt());
        contractOrderEntity.setOpeningTime(new Date());
        contractOrderEntity.setMarkPrice(entrustOrder.getEntrustPrice());
        contractOrderEntity.setOpeningFeeAmount(openFeePrice);
        contractOrderService.save(contractOrderEntity);

        BigDecimal totalPrice = entrustOrder.getEntrustPrice().multiply(BigDecimal.valueOf(entrustOrder.getSymbolCnt()));
        BigDecimal newOpenPrice = totalPrice.add(wholeHoldOrder.getOpeningPrice().multiply(BigDecimal.valueOf(wholeHoldOrder.getSymbolCnt()))).divide(BigDecimal.valueOf(entrustOrder.getSymbolCnt() + wholeHoldOrder.getSymbolCntSale()), 8, BigDecimal.ROUND_DOWN);
        // 保证金
        BigDecimal bondAmount = entrustOrder.getBondAmount();
        // 手续费
        BigDecimal fee = CalculateUtil.getOpenFeePrice(entrustOrder.getEntrustPrice(), entrustOrder.getSymbolSku(), entrustOrder.getSymbolCnt(), tradeSettingEntity.getFeeRatio());
        // 预付款
        BigDecimal prePaymentAmount = wholeHoldOrder.getPrePaymentAmount().add(entrustOrder.getEntrustAmount());

        wholeHoldOrder.setSymbolCnt(wholeHoldOrder.getSymbolCnt() + entrustOrder.getSymbolCnt());
        wholeHoldOrder.setSymbolCntSale(wholeHoldOrder.getSymbolCntSale() + entrustOrder.getSymbolCnt());
        wholeHoldOrder.setOpeningFeeAmount(wholeHoldOrder.getOpeningFeeAmount().add(fee));
        wholeHoldOrder.setOpeningPrice(newOpenPrice);
        wholeHoldOrder.setBondAmount(wholeHoldOrder.getBondAmount().add(bondAmount));
        wholeHoldOrder.setPrePaymentAmount(prePaymentAmount);
        wholeHoldOrder.setOperateNo(wholeHoldOrder.getOperateNo() + 1);
        contractHoldOrderService.updateById(wholeHoldOrder);

        contractEntrustOrderService.removeById(entrustOrder.getId());
        memberWalletContractService.increaseWalletContractBalanceById(null, openFeePrice.negate(), entrustOrder.getBondAmount().negate(), wallet.getId());

        // 发送强平价
        ThreadPoolUtils.sendWholeForceClosingPrice(entrustOrder.getSymbol(), member);

        //返佣
        ThreadPoolUtils.calReturnMoney(member.getId(), openFeePrice, contractOrderEntity, AgentReturnEntity.ORDER_TYPE_OPEN);
    }

    /**
@@ -574,16 +783,17 @@
     * @param
     */
    public void dealCoinOut(List<ContractHoldOrderEntity> orderList, List<OrderModel> orderModels) {
        // 需要比较查询到的和消息发来的单的爆仓操作次序号是否相同
        // 构建map

        if (CollectionUtils.isNotEmpty(orderList)) {
            Map<Long, Integer> modelMap = new HashMap<Long, Integer>();
            for (OrderModel model : orderModels) {
                modelMap.put(model.getOrderId(), model.getOperateNo());
            }
            // TradeSetting tradeSetting = tradeMapper.findTradeSetting();
            for (ContractHoldOrderEntity coinsOrder : orderList) {
                List<Object> types = redisUtils.lGet(AppContants.RABBIT_TYPE + coinsOrder.getId(), 0, -1);
                if(types.contains(9) || types.contains(10) || types.contains(11) || types.contains(12)) {
                    log.info("存在止盈/止损 orderId : {}, types : {}", coinsOrder.getId(), JSONObject.toJSONString(types));
                    continue;
                }
                Long orderId = coinsOrder.getId();
                Integer operateNo = coinsOrder.getOperateNo();
                //判断当前订单是否是最新的爆仓价 不相等时直接进入下一个订单
@@ -592,81 +802,127 @@
                    contractHoldOrderService.updateOrderIsCanClosingAndBatchNoById(orderId);
                    continue;
                }
                boolean isDone = false;
                Long memId = coinsOrder.getMemberId();
                MemberEntity byId = memberService.getById(memId);
                String symbol = coinsOrder.getSymbol();
                //TradeSymbolSku symbolSku = tradeMapper.findSymbolSkubySymbol(symbol);
                BigDecimal nowPrice = coinsOrder.getForceClosingPrice();
                // 创建订单(加入历史表的订单)
                ContractOrderEntity contractOrderEntity = ContractHoldOrderEntityMapper.INSTANCE.holdOrderToOrder(coinsOrder);

                //查询是否满足爆仓条件
                if (coinsOrder.getOpeningType() == ContractHoldOrderEntity.OPENING_TYPE_MORE) {
                    //如果是开多,当前价小于预估强平价即为爆仓
                    // 设置平仓类型 // 爆仓平多
                    contractOrderEntity.setClosingType(4);
                    //更新用户钱包数据
                    isDone = true;
                if (ContractEntrustOrderEntity.POSITION_TYPE_ADD == coinsOrder.getPositionType()) {
                    bombOrder(coinsOrder);
                } else {
                    //如果是开空，当前价大于预估强平价即为爆仓
                    contractOrderEntity.setClosingType(5);
                    //更新主表订单状态位为“已平仓”
                    isDone = true;
                    List<ContractHoldOrderEntity> holdOrderEntities = contractHoldOrderDao.selectHoldOrderListForWholeByMemberIdAndSymbol(coinsOrder.getMemberId(), coinsOrder.getSymbol());
                    if (CollectionUtils.isNotEmpty(holdOrderEntities)) {
                        for (ContractHoldOrderEntity holdOrderEntity : holdOrderEntities) {
                            bombOrder(holdOrderEntity);
                        }

                        MemberWalletContractEntity wallet = memberWalletContractService.findWalletContractByMemberIdAndSymbol(coinsOrder.getMemberId(), CoinTypeConvert.convertContractTypeToCoin(coinsOrder.getSymbol()));

                        // 流水记录 TODO
                        MemberAccountFlowEntity record = new MemberAccountFlowEntity();
                        record.setCreateTime(new Date());
                        record.setSource("系统自动平仓");
                        record.setRemark("系统自动平仓");
                        record.setBalance(BigDecimal.ZERO);
                        record.setMemberId(coinsOrder.getMemberId());
                        record.setSymbol(coinsOrder.getSymbol());
                        record.setPrice(wallet.getTotalBalance().subtract(coinsOrder.getOpeningFeeAmount()));
                        memberAccountFlowEntityDao.insert(record);
                    }
                }
                if (isDone) {
                    //删除次仓订单
                    contractHoldOrderService.removeById(orderId);

                    //系统自动平仓（爆仓）
//                    Double closingPrice = nowPrice
//                            .multiply(new BigDecimal(tradeSetting.getClosingRatio()).divide(new BigDecimal(100), 8, BigDecimal.ROUND_DOWN))
//                            .multiply(symbolSku.getLotNumber())// 规格
//                            .multiply(new BigDecimal(coinsOrder.getSymbolSkuNumber()))
//                            .setScale(8, BigDecimal.ROUND_DOWN).doubleValue();
                    //更新主表订单状态位为“已平仓”
                    contractOrderEntity.setId(null);
                    contractOrderEntity.setClosingPrice(BigDecimal.ZERO);
                    //order.setPayTotalPrice(coinsOrder.getPrePrice()+coinsOrder.getClosingPrice());// 总支付金额(预付款)

                    contractOrderEntity.setClosingPrice(nowPrice);
                    contractOrderEntity.setClosingTime(new Date());
                    contractOrderEntity.setRewardAmount((coinsOrder.getOpeningFeeAmount().multiply(new BigDecimal("2")).subtract(coinsOrder.getPrePaymentAmount())));
                    //order.setRewardRatio(-(coinsOrder.getPrePrice() - (2*coinsOrder.getClosingPrice())));
                    contractOrderService.save(contractOrderEntity);

                    //更新用户钱包数据
                    MemberWalletContractEntity usdt = memberWalletContractService.findWalletContractByMemberIdAndSymbol(memId, "USDT");

                    // Double totalPrice = wallet.getTotalBalance() - coinsOrder.getPrePrice();
                    // 减去的时候用负数
                    BigDecimal totalPrice = coinsOrder.getPrePaymentAmount().negate();
                    //Double totalPrice = - coinsOrder.getPrePrice();
                    memberWalletContractService.increaseWalletContractBalanceById(null, totalPrice, null, usdt.getId());
                    // 流水记录 TODO
                    MemberAccountFlowEntity record = new MemberAccountFlowEntity();
                    record.setCreateTime(new Date());
                    record.setSource("系统自动平仓");
                    record.setRemark("系统自动平仓");
                    record.setBalance(usdt.getAvailableBalance());
                    record.setMemberId(memId);
                    record.setSymbol(coinsOrder.getSymbol());
                    record.setPrice(coinsOrder.getPrePaymentAmount());
                    memberAccountFlowEntityDao.insert(record);
                }
            }
        }
    }

    private void bombOrder(ContractHoldOrderEntity coinsOrder) {
        Long orderId = coinsOrder.getId();
        boolean isDone = false;
        Long memId = coinsOrder.getMemberId();
        BigDecimal nowPrice = coinsOrder.getForceClosingPrice();
        // 创建订单(加入历史表的订单)
        ContractOrderEntity contractOrderEntity = ContractHoldOrderEntityMapper.INSTANCE.holdOrderToOrder(coinsOrder);

        //查询是否满足爆仓条件
        if (coinsOrder.getOpeningType() == ContractHoldOrderEntity.OPENING_TYPE_MORE) {
            //如果是开多,当前价小于预估强平价即为爆仓
            // 设置平仓类型 // 爆仓平多
            contractOrderEntity.setClosingType(4);
            //更新用户钱包数据
            isDone = true;
        } else {
            //如果是开空，当前价大于预估强平价即为爆仓
            contractOrderEntity.setClosingType(5);
            //更新主表订单状态位为“已平仓”
            isDone = true;

        }
        if (isDone) {
            //删除次仓订单
            contractHoldOrderService.removeById(orderId);
            // 订单状态转换
            if (ContractOrderEntity.ORDER_TYPE_OPEN_MORE == contractOrderEntity.getOrderType()) {
                contractOrderEntity.setOrderType(ContractOrderEntity.ORDER_TYPE_CLOSE_MORE);
            } else {
                contractOrderEntity.setOrderType(ContractOrderEntity.ORDER_TYPE_CLOSE_LESS);
            }
            //更新主表订单状态位为“已平仓”
            contractOrderEntity.setId(null);
            contractOrderEntity.setClosingPrice(nowPrice);
            contractOrderEntity.setClosingTime(new Date());
            contractOrderEntity.setClosingFeeAmount(coinsOrder.getOpeningFeeAmount());

            if (coinsOrder.getPositionType() == ContractEntrustOrderEntity.POSITION_TYPE_ADD) {
                contractOrderEntity.setRewardAmount(coinsOrder.getBondAmount().subtract(contractOrderEntity.getOpeningFeeAmount()).negate());
                contractOrderService.save(contractOrderEntity);

                //更新用户钱包数据
                MemberWalletContractEntity usdt = memberWalletContractService.findWalletContractByMemberIdAndSymbol(memId, "USDT");

                // 减去的时候用负数
                BigDecimal totalPrice = coinsOrder.getBondAmount().negate();
                memberWalletContractService.increaseWalletContractBalanceById(null, totalPrice, null, usdt.getId());

                // 流水记录 TODO
                MemberAccountFlowEntity record = new MemberAccountFlowEntity();
                record.setCreateTime(new Date());
                record.setSource("系统自动平仓");
                record.setRemark("系统自动平仓");
                record.setBalance(usdt.getAvailableBalance());
                record.setMemberId(memId);
                record.setSymbol(coinsOrder.getSymbol());
                record.setPrice(coinsOrder.getBondAmount());
                memberAccountFlowEntityDao.insert(record);
            } else {
                MemberWalletContractEntity wallet = memberWalletContractService.findWalletContractByMemberIdAndSymbol(memId, CoinTypeConvert.convertContractTypeToCoin(coinsOrder.getSymbol()));

                BigDecimal rewardRatio = BigDecimal.ZERO;
                // 开多
                if (ContractHoldOrderEntity.OPENING_TYPE_MORE == coinsOrder.getOpeningType()) {
                    // (最新价-开仓价)*规格*张数
                    rewardRatio = nowPrice.subtract(coinsOrder.getOpeningPrice()).multiply(coinsOrder.getSymbolSku()).multiply(new BigDecimal(coinsOrder.getSymbolCntSale()));
                    // 开空
                } else {
                    // (开仓价-最新价)*规格*张数
                    rewardRatio = coinsOrder.getOpeningPrice().subtract(nowPrice).multiply(coinsOrder.getSymbolSku()).multiply(new BigDecimal(coinsOrder.getSymbolCntSale()));
                }

                contractOrderEntity.setRewardAmount(rewardRatio);
                contractOrderService.save(contractOrderEntity);

                memberWalletContractService.increaseWalletContractBalanceById(wallet.getAvailableBalance().negate(), wallet.getTotalBalance().negate(), null, wallet.getId());
            }
        }
    }

    public void calYj(Long mid, BigDecimal money, ContractOrderEntity order, int type) {
        PlatformTradeSettingEntity tradeSetting = cacheSettingUtils.getTradeSetting();
        if (money != null) {
            money = money.multiply(new BigDecimal(0.7868));
            money = money.multiply(tradeSetting.getFeeSpreadRatio());
        }
        MemberEntity member = memberService.getById(mid);
        String[] referenceIds = member.getRefererIds().split(",");
        List<String> ids = Arrays.asList(referenceIds);

        if (MemberEntity.ACCOUNT_TYPE_TEST.equals(member.getAccountType())) {
            return;
        }

        // 判断该用户是否为代理商
        NeedMoneyMemberVo needMoneyMember = memberService.selectFriendRelationUserByMemberId(mid);
@@ -692,24 +948,28 @@


        // 存放uid以及对应uid用户的佣金
        Map<String, BigDecimal> map = new HashMap<>();
        Map<String, Map<String, BigDecimal>> map = new HashMap<>();
        Iterator<Map.Entry<Integer, NeedMoneyMemberVo>> it = treeMap.entrySet().iterator();
        BigDecimal lastRate = BigDecimal.ZERO;
        BigDecimal lastYj = BigDecimal.ZERO;
        while (it.hasNext()) {
            Map.Entry<Integer, NeedMoneyMemberVo> entry = it.next();
            NeedMoneyMemberVo member1 = entry.getValue();
            Map<String, BigDecimal> returnValue = new HashMap<>();
            returnValue.put("ratio", member1.getReturnRatio());
            returnValue.put("lastRate", lastRate);
            // 上下级佣金比率相减后乘以手续费 -- 即用户所得佣金
            lastYj = (member1.getReturnRatio().subtract(lastRate)).multiply(money);
            lastRate = member1.getReturnRatio();
            map.put(member1.getInviteId(), lastYj);
            returnValue.put("returnMoney", lastYj);
            map.put(member1.getInviteId(), returnValue);
        }

        // 输出对应佣金是否正确
        Iterator<Map.Entry<String, BigDecimal>> it1 = map.entrySet().iterator();
        Iterator<Map.Entry<String, Map<String, BigDecimal>>> it1 = map.entrySet().iterator();
        List<AgentReturnEntity> agentList = new ArrayList<AgentReturnEntity>();
        while (it1.hasNext()) {
            Map.Entry<String, BigDecimal> entry = it1.next();
            Map.Entry<String, Map<String, BigDecimal>> entry = it1.next();
            // System.out.println(entry.getKey() + "-----" + entry.getValue());
            MemberEntity agentMember = memberService.selectMemberInfoByInviteId(entry.getKey());
            AgentReturnEntity agent = new AgentReturnEntity();
@@ -720,7 +980,9 @@
            agent.setOrderType(order.getOrderType());
            agent.setReturnSymbol(order.getSymbol());
            agent.setIsReturn(0);
            agent.setReturnAmount(entry.getValue());
            agent.setReturnAmount(entry.getValue().get("returnMoney"));
            agent.setChildReturnRatio(entry.getValue().get("lastRate"));
            agent.setReturnRatio(entry.getValue().get("ratio"));
            agent.setClosingType(order.getClosingType());
            if (type == 1) {//开仓
                agent.setOpeningFeeAmount(order.getOpeningFeeAmount());
@@ -732,8 +994,5 @@
            agent.setInviteId(entry.getKey());
            agentReturnDao.insert(agent);
        }


    }

}