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-25 16:21:37 +08:00
parent 17d57f4ff8
commit 14cb2bc9e6
20 changed files with 192 additions and 1310 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/achieve/mapper/CuMemberRangeMapper.java
View File

@ -3,131 +3,44 @@ package com.hzs.bonus.achieve.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hzs.common.domain.member.achieve.CuMemberRange;
import com.hzs.common.domain.member.achieve.ext.CuMemberRangeExt;
import com.hzs.common.domain.member.achieve.ext.CuMemberRetailRangeExt;
import com.hzs.common.domain.sale.ext.SaOrderExt;
import org.apache.ibatis.annotations.Param;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
* <p>
* Mapper 接口
* </p>
*
* @author hzs
* @since 2024-10-15
*/
public interface CuMemberRangeMapper extends BaseMapper<CuMemberRange> {
/*
* @description: 当天的数据更新为0
* @author: sui q
* @date: 2024/10/18 11:12
* @param: null null
**/
void mergeMemberRangeInit(@Param("rangeTableName") String rangeTableName, @Param("isSameMonth") Integer isSameMonth);
/*
* @description: 免考的会员修改为考核通过
* @author: sui q
* @date: 2024/10/21 14:30
* @param: null null
**/
void updateMemberRangeByPurchase(@Param("rangeTableName") String rangeTableName);
/*
* @description: 将昨天的业绩信息迁移到今天
* @author: sui q
* @date: 2024/10/18 11:09
* @param: null null
**/
void mergeMemberRangeByYesterday(@Param("rangeTableName") String rangeTableName, @Param("yesterdayRangeTableName") String yesterdayRangeTableName,
@Param("isSameMonth") Integer isSameMonth);
/*
* @description: 更新极差秒接表，用昨天的结算表
* @author: sui q
* @date: 2024/10/22 14:23
* @param: null null
**/
void mergeMemberSecondRangeByRange(@Param("rangeTableName") String rangeTableName, @Param("secondRangeTableName") String secondRangeTableName,
@Param("pkMember") Long pkMember);
/*
* @description: 根据会员查询会员上的所有网体
* @author: sui q
* @date: 2024/10/15 15:21
* @param: null null
**/
List<CuMemberRangeExt> queryCuMemberRangeParent(@Param("tableName") String tableName, @Param("saOrderExtList") List<?> saOrderExtList);
/*
* @description: 根据会员查询会员上的所有网体, 按照pkParent作为key
* @author: sui q
* @date: 2024/10/15 15:21
* @param: null null
**/
List<CuMemberRangeExt> queryCuMemberSecondRangeParent(@Param("rangeTableName") String rangeTableName, @Param("secondTableName") String tableName, @Param("pkMember") Long pkMember);
/*
* @description: 推荐推荐人查询推荐人下的所有部门, 该订单日期之前的算他的网体
* @author: sui q
* @date: 2024/10/16 14:06
* @param: null null
* 推荐推荐人查询推荐人下的所有部门, 该订单日期之前的算他的网体
**/
List<CuMemberRangeExt> queryCuMemberRangeExtByParent(@Param("tableName") String tableName, @Param("pkParent") Long pkParent, @Param("orderDate") Date orderDate);
/*
* @description: 推荐推荐人查询推荐人下的所有部门, 该订单日期之前的算他的网体
* @author: sui q
* @date: 2024/10/16 14:06
* @param: null null
* 推荐推荐人查询推荐人下的所有部门, 该订单日期之前的算他的网体
**/
List<CuMemberRangeExt> querySecondCuMemberRangeExtByParent(@Param("tableName") String tableName, @Param("secondTableName") String secondTableName, @Param("pkParent") Long pkParent);
/*
* @description: 批量更新网体
* @author: sui q
* @date: 2024/10/16 15:10
* @param: null null
* 批量更新网体
**/
void mergeCuMemberRangeExt(@Param("rangeTableName") String rangeTableName, @Param("cuMemberRangeExtList") List<?> cuMemberRangeExtList);
/*
* @description: 批量更新网体
* @author: sui q
* @date: 2024/10/16 15:10
* @param: null null
* 批量更新网体
**/
void mergeSecondCuMemberRangeExt(@Param("secondTableName") String secondTableName, @Param("cuMemberRangeExtList") List<CuMemberRangeExt> cuMemberRangeExtList);
/**
* 更新会员树的累计业绩
*
* @param secondTableName 结算日期
* @param cuMemberRangeExtList 树
* @return: void
* @Author: sui q
* @Date: 2022/12/9 16:57
*/
void mergeCuMemberSecondRange(@Param("secondTableName") String secondTableName, @Param("cuMemberRangeExtList") List<?> cuMemberRangeExtList);
/*
* @description: 验证血缘部门 有多少个满足等级
* @author: sui q
* @date: 2024/10/16 16:02
* @param: null null
* 验证血缘部门 有多少个满足等级
**/
Integer validateCuMemberPlaceAwards(@Param("rangeTableName") String rangeTableName, @Param("cuMemberRangeExtList") List<CuMemberRangeExt> cuMemberRangeExtList,
@Param("pkRangeAwards") Integer pkRangeAwards, @Param("orderDate") Date orderDate);
/*
* @description: 验证血缘部门 有多少个满足等级
* @author: sui q
* @date: 2024/10/16 16:02
* @param: null null
* 验证血缘部门 有多少个满足等级
**/
Integer validateSecondCuMemberPlaceAwards(@Param("secondTableName") String secondTableName, @Param("cuMemberRangeExtList") List<CuMemberRangeExt> cuMemberRangeExtList,
@Param("pkRangeAwards") Integer pkRangeAwards);

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

@ -86,11 +86,6 @@ public interface CuMemberRetailRangeMapper extends BaseMapper<CuMemberRetailRang
*/
List<CuMemberRetailRangeExt> queryCuMemberRetailRangeParent(@Param("tableName") String tableName, @Param("saOrderExtList") List<?> saOrderExtList);
/**
* 根据会员查询会员上的所有网体
*/
List<CuMemberRetailRangeExt> queryCuMemberSpeRetailRangeParent(@Param("tableName") String tableName, @Param("saOrderExtList") List<?> saOrderExtList);
/**
* 推荐推荐人查询推荐人下的所有部门, 该订单日期之前的算他的网体
*/
@ -108,16 +103,6 @@ public interface CuMemberRetailRangeMapper extends BaseMapper<CuMemberRetailRang
@Param("secondTableName") String secondTableName,
@Param("pkMember") Long pkMember);
/**
* 根据会员查询会员上的所有网体, 按照pkParent作为key,查询极差秒接表,查询自己和伞下
*/
List<CuMemberRetailRangeExt> queryCuMemberSecondRange(@Param("rangeTableName") String rangeTableName, @Param("secondTableName") String secondTableName, @Param("pkMember") Long pkMember);
/**
* 根据会员查询会员上的所有网体, 按照pkParent作为key,查询极差秒接表,查询自己和伞下
*/
List<CuMemberRetailRangeExt> queryCuMemberSecondRangeYes(@Param("rangeTableName") String rangeTableName, @Param("pkMember") Long pkMember);
/**
* 秒结：推荐人查询推荐人下的所有部门, 该订单日期之前的算他的网体
*/

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

