From b3b3baf9a3b0147ca38476450ca1823c291abd20 Mon Sep 17 00:00:00 2001
From: KKSU <15274802129@163.com>
Date: Fri, 21 Jun 2024 23:02:46 +0800
Subject: [PATCH] 后台矩阵列表

---
 src/main/java/cc/mrbird/febs/dapp/service/impl/DappSystemServiceImpl.java |  463 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 files changed, 451 insertions(+), 12 deletions(-)

diff --git a/src/main/java/cc/mrbird/febs/dapp/service/impl/DappSystemServiceImpl.java b/src/main/java/cc/mrbird/febs/dapp/service/impl/DappSystemServiceImpl.java
index 3d6bb3b..4b6e919 100644
--- a/src/main/java/cc/mrbird/febs/dapp/service/impl/DappSystemServiceImpl.java
+++ b/src/main/java/cc/mrbird/febs/dapp/service/impl/DappSystemServiceImpl.java
@@ -1,23 +1,24 @@
 package cc.mrbird.febs.dapp.service.impl;
 
-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.dto.SystemDto;
 import cc.mrbird.febs.dapp.entity.*;
+import cc.mrbird.febs.dapp.enumerate.DataDictionaryEnum;
+import cc.mrbird.febs.dapp.enumerate.InviteRule;
+import cc.mrbird.febs.dapp.enumerate.NodeType;
 import cc.mrbird.febs.dapp.mapper.*;
 import cc.mrbird.febs.dapp.service.DappSystemService;
 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.date.DateUnit;
 import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
@@ -25,7 +26,9 @@
 
 import java.math.BigDecimal;
 import java.math.RoundingMode;
