angelo
/
java-retail-app
3
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

## 秒结和日结中盒数、业绩上传处理；等级、奖衔计算处理；

This commit is contained in:
cabbage 2025-06-10 20:31:14 +08:00
parent 07d9dcc558
commit 7e20c1d0ed
51 changed files with 818 additions and 4842 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
bd-api/bd-api-bonus/src/main/java/com/hzs/bonus/settle/IMemberSettleBonusApi.java
View File

@ -2,7 +2,6 @@ package com.hzs.bonus.settle;
import com.hzs.common.core.domain.R;
import com.hzs.common.domain.member.bonus.CuMemberRetail;
import com.hzs.common.domain.sale.ext.SaOrderExt;
import com.hzs.common.domain.sale.order.SaOrder;
import java.util.Date;
@ -12,13 +11,6 @@ import java.util.Date;
*/
public interface IMemberSettleBonusApi {
/**
* 根据秒结算会员奖金
*
* @param orderCode 订单
*/
R<Boolean> calculateCumberBonusBySecond(String orderCode);
/*
* 定时任务每天自动计算奖金
**/

21
bd-api/bd-api-sale/src/main/java/com/hzs/sale/order/ISaOrderServiceApi.java
View File

@ -19,14 +19,6 @@ import java.util.List;
*/
public interface ISaOrderServiceApi {
/**
* 查询时间范围内的所有订单，按照订单时间排序,只能用于奖金结算
*
* @param startDate 开始日期
* @param endDate 结束日期
*/
R<List<SaOrderExt>> querySaOrderByDay(Date startDate, Date endDate);
/**
* 查询时间范围内的所有订单，按照订单时间排序,只能用于奖金结算
*
@ -48,11 +40,6 @@ public interface ISaOrderServiceApi {
**/
R<SaOrder> querySaOrderExtByPkId(Long pkId);
/*
* 查询订单编号
**/
R<SaOrderExt> querySaOrderByDay(Date startDate, Date endDate, String orderCode);
/*
* 根据发货单查询销售订单
**/
@ -93,14 +80,6 @@ public interface ISaOrderServiceApi {
*/
R<List<SaOrderItemsExt>> queryOrderItemsListByOrderId(List<Long> pkOrderList, Integer pkCountry);
/**
* 根据订单编号查询订单
*
* @param pkMember 会员主键
* @param orderCode 订单编号
*/
R<BigDecimal> querySaOrderByOrderCode(Long pkMember, String orderCode);
/**
* 根据订单编号查询订单信息
*

8
bd-api/bd-api-system/src/main/java/com/hzs/system/config/IBonusItemsServiceApi.java
View File

@ -32,14 +32,6 @@ public interface IBonusItemsServiceApi {
*/
R<BdBonusItems> queryBonusItems(Integer pkCountry, Integer pkBonusItems);
/**
* 查询奖金项
*
* @param pkCountry 国家
* @param bonusValue 奖金项
*/
R<BdBonusItems> queryBonusItemsByBonusValue(Integer pkCountry, Integer bonusValue);
/**
* 查询国家的推荐奖金参数
*/

196
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/achieve/mapper/CuMemberAchieveMapper.java
View File

@ -3,21 +3,8 @@ package com.hzs.bonus.achieve.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hzs.bonus.achieve.param.MemberAchieveParam;
import com.hzs.common.domain.member.achieve.CuMemberAchieve;
import com.hzs.common.domain.member.achieve.ext.CuMemberAchieveExt;
import com.hzs.bonus.achieve.param.MonthAchieveParam;
import com.hzs.bonus.achieve.vo.CuMemberAwardsUnderVO;
import com.hzs.bonus.achieve.vo.CuMemberMonthAchieveContrastVO;
import com.hzs.bonus.achieve.vo.CuMemberNewAddAchieveVO;
import com.hzs.common.domain.member.ext.CuMemberMonthAchieveExt;
import com.hzs.common.domain.member.ext.CuMemberSettleExt;
import com.hzs.common.domain.member.swing.ext.CuMemberSwingNetExt;
import com.hzs.common.domain.sale.ext.SaOrderExt;
import org.apache.ibatis.annotations.Param;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
/**
* 会员业绩记录 Mapper 接口
*/
@ -42,40 +29,6 @@ public interface CuMemberAchieveMapper extends BaseMapper<CuMemberAchieve> {
**/
void mergeCuMemberMonth(@Param("date") String date, @Param("period") Integer period);
/*
* 查询每月月业绩，获得血缘业绩 首购复购
**/
List<CuMemberAchieveExt> queryCuMemberMonthAchieveByMemberIdList(@Param("settleTableName") String settleTableName, @Param("memberSwingNetExtList") List<CuMemberSwingNetExt> memberSwingNetExtList);
/**
* 将结算日表的值插入到结算月表中
*
* @param targetTableName 目标表 网体月表
* @param sourceTableName 来源表 结算日表
* @param period 期间
*/
void insertCuMemberAchieveBySettleDate(@Param("targetTableName") String targetTableName,
@Param("sourceTableName") String sourceTableName, @Param("period") Integer period);
/**
* 将结算日表的值插入到结算月表中
*
* @param targetTableName 目标表 网体月表
* @param sourceTableName 来源表 结算日表
* @param period 期间
*/
void mergeCuMemberAchieveBySettleDate(@Param("targetTableName") String targetTableName,
@Param("sourceTableName") String sourceTableName, @Param("period") Integer period);
/**
* 将昨天日表数据插入今天日表中, 昨日日表更新今天日表网体表
* 根据昨天结算表数据更新今天结算表的业绩数据
*
* @param sourceTable 来源表，记录10天跟月表一摸一样的滚动表数据
* @param targetTable 目标表 记录10天跟月表一摸一样的滚动表数据
*/
void updateCuMemberSettleAchieveByBeforeDay(@Param("sourceTable") String sourceTable, @Param("targetTable") String targetTable);
/**
* 将昨天日表数据插入今天日表中, 昨日日表更新今天日表网体表
* 根据昨天结算表数据更新今天结算表的业绩数据
@ -85,159 +38,10 @@ public interface CuMemberAchieveMapper extends BaseMapper<CuMemberAchieve> {
*/
void updateCuMemberExpandSettleAchieveByBeforeDay(@Param("sourceTable") String sourceTable, @Param("targetTable") String targetTable);
/*
* 更新为最初始的数据，新增的为0，历史的通过昨天进行更新
**/
void updateCuMemberSettleInitAchieve(String targetTable);
/**
* 根据特殊业务更新业绩
*
* @param targetTable 结算表
* @param period 期间
* @param pkId 主键
*/
void updateCuMemberSettleAchieveBySpecialBus(@Param("targetTable") String targetTable, @Param("period") Integer period,
@Param("pkId") Long pkId);
/*
* 注水到期更新业绩
**/
void mergeCuMemberSettleByAchieveLogByDate(@Param("targetTable") String targetTable, @Param("settleDate") Date settleDate);
/*
* 根据到期日期更新业绩，到期后需要还原到实际累计金额
**/
void updateCuMemberSettleAchieveByDueDate(@Param("currentTableName") String currentTableName, @Param("yesTableName") String yesTableName,
@Param("currentDate") Date currentDate);
/**
* 根据每日日业绩开始更新会员业绩 新增业绩、累计业绩
*
* @param memberAchieveParamList 会员业绩
* @param tableName 更新的表，结算日的日表
*/
Boolean updateCuMemberBackOldAchieveEveryDay(@Param("memberAchieveParamList") List<?> memberAchieveParamList,
@Param("tableName") String tableName);
/*
* 退单回退业绩
**/
void chargeBackSaOrder(@Param("targetTable") String targetTable, @Param("sourceTable") String sourceTable,
@Param("period") Integer period, @Param("achieve") MemberAchieveParam memberAchieveParam);
/**
* 根据每日日业绩开始更新会员业绩 新增业绩、累计业绩
*
* @param memberAchieveParamList 会员业绩
* @param tableName 更新的表，结算日的日表
*/
Boolean updateCuMemberBackAchieveEveryDay(@Param("memberAchieveParamList") List<?> memberAchieveParamList,
@Param("tableName") String tableName);
/**
* 重新结算会员网体业绩
*
* @param currentSettleTableName 更新甩网业绩
*/
void updateCuMemberNetAchieve(@Param("updMemberAchieveExtList") List<CuMemberAchieveExt> updMemberAchieveExtList, @Param("tableName") String currentSettleTableName);
/**
* 查询会员最新业绩
*
* @param pkMember 会员主键
* @param pkCountry 公司
* @param tableName 结算表
*/
CuMemberAchieve queryCuMemberAchieveByPkMember(@Param("pkMember") Long pkMember, @Param("pkCountry") Integer pkCountry, @Param("tableName") String tableName);
/*
* 查询会员伞下血缘业绩
**/
BigDecimal queryCuMemberUnderBloodAchieveByPkMember(@Param("treeTable") String treeTable, @Param("achieveTable") String achieveTable,
@Param("pkMember") Long pkMember, @Param("period") Integer period);
/**
* 会员端新增业绩
*
* @param cuMemberNewAddAchieveVO 端新增业绩
* @return CuMemberNewAddAchieveVO
*/
List<CuMemberNewAddAchieveVO> selectNewAddAchieve(CuMemberNewAddAchieveVO cuMemberNewAddAchieveVO);
/**
* 根据用户ID查询奖衔
*
* @param memberAwardsUnderVO 奖衔VO
* @return CuMemberAwardsUnderVO
*/
CuMemberAwardsUnderVO selectAwardsByPkMember(CuMemberAwardsUnderVO memberAwardsUnderVO);
/**
* 根据用户ID查询奖衔伞下
*
* @param memberAwardsUnderVO 奖衔VO
* @return List<CuMemberAwardsUnderVO>
*/
List<CuMemberAwardsUnderVO> selectUnderMemberAwards(CuMemberAwardsUnderVO memberAwardsUnderVO);
/**
* 月度新增业绩对比
*
* @param memberMonthAchieveContrastVO 参数
* @return CuMemberMonthAchieveContrastVO
*/
CuMemberMonthAchieveContrastVO selectNewAddAchieveContrast(CuMemberMonthAchieveContrastVO memberMonthAchieveContrastVO);
/**
* 查询表名是否存在
*
* @param tableName 表名
* @return Integer
*/
Integer selectExistTable(String tableName);
/**
* 查询推荐业绩
*
* @param memberIds
* @param pkCountry
* @param achieveTable
* @return
*/
List<BigDecimal> selectByParent(@Param("memberIds") List<Long> memberIds, @Param("pkCountry") Integer pkCountry, @Param("achieveTable") String achieveTable);
/*
* 更新会员的业绩
**/
void updateCuMemberAchieve(@Param("tableName") String tableName, @Param("period") Integer period);
/*
* 查询月统计数据，按照月倒叙
**/
List<CuMemberAchieveExt> queryMemberMonthAchieve(@Param("pkMember") Long pkMember, @Param("monthList") List<String> monthList);
/*
* 查询会员一代伞下
**/
List<Long> queryPkMemberMonthAchieve(@Param("month") String month, @Param("pkMember") Long pkMember);
/*
* 查询月统计数据，查询明细
**/
List<CuMemberAchieveExt> queryMemberMonthAchieveDetail(@Param("monthAchieveParam") MonthAchieveParam monthAchieveParam,
@Param("memberList") List<Long> memberList);
/*
* 查询月统计数据，查询明细，安置伞下
**/
List<CuMemberAchieveExt> queryPlaceParentMemberMonthAchieve(MonthAchieveParam monthAchieveParam);
/*
* 查询月统计数据，查询明细，安置伞下
**/
List<CuMemberAchieveExt> queryParentMemberMonthAchieve(MonthAchieveParam monthAchieveParam);
}

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

@ -22,7 +22,8 @@ public interface CuMemberRetailRangeMapper extends BaseMapper<CuMemberRetailRang
/**
* 将昨天的业绩信息迁移到今天
*/
void mergeMemberRetailRangeByYesterday(@Param("rangeTableName") String rangeTableName, @Param("yesterdayRangeTableName") String yesterdayRangeTableName,
void mergeMemberRetailRangeByYesterday(@Param("rangeTableName") String rangeTableName,
@Param("yesterdayRangeTableName") String yesterdayRangeTableName,
@Param("isSameMonth") Integer isSameMonth);
/**

410
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/achieve/mapper/CuMemberTreeMapper.java
View File

@ -2,12 +2,7 @@ package com.hzs.bonus.achieve.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hzs.common.domain.member.achieve.CuMemberTree;
import com.hzs.common.domain.member.detail.CuMemberAwards;
import com.hzs.common.domain.member.detail.CuMemberGrade;
import com.hzs.common.domain.member.ext.CuMemberSettleExt;
import com.hzs.bonus.achieve.param.MemberParentCountParam;
import com.hzs.bonus.census.param.CensusSummaryParam;
import com.hzs.bonus.census.vo.CensusSummaryVo;
import org.apache.ibatis.annotations.Param;
import java.util.Date;
@ -32,40 +27,16 @@ public interface CuMemberTreeMapper extends BaseMapper<CuMemberTree> {
*/
void createCuMemberSettleTable(String tableName);
/*
* 创建会员网体极差结算表
**/
void createCuMemberRangeTable(String tableName);
/*
* 创建会员网体复购极差结算表
**/
void createCuMemberRetailRangeTable(String tableName);
/**
* 创建会员网体结算秒结表（按照日记录，每天一条，记录30天的）
*
* @param tableName 日期
*/
void createCuMemberSecondTable(String tableName);
/*
* 创建极差秒结算表
**/
void createCuMemberRangeSecondTable(String tableName);
/*
* 创建极差秒结算表
**/
void createCuMemberRetailRangeSecondTable(String tableName);
/**
* 删除会员结算表
*
* @param tableName 表明
*/
void dropCuMemberSettleTable(String tableName);
/**
* 创建会员网体推荐人索引
*
@ -87,12 +58,6 @@ public interface CuMemberTreeMapper extends BaseMapper<CuMemberTree> {
*/
void createCuMemberTableUniqueIndex(String tableName);
/*
* 根据历史数据查询settle表
**/
void insertCuMemberSettleByHis(@Param("settleTableName") String settleTableName, @Param("treeTableName") String treeTableName,
@Param("achieveTableName") String achieveTableName, @Param("period") Integer period);
/**
* 创建表的序列
*
@ -108,30 +73,6 @@ public interface CuMemberTreeMapper extends BaseMapper<CuMemberTree> {
*/
void createCuMemberTreeDayOnlyIndex(String tableName);
/**
* 将结算日表的值插入到结算月表中
*
* @param sourceTableName 来源表 结算日表
* @param targetTableName 目标表 网体月表
* @param period 期间
*/
void insertCuMemberTreeBySettleDate(@Param("targetTableName") String targetTableName,
@Param("sourceTableName") String sourceTableName, @Param("period") Integer period);
/*
* 新增货修改会员数
**/
void mergeCuMemberTreeBySettleDate(@Param("targetTableName") String targetTableName,
@Param("sourceTableName") String sourceTableName, @Param("period") Integer period);
/**
* 迁移月表数据，先删除
*
* @param targetTableName 目标表
* @param period 期间
*/
void deleteCuMemberTreeByPeriod(@Param("targetTableName") String targetTableName, @Param("period") Integer period);
/**
* 删除日表数据
*
@ -139,21 +80,6 @@ public interface CuMemberTreeMapper extends BaseMapper<CuMemberTree> {
*/
void truncateCuMemberTreeTable(@Param("tableName") String tableName);
/**
* 将会员表数据插入结算日表中
*
* @param settleTableName 结算表名
*/
void insertCuMemberSettleByMember(String settleTableName);
/**
* 将会员表数据插入结算日表中
*
* @param settleTableName 结算表名
*/
void insertCuMemberRangeByMember(@Param("settleTableName") String settleTableName, @Param("year") String year,
@Param("period") Integer period, @Param("firstDate") Date firstDate);
/**
* 将会员表数据插入结算日表中
*
@ -168,45 +94,11 @@ public interface CuMemberTreeMapper extends BaseMapper<CuMemberTree> {
*/
Integer queryExistOracleTable(String tableName);
/*
* 查询表数量
**/
/**
* 查询表数量
*/
Integer queryExistOrderTableCount(String tableName);
/**
* 根据会员编号查询会员历史业绩、网体记录，用于结算前7天-到前2天
*
* @param pkMember 会员主键
* @param period 期间
* @param settleTableName 需要结算的表
*/
List<CuMemberSettleExt> queryCuMemberTreeExt(@Param("pkMember") Long pkMember, @Param("period") Integer period,
@Param("settleTableName") String settleTableName);
/**
* 根据注册撤单数据将会员网体历史记录表的会员修改为死点
*
* @param saOrderExtList 撤单数据
* @param settleTableName 结算表
*/
void updateCuMemberTreeByCancelOrder(@Param("saOrderExtList") List<?> saOrderExtList, @Param("settleTableName") String settleTableName);
/**
* 根据升级撤单数据将会员网体历史记录表的会员修改等级
*
* @param saOrderExtList 撤单数据
* @param tomorrow 日期
* @param settleTableName 结算表
*/
void updateCuMemberTreeGradeByCancelOrder(@Param("saOrderExtList") List<?> saOrderExtList, @Param("currentDate") Date tomorrow, @Param("settleTableName") String settleTableName);
/**
* 查询历史会员网体信息,查询某一天免考的会员
*
* @param tableName 结算表
*/
List<CuMemberSettleExt> queryExemptCuMemberSettle(String tableName);
/**
* 查询出符合下一等级足够业绩的会员
*
@ -236,14 +128,14 @@ public interface CuMemberTreeMapper extends BaseMapper<CuMemberTree> {
void updateCuMemberRetailRangeAwardByDate(@Param("rangeTableName") String rangeTableName, @Param("settleDate") Date settleDate,
@Param("awardType") Integer awardType);
/*
* 回退会员奖衔
**/
/**
* 初始化期间奖衔
*/
void updateCuMemberRetailRangeInitAward(@Param("rangeTableName") String rangeTableName);
/*
* 更新奖衔，V5默认W1
**/
/**
* 初始化期间V5奖衔
*/
void updateCuMemberRetailRangeInitV5Award(@Param("rangeTableName") String rangeTableName);
/**
@ -311,15 +203,6 @@ public interface CuMemberTreeMapper extends BaseMapper<CuMemberTree> {
List<CuMemberSettleExt> batchQueryCuMemberSettleParent(@Param("settleTableName") String settleTableName,
@Param("pkMemberList") List<?> pkMemberList);
/**
* 批量根据量奖信息查询会员结算表中的父级血缘数据
*
* @param settleTableName 结算表
* @param pkMemberList 有量奖的会员列表
*/
List<CuMemberSettleExt> batchQuerySpecialCuMemberSettleParent(@Param("settleTableName") String settleTableName,
@Param("pkMemberList") List<?> pkMemberList);
/**
* 批量根据量奖信息查询会员结算表中的父级血缘数据
*
@ -329,14 +212,6 @@ public interface CuMemberTreeMapper extends BaseMapper<CuMemberTree> {
List<CuMemberSettleExt> batchQueryCuMemberSettleParentForSpecial(@Param("settleTableName") String settleTableName,
@Param("pkMemberList") List<?> pkMemberList);
/**
* 更新会员网体奖衔数据，更新月表、结算表
*
* @param updateTableName 更新表名
* @param period 期
*/
Integer updateCuMemberSettleMonthByPeriod(@Param("updateTableName") String updateTableName, @Param("period") Integer period);
/**
* 更新会员网体奖衔数据，更新月表、结算表
*
@ -344,14 +219,6 @@ public interface CuMemberTreeMapper extends BaseMapper<CuMemberTree> {
*/
Integer updateCuMemberSettleByPeriod(@Param("updateTableName") String updateTableName, @Param("period") Integer period);
/**
* 更新会员树的累计业绩
*
* @param settleTableName 结算表
* @param cuMemberTreeList 树
*/
void updateCuMemberSettle(@Param("settleTableName") String settleTableName, @Param("cuMemberTreeList") List<?> cuMemberTreeList);
/**
* 更新会员树的累计业绩
*
@ -360,263 +227,4 @@ public interface CuMemberTreeMapper extends BaseMapper<CuMemberTree> {
*/
void updateCuMemberExpandSettle(@Param("settleTableName") String settleTableName, @Param("cuMemberTreeList") List<?> cuMemberTreeList);
/**
* 更新会员树的累计业绩
*
* @param settleTableName 结算表
* @param cuMemberTreeList 树
*/
void updateCuMemberSecond(@Param("settleTableName") String settleTableName, @Param("cuMemberTreeList") List<?> cuMemberTreeList);
/**
* 根据会员编号更新会员安置伞上秒结数据，新增或修改
*
* @param secondTableName 秒结表
* @param settleTableName 结算表
* @param pkMember 会员表
* @param cuMemberTreeList 树
* @param isPlace 是否安置关系
*/
void updateCuMemberSecondPlaceParent(@Param("secondTableName") String secondTableName, @Param("settleTableName") String settleTableName,
@Param("pkMember") Long pkMember, @Param("cuMemberTreeList") List<?> cuMemberTreeList,
@Param("isPlace") Integer isPlace);
/**
* 根据会员编号查询会员伞上安置人秒结数据
*
* @param secondTableName 秒接
* @param pkMember 会员
*/
List<CuMemberSettleExt> queryCuMemberSecondPlaceParent(@Param("secondTableName") String secondTableName, @Param("pkMember") Long pkMember);
/**
* 根据会员编号查询会员伞上安置人秒结数据
*
* @param secondTableName 秒接
* @param pkMember 会员
*/
List<CuMemberSettleExt> queryCuMemberSecondBloParent(@Param("secondTableName") String secondTableName, @Param("pkMember") Long pkMember);
/**
* 根据会员编号查询会员伞上推荐人秒结数据
*
* @param secondTableName 秒接
* @param cuMemberTreeList 推荐人
*/
List<CuMemberSettleExt> queryCuMemberSecondParent(@Param("secondTableName") String secondTableName, @Param("cuMemberTreeList") List<?> cuMemberTreeList);
/**
* 根据等级、奖衔满足晋升的情况 更新网体免考记录
*
* @param settleTableName 结算表
* @param startDate 开始日期
* @param endDate 结束日期
*/
Integer updateCuMemberSettleExemptByAward(@Param("settleTableName") String settleTableName,
@Param("startDate") Date startDate, @Param("endDate") Date endDate);
/**
* 查询安置
*
* @param tableName
* @param pkMember
* @return
*/
List<CuMemberSettleExt> queryCuMemberTreePlaceParentTable(@Param("tableName") String tableName, @Param("pkMember") Long pkMember, @Param("memberIdList") List<Long> memberIdList, @Param("level") Integer level);
/**
* 根据pkmember查询
*
* @param tableName
* @param pkMember
* @return
*/
CuMemberSettleExt queryCuMemberTreeByPkMemberTable(@Param("tableName") String tableName, @Param("pkMember") Long pkMember);
/**
* 查询推荐关系
*
* @param settleTableName
* @param pkMember
* @return
*/
List<CuMemberSettleExt> queryCuMemberTreeParentTable(@Param("tableName") String settleTableName, @Param("pkMember") Long pkMember, @Param("level") Integer level);
/**
* 查询直推人数
*
* @param settleTableName
* @param pkMember
* @return
*/
Long queryCuMemberTreeParentTableCount(@Param("tableName") String settleTableName, @Param("pkMember") Long pkMember);
/**
* 查询历史安置上下级
*
* @param settleTableName
* @param pkMember
* @return
*/
List<CuMemberSettleExt> queryCuMemberTreePlaceParentHistoryTable(@Param("tableName") String settleTableName, @Param("pkMember") Long pkMember, @Param("memberIdList") List<Long> memberIdList, @Param("level") Integer level);
/**
* 查询每一期汇总
*
* @param settleTableName
* @return
*/
CensusSummaryVo queryCuMemberTreeParentSumTable(@Param("tableName") String settleTableName, @Param("censusSummaryParam") CensusSummaryParam censusSummaryParam);
/*
* 查询历史网体的最末安置人，左右区一起查出来
**/
List<CuMemberSettleExt> queryCuMemberTreeLastPlaceParent(@Param("tableName") String settleTableName, @Param("pkMember") Long pkMember);
/*
* 查询
**/
List<CuMemberSettleExt> queryCuMemberTree(@Param("tableName") String settleTableName, @Param("pkMember") Long pkMember, @Param("pkPlaceParent") Long pkPlaceParent);
/**
* 查询秒结表会员信息
*
* @param pkMember
* @param settleTableName
* @return
*/
List<CuMemberSettleExt> selectByTreeMemberList(@Param("pkMember") Long pkMember, @Param("tableName") String settleTableName, @Param("level") Integer level);
/**
* 查询会员真实业绩
*
* @param pkMember
* @return
*/
CuMemberSettleExt getCuMemberRealPerformanceByMemberId(@Param("pkMember") Long pkMember, @Param("tableName") String tableName);
/**
* 查询安置左右区人数
*
* @param memberId 会员id
* @param placeDept
* @return
*/
Long queryPlaceParentPeopleNumber(@Param("memberId") Long memberId, @Param("placeDept") Integer placeDept);
/**
* 查询推荐大小区人数
*
* @param memberId
* @param placeDept
* @return
*/
Long queryParentPeopleNumber(@Param("memberId") Long memberId, @Param("placeDept") Integer placeDept);
/**
* 查询秒结表是否有值
*
* @param settleTableName
* @return
*/
Long selectByselectByTreeMemberCount(@Param("tableName") String settleTableName, @Param("pkMember") Long pkMember);
/**
* 查询伞下安置新增业绩
*
* @param settleTableName
* @param pkMember
* @return
*/
List<CuMemberSettleExt> brollyBelowResettle(@Param("tableName") String settleTableName, @Param("pkMember") Long pkMember);
/**
* 根据pkmember查询 关联parent
*
* @param settleTableName
* @param pkMember
* @return
*/
CuMemberSettleExt queryCuMemberTreeByPlacePkMemberTable(@Param("tableName") String settleTableName, @Param("pkMember") Long pkMember);
/**
* 查询会员直推人数
*
* @param memberIds
* @return
*/
List<MemberParentCountParam> queryByMemberParentCount(@Param("memberIds") List<Long> memberIds);
/**
* 查询会员直推业绩
*
* @param settleTableName
* @param memberIds
* @return
*/
List<MemberParentCountParam> queryByMemberParentSumPv(@Param("tableName") String settleTableName, @Param("memberIds") List<Long> memberIds);
/**
* 查询历史会员直推人数
*
* @param memberIds
* @param settleTableName
* @return
*/
List<MemberParentCountParam> queryByMemberParentAndMemberSettleCount(@Param("memberIds") List<Long> memberIds, @Param("settleTableName") String settleTableName);
/**
* 查询会员历史直推业绩
*
* @param settleTableName
* @param memberIds
* @return
*/
List<MemberParentCountParam> queryByMemberParentSettleSumPv(@Param("tableName") String settleTableName, @Param("memberIds") List<Long> memberIds);
/*
* 每月初初始化奖衔为会员
**/
void updateCuMemberAwardsInit();
/*
* 每月初初始化奖衔为会员
**/
void updateMemberRangeAwardsInit();
/*
* 每月初初始化奖衔为会员
**/
void updateCuMemberSettleAwardsInit(@Param("settleTableName") String settleTableName);
/*
* 每月初初始化奖衔为会员
**/
void updateCuMemberRangeAwardsInit(@Param("rangeTableName") String rangeTableName);
/*
* 根据结算表更新奖衔
**/
void updateCuMemberAwardsBySettle(@Param("startPeriod") Integer startPeriod, @Param("period") Integer period);
/*
* 根据结算表更新奖衔
**/
void updateMemberRangeAwardsBySettle(@Param("startPeriod") Integer startPeriod, @Param("period") Integer period);
/*
* 根据结算表更新奖衔
**/
void updateCuMemberSettleAwardsBySettle(@Param("settleTableName") String settleTableName, @Param("startPeriod") Integer startPeriod, @Param("period") Integer period);
/*
* 根据结算表更新奖衔
**/
void updateCuMemberRangeAwardsBySettle(@Param("rangeTableName") String rangeTableName, @Param("startPeriod") Integer startPeriod, @Param("period") Integer period);
/*
* 根据结算表更新奖衔
**/
void updateCuMemberMaxAwardsBySettle();
}

39
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/achieve/param/MemberParentCountParam.java
View File

@ -1,39 +0,0 @@
package com.hzs.bonus.achieve.param;/**
* @Description:
* @Author: yuhui
* @Time: 2023/7/10 14:01
* @Classname: MemberParentCountParam
* @PackageName: com.hzs.member.achieve.param
*/
import lombok.Data;
import java.math.BigDecimal;
/**
*@BelongsProject: hzs_cloud
*@BelongsPackage: com.hzs.member.achieve.param
*@Author: yh
*@CreateTime: 2023-07-10 14:01
*@Description: TODO
*@Version: 1.0
*/
@Data
public class MemberParentCountParam {
/**
* 会员主键
*/
private Long pkMember;
/**
* 会员直推数量
*/
private Long parentMemberCount;
/**
* 会员直推pv
*/
private BigDecimal parentMemberSumPv;
}

42
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/achieve/param/MonthAchieveParam.java
View File

@ -1,42 +0,0 @@
package com.hzs.bonus.achieve.param;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
* @description: 月度业绩
* @author: sui q
* @time: 2023/8/29 17:37
* @classname: MonthAchieveParam
* @package_name: com.hzs.member.achieve.param
* version 1.0.0
*/
@Data
public class MonthAchieveParam implements Serializable {
private String month;
private String memberCode;
private String memberName;
private Long pkMember;
private Integer placeDept;
private Date startDate;
private Date endDate;
/**
* 等级
*/
private Integer pk_grade;
/**
* 真实奖衔
*/
private Integer pk_awards;
}

91
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/achieve/service/ICuMemberAchieveService.java
View File

@ -2,17 +2,7 @@ package com.hzs.bonus.achieve.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hzs.common.domain.member.achieve.CuMemberAchieve;
import com.hzs.common.domain.member.achieve.ext.CuMemberAchieveExt;
import com.hzs.common.domain.member.ext.CuMemberSettleExt;
import com.hzs.common.domain.member.swing.ext.CuMemberSwingNetExt;
import com.hzs.common.domain.sale.ext.SaOrderExt;
import com.hzs.common.domain.sale.order.SaOrder;
import com.hzs.bonus.achieve.param.MemberAchieveParam;
import org.apache.ibatis.annotations.Param;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
* 会员业绩记录 服务类
@ -38,64 +28,6 @@ public interface ICuMemberAchieveService extends IService<CuMemberAchieve> {
**/
void mergeCuMemberMonth(Integer day, String date);
/**
* 将结算日表的值插入到结算月表中
*
* @param targetTableName 目标表 网体月表
* @param sourceTableName 来源表 结算日表
* @param period 期间
*/
void insertCuMemberAchieveBySettleDate(String targetTableName, String sourceTableName, Integer period);
/**
* 将结算日表的值插入到结算月表中
*
* @param targetTableName 目标表 网体月表
* @param sourceTableName 来源表 结算日表
* @param period 期间
*/
void mergeCuMemberAchieveBySettleDate(String targetTableName, String sourceTableName, Integer period);
/**
* 根据每日日业绩开始更新会员业绩 新增业绩、累计业绩
*
* @param memberAchieveParamMap 修改的结算
* @param tablaName 修改的结算期间表
*/
void updateCuMemberAchieveEveryDay(Map<Long, MemberAchieveParam> memberAchieveParamMap, String tablaName);
/**
* 重新结算会员网体业绩
*
* @param currentSettleTableName 更新甩网业绩
*/
void updateCuMemberNetAchieve(List<CuMemberAchieveExt> updMemberAchieveExtList, String currentSettleTableName);
/**
* 根据每日日业绩开始回退更新会员业绩 新增业绩、累计业绩
*
* @param memberAchieveParamMap 修改的结算
* @param tablaName 修改的结算期间表
*/
void updateCuMemberBackOldAchieveEveryDay(Map<Long, MemberAchieveParam> memberAchieveParamMap, String tablaName);
/**
* 将昨天日表数据插入今天日表中, 昨日日表更新今天日表网体表
* 根据昨天结算表数据更新今天结算表的业绩数据
*
* @param targetTable 目标表 记录10天跟月表一摸一样的滚动表数据
*/
void updateCuMemberSettleInitAchieve(String targetTable);
/**
* 将昨天日表数据插入今天日表中, 昨日日表更新今天日表网体表
* 根据昨天结算表数据更新今天结算表的业绩数据
*
* @param sourceTable 来源表，记录10天跟月表一摸一样的滚动表数据
* @param targetTable 目标表 记录10天跟月表一摸一样的滚动表数据
*/
void updateCuMemberSettleAchieveByBeforeDay(String sourceTable, String targetTable);
/**
* 将昨天日表数据插入今天日表中, 昨日日表更新今天日表网体表
* 根据昨天结算表数据更新今天结算表的业绩数据
@ -105,32 +37,9 @@ public interface ICuMemberAchieveService extends IService<CuMemberAchieve> {
*/
void updateCuMemberExpandSettleAchieveByBeforeDay(String sourceTable, String targetTable);
/**
* 根据特殊业务更新业绩
*
* @param targetTable 结算表
* @param period 期间
* @param pkId 主键
*/
void updateCuMemberSettleAchieveBySpecialBus(String targetTable, Integer period, Long pkId);
/*
* 注水到期更新业绩
**/
void mergeCuMemberSettleByAchieveLogByDate(String targetTable, Date settleDate);
/*
* 根据到期日期更新业绩，到期后需要还原到实际累计金额
**/
void updateCuMemberSettleAchieveByDueDate(String currentTableName, String yesTableName, Date currentDate);
/*
* 退单回退业绩
**/
Boolean chargeBackSaOrder(SaOrder saOrder);
/*
* 查询每月月业绩，获得血缘业绩 首购复购
**/
List<CuMemberAchieveExt> queryCuMemberMonthAchieveByMemberIdList(String settleTableName, List<CuMemberSwingNetExt> memberSwingNetExtList);
}

315
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/achieve/service/ICuMemberTreeService.java
View File

@ -2,16 +2,8 @@ package com.hzs.bonus.achieve.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hzs.common.domain.member.achieve.CuMemberTree;
import com.hzs.common.domain.member.achieve.ext.CuMemberAchieveExt;
import com.hzs.common.domain.member.detail.CuMemberAwards;
import com.hzs.common.domain.member.detail.CuMemberGrade;
import com.hzs.common.domain.member.ext.CuMemberSettleExt;
import com.hzs.common.domain.sale.ext.SaOrderExt;
import com.hzs.bonus.achieve.param.MemberAchieveParam;
import com.hzs.bonus.achieve.param.MemberParentCountParam;
import com.hzs.bonus.census.param.CensusSummaryParam;
import com.hzs.bonus.census.vo.CensusSummaryVo;
import org.apache.ibatis.annotations.Param;
import java.util.Date;
import java.util.List;
@ -30,26 +22,6 @@ public interface ICuMemberTreeService extends IService<CuMemberTree> {
*/
void createCuMemberTree(String date);
/*
* 为计算4-n，增加碰次，增加表
**/
void createTouchCuMemberTree(String date);
/**
* 每月初，初始化考核数据，根据月底网体数据，先进行奖金计算在进行考核，考核在计算奖金之后
*
* @param settleDate 结算日期
*/
void initCuMemberAssessData(String settleDate);
/**
* 初始用来结算奖金的表，
*
* @param yesterdaySettleTableName 昨天的结算表
* @param currentSettleTableName 结算日的结算表
*/
void initCuMemberTreeTable(String yesterdaySettleTableName, String currentSettleTableName);
/**
* 初始用来结算奖金的表，多次重算奖金，只更新结余
*
@ -58,38 +30,6 @@ public interface ICuMemberTreeService extends IService<CuMemberTree> {
*/
void initCuMemberExpandTreeTable(String yesterdaySettleTableName, String currentSettleTableName);
/**
* 重新结算会员网体
*
* @param currentSettleTableName 结算日的表名
*/
void updateCuMemberSettle(Map<Long, MemberAchieveParam> cuMemberAchieveHashMap, String currentSettleTableName);
/**
* 重新结算会员网体业绩
*
* @param currentSettleTableName 更新甩网业绩
*/
void updateCuMemberNetAchieve(List<CuMemberAchieveExt> updMemberAchieveExtList, String currentSettleTableName);
/**
* 重新结算会员网体
*
* @param currentSettleTableName 结算日的表名
*/
void updateCuMemberBackSettle(Map<Long, MemberAchieveParam> cuMemberAchieveHashMap, String currentSettleTableName);
/**
* 更新会员网体，将会员网体改为死点，检查网体是否有问题
*
* @param revokeRegSaOrderList 注册撤销订单
* @param revokeUpdSaOrderList 升级撤销订单
* @param settleDate 计算日期
* @param settleTableName 结算表名
*/
void updateCuMemberTreeByCancelOrder(List<SaOrderExt> revokeRegSaOrderList, List<SaOrderExt> revokeUpdSaOrderList,
String settleDate, String settleTableName);
/**
* 判断是否存在临时表
*
@ -112,22 +52,6 @@ public interface ICuMemberTreeService extends IService<CuMemberTree> {
*/
void createCuMemberTableSequence(String tableName, String tableNameSeq);
/**
* 将结算日表的值插入到结算月表中
*
* @param settleDate 结算日期
* @param settleTableName 结算日表
* @param period 期间
*/
void insertCuMemberTreeBySettleDate(String settleDate, String settleTableName, Integer period);
/**
* 查询历史会员网体信息,查询某一天免考的会员
*
* @param tableName 结算表
*/
List<CuMemberSettleExt> queryExemptCuMemberSettle(String tableName);
/**
* 查询出符合下一等级足够业绩的会员
*
@ -145,9 +69,9 @@ public interface ICuMemberTreeService extends IService<CuMemberTree> {
**/
void updateBackCuMemberSettleRangeAward(String rangeTableName, Integer period);
/*
* 回退会员奖衔
**/
/**
* 回退会员奖衔
*/
void updateBackCuMemberRetailRangeAward(String rangeTableName, Integer period);
/*
@ -155,9 +79,9 @@ public interface ICuMemberTreeService extends IService<CuMemberTree> {
**/
void updateCuMemberRetailRangeAwardByDate(String rangeTableName, Date settleDate);
/*
* 回退会员奖衔
**/
/**
* 初始化期间奖衔
*/
void updateCuMemberRetailRangeInitAward(String rangeTableName);
/**
@ -185,15 +109,6 @@ public interface ICuMemberTreeService extends IService<CuMemberTree> {
*/
void updateCuMemberSettleByPeriod(List<Integer> periodList);
/**
* 根据等级、奖衔满足晋升的情况 更新网体免考记录
*
* @param settleTableName 结算表
* @param startDate 开始日期
* @param endDate 结束日期
*/
Boolean updateCuMemberSettleExemptByAward(String settleTableName, Date startDate, Date endDate);
/**
* 根据订单，查询出网体中记录的会员数据，推荐人、安置人
*
@ -239,14 +154,6 @@ public interface ICuMemberTreeService extends IService<CuMemberTree> {
*/
List<CuMemberSettleExt> batchQueryCuMemberSettleParent(String settleTableName, Set<Long> expandMemberSet);
/**
* 批量根据量奖信息查询会员结算表中的父级血缘数据
*
* @param settleTableName 结算表
* @param expandMemberSet 有量奖的会员
*/
List<CuMemberSettleExt> batchQuerySpecialCuMemberSettleParent(String settleTableName, Set<Long> expandMemberSet);
/**
* 批量根据量奖信息查询会员结算表中的父级血缘数据
*
@ -255,14 +162,6 @@ public interface ICuMemberTreeService extends IService<CuMemberTree> {
*/
List<CuMemberSettleExt> batchQueryCuMemberSettleParentForSpecial(String settleTableName, Set<Long> expandMemberSet);
/**
* 更新会员树的累计业绩
*
* @param settleTableName 结算日期
* @param cuMemberTreeMap 树
*/
void updateCuMemberSettle(String settleTableName, Map<Long, CuMemberSettleExt> cuMemberTreeMap);
/**
* 更新会员树的累计业绩
*
@ -271,199 +170,6 @@ public interface ICuMemberTreeService extends IService<CuMemberTree> {
*/
void updateCuMemberExpandSettle(String settleTableName, Map<Long, CuMemberSettleExt> cuMemberTreeMap);
/**
* 更新会员树的累计业绩
*
* @param settleTableName 结算日期
* @param cuMemberTreeMap 树
*/
void updateCuMemberSecond(String settleTableName, Map<Long, CuMemberSettleExt> cuMemberTreeMap);
/**
* 根据会员编号更新会员伞上秒结数据，新增或修改
*
* @param secondTableName 秒结表
* @param settleTableName 结算表
* @param pkMember 会员表
* @param cuMemberTreeList 树
* @param isPlace 是否安置
*/
void updateCuMemberSecondPlaceParent(String secondTableName, String settleTableName, String yesSettleTableName,
Long pkMember, List<?> cuMemberTreeList, Integer isPlace);
/**
* 根据会员编号查询会员伞上安置秒结数据
*
* @param secondTableName 秒接
* @param pkMember 会员
*/
List<CuMemberSettleExt> queryCuMemberSecondPlaceParent(String secondTableName, Long pkMember);
/**
* 根据会员编号查询会员伞上安置人秒结数据
*
* @param secondTableName 秒接
* @param pkMember 会员
*/
List<CuMemberSettleExt> queryCuMemberSecondBloParent(String secondTableName, Long pkMember);
/**
* 根据会员编号查询会员伞上血缘秒结数据
*
* @param secondTableName 秒接
* @param cuMemberTreeList 推荐人
*/
List<CuMemberSettleExt> queryCuMemberSecondParent(@Param("secondTableName") String secondTableName, @Param("cuMemberTreeList") List<?> cuMemberTreeList);
/**
* 查询安置上下级
*
* @param settleTableName
* @param pkMember
* @return
*/
List<CuMemberSettleExt> queryCuMemberTreePlaceParentTable(String settleTableName, Long pkMember, List<Long> memberIdList, Integer level);
/**
* 根据pkmember查询
*
* @param settleTableName
* @param pkMember
* @return
*/
CuMemberSettleExt queryCuMemberTreeByPkMemberTable(String settleTableName, Long pkMember);
/**
* 查询推荐关系
*
* @param settleTableName
* @param pkMember
* @return
*/
List<CuMemberSettleExt> queryCuMemberTreeParentTable(String settleTableName, Long pkMember, Integer level);
/**
* 查询直推人数
*
* @param settleTableName
* @param pkMember
* @return
*/
Long queryCuMemberTreeParentTableCount(String settleTableName, Long pkMember);
/**
* 查询历史安置上下级
*
* @param settleTableName
* @param pkMember
* @return
*/
List<CuMemberSettleExt> queryCuMemberTreePlaceParentHistoryTable(String settleTableName, Long pkMember, List<Long> memberIdList, Integer level);
/**
* 查询每一期汇总
**/
CensusSummaryVo queryCuMemberTreeParentSumTable(String settleTableName, CensusSummaryParam censusSummaryParam);
/*
* 查询历史网体的最末安置人，左右区一起查出来
**/
List<CuMemberSettleExt> queryCuMemberTreeLastPlaceParent(String settleTableName, Long pkMember);
/*
* 查询
**/
List<CuMemberSettleExt> queryCuMemberTree(String settleTableName, Long pkMember, Long pkPlaceParent);
/**
* 查询秒结表会员信息
*
* @param pkMember
* @param settleTableName
* @param level
* @return
*/
List<CuMemberSettleExt> selectByTreeMemberList(Long pkMember, String settleTableName, Integer level);
/**
* 查询会员真实业绩
*
* @param pkMember
* @return
*/
CuMemberSettleExt getCuMemberRealPerformanceByMemberId(Long pkMember, String tableName);
/**
* 查询会员安置左右区
*
* @param userId
* @param settleTableName
* @return
*/
Long queryLeftPeopleNumber(Long userId, String settleTableName);
/**
* 查询安置左右区人数
*
* @param memberId 会员id
* @param placeDept
* @return
*/
Long queryPlaceParentPeopleNumber(Long memberId, Integer placeDept);
/**
* 查询推荐大小区人数
*
* @param memberId
* @param placeDept
* @return
*/
Long queryParentPeopleNumber(Long memberId, Integer placeDept);
/**
* 查询秒结表是否有值
*
* @param settleTableName
* @return
*/
Long selectByselectByTreeMemberCount(String settleTableName, Long pkMember);
/**
* 查询伞下安置新增业绩
*
* @param settleTableName
* @param pkMember
* @return
*/
List<CuMemberSettleExt> brollyBelowResettle(String settleTableName, Long pkMember);
/**
* 根据pkmember查询 关联parent
*
* @param settleTableName
* @param pkMember
* @return
*/
CuMemberSettleExt queryCuMemberTreeByPlacePkMemberTable(String settleTableName, Long pkMember);
/**
* 查询会员直推业绩
*
* @param settleTableName
* @param memberIds
* @return
*/
List<MemberParentCountParam> queryByMemberParentSumPv(String settleTableName, List<Long> memberIds);
/**
* 迁移月表数据，先删除
*
* @param targetTableName 目标表
* @param period 期间
*/
void deleteCuMemberTreeByPeriod(String targetTableName, Integer period);
/**
* 删除日表数据
*
@ -492,13 +198,4 @@ public interface ICuMemberTreeService extends IService<CuMemberTree> {
*/
void createCuMemberTreePlaceIndex(String tableName);
/**
* 查询会员历史直推业绩
*
* @param settleTableName
* @param memberIds
* @return
*/
List<MemberParentCountParam> queryByMemberParentSettleSumPv(@Param("settleTableName") String settleTableName, @Param("memberIds") List<Long> memberIds);
}

90
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/achieve/service/impl/CuMemberAchieveServiceImpl.java
View File

@ -9,9 +9,6 @@ import com.hzs.common.core.enums.EOrderType;
import com.hzs.common.core.utils.DateUtils;
import com.hzs.common.domain.member.achieve.CuMemberAchieve;
import com.hzs.common.domain.member.achieve.CuMemberSettlePeriod;
import com.hzs.common.domain.member.achieve.ext.CuMemberAchieveExt;
import com.hzs.common.domain.member.ext.CuMemberSettleExt;
import com.hzs.common.domain.member.swing.ext.CuMemberSwingNetExt;
import com.hzs.common.domain.sale.order.SaOrder;
import com.hzs.common.service.ITransactionCommonService;
import com.hzs.bonus.achieve.mapper.CuMemberAchieveMapper;
@ -33,21 +30,13 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
private ICuMemberTreeService cuMemberTreeService;
private CuMemberBonusSettle cuMemberBonusSettle;
private ICuMemberSettlePeriodService cuMemberSettlePeriodService;
@Autowired
public void setCuMemberSettlePeriodService(ICuMemberSettlePeriodService cuMemberSettlePeriodService) {
this.cuMemberSettlePeriodService = cuMemberSettlePeriodService;
}
@Autowired
public void setCuMemberBonusSettle(CuMemberBonusSettle cuMemberBonusSettle) {
this.cuMemberBonusSettle = cuMemberBonusSettle;
}
@Autowired
public void setCuMemberTreeService(ICuMemberTreeService cuMemberTreeService) {
this.cuMemberTreeService = cuMemberTreeService;
@ -88,90 +77,11 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
baseMapper.mergeCuMemberMonth(DateUtils.getMonth(date), cuMemberSettlePeriod.getPkId());
}
@Override
public void insertCuMemberAchieveBySettleDate(String targetTableName, String sourceTableName, Integer period) {
baseMapper.insertCuMemberAchieveBySettleDate(targetTableName, sourceTableName, period);
}
@Override
public void mergeCuMemberAchieveBySettleDate(String targetTableName, String sourceTableName, Integer period) {
baseMapper.mergeCuMemberAchieveBySettleDate(targetTableName, sourceTableName, period);
}
/*
* @description:更新为初始化的数据，防止当天新增的数据
* @author: sui q
* @date: 2023/8/11 14:56
* @param: null null
**/
@Override
public void updateCuMemberSettleInitAchieve(String targetTable) {
baseMapper.updateCuMemberSettleInitAchieve(targetTable);
}
@Override
public void updateCuMemberSettleAchieveByBeforeDay(String sourceTable, String targetTable) {
baseMapper.updateCuMemberSettleAchieveByBeforeDay(sourceTable, targetTable);
}
@Override
public void updateCuMemberExpandSettleAchieveByBeforeDay(String sourceTable, String targetTable) {
baseMapper.updateCuMemberExpandSettleAchieveByBeforeDay(sourceTable, targetTable);
}
@Override
public void updateCuMemberSettleAchieveBySpecialBus(String targetTable, Integer period, Long pkId) {
baseMapper.updateCuMemberSettleAchieveBySpecialBus(targetTable, period, pkId);
}
@Override
public void mergeCuMemberSettleByAchieveLogByDate(String targetTable, Date settleDate) {
baseMapper.mergeCuMemberSettleByAchieveLogByDate(targetTable, settleDate);
}
@Override
public void updateCuMemberSettleAchieveByDueDate(String currentTableName, String yesTableName, Date currentDate) {
baseMapper.updateCuMemberSettleAchieveByDueDate(currentTableName, yesTableName, currentDate);
}
@Override
public void updateCuMemberAchieveEveryDay(Map<Long, MemberAchieveParam> memberAchieveParamMap, String tablaName) {
if (memberAchieveParamMap.size() == 0) {
return;
}
List<MemberAchieveParam> memberAchieveParamList = new ArrayList<>();
memberAchieveParamMap.forEach((key, memberAchieveParam) ->
memberAchieveParamList.add(memberAchieveParam));
List<List<?>> listList = cuMemberBonusSettle.handleCutList(memberAchieveParamList, MagicNumberConstants.DELETE_DATA_BATCH_UPDATE_NUM);
listList.forEach(list -> {
baseMapper.updateCuMemberBackAchieveEveryDay(list, tablaName);
});
}
@Override
public void updateCuMemberNetAchieve(List<CuMemberAchieveExt> updMemberAchieveExtList, String currentSettleTableName) {
baseMapper.updateCuMemberNetAchieve(updMemberAchieveExtList, currentSettleTableName);
}
@Override
public void updateCuMemberBackOldAchieveEveryDay(Map<Long, MemberAchieveParam> memberAchieveParamMap, String tablaName) {
if (memberAchieveParamMap.size() == 0) {
return;
}
List<MemberAchieveParam> memberAchieveParamList = new ArrayList<>();
memberAchieveParamMap.forEach((key, memberAchieveParam) ->
memberAchieveParamList.add(memberAchieveParam));
List<List<?>> listList = cuMemberBonusSettle.handleCutList(memberAchieveParamList, MagicNumberConstants.DELETE_DATA_BATCH_UPDATE_NUM);
listList.forEach(list -> {
baseMapper.updateCuMemberBackOldAchieveEveryDay(list, tablaName);
});
}
@Override
public List<CuMemberAchieveExt> queryCuMemberMonthAchieveByMemberIdList(String settleTableName, List<CuMemberSwingNetExt> memberSwingNetExtList) {
return baseMapper.queryCuMemberMonthAchieveByMemberIdList(settleTableName, memberSwingNetExtList);
}
@Override
public Boolean chargeBackSaOrder(SaOrder saOrder) {
// 根据支付时间查询期间

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

@ -29,8 +29,10 @@ public class CuMemberRetailRangeServiceImpl extends ServiceImpl<CuMemberRetailRa
@Override
public void mergeMemberRetailRangeByYesterday(Date settleEndDate, String rangeTableName, String yesterdayRangeTableName, Boolean isSameMonth) {
// 当天数据全部更新为0
baseMapper.mergeMemberRetailRangeInit(rangeTableName);
if (isSameMonth) {
// 结算期间和结算期间前一期是同月
baseMapper.mergeMemberRetailRangeByYesterday(rangeTableName, yesterdayRangeTableName, 0);
} else {
baseMapper.mergeMemberRetailRangeByYesterday(rangeTableName, yesterdayRangeTableName, 1);

503
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/achieve/service/impl/CuMemberTreeServiceImpl.java
View File

@ -11,28 +11,17 @@ import com.hzs.common.core.constant.TableNameConstants;
import com.hzs.common.core.enums.EAwardsType;
import com.hzs.common.core.utils.ComputeUtil;
import com.hzs.common.core.utils.DateUtils;
import com.hzs.common.core.utils.StringUtils;
import com.hzs.common.domain.member.achieve.CuMemberTree;
import com.hzs.common.domain.member.achieve.ext.CuMemberAchieveExt;
import com.hzs.common.domain.member.detail.CuMemberAwards;
import com.hzs.common.domain.member.detail.CuMemberGrade;
import com.hzs.common.domain.member.ext.CuMemberSettleExt;
import com.hzs.common.domain.sale.ext.SaOrderExt;
import com.hzs.bonus.achieve.mapper.CuMemberTreeMapper;
import com.hzs.bonus.achieve.param.MemberAchieveParam;
import com.hzs.bonus.achieve.param.MemberParentCountParam;
import com.hzs.bonus.census.param.CensusSummaryParam;
import com.hzs.bonus.census.vo.CensusSummaryVo;
import com.hzs.bonus.detail.service.ICuMemberAssessService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;
/**
* 会员网体历史记录 服务实现类
@ -41,25 +30,15 @@ import java.util.stream.Collectors;
@Service
public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuMemberTree> implements ICuMemberTreeService {
@Autowired
private ICuMemberTreeService memberTreeService;
private ICuMemberAchieveService cuMemberAchieveService;
private CuMemberBonusSettle cuMemberBonusSettle;
private ICuMemberSettlePeriodService cuMemberSettlePeriodService;
private ICuMemberAssessService cuMemberAssessService;
@Autowired
private ICuBonusExpandService bonusExpandService;
@Autowired
public void setCuMemberAssessService(ICuMemberAssessService cuMemberAssessService) {
this.cuMemberAssessService = cuMemberAssessService;
}
@Autowired
public void setCuMemberSettlePeriodService(ICuMemberSettlePeriodService cuMemberSettlePeriodService) {
this.cuMemberSettlePeriodService = cuMemberSettlePeriodService;
@ -88,33 +67,6 @@ public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuM
baseMapper.createCuMemberTreeParentIndex(settleTableName);
baseMapper.createCuMemberTreePlaceIndex(settleTableName);
}
// number = baseMapper.queryExistOrderTableCount(settleTableName);
// if (number == null || number <= 0) {
// // 初始化日表数据，将cu_member数据插入到最新的日表记录表
// baseMapper.insertCuMemberSettleByMember(settleTableName);
// // 结算日期月份的第一天
// Date settleDate = DateUtils.parseStringToDate(date);
// Date endDate = DateUtils.afterDate(1, ChronoUnit.DAYS, settleDate);
// Date startDate = DateUtils.beforeMonthFirstDate(settleDate);
// updateCuMemberSettleExemptByAward(settleTableName, startDate, endDate);
// }
// 创建极差结算记录表
// String rangeTableName = TableNameConstants.CU_MEMBER_RANGE + period;
// number = baseMapper.queryExistOracleTable(rangeTableName);
// if(number == null || number <= 0){
// baseMapper.createCuMemberRangeTable(rangeTableName);
// baseMapper.createCuMemberTreeDayOnlyIndex(rangeTableName);
// baseMapper.createCuMemberTreeParentIndex(rangeTableName);
// }
// number = baseMapper.queryExistOrderTableCount(rangeTableName);
// if (number == null || number <= 0) {
// // 初始化日表数据，将cu_member数据插入到最新的日表记录表
// // 获取当前月份第一天
// Date firstDate = DateUtils.currentMonthFirstDate(DateUtils.parseStringToDate(date));
// Integer firstPeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(DateUtils.parseDateToFormat(DateUtils.YYYY_MM_DD, firstDate)).getPkId();
// String year = DateUtils.getYear(date);
// baseMapper.insertCuMemberRangeByMember(rangeTableName, year, firstPeriod, firstDate);
// }
// 创建新零售极差结算记录表
String retailRangeTableName = TableNameConstants.CU_MEMBER_RETAIL_RANGE + period;
number = baseMapper.queryExistOracleTable(retailRangeTableName);
@ -127,26 +79,16 @@ public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuM
if (number == null || number <= 0) {
baseMapper.insertCuMemberRetailRangeByMember(retailRangeTableName);
}
// 创建月表记录表
createMonthTreeTableName(date);
// 创建月表业绩记录表
cuMemberAchieveService.createCuMemberAchieve(date);
// 创建秒接表，秒结表只需要表结构，跟日表一模一样，秒结表期间是date+1期间
Date tomorrowDate = DateUtils.afterDate(1, ChronoUnit.DAYS, DateUtils.parseStringToDate(date));
String tomorrow = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, tomorrowDate);
int nextPeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(tomorrow).getPkId();
// String secondTableName = TableNameConstants.CU_MEMBER_SECOND + nextPeriod;
// number = baseMapper.queryExistOracleTable(secondTableName);
// if (number == null || number <= 0) {
// baseMapper.createCuMemberSecondTable(secondTableName);
// baseMapper.createCuMemberTreeDayOnlyIndex(secondTableName);
// }
// String secondRangeTableName = TableNameConstants.CU_MEMBER_RANGE_S + nextPeriod;
// number = baseMapper.queryExistOracleTable(secondRangeTableName);
// if (number == null || number <= 0) {
// baseMapper.createCuMemberRangeSecondTable(secondRangeTableName);
// baseMapper.createCuMemberTreeDayOnlyIndex(secondRangeTableName);
// }
String secondRetailRangeTableName = TableNameConstants.CU_MEMBER_RETAIL_S + nextPeriod;
number = baseMapper.queryExistOracleTable(secondRetailRangeTableName);
if (number == null || number <= 0) {
@ -154,68 +96,10 @@ public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuM
baseMapper.createCuMemberTreeDayOnlyIndex(secondRetailRangeTableName);
baseMapper.createCuMemberTreeParentIndex(secondRetailRangeTableName);
}
// 删除30天前的结算日表，结算秒表
// Date beforeDate = DateUtils.beforeDate(30, ChronoUnit.DAYS, DateUtils.parseStringToDate(date));
// 上个月最后一天
// Date beforeLastDate = DateUtils.beforeMonthLastDate(DateUtils.parseStringToDate(date));
// int beforePeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, beforeDate)).getPkId();
// 不删除每月最后一条数据
// if(!DateUtils.compareDateEqual(beforeDate, beforeLastDate)) {
// String beforeSettleTableName = TableNameConstants.CU_MEMBER_SETTLE + beforePeriod;
// number = baseMapper.queryExistOracleTable(beforeSettleTableName);
// if (number != null && number > 0) {
// baseMapper.dropCuMemberSettleTable(beforeSettleTableName);
// }
// }
// String beforeSecondTableName = TableNameConstants.CU_MEMBER_SECOND + beforePeriod;
// number = baseMapper.queryExistOracleTable(beforeSecondTableName);
// if (number != null && number > 0) {
// baseMapper.dropCuMemberSettleTable(beforeSecondTableName);
// }
BonusExpandParam bonusExpandParam = BonusExpandParam.builder().settleDate(DateUtils.parseStringToDate(date)).build();
bonusExpandService.firstSaveCuBonusExpand(bonusExpandParam);
}
@Override
public void createTouchCuMemberTree(String date) {
// 创建日表记录表
String settleTableName = createSettleTable(date);
Integer number = baseMapper.queryExistOrderTableCount(settleTableName);
if (number == null || number <= 0) {
// 初始化日表数据，将cu_member数据插入到最新的日表记录表
int period = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(date).getPkId();
String treeTableName = TableNameConstants.CU_MEMBER_TREE + DateUtils.getMonth(date);
String achieveTableName = TableNameConstants.CU_MEMBER_ACHIEVE + DateUtils.getMonth(date);
baseMapper.insertCuMemberSettleByHis(settleTableName, treeTableName, achieveTableName, period);
}
}
private String createSettleTable(String date) {
int period = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(date).getPkId();
String settleTableName = TableNameConstants.CU_MEMBER_SETTLE + period;
Integer number = baseMapper.queryExistOracleTable(settleTableName);
// if(number != null && number >0){
// baseMapper.dropCuMemberSettleTable(settleTableName);
// }
if (number == null || number <= 0) {
baseMapper.createCuMemberSettleTable(settleTableName);
baseMapper.createCuMemberTreeDayOnlyIndex(settleTableName);
baseMapper.createCuMemberTreeParentIndex(settleTableName);
baseMapper.createCuMemberTreePlaceIndex(settleTableName);
}
BonusExpandParam bonusExpandParam = BonusExpandParam.builder().settleDate(DateUtils.parseStringToDate(date)).build();
bonusExpandService.firstSaveCuBonusExpand(bonusExpandParam);
return settleTableName;
}
@Override
public void initCuMemberAssessData(String settleDate) {
// 创建日表记录表
int period = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(settleDate).getPkId();
// 创建月表考核记录表
cuMemberAssessService.initCuMemberAssessData(settleDate, period);
}
private String createMonthTreeTableName(String date) {
Integer number;
String monthTableName = TableNameConstants.CU_MEMBER_TREE + DateUtils.getMonth(date);
@ -230,59 +114,11 @@ public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuM
return monthTableName;
}
@Override
public void initCuMemberTreeTable(String yesterdaySettleTableName, String currentSettleTableName) {
// 更新所有值为0
cuMemberAchieveService.updateCuMemberSettleInitAchieve(currentSettleTableName);
// 初始化结算日的数据，将日期-1的数据作为当天的数据
cuMemberAchieveService.updateCuMemberSettleAchieveByBeforeDay(yesterdaySettleTableName, currentSettleTableName);
}
@Override
public void initCuMemberExpandTreeTable(String yesterdaySettleTableName, String currentSettleTableName) {
cuMemberAchieveService.updateCuMemberExpandSettleAchieveByBeforeDay(yesterdaySettleTableName, currentSettleTableName);
}
/**
* 重新计算网体，计算结算日的值，需要使用结算日的网体、结算日昨天的业绩，网体不存在的话拉最新的会员网体
*
* @return: void
* @Author: sui q
* @Date: 2022/10/31 18:56
*/
@Override
public void updateCuMemberSettle(Map<Long, MemberAchieveParam> cuMemberAchieveHashMap, String currentSettleTableName) {
cuMemberAchieveService.updateCuMemberAchieveEveryDay(cuMemberAchieveHashMap, currentSettleTableName);
}
@Override
public void updateCuMemberNetAchieve(List<CuMemberAchieveExt> updMemberAchieveExtList, String currentSettleTableName) {
cuMemberAchieveService.updateCuMemberNetAchieve(updMemberAchieveExtList, currentSettleTableName);
}
@Override
public void updateCuMemberBackSettle(Map<Long, MemberAchieveParam> cuMemberAchieveHashMap, String currentSettleTableName) {
cuMemberAchieveService.updateCuMemberBackOldAchieveEveryDay(cuMemberAchieveHashMap, currentSettleTableName);
}
@Override
public void updateCuMemberTreeByCancelOrder(List<SaOrderExt> revokeRegSaOrderList, List<SaOrderExt> revokeUpdSaOrderList, String settleDate, String settleTableName) {
// 更新网体，将撤单的注册订单，会员数据修改为死点
if (revokeRegSaOrderList.size() > 0) {
List<List<?>> revokeSaOrderList = cuMemberBonusSettle.handleCutList(revokeRegSaOrderList);
revokeSaOrderList.forEach(saOrderList -> {
baseMapper.updateCuMemberTreeByCancelOrder(saOrderList, settleTableName);
});
}
// 更新网体，将撤销的升级订单，会员等级降级
if (revokeRegSaOrderList.size() > 0) {
Date tomorrow = DateUtils.afterDate(1, ChronoUnit.DAYS, DateUtils.parseStringToDate(settleDate));
List<List<?>> revokeSaOrderList = cuMemberBonusSettle.handleCutList(revokeRegSaOrderList);
revokeSaOrderList.forEach(saOrderList ->
baseMapper.updateCuMemberTreeGradeByCancelOrder(saOrderList, tomorrow, settleTableName));
}
}
@Override
public Integer queryExistOracleTable(String tableName) {
return baseMapper.queryExistOracleTable(tableName);
@ -298,31 +134,6 @@ public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuM
baseMapper.createCuMemberTableSequence(tableName, tableNameSeq);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void insertCuMemberTreeBySettleDate(String settleDate, String settleTableName, Integer period) {
// 创建月表记录表
String treeTableName = createMonthTreeTableName(settleDate);
String achieveTableName = cuMemberAchieveService.createCuMemberAchieve(settleDate);
// 删除之前的数据
// baseMapper.deleteCuMemberTreeByPeriod(treeTableName, period);
// baseMapper.deleteCuMemberTreeByPeriod(achieveTableName, period);
// 迁移新的数据
// baseMapper.insertCuMemberTreeBySettleDate(treeTableName, settleTableName, period);
baseMapper.mergeCuMemberTreeBySettleDate(treeTableName, settleTableName, period);
// cuMemberAchieveService.insertCuMemberAchieveBySettleDate(achieveTableName, settleTableName, period);
cuMemberAchieveService.mergeCuMemberAchieveBySettleDate(achieveTableName, settleTableName, period);
}
@Override
public List<CuMemberSettleExt> queryExemptCuMemberSettle(String tableName) {
List<CuMemberSettleExt> cuMemberSettleExtList = baseMapper.queryExemptCuMemberSettle(tableName);
if (cuMemberSettleExtList == null) {
return Collections.emptyList();
}
return cuMemberSettleExtList;
}
@Override
public List<CuMemberSettleExt> queryCuMemberSettleEnoughAwardAchieve(String settleTableName) {
return baseMapper.queryCuMemberSettleEnoughAwardAchieve(settleTableName);
@ -374,11 +185,6 @@ public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuM
});
}
@Override
public Boolean updateCuMemberSettleExemptByAward(String settleTableName, Date startDate, Date endDate) {
return baseMapper.updateCuMemberSettleExemptByAward(settleTableName, startDate, endDate) > 0;
}
@Override
public List<CuMemberSettleExt> batchQueryMemberSettleBySaOrder(String settleTableName, List<SaOrderExt> saOrderExtList) {
// 查询出推荐人
@ -457,19 +263,6 @@ public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuM
return cuMemberSettleExtList;
}
@Override
public List<CuMemberSettleExt> batchQuerySpecialCuMemberSettleParent(String settleTableName, Set<Long> expandMemberSet) {
List<CuMemberSettleExt> cuMemberSettleExtList = new ArrayList<>();
if (expandMemberSet == null || expandMemberSet.size() == 0) {
return cuMemberSettleExtList;
}
List<Long> memberPkList = Arrays.asList(expandMemberSet.toArray(new Long[]{}));
List<List<?>> listList = cuMemberBonusSettle.handleCutList(memberPkList, MagicNumberConstants.DELETE_DATA_BATCH_UPDATE_NUM);
listList.forEach(list ->
cuMemberSettleExtList.addAll(baseMapper.batchQuerySpecialCuMemberSettleParent(settleTableName, list)));
return cuMemberSettleExtList;
}
@Override
public List<CuMemberSettleExt> batchQueryCuMemberSettleParentForSpecial(String settleTableName, Set<Long> expandMemberSet) {
List<CuMemberSettleExt> cuMemberSettleExtList = new ArrayList<>();
@ -480,305 +273,18 @@ public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuM
return cuMemberSettleExtList;
}
@Override
public void updateCuMemberSettle(String settleTableName, Map<Long, CuMemberSettleExt> cuMemberTreeMap) {
List<List<?>> treeList = setUpdCuMemberTreeLists(cuMemberTreeMap);
treeList.forEach(list -> baseMapper.updateCuMemberSettle(settleTableName, list));
}
@Override
public void updateCuMemberExpandSettle(String settleTableName, Map<Long, CuMemberSettleExt> cuMemberTreeMap) {
List<List<?>> treeList = setUpdCuMemberTreeLists(cuMemberTreeMap);
treeList.forEach(list -> baseMapper.updateCuMemberExpandSettle(settleTableName, list));
}
@Override
public void updateCuMemberSecond(String settleTableName, Map<Long, CuMemberSettleExt> cuMemberTreeMap) {
List<List<?>> treeList = setUpdCuMemberTreeLists(cuMemberTreeMap);
treeList.forEach(list -> baseMapper.updateCuMemberSecond(settleTableName, list));
}
/**
* 查询安置
*
* @param settleTableName
* @param pkMember
* @return
*/
@Override
public List<CuMemberSettleExt> queryCuMemberTreePlaceParentTable(String settleTableName, Long pkMember, List<Long> memberIdList, Integer level) {
return baseMapper.queryCuMemberTreePlaceParentTable(settleTableName, pkMember, memberIdList, level);
}
/**
* 根据pkmember查询
*
* @param settleTableName
* @param pkMember
* @return
*/
@Override
public CuMemberSettleExt queryCuMemberTreeByPkMemberTable(String settleTableName, Long pkMember) {
return baseMapper.queryCuMemberTreeByPkMemberTable(settleTableName, pkMember);
}
/**
* 查询推荐关系
*
* @param settleTableName
* @param pkMember
* @return
*/
@Override
public List<CuMemberSettleExt> queryCuMemberTreeParentTable(String settleTableName, Long pkMember, Integer level) {
Long b = System.currentTimeMillis();
System.out.println("开始时间：" + b);
List<CuMemberSettleExt> memberSettleExtList = baseMapper.queryCuMemberTreeParentTable(settleTableName, pkMember, level);
System.out.println("结束时间：" + (System.currentTimeMillis() - b));
List<Long> ids = memberSettleExtList.stream().map(a -> a.getPkMember()).collect(Collectors.toList());
// 查询会员直推人数
List<MemberParentCountParam> memberParentCountParamList = new ArrayList<>();
if (ids.size() > 0) {
if (settleTableName.contains(TableNameConstants.CU_MEMBER_SECOND)) {
// 秒结表查询当天的推荐上下级
memberParentCountParamList = baseMapper.queryByMemberParentCount(ids);
} else {
memberParentCountParamList = baseMapper.queryByMemberParentAndMemberSettleCount(ids, settleTableName);
}
}
Map<Long, Long> memberParentCountMap = memberParentCountParamList.stream().collect(Collectors.toMap(MemberParentCountParam::getPkMember, MemberParentCountParam::getParentMemberCount));
// 查询直推人数
memberSettleExtList.stream().map(a -> {
a.setDirectPushNumber(memberParentCountMap.getOrDefault(a.getPkMember(), 0L));
return a;
}).collect(Collectors.toList());
//查询直推业绩
if (StringUtils.isNotBlank(settleTableName) && ids.size() > 0) {
List<MemberParentCountParam> memberParentCountParamPvList = new ArrayList<>();
if (settleTableName.contains(TableNameConstants.CU_MEMBER_SECOND)) {
// 查询秒结表
memberParentCountParamPvList = memberTreeService.queryByMemberParentSumPv(settleTableName, ids);
} else {
memberParentCountParamPvList = memberTreeService.queryByMemberParentSettleSumPv(settleTableName, ids);
}
Map<Long, BigDecimal> memberParentPvMap = memberParentCountParamPvList.stream().collect(Collectors.toMap(MemberParentCountParam::getPkMember, MemberParentCountParam::getParentMemberSumPv));
// 查询直推业绩
memberSettleExtList.stream().map(a -> {
a.setHistoryPerformancePv(memberParentPvMap.getOrDefault(a.getPkMember(), BigDecimal.ZERO));
return a;
}).collect(Collectors.toList());
}
return memberSettleExtList;
}
/**
* 查询直推人数
*
* @param settleTableName
* @param pkMember
* @return
*/
@Override
public Long queryCuMemberTreeParentTableCount(String settleTableName, Long pkMember) {
return baseMapper.queryCuMemberTreeParentTableCount(settleTableName, pkMember);
}
/**
* 查询历史安置上下级
*
* @param settleTableName
* @param pkMember
* @return
*/
@Override
public List<CuMemberSettleExt> queryCuMemberTreePlaceParentHistoryTable(String settleTableName, Long pkMember, List<Long> memberIdList, Integer level) {
return baseMapper.queryCuMemberTreePlaceParentHistoryTable(settleTableName, pkMember, memberIdList, level);
}
/**
* 查询每一期汇总
*
* @param settleTableName
* @return
*/
@Override
public CensusSummaryVo queryCuMemberTreeParentSumTable(String settleTableName, CensusSummaryParam censusSummaryParam) {
return baseMapper.queryCuMemberTreeParentSumTable(settleTableName, censusSummaryParam);
}
@Override
public void updateCuMemberSecondPlaceParent(String secondTableName, String settleTableName, String yesSettleTableName, Long pkMember, List<?> cuMemberTreeList, Integer isPlace) {
if (DateUtils.getCurrentHour() < 2) {
settleTableName = yesSettleTableName;
}
baseMapper.updateCuMemberSecondPlaceParent(secondTableName, settleTableName, pkMember, cuMemberTreeList, isPlace);
}
@Override
public List<CuMemberSettleExt> queryCuMemberSecondPlaceParent(String secondTableName, Long pkMember) {
return baseMapper.queryCuMemberSecondPlaceParent(secondTableName, pkMember);
}
@Override
public List<CuMemberSettleExt> queryCuMemberSecondBloParent(String secondTableName, Long pkMember) {
return baseMapper.queryCuMemberSecondBloParent(secondTableName, pkMember);
}
@Override
public List<CuMemberSettleExt> queryCuMemberSecondParent(String secondTableName, List<?> cuMemberTreeList) {
List<CuMemberSettleExt> cuMemberSettleExtList = new ArrayList<>();
List<List<?>> listList = cuMemberBonusSettle.handleCutList(cuMemberTreeList, MagicNumberConstants.DELETE_DATA_BATCH_UPDATE_NUM);
listList.forEach(list -> cuMemberSettleExtList.addAll(baseMapper.queryCuMemberSecondParent(secondTableName, list)));
return cuMemberSettleExtList;
}
@Override
public List<CuMemberSettleExt> queryCuMemberTreeLastPlaceParent(String settleTableName, Long pkMember) {
return baseMapper.queryCuMemberTreeLastPlaceParent(settleTableName, pkMember);
}
@Override
public List<CuMemberSettleExt> queryCuMemberTree(String settleTableName, Long pkMember, Long pkPlaceParent) {
return baseMapper.queryCuMemberTree(settleTableName, pkMember, pkPlaceParent);
}
/**
* 查询秒结表会员信息
*
* @param pkMember
* @param settleTableName
* @param level
* @return
*/
@Override
public List<CuMemberSettleExt> selectByTreeMemberList(Long pkMember, String settleTableName, Integer level) {
return baseMapper.selectByTreeMemberList(pkMember, settleTableName, level);
}
/**
* 查询会员真实业绩
*
* @param pkMember
* @return
*/
@Override
public CuMemberSettleExt getCuMemberRealPerformanceByMemberId(Long pkMember, String tableName) {
return baseMapper.getCuMemberRealPerformanceByMemberId(pkMember, tableName);
}
/**
* 查询安置左右区人数
*
* @param userId 会员id
* @param settleTableName 查询表名
* @return Long
*/
@Override
public Long queryLeftPeopleNumber(Long userId, String settleTableName) {
return null;
}
/**
* 查询安置左右区人数
*
* @param userId 会员id
* @param placeDept
* @return
*/
@Override
public Long queryPlaceParentPeopleNumber(Long userId, Integer placeDept) {
return baseMapper.queryPlaceParentPeopleNumber(userId, placeDept);
}
/**
* 查询推荐大小区人数
*
* @param memberId
* @param placeDept
* @return
*/
@Override
public Long queryParentPeopleNumber(Long memberId, Integer placeDept) {
return baseMapper.queryParentPeopleNumber(memberId, placeDept);
}
/**
* 查询秒结表是否有值
*
* @param settleTableName
* @return
*/
@Override
public Long selectByselectByTreeMemberCount(String settleTableName, Long pkMember) {
return baseMapper.selectByselectByTreeMemberCount(settleTableName, pkMember);
}
/**
* 查询伞下安置新增业绩
*
* @param settleTableName
* @param pkMember
* @return
*/
@Override
public List<CuMemberSettleExt> brollyBelowResettle(String settleTableName, Long pkMember) {
return baseMapper.brollyBelowResettle(settleTableName, pkMember);
}
/**
* 根据pkmember查询 关联parent
*
* @param settleTableName
* @param pkMember
* @return
*/
@Override
public CuMemberSettleExt queryCuMemberTreeByPlacePkMemberTable(String settleTableName, Long pkMember) {
CuMemberSettleExt cuMemberSettleExt = baseMapper.queryCuMemberTreeByPlacePkMemberTable(settleTableName, pkMember);
List<Long> memberIds = Arrays.asList(cuMemberSettleExt.getPkMember());
// 查询会员直推人数
List<MemberParentCountParam> memberParentCountParamList = baseMapper.queryByMemberParentCount(memberIds);
Map<Long, Long> memberParentCountMap = memberParentCountParamList.stream().collect(Collectors.toMap(MemberParentCountParam::getPkMember, MemberParentCountParam::getParentMemberCount));
// 查询直推人数
cuMemberSettleExt.setDirectPushNumber(memberParentCountMap.getOrDefault(cuMemberSettleExt.getPkMember(), 0L));
//查询直推业绩
if (StringUtils.isNotBlank(settleTableName)) {
List<MemberParentCountParam> memberParentCountParamPvList = memberTreeService.queryByMemberParentSumPv(settleTableName, memberIds);
Map<Long, BigDecimal> memberParentPvMap = memberParentCountParamPvList.stream().collect(Collectors.toMap(MemberParentCountParam::getPkMember, MemberParentCountParam::getParentMemberSumPv));
cuMemberSettleExt.setHistoryPerformancePv(memberParentPvMap.getOrDefault(cuMemberSettleExt.getPkMember(), BigDecimal.ZERO));
}
return cuMemberSettleExt;
}
/**
* 查询会员直推业绩
*
* @param settleTableName
* @param memberIds
* @return
*/
@Override
public List<MemberParentCountParam> queryByMemberParentSumPv(String settleTableName, List<Long> memberIds) {
return baseMapper.queryByMemberParentSumPv(settleTableName, memberIds);
}
private List<List<?>> setUpdCuMemberTreeLists(Map<Long, CuMemberSettleExt> cuMemberTreeMap) {
List<CuMemberSettleExt> cuMemberTreeList = new ArrayList<>();
cuMemberTreeMap.forEach((key, value) -> cuMemberTreeList.add(value));
return cuMemberBonusSettle.handleCutList(cuMemberTreeList);
}
@Override
public void deleteCuMemberTreeByPeriod(String targetTableName, Integer period) {
baseMapper.deleteCuMemberTreeByPeriod(targetTableName, period);
}
@Override
public void truncateCuMemberTreeTable(String tableName) {
baseMapper.truncateCuMemberTreeTable(tableName);
@ -799,9 +305,4 @@ public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuM
baseMapper.createCuMemberTreePlaceIndex(tableName);
}
@Override
public List<MemberParentCountParam> queryByMemberParentSettleSumPv(String settleTableName, List<Long> memberIds) {
return baseMapper.queryByMemberParentSettleSumPv(settleTableName, memberIds);
}
}

4
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/base/mapper/CuMemberMapper.java
View File

@ -86,12 +86,12 @@ public interface CuMemberMapper extends BaseMapper<CuMember> {
void updateCuMemberRetailRangeAwardByDate(@Param("settleDate") Date settleDate, @Param("awardType") Integer awardType);
/**
* 更新会员奖衔根据临时表
* 初始化会员奖衔
*/
void updateCuMemberRetailRangeInitAward();
/**
* 更新会员奖衔根据临时表
* 初始化会员V5奖衔
*/
void updateCuMemberRetailRangeInitV5Award();

2
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/base/service/ICuMemberService.java
View File

@ -110,7 +110,7 @@ public interface ICuMemberService extends IService<CuMember> {
void updateCuMemberRetailRangeAwardByDate(Date settleDate);
/**
* 更新会员奖衔根据临时表
* 初始化会员奖衔表
*/
void updateCuMemberRetailRangeInitAward();

42
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/mapper/CuBonusExpandMapper.java
View File

@ -9,68 +9,42 @@ import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* <p>
* Mapper 接口
* </p>
*
* @author hzs
* @since 2024-07-19
* Mapper 接口
*/
public interface CuBonusExpandMapper extends BaseMapper<CuBonusExpand> {
/*
* @description: 查询4-n配置
* @author: sui q
* @date: 2024/7/23 10:09
* @param: null null
* 查询4-n配置
**/
List<CuBonusExpandExt> queryBonusExpand(BonusExpandParam bonusExpandParam);
/*
* @description: 查询日期是否标红
* @author: sui q
* @date: 2024/7/24 10:59
* @param: null null
* 查询日期是否标红
**/
List<CuBonusExpandExt> queryBonusExpandDis(BonusExpandParam bonusExpandParam);
/*
* @description: 查询所有零线会员
* @author: sui q
* @date: 2024/7/22 16:16
* @param: null null
* 查询所有零线会员
**/
List<CuBonusExpand> queryZeroMemberByVertex();
/*
* @description: 根基时间、期间计算波比
* @author: sui q
* @date: 2024/7/22 13:42
* @param: null null
* 根基时间、期间计算波比
**/
List<CuBonusExpand> calculateDayRatioByBonusExpandParam(@Param("bonusExpandParam") BonusExpandParam bonusExpandParam, @Param("tableName") String tableName);
/*
* @description: 根基时间、期间计算波比
* @author: sui q
* @date: 2024/7/22 13:42
* @param: null null
* 根基时间、期间计算波比
**/
List<CuBonusExpand> calculateDayRepRatioByBonusExpandParam(@Param("bonusExpandParam") BonusExpandParam bonusExpandParam, @Param("tableName") String tableName);
/*
* @description: 删除临时表
* @author: sui q
* @date: 2024/7/30 13:49
* @param: null null
* 删除临时表
**/
void truncateTable();
/*
* @description: 批量更新4-n配置
* @author: sui q
* @date: 2024/7/22 14:22
* @param: null null
* 批量更新4-n配置
**/
void mergeBonusExpandByList(@Param("cuBonusExpandList") List<CuBonusExpand> cuBonusExpandList);
}

11
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/provider/MemberSettleBonusProvider.java
View File

@ -11,7 +11,6 @@ import com.hzs.common.core.domain.R;
import com.hzs.common.core.utils.DateUtils;
import com.hzs.common.domain.member.bonus.CuMemberRetail;
import com.hzs.common.domain.member.bonus.CuMemberRetailLog;
import com.hzs.common.domain.sale.ext.SaOrderExt;
import com.hzs.common.domain.sale.order.SaOrder;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.DubboService;
@ -42,16 +41,6 @@ public class MemberSettleBonusProvider implements IMemberSettleBonusApi {
@Autowired
private ICuMemberRetailLogService iCuMemberRetailLogService;
@Override
public R<Boolean> calculateCumberBonusBySecond(String orderCode) {
try {
iBonusSettleService.calculateCumberBonusBySecond(orderCode);
} catch (Exception e) {
return R.fail();
}
return R.ok();
}
@Override
public R<Boolean> autoCalculateBonus(Date settleDate) {
try {

7
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/service/IBonusSettleService.java
View File

@ -10,13 +10,6 @@ import java.util.List;
*/
public interface IBonusSettleService {
/**
* 根据秒结算会员奖金
*
* @param orderCode 订单
*/
void calculateCumberBonusBySecond(String orderCode);
/**
* 计算会员奖金
*

38
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/service/ICuBonusExpandService.java
View File

@ -8,60 +8,38 @@ import com.hzs.common.domain.member.ext.CuBonusExpandExt;
import java.util.List;
/**
* <p>
* 服务类
* </p>
*
* @author hzs
* @since 2024-07-19
* 服务类
*/
public interface ICuBonusExpandService extends IService<CuBonusExpand> {
/*
* @description: 查询4-n配置
* @author: sui q
* @date: 2024/7/23 10:09
* @param: null null
* 查询4-n配置
**/
List<CuBonusExpandExt> queryBonusExpand(BonusExpandParam bonusExpandParam);
/*
* @description: 查询日期是否标红
* @author: sui q
* @date: 2024/7/24 10:59
* @param: null null
* 查询日期是否标红
**/
List<CuBonusExpandExt> queryBonusExpandDis(BonusExpandParam bonusExpandParam);
/*
* @description: 奖金计算时，先拉取昨日4-n 碰次，先用该碰次计算
* @author: sui q
* @date: 2024/7/19 14:22
* @param: null null
* 奖金计算时，先拉取昨日4-n 碰次，先用该碰次计算
**/
void firstSaveCuBonusExpand(BonusExpandParam bonusExpandParam);
/*
* @description: 奖金计算结束，统计波比、业绩
* @author: sui q
* @date: 2024/7/22 11:27
* @param: null null
* 奖金计算结束，统计波比、业绩
**/
void updateCuBonusExpandRatio(BonusExpandParam bonusExpandParam, String tableName);
/*
* @description: 保存或修改昨日4-n碰次
* @author: sui q
* @date: 2024/7/19 14:22
* @param: null null
* 保存或修改昨日4-n碰次
**/
void saveCuBonusExpand(BonusExpandParam bonusExpandParam);
/*
* @description: 重算首购奖金
* @author: sui q
* @date: 2024/7/23 11:59
* @param: null null
* 重算首购奖金
**/
void repeatCuBonusByExpand(BonusExpandParam bonusExpandParam);
}

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

@ -111,7 +111,6 @@ public class BonusSettleRangeHandle extends BonusSettleHandle {
// cuMemberRetailRangeExt.setSameDate(EYesNo.NO.getIntValue());
// }
for (Integer gradeValue : retaiBuyGradeMap.keySet()) {
// 判断购买升级处理
BdGrade bdGrade = retaiBuyGradeMap.get(gradeValue);
if (bdGrade.getBoxNumber() > 0 && cuMemberRetailRangeExt.getGradeValue().equals(gradeValue)) {
// TODO new 一次性补差，需要下个等级的盒数 - 当前等级盒数？？？
@ -144,12 +143,16 @@ public class BonusSettleRangeHandle extends BonusSettleHandle {
// }
// 订单业绩
BigDecimal orderAchieve = saOrderExt.getOrderAchieve();
// 个人累计消费pv
sourceMemberRangeExt.setNewBoxNum(sourceMemberRangeExt.getNewBoxNum() + boxNum);
sourceMemberRangeExt.setConsumeBoxNum(sourceMemberRangeExt.getConsumeBoxNum() + boxNum);
sourceMemberRangeExt.setNewConsumePv(ComputeUtil.computeAdd(sourceMemberRangeExt.getNewConsumePv(), orderAchieve));
sourceMemberRangeExt.setConsumePv(ComputeUtil.computeAdd(sourceMemberRangeExt.getConsumePv(), orderAchieve));
sourceMemberRangeExt.setMonthConsumePv(ComputeUtil.computeAdd(sourceMemberRangeExt.getMonthConsumePv(), orderAchieve));
if (EOrderType.RETAIL_REPURCHASE.getValue() == saOrderExt.getOrderType()
|| EOrderType.RETAIL_CONSUME.getValue() == saOrderExt.getOrderType()
) {
// 复购、重消，盒数、业绩算个人累计数据（盒数、业绩）
sourceMemberRangeExt.setNewBoxNum(sourceMemberRangeExt.getNewBoxNum() + boxNum);
sourceMemberRangeExt.setConsumeBoxNum(sourceMemberRangeExt.getConsumeBoxNum() + boxNum);
sourceMemberRangeExt.setNewConsumePv(ComputeUtil.computeAdd(sourceMemberRangeExt.getNewConsumePv(), orderAchieve));
sourceMemberRangeExt.setConsumePv(ComputeUtil.computeAdd(sourceMemberRangeExt.getConsumePv(), orderAchieve));
sourceMemberRangeExt.setMonthConsumePv(ComputeUtil.computeAdd(sourceMemberRangeExt.getMonthConsumePv(), orderAchieve));
}
// 会员等级升级记录
List<CuMemberGrade> cuMemberGradeList = new ArrayList<>();
@ -381,41 +384,58 @@ public class BonusSettleRangeHandle extends BonusSettleHandle {
*/
void calculateRetailBonusByDay(String settleDate, Map<Long, CuMemberBonus> cuMemberBonusMap, BonusConfigDTO bonusConfigDTO, BonusRecordDetailVO bonusRecordDetailVO,
Integer period, Integer yesterdayPeriod, Boolean isSameMonth) {
// 结算期间日期
Date settleStartDate = DateUtils.parseStringToDate(settleDate);
// 结算期间日期后一天
Date settleEndDate = DateUtils.afterDate(1, ChronoUnit.DAYS, settleStartDate);
List<SaOrderExt> retailOrderList = new ArrayList<>();
// 新零售订单
List<SaOrderExt> orderList = iBonusOrderService.queryRetailSaOrderByDay(settleStartDate, settleEndDate, null);
List<SaOrderExt> retailOrderList = new ArrayList<>();
for (SaOrderExt saOrderExt : orderList) {
if (saOrderExt.getDelFlag() == EYesNo.YES.getIntValue()) {
retailOrderList.add(saOrderExt);
}
}
// 查询新零售订单
// 更新当月会员， 将昨天业绩更到到今天，更新当月会员考核结果，有消费的考核通过
// 结算期间表
String rangeTableName = TableNameConstants.CU_MEMBER_RETAIL_RANGE + period;
// 结算期间前一天表
String yesterdayRangeTableName = TableNameConstants.CU_MEMBER_RETAIL_RANGE + yesterdayPeriod;
// 回退奖衔，将奖衔回退到结算前状态
iCuMemberAwardsService.calculateCuMemberRetailRangeAwardsInit(settleDate, period, rangeTableName);
// 更新网体
iCuMemberRetailRangeService.mergeMemberRetailRangeByYesterday(settleEndDate, rangeTableName, yesterdayRangeTableName, isSameMonth);
List<CuMemberLevel> memberLevelList = iCuMemberGradeService.calculateCuMemberRetailGradeInit(period, settleStartDate, settleEndDate, rangeTableName);
Map<Long, CuMemberLevel> memberLevelMap = new HashMap<>();
memberLevelList.forEach(cuMemberLevel -> memberLevelMap.put(cuMemberLevel.getPkOrder(), cuMemberLevel));
//////////////// TODO //////////////////////
// 回退历史注水
iCuMemberRetailRangeService.mergeCuMemberRetailBackBoxBySpecial(rangeTableName, yesterdayRangeTableName, period);
// 更新注水
iCuMemberRetailRangeService.mergeCuMemberRetailRangeBySpecial(rangeTableName, period);
if (retailOrderList.size() > 0) {
Map<Long, CuMemberLevel> memberLevelMap = new HashMap<>();
List<CuMemberLevel> memberLevelList = iCuMemberGradeService.calculateCuMemberRetailGradeInit(period, settleStartDate, settleEndDate, rangeTableName);
memberLevelList.forEach(cuMemberLevel -> memberLevelMap.put(cuMemberLevel.getPkOrder(), cuMemberLevel));
// 按照血缘，查询该会员所有伞上会员
List<CuMemberRetailRangeExt> memberRetailRangeExtList = iCuMemberRetailRangeService.queryCuMemberRetailRangeParent(rangeTableName, retailOrderList);
// 会员结算map（key：会员ID，value：结算扩展）
Map<Long, CuMemberRetailRangeExt> memberRangeExtMap = new HashMap<>();
// 购买升级等级map（key:等级值，value:等级对象）
Map<Integer, BdGrade> retaiBuyGradeMap = new TreeMap<>();
// 团队升级等级map（key:等级值，value:等级对象）
Map<Integer, BdGrade> retailTeamGradeMap = new TreeMap<>();
Map<Integer, BdGrade> gradeMap = new HashMap<>();
// 等级map（key:等级ID，value:等级对象）
Map<Integer, BdGrade> gradeIdMap = new HashMap<>();
// 等级列表
List<BdGrade> retaiGradeList = bonusConfigDTO.getRetaiGradeList();
// 等级
for (BdGrade bdGrade : retaiGradeList) {
if (bdGrade.getBoxNumber() > 0) {
retaiBuyGradeMap.put(bdGrade.getGradeValue(), bdGrade);
@ -426,81 +446,97 @@ public class BonusSettleRangeHandle extends BonusSettleHandle {
gradeMap.put(bdGrade.getGradeValue(), bdGrade);
gradeIdMap.put(bdGrade.getPkId(), bdGrade);
}
// 奖衔
Map<Integer, BdAwards> retailAwardsMap = new HashMap<>();
List<BdAwards> awardsList = bonusConfigDTO.getAwardsList();
awardsList.forEach(bdAwards -> retailAwardsMap.put(bdAwards.getAwardsValue(), bdAwards));
for (CuMemberRetailRangeExt cuMemberRetailRangeExt : memberRetailRangeExtList) {
if (!memberRangeExtMap.containsKey(cuMemberRetailRangeExt.getPkMember())) {// 转换等级购买数量
memberRangeExtMap.put(cuMemberRetailRangeExt.getPkMember(), cuMemberRetailRangeExt);
if (!memberRangeExtMap.containsKey(cuMemberRetailRangeExt.getPkMember())) {
cuMemberRetailRangeExt.setBuyNum(0);
if (cuMemberRetailRangeExt.getPayTime() != null && DateUtils.compareDateEqual(DateUtils.parseStringToDate(settleDate), cuMemberRetailRangeExt.getPayTime())) {
cuMemberRetailRangeExt.setSameDate(EYesNo.YES.getIntValue());
} else {
cuMemberRetailRangeExt.setSameDate(EYesNo.NO.getIntValue());
}
// TODO new 目前一次性补差升级，不需要校验是不是当天了
cuMemberRetailRangeExt.setSameDate(EYesNo.NO.getIntValue());
// if (cuMemberRetailRangeExt.getPayTime() != null && DateUtils.compareDateEqual(DateUtils.parseStringToDate(settleDate), cuMemberRetailRangeExt.getPayTime())) {
// cuMemberRetailRangeExt.setSameDate(EYesNo.YES.getIntValue());
// } else {
// cuMemberRetailRangeExt.setSameDate(EYesNo.NO.getIntValue());
// }
for (Integer gradeValue : retaiBuyGradeMap.keySet()) {
BdGrade bdGrade = retaiBuyGradeMap.get(gradeValue);
if (bdGrade.getBoxNumber() > 0 && cuMemberRetailRangeExt.getGradeValue().equals(gradeValue)) {
if (cuMemberRetailRangeExt.getSameDate().equals(EYesNo.YES.getIntValue())) {
cuMemberRetailRangeExt.setBuyNum(cuMemberRetailRangeExt.getNewBoxNum());
} else {
cuMemberRetailRangeExt.setBuyNum(bdGrade.getBoxNumber());
}
// TODO new 一次性补差，需要下个等级的盒数 - 当前等级盒数？？？
cuMemberRetailRangeExt.setBuyNum(bdGrade.getBoxNumber());
// if (cuMemberRetailRangeExt.getSameDate().equals(EYesNo.YES.getIntValue())) {
// cuMemberRetailRangeExt.setBuyNum(cuMemberRetailRangeExt.getNewBoxNum());
// } else {
// cuMemberRetailRangeExt.setBuyNum(bdGrade.getBoxNumber());
// }
break;
}
}
memberRangeExtMap.put(cuMemberRetailRangeExt.getPkMember(), cuMemberRetailRangeExt);
}
}
Map<String, CuMemberRetailRangeExt> countyRangeExtMap = new HashMap<>();
// 区域处理
List<CuMemberRetailRangeExt> countyRangeExtList = iCuMemberRetailRangeService.batchQueryMemberRetailRangeByCounty(rangeTableName);
// 区域会员map（key:系统+区ID ,value: 区域会员结算数据）
Map<String, CuMemberRetailRangeExt> countyRangeExtMap = new HashMap<>();
countyRangeExtList.forEach(cuMemberRetailRangeExt ->
countyRangeExtMap.put(cuMemberRetailRangeExt.getSystemType() + "_" + cuMemberRetailRangeExt.getRegionAddress(), cuMemberRetailRangeExt));
// 奖衔升级记录
List<CuMemberAwards> cuMemberAwardsList = new ArrayList<>();
// 会员等级升级记录
List<CuMemberGrade> cuMemberGradeList = new ArrayList<>();
// 会员奖衔升级记录
List<CuMemberAwards> cuMemberAwardsList = new ArrayList<>();
// 平级收益
List<CuMemberBonusRange> cuMemberBonusRangeList = new ArrayList<>();
// 会员奖金明细
List<CuMemberBonusDetail> cuMemberBonusDetailList = new ArrayList<>();
for (SaOrderExt saOrderExt : retailOrderList) {
CuMemberRetailRangeExt sourceMemberRangeExt = memberRangeExtMap.get(saOrderExt.getPkMember());
if (EOrderType.RETAIL_REGISTER.getValue() == saOrderExt.getOrderType() ||
EOrderType.RETAIL_UPGRADE.getValue() == saOrderExt.getOrderType() ||
EOrderType.RETAIL_REPURCHASE.getValue() == saOrderExt.getOrderType()) {
EOrderType.RETAIL_UPGRADE.getValue() == saOrderExt.getOrderType()) {
// 注册、升级才能算激活状态
sourceMemberRangeExt.setEnableStatus(EYesNo.YES.getIntValue());
}
}
for (SaOrderExt saOrderExt : retailOrderList) {
// 计算自消费奖衔
CuMemberRetailRangeExt sourceMemberRangeExt = memberRangeExtMap.get(saOrderExt.getPkMember());
// 先算等级 注册、升级计算等级
int boxNum = 0;
for (SaOrderWaresExt saOrderItems : saOrderExt.getOrderWaresExtList()) {
for (String waresCode : RetailProductConstants.ALL_BOX_WARES_LIST) {
if (saOrderItems.getWaresCode() != null && saOrderItems.getWaresCode().equals(waresCode)) {
boxNum += saOrderItems.getWaresQuantity();
break;
}
}
}
// 订单指定产品盒数（计算等级使用）
int boxNum = saOrderExt.getBoxNum();
// int boxNum = 0;
// for (SaOrderWaresExt saOrderItems : saOrderExt.getOrderWaresExtList()) {
// for (String waresCode : RetailProductConstants.ALL_BOX_WARES_LIST) {
// if (saOrderItems.getWaresCode() != null && saOrderItems.getWaresCode().equals(waresCode)) {
// boxNum += saOrderItems.getWaresQuantity();
// break;
// }
// }
// }
// 个人累计消费pv
BigDecimal orderAchieve = saOrderExt.getOrderAchieve();
// if (saOrderExt.getOrderType().equals(EOrderType.RETAIL_REGISTER.getValue()) ||
// saOrderExt.getOrderType().equals(EOrderType.RETAIL_UPGRADE.getValue())) {
// orderAchieve = BigDecimal.ZERO;
// }else{
// sourceMemberRangeExt.setConsumeBoxNum(sourceMemberRangeExt.getConsumeBoxNum() + boxNum);
// sourceMemberRangeExt.setNewBoxNum(sourceMemberRangeExt.getNewBoxNum() + boxNum);
// }
sourceMemberRangeExt.setConsumeBoxNum(sourceMemberRangeExt.getConsumeBoxNum() + boxNum);
sourceMemberRangeExt.setNewBoxNum(sourceMemberRangeExt.getNewBoxNum() + boxNum);
sourceMemberRangeExt.setConsumePv(ComputeUtil.computeAdd(sourceMemberRangeExt.getConsumePv(), orderAchieve));
sourceMemberRangeExt.setMonthConsumePv(ComputeUtil.computeAdd(sourceMemberRangeExt.getMonthConsumePv(), orderAchieve));
sourceMemberRangeExt.setNewConsumePv(ComputeUtil.computeAdd(sourceMemberRangeExt.getNewConsumePv(), orderAchieve));
// 团队业绩，计算奖衔
if (EOrderType.RETAIL_REPURCHASE.getValue() == saOrderExt.getOrderType()
|| EOrderType.RETAIL_CONSUME.getValue() == saOrderExt.getOrderType()
) {
// 复购、重消，盒数、业绩算个人累计数据（盒数、业绩）
sourceMemberRangeExt.setConsumeBoxNum(sourceMemberRangeExt.getConsumeBoxNum() + boxNum);
sourceMemberRangeExt.setNewBoxNum(sourceMemberRangeExt.getNewBoxNum() + boxNum);
sourceMemberRangeExt.setConsumePv(ComputeUtil.computeAdd(sourceMemberRangeExt.getConsumePv(), orderAchieve));
sourceMemberRangeExt.setMonthConsumePv(ComputeUtil.computeAdd(sourceMemberRangeExt.getMonthConsumePv(), orderAchieve));
sourceMemberRangeExt.setNewConsumePv(ComputeUtil.computeAdd(sourceMemberRangeExt.getNewConsumePv(), orderAchieve));
}
// 计算自己等级、奖衔等
calculateGradeAwards(period, memberRangeExtMap, rangeTableName, saOrderExt, retailTeamGradeMap, retailAwardsMap, null, cuMemberGradeList, cuMemberAwardsList, sourceMemberRangeExt);
// 计算团队业绩、盒数，计算等级、奖衔
cuMemberAwardsList.addAll(calculateRetailRangeGradeAwards(period, memberRangeExtMap, rangeTableName, saOrderExt, retailTeamGradeMap, retailAwardsMap, null, boxNum, cuMemberGradeList));
// TODO new 奖金处理
// 计算奖金 计算极差平级收益
for (SaOrderWaresExt saOrderItems : saOrderExt.getOrderWaresExtList()) {
for (String waresCode : RetailProductConstants.ALL_BOX_WARES_LIST) {
@ -858,14 +894,15 @@ public class BonusSettleRangeHandle extends BonusSettleHandle {
BigDecimal orderAchieve = saOrderExt.getOrderAchieve();
BigDecimal orderAmount = saOrderExt.getOrderAmount();
while (targetMemberRangeExt != null) {
// 累计业绩
targetMemberRangeExt.setTeamConsumeAmount(ComputeUtil.computeAdd(targetMemberRangeExt.getTeamConsumeAmount(), orderAmount));
targetMemberRangeExt.setTeamConsumePv(ComputeUtil.computeAdd(targetMemberRangeExt.getTeamConsumePv(), orderAchieve));
targetMemberRangeExt.setTeamMonthAmount(ComputeUtil.computeAdd(targetMemberRangeExt.getTeamMonthAmount(), orderAmount));
targetMemberRangeExt.setTeamMonthPv(ComputeUtil.computeAdd(targetMemberRangeExt.getTeamMonthPv(), orderAchieve));
targetMemberRangeExt.setTeamNewAmount(ComputeUtil.computeAdd(targetMemberRangeExt.getTeamNewAmount(), orderAmount));
targetMemberRangeExt.setTeamNewPv(ComputeUtil.computeAdd(targetMemberRangeExt.getTeamNewPv(), orderAchieve));
// 激活的账号才能累计业绩和盒数（有注册、升级订单）
if (targetMemberRangeExt.getEnableStatus() == EYesNo.YES.getIntValue()) {
// 累计业绩
targetMemberRangeExt.setTeamConsumeAmount(ComputeUtil.computeAdd(targetMemberRangeExt.getTeamConsumeAmount(), orderAmount));
targetMemberRangeExt.setTeamConsumePv(ComputeUtil.computeAdd(targetMemberRangeExt.getTeamConsumePv(), orderAchieve));
targetMemberRangeExt.setTeamMonthAmount(ComputeUtil.computeAdd(targetMemberRangeExt.getTeamMonthAmount(), orderAmount));
targetMemberRangeExt.setTeamMonthPv(ComputeUtil.computeAdd(targetMemberRangeExt.getTeamMonthPv(), orderAchieve));
targetMemberRangeExt.setTeamNewAmount(ComputeUtil.computeAdd(targetMemberRangeExt.getTeamNewAmount(), orderAmount));
targetMemberRangeExt.setTeamNewPv(ComputeUtil.computeAdd(targetMemberRangeExt.getTeamNewPv(), orderAchieve));
// 累计盒数
targetMemberRangeExt.setTeamBoxNum(targetMemberRangeExt.getTeamBoxNum() + boxNum);
targetMemberRangeExt.setMonthBoxNum(targetMemberRangeExt.getMonthBoxNum() + boxNum);
@ -900,7 +937,7 @@ public class BonusSettleRangeHandle extends BonusSettleHandle {
cuMemberRangeExtList = iCuMemberRetailRangeService.queryCuMemberRetailRangeExtByParent(rangeTableName, targetMemberRangeExt.getPkMember());
}
// TODO new 秒结处理这块应该有问题，自己消费的盒数直接当成大区，好像不对？？？
// TODO new 秒结处理这块应该有问题，自己消费的盒数直接当成大区，如果昨天直推会员有数据，查询秒结表可能没有这些会员，此处就可能出现问题
// 有注水的，大区无限大，新增全算小区
// 大区盒数
int bigBoxNum = targetMemberRangeExt.getConsumeBoxNum();
@ -943,7 +980,7 @@ public class BonusSettleRangeHandle extends BonusSettleHandle {
// 等级达到V5 并且 存在下个奖衔，判断是否能升奖衔
BdAwards bdAwards = retailAwardsMap.get(awardsValue);
// 先验证累计业绩
// TODO new 升级奖衔判断为当月累计业绩，只判断团队还是团队+自己？
// new 升级奖衔判断为当月累计业绩，累计业绩为团队业绩 + 个人消费业绩
if (ComputeUtil.compareValue(ComputeUtil.computeAdd(targetMemberRangeExt.getTeamMonthPv(), targetMemberRangeExt.getMonthConsumePv()), bdAwards.getTotalCheck())) {
// 累计业绩足够
// BigDecimal consumeBigPv = BigDecimal.ZERO;
@ -965,7 +1002,7 @@ public class BonusSettleRangeHandle extends BonusSettleHandle {
// }
// }
// }
// // TODO new 新制度奖衔不校验小区
// // new 新制度奖衔不校验小区
// BigDecimal smallAreaPv = ComputeUtil.computeSubtract(ComputeUtil.computeAdd(targetMemberRangeExt.getTeamMonthPv(), targetMemberRangeExt.getMonthConsumePv()), consumeBigPv);
// if (ComputeUtil.compareValue(smallAreaPv, bdAwards.getCommunityCheck())) {
cuMemberAwardsList.add(getCuMemberRetailAwards(targetMemberRangeExt, period, saOrderExt, bdAwards, EAwardsType.RANGE_TYPE.getValue()));
@ -1538,7 +1575,6 @@ public class BonusSettleRangeHandle extends BonusSettleHandle {
String beforeMonthLastDate = DateUtils.beforeMonthLastDateStr(settleDate);
// 查询上月最后一天
Integer beforeMonthLastPeriod = getCuMemberSettlePeriodService().getCuMemberSettlePeriodByDate(beforeMonthLastDate).getPkId();
// Integer beforeMonthLastPeriod = getCuMemberSettlePeriodService().getCuMemberSettlePeriodByDate(settleDateStr).getPkId();
String rangeTableName = TableNameConstants.CU_MEMBER_RETAIL_RANGE + beforeMonthLastPeriod;
// 查询上月订单
// 结算月第一天
@ -1727,18 +1763,6 @@ public class BonusSettleRangeHandle extends BonusSettleHandle {
}
}
}
// for (SaOrder saOrder : totalMonthOrderList) {
// Map<Integer, CuMemberRetailRangeExt> countyRangeExtMap = new HashMap<>();
// List<CuMemberRetailRangeExt> countyRangeExtList = iCuMemberRetailRangeService.batchQueryMemberRetailRangeByCounty(rangeTableName);
// countyRangeExtList.forEach(cuMemberRetailRangeExt ->
// countyRangeExtMap.put(cuMemberRetailRangeExt.getRegionAddress(), cuMemberRetailRangeExt));
// // 计算区域，获取所有有区域的会员
// CuMemberBonusDetail cuMemberBonusDetail = calculateRetailAreaBonus(countyRangeExtMap, saOrder, bonusConfigDTO, period, memberRangeExtMap, cuMemberBonusMap);
// if (cuMemberBonusDetail != null) {
// memberBonusDetailList.add(cuMemberBonusDetail);
// }
// }
}
if (memberBonusDetailList.size() > 0) {
if (bonusRecordDetailVO.getCuMemberBonusDetailList() == null) {

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

@ -2,7 +2,6 @@ package com.hzs.bonus.bonus.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.json.JSONUtil;
import com.hzs.bonus.achieve.service.ICuMemberSettlePeriodService;
import com.hzs.bonus.achieve.service.ICuMemberTreeService;
import com.hzs.bonus.base.service.ICuAwardsControlService;
@ -25,9 +24,7 @@ import com.hzs.common.core.utils.reflect.ReflectUtils;
import com.hzs.common.domain.bonus.risk.CuMemberRiskControl;
import com.hzs.common.domain.member.achieve.CuMemberSettlePeriod;
import com.hzs.common.domain.member.base.CuAwardsControl;
import com.hzs.common.domain.member.base.CuMember;
import com.hzs.common.domain.member.bonus.*;
import com.hzs.common.domain.member.detail.CuMemberAssess;
import com.hzs.common.domain.member.ext.CuBonusExpandExt;
import com.hzs.common.domain.member.ext.CuMemberSettleExt;
import com.hzs.common.domain.sale.ext.SaOrderExt;
@ -35,10 +32,7 @@ import com.hzs.common.domain.system.config.BdAwards;
import com.hzs.system.base.ISystemConfigServiceApi;
import com.hzs.system.config.IAwardsServiceApi;
import com.hzs.system.config.IBonusItemsServiceApi;
import com.hzs.system.config.IGradeServiceApi;
import com.hzs.system.config.IRangeServiceApi;
import com.hzs.system.config.dto.BonusConfigDTO;
import com.hzs.system.config.dto.GradeDTO;
import com.hzs.system.config.dto.RangeDTO;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.DubboReference;
@ -60,12 +54,8 @@ public class BonusSettleServiceImpl implements IBonusSettleService {
@DubboReference
ISystemConfigServiceApi iSystemConfigServiceApi;
@DubboReference
IGradeServiceApi iGradeServiceApi;
@DubboReference
IAwardsServiceApi iAwardsServiceApi;
@DubboReference
IRangeServiceApi iRangeServiceApi;
@DubboReference
IBonusItemsServiceApi iBonusItemsServiceApi;
@Autowired
@ -91,8 +81,6 @@ public class BonusSettleServiceImpl implements IBonusSettleService {
@Autowired
private BonusSettlePurchaseHandle bonusSettlePurchaseHandle;
@Autowired
private BonusSettleRepCouponsHandle bonusSettleRepCouponsHandle;
@Autowired
private ICuMemberRiskControlService cuMemberRiskControlService;
private ICuMemberBonusService cuMemberBonusService;
@ -137,178 +125,6 @@ public class BonusSettleServiceImpl implements IBonusSettleService {
this.cuMemberBonusService = cuMemberBonusService;
}
@Override
@Transactional(rollbackFor = Exception.class)
public void calculateCumberBonusBySecond(String orderCode) {
log.info("开始执行秒接，订单编号：{}", orderCode);
Date startDate = DateUtils.currentDate();
SaOrderExt saOrderExt = iBonusOrderService.querySaOrderByDay(startDate,
DateUtils.afterDate(1, ChronoUnit.DAYS, startDate), orderCode);
Map<String, String> systemConfigMap = iSystemConfigServiceApi.getBonusSystemConfig().getData();
Map<String, RangeDTO> rangeDtoMap = iRangeServiceApi.queryRangeDto().getData();
// 处理奖金结算秒结表，判断是否存在当天结算的秒接表，从cu_member中获取网体，从昨日结算表中获取累计、结余数据
String settleDate = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, saOrderExt.getPayTime());
String beforeDay = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, DateUtils.beforeDate(1, ChronoUnit.DAYS, saOrderExt.getPayTime()));
String beforeYesDay = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, DateUtils.beforeDate(2, ChronoUnit.DAYS, saOrderExt.getPayTime()));
int period = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(settleDate).getPkId();
int beforePeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(beforeDay).getPkId();
int beforeYesPeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(beforeYesDay).getPkId();
log.info("查询订单，订单参数：{}", JSONUtil.toJsonStr(saOrderExt));
String secondTableName = TableNameConstants.CU_MEMBER_SECOND + period;
String settleTableName = TableNameConstants.CU_MEMBER_SETTLE + beforePeriod;
// 前天
String yesSettleTableName = TableNameConstants.CU_MEMBER_SETTLE + beforeYesPeriod;
Map<Long, CuMemberBonus> cuMemberBonusMap = new HashMap<>(MagicNumberConstants.DELETE_DATA_BATCH_UPDATE_NUM);
BonusConfigDTO bonusConfigDTO = iBonusItemsServiceApi.queryBonusConfigDTO().getData();
Map<Long, CuMemberSettleExt> cuMemberSettleExtMap = new HashMap<>();
Map<Long, CuAwardsControl> cuAwardsControlMap = getCuAwardsControlMap();
// 计算奖金
if (EOrderType.REGISTER_ORDER.getValue() == saOrderExt.getOrderType() ||
EOrderType.UPGRADE_ORDER.getValue() == saOrderExt.getOrderType()) {
log.info("奖金秒接，首购订单，订单编号：{}", orderCode);
// 1注册订单 直推、拓展、领导
// 从会员表中拉数据到 cu_member_second中
// cu_member_second没有 cu_member 网体 cu_member_settle上一期业绩
// 直推奖 - 加首购 加首购新增，只加推荐人
// 拓展奖 - 安置以上，进行量碰 加首购业绩，加一条线
// 领导奖- 安置血缘以上，判断奖衔
// 报单服务费 - 报单人
List<Long> memberList = new ArrayList<>();
CuMember cuMember = cuMemberService.getMember(saOrderExt.getPkMember());
if (cuMember.getPkCenterCode() != null && !saOrderExt.getPkReference().equals(cuMember.getPkCenterCode())) {
memberList.add(cuMember.getPkCenterCode());
}
getSettleMember(saOrderExt, secondTableName, settleTableName, yesSettleTableName, memberList);
// 查询出上面的网体数据
List<CuMemberSettleExt> cuMemberSettleExtList = cuMemberTreeService.queryCuMemberSecondParent(secondTableName, memberList);
bonusSettleFirstPurchaseHandle.getSecondMemberSettle(cuMemberSettleExtMap, cuMemberSettleExtList);
// 计算奖金
// 计算直推奖
List<GradeDTO> gradeDtoList = iGradeServiceApi.queryGradeConfigByCondition(saOrderExt.getPkCountry()).getData();
CuMemberBonusPush cuMemberBonusPush = bonusSettleFirstPurchaseHandle.calculatePushBonusOne(cuMemberSettleExtMap, bonusConfigDTO, systemConfigMap, period, cuMemberBonusMap, saOrderExt, iAwardsServiceApi.getAwards().getData(), gradeDtoList);
log.info("获得直推奖，奖金为：{}", JSONUtil.toJsonStr(cuMemberBonusPush));
// 计算量奖
// 所有需要计算的父节点，只计算新增
List<CuMemberSettleExt> expandMemberSettleExtList = cuMemberTreeService.queryCuMemberSecondPlaceParent(secondTableName, saOrderExt.getPkMember());
bonusSettleFirstPurchaseHandle.getSecondMemberSettle(cuMemberSettleExtMap, expandMemberSettleExtList);
Map<Long, CuMemberBonus> weekMemberBonusMap = getWeekMemberBonusMap(settleDate, period);
Map<Long, CuMemberAssess> cuMemberAssessMap = bonusSettleFirstPurchaseHandle.getLongCuMemberAssessMap(settleDate, expandMemberSettleExtList);
// 查询K值控制
List<CuMemberRiskControl> cuMemberRiskControlList = cuMemberRiskControlService.queryCuMemberRiskControl(DateUtils.parseStringToDate(settleDate));
Map<Long, CuMemberRiskControl> riskControlMap = new HashMap<>();
if (CollectionUtil.isNotEmpty(cuMemberRiskControlList)) {
cuMemberRiskControlList.forEach(cuMemberRiskControl -> riskControlMap.put(cuMemberRiskControl.getPkMember(), cuMemberRiskControl));
}
Map<Long, CuBonusExpandExt> cuBonusExpandExtMap = new HashMap<>();
BonusExpandParam bonusExpandParam = BonusExpandParam.builder().settleDate(DateUtils.parseStringToDate(settleDate)).build();
List<CuBonusExpandExt> cuBonusExpandExtList = bonusExpandService.queryBonusExpand(bonusExpandParam);
cuBonusExpandExtList.forEach(cuBonusExpandExt -> cuBonusExpandExtMap.put(cuBonusExpandExt.getPkMember(), cuBonusExpandExt));
BigDecimal addTouch = BigDecimal.ZERO;
for (int i = expandMemberSettleExtList.size() - 1; i >= 0; i--) {
CuMemberSettleExt cuMemberSettleExt = cuMemberSettleExtList.get(i);
if (cuBonusExpandExtMap.containsKey(cuMemberSettleExt.getPkMember())) {
addTouch = cuBonusExpandExtMap.get(cuMemberSettleExt.getPkMember()).getAddTouch();
break;
}
}
List<CuMemberBonusExpand> cuMemberBonusExpandList = bonusSettleFirstPurchaseHandle.calculateExpandBonusOne(riskControlMap, cuMemberAssessMap, settleTableName, cuMemberSettleExtMap, bonusConfigDTO, systemConfigMap, period, weekMemberBonusMap, cuMemberBonusMap, expandMemberSettleExtList, saOrderExt, false, addTouch, BigDecimal.ZERO, 0);
// 计算领导奖
Map<Long, SaOrderExt> saOrderExtMap = new HashMap<>(1);
saOrderExtMap.put(saOrderExt.getPkId(), saOrderExt);
List<CuMemberBonusCoach> cuMemberBonusCoachList = bonusSettleFirstPurchaseHandle.calculateCoachBonusOne(cuMemberSettleExtMap, settleTableName, settleDate, bonusConfigDTO, cuMemberBonusExpandList, period, cuMemberBonusMap, saOrderExtMap, cuAwardsControlMap, riskControlMap);
// 计算报单服务费
CuMemberBonusDetail cuMemberBonusDetail = bonusSettleFirstPurchaseHandle.calculateServiceBonusOne(settleDate, cuMemberAssessMap, cuMemberSettleExtMap, bonusConfigDTO, period, cuMemberBonusMap, saOrderExt);
// 复购券
List<CuMemberBonusDetail> couponsBonusDetailList = bonusSettleRepCouponsHandle.calculateRepurchaseCoupons(startDate, Collections.singletonList(saOrderExt), period, bonusConfigDTO, cuMemberBonusMap, cuMemberSettleExtMap);
saveCuMemberBonus(period, settleDate, cuMemberBonusMap);
cuMemberBonusPush.setPkBonus(cuMemberBonusMap.get(cuMemberBonusPush.getPkBonus()).getPkId());
Set<Long> memberIdSet = cuMemberBonusService.queryMemberBonusByPeriod(period);
cuMemberBonusPushService.insertCuMemberBonusPush(cuMemberBonusPush);
cuMemberBonusExpandList.forEach(cuMemberBonusExpand ->
cuMemberBonusExpand.setPkBonus(cuMemberBonusMap.get(cuMemberBonusExpand.getPkBonus()).getPkId()));
cuMemberBonusExpandService.batchInsertCuMemberBonusExpand(cuMemberBonusExpandList, memberIdSet);
cuMemberBonusCoachList.forEach(cuMemberBonusCoach ->
cuMemberBonusCoach.setPkBonus(cuMemberBonusMap.get(cuMemberBonusCoach.getPkBonus()).getPkId()));
cuMemberBonusCoachService.batchInsertCuMemberBonusCoach(cuMemberBonusCoachList, memberIdSet);
List<CuMemberBonusDetail> cuMemberBonusDetailList = new ArrayList<>();
if (cuMemberBonusDetail != null) {
cuMemberBonusDetailList.add(cuMemberBonusDetail);
}
if (CollectionUtil.isNotEmpty(couponsBonusDetailList)) {
cuMemberBonusDetailList.addAll(couponsBonusDetailList);
}
if (cuMemberBonusDetailList.size() > 0) {
cuMemberBonusDetailList.forEach(bonusDetail ->
bonusDetail.setPkBonus(cuMemberBonusMap.get(bonusDetail.getPkBonus()).getPkId()));
cuMemberBonusDetailService.batchInsertCuMemberBonusDetail(cuMemberBonusDetailList, memberIdSet);
}
log.info("首购奖金计算完毕");
} else {
// 先处理关系
List<Long> memberList = new ArrayList<>();
getSettleMember(saOrderExt, secondTableName, yesSettleTableName, settleTableName, memberList);
// 初始化需要秒接结算的数据
List<CuMemberSettleExt> pushMemberSettleExtList = cuMemberTreeService.queryCuMemberSecondParent(secondTableName, memberList);
bonusSettleFirstPurchaseHandle.getSecondMemberSettle(cuMemberSettleExtMap, pushMemberSettleExtList);
List<CuMemberBonusPush> cuMemberBonusPushList = bonusSettlePurchaseHandle.calculateRepurchasePushSecondBonus(settleTableName, cuMemberSettleExtMap, bonusConfigDTO, period, cuMemberBonusMap, saOrderExt, pushMemberSettleExtList, settleDate);
// 查询出上面的网体数据
List<CuMemberSettleExt> cuMemberSettleExtList = cuMemberTreeService.queryCuMemberSecondPlaceParent(secondTableName, saOrderExt.getPkMember());
bonusSettleFirstPurchaseHandle.getSecondMemberSettle(cuMemberSettleExtMap, cuMemberSettleExtList);
Map<Long, CuMemberBonus> weekMemberBonusMap = getWeekMemberBonusMap(settleDate, period);
// 复购订单，计算复购推荐 复购极差，复购拓展
// 查询K值控制
List<CuMemberRiskControl> cuMemberRiskControlList = cuMemberRiskControlService.queryCuMemberRiskControl(DateUtils.parseStringToDate(settleDate));
Map<Long, CuMemberRiskControl> riskControlMap = new HashMap<>();
if (CollectionUtil.isNotEmpty(cuMemberRiskControlList)) {
cuMemberRiskControlList.forEach(cuMemberRiskControl -> riskControlMap.put(cuMemberRiskControl.getPkMember(), cuMemberRiskControl));
}
List<CuMemberBonusExpand> cuMemberBonusExpandList = bonusSettlePurchaseHandle.calculateRepurchaseExpandSecondBonus(riskControlMap, settleTableName,
cuMemberSettleExtMap, bonusConfigDTO, systemConfigMap, period, weekMemberBonusMap, cuMemberBonusMap, saOrderExt, cuMemberSettleExtList, settleDate, BigDecimal.ZERO, BigDecimal.ZERO, 0);
// c)增加奖衔记录表
Map<String, BdAwards> awardsMap = iAwardsServiceApi.getAwards().getData();
List<CuMemberBonusRange> cuMemberBonusRangeList = bonusSettlePurchaseHandle.calculateRepurchaseRangeBonus(cuMemberSettleExtMap, settleTableName, settleDate, rangeDtoMap, awardsMap,
bonusConfigDTO, Collections.singletonList(saOrderExt), period, cuMemberBonusMap, cuAwardsControlMap, new LeXueRangeParam());
if (cuMemberBonusMap.size() > 0) {
saveCuMemberBonus(period, settleDate, cuMemberBonusMap);
Set<Long> memberIdSet = cuMemberBonusService.queryMemberBonusByPeriod(period);
cuMemberBonusPushList.forEach(cuMemberBonusPush ->
cuMemberBonusPush.setPkBonus(cuMemberBonusMap.get(cuMemberBonusPush.getPkBonus()).getPkId()));
cuMemberBonusPushService.batchInsertCuMemberBonusPush(cuMemberBonusPushList, memberIdSet);
cuMemberBonusExpandList.forEach(cuMemberBonusExpand ->
cuMemberBonusExpand.setPkBonus(cuMemberBonusMap.get(cuMemberBonusExpand.getPkBonus()).getPkId()));
cuMemberBonusExpandService.batchInsertCuMemberBonusExpand(cuMemberBonusExpandList, memberIdSet);
cuMemberBonusRangeList.forEach(cuMemberBonusRange ->
cuMemberBonusRange.setPkBonus(cuMemberBonusMap.get(cuMemberBonusRange.getPkBonus()).getPkId()));
cuMemberBonusRangeService.batchInsertCuMemberBonusRange(cuMemberBonusRangeList, memberIdSet);
}
log.info("复购奖金计算完毕");
}
// 更新网体结构
if (cuMemberSettleExtMap.size() > 0) {
// 处理网体，更新网体新增 轮次最小值 cuMemberSettleExtMap
cuMemberTreeService.updateCuMemberSecond(secondTableName, cuMemberSettleExtMap);
}
// 1获取业绩，做一张新表，计算过奖金的放进去 2当天没有计算过奖金的，直接根据昨天日表获取业绩放进去进行计算
// 根据网体数据计算奖金
}
private void getSettleMember(SaOrderExt saOrderExt, String secondTableName, String settleTableName, String yesSettleTableName, List<Long> memberList) {
// 先处理关系
memberList.add(saOrderExt.getPkMember());
long pkParent = saOrderExt.getPkReference();
while (true) {
CuMember cuMember = cuMemberService.getMember(pkParent);
if (cuMember == null) {
break;
}
memberList.add(cuMember.getPkId());
pkParent = cuMember.getPkParent();
}
// 初始化需要秒接结算的数据
cuMemberTreeService.updateCuMemberSecondPlaceParent(secondTableName, settleTableName, yesSettleTableName, saOrderExt.getPkMember(), memberList, EYesNo.YES.getIntValue());
}
/**
* 保存会员奖金
*
@ -329,27 +145,37 @@ public class BonusSettleServiceImpl implements IBonusSettleService {
@Transactional(rollbackFor = Exception.class)
public void calculateCuMemberBonus(String settleDate, List<SaOrderExt> saOrderExtList) {
try {
// 结算期间
Integer period = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(settleDate).getPkId();
String yesterday = DateUtils.beforeDateStr(1, ChronoUnit.DAYS, DateUtils.YYYY_MM_DD, settleDate);
// 结算期间前一天期间
Integer yesterdayPeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(yesterday).getPkId();
// 将删除的订单的点位变为死点
//********************************* 更新当天最新的业绩*************************/
// 获取所有国家的奖金项 key = 国家 + 奖金项的值
BonusConfigDTO bonusConfigDTO = iBonusItemsServiceApi.queryBonusConfigDTO().getData();
// 会员奖金map（key:会员ID，
Map<Long, CuMemberBonus> cuMemberBonusMap = new HashMap<>();
// 奖金明细（入库使用）
BonusRecordDetailVO recordDetailVO = new BonusRecordDetailVO();
// 今天和昨天是否同月
Boolean isSameMonth = DateUtils.getMonth(settleDate).equals(DateUtils.getMonth(yesterday));
// 计算新零售团队奖金
bonusSettleRangeHandle.calculateRetailBonusByDay(settleDate, cuMemberBonusMap, bonusConfigDTO, recordDetailVO,
period, yesterdayPeriod, isSameMonth);
if (settleDate.endsWith("01")) {
// TODO new 每月1号，需要计算4个月奖
// 计算新零售团队区域、福利、福利分红奖金
bonusSettleRangeHandle.calculateRetailShareBonus(settleDate, bonusConfigDTO, period, recordDetailVO, cuMemberBonusMap);
}
Date currentDate = DateUtils.afterDate(1, ChronoUnit.DAYS, DateUtils.parseStringToDate(settleDate));
String afterDate = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, currentDate);
if (afterDate.endsWith("01")) {
// 计算完月奖，计算考核
// 计算完月奖，计算考核（区域6个月要达到蓝宝以上）
String rangeTableName = TableNameConstants.CU_MEMBER_RETAIL_RANGE + period;
cuRegionAssessService.assessRegionByEveryMonth(settleDate, rangeTableName);
}
@ -386,6 +212,7 @@ public class BonusSettleServiceImpl implements IBonusSettleService {
if (saOrderExt.getDelFlag() == EYesNo.YES.getIntValue()) {
// 订单下单处理（正向）
// 会员奖金明细
List<CuMemberBonusDetail> cuMemberBonusDetailList = new ArrayList<>();
// 实时计算当月奖衔
List<CuMemberBonusRange> cuMemberBonusRangeList = bonusSettleRangeHandle.calculateCuMemberRetailRangeBonusBySecond(settleDate, saOrderExt, bonusConfigDTO,

29
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/service/impl/CuBonusExpandServiceImpl.java
View File

@ -31,18 +31,13 @@ import java.util.*;
import java.util.stream.Collectors;
/**
* <p>
* 服务实现类
* </p>
*
* @author hzs
* @since 2024-07-19
* 服务实现类
*/
@Service
public class CuBonusExpandServiceImpl extends ServiceImpl<CuBonusExpandMapper, CuBonusExpand> implements ICuBonusExpandService {
@DubboReference
private ISaOrderServiceApi saOrderServiceApi;
ISaOrderServiceApi saOrderServiceApi;
@Autowired
private ICuMemberSettlePeriodService memberSettlePeriodService;
@ -64,7 +59,7 @@ public class CuBonusExpandServiceImpl extends ServiceImpl<CuBonusExpandMapper, C
@Transactional(rollbackFor = Exception.class)
public void firstSaveCuBonusExpand(BonusExpandParam bonusExpandParam) {
List<CuBonusExpand> bonusExpandList = queryCuBonusExpand(bonusExpandParam.getSettleDate(), bonusExpandParam.getPkCountry());
if(bonusExpandList == null || bonusExpandList.size() == 0) {
if (bonusExpandList == null || bonusExpandList.size() == 0) {
// 查询
List<CuBonusExpand> cuBonusExpandList = queryCuBonusExpand(DateUtils.beforeDate(1, ChronoUnit.DAYS, bonusExpandParam.getSettleDate()), bonusExpandParam.getPkCountry());
Map<Long, CuBonusExpand> cuBonusExpandMap = new HashMap<>();
@ -95,7 +90,7 @@ public class CuBonusExpandServiceImpl extends ServiceImpl<CuBonusExpandMapper, C
public void updateCuBonusExpandRatio(BonusExpandParam bonusExpandParam, String tableName) {
// 查询结算的4-n碰次设置
List<CuBonusExpand> cuBonusExpandList = queryCuBonusExpand(bonusExpandParam.getSettleDate(), bonusExpandParam.getPkCountry());
if(CollectionUtil.isNotEmpty(cuBonusExpandList)){
if (CollectionUtil.isNotEmpty(cuBonusExpandList)) {
Date settleDate = bonusExpandParam.getSettleDate();
Map<Long, CuBonusExpand> bonusExpandMap = new HashMap<>();
List<Long> memberIdList = new ArrayList<>();
@ -107,13 +102,13 @@ public class CuBonusExpandServiceImpl extends ServiceImpl<CuBonusExpandMapper, C
// 计算所有体系日波比
packageBonusExpandParam(bonusExpandParam, settleDate, settleDate);
List<CuBonusExpand> dayBonusExpandList = baseMapper.calculateDayRatioByBonusExpandParam(bonusExpandParam, tableName);
if(CollectionUtil.isNotEmpty(dayBonusExpandList)) {
if (CollectionUtil.isNotEmpty(dayBonusExpandList)) {
for (CuBonusExpand cuBonusExpand : dayBonusExpandList) {
if (bonusExpandMap.containsKey(cuBonusExpand.getPkMember())) {
CuBonusExpand bonusExpand = bonusExpandMap.get(cuBonusExpand.getPkMember());
bonusExpand.setDayAchieve(cuBonusExpand.getDayAchieve());
bonusExpand.setDayBonus(cuBonusExpand.getDayBonus());
if("cu_member_bonus".equals(tableName) || !ComputeUtil.compareValue(bonusExpand.getYesDayRatio())) {
if ("cu_member_bonus".equals(tableName) || !ComputeUtil.compareValue(bonusExpand.getYesDayRatio())) {
bonusExpand.setYesDayRatio(cuBonusExpand.getYesDayRatio());
}
bonusExpand.setCurDayRatio(cuBonusExpand.getYesDayRatio());
@ -121,7 +116,7 @@ public class CuBonusExpandServiceImpl extends ServiceImpl<CuBonusExpandMapper, C
}
}
List<CuBonusExpand> dayRepBonusExpandList = baseMapper.calculateDayRepRatioByBonusExpandParam(bonusExpandParam, tableName);
if(CollectionUtil.isNotEmpty(dayRepBonusExpandList)) {
if (CollectionUtil.isNotEmpty(dayRepBonusExpandList)) {
for (CuBonusExpand cuBonusExpand : dayRepBonusExpandList) {
if (bonusExpandMap.containsKey(cuBonusExpand.getPkMember())) {
CuBonusExpand bonusExpand = bonusExpandMap.get(cuBonusExpand.getPkMember());
@ -135,7 +130,7 @@ public class CuBonusExpandServiceImpl extends ServiceImpl<CuBonusExpandMapper, C
// 获得当前月第一天，获得当前月最后一天
packageBonusExpandParam(bonusExpandParam, DateUtils.currentMonthFirstDate(settleDate), settleDate);
List<CuBonusExpand> monthBonusExpandList = baseMapper.calculateDayRatioByBonusExpandParam(bonusExpandParam, tableName);
if(CollectionUtil.isNotEmpty(monthBonusExpandList)) {
if (CollectionUtil.isNotEmpty(monthBonusExpandList)) {
for (CuBonusExpand cuBonusExpand : monthBonusExpandList) {
if (bonusExpandMap.containsKey(cuBonusExpand.getPkMember())) {
CuBonusExpand bonusExpand = bonusExpandMap.get(cuBonusExpand.getPkMember());
@ -162,9 +157,9 @@ public class CuBonusExpandServiceImpl extends ServiceImpl<CuBonusExpandMapper, C
@Override
@Transactional(rollbackFor = Exception.class)
public void saveCuBonusExpand(BonusExpandParam bonusExpandParam) {
if(bonusExpandParam.getPkId() == null){
if (bonusExpandParam.getPkId() == null) {
firstSaveCuBonusExpand(bonusExpandParam);
}else {
} else {
// 查询原数据 增加明细表
CuBonusExpand cuBonusExpand = baseMapper.selectById(bonusExpandParam.getPkId());
CuBonusExpand saveBonusExpand = BeanUtil.copyProperties(cuBonusExpand, CuBonusExpand.class);
@ -197,10 +192,10 @@ public class CuBonusExpandServiceImpl extends ServiceImpl<CuBonusExpandMapper, C
updateCuBonusExpandRatio(bonusExpandParam, "cu_member_repeat_bonus");
}
private List<CuBonusExpand> queryCuBonusExpand(Date settleDate, Integer pkCountry){
private List<CuBonusExpand> queryCuBonusExpand(Date settleDate, Integer pkCountry) {
QueryWrapper<CuBonusExpand> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("SETTLE_DATE", settleDate);
if(pkCountry != null) {
if (pkCountry != null) {
queryWrapper.eq(SystemFieldConstants.PK_COUNTRY, pkCountry);
}
queryWrapper.isNull("PK_PARENT");

50
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/service/impl/CuMemberBonusServiceImpl.java
View File

@ -20,17 +20,14 @@ import com.hzs.common.core.constant.MemberFieldConstants;
import com.hzs.common.core.constant.SystemFieldConstants;
import com.hzs.common.core.domain.R;
import com.hzs.common.core.enums.*;
import com.hzs.common.core.utils.CommonUtil;
import com.hzs.common.core.utils.ComputeUtil;
import com.hzs.common.core.utils.DateUtils;
import com.hzs.common.core.utils.StringUtils;
import com.hzs.common.core.web.page.TableDataInfo;
import com.hzs.common.domain.member.bonus.CuMemberBonus;
import com.hzs.common.domain.member.ext.*;
import com.hzs.common.domain.sale.ext.SaOrderExt;
import com.hzs.common.domain.system.config.BdBonusItems;
import com.hzs.common.domain.system.config.ext.BdBonusItemsExt;
import com.hzs.sale.order.ISaOrderServiceApi;
import com.hzs.system.base.ICurrencyServiceApi;
import com.hzs.system.base.ISystemConfigServiceApi;
import com.hzs.system.base.dto.CurrencyDTO;
@ -46,28 +43,18 @@ import java.util.*;
import java.util.stream.Collectors;
/**
* <p>
* 会员奖金-会员奖金汇总表 服务实现类
* </p>
*
* @author hzs
* @since 2022-11-11
*/
@Service
@Slf4j
public class CuMemberBonusServiceImpl extends ServiceImpl<CuMemberBonusMapper, CuMemberBonus> implements ICuMemberBonusService {
@DubboReference
private ISystemConfigServiceApi systemConfigServiceApi;
ISystemConfigServiceApi iSystemConfigServiceApi;
@DubboReference
private ISaOrderServiceApi saOrderServiceApi;
ICurrencyServiceApi iCurrencyServiceApi;
@DubboReference
private ICurrencyServiceApi currencyServiceApi;
@DubboReference
private IBonusItemsServiceApi bonusItemsServiceApi;
IBonusItemsServiceApi iBonusItemsServiceApi;
private CuMemberBonusDetailMapper cuMemberBonusDetailMapper;
@ -95,7 +82,6 @@ public class CuMemberBonusServiceImpl extends ServiceImpl<CuMemberBonusMapper, C
this.cuMemberTreeService = cuMemberTreeService;
}
@Autowired
public void setCuMemberBonusSettle(CuMemberBonusSettle cuMemberBonusSettle) {
this.cuMemberBonusSettle = cuMemberBonusSettle;
@ -145,7 +131,7 @@ public class CuMemberBonusServiceImpl extends ServiceImpl<CuMemberBonusMapper, C
@Override
public List<CuMemberBonusExt> queryMemberBonusVoByCondition(BonusParam bonusParam) {
String value = systemConfigServiceApi.getBonusSystemConfig(bonusParam.getPkCountry(), ESystemConfig.EXPAND_CAP_METHOD.getKey()).getData();
String value = iSystemConfigServiceApi.getBonusSystemConfig(bonusParam.getPkCountry(), ESystemConfig.EXPAND_CAP_METHOD.getKey()).getData();
if (StringUtils.isNotEmpty(value) && Objects.equals(Integer.toString(EExpandCapMethod.WEEK_SETTLE.getValue()), value)) {
// 周结的话不能查询当前周的数据，只能查询上周的数据
bonusParam.setEndDate(DateUtils.parseStringToDate(DateUtils.getRecentlyTuesday(bonusParam.getEndDate())));
@ -221,7 +207,7 @@ public class CuMemberBonusServiceImpl extends ServiceImpl<CuMemberBonusMapper, C
@Override
public List<CuMemberBonusExt> queryMemberSecondBonusVoByCondition(BonusParam bonusParam) {
String value = systemConfigServiceApi.getBonusSystemConfig(bonusParam.getPkCountry(), ESystemConfig.EXPAND_CAP_METHOD.getKey()).getData();
String value = iSystemConfigServiceApi.getBonusSystemConfig(bonusParam.getPkCountry(), ESystemConfig.EXPAND_CAP_METHOD.getKey()).getData();
// if (StringUtils.isNotEmpty(value) && Objects.equals(Integer.toString(EExpandCapMethod.WEEK_SETTLE.getValue()), value)) {
// // 周结的话不能查询当前周的数据，只能查询上周的数据
// bonusParam.setStartDate(DateUtils.parseStringToDate(DateUtils.getRecentlyTuesday(bonusParam.getStartDate())));
@ -235,7 +221,7 @@ public class CuMemberBonusServiceImpl extends ServiceImpl<CuMemberBonusMapper, C
bonusParam.setGrantStatus(EGrantStatus.PUBLISHED.getValue());
}
List<CuMemberBonusExt> cuMemberBonusExtList = baseMapper.queryMemberBonusByCondition(bonusParam);
R<CurrencyDTO> currency = currencyServiceApi.getCurrency(bonusParam.getPkCountry());
R<CurrencyDTO> currency = iCurrencyServiceApi.getCurrency(bonusParam.getPkCountry());
// 汇率比例
BigDecimal inExchangeRate = currency.getData().getInExchangeRate();
for (CuMemberBonusExt cuMemberBonusExt : cuMemberBonusExtList) {
@ -337,7 +323,7 @@ public class CuMemberBonusServiceImpl extends ServiceImpl<CuMemberBonusMapper, C
@Override
public List<CuMemberBonusExt> queryMemberBonusTotalByCondition(BonusParam bonusParam) {
String value = systemConfigServiceApi.getBonusSystemConfig(bonusParam.getPkCountry(), ESystemConfig.EXPAND_CAP_METHOD.getKey()).getData();
String value = iSystemConfigServiceApi.getBonusSystemConfig(bonusParam.getPkCountry(), ESystemConfig.EXPAND_CAP_METHOD.getKey()).getData();
if (StringUtils.isNotEmpty(value) && Objects.equals(Integer.toString(EExpandCapMethod.WEEK_SETTLE.getValue()), value)) {
// 周结的话不能查询当前周
bonusParam.setEndDate(DateUtils.parseStringToDate(DateUtils.getRecentlyTuesday(bonusParam.getEndDate())));
@ -390,13 +376,6 @@ public class CuMemberBonusServiceImpl extends ServiceImpl<CuMemberBonusMapper, C
return baseMapper.queryMemberBonusByConditionForServer(bonusParam);
}
/**
* @description: 查询奖金明细合计（最后一行）
* @author: zhang jing
* @date: 2024/10/12 14:05
* @param: [bonusParam]
* @return: com.hzs.common.domain.member.ext.CuMemberBonusExt
**/
@Override
public CuMemberBonusExt queryMemberBonusByConditionForServerSum(BonusParam bonusParam) {
return baseMapper.queryMemberBonusByConditionForServerSum(bonusParam);
@ -413,7 +392,7 @@ public class CuMemberBonusServiceImpl extends ServiceImpl<CuMemberBonusMapper, C
TableDataInfo dataTable;
Integer bonusItemsValue = 0;
if (bonusParam.getPkBonusItems() != null) {
BdBonusItems bonusItems = bonusItemsServiceApi.queryBonusItems(bonusParam.getPkCountry(), bonusParam.getPkBonusItems()).getData();
BdBonusItems bonusItems = iBonusItemsServiceApi.queryBonusItems(bonusParam.getPkCountry(), bonusParam.getPkBonusItems()).getData();
bonusItemsValue = bonusItems.getBonusValue();
}
if (null == bonusParam.getPkBonusItems()) {
@ -482,7 +461,7 @@ public class CuMemberBonusServiceImpl extends ServiceImpl<CuMemberBonusMapper, C
});
}
Map<Integer, BdBonusItemsExt> bonusItemsMap = convertBonusItems(bonusParam);
CurrencyDTO currencyDTO = currencyServiceApi.getCurrency(bonusParam.getPkCountry()).getData();
CurrencyDTO currencyDTO = iCurrencyServiceApi.getCurrency(bonusParam.getPkCountry()).getData();
memberBonusDetailVOList.forEach(memberBonusDetailVO -> {
if (bonusItemsMap.containsKey(memberBonusDetailVO.getPkBonusItems())) {
memberBonusDetailVO.setBonusName(bonusItemsMap.get(memberBonusDetailVO.getPkBonusItems()).getBonusName());
@ -498,7 +477,7 @@ public class CuMemberBonusServiceImpl extends ServiceImpl<CuMemberBonusMapper, C
}
private Map<Integer, BdBonusItemsExt> convertBonusItems(BonusParam bonusParam) {
List<BdBonusItemsExt> bonusItemsExtList = bonusItemsServiceApi.queryBonusItems(bonusParam.getPkCountry()).getData();
List<BdBonusItemsExt> bonusItemsExtList = iBonusItemsServiceApi.queryBonusItems(bonusParam.getPkCountry()).getData();
Map<Integer, BdBonusItemsExt> bonusItemsMap = new HashMap<>(ComputeUtil.mapInitCapacity(bonusItemsExtList.size()));
bonusItemsExtList.forEach(bonusItems ->
bonusItemsMap.put(bonusItems.getPkId(), bonusItems));
@ -511,7 +490,7 @@ public class CuMemberBonusServiceImpl extends ServiceImpl<CuMemberBonusMapper, C
List<MemberBonusDetailSerVO> memberBonusDetailSerVoS = new ArrayList<>();
Integer bonusItemsValue = 0;
if (bonusParam.getPkBonusItems() != null) {
BdBonusItems bonusItems = bonusItemsServiceApi.queryBonusItems(bonusParam.getPkCountry(), bonusParam.getPkBonusItems()).getData();
BdBonusItems bonusItems = iBonusItemsServiceApi.queryBonusItems(bonusParam.getPkCountry(), bonusParam.getPkBonusItems()).getData();
bonusItemsValue = bonusItems.getBonusValue();
}
if (bonusParam.getEndDate() != null) {
@ -553,7 +532,7 @@ public class CuMemberBonusServiceImpl extends ServiceImpl<CuMemberBonusMapper, C
memberBonusDetailSerVoS.add(memberBonusDetailVO);
});
} else if (EBonusItems.REPURCHASE_RANGE_INCOME.getValue() == bonusItemsValue || EBonusItems.RETAIL_RANGE_INCOME.getValue() == bonusItemsValue ||
EBonusItems.RETAIL_SAME_LEVEL_INCOME.getValue() == bonusItemsValue || EBonusItems.RETAIL_BENEFIT_RANGE_INCOME.getValue() == bonusItemsValue) {
EBonusItems.RETAIL_SAME_LEVEL_INCOME.getValue() == bonusItemsValue || EBonusItems.RETAIL_BENEFIT_RANGE_INCOME.getValue() == bonusItemsValue) {
// 复购极差
// 拓展收益、复购拓展收益
List<CuMemberBonusRangeExt> cuMemberBonusRangeList = cuMemberBonusRangeMapper.queryMemberBonusRangeByBonusItemsForServer(bonusParam);
@ -678,15 +657,10 @@ public class CuMemberBonusServiceImpl extends ServiceImpl<CuMemberBonusMapper, C
@Override
public Boolean autoCalculateBonus(Date startDate, Date endDate) {
String settleDate = DateUtils.parseDateTimeToStr(DateUtils.YYYY_MM_DD, startDate);
// Date settleEndDate = DateUtils.afterDate(1, ChronoUnit.DAYS, startDate);
// 自动初始化表
// cuMemberTreeService.createCuMemberTree(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, DateUtils.beforeDate(1, ChronoUnit.DAYS)));
cuMemberTreeService.createCuMemberTree(settleDate);
// cuMemberTreeService.createTouchCuMemberTree(settleDate);
log.info("初始化表完成");
// 奖金结算
// List<SaOrderExt> saOrderExtList = saOrderServiceApi.querySaOrderByDay(startDate, settleEndDate).getData();
// bonusSettleService.calculateCuMemberBonus(settleDate, saOrderExtList);
bonusSettleService.calculateCuMemberBonus(settleDate, null);
return Boolean.TRUE;
}

6
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/vo/BonusRecordDetailVO.java
View File

@ -7,11 +7,7 @@ import java.io.Serializable;
import java.util.List;
/**
* @Description: 奖金记录明细，用于结算完奖金，返回值，最终一起入库
* @Author: sui q
* @Time: 2023/2/13 17:58
* @Classname: BonusRecordDetailVO
* @PackageName: com.hzs.member.bonus.vo
* 奖金记录明细，用于结算完奖金，返回值，最终一起入库
*/
@Data
public class BonusRecordDetailVO implements Serializable {

39
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/detail/service/ICuMemberAssessService.java
View File

@ -3,7 +3,6 @@ package com.hzs.bonus.detail.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hzs.common.domain.member.detail.CuMemberAssess;
import com.hzs.common.domain.member.ext.CuMemberSettleExt;
import com.hzs.bonus.detail.vo.CuMemberAssessVO;
import java.util.Date;
import java.util.List;
@ -14,14 +13,6 @@ import java.util.Map;
*/
public interface ICuMemberAssessService extends IService<CuMemberAssess> {
/**
* 每月初，初始化考核数据，根据月底网体数据，先进行奖金计算在进行考核，考核在计算奖金之后
*
* @param settleDate 结算日期
* @param period 结算期间
*/
void initCuMemberAssessData(String settleDate, int period);
/**
* 复购考核每月第一考核调用此方法
*/
@ -44,36 +35,6 @@ public interface ICuMemberAssessService extends IService<CuMemberAssess> {
*/
Map<Long, CuMemberAssess> queryCuMemberAssessByMember(String assessTableName, Integer period, Integer assessType, List<CuMemberSettleExt> cuMemberSettleExtList);
/**
* 查询会员分红考核结果，只查询出免考或者考核通过的，用于分红
*
* @param tableName 表名
* @param period 期间
*/
List<CuMemberAssess> queryCuMemberShareAssess(String tableName, Integer period);
/**
* 会员-考核明细列表
**/
List<CuMemberAssessVO> selectAssessList(CuMemberAssessVO cuMemberAssessVO, List<Integer> orderTypeList);
/**
* 查询会员月度考核（查询列表用）
**/
List<CuMemberAssessVO> getMemberAssessMonthList(CuMemberAssessVO cuMemberAssessVO);
/**
* 查询会员月度考核（查询积分用）
**/
List<CuMemberAssessVO> getMemberAssessMonth(CuMemberAssessVO cuMemberAssessVO);
/**
* 查询会员订单考核积分
**/
CuMemberAssessVO getOrderAssessList(CuMemberAssessVO cuMemberAssessVO);
List<CuMemberAssessVO> getOrderByAssessList(CuMemberAssessVO cuMemberAssessVO);
/*
* 查询满足分红考核的人数，达标人数
**/

296
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/detail/service/impl/CuMemberAssessServiceImpl.java
View File

@ -2,7 +2,6 @@ package com.hzs.bonus.detail.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hzs.bonus.achieve.service.ICuMemberSettlePeriodService;
import com.hzs.bonus.achieve.service.ICuMemberTreeService;
import com.hzs.bonus.achieve.service.impl.CuMemberBonusSettle;
import com.hzs.bonus.detail.service.ICuMemberAssessDetailService;
import com.hzs.bonus.detail.service.ICuMemberAssessService;
@ -10,24 +9,14 @@ 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.core.utils.StringUtils;
import com.hzs.common.domain.member.achieve.CuMemberSettlePeriod;
import com.hzs.common.domain.member.detail.CuMemberAssess;
import com.hzs.common.domain.member.detail.CuMemberAssessDetail;
import com.hzs.common.domain.member.ext.CuMemberAssessExt;
import com.hzs.common.domain.member.ext.CuMemberSettleExt;
import com.hzs.common.domain.sale.order.SaOrder;
import com.hzs.common.domain.system.config.BdAwards;
import com.hzs.bonus.detail.mapper.CuMemberAssessMapper;
import com.hzs.bonus.detail.vo.CuMemberAssessVO;
import com.hzs.sale.order.ISaOrderServiceApi;
import com.hzs.system.config.IAwardsServiceApi;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.time.temporal.ChronoUnit;
import java.util.*;
@ -37,8 +26,6 @@ import java.util.*;
@Service
public class CuMemberAssessServiceImpl extends ServiceImpl<CuMemberAssessMapper, CuMemberAssess> implements ICuMemberAssessService {
private ICuMemberTreeService cuMemberTreeService;
private ICuMemberSettlePeriodService cuMemberSettlePeriodService;
private ICuMemberAssessDetailService cuMemberAssessDetailService;
@ -46,11 +33,6 @@ public class CuMemberAssessServiceImpl extends ServiceImpl<CuMemberAssessMapper,
@Autowired
private CuMemberBonusSettle cuMemberBonusSettle;
@DubboReference
ISaOrderServiceApi saOrderServiceApi;
@DubboReference
IAwardsServiceApi awardsServiceApi;
@Autowired
public void setCuMemberAssessDetailService(ICuMemberAssessDetailService cuMemberAssessDetailService) {
this.cuMemberAssessDetailService = cuMemberAssessDetailService;
@ -61,51 +43,6 @@ public class CuMemberAssessServiceImpl extends ServiceImpl<CuMemberAssessMapper,
this.cuMemberSettlePeriodService = cuMemberSettlePeriodService;
}
@Autowired
public void setCuMemberTreeService(ICuMemberTreeService cuMemberTreeService) {
this.cuMemberTreeService = cuMemberTreeService;
}
@Override
@Transactional(rollbackFor = Exception.class)
public void initCuMemberAssessData(String settleDate, int period) {
// 复购考核，初始化值，值的来源是cu_member_tree上月最后一天的那一期的网体数据
// 初始化值跟最终运算需要分开，防止凌晨12点正好有人支付。
// 根据网体获得需要考核的人员，所有人员
// 免考状态为 免考的顺道修改为考核通过
// 每年一张表，查询的时候只能查询进2年的值
// 结算的是月底那天需要进行考核
Date currentDate = DateUtils.afterDate(1, ChronoUnit.DAYS, DateUtils.parseStringToDate(settleDate));
// 每年1月1日开始创建表
// 判断当前时间是每年第一天，需要初始化表
if (DateUtils.currentDay(currentDate) == 1) {
// 考核表
String tableName = TableNameConstants.CU_MEMBER_ASSESS + DateUtils.currentYear(currentDate);
Integer num = cuMemberTreeService.queryExistOracleTable(tableName);
if (num == null || num <= 0) {
// 判断是否存在年表
baseMapper.createCuMemberAssessTable(tableName);
baseMapper.createCuMemberTableUniqueIndex(tableName);
cuMemberTreeService.createCuMemberTableSequence(tableName, TableNameConstants.CU_MEMBER_ASSESS_SEQ);
}
calculationCuMemberAssess(currentDate);
// String sourceTable = TableNameConstants.CU_MEMBER_SETTLE + period;
// 判断当前时间是月初第一天，需要初始化数据,判断表中是否有数据,没有数据可以进行初始化
// String assessDate = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, currentDate);
// period = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(assessDate).getPkId();
// num = baseMapper.queryCuMemberAssessCount(tableName, period);
// if (num == null || num <= 0) {
// // 初始化复购考核
// String month = DateUtils.getMonth(assessDate);
// // 结算日期后一天
// baseMapper.insertRepCuMemberAssess(tableName, sourceTable, period, month);
// // 初始化分红考核
// baseMapper.insertShareCuMemberAssess(tableName, sourceTable, period, month);
// }
}
}
/**
* 复购考核每月第一次考核调用此方法
*/
@ -147,102 +84,6 @@ public class CuMemberAssessServiceImpl extends ServiceImpl<CuMemberAssessMapper,
return cuMemberAssessMap;
}
@Override
public List<CuMemberAssess> queryCuMemberShareAssess(String tableName, Integer period) {
return baseMapper.queryCuMemberShareAssess(tableName, period);
}
/**
* @description: 会员-考核明细列表
* @author: zhang jing
* @date: 2023/1/23 10:16
* @param: [cuMemberAssessVO]
* @return: java.util.List<com.hzs.member.detail.vo.CuMemberAssessVO>
**/
@Override
public List<CuMemberAssessVO> selectAssessList(CuMemberAssessVO cuMemberAssessVO, List<Integer> orderTypeList) {
Integer year;
if (StringUtils.isNotNull(cuMemberAssessVO) && StringUtils.isNotNull(cuMemberAssessVO.getStartDate())) {
year = DateUtils.currentYear(cuMemberAssessVO.getStartDate());
} else {
year = DateUtils.currentYear(new Date());
}
String tableName = TableNameConstants.CU_MEMBER_ASSESS + year;
if (StringUtils.isNotEmpty(tableName)) {
return baseMapper.selectAssessList(tableName, cuMemberAssessVO.getPkMember(),
cuMemberAssessVO.getPkCountry(), cuMemberAssessVO.getAssessStatus(),
cuMemberAssessVO.getAssessType(), cuMemberAssessVO.getChangeType(), cuMemberAssessVO.getStartDate(),
cuMemberAssessVO.getEndDate(), orderTypeList
);
}
return null;
}
/**
* @description: 查询会员月度考核(查询列表用)
* @author: zhang jing
* @date: 2023/3/14 14:46
* @param: [cuMemberAssessVO]
* @return: java.util.List<com.hzs.member.detail.vo.CuMemberAssessVO>
**/
@Override
public List<CuMemberAssessVO> getMemberAssessMonthList(CuMemberAssessVO cuMemberAssessVO) {
Integer year;
//获取期数
Date date = new Date();
if (StringUtils.isNotNull(cuMemberAssessVO) && StringUtils.isNotNull(cuMemberAssessVO.getStartDate())) {
year = DateUtils.currentYear(cuMemberAssessVO.getStartDate());
} else {
year = DateUtils.currentYear(date);
}
String tableName = TableNameConstants.CU_MEMBER_ASSESS + year;
if (StringUtils.isNotEmpty(tableName)) {
return baseMapper.getMemberAssessMonthList(tableName, cuMemberAssessVO.getPkMember(), cuMemberAssessVO.getAssessType(),
cuMemberAssessVO.getPkCountry(), null);
}
return null;
}
/**
* @description: 查询会员月度考核(查询积分用)
* @author: zhang jing
* @date: 2023/7/2 8:28
* @param: [cuMemberAssessVO]
* @return: java.util.List<com.hzs.member.detail.vo.CuMemberAssessVO>
**/
@Override
public List<CuMemberAssessVO> getMemberAssessMonth(CuMemberAssessVO cuMemberAssessVO) {
Integer year;
//获取期数
Date date = new Date();
int period;
if (StringUtils.isNotNull(cuMemberAssessVO) && StringUtils.isNotNull(cuMemberAssessVO.getStartDate())) {
year = DateUtils.currentYear(cuMemberAssessVO.getStartDate());
if (DateUtils.compareDateBefore(date, cuMemberAssessVO.getStartDate()) || DateUtils.compareDateEqual(date, cuMemberAssessVO.getStartDate())) {
//获取当前月第一天
Date date1 = DateUtils.currentMonthFirstDate(DateUtils.beforeDate(1, ChronoUnit.DAYS, date));
period = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(
DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, date1)).getPkId();
} else {
Date date1 = DateUtils.currentMonthFirstDate(cuMemberAssessVO.getStartDate());
period = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(
DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, date1)).getPkId();
}
} else {
year = DateUtils.currentYear(date);
Date date1 = DateUtils.currentMonthFirstDate(DateUtils.beforeDate(1, ChronoUnit.DAYS, date));
period = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(
DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, date1)).getPkId();
}
String tableName = TableNameConstants.CU_MEMBER_ASSESS + year;
if (StringUtils.isNotEmpty(tableName)) {
return baseMapper.getMemberAssessMonthList(tableName, cuMemberAssessVO.getPkMember(), cuMemberAssessVO.getAssessType(),
cuMemberAssessVO.getPkCountry(), period);
}
return null;
}
/**
* 奖金计算时重算考核 （复购考核、分红考核）,只重算免考的、撤单的
*
@ -323,133 +164,6 @@ public class CuMemberAssessServiceImpl extends ServiceImpl<CuMemberAssessMapper,
// 网体数据修改，修改复购免考类型 0=正常 1=手动免考 2=注册免考 3=晋升免考，修改是否复购免考（0=是,1=否）
}
/**
* @param currentDate 考核日期
* @param cuMemberSettleExtList 前一天的会员免考记录
* @param tableName 会员
* @param currentPeriod 考核期间
* @param settleTableName 考核表
* @Description: 根据撤销订单，进行重算考核数据
* @return: List<CuMemberAssessExt>
* @Author: sui q
* @Date: 2022/11/9 17:45
*/
private List<CuMemberAssessExt> handleCuMemberAssessByRevokeOrder(Date currentDate, List<CuMemberSettleExt> cuMemberSettleExtList,
String tableName, Integer currentPeriod, String settleTableName) {
// e)查询有没有撤单，更新撤单的数据
// List<Integer> orderTypeList = new ArrayList<>();
// orderTypeList.add(EOrderType.REPURCHASE_ORDER.getValue());
// List<SaOrder> saOrderList = saOrderServiceApi.querySaOrderBySettleDate(currentDate, orderTypeList).getData();
// Map<String, SaOrder> saOrderMap = new HashMap<>(ComputeUtil.mapInitCapacity(saOrderList.size()));
// saOrderList.forEach(saOrder -> {
// String key = saOrder.getPkMember().toString() + saOrder.getOrderType().toString();
// saOrderMap.put(key, saOrder);
// });
// if (cuMemberSettleExtList.size() > 0) {
// List<CuMemberSettleExt> memberSettleExtList = new ArrayList<>();
// for (CuMemberSettleExt cuMemberSettleExt : cuMemberSettleExtList) {
// String key = cuMemberSettleExt.getPkMember().toString();
// if (EAssessmentType.REPURCHASE_ASSESS.getValue() == cuMemberSettleExt.getAssessType()) {
// key = key + EOrderType.REPURCHASE_ORDER.getValue();
// } else {
// key = key + EOrderType.WELFARE_ORDER.getValue();
// }
// if (!saOrderMap.containsKey(key)) {
// memberSettleExtList.add(cuMemberSettleExt);
// }
// }
// cuMemberSettleExtList.clear();
// cuMemberSettleExtList.addAll(memberSettleExtList);
// }
// 前一天免考第二天不免考的重新考核
List<CuMemberAssessExt> memberAssessExtList = new ArrayList<>();
if (cuMemberSettleExtList.size() > 0) {
List<List<?>> orderHandleCutList = cuMemberBonusSettle.handleCutList(cuMemberSettleExtList);
orderHandleCutList.forEach(handlerCutList ->
memberAssessExtList.addAll(baseMapper.queryAssessPeriodByRevokeOrder(tableName, settleTableName, currentPeriod, handlerCutList)));
memberAssessExtList.forEach(cuMemberAssessExt -> {
// 需要进行考核的 先变为考核不通过，使用值修改为0
cuMemberAssessExt.setIsExamine(EYesNo.NO.getIntValue());
cuMemberAssessExt.setAssessStatus(EAssessStatus.EXAMINE_NO_PASS.getValue());
cuMemberAssessExt.setMonthUsed(BigDecimal.ZERO);
cuMemberAssessExt.setMonthSurplus(ComputeUtil.computeAdd(cuMemberAssessExt.getMonthBalance(), cuMemberAssessExt.getMonthAdd()));
});
}
// 撤单的也只验证一次，查询新增金额没有进行变更的值
List<CuMemberAssessExt> cuMemberAssessExtList = new ArrayList<>();
// if (saOrderList.size() > 0) {
// List<List<?>> orderHandleCutList = cuMemberBonusSettle.handleCutList(saOrderList);
// orderHandleCutList.forEach(handlerCutList ->
// cuMemberAssessExtList.addAll(baseMapper.queryAssessPeriodByRevokeOrder(tableName, settleTableName, currentPeriod, handlerCutList)));
// packageRetryExamine(cuMemberSettleExtList, saOrderMap, cuMemberAssessExtList);
// }
if (memberAssessExtList.size() > 0) {
cuMemberAssessExtList.addAll(memberAssessExtList);
}
return cuMemberAssessExtList;
}
private void packageRetryExamine(List<CuMemberSettleExt> cuMemberSettleExtList, Map<String, SaOrder> saOrderMap, List<CuMemberAssessExt> cuMemberAssessExtList) {
// 先计算免考的
// 将需要重新考核的考核明细删除
List<CuMemberAssessDetail> revokeDetailList = new ArrayList<>();
cuMemberAssessExtList.forEach(cuMemberAssessExt -> {
String key = cuMemberAssessExt.getPkMember().toString();
if (EAssessmentType.REPURCHASE_ASSESS.getValue() == cuMemberAssessExt.getAssessType()) {
key = key + EOrderType.REPURCHASE_ORDER.getValue();
} else {
key = key + EOrderType.WELFARE_ORDER.getValue();
}
SaOrder saOrder = saOrderMap.get(key);
BigDecimal orderAchieve = BigDecimal.ZERO;
if (saOrder != null) {
orderAchieve = saOrder.getOrderAchieve();
}
// 判断考核类型
CuMemberAssessDetail cuMemberAssessDetail = CuMemberAssessDetail.builder()
.changeType(EAssessmentType.REPURCHASE_ASSESS.getValue() == cuMemberAssessExt.getAssessType() ?
EChangeType.PURCHASE_ASSESSMENT_DEDUCT.getValue() : EChangeType.SHARE_ASSESSMENT_DEDUCT.getValue())
.pkMember(cuMemberAssessExt.getPkMember())
.pkAssess(cuMemberAssessExt.getPkId())
.build();
if (EYesNo.YES.getIntValue() == cuMemberAssessExt.getIsExamine()) {
// 免考的有2种状态 考核通过的需要扣除 免考通过的不扣除
if (EAssessStatus.EXAMINE_PASS.getValue() == cuMemberAssessExt.getAssessStatus()) {
// 考核月新增业绩 month_add 考核月剩余业绩 month_surplus 发生变化
// 剩余 = 结余 + 新增-使用 此条考核记录不能删除
cuMemberAssessExt.setMonthSurplus(ComputeUtil.computeSubtract(ComputeUtil.computeAdd(cuMemberAssessExt.getMonthBalance(), orderAchieve), cuMemberAssessExt.getMonthUsed()));
} else {
// 考核月新增业绩 month_add 考核月剩余业绩 month_surplus 发生变化 考核月使用业绩 month_used 发生变化
// 剩余 = 结余 + 新增
cuMemberAssessExt.setAssessStatus(EAssessStatus.EXEMPT_PASS.getValue());
cuMemberAssessExt.setMonthUsed(BigDecimal.ZERO);
cuMemberAssessExt.setMonthSurplus(ComputeUtil.computeAdd(cuMemberAssessExt.getMonthBalance(), orderAchieve));
revokeDetailList.add(cuMemberAssessDetail);
}
} else {
// 判断奖衔是否发生了变化，发生了变化需要修改目标值 免考的不变更目标值
if (!Objects.equals(cuMemberAssessExt.getPkOriginalAwards(), cuMemberAssessExt.getPkAwards())) {
BdAwards bdAwards = awardsServiceApi.getAwardsOne(cuMemberAssessExt.getPkAwards()).getData();
cuMemberAssessExt.setAssessTarget(EAssessmentType.REPURCHASE_ASSESS.getValue() == cuMemberAssessExt.getAssessType() ?
bdAwards.getPurchaseCheck() : bdAwards.getShareCheck());
}
// 需要进行考核的 先变为考核不通过，使用值修改为0
cuMemberAssessExt.setAssessStatus(EAssessStatus.EXAMINE_NO_PASS.getValue());
cuMemberAssessExt.setMonthUsed(BigDecimal.ZERO);
cuMemberAssessExt.setMonthSurplus(ComputeUtil.computeAdd(cuMemberAssessExt.getMonthBalance(), orderAchieve));
CuMemberSettleExt cuMemberSettleExt = new CuMemberSettleExt();
cuMemberSettleExt.setPkMember(cuMemberAssessExt.getPkMember());
cuMemberSettleExt.setAssessType(cuMemberAssessExt.getAssessType());
cuMemberSettleExtList.add(cuMemberSettleExt);
revokeDetailList.add(cuMemberAssessDetail);
}
});
// 将历史考核明细删除
if (revokeDetailList.size() > 0) {
cuMemberAssessDetailService.deleteCuMemberAssessDetailByList(revokeDetailList);
}
}
private void initCurrentAssess(Date currentDate, String currentTableName, Integer currentPeriod) {
// 获取上月最后一天
String beforeLastDate = DateUtils.beforeMonthLastDateStr(currentDate);
@ -529,16 +243,6 @@ public class CuMemberAssessServiceImpl extends ServiceImpl<CuMemberAssessMapper,
beforeMonthFirstDate, currentMonthFirstDate, orderTypeList);
}
@Override
public CuMemberAssessVO getOrderAssessList(CuMemberAssessVO cuMemberAssessVO) {
return baseMapper.getOrderAssessList(cuMemberAssessVO);
}
@Override
public List<CuMemberAssessVO> getOrderByAssessList(CuMemberAssessVO cuMemberAssessVO) {
return baseMapper.getOrderByAssessList(cuMemberAssessVO);
}
@Override
public List<CuMemberAssess> queryCuMemberAssTotal(String startDate, Integer pkCountry) {
int period = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(startDate).getPkId();

42
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/detail/service/impl/CuMemberAwardsServiceImpl.java
View File

@ -75,7 +75,7 @@ public class CuMemberAwardsServiceImpl extends ServiceImpl<CuMemberAwardsMapper,
baseMapper.deleteCuMemberAwards(period);
while (true) {
List<CuMemberSettleExt> cuMemberSettleExtList = cuMemberTreeService.queryCuMemberSettleEnoughAwardAchieve(settleTableName);
if(!calculateAwards(countryAwardsMap, settleTableName, settleDate, period, cuMemberSettleExtList)){
if (!calculateAwards(countryAwardsMap, settleTableName, settleDate, period, cuMemberSettleExtList)) {
break;
}
}
@ -94,21 +94,23 @@ public class CuMemberAwardsServiceImpl extends ServiceImpl<CuMemberAwardsMapper,
@Override
public void calculateCuMemberRetailRangeAwardsInit(String settleDate, Integer period, String rangeTableName) {
if (settleDate.endsWith("01")) {
// 每月1号更新奖衔
// 每月1号初始化结算表奖衔（月度奖衔归0，V5给S1奖衔）
cuMemberTreeService.updateCuMemberRetailRangeInitAward(rangeTableName);
// 每月1号初始化会员表奖衔（月度奖衔归0，V5给S1奖衔）
cuMemberService.updateCuMemberRetailRangeInitAward();
}
// 更新奖衔，回退奖衔
// List<CuMemberAwards> cuMemberAwards = queryCuMemberAwardsByPeriod(period, systemType);
// 回退结算表奖衔
cuMemberTreeService.updateBackCuMemberRetailRangeAward(rangeTableName, period);
cuMemberService.updateBackCuMemberRetailRangeAward(/*cuMemberAwards,*/ period);
// 回退业绩表奖衔
// 回退会员表奖衔
cuMemberService.updateBackCuMemberRetailRangeAward(period);
// 删除会员奖衔升级记录
baseMapper.deleteCuMemberAwards(period);
// 更新奖衔，手动设置的，一种有效期前的，一种有效期到达的
// 更新手动设置奖衔，一种有效期前的，一种有效期到达的
// 有效期前的奖衔小于手动的，修改奖衔，
Date date = DateUtils.parseStringToDate(settleDate);
cuMemberTreeService.updateCuMemberRetailRangeAwardByDate(rangeTableName, date);
cuMemberService.updateCuMemberRetailRangeAwardByDate(date);;
cuMemberService.updateCuMemberRetailRangeAwardByDate(date);
}
@Override
@ -159,7 +161,7 @@ public class CuMemberAwardsServiceImpl extends ServiceImpl<CuMemberAwardsMapper,
});
List<CuMemberAwards> memberAwardsList = updateAwardsRecord(enoughAwardsMemberList, originalCuMemberSettleMap, period);
if(memberAwardsList != null && memberAwardsList.size() >0){
if (memberAwardsList != null && memberAwardsList.size() > 0) {
cuMemberAwardsList.addAll(memberAwardsList);
}
// 需要验证安置的
@ -174,10 +176,10 @@ public class CuMemberAwardsServiceImpl extends ServiceImpl<CuMemberAwardsMapper,
}
});
List<CuMemberAwards> awardsList = updateAwardsRecord(updateAwardsMemberList, originalCuMemberSettleMap, period);
if(updateAwardsMemberList.size() >0) {
if (updateAwardsMemberList.size() > 0) {
enoughAwardsMemberList.addAll(updateAwardsMemberList);
}
if(awardsList != null && awardsList.size() >0){
if (awardsList != null && awardsList.size() > 0) {
cuMemberAwardsList.addAll(awardsList);
}
}
@ -194,10 +196,10 @@ public class CuMemberAwardsServiceImpl extends ServiceImpl<CuMemberAwardsMapper,
}
});
List<CuMemberAwards> awardsList = updateAwardsRecord(updateAwardsMemberList, originalCuMemberSettleMap, period);
if(updateAwardsMemberList.size() >0) {
if (updateAwardsMemberList.size() > 0) {
enoughAwardsMemberList.addAll(updateAwardsMemberList);
}
if(awardsList != null && awardsList.size() >0){
if (awardsList != null && awardsList.size() > 0) {
cuMemberAwardsList.addAll(awardsList);
}
}
@ -210,7 +212,7 @@ public class CuMemberAwardsServiceImpl extends ServiceImpl<CuMemberAwardsMapper,
// 根据结算日期获得所有需要更新的周期
updateMemberAwardPeriod(settleDate);
return Boolean.TRUE;
}else {
} else {
cuMemberService.updateCuMemberByPeriod(null, period);
updateMemberAwardPeriod(settleDate);
return Boolean.FALSE;
@ -245,10 +247,10 @@ public class CuMemberAwardsServiceImpl extends ServiceImpl<CuMemberAwardsMapper,
List<BdAwards> bdAwardsList = new ArrayList<>();
for (String key : awardsMap.keySet()) {
BdAwards bdAwards = awardsMap.get(key);
if(bdAwards.getPkCountry().equals(CountryConstants.CHINA_COUNTRY) && ComputeUtil.compareValue(bdAwards.getCommunityCheck()) && ComputeUtil.compareGreaterThan(minAchieve, bdAwards.getCommunityCheck())){
if (bdAwards.getPkCountry().equals(CountryConstants.CHINA_COUNTRY) && ComputeUtil.compareValue(bdAwards.getCommunityCheck()) && ComputeUtil.compareGreaterThan(minAchieve, bdAwards.getCommunityCheck())) {
minAchieve = bdAwards.getCommunityCheck();
}
if(ComputeUtil.compareValue(bdAwards.getCommunityCheck()) && bdAwards.getPkCountry().equals(CountryConstants.CHINA_COUNTRY)) {
if (ComputeUtil.compareValue(bdAwards.getCommunityCheck()) && bdAwards.getPkCountry().equals(CountryConstants.CHINA_COUNTRY)) {
bdAwardsList.add(bdAwards);
}
}
@ -288,8 +290,8 @@ public class CuMemberAwardsServiceImpl extends ServiceImpl<CuMemberAwardsMapper,
* @Author: sui q
* @Date: 2023/2/23 17:44
*/
private List<CuMemberAwards> updateAwardsRecord(List<CuMemberSettleExt> enoughAwardsMemberList, Map<Long, CuMemberSettleExt> originalCuMemberSettleMap,
Integer period) {
private List<CuMemberAwards> updateAwardsRecord(List<CuMemberSettleExt> enoughAwardsMemberList, Map<Long, CuMemberSettleExt> originalCuMemberSettleMap,
Integer period) {
if (enoughAwardsMemberList.size() == 0) {
return null;
}
@ -308,7 +310,7 @@ public class CuMemberAwardsServiceImpl extends ServiceImpl<CuMemberAwardsMapper,
* @param period 期间
*/
private List<CuMemberAwards> upgradeCuMemberAwards(List<CuMemberSettleExt> enoughAwardsMemberList, Map<Long, CuMemberSettleExt> originalCuMemberSettleMap,
Integer period) {
Integer period) {
List<CuMemberAwards> cuMemberAwardsList = new ArrayList<>();
if (enoughAwardsMemberList.size() > 0) {
// 记录要入库的，为了验证是否首次晋升
@ -391,7 +393,7 @@ public class CuMemberAwardsServiceImpl extends ServiceImpl<CuMemberAwardsMapper,
private List<CuMemberAwards> queryCuMemberAwardsByPeriod(Integer period, Integer systemType) {
QueryWrapper<CuMemberAwards> queryWrapper = new QueryWrapper<>();
queryWrapper.eq(MemberFieldConstants.PERIOD, period);
if(systemType != null){
if (systemType != null) {
queryWrapper.eq("SYSTEM_TYPE", systemType);
}
queryWrapper.eq(MemberFieldConstants.UP_TYPE, EUpgradeType.AUTO_UPGRADE.getValue());

14
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/detail/vo/CuMemberAssessVO.java
View File

@ -10,15 +10,10 @@ import java.util.Date;
import java.util.List;
/**
* <p>
* 会员信息-会员考核记录VO
* </p>
*
* @author hzs
* @since 2022-08-31
*/
@Data
public class CuMemberAssessVO {
public class CuMemberAssessVO {
private static final long serialVersionUID = 1L;
@ -62,8 +57,6 @@ public class CuMemberAssessVO {
private String orderCode;
/**
* 交易时间
*/
@ -141,9 +134,4 @@ public class CuMemberAssessVO {
List<Integer> orderTypeList;
}

695
bd-business/bd-business-bonus/src/main/resources/mapper/bonus/achieve/CuMemberAchieveMapper.xml
View File

@ -145,36 +145,7 @@
r_rep_b_sum_pv NUMBER(17,6) default 0 not null,
pk_country NUMBER(6) not null
</sql>
<insert id="insertCuMemberAchieveBySettleDate">
insert into ${targetTableName}(period,pk_member,pk_rate,a_balance,b_balance,a_sum_amount,
b_sum_amount,a_sum_pv,b_sum_pv,a_new_amount,b_new_amount,a_new_pv,
b_new_pv,a_sum_real_amount,b_sum_real_amount,a_sum_real_pv,b_sum_real_pv,
rep_a_balance,rep_b_balance,rep_a_new_amount,rep_b_new_amount,rep_a_new_pv,
rep_b_new_pv,rep_a_sum_amount,rep_b_sum_amount,rep_a_sum_pv,rep_b_sum_pv,
register_amount,register_pv,register_new_amount,register_new_pv,
upgrade_amount,upgrade_pv,upgrade_new_amount,upgrade_new_pv,
repurchase_amount,repurchase_pv,repurchase_new_amount,repurchase_new_pv,
hi_fun_amount,hi_fun_pv,hi_fun_new_amount,hi_fun_new_pv,
mall_amount,mall_pv,mall_new_amount,mall_new_pv,
r_a_balance,r_b_balance,r_a_sum_amount,r_b_sum_amount,r_a_sum_pv,r_b_sum_pv,
r_a_sum_real_amount,r_b_sum_real_amount,r_a_sum_real_pv,r_b_sum_real_pv,
r_rep_a_balance,r_rep_b_balance,r_rep_a_sum_amount,r_rep_b_sum_amount,
r_rep_a_sum_pv,r_rep_b_sum_pv,pk_country)
select #{period} period,pk_member,nvl(pk_rate,0) pk_rate,a_balance,b_balance,a_sum_amount,
b_sum_amount,a_sum_pv,b_sum_pv,a_new_amount,b_new_amount,a_new_pv,
b_new_pv,a_sum_real_amount,b_sum_real_amount,a_sum_real_pv,b_sum_real_pv,
rep_a_balance,rep_b_balance,rep_a_new_amount,rep_b_new_amount,rep_a_new_pv,
rep_b_new_pv,rep_a_sum_amount,rep_b_sum_amount,rep_a_sum_pv,rep_b_sum_pv,
register_amount,register_pv,register_new_amount,register_new_pv,
upgrade_amount,upgrade_pv,upgrade_new_amount,upgrade_new_pv,
repurchase_amount,repurchase_pv,repurchase_new_amount,repurchase_new_pv,
hi_fun_amount,hi_fun_pv,hi_fun_new_amount,hi_fun_new_pv,
mall_amount,mall_pv,mall_new_amount,mall_new_pv,
r_a_balance,r_b_balance,r_a_sum_amount,r_b_sum_amount,r_a_sum_pv,r_b_sum_pv,
r_a_sum_real_amount,r_b_sum_real_amount,r_a_sum_real_pv,r_b_sum_real_pv,
r_rep_a_balance,r_rep_b_balance,r_rep_a_sum_amount,r_rep_b_sum_amount,
r_rep_a_sum_pv,r_rep_b_sum_pv,pk_country from ${sourceTableName}
</insert>
<update id="createCuMemberAchieveTable">
create table ${tableName}
(
@ -182,335 +153,6 @@
)
</update>
<!--每日更新累计金额-->
<update id="updateCuMemberBackOldAchieveEveryDay">
merge into ${tableName} a
using (
select pk_member,max(a.pk_rate) pk_rate,sum(a_new_amount/bc.out_exchange_rate) a_new_amount,sum(a_new_pv)
a_new_pv,
sum(b_new_amount/bc.out_exchange_rate) b_new_amount,sum(b_new_pv) b_new_pv,
sum(rep_a_new_amount/bc.out_exchange_rate) rep_a_new_amount,sum(rep_b_new_amount/bc.out_exchange_rate)
rep_b_new_amount,
sum(rep_a_new_pv) rep_a_new_pv,sum(rep_b_new_pv) rep_b_new_pv,sum(a_new_real_amount/bc.out_exchange_rate)
a_new_real_amount,
sum(a_new_real_pv) a_new_real_pv,sum(b_new_real_amount/bc.out_exchange_rate)
b_new_real_amount,sum(b_new_real_pv) b_new_real_pv
from (
<foreach collection="memberAchieveParamList" item="achieve" open=" " separator=" union all " close=" ">
select pk_place_parent pk_member,#{achieve.pkRate} pk_rate,
(case when place_dept =1 then #{achieve.newAmount} else 0 end) a_new_amount,
(case when place_dept =1 then #{achieve.newPv} else 0 end) a_new_pv,
(case when place_dept =1 then #{achieve.repNewAmount} else 0 end) rep_a_new_amount,
(case when place_dept =1 then #{achieve.repNewPv} else 0 end) rep_a_new_pv,
(case when place_dept =1 then #{achieve.newRealAmount} else 0 end) a_new_real_amount,
(case when place_dept =1 then #{achieve.newRealPv} else 0 end) a_new_real_pv,
(case when place_dept =2 then #{achieve.newAmount} else 0 end) b_new_amount,
(case when place_dept =2 then #{achieve.newPv} else 0 end) b_new_pv,
(case when place_dept =2 then #{achieve.repNewAmount} else 0 end) rep_b_new_amount,
(case when place_dept =2 then #{achieve.repNewPv} else 0 end) rep_b_new_pv,
(case when place_dept =2 then #{achieve.newRealAmount} else 0 end) b_new_real_amount,
(case when place_dept =2 then #{achieve.newRealPv} else 0 end) b_new_real_pv
from(
select pk_place_parent,place_dept from(
select * from ${tableName}
start with pk_member = #{achieve.pkMember}
connect by pk_member = prior pk_place_parent
)
where nvl(pk_place_parent,0) !=0
)
</foreach>
) a
inner join bd_currency bc
on a.pk_rate = bc.pk_id
group by pk_member
) b
on (a.pk_member = b.pk_member)
when matched then
update
set a.period = a.period + 1,
a.a_sum_pv = a.a_sum_pv - b.a_new_pv,
a.b_sum_pv = a.b_sum_pv - b.b_new_pv,
a.rep_a_sum_pv = a.rep_a_sum_pv - b.rep_a_new_pv,
a.rep_b_sum_pv = a.rep_b_sum_pv - b.rep_b_new_pv,
a.a_sum_real_pv = a.a_sum_real_pv - b.a_new_real_pv,
a.b_sum_real_pv = a.b_sum_real_pv - b.b_new_real_pv
</update>
<!--每日更新累计金额-->
<update id="updateCuMemberBackAchieveEveryDay">
merge into ${tableName} a
using (
select pk_member,max(a.pk_rate) pk_rate,sum(a_new_amount/bc.out_exchange_rate) a_new_amount,sum(a_new_pv)
a_new_pv,
sum(b_new_amount/bc.out_exchange_rate) b_new_amount,sum(b_new_pv) b_new_pv,
sum(rep_a_new_amount/bc.out_exchange_rate) rep_a_new_amount,sum(rep_b_new_amount/bc.out_exchange_rate)
rep_b_new_amount,
sum(rep_a_new_pv) rep_a_new_pv,sum(rep_b_new_pv) rep_b_new_pv,sum(a_new_real_amount/bc.out_exchange_rate)
a_new_real_amount,
sum(a_new_real_pv) a_new_real_pv,sum(b_new_real_amount/bc.out_exchange_rate)
b_new_real_amount,sum(b_new_real_pv) b_new_real_pv
from (
<foreach collection="memberAchieveParamList" item="achieve" open=" " separator=" union all " close=" ">
select pk_place_parent pk_member,#{achieve.pkRate} pk_rate,
(case when place_dept =1 then #{achieve.newAmount} else 0 end) a_new_amount,
(case when place_dept =1 then #{achieve.newPv} else 0 end) a_new_pv,
(case when place_dept =1 then #{achieve.repNewAmount} else 0 end) rep_a_new_amount,
(case when place_dept =1 then #{achieve.repNewPv} else 0 end) rep_a_new_pv,
(case when place_dept =1 then #{achieve.newRealAmount} else 0 end) a_new_real_amount,
(case when place_dept =1 then #{achieve.newRealPv} else 0 end) a_new_real_pv,
(case when place_dept =2 then #{achieve.newAmount} else 0 end) b_new_amount,
(case when place_dept =2 then #{achieve.newPv} else 0 end) b_new_pv,
(case when place_dept =2 then #{achieve.repNewAmount} else 0 end) rep_b_new_amount,
(case when place_dept =2 then #{achieve.repNewPv} else 0 end) rep_b_new_pv,
(case when place_dept =2 then #{achieve.newRealAmount} else 0 end) b_new_real_amount,
(case when place_dept =2 then #{achieve.newRealPv} else 0 end) b_new_real_pv
from(
select pk_place_parent,place_dept from(
select * from ${tableName}
start with pk_member = #{achieve.pkMember}
connect by pk_member = prior pk_place_parent
)
where nvl(pk_place_parent,0) !=0
)
</foreach>
) a
inner join bd_currency bc
on a.pk_rate = bc.pk_id
group by pk_member
) b
on (a.pk_member = b.pk_member)
when matched then
update set
a.period = a.period + 1,
a.pk_rate = b.pk_rate,
a.a_sum_pv = a.a_sum_pv + b.a_new_pv,
a.b_sum_pv = a.b_sum_pv + b.b_new_pv,
a.rep_a_sum_pv = a.rep_a_sum_pv + b.rep_a_new_pv,
a.rep_b_sum_pv = a.rep_b_sum_pv + b.rep_b_new_pv,
a.a_sum_real_pv = a.a_sum_real_pv + b.a_new_real_pv,
a.b_sum_real_pv = a.b_sum_real_pv + b.b_new_real_pv,
a.r_a_sum_amount = a.r_a_sum_amount + b.a_new_amount,
a.r_b_sum_amount = a.r_b_sum_amount + b.b_new_amount,
a.r_a_sum_pv = a.r_a_sum_pv +b.a_new_pv,
a.r_b_sum_pv = a.r_b_sum_pv + b.b_new_pv,
a.r_rep_a_sum_amount =a.r_rep_a_sum_amount +b.rep_a_new_amount,
a.r_rep_b_sum_amount =a.r_rep_b_sum_amount + b.rep_b_new_amount,
a.r_rep_a_sum_pv = a.r_rep_a_sum_pv + b.rep_a_new_pv,
a.r_rep_b_sum_pv = a.r_rep_b_sum_pv + b.rep_b_new_pv,
a.r_a_sum_real_amount = a.r_a_sum_real_amount + b.a_new_real_amount,
a.r_b_sum_real_amount = a.r_b_sum_real_amount + b.b_new_real_amount,
a.r_a_sum_real_pv = a.r_a_sum_real_pv + b.a_new_real_pv,
a.r_b_sum_real_pv = a.r_b_sum_real_pv + b.b_new_real_pv
</update>
<!--将昨天的各种金额作为今天的期初-->
<update id="updateCuMemberSettleAchieveByBeforeDay">
merge into ${targetTable} a
using(select pk_member,a_balance,b_balance,
a_sum_amount,b_sum_amount,a_sum_pv,b_sum_pv,
a_new_amount,b_new_amount,a_new_pv,b_new_pv,
a_sum_real_amount,b_sum_real_amount,a_sum_real_pv,b_sum_real_pv,
rep_a_balance,rep_b_balance,
rep_a_sum_amount,rep_b_sum_amount,rep_a_sum_pv,rep_b_sum_pv,
register_amount,register_pv,upgrade_amount,upgrade_pv,
repurchase_amount,repurchase_pv,hi_fun_amount,hi_fun_pv,
mall_amount,mall_pv,pk_country,min_achieve,round,second,net_first_achieve,net_repurchase_achieve,
r_a_balance,r_b_balance,r_a_sum_amount,r_b_sum_amount,r_a_sum_pv,r_b_sum_pv,
r_rep_a_sum_amount,r_rep_b_sum_amount,r_rep_a_sum_pv,
r_rep_b_sum_pv,r_a_sum_real_amount,r_b_sum_real_amount,
r_a_sum_real_pv,r_b_sum_real_pv,r_rep_a_balance,r_rep_b_balance from ${sourceTable} ) b
on (a.pk_member = b.pk_member)
when matched then
update set
a.a_balance=b.a_balance,a.b_balance=b.b_balance,
a.a_sum_amount=b.a_sum_amount,a.b_sum_amount=b.b_sum_amount,
a.a_sum_pv=b.a_sum_pv,a.b_sum_pv=b.b_sum_pv,
a.a_sum_real_amount=b.a_sum_real_amount,a.b_sum_real_amount=b.b_sum_real_amount,
a.a_sum_real_pv=b.a_sum_real_pv,a.b_sum_real_pv=b.b_sum_real_pv,
a.rep_a_balance=b.rep_a_balance,a.rep_b_balance=b.rep_b_balance,
a.rep_a_sum_pv=b.rep_a_sum_pv,a.rep_b_sum_pv=b.rep_b_sum_pv,
a.register_amount=b.register_amount,a.register_pv=b.register_pv,
a.upgrade_amount=b.upgrade_amount,a.upgrade_pv=b.upgrade_pv,
a.repurchase_amount=b.repurchase_amount,a.repurchase_pv=b.repurchase_pv,
a.hi_fun_amount=b.hi_fun_amount,a.hi_fun_pv=b.hi_fun_pv,
a.mall_amount=b.mall_amount,a.mall_pv=b.mall_pv,
a.min_achieve=b.min_achieve,a.round=b.round,a.second=b.second,
a.net_first_achieve=b.net_first_achieve,a.net_repurchase_achieve=b.net_repurchase_achieve,
a.r_a_balance=b.r_a_balance,a.r_b_balance=b.r_b_balance,
a.r_a_sum_amount = b.r_a_sum_amount,a.r_b_sum_amount = b.r_b_sum_amount,a.r_a_sum_pv = b.r_a_sum_pv,a.r_b_sum_pv = b.r_b_sum_pv,
a.r_rep_a_sum_amount = b.r_rep_a_sum_amount,a.r_rep_b_sum_amount = b.r_rep_b_sum_amount,a.r_rep_a_sum_pv = b.r_rep_a_sum_pv,
a.r_rep_b_sum_pv = b.r_rep_b_sum_pv,a.r_a_sum_real_amount = b.r_a_sum_real_amount,a.r_b_sum_real_amount = b.r_b_sum_real_amount,
a.r_a_sum_real_pv = b.r_a_sum_real_pv,a.r_b_sum_real_pv = b.r_b_sum_real_pv,a.r_rep_a_balance=b.r_rep_a_balance,a.r_rep_b_balance=b.r_rep_b_balance
</update>
<update id="updateCuMemberSettleAchieveBySpecialBus">
merge into ${targetTable} a
using(select cl.pk_member,
(case infusing_water_type when 1 then ca.a_sum_real_pv + a_sum_real_modify_pv when 2 then ca.a_sum_real_pv- a_sum_real_modify_pv else a_sum_real_modify_pv end) a_sum_real_pv,
(case infusing_water_type when 1 then ca.b_sum_real_pv +b_sum_real_modify_pv when 2 then ca.b_sum_real_pv- b_sum_real_modify_pv else b_sum_real_modify_pv end) b_sum_real_pv,
(case infusing_water_type when 1 then ca.a_sum_pv + a_first_modify_pv when 2 then ca.a_sum_pv- a_first_modify_pv else a_first_modify_pv end) a_sum_pv,
(case infusing_water_type when 1 then ca.b_sum_pv + b_first_modify_pv when 2 then ca.b_sum_pv- b_first_modify_pv else b_first_modify_pv end) b_sum_pv,
(case infusing_water_type when 1 then ca.a_balance + rep_a_first_modify_balance when 2 then ca.a_balance- rep_a_first_modify_balance else rep_a_first_modify_balance end) a_balance,
(case infusing_water_type when 1 then ca.b_balance + rep_b_first_modify_balance when 2 then ca.b_balance- rep_b_first_modify_balance else rep_b_first_modify_balance end) b_balance,
(case infusing_water_type when 1 then ca.rep_a_sum_pv + rep_a_modify_sum_pv when 2 then ca.rep_a_sum_pv- rep_a_modify_sum_pv else rep_a_modify_sum_pv end) rep_a_sum_pv,
(case infusing_water_type when 1 then ca.rep_b_sum_pv + rep_b_modify_sum_pv when 2 then ca.rep_b_sum_pv- rep_b_modify_sum_pv else rep_b_modify_sum_pv end) rep_b_sum_pv,
(case infusing_water_type when 1 then ca.rep_a_balance + rep_a_modify_balance when 2 then ca.rep_a_balance- rep_a_modify_balance else rep_a_modify_balance end) rep_a_balance,
(case infusing_water_type when 1 then ca.rep_b_balance + rep_b_modify_balance when 2 then ca.rep_b_balance- rep_b_modify_balance else rep_b_modify_balance end) rep_b_balance from cu_member_achieve_log cl
left join ${targetTable} ca
on cl.pk_member = ca.pk_member
where cl.period= #{period} and approve_status=5 and cl.pk_id = #{pkId}
order by cl.pk_member,cl.creation_time) b
on (a.pk_member = b.pk_member)
when matched then
update set a.a_sum_real_pv = b.a_sum_real_pv, a.b_sum_real_pv=b.b_sum_real_pv,a.a_sum_pv=b.a_sum_pv,a.b_sum_pv=b.b_sum_pv,
a.a_balance=b.a_balance,a.b_balance=b.b_balance,a.rep_a_sum_pv=b.rep_a_sum_pv,a.rep_b_sum_pv=b.rep_b_sum_pv,
a.rep_a_balance=b.rep_a_balance,a.rep_b_balance=b.rep_b_balance
</update>
<update id="updateCuMemberSettleAchieveByDueDate">
merge into ${currentTableName} a
using (
select ct.pk_member,r_a_balance,r_b_balance,r_a_sum_pv,r_b_sum_pv,r_a_sum_real_pv,r_b_sum_real_pv,
r_rep_a_sum_pv,r_rep_b_sum_pv,r_rep_a_balance,r_rep_b_balance from ${yesTableName} ct
inner join cu_member_achieve_log cl
on ct.pk_member = cl.pk_member
where cl.due_date = #{currentDate, jdbcType=DATE}
) b
on (a.pk_member = b.pk_member)
when matched then
update set a.r_a_balance=b.r_a_balance,a.r_b_balance=b.r_b_balance,
a.r_a_sum_pv=b.r_a_sum_pv,a.r_b_sum_pv=b.r_b_sum_pv,
a.r_a_sum_real_pv=b.r_a_sum_real_pv,a.r_b_sum_real_pv=b.r_b_sum_real_pv,
a.r_rep_a_sum_pv=b.r_rep_a_sum_pv,a.r_rep_b_sum_pv=b.r_rep_b_sum_pv,
a.r_rep_a_balance=b.r_rep_a_balance,a.r_rep_b_balance=b.r_rep_b_balance
</update>
<update id="mergeCuMemberAchieveBySettleDate">
merge into ${targetTableName} a
using(
select #{period} period,pk_member,nvl(pk_rate,0) pk_rate,a_balance,b_balance,a_sum_amount,
b_sum_amount,a_sum_pv,b_sum_pv,a_new_amount,b_new_amount,a_new_pv,
b_new_pv,a_sum_real_amount,b_sum_real_amount,a_sum_real_pv,b_sum_real_pv,
rep_a_balance,rep_b_balance,rep_a_new_amount,rep_b_new_amount,rep_a_new_pv,
rep_b_new_pv,rep_a_sum_amount,rep_b_sum_amount,rep_a_sum_pv,rep_b_sum_pv,
register_amount,register_pv,register_new_amount,register_new_pv,
upgrade_amount,upgrade_pv,upgrade_new_amount,upgrade_new_pv,
repurchase_amount,repurchase_pv,repurchase_new_amount,repurchase_new_pv,
hi_fun_amount,hi_fun_pv,hi_fun_new_amount,hi_fun_new_pv,
mall_amount,mall_pv,mall_new_amount,mall_new_pv,
register_blo_new_pv,upgrade_blo_new_pv,repurchase_blo_new_pv,hi_fun_blo_new_pv,mall_blo_new_pv,
r_a_balance,r_b_balance,r_a_sum_amount,r_b_sum_amount,r_a_sum_pv,r_b_sum_pv,
r_a_sum_real_amount,r_b_sum_real_amount,r_a_sum_real_pv,r_b_sum_real_pv,
r_rep_a_balance,r_rep_b_balance,r_rep_a_sum_amount,r_rep_b_sum_amount,
r_rep_a_sum_pv,r_rep_b_sum_pv,pk_country from ${sourceTableName}
) b
on (a.pk_member=b.pk_member and a.period=b.period)
WHEN MATCHED THEN
update set a.pk_rate = b.pk_rate,a.a_balance = b.a_balance,a.b_balance = b.b_balance,
a.a_sum_amount = b.a_sum_amount,a.b_sum_amount = b.b_sum_amount,
a.a_sum_pv = b.a_sum_pv,a.b_sum_pv = b.b_sum_pv,a.a_new_amount = b.a_new_amount,
a.b_new_amount = b.b_new_amount,a.a_new_pv = b.a_new_pv,a.b_new_pv = b.b_new_pv,
a.a_sum_real_amount = b.a_sum_real_amount,a.b_sum_real_amount = b.b_sum_real_amount,
a.a_sum_real_pv = b.a_sum_real_pv,a.b_sum_real_pv = b.b_sum_real_pv,
a.rep_a_balance = b.rep_a_balance,a.rep_b_balance = b.rep_b_balance,
a.rep_a_new_amount = b.rep_a_new_amount,a.rep_b_new_amount = b.rep_b_new_amount,
a.rep_a_new_pv = b.rep_a_new_pv,a.rep_b_new_pv = b.rep_b_new_pv,
a.rep_a_sum_amount = b.rep_a_sum_amount,a.rep_b_sum_amount = b.rep_b_sum_amount,
a.rep_a_sum_pv = b.rep_a_sum_pv,a.rep_b_sum_pv = b.rep_b_sum_pv,
a.register_amount = b.register_amount,a.register_pv = b.register_pv,a.register_new_amount = b.register_new_amount,
a.register_new_pv = b.register_new_pv,a.upgrade_amount = b.upgrade_amount,a.upgrade_pv = b.upgrade_pv,
a.upgrade_new_amount = b.upgrade_new_amount,a.upgrade_new_pv = b.upgrade_new_pv,
a.repurchase_amount = b.repurchase_amount,a.repurchase_pv = b.repurchase_pv,
a.repurchase_new_amount = b.repurchase_new_amount,a.repurchase_new_pv = b.repurchase_new_pv,
a.hi_fun_amount = b.hi_fun_amount,a.hi_fun_pv = b.hi_fun_pv,a.hi_fun_new_amount = b.hi_fun_new_amount,
a.hi_fun_new_pv = b.hi_fun_new_pv,a.mall_amount = b.mall_amount,a.mall_pv = b.mall_pv,
a.mall_new_amount = b.mall_new_amount,a.mall_new_pv = b.mall_new_pv,
a.register_blo_new_pv=b.register_blo_new_pv,a.upgrade_blo_new_pv=b.upgrade_blo_new_pv,
a.repurchase_blo_new_pv=b.repurchase_blo_new_pv,
a.hi_fun_blo_new_pv=b.hi_fun_blo_new_pv,a.mall_blo_new_pv=b.mall_blo_new_pv,
a.r_a_balance = b.r_a_balance,a.r_b_balance = b.r_b_balance,a.r_a_sum_amount = b.r_a_sum_amount,
a.r_b_sum_amount = b.r_b_sum_amount,a.r_a_sum_pv = b.r_a_sum_pv,a.r_b_sum_pv = b.r_b_sum_pv,
a.r_a_sum_real_amount = b.r_a_sum_real_amount,a.r_b_sum_real_amount = b.r_b_sum_real_amount,
a.r_a_sum_real_pv = b.r_a_sum_real_pv,a.r_b_sum_real_pv = b.r_b_sum_real_pv,
a.r_rep_a_balance = b.r_rep_a_balance,a.r_rep_b_balance = b.r_rep_b_balance,
a.r_rep_a_sum_amount = b.r_rep_a_sum_amount,a.r_rep_b_sum_amount = b.r_rep_b_sum_amount,
a.r_rep_a_sum_pv = b.r_rep_a_sum_pv,a.r_rep_b_sum_pv = b.r_rep_b_sum_pv,a.pk_country = b.pk_country
WHEN NOT MATCHED THEN
insert (period,pk_member,pk_rate,a_balance,b_balance,a_sum_amount,
b_sum_amount,a_sum_pv,b_sum_pv,a_new_amount,b_new_amount,a_new_pv,
b_new_pv,a_sum_real_amount,b_sum_real_amount,a_sum_real_pv,b_sum_real_pv,
rep_a_balance,rep_b_balance,rep_a_new_amount,rep_b_new_amount,rep_a_new_pv,
rep_b_new_pv,rep_a_sum_amount,rep_b_sum_amount,rep_a_sum_pv,rep_b_sum_pv,
register_amount,register_pv,register_new_amount,register_new_pv,
upgrade_amount,upgrade_pv,upgrade_new_amount,upgrade_new_pv,
repurchase_amount,repurchase_pv,repurchase_new_amount,repurchase_new_pv,
hi_fun_amount,hi_fun_pv,hi_fun_new_amount,hi_fun_new_pv,
mall_amount,mall_pv,mall_new_amount,mall_new_pv,
register_blo_new_pv,upgrade_blo_new_pv,repurchase_blo_new_pv,hi_fun_blo_new_pv,mall_blo_new_pv,
r_a_balance,r_b_balance,r_a_sum_amount,r_b_sum_amount,r_a_sum_pv,r_b_sum_pv,
r_a_sum_real_amount,r_b_sum_real_amount,r_a_sum_real_pv,r_b_sum_real_pv,
r_rep_a_balance,r_rep_b_balance,r_rep_a_sum_amount,r_rep_b_sum_amount,
r_rep_a_sum_pv,r_rep_b_sum_pv,pk_country)
values(b.period,b.pk_member,b.pk_rate,b.a_balance,b.b_balance,b.a_sum_amount,
b.b_sum_amount,b.a_sum_pv,b.b_sum_pv,b.a_new_amount,b.b_new_amount,b.a_new_pv,
b.b_new_pv,b.a_sum_real_amount,b.b_sum_real_amount,b.a_sum_real_pv,b.b_sum_real_pv,
b.rep_a_balance,b.rep_b_balance,b.rep_a_new_amount,b.rep_b_new_amount,b.rep_a_new_pv,
b.rep_b_new_pv,b.rep_a_sum_amount,b.rep_b_sum_amount,b.rep_a_sum_pv,b.rep_b_sum_pv,
b.register_amount,b.register_pv,b.register_new_amount,b.register_new_pv,
b.upgrade_amount,b.upgrade_pv,b.upgrade_new_amount,b.upgrade_new_pv,
b.repurchase_amount,b.repurchase_pv,b.repurchase_new_amount,b.repurchase_new_pv,
b.hi_fun_amount,b.hi_fun_pv,b.hi_fun_new_amount,b.hi_fun_new_pv,
b.mall_amount,b.mall_pv,b.mall_new_amount,b.mall_new_pv,
b.register_blo_new_pv,b.upgrade_blo_new_pv,b.repurchase_blo_new_pv,b.hi_fun_blo_new_pv,b.mall_blo_new_pv,
b.r_a_balance,b.r_b_balance,b.r_a_sum_amount,b.r_b_sum_amount,b.r_a_sum_pv,b.r_b_sum_pv,
b.r_a_sum_real_amount,b.r_b_sum_real_amount,b.r_a_sum_real_pv,b.r_b_sum_real_pv,
b.r_rep_a_balance,b.r_rep_b_balance,b.r_rep_a_sum_amount,b.r_rep_b_sum_amount,
b.r_rep_a_sum_pv,b.r_rep_b_sum_pv,b.pk_country)
</update>
<update id="updateCuMemberSettleInitAchieve">
update ${targetTableName} a set
a.a_balance=0,a.b_balance=0,a.a_sum_amount=0,a.b_sum_amount=0,
a.a_sum_pv=0,a.b_sum_pv=0,a.a_new_amount=0,a.b_new_amount=0,
a.a_new_pv=0,a.b_new_pv=0,a.a_sum_real_amount=0,a.b_sum_real_amount=0,
a.a_sum_real_pv=0,a.b_sum_real_pv=0,a.rep_a_balance=0,a.rep_b_balance=0,
a.rep_a_new_amount=0,a.rep_b_new_amount=0,a.rep_a_new_pv=0,a.rep_b_new_pv=0,
a.rep_a_sum_amount=0,a.rep_b_sum_amount=0,a.rep_a_sum_pv=0,a.rep_b_sum_pv=0,
a.register_amount=0,a.register_pv=0,a.register_new_amount=0,a.register_new_pv=0,
a.upgrade_amount=0,a.upgrade_pv=0,a.upgrade_new_amount=0,a.upgrade_new_pv=0,
a.repurchase_amount=0,a.repurchase_pv=0,a.repurchase_new_amount=0,a.repurchase_new_pv=0,
a.hi_fun_amount=0,a.hi_fun_pv=0,a.hi_fun_new_amount=0,a.hi_fun_new_pv=0,
a.mall_amount=0,a.mall_pv=0,a.mall_new_amount=0,a.mall_new_pv=0,
a.register_blo_new_pv=0,a.upgrade_blo_new_pv=0,a.repurchase_blo_new_pv=0,
a.hi_fun_blo_new_pv=0,a.mall_blo_new_pv=0,
a.net_first_achieve=0,a.net_repurchase_achieve=0,
a.min_achieve=0,a.round=0,a.second=1,a.r_a_balance=0,a.r_b_balance=0,
a.r_a_sum_amount = 0,a.r_b_sum_amount = 0,a.r_a_sum_pv = 0,a.r_b_sum_pv = 0,
a.r_rep_a_sum_amount = 0,a.r_rep_b_sum_amount = 0,a.r_rep_a_sum_pv = 0,
a.r_rep_b_sum_pv = 0,a.r_a_sum_real_amount = 0,a.r_b_sum_real_amount = 0,
a.r_a_sum_real_pv = 0,a.r_b_sum_real_pv = 0,a.r_rep_a_balance=0,a.r_rep_b_balance=0
</update>
<update id="updateCuMemberAchieve">
merge into ${tableName} a
using(select #{period} period, a.*
from (select user_id pk_member,
sum(CURR_DAY_MAIN_REG_AMOUNT) REGISTER_AMOUNT,
sum(CURR_DAY_MAIN_REG_PV) REGISTER_PV,
sum(CURR_DAY_MAIN_UP_AMOUNT) UPGRADE_AMOUNT,
sum(CURR_DAY_MAIN_UP_PV) UPGRADE_PV,
sum(CURR_DAY_MAIN_REPUR_AMOUNT) REPURCHASE_AMOUNT,
sum(CURR_DAY_MAIN_REPURCHASE_PV) REPURCHASE_PV,
sum(CURR_DAY_SEA2_REG_AMOUNT) HI_FUN_AMOUNT,
sum(CURR_DAY_SEA2_REG_PV) HI_FUN_PV,
sum(CURR_DAY_MALL_AMOUNT) MALL_AMOUNT,
sum(CURR_DAY_MALL_PV) MALL_PV
from G_MEMBER_ACHIV@link_test
where period between - 729 and #{period}
group by user_id) a) b on
(a.pk_member = b.pk_member and a.period = b.period)
when matched then update set a.REGISTER_AMOUNT = b.REGISTER_AMOUNT,
a.REGISTER_PV = b.REGISTER_PV, a.UPGRADE_AMOUNT = b.UPGRADE_AMOUNT,
a.UPGRADE_PV = b.UPGRADE_PV, a.REPURCHASE_AMOUNT = b.REPURCHASE_AMOUNT,
a.REPURCHASE_PV = b.REPURCHASE_PV, a.HI_FUN_AMOUNT = b.HI_FUN_AMOUNT,
a.HI_FUN_PV = b.HI_FUN_PV, a.MALL_AMOUNT = b.MALL_AMOUNT, a.MALL_PV = b.MALL_PV
</update>
<update id="createCuMemberMonthTable">
create table ${tableName}
(
@ -644,68 +286,7 @@
a.r_a_sum_real_pv = a.r_a_sum_real_pv - b.a_new_pv - b.rep_a_new_pv,
a.r_b_sum_real_pv = a.r_b_sum_real_pv - b.b_new_pv - b.rep_b_new_pv
</update>
<update id="updateCuMemberNetAchieve">
merge into ${tableName} a
using (
<foreach collection="updMemberAchieveExtList" item="achieve" open=" " separator=" union " close=" ">
select #{achieve.pkMember} pk_member,
#{achieve.aSumRealPv} a_sum_real_pv,#{achieve.bSumRealPv} b_sum_real_pv,
#{achieve.repANewPv} rep_a_sum_pv,#{achieve.repBNewPv} rep_b_sum_pv,
#{achieve.netFirstAchieve} net_first_achieve,#{achieve.netRepurchaseAchieve} net_repurchase_achieve
from dual
</foreach>
) b
on (a.pk_member = b.pk_member)
when matched then
update set
a.a_sum_real_pv=a.a_sum_real_pv+b.a_sum_real_pv,
a.b_sum_real_pv=a.b_sum_real_pv+b.b_sum_real_pv,
a.rep_a_new_pv=b.rep_a_sum_pv,a.rep_b_new_pv=b.rep_b_sum_pv,
a.net_first_achieve=a.net_first_achieve+b.net_first_achieve,
a.net_repurchase_achieve=a.net_repurchase_achieve+b.net_repurchase_achieve
</update>
<update id="mergeCuMemberSettleByAchieveLogByDate">
merge into ${targetTable} a
using(select a.pk_member,(a.a_sum_real_pv - b.a_sum_real_pv) a_sum_real_pv,
(a.b_sum_real_pv - b.b_sum_real_pv) b_sum_real_pv,
(a.a_sum_pv - b.a_sum_pv) a_sum_pv,
(a.b_sum_pv - b.b_sum_pv) b_sum_pv,
(case when a.a_balance - b.a_balance &lt;0 then 0 else a.a_balance - b.a_balance end) a_balance,
(case when a.b_balance - b.b_balance &lt;0 then 0 else a.b_balance - b.b_balance end) b_balance,
(a.rep_a_sum_pv - b.rep_a_sum_pv) rep_a_sum_pv,
(a.rep_b_sum_pv - b.rep_b_sum_pv) rep_b_sum_pv,
(case when a.rep_a_balance - b.rep_a_balance&lt;0 then 0 else a.rep_a_balance - b.rep_a_balance end) rep_a_balance,
(case when a.rep_b_balance - b.rep_b_balance&lt;0 then 0 else a.rep_b_balance - b.rep_b_balance end) rep_b_balance
from ${targetTable} a
inner join(
select pk_member,sum(a_sum_real_pv) a_sum_real_pv,sum(B_SUM_REAL_PV) B_SUM_REAL_PV,sum(A_SUM_PV) A_SUM_PV,
sum(B_SUM_PV) B_SUM_PV,sum(A_BALANCE) A_BALANCE,sum(B_BALANCE) B_BALANCE,sum(REP_A_SUM_PV) REP_A_SUM_PV,
sum(REP_B_SUM_PV) REP_B_SUM_PV,sum(REP_A_BALANCE) REP_A_BALANCE,sum(REP_B_BALANCE) REP_B_BALANCE from(
select pk_id,pk_member,pk_country,
(case infusing_water_type when 1 then a_sum_real_modify_pv when 2 then -a_sum_real_modify_pv else a_sum_real_modify_pv-a_sum_real_pv end) a_sum_real_pv,
(case infusing_water_type when 1 then B_SUM_REAL_MODIFY_PV when 2 then -B_SUM_REAL_MODIFY_PV else B_SUM_REAL_MODIFY_PV-B_SUM_REAL_PV end) B_SUM_REAL_PV,
(case infusing_water_type when 1 then A_FIRST_MODIFY_PV when 2 then -A_FIRST_MODIFY_PV else A_FIRST_MODIFY_PV-A_SUM_PV end) A_SUM_PV,
(case infusing_water_type when 1 then B_FIRST_MODIFY_PV when 2 then -B_FIRST_MODIFY_PV else B_FIRST_MODIFY_PV-B_SUM_PV end) B_SUM_PV,
(case infusing_water_type when 1 then REP_A_FIRST_MODIFY_BALANCE when 2 then -REP_A_FIRST_MODIFY_BALANCE else REP_A_FIRST_MODIFY_BALANCE-A_BALANCE end) A_BALANCE,
(case infusing_water_type when 1 then REP_B_FIRST_MODIFY_BALANCE when 2 then -REP_B_FIRST_MODIFY_BALANCE else REP_B_FIRST_MODIFY_BALANCE-B_BALANCE end) B_BALANCE,
(case infusing_water_type when 1 then REP_A_MODIFY_SUM_PV when 2 then -REP_A_MODIFY_SUM_PV else REP_A_MODIFY_SUM_PV-REP_A_SUM_PV end) REP_A_SUM_PV,
(case infusing_water_type when 1 then REP_B_MODIFY_SUM_PV when 2 then -REP_B_MODIFY_SUM_PV else REP_B_MODIFY_SUM_PV-REP_B_SUM_PV end) REP_B_SUM_PV,
(case infusing_water_type when 1 then REP_A_MODIFY_BALANCE when 2 then -REP_A_MODIFY_BALANCE else REP_A_MODIFY_BALANCE-REP_A_BALANCE end) REP_A_BALANCE,
(case infusing_water_type when 1 then REP_B_MODIFY_BALANCE when 2 then -REP_B_MODIFY_BALANCE else REP_B_MODIFY_BALANCE-REP_B_BALANCE end) REP_B_BALANCE
from cu_member_achieve_log
where creation_time >=to_date('2024-02-23','yyyy-mm-dd')
and APPROVE_STATUS=5 and del_flag=0
and due_date=#{settleDate,jdbcType=DATE}
)
group by pk_member
) b
on b.pk_member=a.pk_member)b
on (a.pk_member = b.pk_member)
when matched then
update set a.a_sum_real_pv = b.a_sum_real_pv, a.b_sum_real_pv=b.b_sum_real_pv,a.a_sum_pv=b.a_sum_pv,a.b_sum_pv=b.b_sum_pv,
a.a_balance=b.a_balance,a.b_balance=b.b_balance,a.rep_a_sum_pv=b.rep_a_sum_pv,a.rep_b_sum_pv=b.rep_b_sum_pv,
a.rep_a_balance=b.rep_a_balance,a.rep_b_balance=b.rep_b_balance
</update>
<update id="updateCuMemberExpandSettleAchieveByBeforeDay">
merge into ${targetTable} a
using(select pk_member,a_balance,b_balance,min_achieve,round,second from ${sourceTable}) b
@ -716,276 +297,4 @@
a.min_achieve=b.min_achieve,a.round=b.round,a.second=b.second
</update>
<select id="queryCuMemberAchieveByPkMember" resultMap="CuMemberAchieve">
SELECT PK_MEMBER,PK_RATE,A_BALANCE,B_BALANCE,A_SUM_PV,B_SUM_PV,A_SUM_REAL_PV,B_SUM_REAL_PV,
REP_A_BALANCE,REP_B_BALANCE,REP_A_NEW_PV,REP_B_NEW_PV,REP_A_SUM_PV,REP_B_SUM_PV,PK_COUNTRY
FROM ${tableName}
WHERE (pk_member = #{pkMember} AND pk_country = #{pkCountry})
</select>
<select id="queryCuMemberUnderBloodAchieveByPkMember" resultType="java.math.BigDecimal">
select sum(REGISTER_PV+UPGRADE_PV+REPURCHASE_PV+HI_FUN_PV+MALL_PV) pv from ${achieveTable}
where pk_member in(
select pk_member
from ${treeTable}
where pk_member != #{pkMember}
start with pk_member = #{pkMember}
connect by pk_parent = prior pk_member) and period >= #{period}
</select>
<select id="selectNewAddAchieve" resultType="com.hzs.bonus.achieve.vo.CuMemberNewAddAchieveVO">
select t.*, s.settle_date
from (select a.period,
a.a_new_pv aNewPv,
a.b_new_pv bNewPv,
a.rep_a_new_pv repANewPv,
a.rep_b_new_pv repBNewPv
from ${achieveTableName} a
where a.pk_member = #{pkMember}
and a.pk_country = #{pkCountry}
<if test="upAchieveTableName != null and upAchieveTableName != ''">
union all
select up.period,
up.a_new_pv aNewPv,
up.b_new_pv bNewPv,
up.rep_a_new_pv repANewPv,
up.rep_b_new_pv repBNewPv
from ${upAchieveTableName} up
where up.pk_member = #{pkMember}
and up.pk_country = #{pkCountry}
</if>
) t,
cu_member_settle_period s
where t.period = s.pk_id
and s.del_flag = 0
and s.settle_date >= to_date(#{startDate}, 'yyyy-mm-dd')
and s.settle_date &lt;= to_date(#{endDate}, 'yyyy-mm-dd')
order by s.settle_date
</select>
<select id="selectAwardsByPkMember" resultType="com.hzs.bonus.achieve.vo.CuMemberAwardsUnderVO">
select s.pk_member,
s.a_sum_real_pv aSumRealPv,
s.b_sum_real_pv bSumRealPv,
s.member_name memberName,
s.pk_awards pkAwards
from ${settleTable} s
where s.pay_status = 1
and s.category = 0
and s.pk_country = #{pkCountry}
and s.pk_member = #{pkMember}
</select>
<select id="selectUnderMemberAwards" resultType="com.hzs.bonus.achieve.vo.CuMemberAwardsUnderVO">
select pk_member,
a_sum_real_pv aSumRealPv,
b_sum_real_pv bSumRealPv,
head_path memberPath,
member_name memberName,
pk_awards pkAwards
from (select a.pk_member,
b.pk_awards,
a.a_sum_real_pv,
a.b_sum_real_pv,
b.head_path,
a.member_name
from ${settleTable} a
inner join (select mt.pk_id,
mt.pk_place_parent,
mt.pk_awards,
mt.head_path
from (select m.pk_id,
m.pk_place_parent,
m.place_dept,
m.pk_awards,
m.head_path
from cu_member m
where m.del_flag = 0
and m.pk_settle_country = #{pkCountry} ) mt
start with mt.pk_id =
(select t.pk_id
from cu_member t
where t.category = 0
and t.del_flag = 0
and t.pk_settle_country = #{pkCountry}
and t.pk_place_parent = #{pkMember}
and t.place_dept = #{placeDept})
connect by prior mt.pk_id = mt.pk_place_parent) b
on a.pk_member = b.pk_id
where a.pk_country = #{pkCountry}
and a.pay_status = 1
and a.category = 0
order by b.pk_awards desc, a.a_sum_real_pv desc) tt
where rownum &lt;= 5
</select>
<select id="selectNewAddAchieveContrast" resultType="com.hzs.bonus.achieve.vo.CuMemberMonthAchieveContrastVO">
select sum(a.a_new_pv + a.rep_a_new_pv)/10000 aNewPv, sum(a.b_new_pv + a.rep_b_new_pv)/10000 bNewPv
from ${achieveTable} a
where a.pk_member = #{pkMember}
and a.pk_country = #{pkCountry}
</select>
<select id="selectExistTable" resultType="Integer">
select count(1) from user_tables t where t.table_name=upper('${achieveTable}')
</select>
<select id="selectByParent" resultType="decimal">
select sum(a.REGISTER_PV) registerPv
from ${achieveTable} a
where
a.pk_country = #{pkCountry}
<if test="memberIds != null">
and a.PK_MEMBER in
<foreach item="pkMember" collection="memberIds" open="(" separator="," close=")">
#{pkMember}
</foreach>
</if>
group by a.PK_MEMBER
order by registerPv desc
</select>
<select id="queryMemberMonthAchieve" resultType="com.hzs.common.domain.member.achieve.ext.CuMemberAchieveExt">
select * from(
<foreach collection="monthList" item="item" separator=" union ">
select ${item} month,bc.out_exchange_rate,cm.pk_settle_country,member_name,bg.pk_transaction pk_grade,ba.pk_transaction pk_awards,
cm.A_SUM_PV,cm.B_SUM_PV,cm.REP_A_SUM_PV,cm.REP_B_SUM_PV,nvl((a.REGISTER_PV+a.UPGRADE_PV), 0) firstAchieve,
nvl((a.REPURCHASE_PV+a.HI_FUN_PV+a.MALL_PV), 0) repurchaseAchieve from cu_member_month${item} cm
inner join(
select #{pkMember} pk_member,sum(REGISTER_PV) REGISTER_PV,
sum(UPGRADE_PV) UPGRADE_PV,
sum(REPURCHASE_PV) REPURCHASE_PV,
sum(HI_FUN_PV) HI_FUN_PV,
sum(MALL_PV) MALL_PV from cu_member_month${item}
start with pk_parent = #{pkMember}
connect by pk_parent = prior pk_member)a
on cm.pk_member = a.pk_member
left join bd_grade bg
on bg.pk_id=cm.pk_grade
left join bd_awards ba
on ba.pk_id=cm.pk_awards
left join bd_currency bc
on bc.pk_country = cm.pk_settle_country
</foreach>)
order by month desc
</select>
<select id="queryMemberMonthAchieveDetail" resultType="com.hzs.common.domain.member.achieve.ext.CuMemberAchieveExt">
select * from(
<foreach collection="memberList" item="item" separator=" union ">
select bc.out_exchange_rate,cm.pk_settle_country,cm.member_code,member_name,bg.pk_transaction pk_grade,
cm.pk_grade grade,ba.pk_transaction pk_awards,cm.pk_awards awards,
cm.A_SUM_PV,cm.B_SUM_PV,cm.REP_A_SUM_PV,cm.REP_B_SUM_PV,(a.REGISTER_PV+a.UPGRADE_PV) firstAchieve,
(a.REPURCHASE_PV+a.HI_FUN_PV+a.MALL_PV) repurchaseAchieve from cu_member_month${monthAchieveParam.month} cm
inner join(
select #{item} pk_member,sum(REGISTER_PV) REGISTER_PV,
sum(UPGRADE_PV) UPGRADE_PV,
sum(REPURCHASE_PV) REPURCHASE_PV,
sum(HI_FUN_PV) HI_FUN_PV,
sum(MALL_PV) MALL_PV from cu_member_month${monthAchieveParam.month}
start with pk_member = #{item}
connect by pk_parent = prior pk_member)a
on cm.pk_member = a.pk_member
left join bd_grade bg
on bg.pk_id=cm.pk_grade
left join bd_awards ba
on ba.pk_id=cm.pk_awards
left join bd_currency bc
on bc.pk_country = cm.pk_settle_country
</foreach>
) a
where 1=1
<if test="monthAchieveParam.memberCode != null and monthAchieveParam.memberCode != ''">
and a.member_code = #{monthAchieveParam.memberCode}
</if>
<if test="monthAchieveParam.memberName != null and monthAchieveParam.memberName != ''">
and a.member_name = #{monthAchieveParam.memberName}
</if>
<if test="monthAchieveParam.pkGrade != null">
and a.grade = #{monthAchieveParam.pkGrade}
</if>
<if test="monthAchieveParam.pkAwards != null">
and a.awards = #{monthAchieveParam.pkAwards}
</if>
</select>
<select id="queryPkMemberMonthAchieve" resultType="java.lang.Long">
select pk_member from cu_member_month${month}
where pk_parent = #{pkMember}
</select>
<select id="queryPlaceParentMemberMonthAchieve" resultType="com.hzs.common.domain.member.achieve.ext.CuMemberAchieveExt">
select so.pk_member,so.order_type,cm.member_code,cm.member_name,
so.order_achieve,bc.out_exchange_rate,bg.pk_transaction pk_grade,
cm.pk_grade grade,ba.pk_transaction pk_awards,cm.pk_awards awards,cm.pk_settle_country from sa_order so
inner join(
select pk_member,member_code,member_name,PK_GRADE,PK_AWARDS,pk_settle_country from cu_member_month${month}
start with pk_place_parent = #{pkMember} and place_dept=#{placeDept}
connect by pk_place_parent = prior pk_member) cm
on so.pk_member=cm.pk_member
left join bd_grade bg
on bg.pk_id=cm.pk_grade
left join bd_awards ba
on ba.pk_id=cm.pk_awards
left join bd_currency bc
on bc.pk_country = cm.pk_settle_country
where so.del_flag=0 and so.order_status=1 and so.pay_time >= #{startDate, jdbcType=DATE}
and so.pay_time &lt; #{endDate, jdbcType=DATE}
<if test="memberCode != null and memberCode != ''">
and cm.member_code = #{memberCode}
</if>
<if test="memberName != null and memberName != ''">
and cm.member_name = #{memberName}
</if>
<if test="pk_grade != null">
and cm.PK_GRADE = #{pk_grade}
</if>
<if test="pk_awards != null">
and cm.PK_AWARDS = #{pk_awards}
</if>
order by so.creation_time desc
</select>
<select id="queryParentMemberMonthAchieve" resultType="com.hzs.common.domain.member.achieve.ext.CuMemberAchieveExt">
select so.pk_member,so.order_type,cm.member_code,cm.member_name,
so.order_achieve,bc.out_exchange_rate,bg.pk_transaction pk_grade,
cm.pk_grade grade,ba.pk_transaction pk_awards,cm.pk_awards awards,cm.pk_settle_country from sa_order so
inner join(
select pk_member,member_code,member_name,PK_GRADE,PK_AWARDS,pk_settle_country from cu_member_month${month}
start with pk_parent = #{pkMember}
connect by pk_parent = prior pk_member) cm
on so.pk_member=cm.pk_member
left join bd_grade bg
on bg.pk_id=cm.pk_grade
left join bd_awards ba
on ba.pk_id=cm.pk_awards
left join bd_currency bc
on bc.pk_country = cm.pk_settle_country
where so.del_flag=0 and so.order_status=1 and so.pay_time >= #{startDate, jdbcType=DATE}
and so.pay_time &lt; #{endDate, jdbcType=DATE}
<if test="memberCode != null and memberCode != ''">
and cm.member_code = #{memberCode}
</if>
<if test="memberName != null and memberName != ''">
and cm.member_name = #{memberName}
</if>
<if test="pk_grade != null">
and cm.PK_GRADE = #{pk_grade}
</if>
<if test="pk_awards != null">
and cm.PK_AWARDS = #{pk_awards}
</if>
order by so.creation_time desc
</select>
<select id="queryCuMemberMonthAchieveByMemberIdList" resultMap="CuMemberAchieve">
select pk_member,pk_country,register_blo_new_pv,upgrade_blo_new_pv,repurchase_blo_new_pv from ${settleTableName}
where pk_member in
<foreach collection="memberSwingNetExtList" item="item" open="(" close=")" separator=",">
#{item.pkSourceMember}
</foreach>
</select>
</mapper>

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

@ -65,7 +65,7 @@
team_box_num=0,
month_box_num=0,
team_new_box_num=0,
pk_share_awards=12,
pk_share_awards=(select pk_id from BD_AWARDS where awards_value = 0),
consume_pv=0,
month_consume_pv=0,
new_consume_pv=0,
@ -78,8 +78,7 @@
team_new_pv=0,
recommend_num=0,
team_num=0,
pk_grade=
(select pk_id from bd_grade where del_flag = 0 and grade_value = 20),
pk_grade= (select pk_id from bd_grade where del_flag = 0 and grade_value = 20),
region_address=0,
big_box_num=0,
small_box_num=0,
@ -277,27 +276,70 @@
<select id="queryCuMemberRetailRangeParent" resultMap="CuMemberRetailRangeExt">
<foreach collection="saOrderExtList" item="item" close=" " open=" " separator="union">
select a.pk_member,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.income_status,a.consume_pv,a.pay_time,a.pk_rate,a.system_type,
a.income_status,a.pk_country,a.pk_settle_country,a.pk_share_awards,a.enable_status,
consume_box_num,new_box_num,team_box_num,month_box_num,team_new_box_num,
consume_pv,month_consume_pv,new_consume_pv,team_consume_amount,team_consume_pv,
team_month_amount,team_month_pv,team_new_amount,team_new_pv,recommend_num,team_num,
pk_grade,ba.grade_value,ba.grade_name,bw.awards_value,bw.awards_name,bwa.awards_value share_awards_value,
a.big_box_num,a.small_box_num,a.big_team_pv,a.small_team_pv,
bw.range_ratio,bw.benefit_avg_ratio,bw.benefit_share_ratio,br.name country_name from(
select
a.pk_member,
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.income_status,
a.consume_pv,
a.pay_time,
a.pk_rate,
a.system_type,
a.income_status,
a.pk_country,
a.pk_settle_country,
a.pk_share_awards,
a.enable_status,
consume_box_num,
new_box_num,
team_box_num,
month_box_num,
team_new_box_num,
consume_pv,
month_consume_pv,
new_consume_pv,
team_consume_amount,
team_consume_pv,
team_month_amount,
team_month_pv,
team_new_amount,
team_new_pv,
recommend_num,
team_num,
pk_grade,
ba.grade_value,
ba.grade_name,
bw.awards_value,
bw.awards_name,
bwa.awards_value share_awards_value,
a.big_box_num,
a.small_box_num,
a.big_team_pv,
a.small_team_pv,
bw.range_ratio,
bw.benefit_avg_ratio,
bw.benefit_share_ratio,
br.name country_name
from (
select * from ${tableName}
start with pk_member = #{item}
connect by pk_member = prior pk_parent) a
connect by pk_member = prior pk_parent
) a
inner join bd_grade ba
on a.pk_grade=ba.pk_id
on a.pk_grade = ba.pk_id
inner join bd_awards bw
on bw.pk_id=a.pk_awards
on bw.pk_id = a.pk_awards
left join bd_awards bwa
on bwa.pk_id=a.pk_share_awards and bwa.del_flag=0
on bwa.pk_id = a.pk_share_awards and bwa.del_flag = 0
left join bd_area br
on br.pk_id=a.region_address and br.del_flag=0
where ba.del_flag=0 and bw.del_flag=0
on br.pk_id = a.region_address and br.del_flag = 0
where ba.del_flag = 0 and bw.del_flag = 0
</foreach>
</select>

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

File diff suppressed because it is too large Load Diff

14
bd-business/bd-business-bonus/src/main/resources/mapper/bonus/base/CuMemberMapper.xml
View File

@ -294,9 +294,9 @@
merge into cu_member a
using (select pk_member, max(old_level) pk_awards from cu_member_awards ca
inner join cu_member cm
on ca.pk_member=cm.pk_id
on ca.pk_member = cm.pk_id
where ca.period = #{period} and ca.up_type = 1
and award_type=#{awardType}
and award_type = #{awardType}
<if test="awardType == 1">
and cm.pk_awards &lt; ca.new_level
</if>
@ -349,16 +349,18 @@
a.modified_time = sysdate
</update>
<!-- 初始化会员奖衔 -->
<update id="updateCuMemberRetailRangeInitAward">
update cu_member
set pk_awards=(select pk_id from bd_awards where awards_value = 0)
, pk_range_awards=(select pk_id from bd_awards where awards_value = 0)
set pk_awards = (select pk_id from bd_awards where awards_value = 0),
pk_range_awards = (select pk_id from bd_awards where awards_value = 0)
</update>
<!-- 初始化会员V5奖衔 -->
<update id="updateCuMemberRetailRangeInitV5Award">
update cu_member
set pk_awards=(select pk_id from bd_awards where awards_value = 5)
, pk_range_awards=(select pk_id from bd_awards where awards_value = 5)
set pk_awards=(select pk_id from bd_awards where awards_value = 5),
pk_range_awards=(select pk_id from bd_awards where awards_value = 5)
where pk_settle_grade = (
select pk_id
from bd_grade

1
bd-business/bd-business-bonus/src/main/resources/mapper/bonus/detail/CuMemberAwardsMapper.xml
View File

@ -176,6 +176,7 @@
update set a.pk_awards=b.old_level
</update>
<!-- 删除自动升级的奖衔升级记录 -->
<delete id="deleteCuMemberAwards">
delete
from cu_member_awards

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

@ -121,7 +121,6 @@
<result column="IS_MAKER_GIFT" property="isMakerGift"/>
<result column="EDIT_FLAG" property="editFlag"/>
<result column="WARES_CODE" property="waresCode"/>
<result column="MAKER_INCOME" property="makerIncome"/>
<result column="ITEM_PK_STOREHOUSE" property="pkStorehouse"/>
</collection>
</resultMap>
@ -133,25 +132,33 @@
so.pk_member,
so.order_code,
so.order_type,
so.pk_rate, so.rec_province,so.rec_city,so.rec_county,
so.pk_rate,
so.rec_province,
so.rec_city,
so.rec_county,
so.order_amount,
so.order_achieve,
so.order_ass_achieve,
so.upload_achieve,
so.pk_reference,
so.pk_vertex,
so.pk_country,so.del_flag,
so.pay_time,so.pk_creator,so.consume_amount,
so.pk_country,
so.del_flag,
so.pay_time,
so.pk_creator,
so.consume_amount,
so.box_num,
nvl(st.pk_id,0) items_id,
nvl(st.pk_order,0) pk_order,
nvl(st.pk_wares,0) pk_wares,
nvl(st.wares_price,0) wares_price,nvl(bw.wares_code,'~') wares_code,
nvl(st.wares_price,0) wares_price,
nvl(bw.wares_code,'~') wares_code,
nvl(st.wares_quantity,0) wares_quantity
from sa_order so
left join sa_order_wares st
on so.pk_id = st.pk_order and st.wares_price >0
left join bd_wares bw
on bw.pk_id=st.pk_wares and bw.del_flag=0
on bw.pk_id = st.pk_wares and bw.del_flag = 0
where so.order_status = 1
<if test="orderCode != null and orderCode != ''">
and so.order_code=#{orderCode}
@ -171,7 +178,10 @@
so.pk_member,
so.order_code,
so.order_type,
so.pk_rate, so.rec_province,so.rec_city,so.rec_county,
so.pk_rate,
so.rec_province,
so.rec_city,
so.rec_county,
so.order_amount,
so.order_achieve,
so.order_ass_achieve,
@ -180,7 +190,11 @@
so.pk_reference,
so.pk_vertex,
so.pk_country,
so.pay_time,nvl(so.order_type_extend,0) order_type_extend,so.pk_creator,so.consume_amount,
so.pay_time,
nvl(so.order_type_extend,0) order_type_extend,
so.pk_creator,
so.consume_amount,
so.box_num,
st.pk_id items_id,
st.pk_order,
st.pk_product,
@ -199,8 +213,8 @@
st.is_maker_gift,
0 channel,
sb.pk_order pk_bonus_order,
sd.pk_maker_member maker_space_member,
bt.bonus_value pk_bonus_items,bw.wares_code,nvl(bet.maker_income,0) maker_income
bt.bonus_value pk_bonus_items,
bw.wares_code
from sa_order so
inner join sa_order_items st
on so.pk_id = st.pk_order
@ -209,18 +223,16 @@
left join bd_bonus_items bt
on bt.pk_id = sb.pk_bonus_items and bt.del_flag=0
left join bd_wares bw
on bw.pk_id=st.pk_wares and bw.del_flag=0
on bw.pk_id = st.pk_wares and bw.del_flag=0
left join bd_wares_extend bet
on bet.pk_wares=bw.pk_id and bet.del_flag=0
left join sa_cabin_card_detail sd
on sd.pk_order=so.pk_id and sd.del_flag=0
on bet.pk_wares = bw.pk_id and bet.del_flag=0
where so.order_status = 1
<if test="orderCode != null and orderCode != ''">
and so.order_code=#{orderCode}
</if>
and so.pay_time >= #{startDate}
and so.pay_time &lt; #{endDate}
and so.order_type not in(41,42,43,44)
and so.order_type not in (41, 42, 43, 44)
) od
left join bd_currency bc
on od.pk_rate = bc.pk_id

2
bd-business/bd-business-sale/src/main/java/com/hzs/retail/sale/controller/service/impl/RetailOrderServiceImpl.java
View File

@ -978,7 +978,7 @@ public class RetailOrderServiceImpl implements IRetailOrderService {
//// // 会员激活状态为空，按未激活处理
//// cuMember.setIsActivate(EYesNo.NO.getIntValue());
//
// // TODO new 暂时不处理激活，只要是会员就按激活处理，有订单就有支付状态和时间
// // new 暂时不处理激活，只要是会员就按激活处理，有订单就有支付状态和时间
// cuMember.setIsActivate(EYesNo.YES.getIntValue());
// if (null != saOrder) {
// cuMember.setPayTime(saOrder.getPayTime());

9
bd-business/bd-business-sale/src/main/java/com/hzs/sale/order/mapper/SaOrderMapper.java
View File

@ -32,15 +32,6 @@ public interface SaOrderMapper extends BaseMapper<SaOrder> {
**/
void updateSaOrderByMember(@Param("memberList") List<Long> memberList, @Param("pkApprove") Long pkApprove, @Param("currentDateTime") Date currentDateTime);
/**
* 查询时间范围内的订单，需要查询出del_flag = 1的值
*
* @param startDate 开始时间
* @param endDate 结束时间
*/
List<SaOrderExt> querySaOrderByTime(@Param("startDate") Date startDate, @Param("endDate") Date endDate,
@Param("orderCode") String orderCode);
/**
* 查询时间范围内的所有订单，按照订单时间排序,只能用于奖金结算

72
bd-business/bd-business-sale/src/main/java/com/hzs/sale/order/provider/SaOrderServiceProvider.java
View File

@ -45,12 +45,6 @@ public class SaOrderServiceProvider implements ISaOrderServiceApi {
@Autowired
private ISaOrderService iSaOrderService;
@Override
public R<List<SaOrderExt>> querySaOrderByDay(Date startDate, Date endDate) {
List<SaOrderExt> saOrderList = iSaOrderService.querySaOrderByTime(startDate, endDate, null);
return R.ok(saOrderList);
}
@Override
public R<List<SaOrderExt>> queryRetailSaOrderByDay(Date startDate, Date endDate, String orderCode) {
return R.ok(iSaOrderService.queryRetailSaOrderByDay(startDate, endDate, orderCode));
@ -66,15 +60,6 @@ public class SaOrderServiceProvider implements ISaOrderServiceApi {
return R.ok(iSaOrderService.querySaOrderExtByPkId(pkId));
}
@Override
public R<SaOrderExt> querySaOrderByDay(Date startDate, Date endDate, String orderCode) {
List<SaOrderExt> saOrderList = iSaOrderService.querySaOrderByTime(startDate, endDate, orderCode);
if (CollectionUtil.isNotEmpty(saOrderList)) {
return R.ok(saOrderList.get(0));
}
return R.ok(null);
}
@Override
public R<List<SaOrderExt>> querySaOrderByDeliverList(List<SaDeliverItemsExt> deliverItemExtList) {
return R.ok(iSaOrderService.querySaOrderByDeliverList(deliverItemExtList));
@ -102,34 +87,6 @@ public class SaOrderServiceProvider implements ISaOrderServiceApi {
return R.ok(iSaOrderService.queryOrderSelect(param, pkCountry));
}
@Override
public R<BigDecimal> querySaOrderByOrderCode(Long pkMember, String orderCode) {
// 封装查询条件
SaOrder querySaOrder = SaOrder.builder().orderStatus(EOrderStatus.WAIT_PAY.getValue()).orderCode(orderCode).build();
// 直销订单
SaOrder saOrder = iSaOrderService.querySaleOrderByOrderCode(querySaOrder);
if (null == saOrder) {
// 表中没有则查询缓存
saOrder = redisService.getCacheObject(CacheConstants.TEMP_ORDER + pkMember + orderCode);
if (saOrder == null) {
return R.fail(TransactionUtils.getContent(SaOrderMsgConstants.ORDER_EMPTY));
}
}
// 验证可用量
OrderParam oldOrderParam = redisService.getCacheObject(CacheConstants.TEMP_PARAM + pkMember + orderCode);
if (null != oldOrderParam) {
// 待支付订单，缓存可能不存在了
String msg = iSaOrderService.validateAvailableNum(oldOrderParam, orderCode);
if (StringUtils.isNotEmpty(msg)) {
return R.fail(msg);
}
}
return R.ok(ComputeUtil.computeAdd(saOrder.getOrderAmount(), saOrder.getPostage()));
}
@Override
public R<SaOrderExt> queryOrderByCode(String orderCode, Long pkMember) {
SaOrderExt saOrder = redisService.getCacheObject(CacheConstants.TEMP_ORDER + pkMember + orderCode);
@ -140,12 +97,6 @@ public class SaOrderServiceProvider implements ISaOrderServiceApi {
return R.ok(saOrder);
}
/**
* 空单注册审核通过
*
* @param approvalBusinessResultDTO
* @return
*/
@Override
@Transactional(rollbackFor = Exception.class)
public R<Boolean> regEmptyOrderApproved(ApprovalBusinessResultDTO approvalBusinessResultDTO) {
@ -153,45 +104,22 @@ public class SaOrderServiceProvider implements ISaOrderServiceApi {
}
/**
* 空单注册审核驳回
*
* @param approvalBusinessResultDTO
* @return
*/
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean regEmptyOrderReject(ApprovalBusinessResultDTO approvalBusinessResultDTO) {
return iSaOrderService.regEmptyOrderReject(approvalBusinessResultDTO);
}
/**
* @description: 自助服务-修改收货地址
* @author: zhang jing
* @date: 2023/4/18 17:26
* @param: [saOrder]
* @return: com.hzs.common.core.domain.R<java.lang.Boolean>
**/
@Override
public R<Boolean> updateOrder(SaOrder saOrder) {
return R.ok(iSaOrderService.updateById(saOrder));
}
/**
* 根据订单ID批量查询订单以及详情
*
* @param orderIdList 订单ID列表（必传）
* @param pkCountry 所属国家（非必传）
* @return
*/
@Override
public R<List<SaOrderExt>> queryOrderListByIdList(List<Long> orderIdList, Integer pkCountry) {
return R.ok(iSaOrderService.queryOrderListByIdList(orderIdList, pkCountry));
}
/**
* 定时关单 订单三十分钟未支付自动关闭
*/
@Override
public void closeOrder() {
iSaOrderService.closeOrder();

9
bd-business/bd-business-sale/src/main/java/com/hzs/sale/order/service/ISaOrderService.java
View File

@ -33,7 +33,6 @@ public interface ISaOrderService extends IService<SaOrder> {
*/
List<CuMemberExt> queryMemberExtByCondition(CuMember cuMember);
/**
* 查找安置人伞上
*
@ -307,14 +306,6 @@ public interface ISaOrderService extends IService<SaOrder> {
*/
boolean validateLeftExistMember(Long pkPlaceParent, Integer pkCountry);
/**
* 查询时间范围内的订单，需要查询出del_flag = 1的值
*
* @param startDate 开始时间
* @param endDate 结束时间
*/
List<SaOrderExt> querySaOrderByTime(Date startDate, Date endDate, String orderCode);
/**
* 查询时间范围内的所有订单，按照订单时间排序,只能用于奖金结算
*

10
bd-business/bd-business-sale/src/main/java/com/hzs/sale/order/service/impl/SaOrderServiceImpl.java
View File

@ -1574,12 +1574,9 @@ public class SaOrderServiceImpl extends ServiceImpl<SaOrderMapper, SaOrder> impl
}
/**
* 验证第二部门是否需要验证首单
* @param pkParent 推荐人
* @param pkCountry 国家
* @Description: 验证第二部门是否需要验证首单
* @return: boolean
* @Author: sui q
* @Date: 2022/9/7 9:29
*/
@Override
public boolean validateFirstOrder(Long pkParent, Integer pkCountry) {
@ -1610,11 +1607,6 @@ public class SaOrderServiceImpl extends ServiceImpl<SaOrderMapper, SaOrder> impl
return false;
}
@Override
public List<SaOrderExt> querySaOrderByTime(Date startDate, Date endDate, String orderCode) {
return baseMapper.querySaOrderByTime(startDate, endDate, orderCode);
}
@Override
public List<SaOrderExt> queryRetailSaOrderByDay(Date startDate, Date endDate, String orderCode) {
return baseMapper.queryRetailSaOrderByDay(startDate, endDate, orderCode);

62
bd-business/bd-business-sale/src/main/resources/mapper/sale/order/SaOrderMapper.xml
View File

@ -206,68 +206,6 @@
</if>
</select>
<select id="querySaOrderByTime" resultMap="saOrderExtResultMap">
select od.*, bc.in_exchange_rate
from (
select so.pk_id,
so.pk_member,
so.order_code,
so.order_type,
so.pk_rate, so.rec_province,so.rec_city,so.rec_county,
so.order_amount,
so.order_achieve,
so.order_ass_achieve,
so.upload_achieve,
so.del_flag,
so.pk_reference,
so.pk_vertex,
so.pk_country,
so.pay_time,nvl(so.order_type_extend,0) order_type_extend,so.pk_creator,so.consume_amount,
st.pk_id items_id,
st.pk_order,
st.pk_product,
st.pk_wares,
st.price,
st.achievement,
st.quantity,
st.pk_grade,
st.pk_awards,
st.pk_wares_specs_sku,
st.pk_wares_detail,
st.wares_quantity,
st.is_gift,
st.specs_name,
st.ass_achievement,
st.is_maker_gift,
0 channel,
sb.pk_order pk_bonus_order,
sd.pk_maker_member maker_space_member,
bt.bonus_value pk_bonus_items,bw.wares_code,nvl(bet.maker_income,0) maker_income
from sa_order so
inner join sa_order_items st
on so.pk_id = st.pk_order
left join sa_order_bonus sb
on st.pk_id = sb.pk_order
left join bd_bonus_items bt
on bt.pk_id = sb.pk_bonus_items and bt.del_flag=0
left join bd_wares bw
on bw.pk_id=st.pk_wares and bw.del_flag=0
left join bd_wares_extend bet
on bet.pk_wares=bw.pk_id and bet.del_flag=0
left join sa_cabin_card_detail sd
on sd.pk_order=so.pk_id and sd.del_flag=0
where so.order_status = 1
<if test="orderCode != null and orderCode != ''">
and so.order_code=#{orderCode}
</if>
and so.pay_time >= #{startDate}
and so.pay_time &lt; #{endDate}
and so.order_type not in(41,42,43,44)
) od
left join bd_currency bc
on od.pk_rate = bc.pk_id
order by pay_time
</select>
<select id="queryRetailSaOrderByDay" resultMap="orderExtResultMap">
select od.*, bc.in_exchange_rate
from (

6
bd-business/bd-business-system/src/main/java/com/hzs/system/config/mapper/BdBonusItemsMapper.java
View File

@ -1,16 +1,10 @@
package com.hzs.system.config.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hzs.common.domain.system.config.BdBonusItems;
/**
* <p>
* 奖项配置 Mapper 接口
* </p>
*
* @author zhangjing
* @since 2022-11-09
*/
public interface BdBonusItemsMapper extends BaseMapper<BdBonusItems> {

5
bd-business/bd-business-system/src/main/java/com/hzs/system/config/provider/BonusItemsServiceProvider.java
View File

@ -87,11 +87,6 @@ public class BonusItemsServiceProvider implements IBonusItemsServiceApi {
return R.ok(bonusItemsService.queryBonusItems(pkCountry, pkBonusItems));
}
@Override
public R<BdBonusItems> queryBonusItemsByBonusValue(Integer pkCountry, Integer bonusValue) {
return R.ok(bonusItemsService.queryBonusItemsByBonusValue(pkCountry, bonusValue));
}
@Override
public R<BonusConfigDTO> queryBonusConfigDTO() {
BonusConfigDTO bonusConfigDTO = new BonusConfigDTO();

45
bd-business/bd-business-system/src/main/java/com/hzs/system/config/service/IBdBonusItemsService.java
View File

@ -1,6 +1,5 @@
package com.hzs.system.config.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hzs.common.domain.system.config.BdBonusItems;
import com.hzs.common.domain.system.config.ext.BdBonusItemsExt;
@ -8,66 +7,38 @@ import com.hzs.common.domain.system.config.ext.BdBonusItemsExt;
import java.util.List;
/**
* <p>
* 奖项配置 服务类
* </p>
*
* @author zhangjing
* @since 2022-11-09
*/
public interface IBdBonusItemsService extends IService<BdBonusItems> {
/**
* @description: 生成奖项配置
* @author: zhang jing
* @date: 2022/11/10 17:17
* @param: [bonusItems]
* @return: boolean
* 生成奖项配置
**/
boolean generate(BdBonusItems bonusItems);
/**
* @description: 根据国家查询奖项配置列表
* @author: zhang jing
* @date: 2022/11/10 17:17
* @param: [pkCountry]
* @return: java.util.List<com.hzs.common.domain.system.config.ext.BdBonusItemsExt>
* 根据国家查询奖项配置列表
**/
List<BdBonusItemsExt> queryBonusItems(Integer pkCountry);
/**
* @description: 根据国家查询奖项配置列表
* @author: zhang jing
* @date: 2022/11/10 17:17
* @param: [pkCountry]
* @return: java.util.List<com.hzs.common.domain.system.config.ext.BdBonusItemsExt>
* 根据国家查询奖项配置列表
**/
List<BdBonusItemsExt> queryCalBonusItems(Integer pkCountry);
/**
* 查询奖金项
*
* @param bonusValueList 奖金值
* @return: List<BdBonusItems>
* @Author: sui q
* @Date: 2023/3/14 10:08
*/
*/
List<BdBonusItems> queryBonusItemsByValue(List<Integer> bonusValueList);
/**
* 查询奖金项
* @param pkCountry 国家
*
* @param pkCountry 国家
* @param pkBonusItems 奖金项
* @return: BdBonusItemsExt
* @Author: sui q
* @Date: 2023/3/7 18:07
*/
*/
BdBonusItems queryBonusItems(Integer pkCountry, Integer pkBonusItems);
/*
* @description: 国家，奖金值
* @author: sui q
* @date: 2024/7/12 10:39
* @param: null null
**/
BdBonusItems queryBonusItemsByBonusValue(Integer pkCountry, Integer bonusValue);
}

80
bd-business/bd-business-system/src/main/java/com/hzs/system/config/service/impl/BdBonusItemsServiceImpl.java
View File

@ -2,75 +2,46 @@ package com.hzs.system.config.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hzs.common.core.constant.CacheConstants;
import com.hzs.common.core.constant.SystemFieldConstants;
import com.hzs.common.core.domain.R;
import com.hzs.common.core.enums.EBonusItems;
import com.hzs.common.core.enums.ETransactionKey;
import com.hzs.common.core.enums.EYesNo;
import com.hzs.common.core.service.RedisService;
import com.hzs.common.core.utils.ComputeUtil;
import com.hzs.common.core.utils.StringUtils;
import com.hzs.common.domain.system.config.BdBonusItems;
import com.hzs.common.domain.system.config.ext.BdBonusItemsExt;
import com.hzs.common.security.utils.SecurityUtils;
import com.hzs.system.base.ITransactionServiceApi;
import com.hzs.system.config.mapper.BdBonusItemsMapper;
import com.hzs.system.config.service.IBdBonusItemsService;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.*;
/**
* <p>
* 奖项配置 服务实现类
* </p>
*
* @author zhangjing
* @since 2022-11-09
*/
@Service
public class BdBonusItemsServiceImpl extends ServiceImpl<BdBonusItemsMapper, BdBonusItems> implements IBdBonusItemsService {
@DubboReference
private ITransactionServiceApi iTransactionServiceApi;
@Autowired
private RedisService redisService;
@Autowired
public void setRedisService(RedisService redisService) {
this.redisService = redisService;
}
/**
* @description: 生成奖项配置
* @author: zhang jing
* @date: 2022/11/9 19:38
* @param: [bonusItems]
* @return: boolean
**/
@Override
public boolean generate(BdBonusItems bonusItems) {
Integer pkCountry = SecurityUtils.getPkCountry();
for (EBonusItems value : EBonusItems.values()) {
bonusItems.setBonusName(value.getLabel());
bonusItems.setBonusValue(value.getValue());
//字段翻译保存到数据库
R<Integer> pkTransaction = iTransactionServiceApi.createTransaction(pkCountry, ETransactionKey.BD_BONUS_ITEMS,
value.getLabel(), EYesNo.YES, EYesNo.NO);
bonusItems.setPkTransaction(pkTransaction.getData());
bonusItems.setPkCountry(pkCountry);
bonusItems.setPkCreator(SecurityUtils.getUserId());
bonusItems.setCreationTime(new Date());
QueryWrapper<BdBonusItems> queryWrapper=new QueryWrapper();
queryWrapper.eq("BONUS_VALUE",value.getValue());
queryWrapper.eq("PK_COUNTRY",pkCountry);
BdBonusItems items= baseMapper.selectOne(queryWrapper);
if(StringUtils.isNull(items)){
LambdaQueryWrapper<BdBonusItems> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(BdBonusItems::getBonusValue, value.getValue());
queryWrapper.eq(BdBonusItems::getPkCountry, pkCountry);
BdBonusItems items = baseMapper.selectOne(queryWrapper);
if (StringUtils.isNull(items)) {
baseMapper.insert(bonusItems);
redisService.deleteObject(CacheConstants.BD_BONUS_ITEMS + SecurityUtils.getPkCountry());
}
@ -78,21 +49,14 @@ public class BdBonusItemsServiceImpl extends ServiceImpl<BdBonusItemsMapper, BdB
return true;
}
/**
* @description: 根据国家查询奖项配置列表
* @author: zhang jing
* @date: 2022/11/10 17:11
* @param: [bonusItemsExt]
* @return: java.util.List<com.hzs.common.domain.system.config.ext.BdBonusItemsExt>
**/
@Override
public List<BdBonusItemsExt> queryBonusItems(Integer pkCountry) {
List<BdBonusItemsExt> bonusItemsExtList = redisService.getCacheList(CacheConstants.BD_BONUS_ITEMS + pkCountry);
List<BdBonusItemsExt> bonusItemsExtsNew = new ArrayList<>();
if (CollectionUtil.isEmpty(bonusItemsExtList)) {
QueryWrapper<BdBonusItems> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("PK_COUNTRY", pkCountry);
queryWrapper.orderByAsc("BONUS_VALUE");
LambdaQueryWrapper<BdBonusItems> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(BdBonusItems::getPkCountry, pkCountry);
queryWrapper.orderByAsc(BdBonusItems::getBonusValue);
List<BdBonusItems> btList = baseMapper.selectList(queryWrapper);
if (CollectionUtil.isNotEmpty(btList)) {
btList.forEach(item -> bonusItemsExtsNew.add(BeanUtil.copyProperties(item, BdBonusItemsExt.class)));
@ -107,9 +71,9 @@ public class BdBonusItemsServiceImpl extends ServiceImpl<BdBonusItemsMapper, BdB
@Override
public List<BdBonusItemsExt> queryCalBonusItems(Integer pkCountry) {
List<BdBonusItemsExt> bonusItemsExtList = new ArrayList<>();
QueryWrapper<BdBonusItems> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("PK_COUNTRY", pkCountry);
queryWrapper.orderByAsc("BONUS_VALUE");
LambdaQueryWrapper<BdBonusItems> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(BdBonusItems::getPkCountry, pkCountry);
queryWrapper.orderByAsc(BdBonusItems::getBonusValue);
List<BdBonusItems> bdBonusItems = baseMapper.selectList(queryWrapper);
bdBonusItems.forEach(item -> bonusItemsExtList.add(BeanUtil.copyProperties(item, BdBonusItemsExt.class)));
return bonusItemsExtList;
@ -117,8 +81,8 @@ public class BdBonusItemsServiceImpl extends ServiceImpl<BdBonusItemsMapper, BdB
@Override
public List<BdBonusItems> queryBonusItemsByValue(List<Integer> bonusValueList) {
QueryWrapper<BdBonusItems> queryWrapper = new QueryWrapper<>();
queryWrapper.in("BONUS_VALUE", bonusValueList);
LambdaQueryWrapper<BdBonusItems> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.in(BdBonusItems::getBonusValue, bonusValueList);
return baseMapper.selectList(queryWrapper);
}
@ -138,18 +102,10 @@ public class BdBonusItemsServiceImpl extends ServiceImpl<BdBonusItemsMapper, BdB
return queryBdBonusItems(pkCountry, pkBonusItems);
}
@Override
public BdBonusItems queryBonusItemsByBonusValue(Integer pkCountry, Integer bonusValue) {
QueryWrapper<BdBonusItems> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("PK_COUNTRY", pkCountry);
queryWrapper.eq("BONUS_VALUE", bonusValue);
return baseMapper.selectOne(queryWrapper);
}
private BdBonusItems queryBdBonusItems(Integer pkCountry, Integer pkBonusItems) {
QueryWrapper<BdBonusItems> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("PK_COUNTRY", pkCountry);
queryWrapper.eq(SystemFieldConstants.PK_ID, pkBonusItems);
LambdaQueryWrapper<BdBonusItems> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(BdBonusItems::getPkCountry, pkCountry);
queryWrapper.eq(BdBonusItems::getPkId, pkBonusItems);
return baseMapper.selectOne(queryWrapper);
}
}

4
bd-common/bd-common-core/src/main/java/com/hzs/common/core/constant/TableNameConstants.java
View File

@ -31,12 +31,12 @@ public class TableNameConstants {
public static final String CU_MEMBER_SETTLE = "cu_member_settle";
/**
* 会员极差计算表
* 会员级差计算表
*/
public static final String CU_MEMBER_RANGE = "CU_MEMBER_RANGE";
/**
* 会员极差计算表
* 会员级差计算表
*/
public static final String CU_MEMBER_RETAIL_RANGE = "CU_MEMBER_RETAIL";

2
bd-common/bd-common-core/src/main/java/com/hzs/common/core/enums/EAwardsType.java
View File

@ -12,7 +12,7 @@ import lombok.Getter;
public enum EAwardsType {
/**
* 级差奖衔
* 级差奖衔（荣誉级别）
*/
RANGE_TYPE(1, "级差奖衔", 0, EnumsPrefixConstants.AWARDS_TYPE + "1"),

7
bd-common/bd-common-domain/src/main/java/com/hzs/common/domain/member/achieve/ext/CuMemberAchieveExt.java
View File

@ -8,12 +8,7 @@ import java.math.BigDecimal;
import java.util.Date;
/**
* @description: 会员业绩扩展表
* @author: sui q
* @time: 2023/8/26 10:45
* @classname: CuMemberAchieveVO
* @package_name: com.hzs.common.domain.member.achieve.ext
* version 1.0.0
* 会员业绩扩展表
*/
@EqualsAndHashCode(callSuper = true)
@Data

9
bd-common/bd-common-domain/src/main/java/com/hzs/common/domain/member/bonus/CuBonusExpand.java
View File

@ -4,7 +4,9 @@ import java.math.BigDecimal;
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.TableField;
import com.fasterxml.jackson.annotation.JsonFormat;
@ -13,12 +15,7 @@ import lombok.*;
import lombok.experimental.Accessors;
/**
* <p>
*
* </p> 4-n增加碰次设置
*
* @author hzs
* @since 2024-07-19
* 4-n增加碰次设置
*/
@Data
@EqualsAndHashCode(callSuper = true)

2
bd-common/bd-common-domain/src/main/java/com/hzs/common/domain/member/detail/CuMemberAwards.java
View File

@ -50,7 +50,7 @@ public class CuMemberAwards extends BaseEntity {
private Integer upType;
/**
* 奖衔等级(1=极差奖衔 pk_awards、2=荣誉奖衔 pk_range_awards)
* 奖衔等级(1=级差奖衔 pk_awards、2=荣誉奖衔 pk_range_awards)
*/
@TableField("AWARD_TYPE")
private Integer awardType;

5
bd-common/bd-common-domain/src/main/java/com/hzs/common/domain/sale/ext/SaOrderItemsExt.java
View File

@ -104,11 +104,6 @@ public class SaOrderItemsExt extends SaOrderItems {
*/
private String waresCode;
/**
* 发起人收益（目前复购使用）
*/
private BigDecimal makerIncome;
/**
* 会员ID
*/

9
bd-common/bd-common-domain/src/main/java/com/hzs/common/domain/system/config/BdBonusItems.java
View File

@ -14,12 +14,7 @@ import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* <p>
* 奖项配置
* </p>
*
* @author zhangjing
* @since 2022-11-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
@ -36,7 +31,7 @@ public class BdBonusItems extends BaseEntity {
/**
* 奖金名称
*/
@Excel(name = "奖金名称",sort=1)
@Excel(name = "奖金名称", sort = 1)
@TableField("BONUS_NAME")
private String bonusName;
@ -68,7 +63,7 @@ public class BdBonusItems extends BaseEntity {
/**
* 公布时间
*/
@Excel(name = "公布时间",sort=3)
@Excel(name = "公布时间", sort = 3)
@TableField("PUBLISH_TIME")
private String publishTime;