@ -99,23 +99,6 @@ public interface CuMemberTreeMapper extends BaseMapper<CuMemberTree> {
*/
Integer queryExistOrderTableCount(String tableName);
/**
* 查询出符合下一等级足够业绩的会员
*
* @param settleTableName 结算表
*/
List<CuMemberSettleExt> queryCuMemberSettleEnoughAwardAchieve(String settleTableName);
/*
* 回退会员奖衔
**/
void updateBackCuMemberSettleAward(@Param("settleTableName") String settleTableName, @Param("period") Integer period);
/*
* 回退会员奖衔
**/
void updateBackCuMemberSettleRangeAward(@Param("rangeTableName") String rangeTableName, @Param("period") Integer period);
/*
* 回退会员奖衔
**/
@ -161,30 +144,6 @@ public interface CuMemberTreeMapper extends BaseMapper<CuMemberTree> {
*/
List<CuMemberSettleExt> batchQueryMemberSettleParentByMemberPk(@Param("settleTableName") String settleTableName, @Param("memberPkList") List<?> serviceMemberSet);
/**
* 查询会员结算表，查询出结算表中会员伞下左右区满足等级
*
* @param settleTableName 结算表
* @param awardsValue 验证等级对应的值
* @param placeDept 部门
* @param pkMember 会员
*/
Integer queryCuMemberSettlePlaceUnderUmbrella(@Param("settleTableName") String settleTableName,
@Param("awardsValue") Integer awardsValue,
@Param("placeDept") Integer placeDept,
@Param("pkMember") Long pkMember);
/**
* 查询会员结算表，查询出结算表中会员血缘关系满足等级
*
* @param settleTableName 结算表
* @param pkMember 会员
*/
Integer queryCuMemberSettleBloodUnderUmbrella(@Param("settleTableName") String settleTableName,
@Param("awardsValue") Integer awardsValue,
@Param("placeDept") Integer placeDept,
@Param("pkMember") Long pkMember);
/**
* 批量根据订单信息查询会员结算表中的数据
*
@ -212,13 +171,6 @@ public interface CuMemberTreeMapper extends BaseMapper<CuMemberTree> {
List<CuMemberSettleExt> batchQueryCuMemberSettleParentForSpecial(@Param("settleTableName") String settleTableName,
@Param("pkMemberList") List<?> pkMemberList);
/**
* 更新会员网体奖衔数据，更新月表、结算表
*
* @param updateTableName 更新表名
*/
Integer updateCuMemberSettleByPeriod(@Param("updateTableName") String updateTableName, @Param("period") Integer period);
/**
* 更新会员树的累计业绩
*

114
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/achieve/service/ICuMemberRangeService.java
View File

@ -3,123 +3,43 @@ package com.hzs.bonus.achieve.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hzs.common.domain.member.achieve.CuMemberRange;
import com.hzs.common.domain.member.achieve.ext.CuMemberRangeExt;
import com.hzs.common.domain.member.achieve.ext.CuMemberRetailRangeExt;
import com.hzs.common.domain.sale.ext.SaOrderExt;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
* <p>
* 服务类
* </p>
*
* @author hzs
* @since 2024-10-15
*/
public interface ICuMemberRangeService extends IService<CuMemberRange> {
/*
* @description: 将昨天的业绩信息迁移到今天
* @author: sui q
* @date: 2024/10/18 11:09
* @param: null null
**/
void mergeMemberRangeByYesterday(String rangeTableName, String yesterdayRangeTableName, Boolean isSameMonth);
/*
* @description: 更新极差秒接表，用昨天的结算表
* @author: sui q
* @date: 2024/10/22 14:23
* @param: null null
**/
void mergeMemberSecondRangeByRange(String rangeTableName, String secondRangeTableName, Long pkMember);
/**
* 更新会员树的累计业绩
*
* @param settleTableName 结算日期
* @param cuMemberTreeMap 树
* @return: void
* @Author: sui q
* @Date: 2022/12/9 16:57
* 推荐推荐人查询推荐人下的所有部门, 该订单日期之前的算他的网体
*/
void updateCuMemberRange(String settleTableName, Map<Long, CuMemberRangeExt> cuMemberTreeMap);
/**
* 更新会员树的累计业绩
*
* @param secondTableName 结算日期
* @param cuMemberTreeMap 树
* @return: void
* @Author: sui q
* @Date: 2022/12/9 16:57
*/
void updateCuMemberSecondRange(String secondTableName, Map<Long, CuMemberRangeExt> cuMemberTreeMap);
/*
* @description: 根据会员查询会员上的所有网体, 按照pkParent作为key
* @author: sui q
* @date: 2024/10/15 15:21
* @param: null null
**/
Map<Long, List<CuMemberRangeExt>> queryCuMemberRangeParent(String tableName, List<SaOrderExt> saOrderExtList);
/*
* @description: 根据会员查询会员上的所有网体, 按照pkParent作为key,查询极差秒接表
* @author: sui q
* @date: 2024/10/15 15:21
* @param: null null
**/
Map<Long, List<CuMemberRangeExt>> queryCuMemberSecondRangeParent(String rangeTableName, String secondTableName, Long pkMember);
/*
* @description: 推荐推荐人查询推荐人下的所有部门, 该订单日期之前的算他的网体
* @author: sui q
* @date: 2024/10/16 14:06
* @param: null null
**/
List<CuMemberRangeExt> queryCuMemberRangeExtByParent(String tableName, Long pkParent, Date orderDate);
/*
* @description: 推荐推荐人查询推荐人下的所有部门, 该订单日期之前的算他的网体
* @author: sui q
* @date: 2024/10/16 14:06
* @param: null null
**/
/**
* 推荐推荐人查询推荐人下的所有部门, 该订单日期之前的算他的网体
*/
List<CuMemberRangeExt> querySecondCuMemberRangeExtByParent(String tableName, String secondTableName, Long pkParent);
/*
* @description: 批量更新网体
* @author: sui q
* @date: 2024/10/16 15:10
* @param: null null
**/
/**
* 批量更新网体
*/
void mergeCuMemberRangeExt(String rangeTableName, List<CuMemberRangeExt> cuMemberRangeExtList);
/*
* @description: 批量更新网体
* @author: sui q
* @date: 2024/10/16 15:10
* @param: null null
**/
/**
* 批量更新网体
*/
void mergeSecondCuMemberRangeExt(String secondTableName, List<CuMemberRangeExt> cuMemberRangeExtList);
/*
* @description: 验证血缘部门 有多少个满足等级
* @author: sui q
* @date: 2024/10/16 16:02
* @param: null null
**/
/**
* 验证血缘部门 有多少个满足等级
*/
Integer validateCuMemberPlaceAwards(String rangeTableName, List<CuMemberRangeExt> cuMemberRangeExtList, Integer pkRangeAwards, Date orderDate);
/*
* @description: 验证血缘部门 有多少个满足等级
* @author: sui q
* @date: 2024/10/16 16:02
* @param: null null
**/
/**
* 验证血缘部门 有多少个满足等级
*/
Integer validateSecondCuMemberPlaceAwards(String secondTableName, List<CuMemberRangeExt> cuMemberRangeExtList, Integer pkRangeAwards);
}

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

@ -3,7 +3,6 @@ package com.hzs.bonus.achieve.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hzs.common.domain.member.achieve.CuMemberRetailRange;
import com.hzs.common.domain.member.achieve.ext.CuMemberRetailRangeExt;
import com.hzs.common.domain.member.bonus.CuMemberSpeRetail;
import com.hzs.common.domain.sale.ext.SaOrderExt;
import java.math.BigDecimal;
@ -27,11 +26,6 @@ public interface ICuMemberRetailRangeService extends IService<CuMemberRetailRang
*/
List<CuMemberRetailRangeExt> queryCuMemberRetailRangeParent(String tableName, List<SaOrderExt> saOrderExtList);
/**
* 根据会员查询会员上的所有网体, 按照pkParent作为key
*/
List<CuMemberRetailRangeExt> queryCuMemberSpeRetailRangeParent(String tableName, List<CuMemberSpeRetail> memberSpeRetailList);
/**
* 推荐推荐人查询推荐人下的所有部门, 该订单日期之前的算他的网体
*/
@ -47,11 +41,6 @@ public interface ICuMemberRetailRangeService extends IService<CuMemberRetailRang
*/
List<CuMemberRetailRangeExt> queryCuMemberSecondRangeParent(String rangeTableName, String secondTableName, Long pkMember);
/**
* 根据会员查询会员上的所有网体, 按照pkParent作为key,查询极差秒接表,查询自己和伞下
*/
List<CuMemberRetailRangeExt> queryCuMemberSecondRange(String rangeTableName, String secondTableName, Long pkMember);
/**
* 推荐推荐人查询推荐人下的所有部门, 该订单日期之前的算他的网体
*/
@ -65,14 +54,6 @@ public interface ICuMemberRetailRangeService extends IService<CuMemberRetailRang
*/
void updateCuMemberRetailRange(String settleTableName, Map<Long, CuMemberRetailRangeExt> cuMemberTreeMap);
/**
* 更新会员树的累计业绩
*
* @param settleTableName 结算日期
* @param cuMemberRetailRangeExtList 树
*/
void updateCuMemberRetailRange(String settleTableName, List<CuMemberRetailRangeExt> cuMemberRetailRangeExtList);
/**
* 更新会员树的累计业绩
*

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

@ -52,23 +52,6 @@ public interface ICuMemberTreeService extends IService<CuMemberTree> {
*/
void createCuMemberTableSequence(String tableName, String tableNameSeq);
/**
* 查询出符合下一等级足够业绩的会员
*
* @param settleTableName 结算表
*/
List<CuMemberSettleExt> queryCuMemberSettleEnoughAwardAchieve(String settleTableName);
/*
* 回退会员奖衔
**/
void updateBackCuMemberSettleAward(String settleTableName, Integer period);
/*
* 回退会员奖衔
**/
void updateBackCuMemberSettleRangeAward(String rangeTableName, Integer period);
/**
* 回退会员奖衔
*/
@ -84,31 +67,6 @@ public interface ICuMemberTreeService extends IService<CuMemberTree> {
*/
void updateCuMemberRetailRangeInitAward(String rangeTableName);
/**
* 查询会员结算表，查询出结算表中会员伞下左右区满足等级
*
* @param settleTableName 结算表
* @param placeDept 部门
* @param awardsValue 奖衔对应的值
* @param pkMember 会员
*/
Boolean queryCuMemberSettlePlaceUnderUmbrella(String settleTableName, Integer awardsValue, Integer placeDept, Long pkMember);
/**
* 查询会员结算表，查询出结算表中会员血缘关系满足等级
*
* @param settleTableName 结算表
* @param pkMember 会员
*/
Boolean queryCuMemberSettleBloodUnderUmbrella(String settleTableName, Integer awardsValue, Integer placeDept, Long pkMember);
/**
* 更新会员网体奖衔数据，更新月表、结算表
*
* @param periodList 期间
*/
void updateCuMemberSettleByPeriod(List<Integer> periodList);
/**
* 根据订单，查询出网体中记录的会员数据，推荐人、安置人
*

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

@ -3,25 +3,15 @@ package com.hzs.bonus.achieve.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hzs.bonus.achieve.mapper.CuMemberRangeMapper;
import com.hzs.bonus.achieve.service.ICuMemberRangeService;
import com.hzs.common.core.constant.MagicNumberConstants;
import com.hzs.common.core.utils.ComputeUtil;
import com.hzs.common.domain.member.achieve.CuMemberRange;
import com.hzs.common.domain.member.achieve.ext.CuMemberRangeExt;
import com.hzs.common.domain.member.achieve.ext.CuMemberRetailRangeExt;
import com.hzs.common.domain.member.ext.CuMemberSettleExt;
import com.hzs.common.domain.sale.ext.SaOrderExt;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.*;
/**
* <p>
* 服务实现类
* </p>
*
* @author hzs
* @since 2024-10-15
*/
@Service
public class CuMemberRangeServiceImpl extends ServiceImpl<CuMemberRangeMapper, CuMemberRange> implements ICuMemberRangeService {
@ -29,71 +19,6 @@ public class CuMemberRangeServiceImpl extends ServiceImpl<CuMemberRangeMapper, C
@Autowired
private CuMemberBonusSettle cuMemberBonusSettle;
@Override
public void mergeMemberRangeByYesterday(String rangeTableName, String yesterdayRangeTableName, Boolean isSameMonth) {
if(isSameMonth) {
baseMapper.mergeMemberRangeInit(rangeTableName, 0);
baseMapper.mergeMemberRangeByYesterday(rangeTableName, yesterdayRangeTableName, 0);
}else{
baseMapper.mergeMemberRangeInit(rangeTableName, 1);
baseMapper.mergeMemberRangeByYesterday(rangeTableName, yesterdayRangeTableName, 1);
}
// 免考的会员修改为考核通过
baseMapper.updateMemberRangeByPurchase(rangeTableName);
}
@Override
public void mergeMemberSecondRangeByRange(String rangeTableName, String secondRangeTableName, Long pkMember) {
baseMapper.mergeMemberSecondRangeByRange(rangeTableName, secondRangeTableName, pkMember);
}
@Override
public void updateCuMemberRange(String settleTableName, Map<Long, CuMemberRangeExt> cuMemberTreeMap) {
List<List<?>> treeList = setUpdCuMemberTreeLists(cuMemberTreeMap);
treeList.forEach(list -> baseMapper.mergeCuMemberRangeExt(settleTableName, list));
}
@Override
public void updateCuMemberSecondRange(String secondTableName, Map<Long, CuMemberRangeExt> cuMemberTreeMap) {
List<List<?>> treeList = setUpdCuMemberTreeLists(cuMemberTreeMap);
treeList.forEach(list -> baseMapper.mergeCuMemberSecondRange(secondTableName, list));
}
private List<List<?>> setUpdCuMemberTreeLists(Map<Long, CuMemberRangeExt> cuMemberTreeMap) {
List<CuMemberRangeExt> cuMemberTreeList = new ArrayList<>();
cuMemberTreeMap.forEach((key, value) -> cuMemberTreeList.add(value));
return cuMemberBonusSettle.handleCutList(cuMemberTreeList);
}
@Override
public Map<Long, List<CuMemberRangeExt>> queryCuMemberRangeParent(String tableName, List<SaOrderExt> saOrderExtList) {
List<CuMemberRangeExt> cuMemberRangeExtList = new ArrayList<>();
List<List<?>> cutOrderList = cuMemberBonusSettle.handleCutList(saOrderExtList, MagicNumberConstants.DELETE_DATA_BATCH_UPDATE_NUM);
cutOrderList.forEach(orderList ->
cuMemberRangeExtList.addAll(baseMapper.queryCuMemberRangeParent(tableName, orderList)));
return packageMemberRangeMap(cuMemberRangeExtList);
}
private Map<Long, List<CuMemberRangeExt>> packageMemberRangeMap(List<CuMemberRangeExt> cuMemberRangeExtList) {
Map<Long, List<CuMemberRangeExt>> memberRangeMap = new HashMap<>();
for (CuMemberRangeExt cuMemberRangeExt : cuMemberRangeExtList) {
if(memberRangeMap.containsKey(cuMemberRangeExt.getPkParent())){
memberRangeMap.get(cuMemberRangeExt.getPkParent()).add(cuMemberRangeExt);
}else{
List<CuMemberRangeExt> memberRangeExtList = new ArrayList<>();
memberRangeExtList.add(cuMemberRangeExt);
memberRangeMap.put(cuMemberRangeExt.getPkParent(), memberRangeExtList);
}
}
return memberRangeMap;
}
@Override
public Map<Long, List<CuMemberRangeExt>> queryCuMemberSecondRangeParent(String rangeTableName, String secondTableName, Long pkMember) {
List<CuMemberRangeExt> cuMemberRangeExtList = baseMapper.queryCuMemberSecondRangeParent(rangeTableName, secondTableName, pkMember);
return packageMemberRangeMap(cuMemberRangeExtList);
}
@Override
public List<CuMemberRangeExt> queryCuMemberRangeExtByParent(String tableName, Long pkParent, Date orderDate) {
return baseMapper.queryCuMemberRangeExtByParent(tableName, pkParent, orderDate);
@ -126,4 +51,5 @@ public class CuMemberRangeServiceImpl extends ServiceImpl<CuMemberRangeMapper, C
public Integer validateSecondCuMemberPlaceAwards(String secondTableName, List<CuMemberRangeExt> cuMemberRangeExtList, Integer pkRangeAwards) {
return baseMapper.validateSecondCuMemberPlaceAwards(secondTableName, cuMemberRangeExtList, pkRangeAwards);
}
}

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

@ -7,8 +7,6 @@ import com.hzs.bonus.base.service.ICuMemberService;
import com.hzs.common.core.constant.MagicNumberConstants;
import com.hzs.common.domain.member.achieve.CuMemberRetailRange;
import com.hzs.common.domain.member.achieve.ext.CuMemberRetailRangeExt;
import com.hzs.common.domain.member.bonus.CuMemberSpeRetail;
import com.hzs.common.domain.member.ext.CuMemberExt;
import com.hzs.common.domain.sale.ext.SaOrderExt;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@ -24,8 +22,6 @@ public class CuMemberRetailRangeServiceImpl extends ServiceImpl<CuMemberRetailRa
@Autowired
private CuMemberBonusSettle cuMemberBonusSettle;
@Autowired
private ICuMemberService iCuMemberService;
@Override
public void mergeMemberRetailRangeByYesterday(Date settleEndDate, String rangeTableName, String yesterdayRangeTableName, Boolean isSameMonth) {
@ -58,22 +54,6 @@ public class CuMemberRetailRangeServiceImpl extends ServiceImpl<CuMemberRetailRa
return memberRetailRangeExtList;
}
@Override
public List<CuMemberRetailRangeExt> queryCuMemberSpeRetailRangeParent(String tableName, List<CuMemberSpeRetail> memberSpeRetailList) {
List<CuMemberRetailRangeExt> memberRetailRangeExtList = new ArrayList<>();
List<Long> pkMemberList = new ArrayList<>();
for (CuMemberSpeRetail cuMemberSpeRetail : memberSpeRetailList) {
CuMemberExt cuMemberExt = iCuMemberService.getMemberByCode(cuMemberSpeRetail.getMemberCode());
if (cuMemberExt != null) {
pkMemberList.add(cuMemberExt.getPkId());
}
}
List<List<?>> cutOrderList = cuMemberBonusSettle.handleCutList(pkMemberList, MagicNumberConstants.DELETE_DATA_BATCH_UPDATE_NUM);
cutOrderList.forEach(orderList ->
memberRetailRangeExtList.addAll(baseMapper.queryCuMemberSpeRetailRangeParent(tableName, orderList)));
return memberRetailRangeExtList;
}
@Override
public List<CuMemberRetailRangeExt> queryCuMemberRetailRangeExtByParent(String tableName, Long pkParent) {
return baseMapper.queryCuMemberRetailRangeExtByParent(tableName, pkParent);
@ -90,22 +70,6 @@ public class CuMemberRetailRangeServiceImpl extends ServiceImpl<CuMemberRetailRa
return baseMapper.queryCuMemberSecondRangeParent(rangeTableName, secondTableName, pkMember);
}
@Override
public List<CuMemberRetailRangeExt> queryCuMemberSecondRange(String rangeTableName, String secondTableName, Long pkMember) {
List<CuMemberRetailRangeExt> cuMemberRetailRangeExtList = baseMapper.queryCuMemberSecondRange(rangeTableName, secondTableName, pkMember);
Map<Long, CuMemberRetailRangeExt> retailRangeExtMap = new HashMap<>();
for (CuMemberRetailRangeExt cuMemberRetailRangeExt : cuMemberRetailRangeExtList) {
retailRangeExtMap.put(cuMemberRetailRangeExt.getPkMember(), cuMemberRetailRangeExt);
}
List<CuMemberRetailRangeExt> yesMemberRetailRangeExtList = baseMapper.queryCuMemberSecondRangeYes(rangeTableName, pkMember);
for (CuMemberRetailRangeExt cuMemberRetailRangeExt : yesMemberRetailRangeExtList) {
if (!retailRangeExtMap.containsKey(cuMemberRetailRangeExt.getPkMember())) {
cuMemberRetailRangeExtList.add(cuMemberRetailRangeExt);
}
}
return cuMemberRetailRangeExtList;
}
@Override
public List<CuMemberRetailRangeExt> queryCuMemberSecondRangeExtByParent(String rangeTableName, String secondTableName, Long pkMember) {
return baseMapper.queryCuMemberSecondRangeExtByParent(rangeTableName, secondTableName, pkMember);
@ -117,13 +81,6 @@ public class CuMemberRetailRangeServiceImpl extends ServiceImpl<CuMemberRetailRa
treeList.forEach(list -> baseMapper.mergeCuMemberRetailRangeExt(settleTableName, list));
}
@Override
public void updateCuMemberRetailRange(String settleTableName, List<CuMemberRetailRangeExt> cuMemberRetailRangeExtList) {
List<List<?>> cutOrderList = cuMemberBonusSettle.handleCutList(cuMemberRetailRangeExtList, MagicNumberConstants.DELETE_DATA_BATCH_UPDATE_NUM);
cutOrderList.forEach(orderList ->
baseMapper.mergeCuMemberRetailRangeExt(settleTableName, orderList));
}
@Override
public void mergeCuMemberRetailRangeBySpecial(String settleTableName, Integer period) {
baseMapper.mergeCuMemberRetailRangeBySpecial(settleTableName, period);

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

@ -127,21 +127,6 @@ public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuM
baseMapper.createCuMemberTableSequence(tableName, tableNameSeq);
}
@Override
public List<CuMemberSettleExt> queryCuMemberSettleEnoughAwardAchieve(String settleTableName) {
return baseMapper.queryCuMemberSettleEnoughAwardAchieve(settleTableName);
}
@Override
public void updateBackCuMemberSettleAward(String settleTableName, Integer period) {
baseMapper.updateBackCuMemberSettleAward(settleTableName, period);
}
@Override
public void updateBackCuMemberSettleRangeAward(String rangeTableName, Integer period) {
baseMapper.updateBackCuMemberSettleRangeAward(rangeTableName, period);
}
@Override
public void updateBackCuMemberRetailRangeAward(String rangeTableName, Integer period) {
baseMapper.updateBackCuMemberRetailRangeAward(rangeTableName, period, EAwardsType.RANGE_TYPE.getValue());
@ -160,24 +145,6 @@ public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuM
baseMapper.updateCuMemberRetailRangeInitV5Award(rangeTableName);
}
@Override
public Boolean queryCuMemberSettlePlaceUnderUmbrella(String settleTableName, Integer awardsValue, Integer placeDept, Long pkMember) {
return baseMapper.queryCuMemberSettlePlaceUnderUmbrella(settleTableName, awardsValue, placeDept, pkMember) > 0;
}
@Override
public Boolean queryCuMemberSettleBloodUnderUmbrella(String settleTableName, Integer awardsValue, Integer placeDept, Long pkMember) {
return baseMapper.queryCuMemberSettleBloodUnderUmbrella(settleTableName, awardsValue, placeDept, pkMember) > 0;
}
@Override
public void updateCuMemberSettleByPeriod(List<Integer> periodList) {
periodList.forEach(period -> {
String updateTableName = TableNameConstants.CU_MEMBER_SETTLE + period;
baseMapper.updateCuMemberSettleByPeriod(updateTableName, period);
});
}
@Override
public List<CuMemberSettleExt> batchQueryMemberSettleBySaOrder(String settleTableName, List<SaOrderExt> saOrderExtList) {
// 查询出推荐人

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

@ -24,11 +24,6 @@ public interface CuMemberMapper extends BaseMapper<CuMember> {
*/
CuMemberExt queryLoginMember(@Param("memberCode") String memberCode, @Param("pkMember") Long pkMember);
/**
* 更新会员奖衔根据临时表
*/
Integer updateCuMemberByPeriod(Integer period);
/**
* 更新会员奖衔根据临时表
*/
@ -65,16 +60,6 @@ public interface CuMemberMapper extends BaseMapper<CuMember> {
*/
Integer updateCuMemberGradeByList(@Param("cuMemberGradeList") List<CuMemberGrade> cuMemberGradeList, @Param("period") Integer period);
/**
* 回退会员奖衔
*/
void updateBackCuMemberAward(Integer period);
/**
* 更新会员奖衔根据临时表
*/
void updateBackCuMemberRangeAward(@Param("period") Integer period);
/**
* 更新会员奖衔根据临时表
*/

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

@ -31,13 +31,6 @@ public interface ICuMemberService extends IService<CuMember> {
*/
CuMember getMember(String memberCode);
/**
* 更新会员奖衔根据临时表
*
* @param enoughAwardsMember 修改奖衔的会员
*/
void updateCuMemberByPeriod(List<CuMemberSettleExt> enoughAwardsMember, Integer period);
/**
* 更新会员奖衔根据临时表
*
@ -81,16 +74,6 @@ public interface ICuMemberService extends IService<CuMember> {
*/
void updateCuMemberGradeByList(List<CuMemberGrade> cuMemberGradeList, Integer period);
/**
* 更新会员奖衔根据临时表
*/
void updateBackCuMemberAward(List<CuMemberAwards> cuMemberAwards, Integer period);
/**
* 更新会员奖衔根据临时表
*/
void updateBackCuMemberRangeAward(List<CuMemberAwards> cuMemberAwards, Integer period);
/**
* 更新会员奖衔根据临时表
*/

16
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/base/service/impl/CuMemberServiceImpl.java
View File

@ -8,7 +8,6 @@ import com.hzs.common.domain.member.base.*;
import com.hzs.common.domain.member.detail.CuMemberAwards;
import com.hzs.common.domain.member.detail.CuMemberGrade;
import com.hzs.common.domain.member.ext.CuMemberExt;
import com.hzs.common.domain.member.ext.CuMemberSettleExt;
import com.hzs.bonus.base.mapper.CuMemberMapper;
import org.springframework.stereotype.Service;
@ -33,11 +32,6 @@ public class CuMemberServiceImpl extends ServiceImpl<CuMemberMapper, CuMember> i
return baseMapper.queryLoginMember(memberCode, null);
}
@Override
public void updateCuMemberByPeriod(List<CuMemberSettleExt> enoughAwardsMember, Integer period) {
baseMapper.updateCuMemberByPeriod(period);
}
@Override
public void updateCuMemberRetailRangeByPeriod(List<CuMemberAwards> cuMemberAwardsList, Integer period) {
baseMapper.updateCuMemberRetailAwardsByPeriod(period, EAwardsType.RANGE_TYPE.getValue());
@ -76,16 +70,6 @@ public class CuMemberServiceImpl extends ServiceImpl<CuMemberMapper, CuMember> i
baseMapper.updateCuMemberGradeByList(cuMemberGradeList, period);
}
@Override
public void updateBackCuMemberAward(List<CuMemberAwards> cuMemberAwards, Integer period) {
baseMapper.updateBackCuMemberAward(period);
}
@Override
public void updateBackCuMemberRangeAward(List<CuMemberAwards> cuMemberAwards, Integer period) {
baseMapper.updateBackCuMemberRangeAward(period);
}
@Override
public void updateBackCuMemberRetailRangeAward(Integer period) {
baseMapper.updateBackCuMemberRetailRangeAward(period, EAwardsType.RANGE_TYPE.getValue());

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

@ -1889,7 +1889,7 @@ public class BonusSettleRangeHandle extends BonusSettleHandle {
// 当月总pv，用于计算月度分红（福利平均、福利加权）
for (Integer systemType : orderMap.keySet()) {
List<SaOrder> saOrders = orderMap.get(systemType);
// 月所有订单业绩（注册、升级、复购、重消）
// 月所有订单业绩（注册、升级、复购）
BigDecimal totalMonthConsumePv = BigDecimal.ZERO;
// new 两个月奖

33
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/detail/service/ICuMemberAwardsService.java
View File

@ -3,34 +3,14 @@ package com.hzs.bonus.detail.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hzs.common.domain.member.achieve.ext.CuMemberRetailRangeExt;
import com.hzs.common.domain.member.detail.CuMemberAwards;
import com.hzs.common.domain.system.config.BdAwards;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
* 会员信息-奖衔升级记录 服务类
*/
public interface ICuMemberAwardsService extends IService<CuMemberAwards> {
/**
* 重新计算会员的奖衔，根据累计结束后的业绩
*
* @param settleDate 结算日
* @param countryAwardsMap 国家奖衔配置
* @param settleTableName 结算表
*/
void calculateCuMemberAwards(String settleDate, Map<String, BdAwards> countryAwardsMap, String settleTableName);
/**
* 回退极差奖衔，每日重新结算，先把奖衔回退到前一天
*
* @param period 结算期间
* @param rangeTableName 结算表
*/
void calculateCuMemberRangeAwardsInit(Integer period, String rangeTableName, Integer systemType);
/**
* 回退极差奖衔，每日重新结算，先把奖衔回退到前一天
*
@ -61,17 +41,4 @@ public interface ICuMemberAwardsService extends IService<CuMemberAwards> {
*/
void mergeCuMemberBackAwards(String rangeTableName, Long pkMember, Integer period, Integer isToday);
/**
* 删除奖衔升级记录
*
* @param pkOrder 订单
* @param pkApprove 审核人
* @param currentDateTime 当前时间
*/
void deleteCuMemberAwards(Long pkOrder, Long pkApprove, Date currentDateTime);
/**
* 根据结算表更新奖衔
*/
void updateCuMemberAwardsExamine(Date currentDate, Integer period);
}

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

@ -35,41 +35,8 @@ public class CuMemberAwardsServiceImpl extends ServiceImpl<CuMemberAwardsMapper,
@Autowired
private ICuMemberTreeService iCuMemberTreeService;
@Autowired
private ICuMemberSettlePeriodService iCuMemberSettlePeriodService;
@Autowired
private CuMemberBonusSettle cuMemberBonusSettle;
@Override
@Transactional(rollbackFor = Exception.class)
public void calculateCuMemberAwards(String setDate, Map<String, BdAwards> countryAwardsMap, String settleTableName) {
// 查询结算日当天奖衔发生过变动的会员，本期
Date settleDate = DateUtils.parseStringToDate(setDate);
Integer period = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(setDate).getPkId();
//删除当天奖衔升级记录，自动升级的
// 更新奖衔，回退奖衔
List<CuMemberAwards> cuMemberAwards = queryCuMemberAwardsByPeriod(period, null);
iCuMemberTreeService.updateBackCuMemberSettleAward(settleTableName, period);
iCuMemberService.updateBackCuMemberAward(cuMemberAwards, period);
// 回退业绩表奖衔
baseMapper.deleteCuMemberAwards(period);
while (true) {
List<CuMemberSettleExt> cuMemberSettleExtList = iCuMemberTreeService.queryCuMemberSettleEnoughAwardAchieve(settleTableName);
if (!calculateAwards(countryAwardsMap, settleTableName, settleDate, period, cuMemberSettleExtList)) {
break;
}
}
}
@Override
public void calculateCuMemberRangeAwardsInit(Integer period, String rangeTableName, Integer systemType) {
// 更新奖衔，回退奖衔
List<CuMemberAwards> cuMemberAwards = queryCuMemberAwardsByPeriod(period, systemType);
iCuMemberTreeService.updateBackCuMemberSettleRangeAward(rangeTableName, period);
iCuMemberService.updateBackCuMemberRangeAward(cuMemberAwards, period);
// 回退业绩表奖衔
baseMapper.deleteCuMemberAwards(period);
}
@Override
public void calculateCuMemberRetailRangeAwardsInit(String settleDate, Integer period, String rangeTableName) {
if (settleDate.endsWith("01")) {
@ -118,175 +85,6 @@ public class CuMemberAwardsServiceImpl extends ServiceImpl<CuMemberAwardsMapper,
}
}
private Boolean calculateAwards(Map<String, BdAwards> countryAwardsMap, String settleTableName, Date settleDate, Integer period, List<CuMemberSettleExt> cuMemberSettleExtList) {
// 当天奖衔发生过变动的人, 只要发生过变动，就要进行更新 降奖衔或者不变
// 更新奖衔，更新会员表，更新奖衔变动记录表
// 只满足业绩的
List<CuMemberAwards> cuMemberAwardsList = new ArrayList<>();
List<CuMemberSettleExt> enoughAwardsMemberList = new ArrayList<>();
if (cuMemberSettleExtList.size() > 0) {
List<CuMemberSettleExt> placeAwardsMemberList = new ArrayList<>();
List<CuMemberSettleExt> bloodAwardsMemberList = new ArrayList<>();
// 用于记录原来的奖衔
Map<Long, CuMemberSettleExt> originalCuMemberSettleMap = new HashMap<>(ComputeUtil.mapInitCapacity(cuMemberSettleExtList.size()));
cuMemberSettleExtList.forEach(cuMemberSettleExt -> {
BdAwards bdAwards = getBdAwards(countryAwardsMap, originalCuMemberSettleMap, cuMemberSettleExt);
// 验证关系
if (null == bdAwards.getRelationType()) {
enoughAwardsMemberList.add(cuMemberSettleExt);
} else if (ERelationType.BLOOD_KINSHIP_CHECK.getValue() == bdAwards.getRelationType()) {
bloodAwardsMemberList.add(cuMemberSettleExt);
} else if (ERelationType.PLACE_CHECK.getValue() == bdAwards.getRelationType()) {
placeAwardsMemberList.add(cuMemberSettleExt);
} else {
enoughAwardsMemberList.add(cuMemberSettleExt);
}
});
List<CuMemberAwards> memberAwardsList = updateAwardsRecord(enoughAwardsMemberList, originalCuMemberSettleMap, period);
if (memberAwardsList != null && memberAwardsList.size() > 0) {
cuMemberAwardsList.addAll(memberAwardsList);
}
// 需要验证安置的
if (placeAwardsMemberList.size() > 0) {
List<CuMemberSettleExt> updateAwardsMemberList = new ArrayList<>();
placeAwardsMemberList.forEach(cuMemberSettleExt -> {
BdAwards bdAwards = getBdAwards(countryAwardsMap, originalCuMemberSettleMap, cuMemberSettleExt);
// 验证安置 验证左右区是否存在满足等级的 考核
// 先验证左区
if (validateCuMemberPlaceRelation(settleTableName, bdAwards, cuMemberSettleExt.getPkMember())) {
updateAwardsMemberList.add(cuMemberSettleExt);
}
});
List<CuMemberAwards> awardsList = updateAwardsRecord(updateAwardsMemberList, originalCuMemberSettleMap, period);
if (updateAwardsMemberList.size() > 0) {
enoughAwardsMemberList.addAll(updateAwardsMemberList);
}
if (awardsList != null && awardsList.size() > 0) {
cuMemberAwardsList.addAll(awardsList);
}
}
// 需要验证血缘的
if (bloodAwardsMemberList.size() > 0) {
List<CuMemberSettleExt> updateAwardsMemberList = new ArrayList<>();
bloodAwardsMemberList.forEach(cuMemberSettleExt -> {
BdAwards bdAwards = getBdAwards(countryAwardsMap, originalCuMemberSettleMap, cuMemberSettleExt);
// 验证血缘
// 1 先验证安置，验证左右区是否存在满足等级的 考核
// 2 在验证血缘，验证满足等级的会员是否在他的血缘线上
if (validateBloodRelation(settleTableName, cuMemberSettleExt, bdAwards)) {
updateAwardsMemberList.add(cuMemberSettleExt);
}
});
List<CuMemberAwards> awardsList = updateAwardsRecord(updateAwardsMemberList, originalCuMemberSettleMap, period);
if (updateAwardsMemberList.size() > 0) {
enoughAwardsMemberList.addAll(updateAwardsMemberList);
}
if (awardsList != null && awardsList.size() > 0) {
cuMemberAwardsList.addAll(awardsList);
}
}
}
if (cuMemberAwardsList.size() > 0) {
// 将变动值插入临时表中
// 更新会员表
iCuMemberService.updateCuMemberByPeriod(enoughAwardsMemberList, period);
// 更新结算网体表(月表、日表)
// 根据结算日期获得所有需要更新的周期
updateMemberAwardPeriod(settleDate);
return Boolean.TRUE;
} else {
iCuMemberService.updateCuMemberByPeriod(null, period);
updateMemberAwardPeriod(settleDate);
return Boolean.FALSE;
}
}
private void updateMemberAwardPeriod(Date settleDate) {
Date currentDate = DateUtils.currentDate();
List<Integer> periodList = new ArrayList<>();
while (DateUtils.compareDateBefore(settleDate, currentDate)) {
String settleDateStr = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, settleDate);
periodList.add(iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(settleDateStr).getPkId());
settleDate = DateUtils.afterDate(1, ChronoUnit.DAYS, settleDate);
}
iCuMemberTreeService.updateCuMemberSettleByPeriod(periodList);
}
@Override
public void deleteCuMemberAwards(Long pkOrder, Long pkApprove, Date currentDateTime) {
LambdaUpdateWrapper<CuMemberAwards> updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.set(CuMemberAwards::getDelFlag, EYesNo.NO.getIntValue());
updateWrapper.set(CuMemberAwards::getPkModified, pkApprove);
updateWrapper.set(CuMemberAwards::getModifiedTime, currentDateTime);
updateWrapper.eq(CuMemberAwards::getPkOrder, pkOrder);
update(updateWrapper);
}
@Override
public void updateCuMemberAwardsExamine(Date currentDate, Integer period) {
String currentMonthFirstDate = DateUtils.currentMonthFirstDateStr(currentDate);
Integer currentPeriod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(currentMonthFirstDate).getPkId();
String currentTableName = TableNameConstants.CU_MEMBER_ASSESS + DateUtils.getYear(currentMonthFirstDate);
baseMapper.updateCuMemberAwardsExamine(currentTableName, period, currentPeriod);
}
private BdAwards getBdAwards(Map<String, BdAwards> countryAwardsMap, Map<Long, CuMemberSettleExt> originalCuMemberSettleMap, CuMemberSettleExt cuMemberSettleExt) {
originalCuMemberSettleMap.put(cuMemberSettleExt.getPkMember(), cuMemberSettleExt);
String key = cuMemberSettleExt.getPkSettleCountry().toString() + cuMemberSettleExt.getPkAwards().toString();
return countryAwardsMap.get(key);
}
/**
* 更新奖衔记录
*
* @param enoughAwardsMemberList 满足业绩
* @param originalCuMemberSettleMap 原来的map
* @param period 期间
*/
private List<CuMemberAwards> updateAwardsRecord(List<CuMemberSettleExt> enoughAwardsMemberList, Map<Long, CuMemberSettleExt> originalCuMemberSettleMap,
Integer period) {
if (enoughAwardsMemberList.size() == 0) {
return null;
}
// 更新奖衔记录变动
// 增加奖衔记录表
// 更新升奖衔的会员，插入升衔记录
return upgradeCuMemberAwards(enoughAwardsMemberList, originalCuMemberSettleMap, period);
}
/**
* 插入升级记录
*
* @param enoughAwardsMemberList 足够升级的
* @param originalCuMemberSettleMap 记录会员原等级的map
* @param period 期间
*/
private List<CuMemberAwards> upgradeCuMemberAwards(List<CuMemberSettleExt> enoughAwardsMemberList, Map<Long, CuMemberSettleExt> originalCuMemberSettleMap,
Integer period) {
List<CuMemberAwards> cuMemberAwardsList = new ArrayList<>();
if (enoughAwardsMemberList.size() > 0) {
// 记录要入库的，为了验证是否首次晋升
enoughAwardsMemberList.forEach(enoughAwardsMember -> getCuMemberAwards(originalCuMemberSettleMap, period, cuMemberAwardsList, enoughAwardsMember));
// 验证满足的这群人是否是首次晋升，查询出值的不是首次晋升
List<CuMemberAwards> originalCuMemberAwardsList = baseMapper.queryLastCuMemberAwards(cuMemberAwardsList);
// 是首次晋升的数据
Map<Long, CuMemberAwards> cuMemberAwardsMap = new HashMap<>(ComputeUtil.mapInitCapacity(originalCuMemberAwardsList.size()));
originalCuMemberAwardsList.forEach(cuMemberAwards -> cuMemberAwardsMap.put(cuMemberAwards.getPkMember(), cuMemberAwards));
cuMemberAwardsList.forEach(cuMemberAwards -> {
CuMemberAwards memberAwards = cuMemberAwardsMap.get(cuMemberAwards.getPkMember());
// 没有奖衔升级记录或者奖衔升级记录是会员的 算首次晋升
if (memberAwards == null) {
cuMemberAwards.setPurchaseStatus(EYesNo.YES.getIntValue());
}
});
// 插入记录
baseMapper.saveBatchCuMemberAwards(cuMemberAwardsList);
}
return cuMemberAwardsList;
}
private void getCuMemberAwards(Map<Long, CuMemberSettleExt> originalCuMemberSettleMap, Integer period, List<CuMemberAwards> cuMemberAwardsList, CuMemberSettleExt enoughAwardsMember) {
CuMemberAwards cuMemberAwards = CuMemberAwards.builder()
.pkMember(enoughAwardsMember.getPkMember())
@ -303,86 +101,4 @@ public class CuMemberAwardsServiceImpl extends ServiceImpl<CuMemberAwardsMapper,
cuMemberAwardsList.add(cuMemberAwards);
}
/**
* 更新降衔的会员，把升衔记录删除
*
* @param period 期间
* @param changeAwardsList 降低奖衔的人
* @param cuMemberAwardsList 所有变动记录的数据
*/
private void reduceCuMemberAwards(List<CuMemberAwards> changeAwardsList, Integer period, List<CuMemberAwards> cuMemberAwardsList) {
// 验证是否有降奖衔的，降奖衔的也要更新
if (changeAwardsList.size() > 0) {
// 更新奖衔表，将奖衔升级记录修改为删除状态
LambdaQueryWrapper<CuMemberAwards> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(CuMemberAwards::getPeriod, period);
baseMapper.updateBatchCuMemberAwards(changeAwardsList, period);
// 根据 changeAwardsList 查找到这群人的历史奖衔升级记录
List<CuMemberAwards> hisCuMemberAwardsList = baseMapper.queryLastCuMemberAwards(changeAwardsList);
Map<Long, CuMemberAwards> cuMemberAwardsMap = new HashMap<>();
hisCuMemberAwardsList.forEach(cuMemberAwards -> cuMemberAwardsMap.put(cuMemberAwards.getPkMember(), cuMemberAwards));
// 用于更新网体，将原有奖衔还原
changeAwardsList.forEach(cuMemberAwards -> {
if (cuMemberAwardsMap.containsKey(cuMemberAwards.getPkMember())) {
// 原有奖衔
cuMemberAwards.setNewLevel(cuMemberAwardsMap.get(cuMemberAwards.getPkMember()).getNewLevel());
} else {
// 没有值的变为会员
cuMemberAwards.setNewLevel(EAwards.MEMBER.getValue());
}
});
cuMemberAwardsList.addAll(changeAwardsList);
}
}
/**
* 查询某一期变动的奖衔
*
* @param period 奖金期
*/
private List<CuMemberAwards> queryCuMemberAwardsByPeriod(Integer period, Integer systemType) {
LambdaQueryWrapper<CuMemberAwards> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(CuMemberAwards::getPeriod, period);
if (systemType != null) {
queryWrapper.eq(CuMemberAwards::getSystemType, systemType);
}
queryWrapper.eq(CuMemberAwards::getUpType, EUpgradeType.AUTO_UPGRADE.getValue());
return baseMapper.selectList(queryWrapper);
}
/**
* 验证血缘关系
*
* @param settleTableName 结算表
* @param cuMemberSettleExt 会员结算表
* @param bdAwards 等级
*/
private Boolean validateBloodRelation(String settleTableName, CuMemberSettleExt cuMemberSettleExt, BdAwards bdAwards) {
// 左区满足，且满足血缘
if (iCuMemberTreeService.queryCuMemberSettlePlaceUnderUmbrella(settleTableName, bdAwards.getPkCheckAwardsLeft(), EPlaceDept.LEFT_DEPT.getValue(), cuMemberSettleExt.getPkMember()) &&
iCuMemberTreeService.queryCuMemberSettleBloodUnderUmbrella(settleTableName, bdAwards.getPkCheckAwardsLeft(), EPlaceDept.LEFT_DEPT.getValue(), cuMemberSettleExt.getPkMember())) {
// 验证血缘，左区存在血缘关系的
// 右区满足，且满足血缘
// 进行验证血缘验证
return iCuMemberTreeService.queryCuMemberSettlePlaceUnderUmbrella(settleTableName, bdAwards.getPkCheckAwardsRight(), EPlaceDept.RIGHT_DEPT.getValue(), cuMemberSettleExt.getPkMember()) &&
iCuMemberTreeService.queryCuMemberSettleBloodUnderUmbrella(settleTableName, bdAwards.getPkCheckAwardsRight(), EPlaceDept.RIGHT_DEPT.getValue(), cuMemberSettleExt.getPkMember());
}
return false;
}
/**
* 验证左右区安置关系
*
* @param settleTableName 结算表
* @param bdAwards 等级
* @param pkMember 会员
*/
private Boolean validateCuMemberPlaceRelation(String settleTableName, BdAwards bdAwards, Long pkMember) {
// 验证左区
if (iCuMemberTreeService.queryCuMemberSettlePlaceUnderUmbrella(settleTableName, bdAwards.getPkCheckAwardsLeft(), EPlaceDept.LEFT_DEPT.getValue(), pkMember)) {
// 在验证右区
return iCuMemberTreeService.queryCuMemberSettlePlaceUnderUmbrella(settleTableName, bdAwards.getPkCheckAwardsRight(), EPlaceDept.RIGHT_DEPT.getValue(), pkMember);
}
return false;
}
}

193
bd-business/bd-business-bonus/src/main/resources/mapper/bonus/achieve/CuMemberRangeMapper.xml
View File

@ -56,6 +56,7 @@
<result column="DEPT_TEAM_MONTH_AMOUNT" property="deptTeamMonthAmount"/>
<result column="DEPT_TEAM_MONTH_PV" property="deptTeamMonthPv"/>
</resultMap>
<update id="mergeCuMemberRangeExt">
merge into ${rangeTableName} a
using (
@ -96,75 +97,7 @@
a.team_consume_pv=b.team_consume_pv,a.team_month_pv=b.team_month_pv,
a.small_area_pv=b.small_area_pv,a.assess_status=b.assess_status
</update>
<update id="mergeMemberRangeByYesterday">
merge into ${rangeTableName} a
using(
select pk_member,consume_status,consume_pv,month_pv,effective_num,dept_team_consume_amount,
buy_effective_num,first_agent,second_agent,recommend_num,team_consume_amount,dept_team_consume_pv,
dept_team_month_amount,dept_team_month_pv,
team_consume_pv,team_month_amount,team_month_pv,small_area_pv,assess_status from ${yesterdayRangeTableName}
) b
on (a.pk_member=b.pk_member)
when matched then
update set a.consume_status=b.consume_status,a.consume_pv=b.consume_pv,
a.effective_num=b.effective_num,a.buy_effective_num=b.buy_effective_num,
a.first_agent=b.first_agent,a.second_agent=b.second_agent,a.recommend_num=b.recommend_num,
a.team_consume_amount=b.team_consume_amount,a.team_consume_pv=b.team_consume_pv,a.small_area_pv=b.small_area_pv,
a.dept_team_consume_amount=b.dept_team_consume_amount,a.dept_team_consume_pv=b.dept_team_consume_pv
<if test="isSameMonth == 0">
,a.dept_team_month_amount=b.dept_team_month_amount,a.dept_team_month_pv=b.dept_team_month_pv,
a.team_month_amount=b.team_month_amount,a.team_month_pv=b.team_month_pv,a.month_pv=b.month_pv,
a.assess_status=b.assess_status
</if>
</update>
<update id="mergeMemberRangeInit">
update ${rangeTableName} set consume_pv=0,month_pv=0,new_pv=0,new_team_pv=0,dept_new_team_pv=0,
effective_num=0,buy_effective_num=0,first_agent=0,second_agent=0,recommend_num=0,
team_num=0,team_consume_amount=0,team_month_amount=0,dept_team_consume_amount=0,
dept_team_consume_pv=0,dept_team_month_amount=0,dept_team_month_pv=0,
team_consume_pv=0,team_month_pv=0,small_area_pv=0,consume_status=1
<if test="isSameMonth == 0">
,assess_status=2
</if>
</update>
<update id="updateMemberRangeByPurchase">
update ${rangeTableName} set assess_status=0 where purchase_status=0
</update>
<update id="mergeMemberSecondRangeByRange">
merge into ${secondRangeTableName} a
using (
select a.pk_id pk_member,a.pk_parent,a.pk_range_awards,nvl(b.assess_status,3) assess_status,
nvl(b.consume_status,1) consume_status,
nvl(b.month_member,0) month_member from (select * from cu_member
where del_flag = 0
start with pk_id = #{pkMember}
connect by pk_id = prior pk_parent) a
left join ${rangeTableName} b
on a.pk_id=b.pk_member
) b
on (a.pk_member=b.pk_member)
when not matched then
insert (pk_member,pk_parent,pk_range_awards,assess_status,month_member,consume_status)
values(b.pk_member,b.pk_parent,b.pk_range_awards,b.assess_status,b.month_member,b.consume_status)
</update>
<update id="mergeCuMemberSecondRange">
merge into ${secondTableName} a
using (
<foreach collection="cuMemberRangeExtList" item="item" open=" " close=" " separator="union">
select #{item.pkMember} pk_member,#{item.pkRangeAwards} pk_range_awards,#{item.consumeStatus} consume_status,
#{item.newPv} new_pv,#{item.newEffectiveNum} new_effective_num,#{item.newTeamPv} new_team_pv,
#{item.assessStatus} assess_status,#{item.buyEffectiveNum} buy_effective_num,
#{item.firstAgent} first_agent,#{item.secondAgent} second_agent,
#{item.deptNewTeamPv} dept_new_team_pv from dual
</foreach>
) b
on (a.pk_member=b.pk_member)
when matched then
update set a.pk_range_awards=b.pk_range_awards,a.new_pv=b.new_pv,a.new_effective_num=b.new_effective_num,
a.new_team_pv=b.new_team_pv,a.assess_status=b.assess_status,a.buy_effective_num=b.buy_effective_num,
a.first_agent=b.first_agent,a.second_agent=b.second_agent,a.dept_new_team_pv=b.dept_new_team_pv,
a.consume_status=b.consume_status
</update>
<update id="mergeSecondCuMemberRangeExt">
merge into ${secondTableName} a
using (
@ -181,35 +114,47 @@
when matched then
update set a.pk_range_awards=b.pk_range_awards,a.new_pv=b.new_pv,a.new_team_pv=b.new_team_pv
</update>
<select id="queryCuMemberRangeParent" resultMap="CuMemberRangeExt">
<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_range_awards,a.pk_awards,a.pk_benefit_awards,a.income_status,a.consume_pv,a.range_store_status,
a.consume_status,a.month_pv,a.effective_num,a.buy_effective_num,a.first_agent,a.second_agent,
a.team_consume_amount,a.team_consume_pv,a.team_month_amount,a.team_month_pv,a.small_area_pv,a.new_pv,a.new_team_pv,
a.dept_new_team_pv,a.dept_team_consume_amount,a.dept_team_consume_pv,
a.dept_team_month_amount,a.dept_team_month_pv,
a.assess_status,a.month_member,a.pay_time,a.pk_rate,ba.awards_value range_awards_value from(
select * from ${tableName}
start with pk_member = #{item.pkMember}
connect by pk_member = prior pk_parent) a
<select id="queryCuMemberRangeExtByParent" resultMap="CuMemberRangeExt">
select a.pk_member,
a.pk_parent,
a.pk_settle_country,
a.pk_range_awards,
a.pk_awards,
a.pk_benefit_awards,
a.income_status,
a.consume_pv,
a.month_pv,
a.effective_num,
a.buy_effective_num,
a.first_agent,
a.second_agent,
a.consume_status,
a.team_consume_amount,
a.team_consume_pv,
a.team_month_amount,
a.team_month_pv,
a.small_area_pv,
0 new_pv,
0 new_team_pv,
a.dept_new_team_pv,
a.dept_team_consume_amount,
a.dept_team_consume_pv,
a.dept_team_month_amount,
a.dept_team_month_pv,
a.assess_status,
a.month_member,
a.pay_time,
a.pk_rate,
ba.awards_value range_awards_value
from ${tableName} a
inner join bd_range_awards ba
on a.pk_range_awards = ba.pk_id
where ba.del_flag = 0
</foreach>
</select>
<select id="queryCuMemberRangeExtByParent" resultMap="CuMemberRangeExt">
select a.pk_member,a.pk_parent,a.pk_settle_country,a.pk_range_awards,a.pk_awards,a.pk_benefit_awards,a.income_status,a.consume_pv,
a.month_pv,a.effective_num,a.buy_effective_num,a.first_agent,a.second_agent,a.consume_status,
a.team_consume_amount,a.team_consume_pv,a.team_month_amount,a.team_month_pv,a.small_area_pv,0 new_pv,0 new_team_pv,
a.dept_new_team_pv,a.dept_team_consume_amount,a.dept_team_consume_pv,
a.dept_team_month_amount,a.dept_team_month_pv,
a.assess_status,a.month_member,a.pay_time,a.pk_rate,ba.awards_value range_awards_value from ${tableName} a
inner join bd_range_awards ba
on a.pk_range_awards=ba.pk_id
where ba.del_flag=0 and a.pk_parent= #{pkParent}
and a.pk_parent = #{pkParent}
and a.pay_time &lt;= #{orderDate}
</select>
<select id="validateCuMemberPlaceAwards" resultType="java.lang.Integer">
select count(*) from(
<foreach collection="cuMemberRangeExtList" item="item" close=" " open=" " separator=" union all ">
@ -220,46 +165,42 @@
where pk_range_awards>= #{pkRangeAwards} and pay_time &lt;= #{orderDate}
</foreach>)
</select>
<select id="queryCuMemberSecondRangeParent"
resultType="com.hzs.common.domain.member.achieve.ext.CuMemberRangeExt">
select a.pk_member,cm.member_code,cm.member_name,a.pk_parent,cm.pk_settle_country,cm.category,cm.account_status,
a.pk_range_awards,cm.pk_awards,cm.pk_benefit_awards,cm.income_status,a.consume_status,
nvl(b.consume_pv,0)+a.new_pv consume_pv,a.new_pv,cm.pay_time,nvl(b.pk_rate,0) pk_rate,
nvl(b.month_pv,0)+a.new_pv month_pv,nvl(b.effective_num,0)+a.new_effective_num effective_num,
nvl(b.team_consume_amount,0) team_consume_amount,nvl(b.team_month_amount,0) team_month_amount,
nvl(b.team_consume_pv,0)+a.new_team_pv team_consume_pv,nvl(b.team_month_pv,0)+a.new_team_pv team_month_pv,
nvl(b.small_area_pv,0) small_area_pv,a.new_effective_num,a.new_team_pv,
a.dept_new_team_pv,nvl(dept_team_consume_amount,0) dept_team_consume_amount,
nvl(b.dept_team_month_amount,0) dept_team_month_amount,nvl(b.dept_team_month_pv,0)+a.dept_new_team_pv dept_team_month_pv,
nvl(b.dept_team_consume_pv,0)+a.dept_new_team_pv dept_team_consume_pv,
a.buy_effective_num,nvl(b.range_store_status,0) range_store_status,a.first_agent,a.second_agent,
a.assess_status,a.month_member,ba.awards_value range_awards_value from(
select * from ${secondTableName}
start with pk_member = #{pkMember}
connect by pk_member = prior pk_parent) a
inner join cu_member cm
on cm.pk_id=a.pk_member
left join ${rangeTableName} b
on a.pk_member=b.pk_member
inner join bd_range_awards ba
on a.pk_range_awards=ba.pk_id
where ba.del_flag=0
</select>
<select id="querySecondCuMemberRangeExtByParent" resultMap="CuMemberRangeExt">
select a.pk_member,a.pk_parent,nvl(b.pk_settle_country,1) pk_settle_country,a.pk_range_awards,a.consume_status,
nvl(b.income_status,0) income_status,nvl(b.consume_pv,0)+a.new_pv consume_pv,a.new_pv,a.new_team_pv,
a.dept_new_team_pv,nvl(dept_team_consume_amount,0) dept_team_consume_amount,
nvl(b.dept_team_month_amount,0) dept_team_month_amount,nvl(b.dept_team_month_pv,0)+a.new_team_pv dept_team_month_pv,
select a.pk_member,
a.pk_parent,
nvl(b.pk_settle_country, 1) pk_settle_country,
a.pk_range_awards,
a.consume_status,
nvl(b.income_status, 0) income_status,
nvl(b.consume_pv, 0) + a.new_pv consume_pv,
a.new_pv,
a.new_team_pv,
a.dept_new_team_pv,
nvl(dept_team_consume_amount, 0) dept_team_consume_amount,
nvl(b.dept_team_month_amount, 0) dept_team_month_amount,
nvl(b.dept_team_month_pv, 0) + a.new_team_pv dept_team_month_pv,
nvl(b.dept_team_consume_pv, 0) + a.dept_new_team_pv dept_team_consume_pv,
nvl(b.month_pv,0)+a.new_pv month_pv,nvl(b.effective_num,0)+a.new_effective_num effective_num,a.new_effective_num,
nvl(b.team_consume_pv,0)+a.new_team_pv team_consume_pv,nvl(b.team_month_pv,0)+a.new_team_pv team_month_pv,nvl(b.small_area_pv,0) small_area_pv,
a.assess_status,a.month_member,nvl(b.pay_time,null) pay_time,nvl(b.pk_rate,0) pk_rate,ba.awards_value range_awards_value from ${secondTableName} a
nvl(b.month_pv, 0) + a.new_pv month_pv,
nvl(b.effective_num, 0) + a.new_effective_num effective_num,
a.new_effective_num,
nvl(b.team_consume_pv, 0) + a.new_team_pv team_consume_pv,
nvl(b.team_month_pv, 0) + a.new_team_pv team_month_pv,
nvl(b.small_area_pv, 0) small_area_pv,
a.assess_status,
a.month_member,
nvl(b.pay_time, null) pay_time,
nvl(b.pk_rate, 0) pk_rate,
ba.awards_value range_awards_value
from ${secondTableName} a
left join ${tableName} b
on a.pk_member = b.pk_member
inner join bd_range_awards ba
on a.pk_range_awards = ba.pk_id
where ba.del_flag=0 and a.pk_parent= #{pkParent}
where ba.del_flag = 0
and a.pk_parent = #{pkParent}
</select>
<select id="validateSecondCuMemberPlaceAwards" resultType="java.lang.Integer">
select count(*) from(
<foreach collection="cuMemberRangeExtList" item="item" close=" " open=" " separator=" union all ">

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

@ -675,34 +675,6 @@
where bg.del_flag = 0
</select>
<select id="queryCuMemberSecondRange" resultMap="CuMemberRetailRangeExt">
select a.pk_member,
a.pk_parent,
nvl(b.consume_box_num, 0) + a.new_box_num consume_box_num,
a.new_box_num,
nvl(b.team_box_num, 0) + a.team_new_box_num team_box_num,
nvl(b.month_box_num, 0) + a.team_new_box_num month_box_num,
a.team_new_box_num,
nvl(b.consume_pv, 0) + a.new_consume_pv consume_pv,
nvl(month_consume_pv, 0) + a.new_consume_pv month_consume_pv,
a.new_consume_pv,
nvl(b.team_consume_amount, 0) + a.team_new_amount team_consume_amount,
nvl(b.team_consume_pv, 0) + a.team_new_pv team_consume_pv,
nvl(b.team_month_amount, 0) + a.team_new_amount team_month_amount,
nvl(b.team_month_pv, 0) + a.team_new_pv team_month_pv,
nvl(b.big_box_num, 0) big_box_num,
nvl(b.small_box_num, 0) small_box_num,
nvl(b.big_team_pv, 0) big_team_pv,
nvl(b.small_team_pv, 0) small_team_pv,
a.team_new_amount,
a.team_new_pv
from ${secondTableName} a
left join ${rangeTableName} b
on a.pk_member = b.pk_member
where a.pk_member = #{pkMember}
or a.pk_parent = #{pkMember}
</select>
<select id="queryCuMemberSecondRangeExtByParent" resultMap="CuMemberRetailRangeExt">
select cm.pk_id pk_member,
cm.pk_parent,
@ -777,21 +749,6 @@
-->
</select>
<select id="queryCuMemberSpeRetailRangeParent"
resultType="com.hzs.common.domain.member.achieve.ext.CuMemberRetailRangeExt">
select * from ${tableName}
where pk_parent in
<foreach collection="saOrderExtList" item="item" open="(" close=")" separator=",">
#{item}
</foreach>
union
select * from ${tableName}
where pk_member in
<foreach collection="saOrderExtList" item="item" open="(" close=")" separator=",">
#{item}
</foreach>
</select>
<select id="queryCuMemberRetailRangeEnoughAchieve" resultType="com.hzs.common.domain.member.achieve.ext.CuMemberRetailRangeExt">
select pk_member,
pk_parent,
@ -818,31 +775,4 @@
where pk_parent = #{pkParent}
</select>
<select id="queryCuMemberSecondRangeYes"
resultType="com.hzs.common.domain.member.achieve.ext.CuMemberRetailRangeExt">
select pk_member,
pk_parent,
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,
big_box_num,
small_box_num,
big_team_pv,
small_team_pv,
team_new_amount,
team_new_pv
from ${rangeTableName}
where pk_member = #{pkMember}
or pk_parent = #{pkMember}
</select>
</mapper>

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

@ -325,20 +325,6 @@
)
</update>
<update id="updateCuMemberSettleByPeriod">
merge into ${updateTableName} a
using (
select pk_member, max(new_level) pk_awards
from cu_member_awards
where period = #{period}
and del_flag = 0
group by pk_member) b
on (a.pk_member = b.pk_member)
when matched then
update set
a.pk_awards = b.pk_awards
</update>
<insert id="insertCuMemberRetailRangeByMember">
insert into ${settleTableName} (pk_member, pk_parent, member_code, member_name,
customer_type, phone, pk_grade, pk_awards, account_status, pay_status, category,
@ -388,41 +374,6 @@
<include refid="CuMemberTableTrig"></include>
</update>
<update id="updateBackCuMemberSettleAward">
merge into ${settleTableName} a
using (select pk_member, max(old_level) old_level
from cu_member_awards
where period = #{period}
and del_flag = 0
group by pk_member) b
on (a.pk_member = b.pk_member)
when matched then
update set
a.pk_awards = b.old_level
</update>
<update id="updateBackCuMemberSettleRangeAward">
merge into ${rangeTableName} a
using (
select pk_member, old_level, ba.pk_awards
from (
select pk_member, max(old_level) old_level
from cu_member_awards
where period = #{period}
and up_type = 1
and system_type = 1
and del_flag = 0
group by pk_member) ca
inner join bd_range_awards ba
on ca.old_level = ba.pk_id
where ba.del_flag = 0
) b
on (a.pk_member = b.pk_member)
when matched then
update set
a.pk_awards = b.pk_awards,a.pk_range_awards = b.old_level
</update>
<update id="updateBackCuMemberRetailRangeAward">
merge into ${rangeTableName} a
using (
@ -609,94 +560,6 @@
from ${tableName}
</select>
<select id="queryCuMemberSettleEnoughAwardAchieve" resultMap="CuMemberSettleExt">
select a.pk_member,
a.pk_parent,
a.pk_place_parent,
a.a_sum_real_pv,
a.b_sum_real_pv,
a.pk_country,
a.pk_settle_country,
bw.pk_id pk_awards,
bdw.pk_id pk_ori_awards
from (select ct.pk_member,
ct.pk_parent,
ct.pk_place_parent,
(ba.awards_value + 5) awards_value,
ba.awards_value ori_awards_value,
ct.a_sum_real_pv,
ct.b_sum_real_pv,
ct.pk_country,
ct.pk_settle_country
from ${settleTableName} ct
inner join bd_awards ba
on ct.pk_awards = ba.pk_id
where ct.category = 0
and ct.income_status = 0
and ba.del_flag = 0) a
inner join bd_awards bw
on a.awards_value = bw.awards_value and a.pk_settle_country = bw.pk_country
inner join bd_awards bdw
on a.ori_awards_value = bdw.awards_value and a.pk_settle_country = bdw.pk_country
where bw.del_flag = 0
and bw.community_check &lt;= a.a_sum_real_pv
and bw.community_check &lt;= a.b_sum_real_pv
order by pk_member desc
</select>
<select id="queryCuMemberSettlePlaceUnderUmbrella" resultType="java.lang.Integer">
select count(a.pk_member)
from (select a.*, b.pk_awards
from (select pk_member, pk_parent, pk_place_parent, place_dept
from ${settleTableName} start with pk_place_parent = #{pkMember} and place_dept=#{placeDept}
connect by pk_place_parent = prior pk_member) a
inner join (select cw.pk_member, cw.new_level pk_awards
from cu_member_awards cw
inner join (select pk_member, max(pk_id) pk_id
from cu_member_awards
where del_flag = 0
and UP_TYPE in (1, 3)
group by pk_member) ca
on cw.pk_id = ca.pk_id
where cw.del_flag = 0
) b
on a.pk_member = b.pk_member) a
inner join bd_awards ba
on a.pk_awards = ba.pk_id
where ba.awards_value >= (select awards_value from bd_awards where pk_id = #{awardsValue})
</select>
<select id="queryCuMemberSettleBloodUnderUmbrella" resultType="java.lang.Integer">
select count(pk_member)
from (
select pk_member
from ${settleTableName} start with pk_parent = #{pkMember}
connect by pk_parent = prior pk_member) a
where a.pk_member in (
select x.pk_member
from (
select a.*, b.pk_awards
from (
select pk_member, pk_parent, pk_place_parent, place_dept
from ${settleTableName} start with pk_place_parent = #{pkMember} and place_dept=#{placeDept}
connect by pk_place_parent = prior pk_member) a
inner join (select cw.pk_member, cw.new_level pk_awards
from cu_member_awards cw
inner join(select pk_member, max(pk_id) pk_id
from cu_member_awards
where del_flag = 0
and UP_TYPE in (1, 3)
group by pk_member) ca
on cw.pk_id = ca.pk_id
where cw.del_flag = 0
) b
on a.pk_member = b.pk_member
) x
inner join bd_awards ba
on x.pk_awards = ba.pk_id
where ba.awards_value >= (select awards_value from bd_awards where pk_id = #{awardsValue}))
</select>
<select id="queryMemberSettleBySaOrder" resultMap="CuMemberSettleExt">
select pk_member,member_code,member_name,c.pk_awards,c.pk_grade,account_status,category,income_status,pk_settle_country,
is_maker_space,purchase_status,share_status,bg.grade_value,pk_parent,is_maker_space,

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

@ -174,22 +174,6 @@
where cm.del_flag = 0
</sql>
<update id="updateCuMemberByPeriod">
merge into cu_member a
using (
select pk_member, max(new_level) pk_awards
from cu_member_awards
where period = #{period}
and del_flag = 0
group by pk_member
) b
on (a.pk_id = b.pk_member)
when matched then
update set
a.pk_awards = b.pk_awards,
a.modified_time = sysdate
</update>
<update id="updateCuMemberRetailAwardsByPeriod">
merge into cu_member a
using (
@ -258,40 +242,6 @@
order by pk_awards
</select>
<update id="updateBackCuMemberAward">
merge into cu_member a
using (select pk_member, max(old_level) old_level
from cu_member_awards
where period = #{period}
and del_flag = 0
group by pk_member) b
on (a.pk_id = b.pk_member)
when matched then
update set
a.pk_awards = b.old_level,
a.modified_time = sysdate
</update>
<update id="updateBackCuMemberRangeAward">
merge into cu_member a
using (select pk_member, old_level, ba.pk_awards
from (
select pk_member, max(old_level) old_level
from cu_member_awards
where period = #{period}
and up_type = 1
and del_flag = 0
group by pk_member) ca
inner join bd_range_awards ba
on ca.old_level = ba.pk_id
where ba.del_flag = 0) b
on (a.pk_id = b.pk_member)
when matched then
update set
a.pk_awards = b.pk_awards,a.pk_range_awards = b.old_level,
a.modified_time = sysdate
</update>
<update id="updateBackCuMemberRetailRangeAward">
merge into cu_member a
using (select pk_member, max(old_level) pk_awards

20
bd-business/bd-business-bonus/src/main/resources/mapper/bonus/bonus/CuMemberBonusMapper.xml
View File

@ -151,22 +151,26 @@
</foreach>) )b
on (cb.pk_member=b.pk_member and cb.period=b.period)
WHEN NOT MATCHED THEN
insert(pk_id,pk_member,period,pk_rate,direct_income,expand_income,expand_no_capping,
insert (
pk_id, pk_member, period, pk_rate, direct_income,expand_income,expand_no_capping,
expand_capping,coach_income,share_income,service_income,back_points,service_spend,
pur_real_subtotal,repur_push_income,repur_range_income,repur_expand_income,repur_real_subtotal,
repur_coupon,repur_coupon_share,repur_coupon_subtotal,
store_income, real_income_total,
pk_country,pk_creator,grant_status,income_status,retail_range_income,retail_same_level_income,
retail_area_income,retail_benefit_range_income,retail_benefit_avg_income,retail_benefit_income,
retail_real_subtotal)
values(b.pk_id,b.pk_member,b.period,b.pk_rate,b.direct_income,b.expand_income,b.expand_no_capping,
pk_country, pk_creator, grant_status, income_status,
retail_range_income, retail_same_level_income,
retail_area_income, retail_benefit_range_income, retail_month_repurchase_income,
retail_benefit_avg_income, retail_benefit_income, retail_real_subtotal)
values (
b.pk_id, b.pk_member, b.period, b.pk_rate, b.direct_income,b.expand_income,b.expand_no_capping,
b.expand_capping,b.coach_income,b.share_income,b.service_income,b.back_points,b.service_spend,
b.pur_real_subtotal,b.repur_push_income,b.repur_range_income,b.repur_expand_income,b.repur_real_subtotal,
b.repur_coupon,b.repur_coupon_share,b.repur_coupon_subtotal,
b.store_income, b.real_income_total,
b.pk_country,b.pk_creator,b.grant_status,b.income_status,b.retail_range_income,b.retail_same_level_income,
b.retail_area_income,b.retail_benefit_range_income,b.retail_benefit_avg_income,b.retail_benefit_income,
b.retail_real_subtotal)
b.pk_country, b.pk_creator, b.grant_status, b.income_status,
b.retail_range_income, b.retail_same_level_income,
b.retail_area_income, b.retail_benefit_range_income, retail_month_repurchase_income,
b.retail_benefit_avg_income, b.retail_benefit_income, b.retail_real_subtotal)
</insert>
<insert id="insertOrUpdateCuMemberBonus">