## 一阶段点位填充处理；

bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/achieve/controller/manage/CuMemberSettleController.java

@@ -15,7 +15,6 @@ import com.hzs.common.core.enums.EOperationBusiness;
 import com.hzs.common.core.enums.EOperationMethod;
 import com.hzs.common.core.enums.EOperationModule;
 import com.hzs.common.core.utils.DateUtils;
-import com.hzs.common.core.utils.StringUtils;
 import com.hzs.common.core.web.controller.BaseController;
 import com.hzs.common.core.web.domain.AjaxResult;
 import com.hzs.common.core.web.page.TableDataInfo;
@@ -37,8 +36,6 @@ public class CuMemberSettleController extends BaseController {
     @Autowired
     private ICuMemberBonusService iCuMemberBonusService;
     @Autowired
-    private IBonusSettleService iBonusSettleService;
-    @Autowired
     private ICuMemberTreeService iCuMemberTreeService;
     @Autowired
     private ICuMemberSettlePeriodService iCuMemberSettlePeriodService;
@@ -48,8 +45,6 @@ public class CuMemberSettleController extends BaseController {
 
     /**
      * 初始化奖金结算表
-     *
-     * @return AjaxResult
      */
     @GetMapping("/init-table")
     public AjaxResult initTable(String settleDate) {
@@ -59,8 +54,6 @@ public class CuMemberSettleController extends BaseController {
 
     /**
      * 初始化奖金结算表
-     *
-     * @return AjaxResult
      */
     @GetMapping("/init-period")
     public AjaxResult initPeriod(String settleDate) {
@@ -70,8 +63,6 @@ public class CuMemberSettleController extends BaseController {
 
     /**
      * 奖金计算 - 重新结算
-     *
-     * @return AjaxResult
      */
     @GetMapping("/settle-bonus")
     @Log(module = EOperationModule.BONUS_SETTLE, business = EOperationBusiness.BONUS_SETTLE, method = EOperationMethod.INSERT)
@@ -86,8 +77,6 @@ public class CuMemberSettleController extends BaseController {
 
     /**
      * 公布奖金
-     *
-     * @return AjaxResult
      */
     @GetMapping("/publish-bonus")
     @Log(module = EOperationModule.BONUS_SETTLE, business = EOperationBusiness.BONUS_SETTLE, method = EOperationMethod.PUBLISH)
@@ -102,8 +91,6 @@ public class CuMemberSettleController extends BaseController {
 
     /**
      * 不公布奖金
-     *
-     * @return AjaxResult
      */
     @GetMapping("/no-publish-bonus")
     @Log(module = EOperationModule.BONUS_SETTLE, business = EOperationBusiness.BONUS_SETTLE, method = EOperationMethod.NO_PUBLISH)
@@ -118,8 +105,6 @@ public class CuMemberSettleController extends BaseController {
 
     /**
      * 发放奖金
-     *
-     * @return AjaxResult
      */
     @GetMapping("/grant-bonus")
     @Log(module = EOperationModule.BONUS_SETTLE, business = EOperationBusiness.BONUS_SETTLE, method = EOperationMethod.GRANT)
@@ -134,8 +119,6 @@ public class CuMemberSettleController extends BaseController {
 
     /**
      * 发放奖金
-     *
-     * @return AjaxResult
      */
     @GetMapping("/grant-temp-bonus")
     public AjaxResult grantTempBonus(Integer pkCountry, String settleDate) {
@@ -145,8 +128,6 @@ public class CuMemberSettleController extends BaseController {
 
     /**
      * 发放奖金
-     *
-     * @return AjaxResult
      */
     @GetMapping("/grant-bonus_all")
     public AjaxResult grantBonusAll() {
@@ -156,8 +137,6 @@ public class CuMemberSettleController extends BaseController {
 
     /**
      * 奖金提现
-     *
-     * @return AjaxResult
      */
     @GetMapping("/withdrawal-bonus")
     @Log(module = EOperationModule.BONUS_SETTLE, business = EOperationBusiness.BONUS_SETTLE, method = EOperationMethod.WITHDRAWAL)
@@ -170,20 +149,6 @@ public class CuMemberSettleController extends BaseController {
         return AjaxResult.success();
     }
 
-    /**
-     * 秒接结算业绩，仅用于测试
-     *
-     * @return AjaxResult
-     */
-    @GetMapping("/settle-second-bonus")
-    public AjaxResult settleSecondBonus(String orderCode) {
-        if (StringUtils.isEmpty(orderCode)) {
-            return AjaxResult.error();
-        }
-        iBonusSettleService.calculateCuMemberRetailRangeBonusBySaOrder(orderCode);
-        return AjaxResult.success();
-    }
-
     /*
      *  查询奖金计算期数列表
      **/

bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/achieve/mapper/CuMemberRetailDetailMapper.java

@@ -2,10 +2,20 @@ package com.hzs.bonus.achieve.mapper;
 
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.hzs.common.domain.member.achieve.CuMemberRetailDetail;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
 
 /**
  * 日结算阶段表 Mapper 接口
  */
 public interface CuMemberRetailDetailMapper extends BaseMapper<CuMemberRetailDetail> {
 
+    /**
+     * 查询明细数据（指定阶段，未完成的）
+     */
+    List<CuMemberRetailDetail> listMemberRetailDetail(@Param("retailDetailTableName") String retailDetailTableName,
+                                                      @Param("tmpIdList") List<?> tmpIdList,
+                                                      @Param("stage") Integer stage);
+
 }

bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/achieve/mapper/CuMemberRetailRangeMapper.java

@@ -29,6 +29,12 @@ public interface CuMemberRetailRangeMapper extends BaseMapper<CuMemberRetailRang
                                            @Param("yesterdayRangeTableName") String yesterdayRangeTableName,
                                            @Param("isSameMonth") Integer isSameMonth);
 
+    /**
+     * 将昨天的结算明细迁移到今天
+     */
+    void mergeMemberRetailRangeDetailByYesterday(@Param("detailTableName") String detailTableName,
+                                                 @Param("yesterdayDetailTableName") String yesterdayDetailTableName);
+
     /**
      * 当前网体更新极差秒结表
      */
@@ -52,6 +58,11 @@ public interface CuMemberRetailRangeMapper extends BaseMapper<CuMemberRetailRang
      */
     List<CuMemberRetailRangeExt> queryCuMemberRetailRangeParent(@Param("tableName") String tableName, @Param("saOrderExtList") List<?> saOrderExtList);
 
+    /**
+     * 根据会员ID查询会员数据
+     */
+    List<CuMemberRetailRangeExt> listCuMemberRetailRange(@Param("tableName") String tableName, @Param("pkMemberList") List<Long> pkMemberList);
+
     /**
      * 推荐推荐人查询推荐人下的所有部门, 该订单日期之前的算他的网体
      */
@@ -80,13 +91,19 @@ public interface CuMemberRetailRangeMapper extends BaseMapper<CuMemberRetailRang
     void mergeCuMemberSecondRange(@Param("secondTableName") String secondTableName, @Param("cuMemberRangeExtList") List<?> cuMemberRangeExtList);
 
     /**
-     * 批量更新网体
+     * 更新会员日结数据
      */
     void mergeCuMemberRetailRangeExt(@Param("rangeTableName") String rangeTableName, @Param("cuMemberRangeExtList") List<?> cuMemberRangeExtList);
 
+    /**
+     * 批量会员日结明细数据
+     */
+    void mergeCuMemberRetailDetail(@Param("rangeDetailTableName") String rangeDetailTableName, @Param("cuMemberDetailList") List<?> cuMemberDetailList);
+
 
     /**
      * 向上查找所有parentID
+     *
      * @param pkMember
      * @return
      */
@@ -95,6 +112,7 @@ public interface CuMemberRetailRangeMapper extends BaseMapper<CuMemberRetailRang
 
     /**
      * 更新自己秒结
+     *
      * @param tableName
      * @param orderExt
      * @param cuMember
@@ -103,6 +121,7 @@ public interface CuMemberRetailRangeMapper extends BaseMapper<CuMemberRetailRang
 
     /**
      * 更新上级秒结
+     *
      * @param tableName
      * @param orderExt
      * @param memberList

bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/achieve/service/ICuMemberRetailDetailService.java

@@ -1,11 +1,27 @@
 package com.hzs.bonus.achieve.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
+import com.hzs.common.core.enums.EBonusStage;
 import com.hzs.common.domain.member.achieve.CuMemberRetailDetail;
+import com.hzs.common.domain.member.achieve.ext.CuMemberRetailRangeExt;
+
+import java.util.List;
+import java.util.Map;
 
 /**
  * 日结算阶段表 服务类
  */
 public interface ICuMemberRetailDetailService extends IService<CuMemberRetailDetail> {
 
+    /**
+     * 根据结算会员获取对应的点位数据
+     */
+    void listMemberRetailDetail(String retailDetailTableName, Map<Long, CuMemberRetailRangeExt> memberRangeExtMap, EBonusStage eBonusStage);
+
+    /**
+     * 指定会员获取对应的点位数据
+     */
+    void listMemberRetailDetail(String retailDetailTableName, Map<Long, CuMemberRetailRangeExt> memberRangeExtMap,
+                                List<Long> queryMemberList, EBonusStage eBonusStage);
+
 }

bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/achieve/service/ICuMemberRetailRangeService.java

@@ -21,7 +21,12 @@ public interface ICuMemberRetailRangeService extends IService<CuMemberRetailRang
     /**
      * 将昨天的业绩信息迁移到今天
      */
-    void mergeMemberRetailRangeByYesterday(Date settleEndDate, String rangeTableName, String yesterdayRangeTableName, Boolean isSameMonth);
+    void mergeMemberRetailRangeByYesterday(String rangeTableName, String yesterdayRangeTableName, Boolean isSameMonth);
+
+    /**
+     * 将昨天的结算明细迁移到今天
+     */
+    void mergeMemberRetailRangeDetailByYesterday(String detailTableName, String yesterdayDetailTableName);
 
     /**
      * 根据会员查询会员上的所有网体, 按照pkParent作为key
@@ -49,13 +54,15 @@ public interface ICuMemberRetailRangeService extends IService<CuMemberRetailRang
     List<CuMemberRetailRangeExt> queryCuMemberSecondRangeExtByParent(String rangeTableName, String secondTableName, Long pkMember);
 
     /**
-     * 更新会员树的累计业绩
-     *
-     * @param settleTableName 结算日期
-     * @param cuMemberTreeMap 树
+     * 更新会员日结数据
      */
     void updateCuMemberRetailRange(String settleTableName, Map<Long, CuMemberRetailRangeExt> cuMemberTreeMap);
 
+    /**
+     * 更新会员日结明细数据
+     */
+    void updateCuMemberRetailDetail(String rangeDetailTableName, Map<Long, CuMemberRetailRangeExt> memberRangeExtMap);
+
     /**
      * 更新极差秒接表，用昨天的结算表
      */

bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/achieve/service/impl/CuMemberBonusSettle.java

@@ -3,10 +3,7 @@ package com.hzs.bonus.achieve.service.impl;
 import com.hzs.common.core.constant.MagicNumberConstants;
 import org.springframework.stereotype.Component;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
 
 /**
  * 奖金计算工具类
@@ -39,4 +36,11 @@ public class CuMemberBonusSettle {
         List<?> oriList = Arrays.asList(baseEntityList.toArray());
         return handleCutList(oriList, batchNum);
     }
+
+    public List<List<?>> handleCutList(Collection<?> baseEntityList, Integer... batchNum) {
+        List<?> oriList = Arrays.asList(baseEntityList.toArray());
+        return handleCutList(oriList, batchNum);
+    }
+
+
 }

bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/achieve/service/impl/CuMemberRetailDetailServiceImpl.java

@@ -1,15 +1,67 @@
 package com.hzs.bonus.achieve.service.impl;
 
+import cn.hutool.core.collection.CollectionUtil;
 import com.hzs.bonus.achieve.mapper.CuMemberRetailDetailMapper;
 import com.hzs.bonus.achieve.service.ICuMemberRetailDetailService;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.hzs.common.core.constant.MagicNumberConstants;
+import com.hzs.common.core.enums.EBonusStage;
 import com.hzs.common.domain.member.achieve.CuMemberRetailDetail;
+import com.hzs.common.domain.member.achieve.ext.CuMemberRetailRangeExt;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
+import java.util.*;
+
 /**
  * 日结算阶段表 服务实现类
  */
 @Service
 public class CuMemberRetailDetailServiceImpl extends ServiceImpl<CuMemberRetailDetailMapper, CuMemberRetailDetail> implements ICuMemberRetailDetailService {
 
+    @Autowired
+    private CuMemberBonusSettle cuMemberBonusSettle;
+
+    @Override
+    public void listMemberRetailDetail(String retailDetailTableName, Map<Long, CuMemberRetailRangeExt> memberRangeExtMap, EBonusStage eBonusStage) {
+        List<List<?>> pkMemberList = cuMemberBonusSettle.handleCutList(memberRangeExtMap.keySet(), MagicNumberConstants.BATCH_QUERY_NUM);
+        pkMemberList.forEach(tmpIdList -> {
+            // 查询明细数据（指定阶段，未完成的）
+            List<CuMemberRetailDetail> tmpList = baseMapper.listMemberRetailDetail(retailDetailTableName, tmpIdList, eBonusStage.getValue());
+            if (CollectionUtil.isNotEmpty(tmpList)) {
+                // 明细数据放到对应的会员数据中
+                for (CuMemberRetailDetail cuMemberRetailDetail : tmpList) {
+                    CuMemberRetailRangeExt cuMemberRetailRangeExt = memberRangeExtMap.get(cuMemberRetailDetail.getPkMember());
+                    if (EBonusStage.ONE.getValue() == eBonusStage.getValue()) {
+                        // 阶段一点位列表（使用有序map，为了后续业务处理方便）
+                        if (null == cuMemberRetailRangeExt.getOneDetailMap()) {
+                            cuMemberRetailRangeExt.setOneDetailMap(new LinkedHashMap<>());
+                        }
+                        cuMemberRetailRangeExt.getOneDetailMap().put(cuMemberRetailDetail.getChildNode(), cuMemberRetailDetail);
+                    }
+                }
+            }
+        });
+    }
+
+    @Override
+    public void listMemberRetailDetail(String retailDetailTableName, Map<Long, CuMemberRetailRangeExt> memberRangeExtMap,
+                                       List<Long> queryMemberList, EBonusStage eBonusStage) {
+        // 查询明细数据（指定阶段，未完成的）
+        List<CuMemberRetailDetail> tmpDetailList = baseMapper.listMemberRetailDetail(retailDetailTableName, queryMemberList, eBonusStage.getValue());
+        if (CollectionUtil.isNotEmpty(tmpDetailList)) {
+            // 明细数据放到对应的会员数据中
+            for (CuMemberRetailDetail cuMemberRetailDetail : tmpDetailList) {
+                CuMemberRetailRangeExt cuMemberRetailRangeExt = memberRangeExtMap.get(cuMemberRetailDetail.getPkMember());
+                if (EBonusStage.ONE.getValue() == eBonusStage.getValue()) {
+                    // 阶段一点位列表（使用有序map，为了后续业务处理方便）
+                    if (null == cuMemberRetailRangeExt.getOneDetailMap()) {
+                        cuMemberRetailRangeExt.setOneDetailMap(new LinkedHashMap<>());
+                    }
+                    cuMemberRetailRangeExt.getOneDetailMap().put(cuMemberRetailDetail.getChildNode(), cuMemberRetailDetail);
+                }
+            }
+        }
+    }
+
 }

bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/achieve/service/impl/CuMemberRetailRangeServiceImpl.java

@@ -1,10 +1,12 @@
 package com.hzs.bonus.achieve.service.impl;
 
+import cn.hutool.core.collection.CollectionUtil;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.hzs.bonus.achieve.mapper.CuMemberRetailRangeMapper;
 import com.hzs.bonus.achieve.service.ICuMemberRetailRangeService;
 import com.hzs.common.core.constant.MagicNumberConstants;
 import com.hzs.common.core.enums.EOrderType;
+import com.hzs.common.domain.member.achieve.CuMemberRetailDetail;
 import com.hzs.common.domain.member.achieve.CuMemberRetailRange;
 import com.hzs.common.domain.member.achieve.ext.CuMemberRetailRangeExt;
 import com.hzs.common.domain.member.base.CuMember;
@@ -27,7 +29,7 @@ public class CuMemberRetailRangeServiceImpl extends ServiceImpl<CuMemberRetailRa
     private CuMemberBonusSettle cuMemberBonusSettle;
 
     @Override
-    public void mergeMemberRetailRangeByYesterday(Date settleEndDate, String rangeTableName, String yesterdayRangeTableName, Boolean isSameMonth) {
+    public void mergeMemberRetailRangeByYesterday(String rangeTableName, String yesterdayRangeTableName, Boolean isSameMonth) {
         // 当天数据全部更新为0
         baseMapper.mergeMemberRetailRangeInit(rangeTableName);
         if (isSameMonth) {
@@ -38,6 +40,11 @@ public class CuMemberRetailRangeServiceImpl extends ServiceImpl<CuMemberRetailRa
         }
     }
 
+    @Override
+    public void mergeMemberRetailRangeDetailByYesterday(String detailTableName, String yesterdayDetailTableName) {
+        baseMapper.mergeMemberRetailRangeDetailByYesterday(detailTableName, yesterdayDetailTableName);
+    }
+
     @Override
     public List<CuMemberRetailRangeExt> queryCuMemberRetailRangeParent(String tableName, List<SaOrderExt> saOrderExtList) {
         List<CuMemberRetailRangeExt> memberRetailRangeExtList = new ArrayList<>();
@@ -82,6 +89,21 @@ public class CuMemberRetailRangeServiceImpl extends ServiceImpl<CuMemberRetailRa
         treeList.forEach(list -> baseMapper.mergeCuMemberRetailRangeExt(settleTableName, list));
     }
 
+    @Override
+    public void updateCuMemberRetailDetail(String rangeDetailTableName, Map<Long, CuMemberRetailRangeExt> memberRangeExtMap) {
+        Collection<CuMemberRetailDetail> retailDetailColl = new ArrayList<>();
+        memberRangeExtMap.forEach((key, value) -> {
+            if (null != value.getOneDetailMap() && value.getOneDetailMap().size() > 0) {
+                retailDetailColl.addAll(value.getOneDetailMap().values());
+            }
+        });
+        List<List<?>> list = cuMemberBonusSettle.handleCutList(retailDetailColl);
+        if (CollectionUtil.isNotEmpty(list)) {
+            list.forEach(tmpList ->
+                    baseMapper.mergeCuMemberRetailDetail(rangeDetailTableName, tmpList));
+        }
+    }
+
     @Override
     public void mergeMemberSecondRetailRangeByRange(String rangeTableName, String secondRangeTableName, Long pkMember) {
         // 当前网体更新极差秒接表（血缘伞上）

bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/mapper/CuMemberBonusStageMapper.java

@@ -0,0 +1,11 @@
+package com.hzs.bonus.bonus.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.hzs.common.domain.member.bonus.CuMemberBonusStage;
+
+/**
+ * 会员奖金-阶段收益明细表 Mapper 接口
+ */
+public interface CuMemberBonusStageMapper extends BaseMapper<CuMemberBonusStage> {
+
+}

bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/service/ICuMemberBonusStageService.java

@@ -0,0 +1,41 @@
+package com.hzs.bonus.bonus.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.hzs.common.domain.member.achieve.CuMemberRetailDetail;
+import com.hzs.common.domain.member.achieve.ext.CuMemberRetailRangeExt;
+import com.hzs.common.domain.member.bonus.CuMemberBonusStage;
+
+import java.util.Map;
+
+/**
+ * 会员奖金-阶段收益明细表 服务类
+ */
+public interface ICuMemberBonusStageService extends IService<CuMemberBonusStage> {
+
+    /**
+     * 填充会员点位
+     */
+    String fillChildNode(CuMemberRetailDetail cuMemberRetailDetail, CuMemberRetailDetail newRetailDetail);
+
+    /**
+     * 处理新点位是推荐第一层
+     */
+    void handlePointFirst(Map<Long, CuMemberRetailRangeExt> memberRangeExtMap,
+                          CuMemberRetailDetail newRetailDetail, CuMemberRetailDetail newParentRetailDetail,
+                          String rangeTableName, String rangeDetailTableName, String newNode);
+
+    /**
+     * 处理新点位是推荐第二层
+     */
+    void handlePointSecond(Map<Long, CuMemberRetailRangeExt> memberRangeExtMap,
+                           CuMemberRetailDetail newRetailDetail, CuMemberRetailDetail newParentRetailDetail,
+                           String rangeTableName, String rangeDetailTableName, String newNode);
+
+    /**
+     * 处理新点位是推荐第三层
+     */
+    void handlePointThird(Map<Long, CuMemberRetailRangeExt> memberRangeExtMap,
+                          CuMemberRetailDetail newRetailDetail, CuMemberRetailDetail newParentRetailDetail,
+                          String rangeTableName, String rangeDetailTableName, String newNode);
+
+}

bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/service/impl/BonusSettleRangeHandle.java

@@ -1,35 +1,39 @@
 package com.hzs.bonus.bonus.service.impl;
 
 import cn.hutool.core.collection.CollectionUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.ReflectUtil;
+import com.hzs.bonus.achieve.service.ICuMemberRetailDetailService;
 import com.hzs.bonus.achieve.service.ICuMemberRetailRangeService;
 import com.hzs.bonus.base.service.ICuMemberService;
+import com.hzs.bonus.bonus.service.ICuMemberBonusStageService;
 import com.hzs.bonus.bonus.vo.BonusRecordDetailVO;
+import com.hzs.bonus.constant.BonusConstants;
 import com.hzs.bonus.detail.service.ICuMemberAwardsService;
 import com.hzs.bonus.order.service.IBonusOrderService;
 import com.hzs.common.core.constant.MagicNumberConstants;
 import com.hzs.common.core.constant.RetailConstants;
-import com.hzs.common.core.constant.SysConstants;
 import com.hzs.common.core.constant.TableNameConstants;
 import com.hzs.common.core.enums.*;
 import com.hzs.common.core.utils.ComputeUtil;
 import com.hzs.common.core.utils.DateUtils;
 import com.hzs.common.domain.bonus.BdBonusDeduct;
+import com.hzs.common.domain.member.achieve.CuMemberRetailDetail;
 import com.hzs.common.domain.member.achieve.ext.CuMemberRetailRangeExt;
 import com.hzs.common.domain.member.bonus.*;
 import com.hzs.common.domain.member.detail.*;
-import com.hzs.common.domain.member.ext.CuMemberSettleExt;
 import com.hzs.common.domain.sale.ext.SaOrderExt;
-import com.hzs.common.domain.sale.ext.SaOrderItemsExt;
 import com.hzs.common.domain.sale.ext.SaOrderWaresExt;
 import com.hzs.common.domain.sale.order.SaOrder;
 import com.hzs.common.domain.system.config.BdAwards;
 import com.hzs.system.config.dto.BonusConfigDTO;
-import com.hzs.system.config.dto.GradeDTO;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
+import java.lang.reflect.Field;
 import java.math.BigDecimal;
+import java.math.RoundingMode;
 import java.time.temporal.ChronoUnit;
 import java.util.*;
 import java.util.stream.Collectors;
@@ -41,9 +45,13 @@ import java.util.stream.Collectors;
 @Component
 public class BonusSettleRangeHandle extends BonusSettleHandle {
 
+    @Autowired
+    private ICuMemberRetailDetailService iCuMemberRetailDetailService;
     @Autowired
     private ICuMemberRetailRangeService iCuMemberRetailRangeService;
     @Autowired
+    private ICuMemberBonusStageService iCuMemberBonusStageService;
+    @Autowired
     private ICuMemberAwardsService iCuMemberAwardsService;
     @Autowired
     private ICuMemberService iCuMemberService;
@@ -269,8 +277,8 @@ public class BonusSettleRangeHandle extends BonusSettleHandle {
         // 结算期间日期后一天
         Date settleEndDate = DateUtils.afterDate(1, ChronoUnit.DAYS, settleStartDate);
 
-        // 新零售订单
-        List<SaOrderExt> orderList = iBonusOrderService.listRetailSaOrder(settleStartDate, settleEndDate, null);
+        // 新零售订单（注册、复购）
+        List<SaOrderExt> orderList = iBonusOrderService.listRetailSaOrder(settleStartDate, settleEndDate, null, Arrays.asList(EOrderType.RETAIL_REGISTER.getValue(), EOrderType.RETAIL_REPURCHASE.getValue()));
 
         // 更新当月会员， 将昨天业绩更到到今天，更新当月会员考核结果，有消费的考核通过
         // 结算期间表
@@ -284,22 +292,24 @@ public class BonusSettleRangeHandle extends BonusSettleHandle {
 
         // TODO 回退奖衔，将奖衔回退到结算前状态
         iCuMemberAwardsService.calculateCuMemberRetailRangeAwardsInit(settleDate, period, rangeTableName);
-        // 更新网体
-        iCuMemberRetailRangeService.mergeMemberRetailRangeByYesterday(settleEndDate, rangeTableName, yesterdayRangeTableName, isSameMonth);
+        // 初始化结算网体数据（昨天数据更新到今天数据）
+        iCuMemberRetailRangeService.mergeMemberRetailRangeByYesterday(rangeTableName, yesterdayRangeTableName, isSameMonth);
+        // 初始化结算明细数据（昨天数据更新到今天数据）
+        iCuMemberRetailRangeService.mergeMemberRetailRangeDetailByYesterday(rangeDetailTableName, yesterdayRangeDetailTableName);
 
         if (orderList.size() > 0) {
             // 按照血缘，查询该会员所有伞上会员
             List<CuMemberRetailRangeExt> memberRetailRangeExtList = iCuMemberRetailRangeService.queryCuMemberRetailRangeParent(rangeTableName, orderList);
-
             // 会员结算map（key：会员ID，value：结算扩展）
             Map<Long, CuMemberRetailRangeExt> memberRangeExtMap = new HashMap<>();
-
             // 会员转map
             for (CuMemberRetailRangeExt cuMemberRetailRangeExt : memberRetailRangeExtList) {
                 if (!memberRangeExtMap.containsKey(cuMemberRetailRangeExt.getPkMember())) {
                     memberRangeExtMap.put(cuMemberRetailRangeExt.getPkMember(), cuMemberRetailRangeExt);
                 }
             }
+            // 查询血缘会员明细数据（一阶段）
+            iCuMemberRetailDetailService.listMemberRetailDetail(rangeDetailTableName, memberRangeExtMap, EBonusStage.ONE);
 
             // 奖衔
             Map<Integer, BdAwards> retailAwardsMap = new HashMap<>();
@@ -308,8 +318,10 @@ public class BonusSettleRangeHandle extends BonusSettleHandle {
 
             // 会员奖衔升级记录
             List<CuMemberAwards> cuMemberAwardsList = new ArrayList<>();
-            // 精品直推收益、复购见点收益
+            // 直推收益、见点收益
             List<CuMemberBonusPush> cuMemberBonusPushList = new ArrayList<>();
+            // 阶段收益
+            List<CuMemberBonusStage> cuMemberBonusStageList = new ArrayList<>();
             // 复购级差收益
             List<CuMemberBonusRange> cuMemberBonusRangeList = new ArrayList<>();
             // 会员奖金明细
@@ -321,7 +333,10 @@ public class BonusSettleRangeHandle extends BonusSettleHandle {
                     // 直推收益 -- 来源订单金额，直推拿金额的10%
                     this.calculateDirectIncome(cuMemberBonusPushList, memberRangeExtMap, saOrderExt,
                             bonusConfigDTO, period, cuMemberBonusMap);
+
                     // TODO 阶段收益 -- 来源订单金额
+                    this.calculateStageIncome(cuMemberBonusStageList, memberRangeExtMap, saOrderExt,
+                            settleStartDate, rangeTableName, rangeDetailTableName);
 
 
                     // TODO 领导级差收益 -- 来源PV
@@ -351,8 +366,10 @@ public class BonusSettleRangeHandle extends BonusSettleHandle {
                 // 更新会员表奖衔数据
                 iCuMemberService.updateCuMemberRetailRangeByPeriod(period);
             }
-            // 更新网体
+            // 更新日结数据
             iCuMemberRetailRangeService.updateCuMemberRetailRange(rangeTableName, memberRangeExtMap);
+            // 更新日结明细数据
+            iCuMemberRetailRangeService.updateCuMemberRetailDetail(rangeDetailTableName, memberRangeExtMap);
         }
     }
 
@@ -420,85 +437,85 @@ public class BonusSettleRangeHandle extends BonusSettleHandle {
             break;
         }
 
-        // 校验大小区会员数据
-        List<CuMemberRetailRangeExt> cuMemberRangeExtList = null;
-        // 校验累计小部门会员数据
-        List<CuMemberRetailRangeExt> cuMemberRetailRangeExtList = null;
-        // 计算分红奖衔
-        while (true) {
-            // 当月奖衔值 + 5，获取下一个奖衔值
-            int awardsValue = targetMemberRangeExt.getShareAwardsValue() + 5;
-            if (retailAwardsMap.containsKey(awardsValue)) {
-                BdAwards bdAwards = retailAwardsMap.get(awardsValue);
-                // 先验证累计业绩
-                if (ComputeUtil.compareValue(ComputeUtil.computeAdd(targetMemberRangeExt.getTeamMonthPv(), targetMemberRangeExt.getMonthConsumePv()), bdAwards.getShareTotalCheck())) {
-                    // 再验证小区，计算小区业绩（拉取直推会员数据）
-                    if (null == cuMemberRangeExtList) {
-                        if (null != secondRangeTableName) {
-                            // 会员表 关联 秒结表 和 昨日结算表，查询订单会员直推数据
-                            cuMemberRangeExtList = iCuMemberRetailRangeService.queryCuMemberSecondRangeExtByParent(rangeTableName, secondRangeTableName, targetMemberRangeExt.getPkMember());
-                        } else {
-                            // 昨日结算表，查询订单会员直推数据
-                            cuMemberRangeExtList = iCuMemberRetailRangeService.queryCuMemberRetailRangeExtByParent(rangeTableName, targetMemberRangeExt.getPkMember());
-                        }
-                    }
-                    // 本人月消费业绩（默认为大区）
-                    BigDecimal consumeBigPv = targetMemberRangeExt.getMonthConsumePv();
-                    for (CuMemberRetailRangeExt cuMemberRetailRangeExt : cuMemberRangeExtList) {
-                        if (memberRangeExtMap.containsKey(cuMemberRetailRangeExt.getPkMember())) {
-                            cuMemberRetailRangeExt = memberRangeExtMap.get(cuMemberRetailRangeExt.getPkMember());
-                        }
-                        // 月累计业绩 = 本人月消费业绩 + 团队月消费业绩
-                        BigDecimal consumePv = ComputeUtil.computeAdd(cuMemberRetailRangeExt.getMonthConsumePv(), cuMemberRetailRangeExt.getAllTeamMonthPv());
-                        if (ComputeUtil.compareGreaterThan(consumePv, consumeBigPv)) {
-                            // 月累计业绩 > 大区业绩，则月累计就成为大区了
-                            consumeBigPv = consumePv;
-                        }
-                    }
-
-                    // 小区业绩 = 本人月消费业绩 + 团队月消费业绩 - 大区业绩
-                    BigDecimal smallAreaPv = ComputeUtil.computeAdd(targetMemberRangeExt.getMonthConsumePv(), ComputeUtil.computeSubtract(targetMemberRangeExt.getTeamMonthPv(), consumeBigPv));
-                    if (ComputeUtil.compareValue(smallAreaPv, bdAwards.getShareCommunityCheck())) {
-                        // 小区业绩 >= 小区考核业绩
-                        if (bdAwards.getPlaceDeptNum() > 0) {
-                            // 验证是否有多个区满足业绩
-                            if (null == cuMemberRetailRangeExtList) {
-                                // 非秒结需要查询日结相关数据，秒结表使用上面查出的数据就可以
-                                if (null != secondRangeTableName) {
-                                    // 会员表 关联 秒结表 和 昨日结算表，查询订单会员直推数据
-                                    cuMemberRetailRangeExtList = cuMemberRangeExtList;
-                                } else {
-                                    // 昨日结算表，查询订单会员直推数据
-                                    cuMemberRetailRangeExtList = iCuMemberRetailRangeService.queryCuMemberRetailRangeEnoughAchieve(rangeTableName, targetMemberRangeExt.getPkMember(), bdAwards.getShareCommunityCheck());
-                                }
-                            }
-
-                            int enoughNum = 0;
-                            if (ComputeUtil.compareValue(targetMemberRangeExt.getMonthConsumePv(), bdAwards.getShareCommunityCheck())) {
-                                enoughNum += 1;
-                            }
-                            for (CuMemberRetailRangeExt cuMemberRetailRangeExt : cuMemberRetailRangeExtList) {
-                                if (memberRangeExtMap.containsKey(cuMemberRetailRangeExt.getPkMember())) {
-                                    cuMemberRetailRangeExt = memberRangeExtMap.get(cuMemberRetailRangeExt.getPkMember());
-                                }
-                                if (ComputeUtil.compareValue(ComputeUtil.computeAdd(cuMemberRetailRangeExt.getMonthConsumePv(), cuMemberRetailRangeExt.getAllTeamMonthPv()), bdAwards.getShareCommunityCheck())) {
-                                    // 本人月消费业绩 + 团队月消费业绩 >= 小区考核业绩，则满足条件小部门 +1
-                                    enoughNum += 1;
-                                }
-                            }
-                            if (bdAwards.getPlaceDeptNum() > enoughNum) {
-                                break;
-                            }
-                        }
-                        cuMemberAwardsList.add(getCuMemberRetailAwards(targetMemberRangeExt, period, saOrderExt, bdAwards, EAwardsType.SHARE_TYPE.getValue(), targetMemberRangeExt.getPkShareAwards()));
-                        targetMemberRangeExt.setShareAwardsValue(bdAwards.getAwardsValue());
-                        targetMemberRangeExt.setPkShareAwards(bdAwards.getPkId());
-                        continue;
-                    }
-                }
-            }
-            break;
-        }
+//        // 校验大小区会员数据
+//        List<CuMemberRetailRangeExt> cuMemberRangeExtList = null;
+//        // 校验累计小部门会员数据
+//        List<CuMemberRetailRangeExt> cuMemberRetailRangeExtList = null;
+//        // 计算分红奖衔
+//        while (true) {
+//            // 当月奖衔值 + 5，获取下一个奖衔值
+//            int awardsValue = targetMemberRangeExt.getShareAwardsValue() + 5;
+//            if (retailAwardsMap.containsKey(awardsValue)) {
+//                BdAwards bdAwards = retailAwardsMap.get(awardsValue);
+//                // 先验证累计业绩
+//                if (ComputeUtil.compareValue(ComputeUtil.computeAdd(targetMemberRangeExt.getTeamMonthPv(), targetMemberRangeExt.getMonthConsumePv()), bdAwards.getShareTotalCheck())) {
+//                    // 再验证小区，计算小区业绩（拉取直推会员数据）
+//                    if (null == cuMemberRangeExtList) {
+//                        if (null != secondRangeTableName) {
+//                            // 会员表 关联 秒结表 和 昨日结算表，查询订单会员直推数据
+//                            cuMemberRangeExtList = iCuMemberRetailRangeService.queryCuMemberSecondRangeExtByParent(rangeTableName, secondRangeTableName, targetMemberRangeExt.getPkMember());
+//                        } else {
+//                            // 昨日结算表，查询订单会员直推数据
+//                            cuMemberRangeExtList = iCuMemberRetailRangeService.queryCuMemberRetailRangeExtByParent(rangeTableName, targetMemberRangeExt.getPkMember());
+//                        }
+//                    }
+//                    // 本人月消费业绩（默认为大区）
+//                    BigDecimal consumeBigPv = targetMemberRangeExt.getMonthConsumePv();
+//                    for (CuMemberRetailRangeExt cuMemberRetailRangeExt : cuMemberRangeExtList) {
+//                        if (memberRangeExtMap.containsKey(cuMemberRetailRangeExt.getPkMember())) {
+//                            cuMemberRetailRangeExt = memberRangeExtMap.get(cuMemberRetailRangeExt.getPkMember());
+//                        }
+//                        // 月累计业绩 = 本人月消费业绩 + 团队月消费业绩
+//                        BigDecimal consumePv = ComputeUtil.computeAdd(cuMemberRetailRangeExt.getMonthConsumePv(), cuMemberRetailRangeExt.getAllTeamMonthPv());
+//                        if (ComputeUtil.compareGreaterThan(consumePv, consumeBigPv)) {
+//                            // 月累计业绩 > 大区业绩，则月累计就成为大区了
+//                            consumeBigPv = consumePv;
+//                        }
+//                    }
+//
+//                    // 小区业绩 = 本人月消费业绩 + 团队月消费业绩 - 大区业绩
+//                    BigDecimal smallAreaPv = ComputeUtil.computeAdd(targetMemberRangeExt.getMonthConsumePv(), ComputeUtil.computeSubtract(targetMemberRangeExt.getTeamMonthPv(), consumeBigPv));
+//                    if (ComputeUtil.compareValue(smallAreaPv, bdAwards.getShareCommunityCheck())) {
+//                        // 小区业绩 >= 小区考核业绩
+//                        if (bdAwards.getPlaceDeptNum() > 0) {
+//                            // 验证是否有多个区满足业绩
+//                            if (null == cuMemberRetailRangeExtList) {
+//                                // 非秒结需要查询日结相关数据，秒结表使用上面查出的数据就可以
+//                                if (null != secondRangeTableName) {
+//                                    // 会员表 关联 秒结表 和 昨日结算表，查询订单会员直推数据
+//                                    cuMemberRetailRangeExtList = cuMemberRangeExtList;
+//                                } else {
+//                                    // 昨日结算表，查询订单会员直推数据
+//                                    cuMemberRetailRangeExtList = iCuMemberRetailRangeService.queryCuMemberRetailRangeEnoughAchieve(rangeTableName, targetMemberRangeExt.getPkMember(), bdAwards.getShareCommunityCheck());
+//                                }
+//                            }
+//
+//                            int enoughNum = 0;
+//                            if (ComputeUtil.compareValue(targetMemberRangeExt.getMonthConsumePv(), bdAwards.getShareCommunityCheck())) {
+//                                enoughNum += 1;
+//                            }
+//                            for (CuMemberRetailRangeExt cuMemberRetailRangeExt : cuMemberRetailRangeExtList) {
+//                                if (memberRangeExtMap.containsKey(cuMemberRetailRangeExt.getPkMember())) {
+//                                    cuMemberRetailRangeExt = memberRangeExtMap.get(cuMemberRetailRangeExt.getPkMember());
+//                                }
+//                                if (ComputeUtil.compareValue(ComputeUtil.computeAdd(cuMemberRetailRangeExt.getMonthConsumePv(), cuMemberRetailRangeExt.getAllTeamMonthPv()), bdAwards.getShareCommunityCheck())) {
+//                                    // 本人月消费业绩 + 团队月消费业绩 >= 小区考核业绩，则满足条件小部门 +1
+//                                    enoughNum += 1;
+//                                }
+//                            }
+//                            if (bdAwards.getPlaceDeptNum() > enoughNum) {
+//                                break;
+//                            }
+//                        }
+//                        cuMemberAwardsList.add(getCuMemberRetailAwards(targetMemberRangeExt, period, saOrderExt, bdAwards, EAwardsType.SHARE_TYPE.getValue(), targetMemberRangeExt.getPkShareAwards()));
+//                        targetMemberRangeExt.setShareAwardsValue(bdAwards.getAwardsValue());
+//                        targetMemberRangeExt.setPkShareAwards(bdAwards.getPkId());
+//                        continue;
+//                    }
+//                }
+//            }
+//            break;
+//        }
     }
 
     /**
@@ -571,79 +588,79 @@ public class BonusSettleRangeHandle extends BonusSettleHandle {
             break;
         }
 
-        // 计算分红奖衔
-        while (true) {
-            // 当月奖衔值 + 5，获取下一个奖衔值
-            int awardsValue = targetMemberRangeExt.getShareAwardsValue() + 5;
-            if (retailAwardsMap.containsKey(awardsValue)) {
-                BdAwards bdAwards = retailAwardsMap.get(awardsValue);
-                // 先验证累计业绩
-                if (ComputeUtil.compareValue(ComputeUtil.computeAdd(targetMemberRangeExt.getTeamMonthPv(), targetMemberRangeExt.getMonthConsumePv()), bdAwards.getShareTotalCheck())) {
-                    // 验证小区，计算小区业绩（拉取直推会员数据）
-                    List<CuMemberRetailRangeExt> cuMemberRangeExtList;
-                    if (secondRangeTableName != null) {
-                        // 会员表 关联 秒结表 和 昨日结算表，查询订单会员直推数据
-                        cuMemberRangeExtList = iCuMemberRetailRangeService.queryCuMemberSecondRangeExtByParent(rangeTableName, secondRangeTableName, targetMemberRangeExt.getPkMember());
-                    } else {
-                        // 昨日结算表，查询订单会员直推数据
-                        cuMemberRangeExtList = iCuMemberRetailRangeService.queryCuMemberRetailRangeExtByParent(rangeTableName, targetMemberRangeExt.getPkMember());
-                    }
-                    // 本人月消费业绩（默认为大区）
-                    BigDecimal consumeBigPv = targetMemberRangeExt.getMonthConsumePv();
-                    for (CuMemberRetailRangeExt cuMemberRetailRangeExt : cuMemberRangeExtList) {
-                        if (memberRangeExtMap.containsKey(cuMemberRetailRangeExt.getPkMember())) {
-                            cuMemberRetailRangeExt = memberRangeExtMap.get(cuMemberRetailRangeExt.getPkMember());
-                        }
-                        // 月累计业绩 = 本人月消费业绩 + 团队月消费业绩
-                        BigDecimal consumePv = ComputeUtil.computeAdd(cuMemberRetailRangeExt.getMonthConsumePv(), cuMemberRetailRangeExt.getAllTeamMonthPv());
-                        if (ComputeUtil.compareGreaterThan(consumePv, consumeBigPv)) {
-                            // 月累计业绩 > 大区业绩，则月累计就成为大区了
-                            consumeBigPv = consumePv;
-                        }
-                    }
-
-                    // 小区业绩 = 本人月消费业绩 + 团队月消费业绩 - 大区业绩
-                    BigDecimal smallAreaPv = ComputeUtil.computeAdd(targetMemberRangeExt.getMonthConsumePv(), ComputeUtil.computeSubtract(targetMemberRangeExt.getTeamMonthPv(), consumeBigPv));
-                    if (ComputeUtil.compareValue(smallAreaPv, bdAwards.getShareCommunityCheck())) {
-                        // 小区业绩 >= 小区考核业绩
-                        if (bdAwards.getPlaceDeptNum() > 0) {
-                            // 验证是否有多个区满足业绩
-                            List<CuMemberRetailRangeExt> cuMemberRetailRangeExtList;
-                            if (secondRangeTableName != null) {
-                                // 会员表 关联 秒结表 和 昨日结算表，查询订单会员直推数据
-                                cuMemberRetailRangeExtList = iCuMemberRetailRangeService.queryCuMemberSecondRangeExtByParent(rangeTableName, secondRangeTableName, targetMemberRangeExt.getPkMember());
-                            } else {
-                                // 昨日结算表，查询订单会员直推数据
-                                cuMemberRetailRangeExtList = iCuMemberRetailRangeService.queryCuMemberRetailRangeEnoughAchieve(rangeTableName, targetMemberRangeExt.getPkMember(), bdAwards.getShareCommunityCheck());
-                            }
-
-                            int enoughNum = 0;
-                            if (ComputeUtil.compareValue(targetMemberRangeExt.getMonthConsumePv(), bdAwards.getShareCommunityCheck())) {
-                                enoughNum += 1;
-                            }
-                            for (CuMemberRetailRangeExt cuMemberRetailRangeExt : cuMemberRetailRangeExtList) {
-                                if (memberRangeExtMap.containsKey(cuMemberRetailRangeExt.getPkMember())) {
-                                    cuMemberRetailRangeExt = memberRangeExtMap.get(cuMemberRetailRangeExt.getPkMember());
-                                }
-                                if (ComputeUtil.compareValue(ComputeUtil.computeAdd(cuMemberRetailRangeExt.getMonthConsumePv(), cuMemberRetailRangeExt.getAllTeamMonthPv()), bdAwards.getShareCommunityCheck())) {
-                                    // 本人月消费业绩 + 团队月消费业绩 >= 小区考核业绩，则满足条件小部门 +1
-                                    enoughNum += 1;
-                                }
-                            }
-                            if (bdAwards.getPlaceDeptNum() > enoughNum) {
-                                break;
-                            }
-                        }
-                        CuMemberAwards cuMemberRetailAwards = getCuMemberRetailAwards(targetMemberRangeExt, period, saOrderExt, bdAwards, EAwardsType.SHARE_TYPE.getValue(), targetMemberRangeExt.getPkShareAwards());
-                        cuMemberShareAwardsMap.put(cuMemberRetailAwards.getPkMember() + "_" + cuMemberRetailAwards.getNewLevel(), cuMemberRetailAwards);
-                        targetMemberRangeExt.setShareAwardsValue(bdAwards.getAwardsValue());
-                        targetMemberRangeExt.setPkShareAwards(bdAwards.getPkId());
-                        continue;
-                    }
-                }
-            }
-            break;
-        }
+//        // 计算分红奖衔
+//        while (true) {
+//            // 当月奖衔值 + 5，获取下一个奖衔值
+//            int awardsValue = targetMemberRangeExt.getShareAwardsValue() + 5;
+//            if (retailAwardsMap.containsKey(awardsValue)) {
+//                BdAwards bdAwards = retailAwardsMap.get(awardsValue);
+//                // 先验证累计业绩
+//                if (ComputeUtil.compareValue(ComputeUtil.computeAdd(targetMemberRangeExt.getTeamMonthPv(), targetMemberRangeExt.getMonthConsumePv()), bdAwards.getShareTotalCheck())) {
+//                    // 验证小区，计算小区业绩（拉取直推会员数据）
+//                    List<CuMemberRetailRangeExt> cuMemberRangeExtList;
+//                    if (secondRangeTableName != null) {
+//                        // 会员表 关联 秒结表 和 昨日结算表，查询订单会员直推数据
+//                        cuMemberRangeExtList = iCuMemberRetailRangeService.queryCuMemberSecondRangeExtByParent(rangeTableName, secondRangeTableName, targetMemberRangeExt.getPkMember());
+//                    } else {
+//                        // 昨日结算表，查询订单会员直推数据
+//                        cuMemberRangeExtList = iCuMemberRetailRangeService.queryCuMemberRetailRangeExtByParent(rangeTableName, targetMemberRangeExt.getPkMember());
+//                    }
+//                    // 本人月消费业绩（默认为大区）
+//                    BigDecimal consumeBigPv = targetMemberRangeExt.getMonthConsumePv();
+//                    for (CuMemberRetailRangeExt cuMemberRetailRangeExt : cuMemberRangeExtList) {
+//                        if (memberRangeExtMap.containsKey(cuMemberRetailRangeExt.getPkMember())) {
+//                            cuMemberRetailRangeExt = memberRangeExtMap.get(cuMemberRetailRangeExt.getPkMember());
+//                        }
+//                        // 月累计业绩 = 本人月消费业绩 + 团队月消费业绩
+//                        BigDecimal consumePv = ComputeUtil.computeAdd(cuMemberRetailRangeExt.getMonthConsumePv(), cuMemberRetailRangeExt.getAllTeamMonthPv());
+//                        if (ComputeUtil.compareGreaterThan(consumePv, consumeBigPv)) {
+//                            // 月累计业绩 > 大区业绩，则月累计就成为大区了
+//                            consumeBigPv = consumePv;
+//                        }
+//                    }
+//
+//                    // 小区业绩 = 本人月消费业绩 + 团队月消费业绩 - 大区业绩
+//                    BigDecimal smallAreaPv = ComputeUtil.computeAdd(targetMemberRangeExt.getMonthConsumePv(), ComputeUtil.computeSubtract(targetMemberRangeExt.getTeamMonthPv(), consumeBigPv));
+//                    if (ComputeUtil.compareValue(smallAreaPv, bdAwards.getShareCommunityCheck())) {
+//                        // 小区业绩 >= 小区考核业绩
+//                        if (bdAwards.getPlaceDeptNum() > 0) {
+//                            // 验证是否有多个区满足业绩
+//                            List<CuMemberRetailRangeExt> cuMemberRetailRangeExtList;
+//                            if (secondRangeTableName != null) {
+//                                // 会员表 关联 秒结表 和 昨日结算表，查询订单会员直推数据
+//                                cuMemberRetailRangeExtList = iCuMemberRetailRangeService.queryCuMemberSecondRangeExtByParent(rangeTableName, secondRangeTableName, targetMemberRangeExt.getPkMember());
+//                            } else {
+//                                // 昨日结算表，查询订单会员直推数据
+//                                cuMemberRetailRangeExtList = iCuMemberRetailRangeService.queryCuMemberRetailRangeEnoughAchieve(rangeTableName, targetMemberRangeExt.getPkMember(), bdAwards.getShareCommunityCheck());
+//                            }
+//
+//                            int enoughNum = 0;
+//                            if (ComputeUtil.compareValue(targetMemberRangeExt.getMonthConsumePv(), bdAwards.getShareCommunityCheck())) {
+//                                enoughNum += 1;
+//                            }
+//                            for (CuMemberRetailRangeExt cuMemberRetailRangeExt : cuMemberRetailRangeExtList) {
+//                                if (memberRangeExtMap.containsKey(cuMemberRetailRangeExt.getPkMember())) {
+//                                    cuMemberRetailRangeExt = memberRangeExtMap.get(cuMemberRetailRangeExt.getPkMember());
+//                                }
+//                                if (ComputeUtil.compareValue(ComputeUtil.computeAdd(cuMemberRetailRangeExt.getMonthConsumePv(), cuMemberRetailRangeExt.getAllTeamMonthPv()), bdAwards.getShareCommunityCheck())) {
+//                                    // 本人月消费业绩 + 团队月消费业绩 >= 小区考核业绩，则满足条件小部门 +1
+//                                    enoughNum += 1;
+//                                }
+//                            }
+//                            if (bdAwards.getPlaceDeptNum() > enoughNum) {
+//                                break;
+//                            }
+//                        }
+//                        CuMemberAwards cuMemberRetailAwards = getCuMemberRetailAwards(targetMemberRangeExt, period, saOrderExt, bdAwards, EAwardsType.SHARE_TYPE.getValue(), targetMemberRangeExt.getPkShareAwards());
+//                        cuMemberShareAwardsMap.put(cuMemberRetailAwards.getPkMember() + "_" + cuMemberRetailAwards.getNewLevel(), cuMemberRetailAwards);
+//                        targetMemberRangeExt.setShareAwardsValue(bdAwards.getAwardsValue());
+//                        targetMemberRangeExt.setPkShareAwards(bdAwards.getPkId());
+//                        continue;
+//                    }
+//                }
+//            }
+//            break;
+//        }
     }
 
 
@@ -818,32 +835,6 @@ public class BonusSettleRangeHandle extends BonusSettleHandle {
         cuMemberBonusPushList.add(cuMemberBonusPush);
     }
 
-    /**
-     * 获取直推、见点收益信息
-     */
-    CuMemberBonusPush getCuMemberBonusPush(SaOrderExt saOrderExt, CuMemberRetailRangeExt cuMemberRetailRange, CuMemberBonus cuMemberBonus, Integer pkBonusItems) {
-        CuMemberBonusPush cuMemberBonusPush = CuMemberBonusPush.builder()
-                .pkBonus(cuMemberBonus.getPkId())
-                .pkOrder(saOrderExt.getPkId())
-                .pkBonusItems(pkBonusItems)
-                .incomeStatus(cuMemberRetailRange.getIncomeStatus())
-                .calType(ECalType.RATIO.getValue())
-                .calAchieve(BigDecimal.ZERO)
-                .calValue(BigDecimal.ZERO)
-                .pretaxIncome(BigDecimal.ZERO)
-                .incomeTax(BigDecimal.ZERO)
-                .realIncome(BigDecimal.ZERO)
-                .round(-1)
-                .second(-1)
-                .incomeRatio(BigDecimal.ZERO)
-                .incomeDialRatio(BigDecimal.ZERO)
-                .orderDialRatio(BigDecimal.ZERO)
-                .build();
-        cuMemberBonusPush.setPkCountry(cuMemberRetailRange.getPkSettleCountry());
-        cuMemberBonusPush.setPkCreator(MagicNumberConstants.PK_ADMIN);
-        return cuMemberBonusPush;
-    }
-
     /**
      * 计算见点收益 -- 商城专区
      */
@@ -908,5 +899,127 @@ public class BonusSettleRangeHandle extends BonusSettleHandle {
         }
     }
 
+    /**
+     * 获取直推、见点收益信息
+     */
+    CuMemberBonusPush getCuMemberBonusPush(SaOrderExt saOrderExt, CuMemberRetailRangeExt cuMemberRetailRange, CuMemberBonus cuMemberBonus, Integer pkBonusItems) {
+        CuMemberBonusPush cuMemberBonusPush = CuMemberBonusPush.builder()
+                .pkBonus(cuMemberBonus.getPkId())
+                .pkOrder(saOrderExt.getPkId())
+                .pkBonusItems(pkBonusItems)
+                .incomeStatus(cuMemberRetailRange.getIncomeStatus())
+                .calType(ECalType.RATIO.getValue())
+                .calAchieve(BigDecimal.ZERO)
+                .calValue(BigDecimal.ZERO)
+                .pretaxIncome(BigDecimal.ZERO)
+                .incomeTax(BigDecimal.ZERO)
+                .realIncome(BigDecimal.ZERO)
+                .round(-1)
+                .second(-1)
+                .incomeRatio(BigDecimal.ZERO)
+                .incomeDialRatio(BigDecimal.ZERO)
+                .orderDialRatio(BigDecimal.ZERO)
+                .build();
+        cuMemberBonusPush.setPkCountry(cuMemberRetailRange.getPkSettleCountry());
+        cuMemberBonusPush.setPkCreator(MagicNumberConstants.PK_ADMIN);
+        return cuMemberBonusPush;
+    }
+
+    /**
+     * 计算阶段收益 -- 精品专区
+     */
+    private void calculateStageIncome(List<CuMemberBonusStage> cuMemberBonusStageList, Map<Long, CuMemberRetailRangeExt> memberRangeExtMap, SaOrderExt saOrderExt,
+                                      Date settleDate, String rangeTableName, String rangeDetailTableName) {
+        // 订单金额除50取整，为新増点位数量
+        int newPointInt = saOrderExt.getOrderAmount().divide(RetailConstants.POINT_VAL, 0, RoundingMode.DOWN).intValue();
+        if (newPointInt == 0) {
+            // 当前精品专区订单不足生成点位
+            return;
+        }
+
+        // 订单会员
+        CuMemberRetailRangeExt sourceMember = memberRangeExtMap.get(saOrderExt.getPkMember());
+        // 会员一阶段子点位列表
+        LinkedHashMap<Integer, CuMemberRetailDetail> detailList = sourceMember.getOneDetailMap();
+        if (null == detailList) {
+            detailList = new LinkedHashMap<>();
+            sourceMember.setOneDetailMap(detailList);
+        }
+        // 当前会员子点位总数
+        int pointCount = sourceMember.getPointCount();
+        for (int i = 1; i <= newPointInt; i++) {
+            // 订单会员生成的新点位
+            CuMemberRetailDetail newRetailDetail = CuMemberRetailDetail.builder()
+                    .pkMember(sourceMember.getPkMember())
+                    .childNode(pointCount + i)
+                    .pkParent(sourceMember.getPkParent())
+                    .stage(EBonusStage.ONE.getValue())
+                    .stageStatus(EBonusStageStatus.NO.getValue())
+                    .pointType(EBonusStageType.NORMAL.getValue())
+                    .pointGift(0)
+                    .creationTime(settleDate)
+                    .build();
+            detailList.put(newRetailDetail.getChildNode(), newRetailDetail);
+
+            // 推荐人
+            Long pkParent = sourceMember.getPkParent();
+            while (true) {
+                CuMemberRetailRangeExt targetMember = memberRangeExtMap.get(pkParent);
+                if (null == targetMember) {
+                    // 没有推荐人了，则直接结束
+                    break;
+                }
+                pkParent = targetMember.getPkParent();
+
+                // 推荐人一阶段子点位列表
+                LinkedHashMap<Integer, CuMemberRetailDetail> parentDetailList = targetMember.getOneDetailMap();
+                if (CollectionUtil.isEmpty(parentDetailList)) {
+                    // 推荐人没有未完成点位，继续往上找
+                    continue;
+                }
+                parentDetailList.forEach((key, parentRetailDetail) -> {
+                    // 遍历推荐人点位，使用第一个未完成的点位，进行填充
+                    if (EBonusStageStatus.NO.getValue() == parentRetailDetail.getStageStatus()) {
+                        String newNode = iCuMemberBonusStageService.fillChildNode(parentRetailDetail, newRetailDetail);
+                        if (null == newNode) {
+                            return;
+                        }
+                        switch (newNode) {
+                            case BonusConstants.POINT_11:
+                            case BonusConstants.POINT_12:
+                                // 新点位是推荐人点位的第一层
+                                iCuMemberBonusStageService.handlePointFirst(memberRangeExtMap, newRetailDetail, parentRetailDetail,
+                                        rangeTableName, rangeDetailTableName, newNode);
+                                break;
+                            case BonusConstants.POINT_21:
+                            case BonusConstants.POINT_22:
+                            case BonusConstants.POINT_23:
+                            case BonusConstants.POINT_24:
+                                // 新点位是推荐人点位的第二层
+                                iCuMemberBonusStageService.handlePointSecond(memberRangeExtMap, newRetailDetail, parentRetailDetail,
+                                        rangeTableName, rangeDetailTableName, newNode);
+                                break;
+                            case BonusConstants.POINT_38:
+                                // 第一个点位已经全部填满，更新完成状态和时间
+                                parentRetailDetail.setStageStatus(EBonusStageStatus.YES.getValue());
+                                parentRetailDetail.setStageDate(settleDate);
+                                // TODO 一阶段全满则需要发放一阶段奖金
+                                // TODO 需要记录填满子点位，用来处理生成二阶段以及生成赠点
+                            case BonusConstants.POINT_31:
+                            case BonusConstants.POINT_32:
+                            case BonusConstants.POINT_33:
+                            case BonusConstants.POINT_34:
+                            case BonusConstants.POINT_35:
+                            case BonusConstants.POINT_36:
+                            case BonusConstants.POINT_37:
+                                // 新点位是推荐人点位的第三层
+                                iCuMemberBonusStageService.handlePointThird(memberRangeExtMap, newRetailDetail, parentRetailDetail,
+                                        rangeTableName, rangeDetailTableName, newNode);
+                        }
+                    }
+                });
+            }
+        }
+    }
 
 }

bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/service/impl/BonusSettleServiceImpl.java

@@ -110,7 +110,7 @@ public class BonusSettleServiceImpl implements IBonusSettleService {
         // 查询奖金参数
         BonusConfigDTO bonusConfigDTO = iBonusItemsServiceApi.queryBonusConfigDTO().getData();
         // 需要处理的订单
-        List<SaOrderExt> retailOrderList = iBonusOrderService.listRetailSaOrder(DateUtils.beforeDate(6, ChronoUnit.DAYS), DateUtils.afterDate(1, ChronoUnit.DAYS), orderCode);
+        List<SaOrderExt> retailOrderList = iBonusOrderService.listRetailSaOrder(DateUtils.beforeDate(6, ChronoUnit.DAYS), DateUtils.afterDate(1, ChronoUnit.DAYS), orderCode, null);
 
         if (CollectionUtil.isNotEmpty(retailOrderList)) {
             // 会员奖金map

bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/service/impl/CuMemberBonusStageServiceImpl.java

@@ -0,0 +1,415 @@
+package com.hzs.bonus.bonus.service.impl;
+
+import cn.hutool.core.collection.CollectionUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.ReflectUtil;
+import com.hzs.bonus.achieve.mapper.CuMemberRetailRangeMapper;
+import com.hzs.bonus.achieve.service.ICuMemberRetailDetailService;
+import com.hzs.bonus.bonus.mapper.CuMemberBonusStageMapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.hzs.bonus.bonus.service.ICuMemberBonusStageService;
+import com.hzs.bonus.constant.BonusConstants;
+import com.hzs.common.core.enums.EBonusStage;
+import com.hzs.common.domain.member.achieve.CuMemberRetailDetail;
+import com.hzs.common.domain.member.achieve.ext.CuMemberRetailRangeExt;
+import com.hzs.common.domain.member.bonus.CuMemberBonusStage;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 会员奖金-阶段收益明细表 服务实现类
+ */
+@Service
+public class CuMemberBonusStageServiceImpl extends ServiceImpl<CuMemberBonusStageMapper, CuMemberBonusStage> implements ICuMemberBonusStageService {
+
+    @Autowired
+    private ICuMemberRetailDetailService iCuMemberRetailDetailService;
+
+    @Resource
+    private CuMemberRetailRangeMapper cuMemberRetailRangeMapper;
+
+    private void initFieldMap() {
+        BonusConstants.FIELD_MAP = new HashMap<>();
+        for (String suffix : BonusConstants.FIELD_LIST) {
+            BonusConstants.FIELD_MAP.put(BonusConstants.POINT_MEMBER_FIELD_NAME + suffix, ReflectUtil.getField(CuMemberRetailDetail.class, BonusConstants.POINT_MEMBER_FIELD_NAME + suffix));
+            BonusConstants.FIELD_MAP.put(BonusConstants.POINT_FIELD_NAME + suffix, ReflectUtil.getField(CuMemberRetailDetail.class, BonusConstants.POINT_FIELD_NAME + suffix));
+        }
+    }
+
+    @Override
+    public String fillChildNode(CuMemberRetailDetail cuMemberRetailDetail, CuMemberRetailDetail newRetailDetail) {
+        if (ObjectUtil.isEmpty(BonusConstants.FIELD_MAP)) {
+            initFieldMap();
+        }
+        for (String suffix : BonusConstants.FIELD_LIST) {
+            Field pointMemberField = BonusConstants.FIELD_MAP.get(BonusConstants.POINT_MEMBER_FIELD_NAME + suffix);
+            Field pointField = BonusConstants.FIELD_MAP.get(BonusConstants.POINT_FIELD_NAME + suffix);
+            Object pointFieldValue = ReflectUtil.getFieldValue(cuMemberRetailDetail, pointField);
+            if (ObjectUtil.isEmpty(pointFieldValue)) {
+                ReflectUtil.setFieldValue(cuMemberRetailDetail, pointMemberField, newRetailDetail.getPkMember());
+                ReflectUtil.setFieldValue(cuMemberRetailDetail, pointField, newRetailDetail.getChildNode());
+                return suffix;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 向上填充子点位
+     */
+    public void fillUpTargetRetailDetail(CuMemberRetailDetail targetRetailDetail, CuMemberRetailDetail newParentRetailDetail,
+                                         CuMemberRetailDetail newRetailDetail, String node) {
+        if (null == targetRetailDetail) {
+            return;
+        }
+        for (String suffix : BonusConstants.FIELD_LIST) {
+            Field pointMemberField = BonusConstants.FIELD_MAP.get(BonusConstants.POINT_MEMBER_FIELD_NAME + suffix);
+            Field pointField = BonusConstants.FIELD_MAP.get(BonusConstants.POINT_FIELD_NAME + suffix);
+            if (ReflectUtil.getFieldValue(targetRetailDetail, pointMemberField).equals(newParentRetailDetail.getPkMember())
+                    && ReflectUtil.getFieldValue(targetRetailDetail, pointField).equals(newParentRetailDetail.getChildNode())) {
+                // 中间点位在目标点位的位置，根据位置获取新点位填充的位置
+                switch (suffix) {
+                    case BonusConstants.POINT_11:
+                        if (BonusConstants.POINT_11.equals(node)) {
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_MEMBER_FIELD_NAME + BonusConstants.POINT_21, newRetailDetail.getPkMember());
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_FIELD_NAME + BonusConstants.POINT_21, newRetailDetail.getChildNode());
+                        } else if (BonusConstants.POINT_12.equals(node)) {
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_MEMBER_FIELD_NAME + BonusConstants.POINT_22, newRetailDetail.getPkMember());
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_FIELD_NAME + BonusConstants.POINT_22, newRetailDetail.getChildNode());
+                        } else if (BonusConstants.POINT_21.equals(node)) {
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_MEMBER_FIELD_NAME + BonusConstants.POINT_31, newRetailDetail.getPkMember());
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_FIELD_NAME + BonusConstants.POINT_31, newRetailDetail.getChildNode());
+                        } else if (BonusConstants.POINT_22.equals(node)) {
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_MEMBER_FIELD_NAME + BonusConstants.POINT_32, newRetailDetail.getPkMember());
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_FIELD_NAME + BonusConstants.POINT_32, newRetailDetail.getChildNode());
+                        } else if (BonusConstants.POINT_23.equals(node)) {
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_MEMBER_FIELD_NAME + BonusConstants.POINT_33, newRetailDetail.getPkMember());
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_FIELD_NAME + BonusConstants.POINT_33, newRetailDetail.getChildNode());
+                        } else if (BonusConstants.POINT_24.equals(node)) {
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_MEMBER_FIELD_NAME + BonusConstants.POINT_34, newRetailDetail.getPkMember());
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_FIELD_NAME + BonusConstants.POINT_34, newRetailDetail.getChildNode());
+                        }
+                        break;
+                    case BonusConstants.POINT_12:
+                        if (BonusConstants.POINT_11.equals(node)) {
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_MEMBER_FIELD_NAME + BonusConstants.POINT_23, newRetailDetail.getPkMember());
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_FIELD_NAME + BonusConstants.POINT_23, newRetailDetail.getChildNode());
+                        } else if (BonusConstants.POINT_12.equals(node)) {
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_MEMBER_FIELD_NAME + BonusConstants.POINT_24, newRetailDetail.getPkMember());
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_FIELD_NAME + BonusConstants.POINT_24, newRetailDetail.getChildNode());
+                        } else if (BonusConstants.POINT_21.equals(node)) {
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_MEMBER_FIELD_NAME + BonusConstants.POINT_35, newRetailDetail.getPkMember());
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_FIELD_NAME + BonusConstants.POINT_35, newRetailDetail.getChildNode());
+                        } else if (BonusConstants.POINT_22.equals(node)) {
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_MEMBER_FIELD_NAME + BonusConstants.POINT_36, newRetailDetail.getPkMember());
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_FIELD_NAME + BonusConstants.POINT_36, newRetailDetail.getChildNode());
+                        } else if (BonusConstants.POINT_23.equals(node)) {
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_MEMBER_FIELD_NAME + BonusConstants.POINT_37, newRetailDetail.getPkMember());
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_FIELD_NAME + BonusConstants.POINT_37, newRetailDetail.getChildNode());
+                        } else if (BonusConstants.POINT_24.equals(node)) {
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_MEMBER_FIELD_NAME + BonusConstants.POINT_38, newRetailDetail.getPkMember());
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_FIELD_NAME + BonusConstants.POINT_38, newRetailDetail.getChildNode());
+                        }
+                        break;
+                    case BonusConstants.POINT_21:
+                        if (BonusConstants.POINT_11.equals(node)) {
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_MEMBER_FIELD_NAME + BonusConstants.POINT_31, newRetailDetail.getPkMember());
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_FIELD_NAME + BonusConstants.POINT_31, newRetailDetail.getChildNode());
+                        } else if (BonusConstants.POINT_12.equals(node)) {
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_MEMBER_FIELD_NAME + BonusConstants.POINT_32, newRetailDetail.getPkMember());
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_FIELD_NAME + BonusConstants.POINT_32, newRetailDetail.getChildNode());
+                        }
+                        break;
+                    case BonusConstants.POINT_22:
+                        if (BonusConstants.POINT_11.equals(node)) {
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_MEMBER_FIELD_NAME + BonusConstants.POINT_33, newRetailDetail.getPkMember());
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_FIELD_NAME + BonusConstants.POINT_33, newRetailDetail.getChildNode());
+                        } else if (BonusConstants.POINT_12.equals(node)) {
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_MEMBER_FIELD_NAME + BonusConstants.POINT_34, newRetailDetail.getPkMember());
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_FIELD_NAME + BonusConstants.POINT_34, newRetailDetail.getChildNode());
+                        }
+                        break;
+                    case BonusConstants.POINT_23:
+                        if (BonusConstants.POINT_11.equals(node)) {
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_MEMBER_FIELD_NAME + BonusConstants.POINT_35, newRetailDetail.getPkMember());
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_FIELD_NAME + BonusConstants.POINT_35, newRetailDetail.getChildNode());
+                        } else if (BonusConstants.POINT_12.equals(node)) {
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_MEMBER_FIELD_NAME + BonusConstants.POINT_36, newRetailDetail.getPkMember());
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_FIELD_NAME + BonusConstants.POINT_36, newRetailDetail.getChildNode());
+                        }
+                        break;
+                    case BonusConstants.POINT_24:
+                        if (BonusConstants.POINT_11.equals(node)) {
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_MEMBER_FIELD_NAME + BonusConstants.POINT_37, newRetailDetail.getPkMember());
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_FIELD_NAME + BonusConstants.POINT_37, newRetailDetail.getChildNode());
+                        } else if (BonusConstants.POINT_12.equals(node)) {
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_MEMBER_FIELD_NAME + BonusConstants.POINT_38, newRetailDetail.getPkMember());
+                            ReflectUtil.setFieldValue(targetRetailDetail, BonusConstants.POINT_FIELD_NAME + BonusConstants.POINT_38, newRetailDetail.getChildNode());
+                        }
+                        break;
+                }
+                break;
+            }
+        }
+    }
+
+    /**
+     * 向下填充子点位
+     */
+    public void fillDownTargetRetailDetail(CuMemberRetailDetail targetRetailDetail, CuMemberRetailDetail newRetailDetail,
+                                           String node, Integer level) {
+        if (null == targetRetailDetail) {
+            return;
+        }
+        if (level.equals(1)) {
+            if (BonusConstants.POINT_21.equals(node)
+                    || BonusConstants.POINT_23.equals(node)
+                    || BonusConstants.POINT_31.equals(node)
+                    || BonusConstants.POINT_33.equals(node)
+                    || BonusConstants.POINT_35.equals(node)
+                    || BonusConstants.POINT_37.equals(node)) {
+                targetRetailDetail.setPointMember11(newRetailDetail.getPkMember());
+                targetRetailDetail.setPoint11(newRetailDetail.getChildNode());
+            } else if (BonusConstants.POINT_22.equals(node)
+                    || BonusConstants.POINT_24.equals(node)
+                    || BonusConstants.POINT_32.equals(node)
+                    || BonusConstants.POINT_34.equals(node)
+                    || BonusConstants.POINT_36.equals(node)
+                    || BonusConstants.POINT_38.equals(node)) {
+                targetRetailDetail.setPointMember12(newRetailDetail.getPkMember());
+                targetRetailDetail.setPoint12(newRetailDetail.getChildNode());
+            }
+        } else if (level.equals(2)) {
+            if (BonusConstants.POINT_31.equals(node)
+                    || BonusConstants.POINT_35.equals(node)) {
+                targetRetailDetail.setPointMember21(newRetailDetail.getPkMember());
+                targetRetailDetail.setPoint21(newRetailDetail.getChildNode());
+            } else if (BonusConstants.POINT_32.equals(node)
+                    || BonusConstants.POINT_36.equals(node)) {
+                targetRetailDetail.setPointMember22(newRetailDetail.getPkMember());
+                targetRetailDetail.setPoint22(newRetailDetail.getChildNode());
+            } else if (BonusConstants.POINT_33.equals(node)
+                    || BonusConstants.POINT_37.equals(node)) {
+                targetRetailDetail.setPointMember23(newRetailDetail.getPkMember());
+                targetRetailDetail.setPoint23(newRetailDetail.getChildNode());
+            } else if (BonusConstants.POINT_34.equals(node)
+                    || BonusConstants.POINT_38.equals(node)) {
+                targetRetailDetail.setPointMember24(newRetailDetail.getPkMember());
+                targetRetailDetail.setPoint24(newRetailDetail.getChildNode());
+            }
+        }
+    }
+
+    @Override
+    public void handlePointFirst(Map<Long, CuMemberRetailRangeExt> memberRangeExtMap,
+                                 CuMemberRetailDetail newRetailDetail, CuMemberRetailDetail newParentRetailDetail,
+                                 String rangeTableName, String rangeDetailTableName, String newNode) {
+        // 新点位的上第一层
+        newRetailDetail.setPointMemberFirst(newParentRetailDetail.getPkMember());
+        newRetailDetail.setPointFirst(newParentRetailDetail.getChildNode());
+
+        List<Long> queryMemberList = new ArrayList<>(2);
+        // 获取上第二、三层结算数据
+        CuMemberRetailRangeExt memberFirst = memberRangeExtMap.get(newParentRetailDetail.getPointMemberFirst());
+        if (null == memberFirst && null != newParentRetailDetail.getPointMemberFirst()) {
+            queryMemberList.add(newParentRetailDetail.getPointMemberFirst());
+        }
+        CuMemberRetailRangeExt memberSecond = memberRangeExtMap.get(newParentRetailDetail.getPointMemberSecond());
+        if (null == memberSecond && null != newParentRetailDetail.getPointMemberSecond()) {
+            queryMemberList.add(newParentRetailDetail.getPointMemberSecond());
+        }
+        if (CollectionUtil.isNotEmpty(queryMemberList)) {
+            // 查询会员数据
+            List<CuMemberRetailRangeExt> retailList = cuMemberRetailRangeMapper.listCuMemberRetailRange(rangeTableName, queryMemberList);
+            if (CollectionUtil.isNotEmpty(retailList)) {
+                retailList.forEach(tmpRetail -> {
+                    memberRangeExtMap.put(tmpRetail.getPkMember(), tmpRetail);
+                });
+                // 查询血缘会员明细数据（一阶段）
+                iCuMemberRetailDetailService.listMemberRetailDetail(rangeDetailTableName, memberRangeExtMap, queryMemberList, EBonusStage.ONE);
+            }
+        }
+
+        // 新点位的上第二层
+        newRetailDetail.setPointMemberSecond(newParentRetailDetail.getPointMemberFirst());
+        newRetailDetail.setPointSecond(newParentRetailDetail.getPointFirst());
+        CuMemberRetailRangeExt firstMemberRetail = memberRangeExtMap.get(newParentRetailDetail.getPointMemberFirst());
+        if (null != firstMemberRetail) {
+            CuMemberRetailDetail memberDetail = firstMemberRetail.getOneDetailMap().get(newParentRetailDetail.getPointFirst());
+            this.fillUpTargetRetailDetail(memberDetail, newParentRetailDetail, newRetailDetail, newNode);
+        }
+
+
+        // 新点位的上第三层
+        newRetailDetail.setPointMemberThird(newParentRetailDetail.getPointMemberSecond());
+        newRetailDetail.setPointThird(newParentRetailDetail.getPointSecond());
+        CuMemberRetailRangeExt secondMemberRetail = memberRangeExtMap.get(newParentRetailDetail.getPointMemberSecond());
+        if (null != secondMemberRetail) {
+            CuMemberRetailDetail memberDetail = secondMemberRetail.getOneDetailMap().get(newParentRetailDetail.getPointSecond());
+            this.fillUpTargetRetailDetail(memberDetail, newParentRetailDetail, newRetailDetail, newNode);
+        }
+    }
+
+    @Override
+    public void handlePointSecond(Map<Long, CuMemberRetailRangeExt> memberRangeExtMap,
+                                  CuMemberRetailDetail newRetailDetail, CuMemberRetailDetail newParentRetailDetail,
+                                  String rangeTableName, String rangeDetailTableName, String newNode) {
+        // 新点位的上第二层
+        newRetailDetail.setPointMemberSecond(newParentRetailDetail.getPkMember());
+        newRetailDetail.setPointSecond(newParentRetailDetail.getChildNode());
+
+        List<Long> queryMemberList = new ArrayList<>(2);
+        // 获取上第三层结算数据
+        CuMemberRetailRangeExt memberUpFirst = memberRangeExtMap.get(newParentRetailDetail.getPointMemberFirst());
+        if (null == memberUpFirst) {
+            queryMemberList.add(newParentRetailDetail.getPointMemberFirst());
+        }
+        // 获取上第一层结算数据
+        Long downFirstMember = null;
+        Integer downFirstPoint = null;
+        switch (newNode) {
+            case BonusConstants.POINT_21:
+            case BonusConstants.POINT_22:
+                downFirstMember = newParentRetailDetail.getPointMember11();
+                downFirstPoint = newParentRetailDetail.getPoint11();
+                break;
+            case BonusConstants.POINT_23:
+            case BonusConstants.POINT_24:
+                downFirstMember = newParentRetailDetail.getPointMember12();
+                downFirstPoint = newParentRetailDetail.getPoint12();
+                break;
+        }
+        CuMemberRetailRangeExt memberDownFirst = memberRangeExtMap.get(downFirstMember);
+        if (null == memberDownFirst) {
+            queryMemberList.add(downFirstMember);
+        }
+        if (CollectionUtil.isNotEmpty(queryMemberList)) {
+            // 查询会员数据
+            List<CuMemberRetailRangeExt> retailList = cuMemberRetailRangeMapper.listCuMemberRetailRange(rangeTableName, queryMemberList);
+            if (CollectionUtil.isNotEmpty(retailList)) {
+                retailList.forEach(tmpRetail -> {
+                    memberRangeExtMap.put(tmpRetail.getPkMember(), tmpRetail);
+                });
+                // 查询血缘会员明细数据（一阶段）
+                iCuMemberRetailDetailService.listMemberRetailDetail(rangeDetailTableName, memberRangeExtMap, queryMemberList, EBonusStage.ONE);
+            }
+        }
+
+        // 新点位的上第三层
+        newRetailDetail.setPointMemberThird(newParentRetailDetail.getPointMemberFirst());
+        newRetailDetail.setPointThird(newParentRetailDetail.getPointFirst());
+        CuMemberRetailRangeExt thirdMemberRetail = memberRangeExtMap.get(newParentRetailDetail.getPointMemberFirst());
+        if (null != thirdMemberRetail) {
+            CuMemberRetailDetail memberDetail = thirdMemberRetail.getOneDetailMap().get(newParentRetailDetail.getPointFirst());
+            this.fillUpTargetRetailDetail(memberDetail, newParentRetailDetail, newRetailDetail, newNode);
+        }
+
+        // 新点位的上第一层
+        CuMemberRetailRangeExt firstMemberRetail = memberRangeExtMap.get(downFirstMember);
+        if (null != firstMemberRetail) {
+            CuMemberRetailDetail memberDetail = firstMemberRetail.getOneDetailMap().get(downFirstPoint);
+            if (null != memberDetail) {
+                newRetailDetail.setPointMemberFirst(memberDetail.getPkMember());
+                newRetailDetail.setPointFirst(memberDetail.getChildNode());
+                this.fillDownTargetRetailDetail(memberDetail, newRetailDetail, newNode, 1);
+            }
+        }
+    }
+
+    @Override
+    public void handlePointThird(Map<Long, CuMemberRetailRangeExt> memberRangeExtMap,
+                                 CuMemberRetailDetail newRetailDetail, CuMemberRetailDetail newParentRetailDetail,
+                                 String rangeTableName, String rangeDetailTableName, String newNode) {
+        // 新点位的上第三层
+        newRetailDetail.setPointMemberThird(newParentRetailDetail.getPkMember());
+        newRetailDetail.setPointThird(newParentRetailDetail.getChildNode());
+
+        List<Long> queryMemberList = new ArrayList<>(2);
+        // 获取上第二层结算数据
+        Long downSecondMember = null;
+        Integer downSecondPoint = null;
+        // 获取上第一层结算数据
+        Long downFirstMember = null;
+        Integer downFirstPoint = null;
+        switch (newNode) {
+            case BonusConstants.POINT_31:
+            case BonusConstants.POINT_32:
+            case BonusConstants.POINT_33:
+            case BonusConstants.POINT_34:
+                downSecondMember = newParentRetailDetail.getPointMember11();
+                downSecondPoint = newParentRetailDetail.getPoint11();
+                if (BonusConstants.POINT_31.equals(newNode)
+                        || BonusConstants.POINT_32.equals(newNode)) {
+                    downFirstMember = newParentRetailDetail.getPointMember21();
+                    downFirstPoint = newParentRetailDetail.getPoint21();
+                } else {
+                    downFirstMember = newParentRetailDetail.getPointMember22();
+                    downFirstPoint = newParentRetailDetail.getPoint22();
+                }
+                break;
+            case BonusConstants.POINT_35:
+            case BonusConstants.POINT_36:
+            case BonusConstants.POINT_37:
+            case BonusConstants.POINT_38:
+                downSecondMember = newParentRetailDetail.getPointMember12();
+                downSecondPoint = newParentRetailDetail.getPoint12();
+                if (BonusConstants.POINT_35.equals(newNode)
+                        || BonusConstants.POINT_36.equals(newNode)) {
+                    downFirstMember = newParentRetailDetail.getPointMember23();
+                    downFirstPoint = newParentRetailDetail.getPoint23();
+                } else {
+                    downFirstMember = newParentRetailDetail.getPointMember24();
+                    downFirstPoint = newParentRetailDetail.getPoint24();
+                }
+                break;
+        }
+        CuMemberRetailRangeExt memberDownSecond = memberRangeExtMap.get(downSecondMember);
+        if (null == memberDownSecond) {
+            queryMemberList.add(downSecondMember);
+        }
+        CuMemberRetailRangeExt memberDownFirst = memberRangeExtMap.get(downFirstMember);
+        if (null == memberDownFirst) {
+            queryMemberList.add(downFirstMember);
+        }
+        if (CollectionUtil.isNotEmpty(queryMemberList)) {
+            // 查询会员数据
+            List<CuMemberRetailRangeExt> retailList = cuMemberRetailRangeMapper.listCuMemberRetailRange(rangeTableName, queryMemberList);
+            if (CollectionUtil.isNotEmpty(retailList)) {
+                retailList.forEach(tmpRetail -> {
+                    memberRangeExtMap.put(tmpRetail.getPkMember(), tmpRetail);
+                });
+                // 查询血缘会员明细数据（一阶段）
+                iCuMemberRetailDetailService.listMemberRetailDetail(rangeDetailTableName, memberRangeExtMap, queryMemberList, EBonusStage.ONE);
+            }
+        }
+
+        // 新点位的上第二层
+        CuMemberRetailRangeExt secondMemberRetail = memberRangeExtMap.get(downSecondMember);
+        if (null != secondMemberRetail) {
+            CuMemberRetailDetail memberDetail = secondMemberRetail.getOneDetailMap().get(downSecondPoint);
+            if (null != memberDetail) {
+                newRetailDetail.setPointMemberSecond(newParentRetailDetail.getPkMember());
+                newRetailDetail.setPointSecond(newParentRetailDetail.getChildNode());
+                this.fillDownTargetRetailDetail(memberDetail, newRetailDetail, newNode, 2);
+            }
+        }
+
+        // 新点位的上第一层
+        CuMemberRetailRangeExt firstMemberRetail = memberRangeExtMap.get(downFirstMember);
+        if (null != firstMemberRetail) {
+            CuMemberRetailDetail memberDetail = firstMemberRetail.getOneDetailMap().get(downFirstPoint);
+            if (null != memberDetail) {
+                newRetailDetail.setPointMemberFirst(newParentRetailDetail.getPkMember());
+                newRetailDetail.setPointFirst(newParentRetailDetail.getChildNode());
+                this.fillDownTargetRetailDetail(memberDetail, newRetailDetail, newNode, 1);
+            }
+        }
+    }
+}

bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/constant/BonusConstants.java

@@ -0,0 +1,33 @@
+package com.hzs.bonus.constant;
+
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+public class BonusConstants {
+
+    public static final String POINT_11 = "11";
+    public static final String POINT_12 = "12";
+    public static final String POINT_21 = "21";
+    public static final String POINT_22 = "22";
+    public static final String POINT_23 = "23";
+    public static final String POINT_24 = "24";
+    public static final String POINT_31 = "31";
+    public static final String POINT_32 = "32";
+    public static final String POINT_33 = "33";
+    public static final String POINT_34 = "34";
+    public static final String POINT_35 = "35";
+    public static final String POINT_36 = "36";
+    public static final String POINT_37 = "37";
+    public static final String POINT_38 = "38";
+
+    public static final List<String> FIELD_LIST = Arrays.asList(POINT_11, POINT_12, POINT_21, POINT_22, POINT_23, POINT_24,
+            POINT_31, POINT_32, POINT_33, POINT_34, POINT_35, POINT_36, POINT_37, POINT_38);
+
+    public static final String POINT_FIELD_NAME = "point";
+    public static final String POINT_MEMBER_FIELD_NAME = "pointMember";
+
+    public static Map<String, Field> FIELD_MAP = null;
+
+}

bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/order/mapper/BonusOrderMapper.java