-import java.util.*;
+import java.util.Date;
+import java.util.List;
+import java.util.stream.Collectors;
 
 /**
  * @author
@@ -44,6 +47,9 @@
     private final DappAchieveTreeDao dappAchieveTreeDao;
     private final DappAchieveMemberTreeDao dappAchieveMemberTreeDao;
     private final DappWalletService dappWalletService;
+    private final DataDictionaryCustomMapper dataDictionaryCustomMapper;
+
+    private final DbMemberNodeMapper dbMemberNodeMapper;
 
 
     @Override
@@ -59,6 +65,9 @@
     @Transactional(rollbackFor = Exception.class)
     public synchronized void achieveTree(Long memberId) {
         DappMemberEntity member = dappMemberDao.selectById(memberId);
+        if(ObjectUtil.isEmpty(member)){
+            return;
+        }
 
         int batchNo = 0;
         DappAchieveTreeEntity newestTreeNode = dappAchieveTreeDao.selectNewestTreeNode();
@@ -100,10 +109,11 @@
         dappAchieveMemberTreeDao.insert(achieveMemberTree);
 
         // 激活用户状态
-        member.setActiveStatus(1);
-        dappMemberDao.updateById(member);
+//        member.setActiveStatus(1);
+//        dappMemberDao.updateById(member);
+//        dappMemberDao.updateMemberActiveV2(member.getId());
 
-        putIntoProfit(memberId, 2);
+//        putIntoProfit(memberId, 2);
         if (parentNode == null) {
             return;
         }
@@ -144,6 +154,261 @@
         }
     }
 
+    @Override
+    public void achieveTreeV2(Long fundId) {
+        DappFundFlowEntity dappFundFlowEntity = dappFundFlowDao.selectById(fundId);
+        if(ObjectUtil.isEmpty(dappFundFlowEntity)){
+            return;
+        }
+        Integer status = dappFundFlowEntity.getStatus();
+        if(2 != status){
+            return;
+        }
+        Long memberId = dappFundFlowEntity.getMemberId();
+        DappMemberEntity member = dappMemberDao.selectById(memberId);
+        if(ObjectUtil.isEmpty(member)){
+            return;
+        }
+        BigDecimal amount = dappFundFlowEntity.getAmount();
+        //存放买入新团的类型
+        String toHash = dappFundFlowEntity.getToHash();
+        //根据金额判断属于属于购买的哪一个节点
+        NodeType nodeType = NodeType.NODE_1.getNode(Integer.parseInt(toHash));
+        if(ObjectUtil.isEmpty(nodeType)){
+            return;
+        }
+        /**
+         * 获取一条最老的左右节点未满的记录
+         * 然后生成一条新的记录
+         * 如果添加的为左节点,那么没人出局
+         * 如果添加的为右节点,那么进入判断
+         *      1、父节点为左节点,那么没人出局
+         *      2、父节点为右节点,那么进入判断,父节点是否有上级节点
+         *          1、有,则上级节点出局复投,轮数加1,复投逻辑
+         *
+         */
+        //获取一条最老的左右节点未满且生效中的记录
+        DbMemberNode dbMemberNodeOld = dbMemberNodeMapper.selectOneByWorkStateAndLeftNodeNullOrRightNodeNull(DbMemberNode.STATE_ONE,nodeType.getNodeType());
+        if(ObjectUtil.isEmpty(dbMemberNodeOld)){
+            //生成ROOT节点
+            DbMemberNode root = new DbMemberNode();
+            root.setMemberId(memberId);
+            root.setFundId(fundId);
+            root.setAmount(new BigDecimal(nodeType.getNodeAmount()));
+            root.setType(nodeType.getNodeType());
+            root.setCountFund(1);
+            root.setPerkState(1);
+            root.setWorkState(1);
+            dbMemberNodeMapper.insert(root);
+
+            return;
+        }
+
+        //然后生成一条新的记录
+        DbMemberNode dbMemberNode = new DbMemberNode();
+        dbMemberNode.setMemberId(memberId);
+        dbMemberNode.setFundId(fundId);
+        dbMemberNode.setAmount(new BigDecimal(nodeType.getNodeAmount()));
+        dbMemberNode.setType(nodeType.getNodeType());
+        dbMemberNode.setCountFund(1);
+        dbMemberNode.setPerkState(1);
+        dbMemberNode.setLeftRight(ObjectUtil.isEmpty(dbMemberNodeOld.getLeftNode()) ? 1 : 2);
+        dbMemberNode.setParentNode(dbMemberNodeOld.getId());
+        dbMemberNode.setWorkState(1);
+        dbMemberNodeMapper.insert(dbMemberNode);
+
+        //如果添加的为右节点,那么进入判断
+        if(DbMemberNode.STATE_TWO == dbMemberNode.getLeftRight()){
+            //更新父节点的右节点
+            dbMemberNodeOld.setRightNode(dbMemberNode.getId());
+            dbMemberNodeMapper.updateById(dbMemberNodeOld);
+
+            //父节点为右节点,那么进入判断,父节点是否有上级节点
+            int leftRight = ObjectUtil.isEmpty(dbMemberNodeOld.getLeftRight()) ? 1 : dbMemberNodeOld.getLeftRight();
+            if(DbMemberNode.STATE_TWO == leftRight){
+                if(ObjectUtil.isEmpty(dbMemberNodeOld.getParentNode())){
+                    return;
+                }
+                Long parentNode = dbMemberNodeOld.getParentNode();
+                DbMemberNode dbMemberNodeRoot = dbMemberNodeMapper.selectById(parentNode);
+                if(ObjectUtil.isEmpty(dbMemberNodeRoot)){
+                    return;
+                }
+                //每个星团,只复投10轮
+                if(10 < dbMemberNodeRoot.getCountFund()){
+                    return;
+                }
+                //有,则上级节点出局复投,轮数加1,复投逻辑
+                memberNodeNext(dbMemberNodeRoot);
+            }else{//父节点为左节点,那么没人出局
+                return;
+            }
+        }else{
+            //更新父节点的左节点
+            dbMemberNodeOld.setLeftNode(dbMemberNode.getId());
+            dbMemberNodeMapper.updateById(dbMemberNodeOld);
+            //如果添加的为左节点,那么没人出局
+            return;
+        }
+    }
+
+    /**
+     * 有,则上级节点出局复投,轮数加1,复投逻辑
+     * @param dbMemberNodeRoot
+     */
+    public void memberNodeNext(DbMemberNode dbMemberNodeRoot) {
+        log.info("进入复投");
+
+        DataDictionaryCustom inviteNumDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
+                DataDictionaryEnum.INVITE_NUM.getType(),
+                DataDictionaryEnum.INVITE_NUM.getCode()
+        );
+
+        int inviteNum = Integer.parseInt(inviteNumDic.getValue());
+
+        Long memberId = dbMemberNodeRoot.getMemberId();
+        DappMemberEntity dappMemberEntity = dappMemberDao.selectById(memberId);
+        //必须要有两个直推才能复投,或者获取收益,否则,直接返回
+        QueryWrapper<DappMemberEntity> inviteQuery = new QueryWrapper<>();
+        inviteQuery.eq("referer_id",dappMemberEntity.getInviteId());
+        List<DappMemberEntity> dappMemberEntities = dappMemberDao.selectList(inviteQuery);
+        if(CollUtil.isEmpty(dappMemberEntities)){
+            return;
+        }
+        if(inviteNum > dappMemberEntities.size()){
+            return;
+        }
+        List<Long> collect = dappMemberEntities.stream().map(DappMemberEntity::getId).collect(Collectors.toList());
+        QueryWrapper<DbMemberNode> inviteNodeQuery = new QueryWrapper<>();
+        inviteNodeQuery.select("member_id");
+        inviteNodeQuery.eq("work_state", DbMemberNode.STATE_ONE);
+        inviteNodeQuery.in("member_id",collect);
+        inviteNodeQuery.groupBy("member_id");
+        List<DbMemberNode> inviteNodes = dbMemberNodeMapper.selectList(inviteNodeQuery);
+        if(CollUtil.isEmpty(inviteNodes)){
+            return;
+        }
+        if(inviteNum > inviteNodes.size()){
+            return;
+        }
+        //任何星级的原来节点都要出局
+        dbMemberNodeRoot.setWorkState(DbMemberNode.STATE_TWO);
+        dbMemberNodeMapper.updateById(dbMemberNodeRoot);
+        //任何星级,10轮,收益本金都返回
+        Integer countFund = dbMemberNodeRoot.getCountFund();
+        //收益
+        BigDecimal perkAmount = dbMemberNodeRoot.getAmount().multiply(new BigDecimal("1.4"));
+        if(10 == countFund){//任何星级,10轮,收益本金都返回
+            BigDecimal add = dbMemberNodeRoot.getAmount().add(perkAmount);
+            perkSevenTeen(memberId,add,countFund);
+
+            return;
+        }else{
+            Integer type = dbMemberNodeRoot.getType();
+            //如果是13星局,则直接复投产生收益
+            if(NodeType.NODE_13.getNodeType() == type){
+                //复投
+                futouSixTeen(memberId,dbMemberNodeRoot.getAmount(),type,countFund+1);
+                //产生收益
+                perkSevenTeen(memberId,perkAmount,countFund);
+                return;
+            }
+            //如果是1到12星团
+            if(type >=NodeType.NODE_1.getNodeType() && type <= NodeType.NODE_12.getNodeType()){
+                //需要复投本轮,
+                //如果是第一轮,当下一个星团没有投入时,收益复投下一个新团
+                //如果是第一轮,下一个新团有投入,则产生收益
+                //复投或者收益的金额
+                if(1 == countFund){//第一轮
+                    //复投本轮,轮数 +1
+                    futouSixTeen(memberId,dbMemberNodeRoot.getAmount(),type,countFund+1);
+                    //收益复投(当前的下一个星团没有已投入),还是收益提出
+                    Integer nextType = type + 1;
+                    QueryWrapper<DbMemberNode> nodeQueryWrapper = new QueryWrapper<>();
+                    nodeQueryWrapper.eq("member_id",memberId);
+                    nodeQueryWrapper.eq("type", nextType);
+                    nodeQueryWrapper.eq("work_state", DbMemberNode.STATE_ONE);
+                    DbMemberNode dbMemberNode = dbMemberNodeMapper.selectOne(nodeQueryWrapper);
+                    if(ObjectUtil.isEmpty(dbMemberNode)){
+                        futouSixTeen(memberId,perkAmount,nextType,1);
+                    }else{
+                        perkSevenTeen(memberId,perkAmount,countFund);
+                    }
+                }else{//2-9轮
+                    //复投本轮,轮数 +1
+                    futouSixTeen(memberId,dbMemberNodeRoot.getAmount(),type,countFund+1);
+                    perkSevenTeen(memberId,perkAmount,countFund);
+                }
+            }
+        }
+    }
+    /**
+     * 产生收益
+     * @param memberId 会员ID
+     * @param amount 收益金额
+     * @param countFund 轮数
+     */
+    public void perkSevenTeen(Long memberId,BigDecimal amount,Integer countFund){
+        //收益流水
+        DappFundFlowEntity fundFlow = new DappFundFlowEntity(
+                memberId,
+                amount,
+                17,
+                2,
+                BigDecimal.ZERO,
+                countFund.toString());
+        dappFundFlowDao.insert(fundFlow);
+        //更新用户的金额
+        dappWalletService.updateWalletCoinWithLock(amount, memberId, 1);
+    }
+
+    /**
+     * 复投本轮
+     * 插入流水,产生记录
+     * @param memberId 会员ID
+     * @param amount 复投金额
+     * @param type 星团类型
+     * @param countFund 轮数
+     */
+    public void futouSixTeen(Long memberId,BigDecimal amount,Integer type,Integer countFund){
+        //复投流水
+        DappFundFlowEntity fundFlow = new DappFundFlowEntity(
+                memberId,
+                amount,
+                16,
+                2,
+                BigDecimal.ZERO,
+                null);
+        dappFundFlowDao.insert(fundFlow);
+        DbMemberNode dbMemberNodeOld = dbMemberNodeMapper.selectOneByWorkStateAndLeftNodeNullOrRightNodeNull(DbMemberNode.STATE_ONE,type);
+
+        //复投
+        DbMemberNode dbMemberNode = new DbMemberNode();
+        dbMemberNode.setMemberId(memberId);
+        dbMemberNode.setFundId(fundFlow.getId());
+        dbMemberNode.setAmount(amount);
+        dbMemberNode.setType(type);
+        dbMemberNode.setCountFund(countFund);
+        dbMemberNode.setPerkState(1);
+        if(ObjectUtil.isNotEmpty(dbMemberNodeOld)){
+            dbMemberNode.setLeftRight(ObjectUtil.isEmpty(dbMemberNodeOld.getLeftNode()) ? 1 : 2);
+            dbMemberNode.setParentNode(dbMemberNodeOld.getId());
+        }
+        dbMemberNode.setWorkState(1);
+        dbMemberNodeMapper.insert(dbMemberNode);
+
+        if(ObjectUtil.isNotEmpty(dbMemberNodeOld)){
+            if(dbMemberNode.getLeftRight() == 1){
+                dbMemberNodeOld.setLeftNode(dbMemberNode.getId());
+            }else{
+                dbMemberNodeOld.setRightNode(dbMemberNode.getId());
+            }
+            dbMemberNodeMapper.updateById(dbMemberNodeOld);
+        }
+    }
+
+
+
     // 完成矩阵树,并重置矩阵且重入
     public void finishMatrixTree(Long memberId) {
         List<DappAchieveMemberTreeEntity> matrixTree = dappAchieveMemberTreeDao.selectMatrixTreeByTopNode(memberId, 1);
@@ -166,7 +431,7 @@
         DappMemberEntity parent = dappMemberDao.selectMemberInfoByInviteId(member.getRefererId());
 
         if (parent != null) {
-            BigDecimal directProfit = new BigDecimal("100").multiply(new BigDecimal("0.15"));
+            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);
@@ -193,8 +458,6 @@
                 } else {
                     amount = TreeConstants.FULL_PROFIT_AMOUNT;
                 }
