20221130

xiaoyong931011

2022-12-01 503b82da73da3b872ac00393cbbf0b74febd73b9

 src/main/java/cc/mrbird/febs/dapp/service/impl/DappSystemServiceImpl.java

@@ -3,21 +3,27 @@
import cc.mrbird.febs.common.contants.AppContants;
import cc.mrbird.febs.common.utils.LoginUserUtil;
import cc.mrbird.febs.common.utils.RedisUtils;
import cc.mrbird.febs.common.utils.SpringContextUtil;
import cc.mrbird.febs.dapp.chain.ChainEnum;
import cc.mrbird.febs.dapp.chain.ChainService;
import cc.mrbird.febs.dapp.chain.ContractChainService;
import cc.mrbird.febs.dapp.dto.SystemDto;
import cc.mrbird.febs.dapp.dto.TransferDto;
import cc.mrbird.febs.dapp.entity.*;
import cc.mrbird.febs.dapp.enumerate.DataDictionaryEnum;
import cc.mrbird.febs.dapp.enumerate.LevelProfitEnum;
import cc.mrbird.febs.dapp.mapper.*;
import cc.mrbird.febs.dapp.service.DappSystemService;
import cc.mrbird.febs.dapp.utils.OnlineTransferUtil;
import cc.mrbird.febs.dapp.vo.RedisTransferPoolVo;
import cc.mrbird.febs.dapp.vo.SlipSettingVo;
import cc.mrbird.febs.dapp.service.DappWalletService;
import cc.mrbird.febs.rabbit.producer.ChainProducer;
import cc.mrbird.febs.tree.MatrixTree;
import cc.mrbird.febs.tree.MemberNode;
import cc.mrbird.febs.tree.TreeConstants;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.date.DateUnit;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
@@ -28,7 +34,7 @@
import java.util.*;

/**
 * @author 
 * @author
 * @date 2022-03-24
 **/
@Slf4j
@@ -37,261 +43,473 @@
public class DappSystemServiceImpl implements DappSystemService {

    private final DappSystemDao dappSystemDao;
    private final DappReturnRatioDao dappReturnRatioDao;
    private final RedisUtils redisUtils;
    private final DappFundFlowDao dappFundFlowDao;
    private final DappMemberDao dappMemberDao;

    private final DappAchieveTreeDao dappAchieveTreeDao;
    private final DappAchieveMemberTreeDao dappAchieveMemberTreeDao;
    private final DappWalletService dappWalletService;
    private final DataDictionaryCustomMapper dataDictionaryCustomMapper;
    private final DappOnlineTransferDao dappOnlineTransferDao;
    private final DappSystemProfitDao dappSystemProfitDao;
    private final ChainProducer chainProducer;

    private final String[] ADDRESS_PREFIX = {"T", "0x"};
    @Override
    public Map<String, Object> findTotalInComeAndList() {
        DappMineDataEntity dataMine = dappSystemDao.selectMineDataForOne();


        Map<String, Object> result = new HashMap<>();
        result.put("total", 6000);
        result.put("addreessCnt", 1234);
        result.put("coinCnt", 4000);
        return result;
    }

    @Override
    public Map<String, Object> globalSetting() {
        BigDecimal newPrice = (BigDecimal) redisUtils.get(AppContants.REDIS_KEY_ETH_NEW_PRICE);
        Integer changeFee = (Integer) redisUtils.get(AppContants.REDIS_KEY_CHANGE_FEE);

        List<DappReturnRatioEntity> ratios = dappReturnRatioDao.selectList(null);
        Map<String, Object> result = new HashMap<>();
        result.put("newPrice", newPrice);
        result.put("changeFee", changeFee);
        result.put("ratio", ratios);
        return result;
    }

