finish matrix profit

wzy

2022-08-27 afe2e9a2da152a9b1a54d88b7637e811bf298749

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

@@ -11,11 +11,14 @@
import cc.mrbird.febs.dapp.enumerate.CardPeriod;
import cc.mrbird.febs.dapp.mapper.*;
import cc.mrbird.febs.dapp.service.DappSystemService;
import cc.mrbird.febs.dapp.service.DappWalletService;
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.job.SystemTradeJob;
import cc.mrbird.febs.rabbit.producer.ChainProducer;
import cc.mrbird.febs.tree.MatrixTree;
import cc.mrbird.febs.tree.MemberNode;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUnit;
@@ -62,6 +65,10 @@
    private final DappMemberBoxRecordMapper dappMemberBoxRecordMapper;
    private final DappWalletCoinDao dappWalletCoinDao;

    private final DappAchieveTreeDao dappAchieveTreeDao;
    private final DappAchieveMemberTreeDao dappAchieveMemberTreeDao;
    private final DappWalletService dappWalletService;


    @Override
    public Map<String, Object> findTotalInComeAndList() {
@@ -98,80 +105,7 @@
        DappMemberEntity member = LoginUserUtil.getAppUser();

        SystemDto system = new SystemDto();
        String hasStart = redisUtils.getString(AppContants.SYSTEM_START_FLAG);
        // 启动未启动
        if (!"start".equals(hasStart)) {
            system.setFeeRatio(new BigDecimal("7"));
            system.setBuyFeeRatio(new BigDecimal("3"));
            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.name()).balanceOf(ChainEnum.BSC_TFC.getAddress());
                redisUtils.set(AppContants.REDIS_KEY_MAKE_POOL_CNT, balance);
            } else {
                balance = (BigDecimal) makePoolObj;
            }
            system.setBuyRemain(balance);
            system.setBuyTotal(balance);


            Object maxDailyBuy = redisUtils.get(AppContants.REDIS_KEY_IDO_USDT_MAX_BUY_DAILY + member.getAddress());
            if (maxDailyBuy == null) {
                DateTime tomorrow = DateUtil.beginOfDay(DateUtil.tomorrow());
                long time = DateUtil.between(new Date(), tomorrow, DateUnit.SECOND, true);

                redisUtils.set(AppContants.REDIS_KEY_IDO_USDT_MAX_BUY_DAILY + member.getAddress(), new BigDecimal("1000"), time);
            }

            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 minLimit = new BigDecimal(50);
        BigDecimal coinTotal;
        if (balance.compareTo(minLimit) > 0) {
            coinTotal = balance.multiply(BigDecimal.valueOf(0.3)).setScale(instance.decimals(), RoundingMode.HALF_DOWN);
        } else {
            coinTotal = new BigDecimal(50);
        }

        BigDecimal remain;
        if (o == null) {
            DateTime tomorrow = DateUtil.beginOfDay(DateUtil.tomorrow());
            long time = DateUtil.between(new Date(), tomorrow, DateUnit.SECOND, true);

            remain = coinTotal;
            redisUtils.set(AppContants.REDIS_KEY_COIN_REMAIN + member.getAddress(), remain, time);
        } 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(new BigDecimal("7"));
        system.setBuyFeeRatio(new BigDecimal("3"));
        system.setBuyAmount(new BigDecimal("100"));
        return system;
    }

@@ -727,7 +661,122 @@
    }

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

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

        // 在内存树(大树)中插入当前节点，并返回父节点
        MemberNode node = new MemberNode(member.getId(), member.getAddress(), member.getInviteId(), member.getRefererId());
        MatrixTree tree = MatrixTree.getInstance();
        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 = new BigDecimal("100").multiply(new BigDecimal("0.15"));
            dappWalletService.updateWalletCoinWithLock(directProfit, parent.getId());

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

        // 如果是复投的，则需奖励
        if (isReIn == 1) {
            dappWalletService.updateWalletCoinWithLock(new BigDecimal(190), member.getId());

            DappFundFlowEntity matrixProfitFlow = new DappFundFlowEntity(memberId, new BigDecimal("190"), 2, 2, null, null);
            dappFundFlowDao.insert(matrixProfitFlow);

            DappFundFlowEntity rePutInFlow = new DappFundFlowEntity(memberId, new BigDecimal("100").negate(), 1, 2, null, null);
            dappFundFlowDao.insert(rePutInFlow);

            DappFundFlowEntity safePoolFlow = new DappFundFlowEntity(memberId, new BigDecimal("10").negate(), 4, 2, null, null);
            dappFundFlowDao.insert(safePoolFlow);

            DappMineDataEntity mineData = dappSystemDao.selectMineDataForOne();
            mineData.setSafePool(mineData.getSafePool().add(BigDecimal.TEN));
            dappSystemDao.updateMineData(mineData);
        }
    }
}