-
-                dappWalletService.releaseFrozenAmountWithLock(memberId);
 
                 member.setOutCnt(member.getOutCnt() + 1);
                 dappMemberDao.updateById(member);
@@ -246,4 +509,180 @@
         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 invitePerkMsg(Long id) {
+        /**
+         * 推荐规则:
+         * 无直推奖励,推2个3层,3个6层,4个10层。1%见点奖(有效层级内,每个每1%),共10层,共%10。
+         */
+        DappFundFlowEntity dappFundFlowEntity = dappFundFlowDao.selectById(id);
+        if(ObjectUtil.isEmpty(dappFundFlowEntity)){
+            return;
+        }
+        BigDecimal amount = dappFundFlowEntity.getAmount().abs();
+        /**
+         * 往上循环十层,判断每一层是否有见点奖
+         */
+        Long memberId = dappFundFlowEntity.getMemberId();
+        for(int i = 1;i <= 10;i++){
+            DappMemberEntity dappMemberEntity = dappMemberDao.selectById(memberId);
+            String refererId = dappMemberEntity.getRefererId();
+            //上级不存在,则停止循环。
+            QueryWrapper<DappMemberEntity> objectQueryWrapper = new QueryWrapper<>();
+            objectQueryWrapper.eq("invite_id",refererId);
+            DappMemberEntity dappMemberEntityRef = dappMemberDao.selectOne(objectQueryWrapper);
+            if(ObjectUtil.isEmpty(dappMemberEntityRef)){
+                return;
+            }
+
+            memberId = dappMemberEntityRef.getId();
+            //如果为购买星级激活用户,则跳过
+            Integer activeStatus = dappMemberEntityRef.getActiveStatus();
+            if(1 != activeStatus){
+                continue;
+            }
+            //获取上级全部的直推
+            String inviteId = dappMemberEntityRef.getInviteId();
+            QueryWrapper<DappMemberEntity> memberInviteQuery = new QueryWrapper<>();
+            memberInviteQuery.eq("referer_id",inviteId);
+            List<DappMemberEntity> memberInviteList = dappMemberDao.selectList(memberInviteQuery);
+
+            //如果没有直推,则跳过
+            if(CollUtil.isEmpty(memberInviteList)){
+                continue;
+            }
+
+            InviteRule rule = InviteRule.LEVEL_1.getRule(i);
+            if(ObjectUtil.isEmpty(rule)){
+                return;
+            }
+            //如果直推不满足当前规则需要的人数,则跳过
+            if(memberInviteList.size() < rule.getInviteNum()){
+                continue;
+            }
+            BigDecimal perkPercent = new BigDecimal(rule.getPerkPercent()).multiply(new BigDecimal("0.01"));
+            BigDecimal perkAmount = perkPercent.multiply(amount);
+            Long perkMemberId = dappMemberEntityRef.getId();
+            //生成一条流水
+            DappFundFlowEntity rePutInFlow = new DappFundFlowEntity(
+                    perkMemberId,
+                    perkAmount,
+                    15,
+                    2,
+                    null,
+                    null);
+            dappFundFlowDao.insert(rePutInFlow);
+            //更新用户的金额
+            dappWalletService.updateWalletCoinWithLock(perkAmount, perkMemberId, 1);
+        }
+    }
+
+    @Override
+    public void nodePerkMsg(Long id) {
+        DappFundFlowEntity dappFundFlowEntity = dappFundFlowDao.selectById(id);
+        if(ObjectUtil.isEmpty(dappFundFlowEntity)){
+            return;
+        }
+        BigDecimal amount = dappFundFlowEntity.getAmount().abs();
+        log.info("买入贡献值-平分总金额-{}",amount);
+        /**
+         * 获取节点平分百分比 perkPercent
+         * 获取平分的份数 perKNum
+         * 获取每一份的金额 perkAmount
+         * 获取节点总数 buyNodeNum
+         * 如果perKNum大于buyNodeNum,则每个人获得(amount * perkPercent)/ perKNum = perkAmount
+         * 如果超出,再超出的人没有奖励
+         */
+        DataDictionaryCustom perkPercentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
+                DataDictionaryEnum.PERK_PERCENT.getType(),
+                DataDictionaryEnum.PERK_PERCENT.getCode()
+        );
+        BigDecimal perkPercent = new BigDecimal(ObjectUtil.isEmpty(perkPercentDic) ? "10" : perkPercentDic.getValue()).multiply(new BigDecimal("0.01"));
+
+        DataDictionaryCustom perKNumDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
+                DataDictionaryEnum.PERK_NUM.getType(),
+                DataDictionaryEnum.PERK_NUM.getCode()
+        );
+        BigDecimal perKNum = new BigDecimal(ObjectUtil.isEmpty(perKNumDic) ? "200" : perKNumDic.getValue());
+
+        BigDecimal perkAmount = amount.multiply(perkPercent).divide(perKNum, 8, BigDecimal.ROUND_DOWN);
+        if(BigDecimal.ZERO.compareTo(perkAmount) >= 0){
+            return;
+        }
+
+        QueryWrapper<DappMemberEntity> objectQueryWrapper = new QueryWrapper<>();
+        objectQueryWrapper.ge("buy_node",0);
+        List<DappMemberEntity> dappMemberEntities = dappMemberDao.selectList(objectQueryWrapper);
+        if(CollUtil.isEmpty(dappMemberEntities)){
+            return;
+        }
+
+        //奖励总份数
+        BigDecimal totalPerkNum = BigDecimal.ZERO;
+        for(DappMemberEntity dappMemberEntity : dappMemberEntities){
+            //如果账号未激活,则无法领取收益
+            if(1 != dappMemberEntity.getActiveStatus()){
+                continue;
+            }
+            BigDecimal buyNode = new BigDecimal(dappMemberEntity.getBuyNode());
+            totalPerkNum = totalPerkNum.add(buyNode);
+            if(perKNum.compareTo(totalPerkNum) < 0){
+                return;
+            }
+            //奖励金额
+            BigDecimal memberPerk = perkAmount.multiply(buyNode);
+            if(BigDecimal.ZERO.compareTo(memberPerk) >= 0){
+                continue;
+            }
+            dappWalletService.updateWalletCoinWithLock(memberPerk, dappMemberEntity.getId(), 1);
+
+            DappFundFlowEntity fundFlow = new DappFundFlowEntity(
+                    dappMemberEntity.getId(),
+                    memberPerk,
+                    14,
+                    2,
+                    BigDecimal.ZERO,
+                    null);
+            dappFundFlowDao.insert(fundFlow);
+        }
+
+        log.info("买入贡献值-总人数{},-每人金额{}",dappMemberEntities.size(),perkAmount);
+    }
+
 }

--
Gitblit v1.9.1