    @Override
    public SystemDto system() {
        DappMemberEntity member = LoginUserUtil.getAppUser();

        SystemDto system = new SystemDto();
        String hasStart = redisUtils.getString(AppContants.SYSTEM_START_FLAG);
        // 启动未启动
        if (!"start".equals(hasStart)) {
            system.setFeeRatio(BigDecimal.TEN);
            system.setUsdtRemain(BigDecimal.ZERO);
            system.setUsdtTotal(BigDecimal.ZERO);
            system.setSaleRemain(BigDecimal.ZERO);
            system.setSaleTotal(BigDecimal.ZERO);
            Object makePoolObj = redisUtils.get(AppContants.REDIS_KEY_MAKE_POOL_CNT);
            BigDecimal balance;
            if (makePoolObj == null) {
                balance = ChainService.getInstance(ChainEnum.BSC_TFC_MAKE.name()).balanceOf(ChainEnum.BSC_TFC_MAKE.getAddress());
                redisUtils.set(AppContants.REDIS_KEY_MAKE_POOL_CNT, balance);
            } else {
                balance = (BigDecimal) makePoolObj;
            }
            system.setBuyRemain(balance);
            system.setBuyTotal(balance);

            return system;
        }

        RedisTransferPoolVo transferPool = (RedisTransferPoolVo) redisUtils.get(AppContants.REDIS_KEY_TRANSFER_POOL_VOL);
        BigDecimal poolRemain = (BigDecimal) redisUtils.get(AppContants.REDIS_KEY_TRANSFER_POOL_VOL_REMAIN);
        // 买币数量
        system.setBuyTotal(transferPool.getTodayVol());
        system.setBuyRemain(poolRemain);

        ContractChainService instance = ChainService.getInstance(ChainEnum.BSC_TFC.name());
        BigDecimal balance = instance.balanceOf(member.getAddress());
        Object o = redisUtils.get(AppContants.REDIS_KEY_COIN_REMAIN + member.getAddress());

        BigDecimal coinTotal = balance.multiply(BigDecimal.valueOf(0.3)).setScale(instance.decimals(), RoundingMode.HALF_DOWN);
        BigDecimal remain;
        if (o == null) {
            remain = coinTotal;
            redisUtils.set(AppContants.REDIS_KEY_COIN_REMAIN + member.getAddress(), remain);
        } else {
            remain = (BigDecimal) o;
        }
        // 卖币数量
        system.setSaleTotal(coinTotal);
        system.setSaleRemain(remain);

        BigDecimal usdtRemain = (BigDecimal) redisUtils.get(AppContants.REDIS_KEY_USDT_OUT_LIMIT_REMAIN);
        BigDecimal usdtTotal = (BigDecimal) redisUtils.get(AppContants.REDIS_KEY_USDT_OUT_LIMIT);

        // usdt数量
        system.setUsdtTotal(usdtTotal);
        system.setUsdtRemain(usdtRemain);

        system.setFeeRatio(BigDecimal.TEN);
        system.setBuyAmount(new BigDecimal("100"));
        return system;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void tradeProfitDistribute(Long id) {
        DappFundFlowEntity fundflow = dappFundFlowDao.selectById(id);
    public synchronized void achieveTree(Long memberId) {
        DappMemberEntity member = dappMemberDao.selectById(memberId);

        BigDecimal fee = fundflow.getFee();
        DappMemberEntity member = dappMemberDao.selectById(fundflow.getMemberId());

        if (StrUtil.isBlank(member.getRefererId()) || "0".equals(member.getRefererId())) {
            return;
        }
        List<String> inviteIds = StrUtil.split(member.getRefererId(), ',');
        List<DappMemberEntity> parents = dappMemberDao.selectParentsList(inviteIds, 6);

        DataDictionaryCustom miniHoldCoin = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(AppContants.DIC_TYPE_SYSTEM_SETTING, AppContants.DIC_VALUE_MINI_HOLD_COIN_LIMIT);
        DataDictionaryCustom slipPointSetting = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(AppContants.DIC_TYPE_SLIP_POINT_SETTING, AppContants.DIC_TYPE_SLIP_POINT_SETTING);
        SlipSettingVo slipSetting = JSONObject.parseObject(slipPointSetting.getValue(), SlipSettingVo.class);

        // 源池
        ContractChainService instance = ChainService.getInstance(ChainEnum.BSC_TFC_SOURCE.name());
        BigDecimal destroy = slipSetting.getDestroyPoint().divide(slipSetting.getAllPoint(), 2, RoundingMode.HALF_DOWN).multiply(fee);
        log.info("销毁数量:{}, 比例:{}", destroy, slipSetting.getDestroyPoint());

        // 销毁
//        instance.transfer(AppContants.DESTROY_ADDRESS, destroy);
        OnlineTransferUtil.addTransfer(AppContants.DESTROY_ADDRESS, destroy, fundflow.getType(), 3, ChainEnum.BSC_TFC_SOURCE.name(), AppContants.SYMBOL_COIN, fundflow.getId().toString());

        // 总分发金额
        BigDecimal distrbAmount = fee.subtract(destroy);
        // 技术金额
        BigDecimal techAmount = distrbAmount.multiply(slipSetting.getTechProp().divide(BigDecimal.valueOf(100), 2, RoundingMode.HALF_UP));
        // 节点金额
        BigDecimal nodeAmount = distrbAmount.subtract(techAmount);
        log.info("总分发金额:{}, 技术:{}, 节点:{}", distrbAmount, techAmount, nodeAmount);

        int i = 1;
        for (DappMemberEntity parent : parents) {
            BigDecimal balance = instance.balanceOf(parent.getAddress());
            log.info("地址:{}, 余额:{}", parent.getAddress(), balance);

            // 若地址持币少了指定数量
            if (balance.compareTo(new BigDecimal(miniHoldCoin.getValue())) < 0) {
                return;
            }

            DataDictionaryCustom distribDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(AppContants.DIC_TYPE_DISTRIBUTE_PROP, String.valueOf(i));
            BigDecimal total = distrbAmount.multiply(new BigDecimal(distribDic.getValue()).divide(BigDecimal.valueOf(100), 2, RoundingMode.HALF_UP));

            OnlineTransferUtil.addTransfer(parent.getAddress(), total, fundflow.getType(), 1, ChainEnum.BSC_TFC_SOURCE.name(), AppContants.SYMBOL_COIN, fundflow.getId().toString());

            nodeAmount = nodeAmount.subtract(total);
        }

        // 若节点金额还有剩余，则进入技术金额
        techAmount = techAmount.add(nodeAmount);
//        instance.transfer(ChainEnum.BSC_TFC_TECH.getAddress(), techAmount);

        OnlineTransferUtil.addTransfer(ChainEnum.BSC_TFC_TECH.getAddress(), techAmount, fundflow.getType(), 2, ChainEnum.BSC_TFC_SOURCE.name(), AppContants.SYMBOL_COIN, fundflow.getId().toString());

        Map<String, String> map = new HashMap<>();
        map.put("batchNo", fundflow.getId().toString());
        map.put("type", "flow");

        // 发送转账消息
        chainProducer.sendOnlineTransfer(JSONObject.toJSONString(map));
    }

    @Override
    public void mining() {
        log.info("挖矿");

        Object o = redisUtils.get(AppContants.REDIS_KEY_MINE_ALL_INTERNET_CNT);
        if (o == null) {
            return;
        }

        Object transferPoolObj = redisUtils.get(AppContants.REDIS_KEY_MINE_TRANSFER_POOL_TRADE_CNT);

        BigDecimal allInternet = (BigDecimal) o;
        BigDecimal transferPoll = (BigDecimal) transferPoolObj;

        List<DappMemberEntity> allMembers = dappMemberDao.selectList(null);
        if (CollUtil.isEmpty(allMembers)) {
            return;
        }
        DataDictionaryCustom miniHoldCoin = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(AppContants.DIC_TYPE_SYSTEM_SETTING, AppContants.DIC_VALUE_MINI_HOLD_COIN_LIMIT);

        String batchNo = RandomUtil.randomString(32);
        ContractChainService instance = ChainService.getInstance(ChainEnum.BSC_TFC.name());
        for (DappMemberEntity member : allMembers) {
            if ("admin".equals(member.getAccountType())) {
                continue;
            }

            BigDecimal balance = instance.balanceOf(member.getAddress());
            if (balance.compareTo(new BigDecimal(miniHoldCoin.getValue())) < 1) {
                continue;
            }

            // 挖矿数量
            BigDecimal mine = transferPoll.multiply(balance.divide(allInternet, instance.decimals(), RoundingMode.HALF_UP));
            if (mine.compareTo(BigDecimal.ZERO) < 1) {
                continue;
            }

            OnlineTransferUtil.addTransfer(member.getAddress(), mine, 3, 1, ChainEnum.BSC_TFC.name(), AppContants.SYMBOL_COIN, batchNo);
        }

        Map<String, String> map = new HashMap<>();
        map.put("batchNo", batchNo);
        map.put("type", "batch");

        // 发送转账消息
        chainProducer.sendOnlineTransfer(JSONObject.toJSONString(map));
    }

    @Override
    public void onlineTransfer(String str) {
        JSONObject jsonObject = JSONObject.parseObject(str);
        String batchNo = jsonObject.getString("batchNo");
        List<DappOnlineTransferEntity> transferList = dappOnlineTransferDao.selectByBatchNo(batchNo);

        if (CollUtil.isEmpty(transferList)) {
            return;
        }

        for (DappOnlineTransferEntity transfer : transferList) {
            if (transfer.getHasFinish() == 1) {
                continue;
            }

            // TODO 线上转账，已注释
            String txHash = ChainService.getInstance(transfer.getFromType()).transfer(transfer.getAddress(), transfer.getAmount());
            transfer.setTxHash(txHash);
            transfer.setHasFinish(1);
            transfer.setUpdateTime(new Date());
            dappOnlineTransferDao.updateById(transfer);

            if ("flow".equals(jsonObject.getString("type"))) {
                DappFundFlowEntity fundFlow = dappFundFlowDao.selectById(Long.parseLong(batchNo));

                fundFlow.setStatus(3);
                fundFlow.setToHash(txHash);

                dappFundFlowDao.updateById(fundFlow);
            }

            // 修改剩余量
            if (AppContants.SYMBOL_COIN.equals(transfer.getSymbol())) {

                BigDecimal poolRemain = (BigDecimal) redisUtils.get(AppContants.REDIS_KEY_TRANSFER_POOL_VOL_REMAIN);
                redisUtils.set(AppContants.REDIS_KEY_TRANSFER_POOL_VOL_REMAIN, poolRemain.subtract(transfer.getAmount()));
        int batchNo = 0;
        DappAchieveTreeEntity newestTreeNode = dappAchieveTreeDao.selectNewestTreeNode();
        if (newestTreeNode != null) {
            if (newestTreeNode.getValidState() == 2) {
                batchNo = newestTreeNode.getBatchNo() + 1;
            } else {

                BigDecimal usdtRemain = (BigDecimal) redisUtils.get(AppContants.REDIS_KEY_USDT_OUT_LIMIT_REMAIN);
                usdtRemain = usdtRemain.subtract(transfer.getAmount());
                if (usdtRemain.compareTo(BigDecimal.ZERO) < 0) {
                    usdtRemain = BigDecimal.ZERO;
                }
                redisUtils.set(AppContants.REDIS_KEY_USDT_OUT_LIMIT_REMAIN, usdtRemain);
                batchNo = newestTreeNode.getBatchNo();
            }
        }

        // 在大树中，插入当前节点
        DappAchieveTreeEntity achieveTree = new DappAchieveTreeEntity();
        achieveTree.setMidNode(memberId);
        achieveTree.setValidState(1);
        achieveTree.setBatchNo(batchNo);
        dappAchieveTreeDao.insert(achieveTree);

        // 在内存树(大树)中插入当前节点，并返回父节点
        MemberNode node = new MemberNode(member.getId(), member.getAddress(), member.getInviteId(), member.getRefererId());

        MatrixTree tree = MatrixTree.getInstance();
        MemberNode exist = tree.getNode(member.getId());
        if (exist != null) {
            return;
        }

        MemberNode parentNode = tree.addNode(node);

        // 创建该节点的矩阵
        DappAchieveMemberTreeEntity achieveMemberTree = new DappAchieveMemberTreeEntity();
        achieveMemberTree.setTreeNode(memberId);
        achieveMemberTree.setTopNode(memberId);
        achieveMemberTree.setDeep(1);
        achieveMemberTree.setHasMoney(1);
        if (parentNode != null) {
            achieveMemberTree.setParentNode(parentNode.getMemberId());
        }
        dappAchieveMemberTreeDao.insert(achieveMemberTree);

        // 激活用户状态
        member.setActiveStatus(1);
        dappMemberDao.updateById(member);

        putIntoProfit(memberId, 2);
        if (parentNode == null) {
            return;
        }

        // 修改父节点在数据库中的左/右节点数据
        DappAchieveTreeEntity treeMidNode = dappAchieveTreeDao.selectByMidNode(parentNode.getMemberId());
        boolean isLeft = false;
        if (parentNode.getLeft() != null && memberId.equals(parentNode.getLeft().getMemberId())) {
            treeMidNode.setLeftNode(memberId);
            isLeft = true;
        } else {
            treeMidNode.setRightNode(memberId);
        }
        dappAchieveTreeDao.updateById(treeMidNode);

        // 更新矩阵中的数据
        List<DappAchieveMemberTreeEntity> matrixNodes = dappAchieveMemberTreeDao.selectNotBottomNodeInMatrix(parentNode.getMemberId());
        for (DappAchieveMemberTreeEntity matrixNode : matrixNodes) {
            if (isLeft) {
                matrixNode.setLeftNode(memberId);
            } else {
                matrixNode.setRightNode(memberId);
            }

            dappAchieveMemberTreeDao.updateById(matrixNode);

            DappAchieveMemberTreeEntity newMatrixNode = new DappAchieveMemberTreeEntity();
            newMatrixNode.setTreeNode(memberId);
            newMatrixNode.setTopNode(matrixNode.getTopNode());
            newMatrixNode.setParentNode(parentNode.getMemberId());
            newMatrixNode.setHasMoney(1);
            newMatrixNode.setDeep(matrixNode.getDeep() + 1);
            dappAchieveMemberTreeDao.insert(newMatrixNode);

            if (matrixNode.getDeep() == 2) {
                finishMatrixTree(matrixNode.getTopNode());
            }
        }
    }

    // 完成矩阵树，并重置矩阵且重入
    public void finishMatrixTree(Long memberId) {
        List<DappAchieveMemberTreeEntity> matrixTree = dappAchieveMemberTreeDao.selectMatrixTreeByTopNode(memberId, 1);
        // 如果达到标准，则重置该矩阵树
        if (matrixTree.size() == 7) {
            dappAchieveMemberTreeDao.resetMatrixTree(memberId);
            dappAchieveMemberTreeDao.reentryMoney(memberId);

            putIntoProfit(memberId, 1);
            DappAchieveMemberTreeEntity bottomNode = dappAchieveMemberTreeDao.selectNodeByDeep(memberId, 3);
            if (bottomNode != null) {
                finishMatrixTree(bottomNode.getTopNode());
            }
        }
    }

    @Override
    public void putIntoProfit(Long memberId, int isReIn) {
        DappMemberEntity member = dappMemberDao.selectById(memberId);
        DappMemberEntity parent = dappMemberDao.selectMemberInfoByInviteId(member.getRefererId());

        if (parent != null) {
            BigDecimal directProfit = TreeConstants.PUT_IN_AMOUNT.multiply(new BigDecimal("0.1"));
            dappWalletService.updateWalletCoinWithLock(directProfit, parent.getId(), 1);

            DappFundFlowEntity fundFlow = new DappFundFlowEntity(parent.getId(), directProfit, 3, 2, null, null);
            dappFundFlowDao.insert(fundFlow);
        }

        // 如果是复投的，则需奖励
        if (isReIn == 1) {
            List<DappMemberEntity> directCnt = dappMemberDao.selectChildMemberDirectOrNot(member.getInviteId(), 1, 1);

            /**
             * 复投后，推一个拿一轮，推两个拿两轮，推三个后终身有效。
             * 200u单。
             * 无直推则收益200U
             * 一人加一轮400u，二人二轮
             * 三人永久。
             */
            if (directCnt.size() < 3 && member.getOutCnt() != 0 && member.getOutCnt() - 1 == directCnt.size()) {
                return;
            } else {
                BigDecimal amount = null;
                if (directCnt.size() < 1) {
                    amount = TreeConstants.PUT_IN_AMOUNT;
                } else {
                    amount = TreeConstants.FULL_PROFIT_AMOUNT;
                }

                member.setOutCnt(member.getOutCnt() + 1);
                dappMemberDao.updateById(member);

                dappWalletService.updateWalletCoinWithLock(amount, member.getId(), 1);

                DappFundFlowEntity matrixProfitFlow = new DappFundFlowEntity(memberId, amount, 2, 2, null, null);
                dappFundFlowDao.insert(matrixProfitFlow);
            }

            DappFundFlowEntity rePutInFlow = new DappFundFlowEntity(memberId, TreeConstants.PUT_IN_AMOUNT.negate(), 1, 2, null, null);
            dappFundFlowDao.insert(rePutInFlow);
        }
    }

    @Override
    public void tfcNewPrice(String data) {
//        redisUtils.set(AppContants.REDIS_KEY_TFC_NEW_PRICE, new BigDecimal(data));
    }

    @Override
    public void resetMatrix() {
        DappAchieveTreeEntity node = dappAchieveTreeDao.selectNewestTreeNode();
        if (node.getValidState() == 2) {
            return;
        }

        long days = DateUtil.between(node.getCreateTime(), new Date(), DateUnit.DAY);
        if (days < 7) {
            return;
        }
        DappMineDataEntity mineDataEntity = dappSystemDao.selectMineDataForOne();

        List<DappAchieveTreeEntity> list = dappAchieveTreeDao.selectLastCountTreeNode(500);
        if (CollUtil.isNotEmpty(list)) {
            BigDecimal preAmount = mineDataEntity.getSafePool().divide(new BigDecimal(list.size()), 2, RoundingMode.HALF_UP);

            list.forEach(item -> {
                dappWalletService.updateWalletCoinWithLock(preAmount, item.getMidNode(), 1);
                DappFundFlowEntity flow = new DappFundFlowEntity(item.getMidNode(), preAmount, 8, 2, null, null);
                dappFundFlowDao.insert(flow);
            });
        }

        mineDataEntity.setSafePool(BigDecimal.ZERO);
        dappSystemDao.updateMineData(mineDataEntity);

        dappAchieveTreeDao.updateNodeValidState();
        dappAchieveMemberTreeDao.emptyTable();
        dappMemberDao.updateMemberActive();
    }

    @Override
    public void feeDistribute(String data) {
        if (StrUtil.isBlank(data)) {
            return;
        }

        Long flowId = Long.parseLong(data);
        DappFundFlowEntity fundFlow = dappFundFlowDao.selectById(flowId);
        if (fundFlow == null) {
            return;
        }

        DataDictionaryCustom memberFeeDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(DataDictionaryEnum.MEMBER_FEE.getType(), DataDictionaryEnum.MEMBER_FEE.getCode());
        if (memberFeeDic == null) {
            log.info("未设置手续费返利比例");
            return;
        }
        List<DappMemberEntity> memberList = dappMemberDao.selectMemberListNeedProfit();
        if (CollUtil.isEmpty(memberList)) {
            return;
        }

        BigDecimal feeReturnRatio = new BigDecimal(memberFeeDic.getValue());
        int size = memberList.size();
        BigDecimal totalProfit = fundFlow.getFee().multiply(feeReturnRatio.divide(BigDecimal.valueOf(100), 2, RoundingMode.HALF_DOWN));
        BigDecimal perProfit = totalProfit.divide(BigDecimal.valueOf(size), 8, RoundingMode.HALF_DOWN);

        memberList.forEach(item -> {
            dappWalletService.updateWalletMineWithLock(perProfit, item.getId(), 1);

            DappFundFlowEntity profitFlow = new DappFundFlowEntity(item.getId(), perProfit, 12, 2, null, null);
            dappFundFlowDao.insert(profitFlow);
        });
    }

    @Override
    public void levelProfit(Long id) {
        DappSystemProfit dappSystemProfit = dappSystemProfitDao.selectById(id);
        if(ObjectUtil.isEmpty(dappSystemProfit)){
            return;
        }
        Integer levelProfitState = dappSystemProfit.getLevelProfit();

        if(DappSystemProfit.ENUM_YES == levelProfitState){
            return;
        }
        Long memberId = dappSystemProfit.getMemberId();
        //获取用户的上级用户信息
        DappMemberEntity dappMemberEntity = dappMemberDao.selectById(memberId);
        if(ObjectUtil.isEmpty(dappMemberEntity)){
            return;
        }
        String refererIds = dappMemberEntity.getRefererIds();
        if(StrUtil.isEmpty(refererIds)){
            return;
        }
        DataDictionaryCustom levelProfitSet = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(DataDictionaryEnum.LEVEL_PROFIT.getType(), DataDictionaryEnum.LEVEL_PROFIT.getCode());
        BigDecimal levelProfit = new BigDecimal(StrUtil.isEmpty(levelProfitSet.getValue()) ? "0.3" : levelProfitSet.getValue());
        //投入金额减去技术方收益
        DataDictionaryCustom systemProfitSet = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(DataDictionaryEnum.SYSTEM_PROFIT.getType(), DataDictionaryEnum.SYSTEM_PROFIT.getCode());
        BigDecimal systemProfit = new BigDecimal(StrUtil.isEmpty(systemProfitSet.getValue()) ? "0.05" : systemProfitSet.getValue());
        BigDecimal amount = dappSystemProfit.getAmount().subtract(systemProfit);
        //层级奖励总奖金
        BigDecimal levelProfitTotal = amount.multiply(levelProfit);
        //实发层级奖励 -- 如果还有剩余给技术方
        BigDecimal systemProfitTotal = BigDecimal.ZERO;
        //返回十层
        List<String> refererIdList = StrUtil.split(refererIds, ',');
        //i：计数层数，同时i也为对应层数应推广的人数，当达到对应的直推人数时，才能获取对应层级奖励
        if(CollUtil.isEmpty(refererIdList)){
            return;
        }
        //层级奖励最大循环次数
        int maxLevel = 10;
        if(maxLevel > refererIdList.size()){
            maxLevel = refererIdList.size();
        }
        for(int i = 0;i < maxLevel; i++){
            if(systemProfitTotal.compareTo(levelProfitTotal) < 0){
                String inviteId = refererIdList.get(i);
                //获取每层用户的直推人数，判断能否获得这个层级的层级奖励
                DappMemberEntity refererMember = dappMemberDao.selectMemberInfoByInviteId(inviteId);
                //获取直推用户数量
                QueryWrapper<DappMemberEntity> objectQueryWrapper = new QueryWrapper<>();
                objectQueryWrapper.eq("referer_id",refererMember.getInviteId());
                Integer selectCount = dappMemberDao.selectCount(objectQueryWrapper);
                if(i > selectCount){
                    continue;
                }
                //获取对应层级奖励
                BigDecimal profit = LevelProfitEnum.YI.getProfit(i+1);
                String accountType = refererMember.getAccountType();
                //根据会员的等级类型，获取对应的百分比收益
                DataDictionaryCustom memberLevelSet = dataDictionaryCustomMapper.selectDicDataByTypeAndCode("MEMBER_LEVEL", accountType);
                BigDecimal memberLevel = new BigDecimal(memberLevelSet.getValue());

                BigDecimal memberLevelProfit = levelProfitTotal.multiply(profit).multiply(memberLevel);

                DappFundFlowEntity fundFlow = new DappFundFlowEntity(refererMember.getId(), memberLevelProfit, 4, 1, BigDecimal.ZERO,null,dappSystemProfit.getId());
                dappFundFlowDao.insert(fundFlow);
                //发送转币消息
                chainProducer.sendBnbTransferMsg(fundFlow.getId());
                systemProfitTotal = systemProfitTotal.add(memberLevelProfit);
            }
        }
        //如果还有剩余给技术方
        if(levelProfitTotal.compareTo(systemProfitTotal) > 0){
            BigDecimal avaProfit = levelProfitTotal.subtract(systemProfitTotal);
            DappFundFlowEntity fundFlow = new DappFundFlowEntity(1L, avaProfit, 5, 1, BigDecimal.ZERO,null,dappSystemProfit.getId());
            dappFundFlowDao.insert(fundFlow);
            //发送转币消息
            chainProducer.sendBnbTransferMsg(fundFlow.getId());
        }

        dappSystemProfitDao.updateLevelProfitById(DappSystemProfit.ENUM_YES,dappSystemProfit.getId());
    }

    @Override
    public void memberOut(Long id) {
        //验证是否已经加入动能队列
        DappSystemProfit systemProfit = dappSystemProfitDao.selectById(id);
        if(ObjectUtil.isEmpty(systemProfit)){
            return;
        }
        //获取当前是第几轮队列
        String redisKey = "QUEUE_COUNT";
        String memberOutCount = redisUtils.getString(redisKey);
        DataDictionaryCustom queueCountSet = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(DataDictionaryEnum.QUEUE_COUNT.getType(), DataDictionaryEnum.QUEUE_COUNT.getCode());
        String queueCount = queueCountSet.getValue();
        if(StrUtil.isBlank(memberOutCount) || !queueCount.equals(memberOutCount)){
            redisUtils.set(redisKey,queueCount,0L);
            memberOutCount = queueCount;
        }
        //出局条件的人数
        /**
         * 初始大小 5+4*0
         * 1  1,2,3,4,5  1出局 5+4*0
         * 2  2,3,4,5,1(复投),7,8,9,10  2出局 5+4*1
         * 3  3,4,5,1(复投),7,8,9,10,2(复投),12,13,14,15 3出局 5+4*2
         * 4  4,5,1(复投),7,8,9,10,2(复投),12,13,14,15,3(复投),17,18,19,20  4出局 5+4*3
         */
        Integer memberCount = Integer.parseInt(memberOutCount) * 4 + 5;
        //判断当前是否符合出局条件
        QueryWrapper<DappSystemProfit> objectQueryWrapper = new QueryWrapper<>();
        objectQueryWrapper.eq("state",DappSystemProfit.STATE_IN);
        //实际投资人数
        Integer selectCount = dappSystemProfitDao.selectCount(objectQueryWrapper);
        //实际投资人数小于出局条件人数
        if(selectCount < memberCount){
            return;
        }
        //符合则出局 实际投资人数等于出局条件人数
        DappSystemProfit dappSystemProfit = dappSystemProfitDao.selectSystemProfitByState(DappSystemProfit.STATE_IN);
        if(ObjectUtil.isEmpty(dappSystemProfit)){
            return;
        }
        //符合则出局，轮数+1
        Integer realCount = (Integer.parseInt(queueCount) + 1);
        queueCountSet.setValue(realCount.toString());
        dataDictionaryCustomMapper.updateById(queueCountSet);
        redisUtils.set(redisKey,realCount,0L);

        DappSystemProfit dappSystemProfitNow = dappSystemProfitDao.selectByIdForUpdate(dappSystemProfit.getId(),DappSystemProfit.STATE_IN);
        dappSystemProfitDao.updateStateById(DappSystemProfit.STATE_OUT,dappSystemProfitNow.getId());

        //todo 直接拿走0.95ge

        DataDictionaryCustom investAmountProfitSet = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(DataDictionaryEnum.INVEST_AMOUNT_PROFIT.getType(), DataDictionaryEnum.INVEST_AMOUNT_PROFIT.getCode());
        BigDecimal investAmountProfit = new BigDecimal(investAmountProfitSet.getValue());
        DappFundFlowEntity fundFlowOut = new DappFundFlowEntity(dappSystemProfitNow.getMemberId(), investAmountProfit, 7, 1, BigDecimal.ZERO, null,dappSystemProfitNow.getId());
        dappFundFlowDao.insert(fundFlowOut);
        //发送转币消息
        chainProducer.sendBnbTransferMsg(fundFlowOut.getId());
        //复投 成功{type: 1, txHash: result.transactionHash, id: res.data, flag: 'success', buyType: 2}
        DataDictionaryCustom investAmountSet = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(DataDictionaryEnum.INVEST_AMOUNT.getType(), DataDictionaryEnum.INVEST_AMOUNT.getCode());
        BigDecimal investAmount = new BigDecimal(investAmountSet.getValue());
        //todo 直接运行转账
        String txHash = "复投";
        DappFundFlowEntity fundFlow = new DappFundFlowEntity(dappSystemProfitNow.getMemberId(), investAmount, 6, 1, BigDecimal.ZERO, txHash);
        dappFundFlowDao.insert(fundFlow);

        TransferDto transferDto = new TransferDto();
        transferDto.setType(1);
        transferDto.setTxHash(txHash);
        transferDto.setBuyType(2);
        transferDto.setId(fundFlow.getId());
        transferDto.setFlag("success");
        transferDto.setAmount(investAmount);
        transferDto.setMemberId(dappSystemProfitNow.getMemberId());
        dappWalletService.transferAgain(transferDto);
    }

    @Override
    public void bnbTransfer(Long id) {
        log.info("{}",id);
        //获取对应的流水记录
        DappFundFlowEntity dappFundFlowEntity = dappFundFlowDao.selectById(id);
        if(ObjectUtil.isEmpty(dappFundFlowEntity)){
            return;
        }
        if(DappFundFlowEntity.WITHDRAW_STATUS_AGREE == dappFundFlowEntity.getStatus()){
            return;
        }
//        //金额
//        BigDecimal amount = dappFundFlowEntity.getAmount();
//        Long memberId = dappFundFlowEntity.getMemberId();
//        DappMemberEntity dappMemberEntity = dappMemberDao.selectById(memberId);
//        if(ObjectUtil.isEmpty(dappMemberEntity)){
//            return;
//        }
//        //目标地址
//        String address = dappMemberEntity.getAddress();
//        String hash = ChainService.getInstance(ChainEnum.BSC_USDT.name()).transfer(address, amount);
//        if(StrUtil.isEmpty(hash)){
//            return;
//        }
//        dappFundFlowEntity.setToHash(hash);
        dappFundFlowEntity.setStatus(DappFundFlowEntity.WITHDRAW_STATUS_AGREE);
        dappFundFlowDao.updateById(dappFundFlowEntity);

    }

    @Override
    public void agentUp(Long id) {
        //根据邀请码获取用户信息
        DappMemberEntity dappMemberEntity = dappMemberDao.selectById(id);
        if(ObjectUtil.isEmpty(dappMemberEntity)){
            return;
        }
        String accountType = dappMemberEntity.getAccountType();
        if(DataDictionaryEnum.BIG_BOSS.getCode().equals(accountType)){
            return;
        }
        //当前为BOSS，且直推中有两个BOSS以上，则升级BIG_BOSS
        if(DataDictionaryEnum.BOSS.getCode().equals(accountType)){
            Integer bossCount = dappMemberDao.selectCountByAccountTypeAndRefererId(DataDictionaryEnum.BOSS.getCode(),dappMemberEntity.getInviteId());
            if(2 <= bossCount){
                dappMemberDao.updateMemberAccountType(DataDictionaryEnum.BIG_BOSS.getCode(),dappMemberEntity.getId());
            }
            return;
        }
        //当前为AGENT，且直推中有两个以上，则升级BOSS
        if(DataDictionaryEnum.AGENT.getCode().equals(accountType)){
            Integer bossCount = dappMemberDao.selectCountByAccountTypeAndRefererId(null,dappMemberEntity.getInviteId());
            if(2 <= bossCount){
                dappMemberDao.updateMemberAccountType(DataDictionaryEnum.BOSS.getCode(),dappMemberEntity.getId());
            }
            return;
        }
    }

    public static void main(String[] args) {
        String refererIds = "1,2,3,4,5," +
                            "6,7,8,9,10," +
                            "11,12,13,14,15";
        List<String> refererIdList = StrUtil.split(refererIds, ',');
        System.out.println(refererIdList);
    }
}