@@ -16,6 +16,7 @@ public interface BonusOrderMapper {
      */
     List<SaOrderExt> listRetailSaOrder(@Param("startDate") Date startDate,
                                        @Param("endDate") Date endDate,
-                                       @Param("orderCode") String orderCode);
+                                       @Param("orderCode") String orderCode,
+                                       @Param("orderTypeList") List<Integer> orderTypeList);
 
 }

bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/order/service/IBonusOrderService.java

@@ -13,6 +13,6 @@ public interface IBonusOrderService {
      * @param startDate 开始日期
      * @param endDate   结束日期
      */
-    List<SaOrderExt> listRetailSaOrder(Date startDate, Date endDate, String orderCode);
+    List<SaOrderExt> listRetailSaOrder(Date startDate, Date endDate, String orderCode, List<Integer> orderTypeList);
 
 }

bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/order/service/impl/BonusOrderServiceImpl.java

@@ -15,8 +15,8 @@ public class BonusOrderServiceImpl implements IBonusOrderService {
     private BonusOrderMapper bonusOrderMapper;
 
     @Override
-    public List<SaOrderExt> listRetailSaOrder(Date startDate, Date endDate, String orderCode) {
-        return bonusOrderMapper.listRetailSaOrder(startDate, endDate, orderCode);
+    public List<SaOrderExt> listRetailSaOrder(Date startDate, Date endDate, String orderCode, List<Integer> orderTypeList) {
+        return bonusOrderMapper.listRetailSaOrder(startDate, endDate, orderCode, orderTypeList);
     }
 
 }

bd-business/bd-business-bonus/src/main/resources/mapper/bonus/achieve/CuMemberRetailDetailMapper.xml

@@ -2,5 +2,17 @@
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.hzs.bonus.achieve.mapper.CuMemberRetailDetailMapper">
 
+    <!-- 查询明细数据 -->
+    <select id="listMemberRetailDetail" resultType="com.hzs.common.domain.member.achieve.CuMemberRetailDetail">
+        select cmrd.*
+        from ${retailDetailTableName} cmrd
+        where cmrd.pk_member in
+        <foreach collection="tmpIdList" item="items" open="(" close=")" separator=",">
+            #{items}
+        </foreach>
+        and cmrd.stage = #{stage}
+        and cmrd.stage_status = 1
+        order by cmrd.pk_member, cmrd.child_node
+    </select>
 
 </mapper>

bd-business/bd-business-bonus/src/main/resources/mapper/bonus/achieve/CuMemberRetailRangeMapper.xml

@@ -50,11 +50,10 @@
         <result column="rep_consume_new_pv" property="repConsumeNewPv"/>
         <result column="rep_team_new_amount" property="repTeamNewAmount"/>
         <result column="rep_team_new_pv" property="repTeamNewPv"/>
+        <result column="point_count" property="pointCount"/>
 
         <result column="AWARDS_VALUE" property="awardsValue"/>
         <result column="AWARDS_NAME" property="awardsName"/>
-        <result column="SHARE_AWARDS_VALUE" property="shareAwardsValue"/>
-        <result column="SHARE_AWARDS_NAME" property="shareAwardsName"/>
         <result column="RANGE_RATIO" property="rangeRatio"/>
         <result column="MONTH_REPURCHASE_RATIO" property="monthRepurchaseRatio"/>
         <result column="BENEFIT_AVG_RATIO" property="benefitAvgRatio"/>
@@ -125,6 +124,191 @@
         </if>
     </update>
 
+    <!-- 将昨天的结算明细迁移到今天 -->
+    <update id="mergeMemberRetailRangeDetailByYesterday">
+        merge into ${detailTableName} a
+            using (
+                select x.pk_member,
+                       x.child_node,
+                       cm.pk_parent,
+                       x.stage,
+                       x.stage_status,
+                       x.stage_date,
+                       x.point_11,
+                       x.point_12,
+                       x.point_21,
+                       x.point_22,
+                       x.point_23,
+                       x.point_24,
+                       x.point_31,
+                       x.point_32,
+                       x.point_33,
+                       x.point_34,
+                       x.point_35,
+                       x.point_36,
+                       x.point_37,
+                       x.point_38,
+                       x.point_member_11,
+                       x.point_member_12,
+                       x.point_member_21,
+                       x.point_member_22,
+                       x.point_member_23,
+                       x.point_member_24,
+                       x.point_member_31,
+                       x.point_member_32,
+                       x.point_member_33,
+                       x.point_member_34,
+                       x.point_member_35,
+                       x.point_member_36,
+                       x.point_member_37,
+                       x.point_member_38,
+                       x.point_type,
+                       x.point_gift,
+                       x.creation_time,
+                       x.point_first,
+                       x.point_member_first,
+                       x.point_second,
+                       x.point_member_second,
+                       x.point_third,
+                       x.point_member_third
+                from ${yesterdayDetailTableName} x
+                         left join cu_member cm
+                                   on cm.pk_id = x.pk_member
+            ) b
+            on (a.pk_member = b.pk_member and a.child_node = b.child_node)
+            when not matched then
+                insert (pk_member,
+                        child_node,
+                        pk_parent,
+                        stage,
+                        stage_status,
+                        stage_date,
+                        point_11,
+                        point_12,
+                        point_21,
+                        point_22,
+                        point_23,
+                        point_24,
+                        point_31,
+                        point_32,
+                        point_33,
+                        point_34,
+                        point_35,
+                        point_36,
+                        point_37,
+                        point_38,
+                        point_member_11,
+                        point_member_12,
+                        point_member_21,
+                        point_member_22,
+                        point_member_23,
+                        point_member_24,
+                        point_member_31,
+                        point_member_32,
+                        point_member_33,
+                        point_member_34,
+                        point_member_35,
+                        point_member_36,
+                        point_member_37,
+                        point_member_38,
+                        point_type,
+                        point_gift,
+                        creation_time,
+                        point_first,
+                        point_member_first,
+                        point_second,
+                        point_member_second,
+                        point_third,
+                        point_member_third)
+                    values (b.pk_member,
+                            b.child_node,
+                            b.pk_parent,
+                            b.stage,
+                            b.stage_status,
+                            b.stage_date,
+                            b.point_11,
+                            b.point_12,
+                            b.point_21,
+                            b.point_22,
+                            b.point_23,
+                            b.point_24,
+                            b.point_31,
+                            b.point_32,
+                            b.point_33,
+                            b.point_34,
+                            b.point_35,
+                            b.point_36,
+                            b.point_37,
+                            b.point_38,
+                            b.point_member_11,
+                            b.point_member_12,
+                            b.point_member_21,
+                            b.point_member_22,
+                            b.point_member_23,
+                            b.point_member_24,
+                            b.point_member_31,
+                            b.point_member_32,
+                            b.point_member_33,
+                            b.point_member_34,
+                            b.point_member_35,
+                            b.point_member_36,
+                            b.point_member_37,
+                            b.point_member_38,
+                            b.point_type,
+                            b.point_gift,
+                            b.creation_time,
+                            b.point_first,
+                            b.point_member_first,
+                            b.point_second,
+                            b.point_member_second,
+                            b.point_third,
+                            b.point_member_third)
+            when matched then
+                update set
+                    a.pk_parent = b.pk_parent,
+                    a.stage = b.stage,
+                    a.stage_status = b.stage_status,
+                    a.stage_date = b.stage_date,
+                    a.point_11 = b.point_11,
+                    a.point_12 = b.point_12,
+                    a.point_21 = b.point_21,
+                    a.point_22 = b.point_22,
+                    a.point_23 = b.point_23,
+                    a.point_24 = b.point_24,
+                    a.point_31 = b.point_31,
+                    a.point_32 = b.point_32,
+                    a.point_33 = b.point_33,
+                    a.point_34 = b.point_34,
+                    a.point_35 = b.point_35,
+                    a.point_36 = b.point_36,
+                    a.point_37 = b.point_37,
+                    a.point_38 = b.point_38,
+                    a.point_member_11 = b.point_member_11,
+                    a.point_member_12 = b.point_member_12,
+                    a.point_member_21 = b.point_member_21,
+                    a.point_member_22 = b.point_member_22,
+                    a.point_member_23 = b.point_member_23,
+                    a.point_member_24 = b.point_member_24,
+                    a.point_member_31 = b.point_member_31,
+                    a.point_member_32 = b.point_member_32,
+                    a.point_member_33 = b.point_member_33,
+                    a.point_member_34 = b.point_member_34,
+                    a.point_member_35 = b.point_member_35,
+                    a.point_member_36 = b.point_member_36,
+                    a.point_member_37 = b.point_member_37,
+                    a.point_member_38 = b.point_member_38,
+                    a.point_type = b.point_type,
+                    a.point_gift = b.point_gift,
+                    a.creation_time = b.creation_time,
+                    a.point_first = b.point_first,
+                    a.point_member_first = b.point_member_first,
+                    a.point_second = b.point_second,
+                    a.point_member_second = b.point_member_second,
+                    a.point_third = b.point_third,
+                    a.point_member_third = b.point_member_third
+    </update>
+
+    <!-- 更新会员日结数据 -->
     <update id="mergeCuMemberRetailRangeExt">
         merge into ${rangeTableName} a
         using (
@@ -156,6 +340,104 @@
         a.rep_team_new_amount = b.rep_team_new_amount, a.rep_team_new_pv = b.rep_team_new_pv
     </update>
 
+    <!-- 更新会员日结数据 -->
+    <update id="mergeCuMemberRetailDetail">
+        merge into ${rangeDetailTableName} a
+        using (
+        <foreach collection="cuMemberDetailList" item="item" open=" " close=" " separator=" union ">
+            select
+            #{item.pkMember} pk_member, #{item.childNode} child_node, #{item.pkParent} pk_parent,
+            #{item.stage} stage, #{item.stageStatus} stage_status, #{item.stageDate, jdbcType=TIMESTAMP} stage_date,
+            #{item.point11, jdbcType=NUMERIC} point_11, #{item.point12, jdbcType=NUMERIC} point_12,
+            #{item.point21, jdbcType=NUMERIC} point_21, #{item.point22, jdbcType=NUMERIC} point_22,
+            #{item.point23, jdbcType=NUMERIC} point_23, #{item.point24, jdbcType=NUMERIC} point_24,
+            #{item.point31, jdbcType=NUMERIC} point_31, #{item.point32, jdbcType=NUMERIC} point_32,
+            #{item.point33, jdbcType=NUMERIC} point_33, #{item.point34, jdbcType=NUMERIC} point_34,
+            #{item.point35, jdbcType=NUMERIC} point_35, #{item.point36, jdbcType=NUMERIC} point_36,
+            #{item.point37, jdbcType=NUMERIC} point_37, #{item.point38, jdbcType=NUMERIC} point_38,
+            #{item.pointMember11, jdbcType=NUMERIC} point_member_11, #{item.pointMember12, jdbcType=NUMERIC} point_member_12,
+            #{item.pointMember21, jdbcType=NUMERIC} point_member_21, #{item.pointMember22, jdbcType=NUMERIC} point_member_22,
+            #{item.pointMember23, jdbcType=NUMERIC} point_member_23, #{item.pointMember24, jdbcType=NUMERIC} point_member_24,
+            #{item.pointMember31, jdbcType=NUMERIC} point_member_31, #{item.pointMember32, jdbcType=NUMERIC} point_member_32,
+            #{item.pointMember33, jdbcType=NUMERIC} point_member_33, #{item.pointMember34, jdbcType=NUMERIC} point_member_34,
+            #{item.pointMember35, jdbcType=NUMERIC} point_member_35, #{item.pointMember36, jdbcType=NUMERIC} point_member_36,
+            #{item.pointMember37, jdbcType=NUMERIC} point_member_37, #{item.pointMember38, jdbcType=NUMERIC} point_member_38,
+            #{item.pointType} point_type, #{item.pointGift} point_gift,
+            #{item.creationTime, jdbcType=TIMESTAMP} creation_time,
+            #{item.pointFirst, jdbcType=NUMERIC} point_first, #{item.pointMemberFirst, jdbcType=NUMERIC} point_member_first,
+            #{item.pointSecond, jdbcType=NUMERIC} point_second, #{item.pointMemberSecond, jdbcType=NUMERIC} point_member_second,
+            #{item.pointThird, jdbcType=NUMERIC} point_third, #{item.pointMemberThird, jdbcType=NUMERIC} point_member_third
+            from dual
+        </foreach>
+        ) b
+        on (a.pk_member = b.pk_member and a.child_node = b.child_node)
+        when not matched then
+        insert (pk_member, child_node, pk_parent,
+        stage, stage_status, stage_date,
+        point_11, point_12,
+        point_21, point_22,
+        point_23, point_24,
+        point_31, point_32,
+        point_33, point_34,
+        point_35, point_36,
+        point_37, point_38,
+        point_member_11, point_member_12,
+        point_member_21, point_member_22,
+        point_member_23, point_member_24,
+        point_member_31, point_member_32,
+        point_member_33, point_member_34,
+        point_member_35, point_member_36,
+        point_member_37, point_member_38,
+        point_type, point_gift,
+        creation_time,
+        point_first, point_member_first,
+        point_second, point_member_second,
+        point_third, point_member_third)
+        values (b.pk_member, b.child_node, b.pk_parent,
+        b.stage, b.stage_status, b.stage_date,
+        b.point_11, b.point_12,
+        b.point_21, b.point_22,
+        b.point_23, b.point_24,
+        b.point_31, b.point_32,
+        b.point_33, b.point_34,
+        b.point_35, b.point_36,
+        b.point_37, b.point_38,
+        b.point_member_11, b.point_member_12,
+        b.point_member_21, b.point_member_22,
+        b.point_member_23, b.point_member_24,
+        b.point_member_31, b.point_member_32,
+        b.point_member_33, b.point_member_34,
+        b.point_member_35, b.point_member_36,
+        b.point_member_37, b.point_member_38,
+        b.point_type, b.point_gift,
+        b.creation_time,
+        b.point_first, b.point_member_first,
+        b.point_second, b.point_member_second,
+        b.point_third, b.point_member_third)
+        when matched then
+        update set
+        a.stage = b.stage, a.stage_status = b.stage_status, a.stage_date = b.stage_date,
+        a.point_11 = b.point_11, a.point_12 = b.point_12,
+        a.point_21 = b.point_21, a.point_22 = b.point_22,
+        a.point_23 = b.point_23, a.point_24 = b.point_24,
+        a.point_31 = b.point_31, a.point_32 = b.point_32,
+        a.point_33 = b.point_33, a.point_34 = b.point_34,
+        a.point_35 = b.point_35, a.point_36 = b.point_36,
+        a.point_37 = b.point_37, a.point_38 = b.point_38,
+        a.point_member_11 = b.point_member_11, a.point_member_12 = b.point_member_12,
+        a.point_member_21 = b.point_member_21, a.point_member_22 = b.point_member_22,
+        a.point_member_23 = b.point_member_23, a.point_member_24 = b.point_member_24,
+        a.point_member_31 = b.point_member_31, a.point_member_32 = b.point_member_32,
+        a.point_member_33 = b.point_member_33, a.point_member_34 = b.point_member_34,
+        a.point_member_35 = b.point_member_35, a.point_member_36 = b.point_member_36,
+        a.point_member_37 = b.point_member_37, a.point_member_38 = b.point_member_38,
+        a.point_type = b.point_type, a.point_gift = b.point_gift,
+        a.creation_time = b.creation_time,
+        a.point_first = b.point_first, a.point_member_first = b.point_member_first,
+        a.point_second = b.point_second, a.point_member_second = b.point_member_second,
+        a.point_third = b.point_third, a.point_member_third = b.point_member_third
+    </update>
+
     <!-- 当前网体更新极差秒接表 -->
     <update id="mergeMemberSecondRetailRangeByRange">
         merge into ${secondRangeTableName} a
@@ -321,48 +603,95 @@
             rep_consume_new_pv,
             rep_team_new_amount,
             rep_team_new_pv,
+            point_count,
             bw.awards_value,
-            bw.awards_name,
-            bwa.awards_value share_awards_value,
-            bwa.awards_name share_awards_name
+            bw.awards_name
             from (
             select * from ${tableName}
             start with pk_member = #{item}
             connect by pk_member = prior pk_parent
             ) a
             inner join bd_awards bw
-            on bw.pk_id = a.pk_awards and bw.del_flag = 0
-            left join bd_awards bwa
-            on bwa.pk_id = a.pk_share_awards and bwa.del_flag = 0
+            on bw.pk_id = a.pk_awards
             left join bd_vertex bv
             on bv.pk_id = a.pk_vertex
         </foreach>
     </select>
 
+    <select id="listCuMemberRetailRange" resultMap="CuMemberRetailRangeExt">
+        select
+        a.pk_member,
+        a.pk_parent,
+        a.member_code,
+        a.member_name,
+        a.pk_grade,
+        a.pk_awards,
+        a.pk_share_awards,
+        a.account_status,
+        a.pay_time,
+        a.category,
+        a.income_status,
+        a.pk_vertex,
+        a.pk_settle_country,
+        a.pk_rate,
+        new_consume_pv,
+        consume_pv,
+        month_consume_pv,
+        new_consume_amount,
+        consume_amount,
+        month_consume_amount,
+        team_new_pv,
+        team_consume_pv,
+        team_month_pv,
+        team_new_amount,
+        team_consume_amount,
+        team_month_amount,
+        recommend_num,
+        team_num,
+        big_team_pv,
+        small_team_pv,
+        reg_consume_new_amount,
+        reg_consume_new_pv,
+        reg_team_new_amount,
+        reg_team_new_pv,
+        rep_consume_new_amount,
+        rep_consume_new_pv,
+        rep_team_new_amount,
+        rep_team_new_pv,
+        bw.awards_value,
+        bw.awards_name
+        from ${tableName} a
+        inner join bd_awards bw
+        on bw.pk_id = a.pk_awards
+        left join bd_vertex bv
+        on bv.pk_id = a.pk_vertex
+        where a.pk_member in
+        <foreach collection="pkMemberList" item="items" open="(" close=")" separator=",">
+            #{items}
+        </foreach>
+    </select>
+
     <select id="queryCuMemberRetailRangeExtByParent" resultMap="CuMemberRetailRangeExt">
         select a.pk_member,
+               a.pk_parent,
                a.member_code,
                a.member_name,
-               a.pk_parent,
-               a.pk_settle_country,
-               a.category,
-               a.account_status,
                a.pk_grade,
                a.pk_awards,
                a.pk_share_awards,
-               a.income_status,
-               a.consume_pv,
+               a.account_status,
                a.pay_time,
-               a.pk_rate,
+               a.category,
                a.income_status,
-               a.pk_country,
+               a.pk_vertex,
                a.pk_settle_country,
-               a.big_team_pv,
-               a.small_team_pv,
-               a.system_type,
+               a.pk_rate,
                new_consume_pv,
                consume_pv,
                month_consume_pv,
+               new_consume_amount,
+               consume_amount,
+               month_consume_amount,
                team_new_pv,
                team_consume_pv,
                team_month_pv,
@@ -371,22 +700,24 @@
                team_month_amount,
                recommend_num,
                team_num,
+               big_team_pv,
+               small_team_pv,
+               reg_consume_new_amount,
+               reg_consume_new_pv,
+               reg_team_new_amount,
+               reg_team_new_pv,
+               rep_consume_new_amount,
+               rep_consume_new_pv,
+               rep_team_new_amount,
+               rep_team_new_pv,
                bw.awards_value,
-               bw.awards_name,
-               bws.awards_value share_awards_value,
-               bw.range_ratio,
-               bw.month_repurchase_ratio,
-               bw.benefit_avg_ratio,
-               bw.benefit_share_ratio
+               bw.awards_name
         from ${tableName} a
-                 inner join bd_grade ba
-                            on a.pk_grade = ba.pk_id
                  inner join bd_awards bw
-                            on bw.pk_id = a.pk_awards and bw.del_flag = 0
-                 inner join bd_awards bws
-                            on bws.pk_id = a.pk_share_awards and bws.del_flag = 0
-        where ba.del_flag = 0
-          and a.pk_parent = #{pkParent}
+                            on bw.pk_id = a.pk_awards
+                 left join bd_vertex bv
+                           on bv.pk_id = a.pk_vertex
+        where a.pk_parent = #{pkParent}
     </select>
 
     <select id="queryCuMemberSecondRangeParent" resultMap="CuMemberRetailRangeExt">

bd-business/bd-business-bonus/src/main/resources/mapper/bonus/achieve/CuMemberTreeMapper.xml

@@ -292,53 +292,58 @@
     <update id="createCuMemberRetailDetail">
         create table ${tableName}
         (
-            pk_id           NUMBER(20) primary key,
-            pk_member       NUMBER(20) not null,
-            child_node      NUMBER(8) not null,
-            pk_parent       NUMBER(20) not null,
-            stage           NUMBER(1) default 1 not null,
-            stage_status    NUMBER(1) default 1 not null,
-            stage_date      DATE,
-            point_11        NUMBER(20),
-            point_12        NUMBER(20),
-            point_21        NUMBER(20),
-            point_22        NUMBER(20),
-            point_23        NUMBER(20),
-            point_24        NUMBER(20),
-            point_31        NUMBER(20),
-            point_32        NUMBER(20),
-            point_33        NUMBER(20),
-            point_34        NUMBER(20),
-            point_35        NUMBER(20),
-            point_36        NUMBER(20),
-            point_37        NUMBER(20),
-            point_38        NUMBER(20),
-            point_member_11 NUMBER(20),
-            point_member_12 NUMBER(20),
-            point_member_21 NUMBER(20),
-            point_member_22 NUMBER(20),
-            point_member_23 NUMBER(20),
-            point_member_24 NUMBER(20),
-            point_member_31 NUMBER(20),
-            point_member_32 NUMBER(20),
-            point_member_33 NUMBER(20),
-            point_member_34 NUMBER(20),
-            point_member_35 NUMBER(20),
-            point_member_36 NUMBER(20),
-            point_member_37 NUMBER(20),
-            point_member_38 NUMBER(20),
-            point_type      NUMBER(1) default 0 not null,
-            point_gift      NUMBER(1) default 0 not null,
-            creation_time   DATE
+            pk_member           NUMBER(20) not null,
+            child_node          NUMBER(8) not null,
+            pk_parent           NUMBER(20) not null,
+            stage               NUMBER(1) default 1 not null,
+            stage_status        NUMBER(1) default 1 not null,
+            stage_date          DATE,
+            point_11            NUMBER(8),
+            point_12            NUMBER(8),
+            point_21            NUMBER(8),
+            point_22            NUMBER(8),
+            point_23            NUMBER(8),
+            point_24            NUMBER(8),
+            point_31            NUMBER(8),
+            point_32            NUMBER(8),
+            point_33            NUMBER(8),
+            point_34            NUMBER(8),
+            point_35            NUMBER(8),
+            point_36            NUMBER(8),
+            point_37            NUMBER(8),
+            point_38            NUMBER(8),
+            point_member_11     NUMBER(20),
+            point_member_12     NUMBER(20),
+            point_member_21     NUMBER(20),
+            point_member_22     NUMBER(20),
+            point_member_23     NUMBER(20),
+            point_member_24     NUMBER(20),
+            point_member_31     NUMBER(20),
+            point_member_32     NUMBER(20),
+            point_member_33     NUMBER(20),
+            point_member_34     NUMBER(20),
+            point_member_35     NUMBER(20),
+            point_member_36     NUMBER(20),
+            point_member_37     NUMBER(20),
+            point_member_38     NUMBER(20),
+            point_type          NUMBER(1) default 0 not null,
+            point_gift          NUMBER(1) default 0 not null,
+            creation_time       DATE,
+            point_first         NUMBER(8),
+            point_member_first  NUMBER(20),
+            point_second        NUMBER(8),
+            point_member_second NUMBER(20),
+            point_third         NUMBER(8),
+            point_member_third  NUMBER(20)
         )
     </update>
 
     <!-- 创建结算明细表会员索引 -->
     <update id="createCuMemberRetailDetailMemberIndex">
-        create index ${tableName}_MEMBER
+        create unique index PK_${tableName}
         on ${tableName}
         (
-        PK_MEMBER
+        PK_MEMBER, CHILD_NODE
         )
     </update>
 

bd-business/bd-business-bonus/src/main/resources/mapper/bonus/bonus/CuMemberBonusStageMapper.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.hzs.bonus.bonus.mapper.CuMemberBonusStageMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="com.hzs.common.domain.member.bonus.CuMemberBonusStage">
+        <id column="PK_ID" property="pkId"/>
+        <result column="DEL_FLAG" property="delFlag"/>
+        <result column="PK_COUNTRY" property="pkCountry"/>
+        <result column="PK_CREATOR" property="pkCreator"/>
+        <result column="CREATION_TIME" property="creationTime"/>
+        <result column="PK_MODIFIED" property="pkModified"/>
+        <result column="MODIFIED_TIME" property="modifiedTime"/>
+        <result column="PK_BONUS" property="pkBonus"/>
+        <result column="PK_ORDER" property="pkOrder"/>
+        <result column="PK_BONUS_ITEMS" property="pkBonusItems"/>
+        <result column="INCOME_STATUS" property="incomeStatus"/>
+        <result column="CAL_TYPE" property="calType"/>
+        <result column="CAL_ACHIEVE" property="calAchieve"/>
+        <result column="CAL_VALUE" property="calValue"/>
+        <result column="PRETAX_INCOME" property="pretaxIncome"/>
+        <result column="INCOME_TAX" property="incomeTax"/>
+        <result column="REAL_INCOME" property="realIncome"/>
+        <result column="REMARK" property="remark"/>
+        <result column="INCOME_RATIO" property="incomeRatio"/>
+        <result column="INCOME_DIAL_RATIO" property="incomeDialRatio"/>
+        <result column="ORDER_DIAL_RATIO" property="orderDialRatio"/>
+        <result column="STAGE" property="stage"/>
+        <result column="STAGE_NUM" property="stageNum"/>
+    </resultMap>
+
+</mapper>

bd-business/bd-business-bonus/src/main/resources/mapper/bonus/order/BonusOrderMapper.xml

@@ -82,6 +82,12 @@
         <if test="orderCode != null and orderCode != ''">
             and so.order_code=#{orderCode}
         </if>
+        <if test="orderTypeList != null and orderTypeList.size > 0">
+            and so.order_type in
+            <foreach collection="orderTypeList" item="items" open="(" close=")" separator=",">
+                #{items}
+            </foreach>
+        </if>
         and so.pay_time >= #{startDate}
         and so.pay_time &lt; #{endDate}
         order by pay_time desc

bd-business/bd-business-member/src/main/java/com/hzs/member/base/service/ICuMemberService.java

@@ -150,15 +150,7 @@ public interface ICuMemberService extends IService<CuMember> {
      * @param digit     编号数字位数
      * @return
      */
-    String createUserNameByPremix(Integer pkCountry, Integer digit);    /**
-     * 生成会员编号
-     *
-     * @param pkCountry 所属国家
-     * @param isHaiFun
-     * @param digit     编号数字位数
-     * @return
-     */
-    String createUserNameByPremix(Integer pkCountry, Boolean isHaiFun, Integer digit);
+    String createUserNameByPremix(Integer pkCountry, Integer digit);
 
     /**
      * 批量生成会员编号

bd-business/bd-business-member/src/main/java/com/hzs/member/base/service/impl/CuMemberServiceImpl.java

@@ -1541,34 +1541,6 @@ public class CuMemberServiceImpl extends ServiceImpl<CuMemberMapper, CuMember> i
         return memberCode;
     }
 
-    @Override
-    public String createUserNameByPremix(Integer pkCountry, Boolean isHaiFun, Integer digit) {
-        String prefix;
-        if (isHaiFun) {
-            prefix = SysConstants.HAI_FUN_PREFIX;
-        } else {
-            CountryDTO country = iCountryServiceApi.getCountry(pkCountry).getData();
-            prefix = country.getCode();
-        }
-        if (StringUtils.isEmpty(prefix)) {
-            return null;
-        }
-        // 生成loginName
-        String memberCode = this.createMemberCode(prefix, digit);
-
-        CuMember cuMemberByKey = getMember(memberCode);
-        if (cuMemberByKey != null && cuMemberByKey.getPkId() > 0) {
-            // 用户名已经存在，则继续尝试
-            return this.createUserNameByPremix(pkCountry, isHaiFun, digit);
-        } else {
-            // 验证空单注册里面是否存在编号
-            List<CuMemberEmptyCode> cuMemberEmptyDetails = iCuMemberEmptyCodeService.queryCuMemberEmptyCode(memberCode);
-            if (CollectionUtil.isNotEmpty(cuMemberEmptyDetails)) {
-                return this.createUserNameByPremix(pkCountry, isHaiFun, digit);
-            }
-        }
-        return memberCode;
-    }
     /**
      * 创建会员编号
      *

bd-business/bd-business-member/src/main/java/com/hzs/retail/member/vo/RecommendListVO.java

@@ -2,12 +2,14 @@ package com.hzs.retail.member.vo;
 
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.hzs.common.core.annotation.BigDecimalFormat;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
 import java.io.Serializable;
+import java.math.BigDecimal;
 import java.util.Date;
 
 /**
@@ -54,5 +56,15 @@ public class RecommendListVO implements Serializable {
      * 手机号
      */
     private String phone;
+    /**
+     * 注册业绩
+     */
+    @BigDecimalFormat
+    private BigDecimal consumeAchieve;
+
+    /**
+     * 团队人数
+     */
+    private Integer teamCount;
 
 }

bd-business/bd-business-member/src/main/resources/mapper/member/base/CuMemberMapper.xml

@@ -2238,19 +2238,40 @@
 
     <!-- 推荐列表 -->
     <select id="listRecommend" resultType="com.hzs.common.domain.member.ext.CuMemberExt">
-        select cm.member_code,
-               cm.member_name,
-               cm.nick_name,
-               cm.creation_time,
-               cm.phone,
-               bg.grade_name settle_grade_val
-        from cu_member cm
-                 left join bd_grade bg
-                           on bg.pk_id = cm.pk_settle_grade
-        where cm.del_flag = 0
-          and cm.category = 0
-          and cm.pk_parent = #{pkMember}
-        order by cm.creation_time desc
+        WITH team_data AS (
+            SELECT
+                connect_by_root pk_id AS root_pk_id,
+                COUNT(*) OVER (PARTITION BY connect_by_root pk_id) - 1 AS team_count
+            FROM
+                cu_member
+            WHERE
+                del_flag = 0
+              AND category = 0
+        START WITH
+            pk_parent = #{pkMember}
+        CONNECT BY
+            PRIOR pk_id = pk_parent
+            )
+        SELECT DISTINCT
+            cm.member_code,
+            cm.member_name,
+            cm.nick_name,
+            cm.consume_achieve,
+            cm.creation_time,
+            cm.phone,
+            bg.grade_name AS settle_grade_val,
+            td.team_count
+        FROM
+            cu_member cm
+                LEFT JOIN
+            bd_grade bg ON bg.pk_id = cm.pk_settle_grade
+                LEFT JOIN
+            team_data td ON cm.pk_id = td.root_pk_id
+        WHERE
+            cm.del_flag = 0
+          AND cm.category = 0
+          AND cm.PK_PARENT = #{pkMember}
+        ORDER BY cm.creation_time desc
     </select>
 
     <!-- 查询分享或空单并且没有订单会员列表 -->

bd-business/bd-business-member/src/main/resources/mapper/member/detail/CuMemberAssessMapper.xml

@@ -129,11 +129,8 @@
         )
     </update>
     <update id="createCuMemberTableUniqueIndex">
-        create
-        unique index
-        ${tableName}
-        _
-        PK_M
+        create unique index
+        ${tableName}_PK_M
         on
         ${tableName}
         (

bd-common/bd-common-core/src/main/java/com/hzs/common/core/constant/MagicNumberConstants.java

@@ -47,16 +47,6 @@ public class MagicNumberConstants {
      */
     public static final Long PK_ADMIN = 100000000L;
 
-    /**
-     * 开始血缘代
-     */
-    public static final Integer BLOOD_GENERATION_START = 1;
-
-    /**
-     * 结束血缘代
-     */
-    public static final Integer BLOOD_GENERATION_END = 10;
-
     /**
      * 老会员编号位数
      */

bd-common/bd-common-core/src/main/java/com/hzs/common/core/constant/RetailConstants.java

@@ -7,6 +7,13 @@ import java.math.BigDecimal;
  */
 public class RetailConstants {
 
+    /**
+     * 精品专区50金额为一个子点位，商城专区50PV为一个子点位
+     * 精品专区计算点位：金额 / 50，余不做处理
+     * 商城专区计算点位：累计业绩 / 50， 剩下的继续累计
+     */
+    public static final BigDecimal POINT_VAL = new BigDecimal("50");
+
     /**
      * 精品专区直推收益订单金额 10%，商城专区见点收益20代订单PV 10%
      */

bd-common/bd-common-core/src/main/java/com/hzs/common/core/constant/SysConstants.java

@@ -1,6 +1,5 @@
 package com.hzs.common.core.constant;
 
-import java.math.BigDecimal;
 import java.util.Collections;
 import java.util.List;
 
@@ -9,15 +8,10 @@ import java.util.List;
  */
 public class SysConstants {
 
-
-    /**
-     * 嗨粉前缀
-     */
-    public static final String HAI_FUN_PREFIX = "HF";
     /**
      * 众康系统前缀
      */
-    public static final String RETAIL_PREFIX = "KG";
+    public static final String RETAIL_PREFIX = "ZK";
     /**
      * 顶点
      */
@@ -36,21 +30,11 @@ public class SysConstants {
     /**
      * 特殊处理编号（对外开放使用，主要用于支付接入审核）
      */
-    public static final String SPECIAL_CODE = "KG68880628";
-
-    /**
-     * 血缘累计业绩30万
-     */
-    public static final BigDecimal TOTAL_AREA_PV = new BigDecimal("300000");
-
-    /**
-     * 小区业绩累计10万
-     */
-    public static final BigDecimal SMALL_AREA_PV = new BigDecimal("100000");
+    public static final String SPECIAL_CODE = "ZK68880628";
 
     /**
      * 开放使用会员编号（用于支付登录查看数据）
      */
-    public static final List<String> CONTROL_MEMBER_LIST = Collections.singletonList("KG66886688");
+    public static final List<String> CONTROL_MEMBER_LIST = Collections.singletonList("ZK68880628");
 
 }

bd-common/bd-common-core/src/main/java/com/hzs/common/core/enums/EBonusStage.java

@@ -0,0 +1,37 @@
+package com.hzs.common.core.enums;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * 阶段奖项枚举
+ */
+@AllArgsConstructor
+@Getter
+public enum EBonusStage {
+
+    /**
+     * 一阶段
+     */
+    ONE(1, "一阶段"),
+    /**
+     * 二阶段
+     */
+    TWO(2, "二阶段"),
+    /**
+     * 三阶段
+     */
+    THREE(3, "三阶段"),
+
+    ;
+
+    /**
+     * 实际值
+     */
+    private final int value;
+    /**
+     * 显示标签
+     */
+    private final String label;
+
+}

bd-common/bd-common-core/src/main/java/com/hzs/common/core/enums/EBonusStageStatus.java

@@ -0,0 +1,33 @@
+package com.hzs.common.core.enums;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * 阶段状态枚举
+ */
+@AllArgsConstructor
+@Getter
+public enum EBonusStageStatus {
+
+    /**
+     * 已完成
+     */
+    YES(0, "已完成"),
+    /**
+     * 未完成
+     */
+    NO(1, "未完成"),
+
+    ;
+
+    /**
+     * 实际值
+     */
+    private final int value;
+    /**
+     * 显示标签
+     */
+    private final String label;
+
+}

bd-common/bd-common-core/src/main/java/com/hzs/common/core/enums/EBonusStageType.java

@@ -0,0 +1,33 @@
+package com.hzs.common.core.enums;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * 阶段点位类型枚举
+ */
+@AllArgsConstructor
+@Getter
+public enum EBonusStageType {
+
+    /**
+     * 普通点位
+     */
+    NORMAL(0, "普通点位"),
+    /**
+     * 赠送点位
+     */
+    GIFT(1, "赠送点位"),
+
+    ;
+
+    /**
+     * 实际值
+     */
+    private final int value;
+    /**
+     * 显示标签
+     */
+    private final String label;
+
+}

bd-common/bd-common-core/src/main/java/com/hzs/common/core/enums/EDelFlag.java

@@ -6,8 +6,6 @@ import lombok.Getter;
 
 /**
  * 删除标记枚举类
- *
- * @author hzs
  */
 @AllArgsConstructor
 @Getter

bd-common/bd-common-core/src/main/java/com/hzs/common/core/enums/ESysName.java

@@ -13,9 +13,9 @@ public enum ESysName {
     MANAGE("manage", "后台管理"),
 
     /**
-     * 康健系统
+     * 众康系统
      */
-    KG("kg", "康健系统"),
+    ZK("zk", "众康系统"),
 
     ;
 

bd-common/bd-common-domain/src/main/java/com/hzs/common/domain/member/achieve/CuMemberRetailDetail.java

@@ -1,33 +1,26 @@
 package com.hzs.common.domain.member.achieve;
 
-import com.baomidou.mybatisplus.annotation.KeySequence;
-import com.baomidou.mybatisplus.annotation.TableName;
-
 import java.util.Date;
 
-import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.fasterxml.jackson.annotation.JsonFormat;
-import com.hzs.common.core.annotation.Excel;
-import com.hzs.common.core.web.domain.BaseEntity;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
+import lombok.*;
 import lombok.experimental.Accessors;
 
 /**
  * 日结算阶段表
  */
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
 @Data
 @Accessors(chain = true)
-@KeySequence("CU_MEMBER_RETAIL_DETAIL_SEQ")
 @TableName("CU_MEMBER_RETAIL_DETAIL")
 public class CuMemberRetailDetail {
 
     private static final long serialVersionUID = 1L;
 
-    @TableId("PK_ID")
-    private Long pkId;
-
     /**
      * 会员ID
      */
@@ -65,169 +58,169 @@ public class CuMemberRetailDetail {
     private Date stageDate;
 
     /**
-     * 点位1-1
+     * 点位1-1会员子节点
      */
     @TableField("POINT_11")
-    private Long point11;
+    private Integer point11;
 
     /**
-     * 点位1-2
+     * 点位1-2会员子节点
      */
     @TableField("POINT_12")
-    private Long point12;
+    private Integer point12;
 
     /**
-     * 点位2-1
+     * 点位2-1会员子节点
      */
     @TableField("POINT_21")
-    private Long point21;
+    private Integer point21;
 
     /**
-     * 点位2-2
+     * 点位2-2会员子节点
      */
     @TableField("POINT_22")
-    private Long point22;
+    private Integer point22;
 
     /**
-     * 点位2-3
+     * 点位2-3会员子节点
      */
     @TableField("POINT_23")
-    private Long point23;
+    private Integer point23;
 
     /**
-     * 点位2-4
+     * 点位2-4会员子节点
      */
     @TableField("POINT_24")
-    private Long point24;
+    private Integer point24;
 
     /**
-     * 点位3-1
+     * 点位3-1会员子节点
      */
     @TableField("POINT_31")
-    private Long point31;
+    private Integer point31;
 
     /**
-     * 点位3-2
+     * 点位3-2会员子节点
      */
     @TableField("POINT_32")
-    private Long point32;
+    private Integer point32;
 
     /**
-     * 点位3-3
+     * 点位3-3会员子节点
      */
     @TableField("POINT_33")
-    private Long point33;
+    private Integer point33;
 
     /**
-     * 点位3-4
+     * 点位3-4会员子节点
      */
     @TableField("POINT_34")
-    private Long point34;
+    private Integer point34;
 
     /**
-     * 点位3-5
+     * 点位3-5会员子节点
      */
     @TableField("POINT_35")
-    private Long point35;
+    private Integer point35;
 
     /**
-     * 点位3-6
+     * 点位3-6会员子节点
      */
     @TableField("POINT_36")
-    private Long point36;
+    private Integer point36;
 
     /**
-     * 点位3-7
+     * 点位3-7会员子节点
      */
     @TableField("POINT_37")
-    private Long point37;
+    private Integer point37;
 
     /**
-     * 点位3-8
+     * 点位3-8会员子节点
      */
     @TableField("POINT_38")
-    private Long point38;
+    private Integer point38;
 
     /**
-     * 点位1-1会员
+     * 点位1-1会员ID
      */
     @TableField("POINT_MEMBER_11")
     private Long pointMember11;
 
     /**
-     * 点位1-2会员
+     * 点位1-2会员ID
      */
     @TableField("POINT_MEMBER_12")
     private Long pointMember12;
 
     /**
-     * 点位2-1会员
+     * 点位2-1会员ID
      */
     @TableField("POINT_MEMBER_21")
     private Long pointMember21;
 
     /**
-     * 点位2-2会员
+     * 点位2-2会员ID
      */
     @TableField("POINT_MEMBER_22")
     private Long pointMember22;
 
     /**
-     * 点位2-3会员
+     * 点位2-3会员ID
      */
     @TableField("POINT_MEMBER_23")
     private Long pointMember23;
 
     /**
-     * 点位2-4会员
+     * 点位2-4会员ID
      */
     @TableField("POINT_MEMBER_24")
     private Long pointMember24;
 
     /**
-     * 点位3-1会员
+     * 点位3-1会员ID
      */
     @TableField("POINT_MEMBER_31")
     private Long pointMember31;
 
     /**
-     * 点位3-2会员
+     * 点位3-2会员ID
      */
     @TableField("POINT_MEMBER_32")
     private Long pointMember32;
 
     /**
-     * 点位3-3会员
+     * 点位3-3会员ID
      */
     @TableField("POINT_MEMBER_33")
     private Long pointMember33;
 
     /**
-     * 点位3-4会员
+     * 点位3-4会员ID
      */
     @TableField("POINT_MEMBER_34")
     private Long pointMember34;
 
     /**
-     * 点位3-5会员
+     * 点位3-5会员ID
      */
     @TableField("POINT_MEMBER_35")
     private Long pointMember35;
 
     /**
-     * 点位3-6会员
+     * 点位3-6会员ID
      */
     @TableField("POINT_MEMBER_36")
     private Long pointMember36;
 
     /**
-     * 点位3-7会员
+     * 点位3-7会员ID
      */
     @TableField("POINT_MEMBER_37")
     private Long pointMember37;
 
     /**
-     * 点位3-8会员
+     * 点位3-8会员ID
      */
     @TableField("POINT_MEMBER_38")
     private Long pointMember38;
@@ -251,4 +244,41 @@ public class CuMemberRetailDetail {
     @TableField("CREATION_TIME")
     private Date creationTime;
 
+    /**
+     * 第一层会员子节点
+     */
+    @TableField("POINT_FIRST")
+    private Integer pointFirst;
+
+    /**
+     * 第一层会员ID
+     */
+    @TableField("POINT_MEMBER_FIRST")
+    private Long pointMemberFirst;
+
+    /**
+     * 第二层会员子节点
+     */
+    @TableField("POINT_SECOND")
+    private Integer pointSecond;
+
+    /**
+     * 第二层会员ID
+     */
+    @TableField("POINT_MEMBER_SECOND")
+    private Long pointMemberSecond;
+
+    /**
+     * 第三层会员子节点
+     */
+    @TableField("POINT_THIRD")
+    private Integer pointThird;
+
+    /**
+     * 第三层会员ID
+     */
+    @TableField("POINT_MEMBER_THIRD")
+    private Long pointMemberThird;
+
+
 }

bd-common/bd-common-domain/src/main/java/com/hzs/common/domain/member/achieve/CuMemberRetailRange.java

@@ -189,4 +189,10 @@ public class CuMemberRetailRange extends BaseEntity {
     @TableField("small_team_pv")
     private BigDecimal smallTeamPv;
 
+    /**
+     * 子点位总数
+     */
+    @TableField("point_count")
+    private Integer pointCount;
+
 }

bd-common/bd-common-domain/src/main/java/com/hzs/common/domain/member/achieve/ext/CuMemberRetailRangeExt.java

@@ -1,10 +1,13 @@
 package com.hzs.common.domain.member.achieve.ext;
 
+import com.hzs.common.domain.member.achieve.CuMemberRetailDetail;
 import com.hzs.common.domain.member.achieve.CuMemberRetailRange;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 
 import java.math.BigDecimal;
+import java.util.LinkedHashMap;
+import java.util.List;
 
 /**
  * 新零售极差实体
@@ -31,14 +34,6 @@ public class CuMemberRetailRangeExt extends CuMemberRetailRange {
      * 奖衔名称
      */
     private String awardsName;
-    /**
-     * 分红奖衔值
-     */
-    private Integer shareAwardsValue;
-    /**
-     * 分红奖衔名称
-     */
-    private String shareAwardsName;
 
     /**
      * 福利级差比例
@@ -134,4 +129,9 @@ public class CuMemberRetailRangeExt extends CuMemberRetailRange {
     private BigDecimal repTeamNewPv;
     //  秒结 end
 
+    /**
+     * 阶段一点位列表
+     */
+    private LinkedHashMap<Integer, CuMemberRetailDetail> oneDetailMap;
+
 }

bd-common/bd-common-domain/src/main/java/com/hzs/common/domain/member/bonus/CuMemberBonus.java

@@ -50,7 +50,7 @@ public class CuMemberBonus extends BaseEntity {
     private Integer pkRate;
 
     /**
-     * 注册直推收益
+     * 注册直推收益-康健
      */
     @TableField("DIRECT_INCOME")
     private BigDecimal directIncome;
@@ -176,7 +176,7 @@ public class CuMemberBonus extends BaseEntity {
     private BigDecimal repurCouponSubtotal;
 
     /**
-     * 复购见点收益
+     * 复购见点收益-康健
      */
     @TableField("GLOBAL_POINTS")
     private BigDecimal globalPoints;
@@ -188,7 +188,7 @@ public class CuMemberBonus extends BaseEntity {
     private BigDecimal carAwardPoints;
 
     /**
-     * 店铺收益
+     * 注册阶段收益-康健
      */
     @TableField("STORE_INCOME")
     private BigDecimal storeIncome;

bd-common/bd-common-domain/src/main/java/com/hzs/common/domain/member/bonus/CuMemberBonusStage.java

@@ -0,0 +1,129 @@
+package com.hzs.common.domain.member.bonus;
+
+import java.math.BigDecimal;
+
+import com.baomidou.mybatisplus.annotation.KeySequence;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.hzs.common.core.web.domain.BaseEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+
+/**
+ * 会员奖金-阶段收益明细表
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@Accessors(chain = true)
+@KeySequence("CU_MEMBER_BONUS_STAGE_SEQ")
+@TableName("CU_MEMBER_BONUS_STAGE")
+public class CuMemberBonusStage extends BaseEntity {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 主键
+     */
+    @TableId("PK_ID")
+    private Long pkId;
+
+    /**
+     * 主表主键
+     */
+    @TableField("PK_BONUS")
+    private Long pkBonus;
+
+    /**
+     * 订单主键
+     */
+    @TableField("PK_ORDER")
+    private Long pkOrder;
+
+    /**
+     * 奖金项
+     */
+    @TableField("PK_BONUS_ITEMS")
+    private Integer pkBonusItems;
+
+    /**
+     * 收益状态 (0=正常，1=烧伤)
+     */
+    @TableField("INCOME_STATUS")
+    private Integer incomeStatus;
+
+    /**
+     * 计算类型 1=比例 2=值
+     */
+    @TableField("CAL_TYPE")
+    private Integer calType;
+
+    /**
+     * 计算业绩
+     */
+    @TableField("CAL_ACHIEVE")
+    private BigDecimal calAchieve;
+
+    /**
+     * 计算比例
+     */
+    @TableField("CAL_VALUE")
+    private BigDecimal calValue;
+
+    /**
+     * 税前收益
+     */
+    @TableField("PRETAX_INCOME")
+    private BigDecimal pretaxIncome;
+
+    /**
+     * 扣除个税
+     */
+    @TableField("INCOME_TAX")
+    private BigDecimal incomeTax;
+
+    /**
+     * 实际收益
+     */
+    @TableField("REAL_INCOME")
+    private BigDecimal realIncome;
+
+    /**
+     * 备注
+     */
+    @TableField("REMARK")
+    private String remark;
+
+    /**
+     * 收益占比
+     */
+    @TableField("INCOME_RATIO")
+    private BigDecimal incomeRatio;
+
+    /**
+     * 收益拨比
+     */
+    @TableField("INCOME_DIAL_RATIO")
+    private BigDecimal incomeDialRatio;
+
+    /**
+     * 订单拨比
+     */
+    @TableField("ORDER_DIAL_RATIO")
+    private BigDecimal orderDialRatio;
+
+    /**
+     * 三个阶段（1、2、3）
+     */
+    @TableField("STAGE")
+    private Integer stage;
+
+    /**
+     * 第几个点（一二阶段：满14发；三阶段：满2发，满6发，7以上每个发一次）
+     */
+    @TableField("STAGE_NUM")
+    private Integer stageNum;
+
+
+}

bd-common/bd-common-domain/src/main/java/com/hzs/common/domain/member/ext/CuMemberExt.java

@@ -182,6 +182,10 @@ public class CuMemberExt extends CuMember {
      * 团队名称
      */
     private String teamName;
+    /**
+     * 团队人数
+     */
+    private Integer teamCount;
 
     /**
      * 次数