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

## 去掉不用的4-N等老奖金处理；去掉荣誉墙、推荐达人等；

This commit is contained in:
cabbage 2025-06-26 10:00:16 +08:00
parent 5bef937a1f
commit fa9d7184ea
122 changed files with 259 additions and 8445 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
bd-api/bd-api-member/src/main/java/com/hzs/member/account/dto/MemberAmountDTO.java
View File

@ -10,12 +10,6 @@ import java.math.BigDecimal;
/**
* 会员业务手续费
*
* @Description:
* @Author: ljc
* @Time: 2023/1/6 15:15
* @Classname: BusinessCommissionDTO
* @Package_name: com.hzs.member.account.dto
*/
@Data
@Builder

39
bd-api/bd-api-sale/src/main/java/com/hzs/activity/pick/IAcPickServiceApi.java
View File

@ -1,39 +0,0 @@
package com.hzs.activity.pick;
import com.hzs.common.core.domain.R;
import com.hzs.common.domain.activity.pick.AcPickMemberLog;
import com.hzs.common.domain.activity.pick.ext.AcPickExt;
import com.hzs.common.domain.sale.ext.SaOrderExt;
import java.math.BigDecimal;
import java.util.List;
/**
* @Description: 提货相关dubbo服务入口
* @Author: jiang chao
* @Time: 2023/5/15 11:20
* @Classname: IAcPickServiceApi
* @PackageName: com.hzs.activity.base
*/
public interface IAcPickServiceApi {
/*
* @description: 查询会员提货使用记录
* @author: sui q
* @date: 2023/6/3 10:51
* @param: null null
**/
R<List<AcPickMemberLog>> queryPickMemberLog(List<SaOrderExt> saOrderExtList);
/**
* 根据订单查询邮费
*
* @param orderCode 订单编号
* @param recProvince 省
* @param recCity 市
* @param pkCountry 国家
* @return
*/
R<BigDecimal> queryOrderPostage(String orderCode, Integer recProvince, Integer recCity, Integer pkCountry);
}

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

@ -27,14 +27,6 @@ public interface ISaOrderServiceApi {
*/
R<List<SaOrderExt>> queryRetailSaOrderByDay(Date startDate, Date endDate, String orderCode);
/**
* 查询时间范围内的所有订单，按照订单时间排序,只能用于奖金结算
*
* @param startDate 开始日期
* @param endDate 结束日期
*/
R<List<SaOrderExt>> queryRepeatSaOrderByDay(Date startDate, Date endDate);
/*
* 根据主键查询订单,需要查询del_flag=1的，存在先撤单在退货
**/
@ -45,32 +37,6 @@ public interface ISaOrderServiceApi {
**/
R<List<SaOrderExt>> querySaOrderByDeliverList(List<SaDeliverItemsExt> deliverItemExtList);
/**
* 查询时间范围内的所有订单，按照订单时间排序，不查询删除的，用于云代奖金计算，只需要主表
*
* @param startDate 开始日期
* @param endDate 结束日期
*/
R<List<SaOrder>> querySaOrderByDayForCloud(Date startDate, Date endDate, List<Integer> orderType);
/**
* 计算复购券分享奖金，查询订单
*
* @param startDate 开始日期
* @param endDate 结束日期
* @param orderTypeList 订单类型
* @param orderAmount 订单金额
* @param orderAchieve 订单业绩
*/
R<List<SaOrder>> querySaOrderByTimeForCouponShare(Date startDate, Date endDate, List<Integer> orderTypeList,
BigDecimal orderAmount, BigDecimal orderAchieve, Integer pkCountry);
/*
* 计算店铺奖金，查询订单
**/
R<List<SaOrderExt>> querySaOrderByTimeForStore(Date startDate, Date endDate);
/**
* 根据订单ID查询订单详细列表
*
@ -80,15 +46,6 @@ public interface ISaOrderServiceApi {
*/
R<List<SaOrderItemsExt>> queryOrderItemsListByOrderId(List<Long> pkOrderList, Integer pkCountry);
/**
* 根据订单编号查询订单信息
*
* @param orderCode 订单编号
* @param pkMember 会员主键
* @return
*/
R<SaOrderExt> queryOrderByCode(String orderCode, Long pkMember);
/**
* 空单注册审核通过
*

335
bd-api/bd-api-sale/src/main/java/com/hzs/sale/order/dto/OrderParamDTO.java
View File

@ -1,335 +0,0 @@
package com.hzs.sale.order.dto;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.hzs.common.core.constant.msg.MemberMsgConstants;
import jdk.nashorn.internal.ir.annotations.Ignore;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.Size;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class OrderParamDTO implements Serializable {
/**
* 订单编号
*/
private String orderCode;
/**
* 会员编号
*/
private Long pkMember;
/**
* 会员编号
*/
private String memberCode;
/**
* 会员姓名
*/
private String memberName;
/**
* 会员类型（0.正常 1.空单 2.死点 4.嗨粉）
*/
private Integer customerType;
/**
* 等级
*/
private Integer pkGrade;
/**
* 手机号码
*/
@Size(min = 1, max = 30, message = MemberMsgConstants.PHONE_LENGTH)
private String phone;
/**
* 证件号码
*/
private String idCard;
/**
* 性别（0=未知,1=男,2=女）
*/
private Integer sex;
/**
* 自然国家
*/
private Integer pkCountry;
/**
* 结算国家
*/
private Integer pkSettleCountry;
/**
* 创建人结算国家，用于跨国报单
*/
@JsonIgnore
private Integer pkLoginSettleCountry;
/**
* 推荐人编号
*/
private String parent;
@JsonIgnore
private Long parentId;
/**
* 推荐人ID，为防止之前业务有问题，不使用上面的字段
*/
private Long pkParent;
/**
* 会员ID，为防止之前业务有问题，新添加会员ID字段
*/
private Long pkMemberId;
/**
* 推荐人姓名
*/
private String parentName;
/**
* 安置人编号
*/
private String placeParent;
@JsonIgnore
private Long placeParentId;
/**
* 安置人姓名
*/
private String placeParentName;
/**
* 安置人部门
*/
private Integer placeDept;
/**
* 报单中心编号
*/
private Long centerCodeId;
/**
* 报单中心名称
*/
private String centerName;
/**
* 升级会员编号，需要验证安置线，只能给自己的安置以下升级
*/
private String upgradeMemberCode;
/**
* 复购会员编号，需要验证安置线，只能给自己的安置以下升级
*/
private String repurchaseMemberCode;
/**
* 会员升级姓名
*/
private String upgradeMemberName;
/**
* 数据来源（1=PC端,2=APP,3=H5）
*/
private Integer source;
/**
* 收货人
*/
private String recName;
/**
* 收货电话
*/
private String recPhone;
/**
* 收货省
*/
private Integer recProvince;
/**
* 收货市
*/
private Integer recCity;
/**
* 收货县
*/
private Integer recCounty;
/**
* 收货地址
*/
private String recAddress;
/**
* 备注
*/
private String remark;
/**
* 配送中心
*/
private Integer deliveryCenter;
/**
* 配送省
*/
private Integer deliveryProvince;
/**
* 配送市
*/
private Integer deliveryCity;
/**
* 配送县
*/
private Integer deliveryCounty;
/**
* 发货方式
*/
private Integer deliveryWay;
/**
* 运输类型 1=陆运，2=空运，3=海运
*/
private Integer transType;
/**
* 运输类型 1=陆运，2=空运，3=海运
*/
private Integer tranType;
/**
* 登录密码
*/
@JsonIgnore
private String loginPwd;
/**
* 支付密码
*/
private String payPwd;
/**
* 邮箱
*/
private String email;
/**
* 所属专区
*/
private Integer specialArea;
/**
* 银行
*/
private Integer pkBank;
/**
* 支行名称
*/
private String subBankName;
/**
* 银行卡号
*/
private String cardNumber;
/**
* 会员店铺
*/
private Integer pkMemberStore;
/**
* 仓库
*/
private Integer pkStorehouse;
/**
* 邮费
*/
private BigDecimal postage = BigDecimal.ZERO;
/**
* 特殊邮费（处理不参与复购300包邮的邮费）
*/
private BigDecimal specialPostage = BigDecimal.ZERO;
/**
* 特殊邮费金额（处理不参与复购300包邮的邮费）
*/
private BigDecimal specialPostageAmount = BigDecimal.ZERO;
/**
* 订单商品明细
*/
private List<OrderItemsParamDTO> orderItemsParams;
/**
* 是否首单
*/
private Boolean isFirst = false;
/**
* 是否海粉订单
*/
@JsonIgnore
private Boolean isHaiFun = false;
/**
* 显示默认，0=快速注册，1=普通注册
*/
private Integer displayDefault;
/**
* @Description: 验证保存的必输字段
* @return: List
* @Author: sui q
* @Date: 2022/8/29 11:10
*/
@JsonIgnore
public List<String> getValidSaveField() {
List<String> fieldList = getValidConfirmField();
fieldList.add("payPwd");
return fieldList;
}
@JsonIgnore
public List<String> getFunValidConfirmField() {
List<String> fieldList = getList();
fieldList.add("memberName");
fieldList.add("phone");
fieldList.add("parent");
return fieldList;
}
@JsonIgnore
public List<String> getValidConfirmField() {
List<String> fieldList = getFunValidConfirmField();
fieldList.add("placeParent");
fieldList.add("placeDept");
return fieldList;
}
@Ignore
private List<String> getList() {
return new ArrayList<>();
}
}

33
bd-api/bd-api-scm/src/main/java/com/hzs/scm/pub/IScmBillServiceApi.java
View File

@ -11,12 +11,7 @@ import com.hzs.system.sys.dto.ApprovalBusinessResultDTO;
import java.util.List;
/**
* @description: 供应链单据对外接口发布
* @author: sui q
* @time: 2023/11/25 09:21
* @classname: IScmBillServiceApi
* @package_name: com.hzs.scm.ic
* version 1.0.0
* 供应链单据对外接口发布
*/
public interface IScmBillServiceApi {
@ -29,42 +24,28 @@ public interface IScmBillServiceApi {
R<Boolean> approvalCallback(ApprovalBusinessResultDTO approvalBusinessResultDTO);
/*
* @description: 查询单据信息
* @author: sui q
* @date: 2023/11/25 9:38
* @param: null null
* 查询单据信息
**/
R<List<BillDTO>> queryBillDtoByCondition(EApprovalBusiness eApprovalBusiness, String businessCode);
/*
* @description: 下单时验证可用量
* @author: sui q
* @date: 2023/12/11 10:01
* @param: null null
* 下单时验证可用量
**/
R<List<IcAvailableNumExt>> queryAvailableNumByProduct(List<IcAvailableNum> availableNumList);
/*
* @description: 更新可用量
* @author: sui q
* @date: 2023/12/18 9:28
* @param: null null
* 更新可用量
**/
R<Boolean> updateDeductIcAvailableNumByList(List<IcAvailableNumExt> availableNumList);
/*
* @description: 更新单据号规则
* @author: sui q
* @date: 2024/2/21 15:40
* @param: null null
* 更新单据号规则
**/
R<Boolean> updateScmBillNoNextValue();
/*
* @description: 撤单、退单回退可用量
* @author: sui q
* @date: 2024/4/17 10:13
* @param: null null
* 撤单、退单回退可用量
**/
R<Boolean> backSaOrderAvailable(SaOrderExt saOrderExt);
}

6
bd-api/bd-api-system/src/main/java/com/hzs/system/config/IGradeServiceApi.java
View File

@ -2,7 +2,6 @@ package com.hzs.system.config;
import com.hzs.common.core.domain.R;
import com.hzs.common.domain.system.config.BdGrade;
import com.hzs.common.domain.system.config.ext.BdStoreLevelExt;
import com.hzs.system.config.dto.GradeDTO;
import java.math.BigDecimal;
@ -69,11 +68,6 @@ public interface IGradeServiceApi {
*/
R<List<GradeDTO>> selectGradeAll(Integer dataCountry);
/*
* 查询店铺等级
**/
R<List<BdStoreLevelExt>> queryStoreLevel();
/**
* 根据国家查询等级配置列表
*

13
bd-api/bd-api-system/src/main/java/com/hzs/system/config/IServiceChargeServiceApi.java
View File

@ -6,20 +6,12 @@ import com.hzs.system.config.dto.ServiceChargeDTO;
import java.util.List;
/**
* @Description: 办理业务手续费api
* @Author: zhangjing
* @Time: 2022/9/9 14:07
* @Classname: IGradeServiceApi
* @PackageName: com.hzs.system.config
* 办理业务手续费api
*/
public interface IServiceChargeServiceApi {
/**
* @description: 根据业务类型查询扣款
* @author: zhang jing
* @date: 2023/1/7 15:01
* @param: [type, quantity]
* @return: com.hzs.common.core.domain.R<com.hzs.system.config.dto.ServiceChargeDTO>
* 根据业务类型查询扣款
**/
R<ServiceChargeDTO> getServiceChargeByType(ServiceChargeDTO serviceChargeDTO);
@ -31,5 +23,4 @@ public interface IServiceChargeServiceApi {
*/
R<List<ServiceChargeDTO>> getServiceChargeByType(List<ServiceChargeDTO> serviceChargeDTOList);
}

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

@ -2,7 +2,6 @@ package com.hzs.bonus.achieve.controller.manage;
import cn.hutool.core.bean.BeanUtil;
import com.hzs.bonus.achieve.param.MemberPeriodParam;
import com.hzs.bonus.achieve.service.ICuMemberMonthAchieveService;
import com.hzs.bonus.achieve.service.ICuMemberSettlePeriodService;
import com.hzs.bonus.achieve.service.ICuMemberTreeService;
import com.hzs.bonus.bonus.service.IBonusGrantService;
@ -45,8 +44,6 @@ public class CuMemberSettleController extends BaseController {
private ICuMemberSettlePeriodService iCuMemberSettlePeriodService;
@Autowired
private IBonusGrantService iBonusGrantService;
@Autowired
private ICuMemberMonthAchieveService iCuMemberMonthAchieveService;
/**
@ -183,22 +180,10 @@ public class CuMemberSettleController extends BaseController {
if (StringUtils.isEmpty(orderCode)) {
return AjaxResult.error();
}
// iBonusSettleService.calculateCumberBonusBySecond(orderCode);
iBonusSettleService.calculateCuMemberRetailRangeBonusBySaOrder(orderCode);
return AjaxResult.success();
}
/**
* 秒接结算业绩，仅用于测试
*
* @return AjaxResult
*/
@GetMapping("/settle-month")
public AjaxResult settleMonth() {
iCuMemberMonthAchieveService.insertCuMemberAchieveByEveryDay(DateUtils.beforeDate(1, ChronoUnit.DAYS));
return AjaxResult.success();
}
/*
* 查询奖金计算期数列表
**/

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

@ -29,15 +29,6 @@ public interface CuMemberAchieveMapper extends BaseMapper<CuMemberAchieve> {
**/
void mergeCuMemberMonth(@Param("date") String date, @Param("period") Integer period);
/**
* 将昨天日表数据插入今天日表中, 昨日日表更新今天日表网体表
* 根据昨天结算表数据更新今天结算表的业绩数据
*
* @param sourceTable 来源表，记录10天跟月表一摸一样的滚动表数据
* @param targetTable 目标表 记录10天跟月表一摸一样的滚动表数据
*/
void updateCuMemberExpandSettleAchieveByBeforeDay(@Param("sourceTable") String sourceTable, @Param("targetTable") String targetTable);
/*
* 退单回退业绩
**/

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

@ -130,12 +130,6 @@ public interface CuMemberTreeMapper extends BaseMapper<CuMemberTree> {
List<CuMemberSettleExt> queryMemberSettleBySaOrder(@Param("settleTableName") String settleTableName,
@Param("memberPkList") List<?> memberPkList);
/*
* 查询所有有奖衔的会员
**/
List<CuMemberSettleExt> queryMemberSettleByAwards(@Param("settleTableName") String settleTableName, @Param("rangeTableName") String rangeTableName,
@Param("startPeriod") Integer startPeriod, @Param("endPeriod") Integer endPeriod);
/**
* 根据订单，查询出网体中记录的会员数据及推荐人
*
@ -144,15 +138,6 @@ public interface CuMemberTreeMapper extends BaseMapper<CuMemberTree> {
*/
List<CuMemberSettleExt> batchQueryMemberSettleParentByMemberPk(@Param("settleTableName") String settleTableName, @Param("memberPkList") List<?> serviceMemberSet);
/**
* 批量根据订单信息查询会员结算表中的数据
*
* @param settleTableName 结算表
* @param firPurchaseOrderList 首单列表
*/
List<CuMemberSettleExt> batchQueryCuMemberSettlePlaceParent(@Param("settleTableName") String settleTableName,
@Param("firPurchaseOrderList") List<?> firPurchaseOrderList);
/**
* 批量根据量奖信息查询会员结算表中的父级血缘数据
*
@ -162,21 +147,4 @@ public interface CuMemberTreeMapper extends BaseMapper<CuMemberTree> {
List<CuMemberSettleExt> batchQueryCuMemberSettleParent(@Param("settleTableName") String settleTableName,
@Param("pkMemberList") List<?> pkMemberList);
/**
* 批量根据量奖信息查询会员结算表中的父级血缘数据
*
* @param settleTableName 结算表
* @param pkMemberList 有量奖的会员列表
*/
List<CuMemberSettleExt> batchQueryCuMemberSettleParentForSpecial(@Param("settleTableName") String settleTableName,
@Param("pkMemberList") List<?> pkMemberList);
/**
* 更新会员树的累计业绩
*
* @param settleTableName 结算表
* @param cuMemberTreeList 树
*/
void updateCuMemberExpandSettle(@Param("settleTableName") String settleTableName, @Param("cuMemberTreeList") List<?> cuMemberTreeList);
}

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

@ -28,15 +28,6 @@ public interface ICuMemberAchieveService extends IService<CuMemberAchieve> {
**/
void mergeCuMemberMonth(Integer day, String date);
/**
* 将昨天日表数据插入今天日表中, 昨日日表更新今天日表网体表
* 根据昨天结算表数据更新今天结算表的业绩数据
*
* @param sourceTable 来源表，记录10天跟月表一摸一样的滚动表数据
* @param targetTable 目标表 记录10天跟月表一摸一样的滚动表数据
*/
void updateCuMemberExpandSettleAchieveByBeforeDay(String sourceTable, String targetTable);
/*
* 退单回退业绩
**/

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

@ -3,11 +3,9 @@ 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.ext.CuMemberSettleExt;
import com.hzs.common.domain.sale.ext.SaOrderExt;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
@ -22,14 +20,6 @@ public interface ICuMemberTreeService extends IService<CuMemberTree> {
*/
void createCuMemberTree(String date);
/**
* 初始用来结算奖金的表，多次重算奖金，只更新结余
*
* @param yesterdaySettleTableName 昨天的结算表
* @param currentSettleTableName 结算日的结算表
*/
void initCuMemberExpandTreeTable(String yesterdaySettleTableName, String currentSettleTableName);
/**
* 判断是否存在临时表
*
@ -67,14 +57,6 @@ public interface ICuMemberTreeService extends IService<CuMemberTree> {
*/
void updateCuMemberRetailRangeInitAward(String rangeTableName);
/**
* 根据订单，查询出网体中记录的会员数据，推荐人、安置人
*
* @param settleTableName 结算表
* @param saOrderExtList 订单
*/
List<CuMemberSettleExt> batchQueryMemberSettleBySaOrder(String settleTableName, List<SaOrderExt> saOrderExtList);
/**
* 根据订单，查询出网体中记录的会员数据，推荐人、安置人
*
@ -83,11 +65,6 @@ public interface ICuMemberTreeService extends IService<CuMemberTree> {
*/
List<CuMemberSettleExt> batchQueryMemberSettleByMemberPk(String settleTableName, Set<Long> serviceMemberSet);
/*
* 查询所有有奖衔的会员
**/
List<CuMemberSettleExt> queryMemberSettleByAwards(String settleTableName, String rangeTableName, Integer startPeriod, Integer endPeriod);
/**
* 根据订单，查询出网体中记录的会员数据及推荐人
*
@ -96,14 +73,6 @@ public interface ICuMemberTreeService extends IService<CuMemberTree> {
*/
List<CuMemberSettleExt> batchQueryMemberSettleParentByMemberPk(String settleTableName, Set<Long> serviceMemberSet);
/**
* 批量根据订单信息查询会员结算表中的父级安置数据
*
* @param settleTableName 结算表
* @param firPurchaseOrderList 首单列表
*/
Map<Long, List<CuMemberSettleExt>> batchQueryCuMemberSettlePlaceParent(String settleTableName, List<SaOrderExt> firPurchaseOrderList);
/**
* 批量根据量奖信息查询会员结算表中的父级血缘数据
*
@ -112,22 +81,6 @@ public interface ICuMemberTreeService extends IService<CuMemberTree> {
*/
List<CuMemberSettleExt> batchQueryCuMemberSettleParent(String settleTableName, Set<Long> expandMemberSet);
/**
* 批量根据量奖信息查询会员结算表中的父级血缘数据
*
* @param settleTableName 结算表
* @param expandMemberSet 有量奖的会员列表
*/
List<CuMemberSettleExt> batchQueryCuMemberSettleParentForSpecial(String settleTableName, Set<Long> expandMemberSet);
/**
* 更新会员树的累计业绩
*
* @param settleTableName 结算日期
* @param cuMemberTreeMap 树
*/
void updateCuMemberExpandSettle(String settleTableName, Map<Long, CuMemberSettleExt> cuMemberTreeMap);
/**
* 删除日表数据
*

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

@ -77,11 +77,6 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
baseMapper.mergeCuMemberMonth(DateUtils.getMonth(date), cuMemberSettlePeriod.getPkId());
}
@Override
public void updateCuMemberExpandSettleAchieveByBeforeDay(String sourceTable, String targetTable) {
baseMapper.updateCuMemberExpandSettleAchieveByBeforeDay(sourceTable, targetTable);
}
@Override
public Boolean chargeBackSaOrder(SaOrder saOrder) {
// 根据支付时间查询期间

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

@ -1,23 +1,15 @@
package com.hzs.bonus.achieve.service.impl;
import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hzs.bonus.achieve.service.ICuMemberAchieveService;
import com.hzs.bonus.achieve.service.ICuMemberMonthAchieveService;
import com.hzs.bonus.achieve.service.ICuMemberSettlePeriodService;
import com.hzs.bonus.base.service.ICuMemberHonorWallService;
import com.hzs.common.core.constant.MagicNumberConstants;
import com.hzs.common.core.constant.TableNameConstants;
import com.hzs.common.core.enums.HonorWallType;
import com.hzs.common.core.utils.DateUtils;
import com.hzs.common.domain.member.achieve.CuMemberMonthAchieve;
import com.hzs.common.domain.member.achieve.CuMemberSettlePeriod;
import com.hzs.common.domain.member.ext.CuMemberMonthAchieveExt;
import com.hzs.common.domain.member.honor.CuHonorWall;
import com.hzs.common.domain.member.honor.CuMemberHonorWall;
import com.hzs.bonus.achieve.mapper.CuMemberMonthAchieveMapper;
import com.hzs.bonus.achieve.service.ICuMemberTreeService;
import com.hzs.bonus.base.service.ICuHonorWallService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@ -33,10 +25,6 @@ public class CuMemberMonthAchieveServiceImpl extends ServiceImpl<CuMemberMonthAc
@Autowired
private ICuMemberSettlePeriodService iCuMemberSettlePeriodService;
@Autowired
private ICuHonorWallService iCuHonorWallService;
@Autowired
private ICuMemberHonorWallService iCuMemberHonorWallService;
@Autowired
private ICuMemberTreeService iCuMemberTreeService;
@Autowired
private ICuMemberAchieveService iCuMemberAchieveService;
@ -72,44 +60,6 @@ public class CuMemberMonthAchieveServiceImpl extends ServiceImpl<CuMemberMonthAc
// 计算当前月
String settleMonth = DateUtils.getMonth(currentMonthDate);
baseMapper.insertCuMemberMonthAchieve(table, cuMemberSettlePeriod.getPkId(), settleMonth);
// 每月7号发放徽章,发放上个月的
if (day == 7) {
// 查询徽章
List<CuHonorWall> cuHonorWallList = iCuHonorWallService.queryCuHonorWall();
Map<String, CuHonorWall> honorWallMap = new HashMap<>();
cuHonorWallList.forEach(cuHonorWall -> {
String key = cuHonorWall.getPkCountry().toString() + cuHonorWall.getType() + cuHonorWall.getValue();
honorWallMap.put(key, cuHonorWall);
});
List<CuMemberHonorWall> cuMemberHonorWallList = new ArrayList<>();
// 上月期间，作为结束期间
String beforeFirstMonthDate = DateUtils.beforeMonthFirstDateStr(settleDate);
CuMemberSettlePeriod beforePeriod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(beforeFirstMonthDate);
// 月徽章
grantHonorWall(beforePeriod.getPkId(), cuMemberSettlePeriod.getPkId(), settleMonth,
HonorWallType.RECOMMEND_MONTH.getValue(), HonorWallType.ANTIFADING_MONTH.getValue(), honorWallMap, cuMemberHonorWallList);
// 再发季度徽章
if (month == 1 || month == 4 || month == 7 || month == 10) {
// 3个月期间，作为开始期间
String quarterFirstMonthDate = DateUtils.beforeMonthFirstDateStr(3, settleDate);
CuMemberSettlePeriod quarterPeriod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(quarterFirstMonthDate);
grantHonorWall(quarterPeriod.getPkId(), cuMemberSettlePeriod.getPkId(), settleMonth,
HonorWallType.RECOMMEND_QUARTER.getValue(), HonorWallType.ANTIFADING_QUARTER.getValue(), honorWallMap, cuMemberHonorWallList);
if (month == 1) {
// 再发年度徽章
// 3个月期间，作为开始期间
String yearFirstMonthDate = DateUtils.beforeMonthFirstDateStr(12, settleDate);
CuMemberSettlePeriod yearPeriod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(yearFirstMonthDate);
if (yearPeriod != null) {
grantHonorWall(yearPeriod.getPkId(), cuMemberSettlePeriod.getPkId(), settleMonth,
HonorWallType.RECOMMEND_QUARTER.getValue(), HonorWallType.ANTIFADING_QUARTER.getValue(), honorWallMap, cuMemberHonorWallList);
}
}
}
if (cuMemberHonorWallList.size() > 0) {
iCuMemberHonorWallService.saveBatch(cuMemberHonorWallList);
}
}
}
@Override
@ -133,37 +83,4 @@ public class CuMemberMonthAchieveServiceImpl extends ServiceImpl<CuMemberMonthAc
iCuMemberAchieveService.mergeCuMemberMonth(0, DateUtils.parseDateToFormat(DateUtils.YYYY_MM_DD, settleDate));
}
private void grantHonorWall(Integer startPeriod, Integer endPeriod, String settleMonth, Integer recommend, Integer repurchase,
Map<String, CuHonorWall> honorWallMap, List<CuMemberHonorWall> cuMemberHonorWallList) {
// 先发月徽章 查询值，查询前3名
List<CuMemberMonthAchieveExt> cuMemberMonthAchieveList = baseMapper.queryCuMemberMonthAchieveByDate(startPeriod, endPeriod, recommend, repurchase);
if (CollectionUtil.isNotEmpty(cuMemberMonthAchieveList)) {
Map<Integer, List<CuMemberMonthAchieveExt>> monthAchieveMap = new HashMap<>();
cuMemberMonthAchieveList.forEach(cuMemberMonthAchieve -> {
if (monthAchieveMap.containsKey(cuMemberMonthAchieve.getWallType())) {
monthAchieveMap.get(cuMemberMonthAchieve.getWallType()).add(cuMemberMonthAchieve);
} else {
List<CuMemberMonthAchieveExt> cuMemberMonthAchieveExtList = new ArrayList<>();
cuMemberMonthAchieveExtList.add(cuMemberMonthAchieve);
monthAchieveMap.put(cuMemberMonthAchieve.getWallType(), cuMemberMonthAchieveExtList);
}
});
monthAchieveMap.forEach((wallType, cuMemberMonthAchieveExtList) -> {
for (int i = 1; i <= cuMemberMonthAchieveExtList.size(); i++) {
CuMemberMonthAchieveExt cuMemberMonthAchieveExt = cuMemberMonthAchieveExtList.get(i - 1);
String key = cuMemberMonthAchieveExt.getPkCountry().toString() + cuMemberMonthAchieveExt.getWallType() + i;
if (honorWallMap.containsKey(key)) {
CuMemberHonorWall cuMemberHonorWall = CuMemberHonorWall.builder()
.pkMember(cuMemberMonthAchieveExt.getPkMember())
.pkHonorWall(honorWallMap.get(key).getPkId())
.settleMonth(settleMonth)
.build();
cuMemberHonorWall.setPkCountry(cuMemberMonthAchieveExt.getPkCountry());
cuMemberHonorWall.setPkCreator(MagicNumberConstants.PK_ADMIN);
cuMemberHonorWallList.add(cuMemberHonorWall);
}
}
});
}
}
}

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

@ -7,11 +7,9 @@ import com.hzs.bonus.achieve.service.ICuMemberTreeService;
import com.hzs.common.core.constant.MagicNumberConstants;
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.domain.member.achieve.CuMemberTree;
import com.hzs.common.domain.member.ext.CuMemberSettleExt;
import com.hzs.common.domain.sale.ext.SaOrderExt;
import com.hzs.bonus.achieve.mapper.CuMemberTreeMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
@ -28,32 +26,18 @@ import java.util.*;
@Service
public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuMemberTree> implements ICuMemberTreeService {
private ICuMemberAchieveService cuMemberAchieveService;
@Autowired
private ICuMemberAchieveService iCuMemberAchieveService;
@Autowired
private ICuMemberSettlePeriodService iCuMemberSettlePeriodService;
@Autowired
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 setCuMemberAchieveService(ICuMemberAchieveService cuMemberAchieveService) {
this.cuMemberAchieveService = cuMemberAchieveService;
}
@Override
@Transactional(rollbackFor = Exception.class)
public void createCuMemberTree(String date) {
// 创建日表记录表
int period = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(date).getPkId();
int period = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(date).getPkId();
String settleTableName = TableNameConstants.CU_MEMBER_SETTLE + period;
Integer number = baseMapper.queryExistOracleTable(settleTableName);
if (number == null || number <= 0) {
@ -78,12 +62,12 @@ public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuM
// 创建月表记录表
createMonthTreeTableName(date);
// 创建月表业绩记录表
cuMemberAchieveService.createCuMemberAchieve(date);
iCuMemberAchieveService.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();
int nextPeriod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(tomorrow).getPkId();
String secondRetailRangeTableName = TableNameConstants.CU_MEMBER_RETAIL_S + nextPeriod;
number = baseMapper.queryExistOracleTable(secondRetailRangeTableName);
if (number == null || number <= 0) {
@ -107,11 +91,6 @@ public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuM
return monthTableName;
}
@Override
public void initCuMemberExpandTreeTable(String yesterdaySettleTableName, String currentSettleTableName) {
cuMemberAchieveService.updateCuMemberExpandSettleAchieveByBeforeDay(yesterdaySettleTableName, currentSettleTableName);
}
@Override
public Integer queryExistOracleTable(String tableName) {
return baseMapper.queryExistOracleTable(tableName);
@ -145,18 +124,6 @@ public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuM
baseMapper.updateCuMemberRetailRangeInitV5Award(rangeTableName);
}
@Override
public List<CuMemberSettleExt> batchQueryMemberSettleBySaOrder(String settleTableName, List<SaOrderExt> saOrderExtList) {
// 查询出推荐人
Set<Long> serviceMemberSet = new HashSet<>();
saOrderExtList.forEach(saOrderExt -> {
serviceMemberSet.add(saOrderExt.getPkReference());
// 查出自己跟推荐人
serviceMemberSet.add(saOrderExt.getPkMember());
});
return getCuMemberSettleExtList(settleTableName, serviceMemberSet);
}
private List<CuMemberSettleExt> getCuMemberSettleExtList(String settleTableName, Set<Long> serviceMemberSet) {
List<CuMemberSettleExt> cuMemberSettleExtList = new ArrayList<>();
if (serviceMemberSet.size() > 0) {
@ -173,11 +140,6 @@ public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuM
return getCuMemberSettleExtList(settleTableName, serviceMemberSet);
}
@Override
public List<CuMemberSettleExt> queryMemberSettleByAwards(String settleTableName, String rangeTableName, Integer startPeriod, Integer endPeriod) {
return baseMapper.queryMemberSettleByAwards(settleTableName, rangeTableName, startPeriod, endPeriod);
}
@Override
public List<CuMemberSettleExt> batchQueryMemberSettleParentByMemberPk(String settleTableName, Set<Long> serviceMemberSet) {
List<CuMemberSettleExt> cuMemberSettleExtList = new ArrayList<>();
@ -190,26 +152,6 @@ public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuM
return cuMemberSettleExtList;
}
@Override
public Map<Long, List<CuMemberSettleExt>> batchQueryCuMemberSettlePlaceParent(String settleTableName, List<SaOrderExt> firPurchaseOrderList) {
// 查询出所有父级安置人
List<CuMemberSettleExt> cuMemberSettleExtList = new ArrayList<>();
List<List<?>> listList = cuMemberBonusSettle.handleCutList(firPurchaseOrderList, MagicNumberConstants.DELETE_DATA_BATCH_UPDATE_NUM);
listList.forEach(list ->
cuMemberSettleExtList.addAll(baseMapper.batchQueryCuMemberSettlePlaceParent(settleTableName, list)));
Map<Long, List<CuMemberSettleExt>> memberSettleMap = new HashMap<>(ComputeUtil.mapInitCapacity(firPurchaseOrderList.size()));
cuMemberSettleExtList.forEach(cuMemberSettleExt -> {
if (memberSettleMap.containsKey(cuMemberSettleExt.getPkOrder())) {
memberSettleMap.get(cuMemberSettleExt.getPkOrder()).add(cuMemberSettleExt);
} else {
List<CuMemberSettleExt> cuMemberSettles = new ArrayList<>();
cuMemberSettles.add(cuMemberSettleExt);
memberSettleMap.put(cuMemberSettleExt.getPkOrder(), cuMemberSettles);
}
});
return memberSettleMap;
}
@Override
public List<CuMemberSettleExt> batchQueryCuMemberSettleParent(String settleTableName, Set<Long> expandMemberSet) {
List<CuMemberSettleExt> cuMemberSettleExtList = new ArrayList<>();
@ -223,22 +165,6 @@ public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuM
return cuMemberSettleExtList;
}
@Override
public List<CuMemberSettleExt> batchQueryCuMemberSettleParentForSpecial(String settleTableName, Set<Long> expandMemberSet) {
List<CuMemberSettleExt> cuMemberSettleExtList = new ArrayList<>();
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.batchQueryCuMemberSettleParentForSpecial(settleTableName, list)));
return cuMemberSettleExtList;
}
@Override
public void updateCuMemberExpandSettle(String settleTableName, Map<Long, CuMemberSettleExt> cuMemberTreeMap) {
List<List<?>> treeList = setUpdCuMemberTreeLists(cuMemberTreeMap);
treeList.forEach(list -> baseMapper.updateCuMemberExpandSettle(settleTableName, list));
}
private List<List<?>> setUpdCuMemberTreeLists(Map<Long, CuMemberSettleExt> cuMemberTreeMap) {
List<CuMemberSettleExt> cuMemberTreeList = new ArrayList<>();
cuMemberTreeMap.forEach((key, value) -> cuMemberTreeList.add(value));

29
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/base/mapper/CuAwardsControlMapper.java
View File

@ -1,29 +0,0 @@
package com.hzs.bonus.base.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hzs.common.domain.member.base.CuAwardsControl;
import com.hzs.bonus.base.vo.CuAwardsControlVO;
import java.util.List;
/**
* <p>
* 真实奖衔控制 Mapper 接口
* </p>
*
* @author hzs
* @since 2023-04-07
*/
public interface CuAwardsControlMapper extends BaseMapper<CuAwardsControl> {
/**
* @description: 查询奖衔控制列表
* @author: zhang jing
* @date: 2023/4/8 11:40
* @param: [controlVO]
* @return: java.util.List<com.hzs.member.base.vo.CuAwardsControlVO>
**/
List<CuAwardsControlVO> queryAwardsControlList(CuAwardsControlVO controlVO);
}

14
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/base/mapper/CuHonorWallMapper.java
View File

@ -1,14 +0,0 @@
package com.hzs.bonus.base.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hzs.common.domain.member.honor.CuHonorWall;
/**
* 荣誉墙 Mapper 接口
*
* @author hzs
* @since 2023-04-26
*/
public interface CuHonorWallMapper extends BaseMapper<CuHonorWall> {
}

16
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/base/mapper/CuMemberHonorWallMapper.java
View File

@ -1,16 +0,0 @@
package com.hzs.bonus.base.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hzs.common.domain.member.honor.CuMemberHonorWall;
/**
* <p>
* 会员荣誉墙关联表 Mapper 接口
* </p>
*
* @author hzs
* @since 2023-04-26
*/
public interface CuMemberHonorWallMapper extends BaseMapper<CuMemberHonorWall> {
}

25
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/base/service/ICuAwardsControlService.java
View File

@ -1,25 +0,0 @@
package com.hzs.bonus.base.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hzs.common.domain.member.base.CuAwardsControl;
import java.util.List;
/**
* <p>
* 真实奖衔控制 服务类
* </p>
*
* @author hzs
* @since 2023-04-07
*/
public interface ICuAwardsControlService extends IService<CuAwardsControl> {
/*
* @description: 查询所有的真实奖衔控制会员，用于奖金计算
* @author: sui q
* @date: 2023/4/11 11:03
* @param: null null
**/
List<CuAwardsControl> queryAllCuAwardsControl();
}

27
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/base/service/ICuHonorWallService.java
View File

@ -1,27 +0,0 @@
package com.hzs.bonus.base.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hzs.common.domain.member.ext.CuHonorWallExt;
import com.hzs.common.domain.member.honor.CuHonorWall;
import java.util.List;
/**
* <p>
* 荣誉墙 服务类
* </p>
*
* @author hzs
* @since 2023-04-26
*/
public interface ICuHonorWallService extends IService<CuHonorWall> {
/*
* @description: 查询所有的徽章
* @author: sui q
* @date: 2023/6/7 14:30
* @param: null null
**/
List<CuHonorWall> queryCuHonorWall();
}

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

@ -1,16 +0,0 @@
package com.hzs.bonus.base.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hzs.common.domain.member.honor.CuMemberHonorWall;
/**
* <p>
* 会员荣誉墙关联表 服务类
* </p>
*
* @author hzs
* @since 2023-04-26
*/
public interface ICuMemberHonorWallService extends IService<CuMemberHonorWall> {
}

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

@ -5,7 +5,6 @@ import com.hzs.common.domain.member.base.CuMember;
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 java.util.Date;
import java.util.List;
@ -23,14 +22,6 @@ public interface ICuMemberService extends IService<CuMember> {
*/
CuMemberExt getMemberByCode(String memberCode);
/**
* 获取会员缓存
*
* @param memberCode 会员编号的值
* @return CuMember
*/
CuMember getMember(String memberCode);
/**
* 更新会员奖衔根据临时表
*

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

@ -1,29 +0,0 @@
package com.hzs.bonus.base.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hzs.bonus.base.service.ICuAwardsControlService;
import com.hzs.common.domain.member.base.CuAwardsControl;
import com.hzs.bonus.base.mapper.CuAwardsControlMapper;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* <p>
* 真实奖衔控制 服务实现类
* </p>
*
* @author hzs
* @since 2023-04-07
*/
@Service
public class CuAwardsControlServiceImpl extends ServiceImpl<CuAwardsControlMapper, CuAwardsControl> implements ICuAwardsControlService {
@Override
public List<CuAwardsControl> queryAllCuAwardsControl() {
QueryWrapper<CuAwardsControl> queryWrapper = new QueryWrapper<>();
return baseMapper.selectList(queryWrapper);
}
}

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

@ -1,28 +0,0 @@
package com.hzs.bonus.base.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hzs.bonus.base.mapper.CuHonorWallMapper;
import com.hzs.bonus.base.service.ICuHonorWallService;
import com.hzs.common.domain.member.honor.CuHonorWall;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 荣誉墙 服务实现类
*
* @author hzs
* @since 2023-04-26
*/
@Service
public class CuHonorWallServiceImpl extends ServiceImpl<CuHonorWallMapper, CuHonorWall> implements ICuHonorWallService {
@Override
public List<CuHonorWall> queryCuHonorWall() {
QueryWrapper<CuHonorWall> queryWrapper = new QueryWrapper<>();
queryWrapper.select("pk_id,PK_COUNTRY,TYPE,VALUE,IMG");
return baseMapper.selectList(queryWrapper);
}
}

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

@ -1,20 +0,0 @@
package com.hzs.bonus.base.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hzs.bonus.base.mapper.CuMemberHonorWallMapper;
import com.hzs.bonus.base.service.ICuMemberHonorWallService;
import com.hzs.common.domain.member.honor.CuMemberHonorWall;
import org.springframework.stereotype.Service;
/**
* <p>
* 会员荣誉墙关联表 服务实现类
* </p>
*
* @author hzs
* @since 2023-04-26
*/
@Service
public class CuMemberHonorWallServiceImpl extends ServiceImpl<CuMemberHonorWallMapper, CuMemberHonorWall> implements ICuMemberHonorWallService {
}

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

@ -24,14 +24,6 @@ public class CuMemberServiceImpl extends ServiceImpl<CuMemberMapper, CuMember> i
return baseMapper.queryLoginMember(memberCode, null);
}
@Override
public CuMember getMember(String memberCode) {
if (StringUtils.isEmpty(memberCode)) {
return null;
}
return baseMapper.queryLoginMember(memberCode, null);
}
@Override
public void updateCuMemberRetailRangeByPeriod(List<CuMemberAwards> cuMemberAwardsList, Integer period) {
baseMapper.updateCuMemberRetailAwardsByPeriod(period, EAwardsType.RANGE_TYPE.getValue());

113
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/controller/manage/CuBonusExpandController.java
View File

@ -1,113 +0,0 @@
package com.hzs.bonus.bonus.controller.manage;
import com.hzs.bonus.bonus.param.BonusExpandParam;
import com.hzs.bonus.bonus.service.ICuBonusExpandService;
import com.hzs.bonus.bonus.vo.BonusExpandTitleVO;
import com.hzs.common.core.annotation.AccessPermissions;
import com.hzs.common.core.constant.HttpStatus;
import com.hzs.common.core.constant.msg.MemberMsgConstants;
import com.hzs.common.core.enums.EYesNo;
import com.hzs.common.core.utils.DateUtils;
import com.hzs.common.core.web.controller.BaseController;
import com.hzs.common.core.web.domain.AjaxResult;
import com.hzs.common.core.web.page.TableDataInfo;
import com.hzs.common.domain.member.ext.CuBonusExpandExt;
import com.hzs.common.security.utils.SecurityUtils;
import com.hzs.common.util.TransactionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.time.temporal.ChronoUnit;
import java.util.*;
/**
* <p>
* 4-n增加设置碰次 前端控制器
* </p>
*
* @author hzs
* @since 2024-07-19
*/
@RestController
@RequestMapping("/expand")
public class CuBonusExpandController extends BaseController {
@Autowired
private ICuBonusExpandService bonusExpandService;
/**
* 在管理页面修改保存4-n参数
*
* @return AjaxResult
*/
@PostMapping("/touch/save")
public AjaxResult saveCuBonusExpand(@RequestBody BonusExpandParam bonusExpandParam) {
if (bonusExpandParam.getAddTouch() == null) {
return AjaxResult.error(TransactionUtils.getContent(MemberMsgConstants.REQUIRED_NOT_EMPTY));
}
if (bonusExpandParam.getPkId() == null && bonusExpandParam.getSettleDate() == null) {
return AjaxResult.error(TransactionUtils.getContent(MemberMsgConstants.REQUIRED_NOT_EMPTY));
}
bonusExpandParam.setPkCountry(SecurityUtils.getPkCountry());
bonusExpandParam.setPkModified(SecurityUtils.getUserId());
bonusExpandService.saveCuBonusExpand(bonusExpandParam);
return AjaxResult.success();
}
/**
* 在管理页面修改保存4-n参数
*
* @return AjaxResult
*/
@PostMapping("/touch/repeat")
public AjaxResult repeatCuBonusByExpand(@RequestBody BonusExpandParam bonusExpandParam) {
if (bonusExpandParam.getSettleDate() == null) {
return AjaxResult.error(TransactionUtils.getContent(MemberMsgConstants.REQUIRED_NOT_EMPTY));
}
bonusExpandParam.setPkCountry(SecurityUtils.getPkCountry());
bonusExpandService.repeatCuBonusByExpand(bonusExpandParam);
return AjaxResult.success();
}
/**
* 分页查询会员某个时间段内的奖金汇总
*/
@AccessPermissions("ForeNumber")
@PostMapping("/touch/query")
public TableDataInfo listCuBonusExpand(@RequestBody BonusExpandParam bonusExpandParam) {
if (bonusExpandParam.getSettleDate() == null) {
TableDataInfo rspData = new TableDataInfo();
rspData.setCode(HttpStatus.ERROR);
rspData.setMsg("查询条件中结算日期不能为空");
return rspData;
}
bonusExpandParam.setPkCountry(SecurityUtils.getPkCountry());
startPage();
return getDataTable(bonusExpandService.queryBonusExpand(bonusExpandParam));
}
/**
* 分页查询会员某个时间段内的奖金汇总
*/
@GetMapping("/touch/query-title")
public TableDataInfo listCuBonusExpandTitle() {
BonusExpandParam bonusExpandParam = BonusExpandParam.builder().pkCountry(SecurityUtils.getPkCountry()).build();
Map<Date, CuBonusExpandExt> bonusExpandExtMap = new HashMap<>();
List<CuBonusExpandExt> cuBonusExpandExtList = bonusExpandService.queryBonusExpandDis(bonusExpandParam);
cuBonusExpandExtList.forEach(cuBonusExpandExt ->
bonusExpandExtMap.put(cuBonusExpandExt.getSettleDate(), cuBonusExpandExt));
List<BonusExpandTitleVO> bonusExpandTitleVoList = new ArrayList<>();
for (int i = 1; i <= 6; i++) {
Date settleDate = DateUtils.beforeDate(i, ChronoUnit.DAYS);
BonusExpandTitleVO bonusExpandTitleVO = new BonusExpandTitleVO();
bonusExpandTitleVO.setSettleDate(DateUtils.parseDateToFormat(DateUtils.YYYY_MM_DD, settleDate));
bonusExpandTitleVO.setIsDisplayRed(EYesNo.NO.getIntValue());
if(bonusExpandExtMap.containsKey(settleDate)){
bonusExpandTitleVO.setIsDisplayRed(EYesNo.YES.getIntValue());
}
bonusExpandTitleVoList.add(bonusExpandTitleVO);
}
return getDataTable(bonusExpandTitleVoList);
}
}

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

@ -1,50 +0,0 @@
package com.hzs.bonus.bonus.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hzs.bonus.bonus.param.BonusExpandParam;
import com.hzs.common.domain.member.bonus.CuBonusExpand;
import com.hzs.common.domain.member.ext.CuBonusExpandExt;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* Mapper 接口
*/
public interface CuBonusExpandMapper extends BaseMapper<CuBonusExpand> {
/*
* 查询4-n配置
**/
List<CuBonusExpandExt> queryBonusExpand(BonusExpandParam bonusExpandParam);
/*
* 查询日期是否标红
**/
List<CuBonusExpandExt> queryBonusExpandDis(BonusExpandParam bonusExpandParam);
/*
* 查询所有零线会员
**/
List<CuBonusExpand> queryZeroMemberByVertex();
/*
* 根基时间、期间计算波比
**/
List<CuBonusExpand> calculateDayRatioByBonusExpandParam(@Param("bonusExpandParam") BonusExpandParam bonusExpandParam, @Param("tableName") String tableName);
/*
* 根基时间、期间计算波比
**/
List<CuBonusExpand> calculateDayRepRatioByBonusExpandParam(@Param("bonusExpandParam") BonusExpandParam bonusExpandParam, @Param("tableName") String tableName);
/*
* 删除临时表
**/
void truncateTable();
/*
* 批量更新4-n配置
**/
void mergeBonusExpandByList(@Param("cuBonusExpandList") List<CuBonusExpand> cuBonusExpandList);
}

28
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/mapper/CuMemberBonusPushMapper.java
View File

@ -1,7 +1,6 @@
package com.hzs.bonus.bonus.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hzs.bonus.bonus.param.TripleCycleListParam;
import com.hzs.common.domain.member.bonus.CuMemberBonusPush;
import com.hzs.common.domain.member.ext.CuMemberBonusPushExt;
import com.hzs.bonus.bonus.param.BonusParam;
@ -10,58 +9,43 @@ import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* <p>
* 会员奖金-直推收益明细表 Mapper 接口
* </p>
*
* @author hzs
* @since 2022-11-10
*/
public interface CuMemberBonusPushMapper extends BaseMapper<CuMemberBonusPush> {
/**
* 根据查询条件查询固定的奖金明细
*
* @param bonusParam 查询条件
* @return: List<CuMemberBonusDetail>
* @Author: sui q
* @Date: 2023/1/14 11:18
*/
List<CuMemberBonusPushExt> queryMemberBonusPushByBonusItems(BonusParam bonusParam);
/**
* 根据查询条件查询固定的奖金明细
*
* @param bonusParam 查询条件
* @return: List<CuMemberBonusDetail>
* @Author: sui q
* @Date: 2023/1/14 11:18
*/
List<CuMemberBonusPushExt> queryMemberBonusPushByBonusItemsFoServer(@Param("bonusParam") BonusParam bonusParam);
/**
* 删除会员奖金汇总表
*
* @param period 结算期间
* @return: void
* @Author: sui q
* @Date: 2022/12/13 11:54
*/
void deleteCuMemberBonusPush(Integer period);
/**
* 批量插入会员直推奖
*
* @param cuMemberBonusPushList 会员奖金
* @return: void
* @Author: sui q
* @Date: 2022/12/13 13:56
*/
void batchInsertCuMemberBonusPush(@Param("cuMemberBonusPushList") List<?> cuMemberBonusPushList);
/**
* 插入会员直推奖
*
* @param cuMemberBonusPush 直推奖金
* @return: void
* @Author: sui q
* @Date: 2023/2/17 9:48
*/
void insertCuMemberBonusPush(@Param("item")CuMemberBonusPush cuMemberBonusPush);
void insertCuMemberBonusPush(@Param("item") CuMemberBonusPush cuMemberBonusPush);
}

26
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/mapper/CuMemberRepeatBonusMapper.java
View File

@ -1,26 +0,0 @@
package com.hzs.bonus.bonus.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hzs.common.domain.member.bonus.CuMemberRepeatBonus;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* <p>
* 会员奖金-4-n碰次重算奖金表 Mapper 接口
* </p>
*
* @author hzs
* @since 2024-07-23
*/
public interface CuMemberRepeatBonusMapper extends BaseMapper<CuMemberRepeatBonus> {
/*
* @description: 批量插入重算奖金数据
* @author: sui q
* @date: 2024/7/23 11:46
* @param: null null
**/
void insertCuMemberRepeatBonus(@Param("cuMemberRepeatBonusList") List<CuMemberRepeatBonus> cuMemberRepeatBonusList);
}

98
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/param/BonusExpandParam.java
View File

@ -1,98 +0,0 @@
package com.hzs.bonus.bonus.param;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
/**
* 4-n 增加碰次
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class BonusExpandParam implements Serializable {
/**
* 主键
*/
private Long pkId;
/**
* 连接主键
*/
private Long pkParent;
/**
* 结算日期
*/
private Date settleDate;
/**
* 4-n增加碰次
*/
private BigDecimal addTouch;
private List<Long> memberIdList;
/**
* 国家
*/
private Integer pkCountry;
/**
* 开始日期
*/
private Date startDate;
/**
* 结束日期
*/
private Date endDate;
/**
* 开始期间
*/
private Integer startPeriod;
/**
* 结束期间
*/
private Integer endPeriod;
/**
* 修改人ID
*/
private Long pkModified;
/**
* 体系名称
*/
private String vertexName;
/**
* 会员编号
*/
private String memberCode;
/**
* 会员姓名
*/
private String memberName;
/**
* 拓展比例
*/
private BigDecimal expandRatio;
/**
* 拓展次数
*/
private Integer expandNumber;
}

68
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/param/TripleCycleListParam.java
View File

@ -1,68 +0,0 @@
package com.hzs.bonus.bonus.param;/**
* @Description:
* @Author: yuhui
* @Time: 2023/6/7 14:43
* @Classname: TripleCycleListParam
* @PackageName: com.hzs.member.marketnews.param
*/
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.util.Date;
/**
*@BelongsProject: hzs_cloud
*@BelongsPackage: com.hzs.member.marketnews.param
*@Author: yh
*@CreateTime: 2023-06-07 14:43
*@Description: TODO
*@Version: 1.0
*/
@Data
public class TripleCycleListParam {
/**
* 会员主键
*/
private Long pkMember;
/**
* 会员编号
*/
private String memberCode;
/**
* 会员姓名
*/
private String memberName;
/**
* 开始时间
*/
@JsonFormat(pattern = "yyyy-MM-dd")
private Date startCreationTime;
/**
* 结束时间
*/
@JsonFormat(pattern = "yyyy-MM-dd")
private Date endCreationTime;
/**
* 国家
*/
private Integer pkCountry;
/**
* 注册等级
*/
private Integer pkRegisterGrade;
/**
* 查询会员信息
*/
private String memberInfo;
}

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

@ -22,9 +22,4 @@ public interface IBonusSettleService {
*/
void calculateCuMemberRetailRangeBonusBySaOrder(String orderCode);
/*
* 4-n配置修改后，重算首购奖金
**/
void repeatCuMemberBonusByExpand(String settleDate, List<SaOrderExt> saOrderExtList);
}

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

@ -1,45 +0,0 @@
package com.hzs.bonus.bonus.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hzs.bonus.bonus.param.BonusExpandParam;
import com.hzs.common.domain.member.bonus.CuBonusExpand;
import com.hzs.common.domain.member.ext.CuBonusExpandExt;
import java.util.List;
/**
* 服务类
*/
public interface ICuBonusExpandService extends IService<CuBonusExpand> {
/*
* 查询4-n配置
**/
List<CuBonusExpandExt> queryBonusExpand(BonusExpandParam bonusExpandParam);
/*
* 查询日期是否标红
**/
List<CuBonusExpandExt> queryBonusExpandDis(BonusExpandParam bonusExpandParam);
/*
* 奖金计算时，先拉取昨日4-n 碰次，先用该碰次计算
**/
void firstSaveCuBonusExpand(BonusExpandParam bonusExpandParam);
/*
* 奖金计算结束，统计波比、业绩
**/
void updateCuBonusExpandRatio(BonusExpandParam bonusExpandParam, String tableName);
/*
* 保存或修改昨日4-n碰次
**/
void saveCuBonusExpand(BonusExpandParam bonusExpandParam);
/*
* 重算首购奖金
**/
void repeatCuBonusByExpand(BonusExpandParam bonusExpandParam);
}

24
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/service/ICuMemberBonusPushService.java
View File

@ -1,48 +1,28 @@
package com.hzs.bonus.bonus.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hzs.bonus.bonus.param.TripleCycleListParam;
import com.hzs.common.domain.member.bonus.CuMemberBonusPush;
import com.hzs.common.domain.member.ext.CuMemberBonusPushExt;
import java.util.List;
import java.util.Set;
/**
* <p>
* 会员奖金-直推收益明细表 服务类
* </p>
*
* @author hzs
* @since 2022-11-10
*/
public interface ICuMemberBonusPushService extends IService<CuMemberBonusPush> {
/**
* 删除会员奖金汇总表
*
* @param period 结算周期
* @return: void
* @Author: sui q
* @Date: 2022/12/13 11:54
*/
void deleteCuMemberBonusPush(Integer period);
/**
* 批量插入会员直推奖
*
* @param cuMemberBonusPushList 会员奖金
* @return: void
* @Author: sui q
* @Date: 2022/12/13 13:56
*/
void batchInsertCuMemberBonusPush(List<CuMemberBonusPush> cuMemberBonusPushList, Set<Long> memberIdSet);
/**
* 插入会员直推奖
* @param cuMemberBonusPush 直推奖金
* @return: void
* @Author: sui q
* @Date: 2023/2/17 9:48
*/
void insertCuMemberBonusPush(CuMemberBonusPush cuMemberBonusPush);
}

25
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/service/ICuMemberRepeatBonusService.java
View File

@ -1,25 +0,0 @@
package com.hzs.bonus.bonus.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hzs.common.domain.member.bonus.CuMemberRepeatBonus;
import java.util.List;
/**
* <p>
* 会员奖金-4-n碰次重算奖金表 服务类
* </p>
*
* @author hzs
* @since 2024-07-23
*/
public interface ICuMemberRepeatBonusService extends IService<CuMemberRepeatBonus> {
/*
* @description: 批量插入重算奖金数据
* @author: sui q
* @date: 2024/7/23 11:46
* @param: null null
**/
void insertCuMemberRepeatBonus(List<CuMemberRepeatBonus> cuMemberRepeatBonusList);
}

1169
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/service/impl/BonusSettleFirstPurchaseHandle.java
View File

File diff suppressed because it is too large Load Diff

1005
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/service/impl/BonusSettlePurchaseHandle.java
View File

File diff suppressed because it is too large Load Diff

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

@ -1,46 +1,26 @@
package com.hzs.bonus.bonus.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.hzs.bonus.achieve.service.ICuMemberSettlePeriodService;
import com.hzs.bonus.achieve.service.ICuMemberTreeService;
import com.hzs.bonus.base.service.ICuAwardsControlService;
import com.hzs.bonus.bonus.param.BonusExpandParam;
import com.hzs.bonus.bonus.param.LeXueRangeParam;
import com.hzs.bonus.bonus.service.*;
import com.hzs.bonus.bonus.vo.BonusRecordDetailVO;
import com.hzs.bonus.bonus.vo.MemberBonusDetailCalVO;
import com.hzs.bonus.detail.service.ICuRegionAssessService;
import com.hzs.bonus.order.service.IBonusOrderService;
import com.hzs.bonus.risk.service.ICuMemberRiskControlService;
import com.hzs.common.core.config.BdConfig;
import com.hzs.common.core.constant.BonusFieldConstants;
import com.hzs.common.core.constant.MagicNumberConstants;
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.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.bonus.*;
import com.hzs.common.domain.member.ext.CuBonusExpandExt;
import com.hzs.common.domain.member.ext.CuMemberSettleExt;
import com.hzs.common.domain.sale.ext.SaOrderExt;
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.dto.BonusConfigDTO;
import com.hzs.system.config.dto.RangeDTO;
import lombok.extern.slf4j.Slf4j;
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.*;
@ -51,10 +31,6 @@ import java.util.*;
@Slf4j
public class BonusSettleServiceImpl implements IBonusSettleService {
@DubboReference
ISystemConfigServiceApi iSystemConfigServiceApi;
@DubboReference
IAwardsServiceApi iAwardsServiceApi;
@DubboReference
IBonusItemsServiceApi iBonusItemsServiceApi;
@ -63,23 +39,9 @@ public class BonusSettleServiceImpl implements IBonusSettleService {
@Autowired
private ICuRegionAssessService cuRegionAssessService;
@Autowired
private ICuMemberTreeService cuMemberTreeService;
@Autowired
private ICuMemberSettlePeriodService cuMemberSettlePeriodService;
@Autowired
private ICuAwardsControlService cuAwardsControlService;
@Autowired
private ICuMemberRepeatBonusService cuMemberRepeatBonusService;
@Autowired
private BonusSettleRangeHandle bonusSettleRangeHandle;
@Autowired
private ICuBonusExpandService bonusExpandService;
@Autowired
private BonusSettleFirstPurchaseHandle bonusSettleFirstPurchaseHandle;
@Autowired
private BonusSettlePurchaseHandle bonusSettlePurchaseHandle;
@Autowired
private ICuMemberRiskControlService cuMemberRiskControlService;
private ICuMemberBonusService cuMemberBonusService;
@ -251,75 +213,6 @@ public class BonusSettleServiceImpl implements IBonusSettleService {
}
}
@Override
@Transactional(rollbackFor = Exception.class)
public void repeatCuMemberBonusByExpand(String settleDate, List<SaOrderExt> saOrderExtList) {
Integer period = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(settleDate).getPkId();
String currentSettleTableName = TableNameConstants.CU_MEMBER_SETTLE + period;
String yesterday = DateUtils.beforeDateStr(1, ChronoUnit.DAYS, DateUtils.YYYY_MM_DD, settleDate);
Integer yesterdayPeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(yesterday).getPkId();
String yesterdayTableName = TableNameConstants.CU_MEMBER_SETTLE + yesterdayPeriod;
cuMemberTreeService.initCuMemberExpandTreeTable(yesterdayTableName, currentSettleTableName);
BonusConfigDTO bonusConfigDTO = iBonusItemsServiceApi.queryBonusConfigDTO().getData();
Map<Long, CuMemberSettleExt> cuMemberSettleExtMap = new HashMap<>();
Map<Long, CuMemberBonus> cuMemberBonusMap = new HashMap<>();
Map<Long, CuAwardsControl> cuAwardsControlMap = getCuAwardsControlMap();
Map<Long, CuMemberBonus> weekMemberBonusMap = getWeekMemberBonusMap(settleDate, period);
Map<String, String> systemConfigMap = iSystemConfigServiceApi.getBonusSystemConfig().getData();
BonusRecordDetailVO recordDetailVO = new BonusRecordDetailVO();
Map<String, BdAwards> awardsMap = iAwardsServiceApi.getAwards().getData();
// 首购订单
List<SaOrderExt> firPurchaseOrderList = new ArrayList<>();
saOrderExtList.forEach(saOrderExt ->
packageSaOrderListByType(firPurchaseOrderList, null, saOrderExt));
// 查询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));
}
// 查询所有的4-n碰次
BonusExpandParam bonusExpandParam = BonusExpandParam.builder().settleDate(DateUtils.parseStringToDate(settleDate)).build();
Map<Long, CuBonusExpandExt> cuBonusExpandExtMap = new HashMap<>();
List<CuBonusExpandExt> cuBonusExpandExtList = bonusExpandService.queryBonusExpand(bonusExpandParam);
cuBonusExpandExtList.forEach(cuBonusExpandExt -> cuBonusExpandExtMap.put(cuBonusExpandExt.getPkMember(), cuBonusExpandExt));
if (firPurchaseOrderList.size() > 0) {
calculateFirPurchaseOrder(riskControlMap, cuMemberSettleExtMap, currentSettleTableName, settleDate, systemConfigMap, bonusConfigDTO,
firPurchaseOrderList, period, weekMemberBonusMap, cuMemberBonusMap, recordDetailVO, awardsMap, cuAwardsControlMap, cuBonusExpandExtMap);
}
List<CuMemberRepeatBonus> cuMemberBonusList = new ArrayList<>();
for (CuMemberBonus cuMemberBonus : cuMemberBonusMap.values()) {
cuMemberBonusList.add(BeanUtil.copyProperties(cuMemberBonus, CuMemberRepeatBonus.class));
}
if (cuMemberBonusList.size() > 0) {
cuMemberRepeatBonusService.insertCuMemberRepeatBonus(cuMemberBonusList);
}
if (cuMemberSettleExtMap.size() > 0) {
// 处理网体，更新网体新增 轮次最小值 cuMemberSettleExtMap
cuMemberTreeService.updateCuMemberExpandSettle(currentSettleTableName, cuMemberSettleExtMap);
}
}
private Map<Long, CuMemberBonus> getWeekMemberBonusMap(String settleDate, Integer period) {
// 根据结算日期获取周期的期间，用于海外
String recentlyMonday = DateUtils.getRecentlyTuesday(settleDate);
CuMemberSettlePeriod startMemberSettlePeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(recentlyMonday);
// 查询封顶周期是周的国家的所有人的拓展收益、复购拓展收益
return cuMemberBonusService.queryWeekMemberBonus(startMemberSettlePeriod.getPkId(), period);
}
private Map<Long, CuAwardsControl> getCuAwardsControlMap() {
// 查询真实奖衔控制
List<CuAwardsControl> cuAwardsControls = cuAwardsControlService.queryAllCuAwardsControl();
Map<Long, CuAwardsControl> cuAwardsControlMap = new HashMap<>(ComputeUtil.mapInitCapacity(cuAwardsControls.size()));
if (CollectionUtil.isNotEmpty(cuAwardsControls)) {
cuAwardsControls.forEach(cuAwardsControl ->
cuAwardsControlMap.put(cuAwardsControl.getPkMember(), cuAwardsControl));
}
return cuAwardsControlMap;
}
/**
* 计算每天的奖金入库
*
@ -400,173 +293,4 @@ public class BonusSettleServiceImpl implements IBonusSettleService {
return cuMemberBonusList;
}
/**
* 根据订单类型封装为不同订单列表
*
* @param firPurchaseOrderList 首购
* @param repurchaseOrderList 复购
* @param saOrderExt 来源订单
*/
private void packageSaOrderListByType(List<SaOrderExt> firPurchaseOrderList, List<SaOrderExt> repurchaseOrderList, SaOrderExt saOrderExt) {
if (Objects.equals(EOrderType.REGISTER_ORDER.getValue(), saOrderExt.getOrderType()) ||
Objects.equals(EOrderType.UPGRADE_ORDER.getValue(), saOrderExt.getOrderType())) {
firPurchaseOrderList.add(saOrderExt);
} else if (Objects.equals(EOrderType.FICTITIOUS_ORDER.getValue(), saOrderExt.getOrderType())) {
firPurchaseOrderList.add(saOrderExt);
} else if (Objects.equals(EOrderType.REPURCHASE_ORDER.getValue(), saOrderExt.getOrderType())) {
repurchaseOrderList.add(saOrderExt);
} else if (Objects.equals(EOrderType.MALL_ORDER.getValue(), saOrderExt.getOrderType()) ||
Objects.equals(EOrderType.COOPERATE_ORDER.getValue(), saOrderExt.getOrderType())) {
repurchaseOrderList.add(saOrderExt);
} else {
// 商城订单也计算复购量奖
repurchaseOrderList.add(saOrderExt);
}
}
/**
* 计算首购订单的奖金
*
* @param settleTableName 结算日表
* @param settleDate 结算日期
* @param bonusConfigDTO 各个国家奖金参数
* @param firPurchaseOrderList 首购订单
*/
private void calculateFirPurchaseOrder(Map<Long, CuMemberRiskControl> riskControlMap, Map<Long, CuMemberSettleExt> cuMemberSettleExtMap, String settleTableName, String settleDate, Map<String, String> systemConfigMap,
BonusConfigDTO bonusConfigDTO, List<SaOrderExt> firPurchaseOrderList, Integer period, Map<Long, CuMemberBonus> weekMemberBonusMap,
Map<Long, CuMemberBonus> cuMemberBonusMap, BonusRecordDetailVO bonusRecordDetailVO, Map<String, BdAwards> awardsMap,
Map<Long, CuAwardsControl> cuAwardsControlMap, Map<Long, CuBonusExpandExt> cuBonusExpandExtMap) {
// 获得国家是三单循环还是四单循环
// 获得升级方式是纳入三单循环还是固定值
// 获取有订单国家的系统参数，获得三单循环还是四单循环 key 国家+系统参数key
// 需要更新的会员结算表 cuMemberSettleExtMap
//***************************计算推荐奖******************************/
List<CuMemberBonusPush> cuMemberBonusPushList = bonusSettleFirstPurchaseHandle.calculateRecommendBonus(cuMemberSettleExtMap, settleTableName, bonusConfigDTO, systemConfigMap, firPurchaseOrderList, period, cuMemberBonusMap, awardsMap);
bonusRecordDetailVO.setCuMemberBonusPushList(cuMemberBonusPushList);
//****************************计算量奖*****************************/
List<CuMemberBonusExpand> cuMemberBonusExpandList = bonusSettleFirstPurchaseHandle.calculateExpandBonus(cuMemberSettleExtMap, settleDate, settleTableName, bonusConfigDTO, systemConfigMap, firPurchaseOrderList, period, weekMemberBonusMap, cuMemberBonusMap, riskControlMap, cuBonusExpandExtMap);
if (cuMemberBonusExpandList.size() > 0) {
if (bonusRecordDetailVO.getCuMemberBonusExpandList() == null) {
bonusRecordDetailVO.setCuMemberBonusExpandList(cuMemberBonusExpandList);
} else {
bonusRecordDetailVO.getCuMemberBonusExpandList().addAll(cuMemberBonusExpandList);
}
}
//*********************************计算领导奖************************/
// 判断是否有量奖，有量奖有辅导奖
// List<CuMemberBonusCoach> cuMemberBonusCoachList = bonusSettleFirstPurchaseHandle.calculateCoachBonus(cuMemberSettleExtMap, settleTableName, settleDate, bonusConfigDTO, firPurchaseOrderList,
// cuMemberBonusExpandList, period, cuMemberBonusMap, cuAwardsControlMap, riskControlMap);
// bonusRecordDetailVO.setCuMemberBonusCoachList(cuMemberBonusCoachList);
//*********************************计算服务奖************************/
List<CuMemberBonusDetail> cuMemberBonusDetailList = bonusSettleFirstPurchaseHandle.calculateServiceBonus(cuMemberSettleExtMap, settleDate, settleTableName, bonusConfigDTO, firPurchaseOrderList, period, cuMemberBonusMap);
bonusRecordDetailVO.setCuMemberBonusDetailList(cuMemberBonusDetailList);
// 收益拨比 实发此单直推/此单所有奖金（直推、量奖） 订单拨比 所有奖金/此单金额
Map<Long, MemberBonusDetailCalVO> memberBonusDetailCalVoMap = new HashMap<>(ComputeUtil.mapInitCapacity(firPurchaseOrderList.size()));
cuMemberBonusPushList.forEach(cuMemberBonusPush -> {
MemberBonusDetailCalVO memberBonusDetailCalVO = calculateOrderRatio(memberBonusDetailCalVoMap, cuMemberBonusPush);
memberBonusDetailCalVO.setPushIncome(ComputeUtil.computeAdd(memberBonusDetailCalVO.getPushIncome(), cuMemberBonusPush.getRealIncome()));
});
cuMemberBonusExpandList.forEach(cuMemberBonusExpand -> {
MemberBonusDetailCalVO memberBonusDetailCalVO = calculateOrderRatio(memberBonusDetailCalVoMap, cuMemberBonusExpand);
memberBonusDetailCalVO.setExpandIncome(ComputeUtil.computeAdd(memberBonusDetailCalVO.getExpandIncome(), cuMemberBonusExpand.getRealIncome()));
});
// cuMemberBonusCoachList.forEach(cuMemberBonusCoach -> {
// MemberBonusDetailCalVO memberBonusDetailCalVO = calculateOrderRatio(memberBonusDetailCalVoMap, cuMemberBonusCoach);
// memberBonusDetailCalVO.setCoachIncome(ComputeUtil.computeAdd(memberBonusDetailCalVO.getCoachIncome(), cuMemberBonusCoach.getRealIncome()));
// });
cuMemberBonusDetailList.forEach(cuMemberBonusDetail -> {
MemberBonusDetailCalVO memberBonusDetailCalVO = calculateOrderRatio(memberBonusDetailCalVoMap, cuMemberBonusDetail);
memberBonusDetailCalVO.setServiceIncome(ComputeUtil.computeAdd(memberBonusDetailCalVO.getServiceIncome(), cuMemberBonusDetail.getRealIncome()));
});
Map<Long, SaOrderExt> saOrderExtMap = new HashMap<>(ComputeUtil.mapInitCapacity(firPurchaseOrderList.size()));
firPurchaseOrderList.forEach(saOrderExt ->
saOrderExtMap.put(saOrderExt.getPkId(), saOrderExt));
// 计算 收益拨比 此类型收益÷总拨金额 订单拨比 此订单所有收益之合得实发金额÷订单总金额
cuMemberBonusPushList.forEach(cuMemberBonusPush -> {
MemberBonusDetailCalVO memberBonusDetailCalVO = memberBonusDetailCalVoMap.get(cuMemberBonusPush.getPkOrder());
SaOrderExt saOrderExt = saOrderExtMap.get(memberBonusDetailCalVO.getPkOrder());
cuMemberBonusPush.setIncomeDialRatio(ComputeUtil.computeDivide(memberBonusDetailCalVO.getPushIncome(), memberBonusDetailCalVO.getRealIncome()));
cuMemberBonusPush.setOrderDialRatio(ComputeUtil.computeDivide(memberBonusDetailCalVO.getRealIncome(), saOrderExt.getOrderAmount()));
});
// 拓展收益
cuMemberBonusExpandList.forEach(cuMemberBonusExpand -> {
MemberBonusDetailCalVO memberBonusDetailCalVO = memberBonusDetailCalVoMap.get(cuMemberBonusExpand.getPkOrder());
SaOrderExt saOrderExt = saOrderExtMap.get(memberBonusDetailCalVO.getPkOrder());
cuMemberBonusExpand.setIncomeDialRatio(ComputeUtil.computeDivide(memberBonusDetailCalVO.getExpandIncome(), memberBonusDetailCalVO.getRealIncome()));
cuMemberBonusExpand.setOrderDialRatio(ComputeUtil.computeDivide(memberBonusDetailCalVO.getRealIncome(), saOrderExt.getOrderAmount()));
});
// 辅导收益
// cuMemberBonusCoachList.forEach(cuMemberBonusCoach -> {
// MemberBonusDetailCalVO memberBonusDetailCalVO = memberBonusDetailCalVoMap.get(cuMemberBonusCoach.getPkOrder());
// SaOrderExt saOrderExt = saOrderExtMap.get(memberBonusDetailCalVO.getPkOrder());
// cuMemberBonusCoach.setIncomeDialRatio(ComputeUtil.computeDivide(memberBonusDetailCalVO.getCoachIncome(), memberBonusDetailCalVO.getRealIncome()));
// cuMemberBonusCoach.setOrderDialRatio(ComputeUtil.computeDivide(memberBonusDetailCalVO.getRealIncome(), saOrderExt.getOrderAmount()));
// });
// 报单服务费
cuMemberBonusDetailList.forEach(cuMemberBonusDetail -> {
MemberBonusDetailCalVO memberBonusDetailCalVO = memberBonusDetailCalVoMap.get(cuMemberBonusDetail.getPkOrder());
SaOrderExt saOrderExt = saOrderExtMap.get(memberBonusDetailCalVO.getPkOrder());
cuMemberBonusDetail.setIncomeDialRatio(ComputeUtil.computeDivide(memberBonusDetailCalVO.getServiceIncome(), memberBonusDetailCalVO.getRealIncome()));
cuMemberBonusDetail.setOrderDialRatio(ComputeUtil.computeDivide(memberBonusDetailCalVO.getRealIncome(), ComputeUtil.computeDivide(saOrderExt.getOrderAmount(), saOrderExt.getInExchangeRate())));
});
// //*********************************计算分红奖,理论最大值************************/
// Map<Integer, List<SaOrderExt>> saOrderMap = new HashMap<>(ComputeUtil.mapInitCapacity(firPurchaseOrderList.size()));
// firPurchaseOrderList.forEach(saOrderExt -> {
// Integer key = saOrderExt.getPkCountry();
// if (saOrderMap.containsKey(key)) {
// saOrderMap.get(key).add(saOrderExt);
// } else {
// List<SaOrderExt> saOrderExtList = new ArrayList<>();
// saOrderExtList.add(saOrderExt);
// saOrderMap.put(key, saOrderExtList);
// }
// });
// saOrderMap.forEach((pkCountry, saOrderExtList) -> {
// CuMemberShareMax cuMemberShareMax = CuMemberShareMax.builder()
// .period(period)
// .pkRate(saOrderExtList.get(0).getPkRate())
// .shareIncome(BigDecimal.ZERO)
// .orderAchieve(BigDecimal.ZERO)
// .build();
// cuMemberShareMax.setPkCountry(pkCountry);
// cuMemberShareMax.setPkCreator(MagicNumberConstants.PK_ADMIN);
// saOrderExtList.forEach(saOrderExt -> {
// cuMemberShareMax.setOrderAchieve(ComputeUtil.computeAdd(cuMemberShareMax.getOrderAchieve(), saOrderExt.getOrderAchieve()));
// cuMemberShareMax.setShareIncome(ComputeUtil.computeAdd(cuMemberShareMax.getShareIncome(), ComputeUtil.computeBonusMultiply(saOrderExt.getOrderAchieve(), BigDecimal.valueOf(5))));
// });
// cuMemberShareMaxService.insertMaxShareBonus(cuMemberShareMax);
// });
}
/**
* 计算订单奖金累计值
*/
private MemberBonusDetailCalVO calculateOrderRatio(Map<Long, MemberBonusDetailCalVO> memberBonusDetailVoMap, Object cuMemberBonus) {
Long pkOrder = ReflectUtils.invokeGetter(cuMemberBonus, "pkOrder");
MemberBonusDetailCalVO memberBonusDetailCalVO;
if (memberBonusDetailVoMap.containsKey(pkOrder)) {
memberBonusDetailCalVO = memberBonusDetailVoMap.get(pkOrder);
memberBonusDetailCalVO.setPretaxIncome(ComputeUtil.computeAdd(memberBonusDetailCalVO.getPretaxIncome(), ReflectUtils.invokeGetter(cuMemberBonus, BonusFieldConstants.PRETAX_INCOME)));
memberBonusDetailCalVO.setIncomeTax(ComputeUtil.computeAdd(memberBonusDetailCalVO.getIncomeTax(), ReflectUtils.invokeGetter(cuMemberBonus, BonusFieldConstants.INCOME_TAX)));
memberBonusDetailCalVO.setRealIncome(ComputeUtil.computeAdd(memberBonusDetailCalVO.getRealIncome(), ReflectUtils.invokeGetter(cuMemberBonus, BonusFieldConstants.REAL_INCOME)));
} else {
memberBonusDetailCalVO = MemberBonusDetailCalVO.builder()
.pkOrder(ReflectUtils.invokeGetter(cuMemberBonus, "pkOrder"))
.pretaxIncome(ReflectUtils.invokeGetter(cuMemberBonus, "pretaxIncome"))
.incomeTax(ReflectUtils.invokeGetter(cuMemberBonus, "incomeTax"))
.realIncome(ReflectUtils.invokeGetter(cuMemberBonus, "realIncome"))
.pushIncome(BigDecimal.ZERO)
.expandIncome(BigDecimal.ZERO)
.coachIncome(BigDecimal.ZERO)
.serviceIncome(BigDecimal.ZERO)
.repExpandIncome(BigDecimal.ZERO)
.repRangeIncome(BigDecimal.ZERO)
.hiFunIncome(BigDecimal.ZERO)
.haiFunIncome(BigDecimal.ZERO)
.build();
memberBonusDetailVoMap.put(pkOrder, memberBonusDetailCalVO);
}
return memberBonusDetailCalVO;
}
}

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

@ -1,204 +0,0 @@
package com.hzs.bonus.bonus.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.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hzs.bonus.achieve.service.ICuMemberSettlePeriodService;
import com.hzs.bonus.bonus.mapper.CuBonusExpandMapper;
import com.hzs.bonus.bonus.param.BonusExpandParam;
import com.hzs.bonus.bonus.service.IBonusSettleService;
import com.hzs.bonus.bonus.service.ICuBonusExpandService;
import com.hzs.common.core.annotation.Transaction;
import com.hzs.common.core.constant.CountryConstants;
import com.hzs.common.core.constant.MagicNumberConstants;
import com.hzs.common.core.constant.SystemFieldConstants;
import com.hzs.common.core.utils.ComputeUtil;
import com.hzs.common.core.utils.DateUtils;
import com.hzs.common.domain.member.achieve.CuMemberSettlePeriod;
import com.hzs.common.domain.member.bonus.CuBonusExpand;
import com.hzs.common.domain.member.ext.CuBonusExpandExt;
import com.hzs.common.domain.sale.ext.SaOrderExt;
import com.hzs.sale.order.ISaOrderServiceApi;
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.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;
/**
* 服务实现类
*/
@Service
public class CuBonusExpandServiceImpl extends ServiceImpl<CuBonusExpandMapper, CuBonusExpand> implements ICuBonusExpandService {
@DubboReference
ISaOrderServiceApi saOrderServiceApi;
@Autowired
private ICuMemberSettlePeriodService memberSettlePeriodService;
@Autowired
private IBonusSettleService bonusSettleService;
@Override
public List<CuBonusExpandExt> queryBonusExpand(BonusExpandParam bonusExpandParam) {
return baseMapper.queryBonusExpand(bonusExpandParam);
}
@Override
public List<CuBonusExpandExt> queryBonusExpandDis(BonusExpandParam bonusExpandParam) {
return baseMapper.queryBonusExpandDis(bonusExpandParam);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void firstSaveCuBonusExpand(BonusExpandParam bonusExpandParam) {
List<CuBonusExpand> bonusExpandList = queryCuBonusExpand(bonusExpandParam.getSettleDate(), bonusExpandParam.getPkCountry());
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<>();
cuBonusExpandList.forEach(cuBonusExpand -> cuBonusExpandMap.put(cuBonusExpand.getPkMember(), cuBonusExpand));
// 查询0线
List<CuBonusExpand> saveBonusExpandList = baseMapper.queryZeroMemberByVertex();
for (CuBonusExpand saveBonusExpand : saveBonusExpandList) {
saveBonusExpand.setSettleDate(bonusExpandParam.getSettleDate());
saveBonusExpand.setPkCreator(MagicNumberConstants.PK_ADMIN);
if (cuBonusExpandMap.containsKey(saveBonusExpand.getPkMember())) {
CuBonusExpand cuBonusExpand = cuBonusExpandMap.get(saveBonusExpand.getPkMember());
saveBonusExpand.setAddTouch(cuBonusExpand.getAddTouch());
saveBonusExpand.setExpandRatio(cuBonusExpand.getExpandRatio());
saveBonusExpand.setExpandNumber(cuBonusExpand.getExpandNumber());
}
if (bonusExpandParam.getAddTouch() != null) {
saveBonusExpand.setAddTouch(bonusExpandParam.getAddTouch());
saveBonusExpand.setExpandRatio(bonusExpandParam.getExpandRatio());
saveBonusExpand.setExpandNumber(bonusExpandParam.getExpandNumber());
}
}
saveBatch(saveBonusExpandList);
}
}
@Override
@Transactional(rollbackFor = Exception.class)
public void updateCuBonusExpandRatio(BonusExpandParam bonusExpandParam, String tableName) {
// 查询结算的4-n碰次设置
List<CuBonusExpand> cuBonusExpandList = queryCuBonusExpand(bonusExpandParam.getSettleDate(), bonusExpandParam.getPkCountry());
if (CollectionUtil.isNotEmpty(cuBonusExpandList)) {
Date settleDate = bonusExpandParam.getSettleDate();
Map<Long, CuBonusExpand> bonusExpandMap = new HashMap<>();
List<Long> memberIdList = new ArrayList<>();
cuBonusExpandList.forEach(cuBonusExpand -> {
bonusExpandMap.put(cuBonusExpand.getPkMember(), cuBonusExpand);
memberIdList.add(cuBonusExpand.getPkMember());
});
bonusExpandParam.setMemberIdList(memberIdList);
// 计算所有体系日波比
packageBonusExpandParam(bonusExpandParam, settleDate, settleDate);
List<CuBonusExpand> dayBonusExpandList = baseMapper.calculateDayRatioByBonusExpandParam(bonusExpandParam, tableName);
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())) {
bonusExpand.setYesDayRatio(cuBonusExpand.getYesDayRatio());
}
bonusExpand.setCurDayRatio(cuBonusExpand.getYesDayRatio());
}
}
}
List<CuBonusExpand> dayRepBonusExpandList = baseMapper.calculateDayRepRatioByBonusExpandParam(bonusExpandParam, tableName);
if (CollectionUtil.isNotEmpty(dayRepBonusExpandList)) {
for (CuBonusExpand cuBonusExpand : dayRepBonusExpandList) {
if (bonusExpandMap.containsKey(cuBonusExpand.getPkMember())) {
CuBonusExpand bonusExpand = bonusExpandMap.get(cuBonusExpand.getPkMember());
bonusExpand.setDayRepAchieve(cuBonusExpand.getDayRepAchieve());
bonusExpand.setDayRepBonus(cuBonusExpand.getDayRepBonus());
bonusExpand.setCurDayRepRatio(cuBonusExpand.getCurDayRepRatio());
}
}
}
// 计算所有体系月波比
// 获得当前月第一天，获得当前月最后一天
packageBonusExpandParam(bonusExpandParam, DateUtils.currentMonthFirstDate(settleDate), settleDate);
List<CuBonusExpand> monthBonusExpandList = baseMapper.calculateDayRatioByBonusExpandParam(bonusExpandParam, tableName);
if (CollectionUtil.isNotEmpty(monthBonusExpandList)) {
for (CuBonusExpand cuBonusExpand : monthBonusExpandList) {
if (bonusExpandMap.containsKey(cuBonusExpand.getPkMember())) {
CuBonusExpand bonusExpand = bonusExpandMap.get(cuBonusExpand.getPkMember());
bonusExpand.setMonthAchieve(cuBonusExpand.getDayAchieve());
bonusExpand.setMonthBonus(cuBonusExpand.getDayBonus());
bonusExpand.setMonthRatio(cuBonusExpand.getYesDayRatio());
}
}
}
// 批量更新数据，更新4-n的波比
baseMapper.mergeBonusExpandByList(new ArrayList<>(bonusExpandMap.values()));
}
}
private void packageBonusExpandParam(BonusExpandParam bonusExpandParam, Date settleDate, Date endDate) {
bonusExpandParam.setStartDate(settleDate);
bonusExpandParam.setEndDate(DateUtils.afterDate(1, ChronoUnit.DAYS, endDate));
CuMemberSettlePeriod startPeriod = memberSettlePeriodService.getCuMemberSettlePeriodByDate(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, bonusExpandParam.getStartDate()));
CuMemberSettlePeriod endPeriod = memberSettlePeriodService.getCuMemberSettlePeriodByDate(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, endDate));
bonusExpandParam.setStartPeriod(startPeriod.getPkId());
bonusExpandParam.setEndPeriod(endPeriod.getPkId());
}
@Override
@Transactional(rollbackFor = Exception.class)
public void saveCuBonusExpand(BonusExpandParam bonusExpandParam) {
if (bonusExpandParam.getPkId() == null) {
firstSaveCuBonusExpand(bonusExpandParam);
} else {
// 查询原数据 增加明细表
CuBonusExpand cuBonusExpand = baseMapper.selectById(bonusExpandParam.getPkId());
CuBonusExpand saveBonusExpand = BeanUtil.copyProperties(cuBonusExpand, CuBonusExpand.class);
saveBonusExpand.setPkId(null);
saveBonusExpand.setPkParent(cuBonusExpand.getPkId());
save(saveBonusExpand);
// 2 更新主表
UpdateWrapper<CuBonusExpand> updateWrapper = new UpdateWrapper<>();
updateWrapper.set("ADD_TOUCH", bonusExpandParam.getAddTouch());
updateWrapper.set("EXPAND_RATIO", bonusExpandParam.getExpandRatio());
updateWrapper.set("EXPAND_NUMBER", bonusExpandParam.getExpandNumber());
updateWrapper.set(SystemFieldConstants.PK_MODIFIED, bonusExpandParam.getPkModified());
updateWrapper.set(SystemFieldConstants.MODIFIED_TIME, DateUtils.currentDateTime());
updateWrapper.eq(SystemFieldConstants.PK_ID, bonusExpandParam.getPkId());
update(updateWrapper);
}
}
@Override
@Transactional(rollbackFor = Exception.class)
public void repeatCuBonusByExpand(BonusExpandParam bonusExpandParam) {
String settleDate = DateUtils.parseDateToFormat(DateUtils.YYYY_MM_DD, bonusExpandParam.getSettleDate());
Date endDate = DateUtils.afterDate(1, ChronoUnit.DAYS, bonusExpandParam.getSettleDate());
// 查询订单
List<SaOrderExt> saOrderExtList = saOrderServiceApi.queryRepeatSaOrderByDay(bonusExpandParam.getSettleDate(), endDate).getData();
baseMapper.truncateTable();
// 重算奖金
bonusSettleService.repeatCuMemberBonusByExpand(settleDate, saOrderExtList);
// 更新波比、业绩
updateCuBonusExpandRatio(bonusExpandParam, "cu_member_repeat_bonus");
}
private List<CuBonusExpand> queryCuBonusExpand(Date settleDate, Integer pkCountry) {
QueryWrapper<CuBonusExpand> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("SETTLE_DATE", settleDate);
if (pkCountry != null) {
queryWrapper.eq(SystemFieldConstants.PK_COUNTRY, pkCountry);
}
queryWrapper.isNull("PK_PARENT");
return baseMapper.selectList(queryWrapper);
}
}

12
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/service/impl/CuMemberBonusPushServiceImpl.java
View File

@ -2,11 +2,9 @@ package com.hzs.bonus.bonus.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hzs.bonus.achieve.service.impl.CuMemberBonusSettle;
import com.hzs.bonus.bonus.param.TripleCycleListParam;
import com.hzs.bonus.bonus.service.ICuMemberBonusPushService;
import com.hzs.common.domain.member.bonus.CuMemberBonusPush;
import com.hzs.bonus.bonus.mapper.CuMemberBonusPushMapper;
import com.hzs.common.domain.member.ext.CuMemberBonusPushExt;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@ -15,12 +13,7 @@ import java.util.List;
import java.util.Set;
/**
* <p>
* 会员奖金-直推收益明细表 服务实现类
* </p>
*
* @author hzs
* @since 2022-11-10
*/
@Service
public class CuMemberBonusPushServiceImpl extends ServiceImpl<CuMemberBonusPushMapper, CuMemberBonusPush> implements ICuMemberBonusPushService {
@ -56,9 +49,4 @@ public class CuMemberBonusPushServiceImpl extends ServiceImpl<CuMemberBonusPushM
baseMapper.batchInsertCuMemberBonusPush(list));
}
@Override
public void insertCuMemberBonusPush(CuMemberBonusPush cuMemberBonusPush) {
baseMapper.insertCuMemberBonusPush(cuMemberBonusPush);
}
}

26
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/bonus/service/impl/CuMemberRepeatBonusServiceImpl.java
View File

@ -1,26 +0,0 @@
package com.hzs.bonus.bonus.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hzs.bonus.bonus.mapper.CuMemberRepeatBonusMapper;
import com.hzs.bonus.bonus.service.ICuMemberRepeatBonusService;
import com.hzs.common.domain.member.bonus.CuMemberRepeatBonus;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* <p>
* 会员奖金-4-n碰次重算奖金表 服务实现类
* </p>
*
* @author hzs
* @since 2024-07-23
*/
@Service
public class CuMemberRepeatBonusServiceImpl extends ServiceImpl<CuMemberRepeatBonusMapper, CuMemberRepeatBonus> implements ICuMemberRepeatBonusService {
@Override
public void insertCuMemberRepeatBonus(List<CuMemberRepeatBonus> cuMemberRepeatBonusList) {
baseMapper.insertCuMemberRepeatBonus(cuMemberRepeatBonusList);
}
}

24
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/risk/param/MemberRiskControlParam.java
View File

@ -1,30 +1,16 @@
package com.hzs.bonus.risk.param;/**
* @Description:
* @Author: yuhui
* @Time: 2024/4/9 17:00
* @Classname: MemberRiskControlParam
* @PackageName: com.hzs.bonus.risk.param
*/
package com.hzs.bonus.risk.param;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.hzs.common.core.web.domain.BaseEntity;
import com.hzs.member.account.dto.MemberAmountDTO;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
/**
*@BelongsProject: hzs_cloud
*@BelongsPackage: com.hzs.bonus.risk.param
*@Author: yh
*@CreateTime: 2024-04-09 17:00
*@Description: TODO
*@Version: 1.0
*/
@EqualsAndHashCode(callSuper = true)
@Data
public class MemberRiskControlParam extends BaseEntity {
@ -37,7 +23,7 @@ public class MemberRiskControlParam extends BaseEntity {
/**
* 会员编号
*/
private String memberCode ;
private String memberCode;
/**
* 会员主键
@ -85,7 +71,6 @@ public class MemberRiskControlParam extends BaseEntity {
private Date beginEndDate;
/**
* 结束结束时间
*/
@ -108,7 +93,6 @@ public class MemberRiskControlParam extends BaseEntity {
private Integer changeNumber;
/**
* 费用
*/

22
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/risk/param/MemberRiskControlPetition.java
View File

@ -1,33 +1,17 @@
package com.hzs.bonus.risk.param;/**
* @Description:
* @Author: yuhui
* @Time: 2024/7/1 10:33
* @Classname: MemberRiskControlPetition
* @PackageName: com.hzs.bonus.risk.param
*/
package com.hzs.bonus.risk.param;
import com.hzs.common.core.web.domain.BaseApprovalEntity;
import com.hzs.member.account.dto.MemberAmountDTO;
import com.hzs.system.sys.dto.LoginUser;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.List;
import java.util.Set;
/**
*@BelongsProject: hzs_cloud
*@BelongsPackage: com.hzs.bonus.risk.param
*@Author: yh
*@CreateTime: 2024-07-01 10:33
*@Description: TODO
*@Version: 1.0
*/
@EqualsAndHashCode(callSuper = true)
@Data
public class MemberRiskControlPetition extends BaseApprovalEntity implements Serializable {
/**
* 操作类型（1=新增,2=修改,3=删除）
*/

52
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/risk/param/MemberRiskParam.java
View File

@ -1,52 +0,0 @@
package com.hzs.bonus.risk.param;/**
* @Description:
* @Author: yuhui
* @Time: 2024/5/8 9:50
* @Classname: MemberRiskParam
* @PackageName: com.hzs.bonus.risk.param
*/
import com.hzs.common.core.web.domain.BaseApprovalEntity;
import com.hzs.system.sys.dto.LoginUser;
import lombok.Data;
import java.io.Serializable;
/**
*@BelongsProject: hzs_cloud
*@BelongsPackage: com.hzs.bonus.risk.param
*@Author: yh
*@CreateTime: 2024-05-08 09:50
*@Description: TODO
*@Version: 1.0
*/
@Data
public class MemberRiskParam extends BaseApprovalEntity implements Serializable {
/**
* 操作类型（1=新增,2=修改,3=删除）
*/
private Integer controlType;
/**
* 国家
*/
private Integer pkCountry;
/**
* 会员ID
*/
private Long pkMember;
/**
* 登录用户信息
*/
private LoginUser loginUser;
/**
* K值风控设置
*/
private MemberRiskControlParam memberRiskControlParam;
}

19
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/risk/service/ICuMemberRiskControlService.java
View File

@ -3,35 +3,19 @@ package com.hzs.bonus.risk.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hzs.bonus.risk.param.MemberRiskControlParam;
import com.hzs.bonus.risk.param.MemberRiskControlPetition;
import com.hzs.bonus.risk.param.MemberRiskParam;
import com.hzs.bonus.risk.vo.MemberRiskControlVo;
import com.hzs.common.domain.bonus.risk.CuMemberRiskControl;
import java.util.Date;
import java.util.List;
/**
* <p>
* 会员奖金-K值风控设置 服务类
* </p>
*
* @author zhangjing
* @since 2024-04-08
*/
public interface ICuMemberRiskControlService extends IService<CuMemberRiskControl> {
/*
* @description: 查询时间范围内生效的k值
* @author: sui q
* @date: 2024/4/8 15:59
* @param: null null
**/
List<CuMemberRiskControl> queryCuMemberRiskControl(Date settleDate);
/**
* 列表查询
*
* @param memberRiskControlParam
* @return
*/
@ -40,6 +24,7 @@ public interface ICuMemberRiskControlService extends IService<CuMemberRiskContro
/**
* k值风控参数 审批
*
* @param memberRiskControlPetition
*/
void onLinePetition(MemberRiskControlPetition memberRiskControlPetition);

70
bd-business/bd-business-bonus/src/main/java/com/hzs/bonus/risk/service/impl/CuMemberRiskControlServiceImpl.java
View File

@ -2,7 +2,6 @@ package com.hzs.bonus.risk.service.impl;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hzs.bonus.risk.mapper.CuMemberRiskControlMapper;
import com.hzs.bonus.risk.param.MemberRiskControlParam;
@ -13,67 +12,33 @@ 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.DateUtils;
import com.hzs.common.domain.activity.base.AcApprovalLog;
import com.hzs.common.domain.bonus.risk.CuMemberRiskControl;
import com.hzs.common.domain.member.detail.CuMemberServiceLog;
import com.hzs.common.domain.system.sys.SysApprovalBusinessMember;
import com.hzs.common.security.service.UserTokenService;
import com.hzs.common.security.utils.SecurityUtils;
import com.hzs.member.account.ICuMemberTradeServiceApi;
import com.hzs.member.detail.ICuMemberServiceLogServiceApi;
import com.hzs.system.sys.IApprovalServiceApi;
import com.hzs.system.sys.dto.ApprovalSubmitDTO;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
/**
* <p>
* 会员奖金-K值风控设置 服务实现类
* </p>
*
* @author zhangjing
* @since 2024-04-08
*/
@Service
public class CuMemberRiskControlServiceImpl extends ServiceImpl<CuMemberRiskControlMapper, CuMemberRiskControl> implements ICuMemberRiskControlService {
@DubboReference
private IApprovalServiceApi approvalServiceApi;
@DubboReference
private ICuMemberTradeServiceApi memberTradeServiceApi;
@Autowired
private UserTokenService userTokenService;
@Autowired
private RabbitTemplate rabbitTemplate;
@DubboReference
private ICuMemberServiceLogServiceApi memberServiceLogServiceApi;
IApprovalServiceApi approvalServiceApi;
@DubboReference
ICuMemberServiceLogServiceApi memberServiceLogServiceApi;
@Override
public List<CuMemberRiskControl> queryCuMemberRiskControl(Date settleDate) {
QueryWrapper<CuMemberRiskControl> queryWrapper = new QueryWrapper<>();
queryWrapper.le("start_date", settleDate);
queryWrapper.ge("end_date", settleDate);
return baseMapper.selectList(queryWrapper);
}
/**
* 列表查询
* @param memberRiskControlParam
* @return
*/
@Override
public List<MemberRiskControlVo> queryByList(MemberRiskControlParam memberRiskControlParam)
{
public List<MemberRiskControlVo> queryByList(MemberRiskControlParam memberRiskControlParam) {
return baseMapper.queryByList(memberRiskControlParam);
}
/**
* k值风控参数 审批
* @param memberRiskControlPetition
*/
@Override
public void onLinePetition(MemberRiskControlPetition memberRiskControlPetition) {
EApprovalBusiness approvalBusiness = null;
@ -86,24 +51,17 @@ public class CuMemberRiskControlServiceImpl extends ServiceImpl<CuMemberRiskCont
}
//业务单号
String businessCode = CommonUtil.createSerialNumber(EOrderPrefix.RISK_CONTROL.getValue());
Boolean b = submitApproval(memberRiskControlPetition, approvalBusiness,businessCode);
//日志
// MemberRiskControlParam memberRiskControlParam = memberRiskControlPetition.getMemberRiskControlParam();
// memberRiskControlParam.setPkCountry(SecurityUtils.getPkCountry());
// memberRiskControlParam.setPkCreator(SecurityUtils.getUserId());
// memberRiskControlParam.setActType(EActType.PRODUCT_GIFT.getValue());
// memberRiskControlParam.setBusinessCode(recommendParam.getActivityParam().getBusinessCode());
// IActivityService.createBaseConfigLog(activityParam, new StringBuffer(), null, approvalBusiness.getValue(), false);
// return b;
Boolean b = submitApproval(memberRiskControlPetition, approvalBusiness, businessCode);
}
/**
* 提交审批
*
* @param memberRiskControlPetition 抽奖参数
*/
public Boolean submitApproval(MemberRiskControlPetition memberRiskControlPetition, EApprovalBusiness approvalBusiness,String businessCode) {
public Boolean submitApproval(MemberRiskControlPetition memberRiskControlPetition, EApprovalBusiness approvalBusiness, String businessCode) {
//保存审批日志
CuMemberServiceLog memberServiceLog = saveApprovalLog(memberRiskControlPetition, approvalBusiness,businessCode);
CuMemberServiceLog memberServiceLog = saveApprovalLog(memberRiskControlPetition, approvalBusiness, businessCode);
ApprovalSubmitDTO approvalSubmitDTO = ApprovalSubmitDTO.builder().eApprovalBusiness(approvalBusiness)
.businessCode(businessCode)
.businessData(JSONObject.toJSONString(memberRiskControlPetition.getMemberRiskControlParam()))
@ -121,11 +79,11 @@ public class CuMemberRiskControlServiceImpl extends ServiceImpl<CuMemberRiskCont
/**
* 保存活动审批日志信息
*
* @param memberRiskControlPetition 直推赠送参数
* @param approvalBusiness 审批业务
* @param memberRiskControlPetition 直推赠送参数
* @param approvalBusiness 审批业务
* @return boolean
*/
public CuMemberServiceLog saveApprovalLog(MemberRiskControlPetition memberRiskControlPetition, EApprovalBusiness approvalBusiness,String businessCode) {
public CuMemberServiceLog saveApprovalLog(MemberRiskControlPetition memberRiskControlPetition, EApprovalBusiness approvalBusiness, String businessCode) {
Integer controlType = memberRiskControlPetition.getControlType();
//查询变更前的数据
/* String afterData = !controlType.equals(EControlType.SAVE.getValue()) ?
@ -134,7 +92,7 @@ public class CuMemberRiskControlServiceImpl extends ServiceImpl<CuMemberRiskCont
String afterData = JSONUtil.toJsonStr(memberRiskControlPetition);
String beforeData = controlType.equals(EControlType.SAVE.getValue()) ? JSONUtil.toJsonStr(memberRiskControlPetition) : null;
// MemberRiskControlParam memberRiskControlParam = memberRiskControlPetition.getMemberRiskControlParam();
// MemberRiskControlParam memberRiskControlParam = memberRiskControlPetition.getMemberRiskControlParam();
CuMemberServiceLog cuMemberServiceLog = new CuMemberServiceLog();
cuMemberServiceLog.setEditType(approvalBusiness.getValue());
cuMemberServiceLog.setPkMember(memberRiskControlPetition.getPkMember());

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

@ -287,14 +287,4 @@
a.r_b_sum_real_pv = a.r_b_sum_real_pv - b.b_new_pv - b.rep_b_new_pv
</update>
<update id="updateCuMemberExpandSettleAchieveByBeforeDay">
merge into ${targetTable} a
using(select pk_member,a_balance,b_balance,min_achieve,round,second 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.min_achieve=b.min_achieve,a.round=b.round,a.second=b.second
</update>
</mapper>

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

@ -460,21 +460,6 @@
)
</update>
<update id="updateCuMemberExpandSettle">
merge into ${settleTableName} a
using(
select * from (
<foreach collection="cuMemberTreeList" item="item" open=" " separator=" union " close=" ">
select #{item.pkMember} pk_member,#{item.aBalance} a_balance, #{item.bBalance} b_balance,
#{item.minAchieve} min_achieve,#{item.round} round,#{item.second} second from dual
</foreach>)
) 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.min_achieve=b.min_achieve,a.round = b.round,a.second=b.second
</update>
<update id="createCuMemberRetailRangeSecondTable">
create table ${tableName}
(
@ -575,52 +560,10 @@
</foreach>
</select>
<select id="batchQueryCuMemberSettlePlaceParent" resultMap="CuMemberSettleExt">
select pk_order,pk_member,member_code,member_name,pk_place_parent,place_dept,pk_grade,a.pk_awards,bg.grade_value,account_status,
income_status,pk_settle_country,purchase_status,share_status,a.register_authority,
a_balance,b_balance,r_a_balance,r_b_balance,rep_a_balance,rep_b_balance,r_rep_a_balance,r_rep_b_balance,
register_amount,register_pv,upgrade_amount,upgrade_pv,repurchase_amount,pk_center_code,
repurchase_pv,hi_fun_amount,hi_fun_pv,mall_amount,mall_pv,category,pk_vertex,
min_achieve,round,second,store_level,expire_status from (
<foreach collection="firPurchaseOrderList" item="item" open=" " close=" " separator=" union all ">
select #{item.pkId} pk_order,pk_member,member_code,member_name,pk_place_parent,place_dept,pk_grade,pk_awards,account_status,
income_status,pk_settle_country,purchase_status,share_status,register_authority,
a_balance,b_balance,r_a_balance,r_b_balance,rep_a_balance,rep_b_balance,r_rep_a_balance,r_rep_b_balance,
register_amount,register_pv,upgrade_amount,upgrade_pv,repurchase_amount,pk_center_code,
repurchase_pv,hi_fun_amount,hi_fun_pv,mall_amount,mall_pv,category,pk_vertex,
min_achieve,round,second,store_level,expire_status,level sort
from ${settleTableName}
start with pk_member = #{item.pkMember}
connect by pk_member = prior pk_place_parent
</foreach>
) a
left join bd_grade bg
on a.pk_grade = bg.pk_id
order by a.pk_order,a.sort
</select>
<select id="batchQueryCuMemberSettleParent" resultMap="CuMemberSettleExt">
<include refid="memberParent"></include>
</select>
<select id="batchQueryCuMemberSettleParentForSpecial" resultMap="CuMemberSettleExt">
select a.pk_member,a.pk_parent,a.member_code,a.member_name,a.pk_awards,a.account_status,a.register_authority,a.customer_type,
a.income_status,a.pk_settle_country,a.purchase_status,a.share_status,a.is_maker_space,
a.a_balance,a.b_balance,a.r_a_balance,a.r_b_balance,a.rep_a_balance,a.rep_b_balance,a.r_rep_a_balance,a.r_rep_b_balance,
a.register_amount,a.register_pv,a.upgrade_amount,a.upgrade_pv,a.repurchase_amount,a.pk_center_code,
a.repurchase_pv,a.hi_fun_amount,a.hi_fun_pv,a.mall_amount,a.mall_pv,a.category,a.pk_grade,bg.grade_value,
a.min_achieve,a.round,second,ap.pk_id ap_pk_id,nvl(ap.usable_quantity,0) usable_quantity,
nvl(bp.retail_price,0) retail_price,ap.pk_data_id from (
<include refid="QueryMemberParent"></include>
) a
inner join bd_grade bg
on a.pk_grade = bg.pk_id
left join ac_pick ap
on ap.pk_member = a.pk_member and ap.pick_type=8 and ap.del_flag=0
left join bd_product bp
on ap.pk_data_id = bp.pk_id
</select>
<select id="batchQueryMemberSettleParentByMemberPk" resultMap="CuMemberSettleExt">
select
cl.pk_member,cl.member_code,cl.member_name,cl.pk_awards,cl.pk_grade,cl.account_status,cl.category,cl.income_status,cl.pk_settle_country,
@ -646,41 +589,5 @@
</foreach>
</select>
<select id="queryMemberSettleByAwards" resultType="com.hzs.common.domain.member.ext.CuMemberSettleExt">
select a.pk_settle_country, a.income_status, a.pk_member, a.expire_status, a.purchase_status, ba.abonus_ratio, c.real_income_total
from ${settleTableName} a
inner join bd_awards ba
on a.pk_awards = ba.pk_id
inner join (
select pk_member, sum(real_income_total - global_points) real_income_total
from cu_member_bonus
where del_flag = 0
and period between #{startPeriod} and #{endPeriod}
and real_income_total > 0
group by pk_member) c
on a.pk_member = c.pk_member
where ba.del_flag = 0
and ba.awards_value >= 5
and ba.abonus_ratio > 0
and a.pk_settle_country = 1
union
select a.pk_settle_country, a.income_status, a.pk_member, 1 expire_status, a.purchase_status, ba.abonus_ratio, c.real_income_total
from ${rangeTableName} a
inner join bd_awards ba
on a.pk_benefit_awards = ba.pk_id
inner join (
select pk_member, sum(real_income_total) real_income_total
from cu_member_bonus
where del_flag = 0
and period between #{startPeriod} and #{endPeriod}
and real_income_total > 0
group by pk_member
) c
on a.pk_member = c.pk_member
where ba.del_flag = 0
and ba.awards_value >= 5
and ba.abonus_ratio > 0
and a.pk_settle_country = 1
</select>
</mapper>

114
bd-business/bd-business-bonus/src/main/resources/mapper/bonus/base/CuAwardsControlMapper.xml
View File

@ -1,114 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.hzs.bonus.base.mapper.CuAwardsControlMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.hzs.common.domain.member.base.CuAwardsControl">
<id column="PK_ID" property="pkId" />
<result column="DEL_FLAG" property="delFlag" />
<result column="PK_COUNTRY" property="pkCountry" />
<result column="CREATION_TIME" property="creationTime" />
<result column="MODIFIED_TIME" property="modifiedTime" />
<result column="PK_CREATOR" property="pkCreator" />
<result column="PK_MODIFIED" property="pkModified" />
<result column="REAL_AWARDS" property="realAwards" />
<result column="MENTORING_AWARD" property="mentoringAward" />
<result column="DIVIDEND_AWARD" property="dividendAward" />
<result column="EXTREME_AWARDS" property="extremeAwards" />
<result column="REPLY_EXAM_AWARD" property="replyExamAward" />
<result column="DIVVY_EXAM_AWARDS" property="divvyExamAwards" />
<result column="PK_MEMBER" property="pkMember" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
DEL_FLAG,
PK_COUNTRY,
CREATION_TIME,
MODIFIED_TIME,
PK_CREATOR,
PK_MODIFIED,
PK_ID, REAL_AWARDS, MENTORING_AWARD, DIVIDEND_AWARD, EXTREME_AWARDS, REPURCHASE_ASSESSMENT_AWARD, DIVIDEND_ASSESSMENT_AWARDS
</sql>
<!-- 查询奖衔控制列表-->
<select id="queryAwardsControlList" parameterType="com.hzs.bonus.base.vo.CuAwardsControlVO"
resultType="com.hzs.bonus.base.vo.CuAwardsControlVO">
select
me.MEMBER_CODE memberCode,
me.MEMBER_NAME memberName,
a.PK_ID pkID,
a.pk_Member pkMember,
a.REAL_AWARDS realAwards,
a.MENTORING_AWARD mentoringAward,
a.DIVIDEND_AWARD dividendAward,
a.EXTREME_AWARDS extremeAwards,
a.REPLY_EXAM_AWARD replyExamAward,
a.DIVVY_EXAM_AWARDS divvyExamAwards,
b.PK_TRANSACTION realAwardsKey,
c.PK_TRANSACTION mentoringAwardKey,
d.PK_TRANSACTION dividendAwardKey,
e.PK_TRANSACTION extremeAwardsKey,
f.PK_TRANSACTION replyExamAwardKey,
g.PK_TRANSACTION divvyExamAwardsKey
from CU_AWARDS_CONTROL a
left join CU_MEMBER me on me.PK_ID=PK_MEMBER
left JOIN BD_AWARDS b on b.PK_ID=a.REAL_AWARDS
left JOIN BD_AWARDS c on c.PK_ID=a.MENTORING_AWARD
left JOIN BD_AWARDS d on d.PK_ID=a.DIVIDEND_AWARD
left JOIN BD_AWARDS e on e.PK_ID=a.EXTREME_AWARDS
left JOIN BD_AWARDS f on f.PK_ID=a.REPLY_EXAM_AWARD
left JOIN BD_AWARDS g on g.PK_ID=a.DIVVY_EXAM_AWARDS
WHERE
a.DEL_FLAG = 0 and me.DEL_FLAG = 0
<if test="memberCode != null and memberCode !='' ">
AND me.MEMBER_CODE like #{memberCode} || '%'
</if>
<if test="memberCodeList != null and memberCodeList.size >0">
and me.MEMBER_CODE in
<foreach collection="memberCodeList" item="item" open="(" close=")" separator=",">
#{item}
</foreach>
</if>
<if test="pkMemberList != null and pkMemberList.size >0">
and a.PK_MEMBER in
<foreach collection="pkMemberList" item="item" open="(" close=")" separator=",">
#{item}
</foreach>
</if>
<if test="memberName != null and memberName !='' ">
AND me.MEMBER_NAME like #{memberName} || '%'
</if>
<if test="realAwards != null ">
AND a.REAL_AWARDS = #{realAwards}
</if>
<if test="mentoringAward != null ">
AND a.MENTORING_AWARD = #{mentoringAward}
</if>
<if test="dividendAward != null ">
AND a.DIVIDEND_AWARD = #{dividendAward}
</if>
<if test="extremeAwards != null ">
AND a.EXTREME_AWARDS = #{extremeAwards}
</if>
<if test="replyExamAward != null ">
AND a.REPLY_EXAM_AWARD = #{replyExamAward}
</if>
<if test="divvyExamAwards != null ">
AND a.DIVVY_EXAM_AWARDS = #{divvyExamAwards}
</if>
<if test="pkCountry != null ">
AND a.pk_Country = #{pkCountry}
</if>
order by a.PK_ID desc
</select>
</mapper>

5
bd-business/bd-business-bonus/src/main/resources/mapper/bonus/base/CuHonorWallMapper.xml
View File

@ -1,5 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.hzs.bonus.base.mapper.CuHonorWallMapper">
</mapper>

13
bd-business/bd-business-bonus/src/main/resources/mapper/bonus/base/CuMemberHonorWallMapper.xml
View File

@ -1,13 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.hzs.bonus.base.mapper.CuMemberHonorWallMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.hzs.common.domain.member.honor.CuMemberHonorWall">
<id column="PK_ID" property="pkId"/>
<result column="PK_MEMBER" property="pkMember"/>
<result column="PK_HONOR_WALL" property="pkHonorWall"/>
<result column="SETTLE_MONTH" property="settleMonth"/>
</resultMap>
</mapper>

167
bd-business/bd-business-bonus/src/main/resources/mapper/bonus/bonus/CuBonusExpandMapper.xml
View File

@ -1,167 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.hzs.bonus.bonus.mapper.CuBonusExpandMapper">
<!-- 通用查询映射结果 -->
<resultMap id="CuBonusExpandExt" type="com.hzs.common.domain.member.ext.CuBonusExpandExt">
<id column="PK_ID" property="pkId" />
<result column="DEL_FLAG" property="delFlag" />
<result column="PK_COUNTRY" property="pkCountry" />
<result column="PK_CREATOR" property="pkCreator" />
<result column="CREATION_TIME" property="creationTime" />
<result column="PK_MODIFIED" property="pkModified" />
<result column="MODIFIED_TIME" property="modifiedTime" />
<result column="SETTLE_DATE" property="settleDate" />
<result column="PK_MEMBER" property="pkMember" />
<result column="PK_VERTEX" property="pkVertex" />
<result column="DAY_ACHIEVE" property="dayAchieve" />
<result column="DAY_BONUS" property="dayBonus" />
<result column="YES_DAY_RATIO" property="yesDayRatio" />
<result column="CUR_DAY_RATIO" property="curDayRatio" />
<result column="MONTH_ACHIEVE" property="monthAchieve" />
<result column="MONTH_BONUS" property="monthBonus" />
<result column="MONTH_RATIO" property="monthRatio" />
<result column="ADD_TOUCH" property="addTouch" />
<result column="SORT" property="sort" />
<result column="MEMBER_CODE" property="memberCode" />
<result column="MEMBER_NAME" property="memberName" />
<result column="VERTEX_NAME" property="vertexName" />
<result column="EXPAND_RATIO" property="expandRatio" />
</resultMap>
<update id="mergeBonusExpandByList">
merge into cu_bonus_expand ce
using (
select * from(
<foreach collection="cuBonusExpandList" item="item" index="index" separator=" union ">
select #{item.pkId} pk_id,#{item.dayAchieve,jdbcType=NUMERIC} day_achieve,#{item.dayBonus,jdbcType=NUMERIC} day_bonus,
#{item.yesDayRatio,jdbcType=NUMERIC} yes_day_ratio,#{item.curDayRatio,jdbcType=NUMERIC} cur_day_ratio,
#{item.monthAchieve,jdbcType=NUMERIC} month_achieve,#{item.monthBonus,jdbcType=NUMERIC} month_bonus,
#{item.monthRatio,jdbcType=NUMERIC} month_ratio,#{item.dayRepAchieve,jdbcType=NUMERIC} day_rep_achieve,
#{item.dayRepBonus,jdbcType=NUMERIC} day_rep_bonus,#{item.curDayRepRatio,jdbcType=NUMERIC} cur_day_rep_ratio from dual
</foreach>)
) b
on (ce.pk_id=b.pk_id)
when matched then
update set ce.day_achieve=b.day_achieve,ce.day_bonus=b.day_bonus,ce.yes_day_ratio=b.yes_day_ratio,
ce.cur_day_ratio=b.cur_day_ratio,ce.month_achieve=b.month_achieve,
ce.month_bonus=b.month_bonus,ce.month_ratio=b.month_ratio,
ce.day_rep_achieve=b.day_rep_achieve,ce.day_rep_bonus=b.day_rep_bonus,
ce.cur_day_rep_ratio=b.cur_day_rep_ratio
</update>
<update id="truncateTable">
truncate table cu_member_repeat_bonus
</update>
<select id="calculateDayRepRatioByBonusExpandParam" resultMap="CuBonusExpandExt">
<foreach collection="bonusExpandParam.memberIdList" item="item" index="index" separator=" union ">
select a.pk_member,COALESCE(a.order_amount,0) day_rep_achieve,
COALESCE(b.pur_real_subtotal*bc.out_exchange_rate,0) day_rep_bonus,
COALESCE(ROUND(b.pur_real_subtotal*bc.out_exchange_rate/a.order_amount*100, 2),0) cur_day_rep_ratio from(
select #{item} pk_member,sum(order_amount) order_amount from(
select so.pk_member,order_achieve, order_amount from sa_order so
inner join(
select * from cu_member
start with pk_id= #{item}
connect by pk_place_parent =prior pk_id
) cu
on cu.pk_id=so.pk_member
where so.order_status = 1 and so.del_flag=0 and so.order_achieve>0 and so.pk_country=1
and so.order_type in(3,9,11,12,14,21,22,23,26,31)
and so.pay_time >= #{bonusExpandParam.startDate,jdbcType=DATE}
and so.pay_time &lt; #{bonusExpandParam.endDate,jdbcType=DATE})) a
inner join(
select #{item} pk_member,nvl(sum(repur_real_subtotal),0) pur_real_subtotal from ${tableName} cb
inner join(
select * from cu_member
start with pk_id=#{item}
connect by pk_place_parent =prior pk_id
) cu
on cu.pk_id = cb.pk_member
where period between #{bonusExpandParam.startPeriod} and #{bonusExpandParam.endPeriod} and cb.del_flag=0 and cb.pk_country=1
) b
on a.pk_member=b.pk_member
join cu_member cm
on cm.pk_id=a.pk_member
join bd_currency bc
on bc.pk_country=cm.pk_settle_country and bc.del_flag=0
</foreach>
</select>
<select id="calculateDayRatioByBonusExpandParam" resultMap="CuBonusExpandExt">
<foreach collection="bonusExpandParam.memberIdList" item="item" index="index" separator=" union ">
select a.pk_member,COALESCE(a.order_amount,0) day_achieve,
COALESCE(b.pur_real_subtotal*bc.out_exchange_rate,0) day_bonus,
COALESCE(ROUND(b.pur_real_subtotal*bc.out_exchange_rate/a.order_amount*100, 2),0) yes_day_ratio from(
select #{item} pk_member,sum(order_amount) order_amount from(
select so.pk_member,order_achieve,order_amount from sa_order so
inner join(
select * from cu_member
start with pk_id= #{item}
connect by pk_place_parent =prior pk_id
) cu
on cu.pk_id=so.pk_member
where so.order_status = 1 and so.del_flag=0
and so.order_type in(1,2,24,25) and so.pk_country=1
and so.pay_time >= #{bonusExpandParam.startDate,jdbcType=DATE}
and so.pay_time &lt; #{bonusExpandParam.endDate,jdbcType=DATE})) a
inner join(
select #{item} pk_member,nvl(sum(pur_real_subtotal+maker_real_subtotal),0) pur_real_subtotal from ${tableName} cb
inner join(
select * from cu_member
start with pk_id=#{item}
connect by pk_place_parent =prior pk_id
) cu
on cu.pk_id = cb.pk_member
where period between #{bonusExpandParam.startPeriod} and #{bonusExpandParam.endPeriod} and cb.del_flag=0 and cb.pk_country=1
) b
on a.pk_member=b.pk_member
join cu_member cm
on cm.pk_id=a.pk_member
join bd_currency bc
on bc.pk_country=cm.pk_settle_country and bc.del_flag=0
</foreach>
</select>
<select id="queryZeroMemberByVertex" resultMap="CuBonusExpandExt">
select cm.pk_id pk_member,bt.pk_id pk_vertex,nvl(bt.sort,99) sort,cm.pk_settle_country pk_country from cu_member cm
inner join cu_member par
on par.pk_id=cm.pk_place_parent
left join bd_vertex bt
on cm.pk_id = bt.pk_member and bt.del_flag=0
where par.member_code='GJ30720200'
and cm.del_flag=0
order by sort,pk_member
</select>
<select id="queryBonusExpand" resultMap="CuBonusExpandExt">
select ce.*,cm.member_code,cm.member_name,bv.vertex_name from cu_bonus_expand ce
inner join cu_member cm
on ce.pk_member = cm.pk_id
left join bd_vertex bv
on ce.pk_vertex=bv.pk_id and bv.del_flag=0
where ce.del_flag=0 and cm.del_flag=0
<if test="pkCountry != null">
and ce.pk_country = #{pkCountry}
</if>
<if test="settleDate != null">
and ce.settle_date=#{settleDate,jdbcType=DATE}
</if>
<choose>
<when test="pkParent != null"> and ce.pk_parent=#{pkParent}</when>
<otherwise> and ce.pk_parent is null</otherwise>
</choose>
<if test="memberCode != null and memberCode != ''">
and cm.member_code like '%' || #{memberCode} || '%'
</if>
<if test="memberName != null and memberName != ''">
and cm.member_name like '%' || #{memberName} || '%'
</if>
<if test="vertexName != null and vertexName != ''">
and bv.vertex_name like '%' || #{vertexName} || '%'
</if>
order by ce.sort,ce.pk_member
</select>
<select id="queryBonusExpandDis" resultMap="CuBonusExpandExt">
select settle_date from cu_bonus_expand
where del_flag=0 and (yes_day_ratio > 65 or CUR_DAY_RATIO > 65 or MONTH_RATIO > 65)
and settle_date>sysdate-7
group by settle_date
</select>
</mapper>

46
bd-business/bd-business-bonus/src/main/resources/mapper/bonus/bonus/CuMemberRepeatBonusMapper.xml
View File

@ -1,46 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.hzs.bonus.bonus.mapper.CuMemberRepeatBonusMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.hzs.common.domain.member.bonus.CuMemberRepeatBonus">
<result column="DEL_FLAG" property="delFlag" />
<result column="PK_COUNTRY" property="pkCountry" />
<result column="PK_CREATOR" property="pkCreator" />
<result column="CREATION_TIME" property="creationTime" />
<result column="PK_MODIFIED" property="pkModified" />
<result column="MODIFIED_TIME" property="modifiedTime" />
<result column="PK_MEMBER" property="pkMember" />
<result column="PERIOD" property="period" />
<result column="PK_RATE" property="pkRate" />
<result column="DIRECT_INCOME" property="directIncome" />
<result column="EXPAND_INCOME" property="expandIncome" />
<result column="COACH_INCOME" property="coachIncome" />
<result column="SHARE_INCOME" property="shareIncome" />
<result column="SERVICE_INCOME" property="serviceIncome" />
<result column="BACK_POINTS" property="backPoints" />
<result column="SERVICE_SPEND" property="serviceSpend" />
<result column="PUR_REAL_SUBTOTAL" property="purRealSubtotal" />
<result column="MAKER_DIRECT_INCOME" property="makerDirectIncome" />
<result column="MAKER_SHARE_INCOME" property="makerShareIncome" />
<result column="MAKER_REAL_SUBTOTAL" property="makerRealSubtotal" />
<result column="REAL_INCOME_TOTAL" property="realIncomeTotal" />
</resultMap>
<insert id="insertCuMemberRepeatBonus">
insert ALL
<foreach item="item" index="index" collection="cuMemberRepeatBonusList" separator=" ">
into CU_MEMBER_REPEAT_BONUS(pk_member,period,pk_rate,direct_income,expand_income,
coach_income,share_income,service_income,back_points,service_spend,
pur_real_subtotal,maker_direct_income,maker_share_income,maker_real_subtotal,real_income_total,
pk_country,pk_creator)
values
(#{item.pkMember},#{item.period},#{item.pkRate,jdbcType=INTEGER},#{item.directIncome},
#{item.expandIncome},#{item.coachIncome},#{item.shareIncome},#{item.serviceIncome},
#{item.backPoints},#{item.serviceSpend},#{item.purRealSubtotal},#{item.makerDirectIncome},
#{item.makerShareIncome},#{item.makerRealSubtotal},#{item.realIncomeTotal},
#{item.pkCountry},#{item.pkCreator})
</foreach>
SELECT 1 FROM dual
</insert>
</mapper>

37
bd-business/bd-business-member/src/main/java/com/hzs/member/achieve/controller/api/ApiCuMemberAchieveDisController.java
View File

@ -19,14 +19,12 @@ import com.hzs.common.core.web.controller.BaseController;
import com.hzs.common.core.web.domain.AjaxResult;
import com.hzs.common.core.web.page.TableDataInfo;
import com.hzs.common.domain.member.achieve.ext.CuMemberAchieveExt;
import com.hzs.common.domain.member.ext.CuMemberMonthAchieveExt;
import com.hzs.common.security.utils.SecurityUtils;
import com.hzs.common.util.TransactionUtils;
import com.hzs.member.achieve.controller.vo.*;
import com.hzs.member.achieve.param.MemberAchieveDisParam;
import com.hzs.member.achieve.param.MonthAchieveParam;
import com.hzs.member.achieve.service.ICuMemberAchieveService;
import com.hzs.member.achieve.service.ICuMemberMonthAchieveService;
import com.hzs.member.achieve.service.ICuMemberSettlePeriodService;
import com.hzs.system.base.ICurrencyServiceApi;
import com.hzs.system.base.dto.CurrencyDTO;
@ -62,19 +60,6 @@ public class ApiCuMemberAchieveDisController extends BaseController {
private ICuMemberSettlePeriodService iCuMemberSettlePeriodService;
@Autowired
private ICuMemberAchieveService iCuMemberAchieveService;
@Autowired
private ICuMemberMonthAchieveService iCuMemberMonthAchieveService;
/**
* 用于查询会员市场动态
*/
@GetMapping("/query-place-tree")
public AjaxResult queryPlaceParentTree() {
// 查询架构树
MemberAchieveDisParam memberAchieveDisParam = new MemberAchieveDisParam();
memberAchieveDisParam.setPkMember(SecurityUtils.getUserId());
return AjaxResult.success(iCuMemberAchieveService.queryCuMemberAchieveDis(memberAchieveDisParam));
}
/**
* 用于查询会员市场动态
@ -371,28 +356,6 @@ public class ApiCuMemberAchieveDisController extends BaseController {
return endDate;
}
/**
* 推荐分布
**/
@PostMapping("/recommend")
public TableDataInfo recommendExperts(@RequestBody ParentAchieveVO parentAchieveVO) {
if (parentAchieveVO.getWallType() == null) {
return new TableDataInfo();
}
parentAchieveVO.setPkCountry(SecurityUtils.getPkCountry());
List<CuMemberMonthAchieveExt> cuMemberMonthAchieveExtList = iCuMemberMonthAchieveService.queryCuMemberMonthAchieveRecommend(parentAchieveVO);
cuMemberMonthAchieveExtList.forEach(cuMemberMonthAchieveExt -> {
String memberName = cuMemberMonthAchieveExt.getMemberName();
if (memberName.length() > 2) {
cuMemberMonthAchieveExt.setMemberName(memberName.replaceFirst(memberName.substring(1, memberName.length() - 1), "*"));
} else {
cuMemberMonthAchieveExt.setMemberName(memberName.replaceFirst(memberName.substring(1), "*"));
}
});
return getDataTable(cuMemberMonthAchieveExtList);
}
/**
* 月度业绩
**/

7
bd-business/bd-business-member/src/main/java/com/hzs/member/achieve/controller/vo/ParentAchieveVO.java
View File

@ -8,21 +8,14 @@ import lombok.Data;
import java.math.BigDecimal;
import java.util.List;
/**
* <p>
* 直推业绩统计VO
* </p>
*
* @author zhangjing
* @since 2023-05-17
*/
@Data
public class ParentAchieveVO {
private static final long serialVersionUID = 1L;
/**
* 会员主键
*/

21
bd-business/bd-business-member/src/main/java/com/hzs/member/achieve/mapper/CuMemberMonthAchieveMapper.java
View File

@ -2,34 +2,14 @@ package com.hzs.member.achieve.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hzs.common.domain.member.achieve.CuMemberMonthAchieve;
import com.hzs.common.domain.member.ext.CuMemberMonthAchieveExt;
import com.hzs.member.achieve.controller.vo.ParentAchieveVO;
import com.hzs.member.achieve.controller.vo.RealPerformanceVo;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 会员月数据 Mapper 接口
*/
public interface CuMemberMonthAchieveMapper extends BaseMapper<CuMemberMonthAchieve> {
/**
* 根据时间查询月业绩
*/
List<CuMemberMonthAchieveExt> queryCuMemberMonthAchieveByDate(@Param("startPeriod") Integer startPeriod, @Param("endPeriod") Integer endPeriod,
@Param("recommend") Integer recommend, @Param("repurchase") Integer repurchase);
/**
* 根据条件查询会员月业绩 推荐达人
*/
List<CuMemberMonthAchieveExt> queryCuMemberMonthAchieveRecommend(ParentAchieveVO parentAchieveVO);
/**
* 每天插入会员月表，计算推荐业绩，复购业绩，1-6号计算前7天
*/
void insertCuMemberMonthAchieve(@Param("tableName") String tableName, @Param("period") Integer period, @Param("month") String month);
/**
* 查询会员真实业绩
*
@ -38,4 +18,5 @@ public interface CuMemberMonthAchieveMapper extends BaseMapper<CuMemberMonthAchi
* @return
*/
RealPerformanceVo queryCuMemberMonthAchieveInfo(@Param("pkMember") Long pkMember, @Param("achieveTable") String achieveTable);
}

50
bd-business/bd-business-member/src/main/java/com/hzs/member/achieve/mapper/CuMemberTreeMapper.java
View File

@ -14,49 +14,6 @@ import java.util.List;
*/
public interface CuMemberTreeMapper extends BaseMapper<CuMemberTree> {
/**
* 创建会员网体推荐人索引
*
* @param tableName 日期
*/
void createCuMemberTreeParentIndex(String tableName);
/**
* 创建会员网体安置人索引
*
* @param tableName 日期
*/
void createCuMemberTreePlaceIndex(String tableName);
/**
* 创建会员网体推荐人索引
*
* @param tableName 日期
*/
void createCuMemberTableUniqueIndex(String tableName);
/**
* 创建表的序列
*
* @param tableName 表名
* @param tableNameSeq 序列名
*/
void createCuMemberTableSequence(@Param("tableName") String tableName, @Param("tableNameSeq") String tableNameSeq);
/**
* 创建会员网体推荐人索引
*
* @param tableName 日期
*/
void createCuMemberTreeDayOnlyIndex(String tableName);
/**
* 删除日表数据
*
* @param tableName 表名
*/
void truncateCuMemberTreeTable(@Param("tableName") String tableName);
/**
* 判断是否存在临时表
*
@ -64,13 +21,6 @@ public interface CuMemberTreeMapper extends BaseMapper<CuMemberTree> {
*/
Integer queryExistOracleTable(String tableName);
/**
* 查询历史会员网体信息,查询某一天免考的会员
*
* @param tableName 结算表
*/
List<CuMemberSettleExt> queryExemptCuMemberSettle(String tableName);
/**
* 查询会员结算表，查询出结算表中会员伞下左右区满足等级
*

81
bd-business/bd-business-member/src/main/java/com/hzs/member/achieve/param/MemberAchieveParam.java
View File

@ -1,81 +0,0 @@
package com.hzs.member.achieve.param;
import com.baomidou.mybatisplus.annotation.KeySequence;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.math.BigDecimal;
/**
* <p>
* 会员业绩记录
* </p>
*
* @author hzs
* @since 2022-10-26
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class MemberAchieveParam implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 会员编号
*/
private Long pkMember;
/**
* 汇率
*/
private Integer pkRate;
/**
* 首购新增金额
*/
private BigDecimal newAmount;
/**
* 首购新增业绩
*/
private BigDecimal newPv;
/**
* 真实新增金额
*/
private BigDecimal newRealAmount;
/**
* 真实新增业绩
*/
private BigDecimal newRealPv;
/**
* 复购新增金额
*/
private BigDecimal repNewAmount;
/**
* 复购新增业绩
*/
private BigDecimal repNewPv;
/**
* 轮
*/
private Integer round;
/**
* 次
*/
private Integer second;
}

268
bd-business/bd-business-member/src/main/java/com/hzs/member/achieve/service/ICuMemberAchieveService.java
View File

@ -3,10 +3,8 @@ package com.hzs.member.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.sale.order.SaOrder;
import com.hzs.member.achieve.controller.vo.*;
import com.hzs.member.achieve.param.MemberAchieveDisParam;
import com.hzs.member.achieve.param.MemberAchieveParam;
import com.hzs.member.achieve.param.MonthAchieveParam;
import com.hzs.member.achieve.vo.*;
import com.hzs.member.settlecenter.param.PlacementDataParam;
@ -19,15 +17,9 @@ import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
* <p>
* 会员业绩记录 服务类
* </p>
*
* @author hzs
* @since 2022-10-26
*/
public interface ICuMemberAchieveService extends IService<CuMemberAchieve> {
@ -36,171 +28,16 @@ public interface ICuMemberAchieveService extends IService<CuMemberAchieve> {
*
* @param pkMember 会员主键
* @param pkCountry 公司
* @return: CuMemberAchieve
* @Author: sui q
* @Date: 2022/10/26 15:04
*/
CuMemberAchieve queryCuMemberAchieveByPkMember(Long pkMember, Integer pkCountry);
/**
* 计算业绩（根据订单，用于秒接）
*
* @param saOrder 订单
* @return: void
* @Author: sui q
* @Date: 2022/10/31 10:03
*/
void calculateAchieveBySaOrder(SaOrder saOrder);
/**
* 计算业绩（根据订单列表，7天内所有订单）
*
* @param saOrderMap 订单列表
* @return: void
* @Author: sui q
* @Date: 2022/10/31 10:01
*/
void calculateAchieveBySaOrder(Map<String, List<SaOrder>> saOrderMap);
/**
* 创建每月的会员业绩记录表
*
* @param date 日期
* @return: void
* @Author: sui q
* @Date: 2022/10/31 15:17
*/
String createCuMemberAchieve(String date);
/**
* 创建每年的业绩统计年表，用于放月表
*
* @param tableName 表名
* @return: void
* @Author: sui q
* @Date: 2022/11/7 14:10
*/
void createCuMemberMonthTable(String tableName);
/*
* @description:更新会员业绩表 每月月统计报表
* @author: sui q
* @date: 2023/8/29 10:57
* @param: null null
**/
void mergeCuMemberMonth(Integer day, String date);
/**
* 将结算日表的值插入到结算月表中
*
* @param targetTableName 目标表 网体月表
* @param sourceTableName 来源表 结算日表
* @param period 期间
* @return: void
* @Author: sui q
* @Date: 2023/2/16 11:35
*/
void insertCuMemberAchieveBySettleDate(String targetTableName, String sourceTableName, Integer period);
/**
* 将结算日表的值插入到结算月表中
*
* @param targetTableName 目标表 网体月表
* @param sourceTableName 来源表 结算日表
* @param period 期间
* @return: void
* @Author: sui q
* @Date: 2023/2/16 11:35
*/
void mergeCuMemberAchieveBySettleDate(String targetTableName, String sourceTableName, Integer period);
/**
* 根据每日日业绩开始更新会员业绩 新增业绩、累计业绩
*
* @param memberAchieveParamMap 修改的结算
* @param tablaName 修改的结算期间表
* @return: Boolean
* @Author: sui q
* @Date: 2022/11/2 11:30
*/
Boolean updateCuMemberAchieveEveryDay(Map<Long, MemberAchieveParam> memberAchieveParamMap, String tablaName);
/**
* 根据每日日业绩开始回退更新会员业绩 新增业绩、累计业绩
*
* @param memberAchieveParamMap 修改的结算
* @param tablaName 修改的结算期间表
* @return: Boolean
* @Author: sui q
* @Date: 2022/11/2 11:30
*/
void updateCuMemberBackOldAchieveEveryDay(Map<Long, MemberAchieveParam> memberAchieveParamMap, String tablaName);
/**
* 将昨天日表数据插入今天日表中, 昨日日表更新今天日表网体表
* 根据昨天结算表数据更新今天结算表的业绩数据
*
* @param targetTable 目标表 记录10天跟月表一摸一样的滚动表数据
* @return: void
* @Author: sui q
* @Date: 2022/10/31 16:26
*/
void updateCuMemberSettleInitAchieve(String targetTable);
/**
* 将昨天日表数据插入今天日表中, 昨日日表更新今天日表网体表
* 根据昨天结算表数据更新今天结算表的业绩数据
*
* @param sourceTable 来源表，记录10天跟月表一摸一样的滚动表数据
* @param targetTable 目标表 记录10天跟月表一摸一样的滚动表数据
* @return: void
* @Author: sui q
* @Date: 2022/10/31 16:26
*/
void updateCuMemberSettleAchieveByBeforeDay(String sourceTable, String targetTable);
/**
* 根据特殊业务更新业绩
*
* @param targetTable 结算表
* @param period 期间
* @param pkId 主键
* @return: void
* @Author: sui q
* @Date: 2023/3/11 13:42
*/
void updateCuMemberSettleAchieveBySpecialBus(String targetTable, Integer period, Long pkId);
/*
* @description: 根据到期日期更新业绩，到期后需要还原到实际累计金额
* @author: sui q
* @date: 2023/4/8 15:32
* @param: null null
**/
void updateCuMemberSettleAchieveByDueDate(String currentTableName, String yesTableName, Date currentDate);
/*
* description: 业绩分布-安置图
* @author: sui q
* @date: 2023/4/6 18:01
* @param: null null
**/
CuMemberDisVO queryCuMemberAchieveDis(MemberAchieveDisParam memberAchieveDisParam);
/*
* @description: 点击架构树显示会员的业绩情况
* @author: sui q
* @date: 2023/5/10 16:04
* @param: null null
* 点击架构树显示会员的业绩情况
**/
CuMemberDisVO queryCuMemberDis(MemberAchieveDisParam memberAchieveDisParam);
/*
* description: 查询会员伞下血缘业绩
* @author: sui q
* @date: 2023/4/7 15:13
* @param: null null
* 查询会员伞下血缘业绩
**/
BigDecimal queryCuMemberUnderBloodAchieveByPkMember(MemberAchieveDisParam memberAchieveDisParam);
@ -212,14 +49,6 @@ public interface ICuMemberAchieveService extends IService<CuMemberAchieve> {
*/
List<CuMemberNewAddAchieveVO> selectNewAddAchieve(CuMemberNewAddAchieveVO cuMemberNewAddAchieveVO);
/**
* 根据天数查询新增业绩
*
* @param cuMemberNewAddAchieveVO 端新增业绩
* @return List<CuMemberNewAddAchieveVO>
*/
List<CuMemberNewAddAchieveVO> selectNewAddAchieveByDay(CuMemberNewAddAchieveVO cuMemberNewAddAchieveVO);
/**
* 会员端首页荣誉奖衔
*
@ -251,77 +80,44 @@ public interface ICuMemberAchieveService extends IService<CuMemberAchieve> {
LocalDate getStartDateByType(Integer dayType, LocalDate localDate);
/**
* @description: 业绩分布-新增业绩统计
* @author: zhang jing
* @date: 2023/5/19 10:29
* @param: []
* @return: com.hzs.member.achieve.controller.vo.PlaceNewAddAchieveVO
* 业绩分布-新增业绩统计
**/
PlaceNewAddAchieveVO placeNewAddAchieveStat(PlaceNewAddAchieveVO pna);
Date getDateFromYearAndMonth(String year, String month);
/**
* @description: 月度业绩-左右区人数详情(最新)
* @author: zhang jing
* @date: 2023/9/28 11:38
* @param: [pna]
* @return: java.util.List<com.hzs.member.achieve.controller.vo.PlaceNewAddAchieveVO>
* 月度业绩-左右区人数详情(最新)
**/
List<PlaceNewAddAchieveVO> placeNewAddAchieveDetails(PlaceNewAddAchieveVO pna);
/**
* @description: 月度业绩-左右区人数详情(历史)
* @author: zhang jing
* @date: 2023/9/28 11:38
* @param: [pna]
* @return: java.util.List<com.hzs.member.achieve.controller.vo.PlaceNewAddAchieveVO>
* 月度业绩-左右区人数详情(历史)
**/
List<PlaceNewAddAchieveVO> placeNewAddAchieveHistoryDetails(PlaceNewAddAchieveVO pna);
/**
* @description:月度业绩-左右区业绩详情
* @author: zhang jing
* @date: 2023/11/30 9:17
* @param: [pna]
* @return: java.util.List<com.hzs.member.achieve.controller.vo.PlaceNewAddAchieveVO>
* 月度业绩-左右区业绩详情
**/
List<PlaceNewAddAchieveVO> leftRightAchieveDetails(PlaceNewAddAchieveVO pna);
/**
* @description:月度业绩-左右区血缘业绩详情
* @author: zhang jing
* @date: 2023/11/30 11:15
* @param: [pna]
* @return: java.util.List<com.hzs.member.achieve.controller.vo.PlaceNewAddAchieveVO>
* 月度业绩-左右区血缘业绩详情
**/
List<PlaceNewAddAchieveVO> leftRightDirectAchieveDetails(PlaceNewAddAchieveVO pna);
/**
* @description:月度业绩-查询血缘业绩详情
* @author: zhang jing
* @date: 2023/11/30 14:13
* @param: [pna]
* @return: java.util.List<com.hzs.member.achieve.controller.vo.PlaceNewAddAchieveVO>
* 月度业绩-查询血缘业绩详情
**/
List<PlaceNewAddAchieveVO> directAchieveDetails(PlaceNewAddAchieveVO pna);
/**
* @description: 业绩分布-直推业绩（右图）
* @author: zhang jing
* @date: 2023/5/20 16:22
* @param: [pa]
* @return: com.hzs.member.achieve.controller.vo.ParentAchieveVO
* 业绩分布-直推业绩（右图）
**/
ParentAchieveVO parentAchieveRight(ParentAchieveVO pa);
/**
* @description: 业绩分布-直推业绩（左图）
* @author: zhang jing
* @date: 2023/5/23 19:49
* @param: [pa]
* @return: java.util.List<com.hzs.member.achieve.controller.vo.ParentAchieveVO>
* 业绩分布-直推业绩（左图）
**/
List<ParentAchieveVO> parentAchieveLeft(ParentAchieveVO pa);
@ -352,7 +148,6 @@ public interface ICuMemberAchieveService extends IService<CuMemberAchieve> {
*/
RealPerformanceVo queryRealPerformance(Long pkMember, Integer pkCountry, Integer month);
/**
* 会员真实业绩饼状图
*
@ -363,15 +158,6 @@ public interface ICuMemberAchieveService extends IService<CuMemberAchieve> {
*/
AzAchievementPie queryRealPerformancePic(Long pkMember, Integer pkCountry, Integer month);
/*
* @description: 更新会员的业绩
* @author: sui q
* @date: 2023/8/12 15:46
* @param: null null
**/
void updateCuMemberAchieve();
/**
* 查询安置图表
*
@ -380,7 +166,6 @@ public interface ICuMemberAchieveService extends IService<CuMemberAchieve> {
*/
PlacementImageDataVO selectPlaceImage(PlacementDataParam param);
/**
* 查询推荐体第图表
*
@ -389,7 +174,6 @@ public interface ICuMemberAchieveService extends IService<CuMemberAchieve> {
*/
List<RecommendImageDataVO> selectRecommendVertexImage(PlacementDataParam param);
/**
* 查询推荐团队图表
*
@ -399,46 +183,20 @@ public interface ICuMemberAchieveService extends IService<CuMemberAchieve> {
List<RecommendTeamImagVO> selectRecommendTeamImage(PlacementDataParam param);
/*
* @description: 查询月统计数据，按照月倒叙
* @author: sui q
* @date: 2023/8/29 16:10
* @param: null null
* 查询月统计数据，按照月倒叙
**/
List<CuMemberAchieveExt> queryMemberMonthAchieve(Long pkMember, String month);
/*
* @description: 查询会员一代伞下
* @author: sui q
* @date: 2023/8/29 18:07
* @param: null null
**/
List<Long> queryPkMemberMonthAchieve(String month, Long pkMember);
/*
* @description: 查询月统计数据，查询明细
* @author: sui q
* @date: 2023/8/29 17:43
* @param: null null
**/
List<CuMemberAchieveExt> queryMemberMonthAchieveDetail(List<Long> memberList, MonthAchieveParam monthAchieveParam);
/*
* @description: 查询月统计数据，查询明细，安置伞下
* @author: sui q
* @date: 2023/9/6 21:12
* @param: null null
* 查询月统计数据，查询明细，安置伞下
**/
List<CuMemberAchieveExt> queryPlaceParentMemberMonthAchieve(MonthAchieveParam monthAchieveParam);
/*
* @description: 查询月统计数据，查询明细，安置伞下
* @author: sui q
* @date: 2023/9/6 21:12
* @param: null null
* 查询月统计数据，查询明细，安置伞下
**/
List<CuMemberAchieveExt> queryParentMemberMonthAchieve(MonthAchieveParam monthAchieveParam);
/**
* 根据实时小区业绩获取奖衔
*

24
bd-business/bd-business-member/src/main/java/com/hzs/member/achieve/service/ICuMemberMonthAchieveService.java
View File

@ -2,38 +2,14 @@ package com.hzs.member.achieve.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hzs.common.domain.member.achieve.CuMemberMonthAchieve;
import com.hzs.common.domain.member.ext.CuMemberMonthAchieveExt;
import com.hzs.member.achieve.controller.vo.ParentAchieveVO;
import com.hzs.member.achieve.controller.vo.RealPerformanceVo;
import java.util.Date;
import java.util.List;
/**
* 会员月数据 服务类
*/
public interface ICuMemberMonthAchieveService extends IService<CuMemberMonthAchieve> {
/**
* 每日生成业绩、月表统计数据
*/
void insertCuMemberAchieveByEveryDay(Date settleDate);
/**
* 每天插入会员月表，计算推荐业绩，复购业绩，1-6号计算前7天
*/
void insertCuMemberMonthAchieve(Date settleDate);
/**
* 每天统计月表数据
*/
void insertCuMemberCuMemberMonthYearAchieve(Date settleDate);
/**
* 根据条件查询会员月业绩
*/
List<CuMemberMonthAchieveExt> queryCuMemberMonthAchieveRecommend(ParentAchieveVO parentAchieveVO);
/**
* 查询会员真实业绩
*

50
bd-business/bd-business-member/src/main/java/com/hzs/member/achieve/service/ICuMemberTreeService.java
View File

@ -19,28 +19,6 @@ public interface ICuMemberTreeService extends IService<CuMemberTree> {
*/
Integer queryExistOracleTable(String tableName);
/**
* 创建会员网体推荐人索引
*
* @param tableName 日期
*/
void createCuMemberTableUniqueIndex(String tableName);
/**
* 创建表的序列
*
* @param tableName 表名
* @param tableNameSeq 序列名
*/
void createCuMemberTableSequence(String tableName, String tableNameSeq);
/**
* 查询历史会员网体信息,查询某一天免考的会员
*
* @param tableName 结算表
*/
List<CuMemberSettleExt> queryExemptCuMemberSettle(String tableName);
/**
* 查询会员结算表，查询出结算表中会员伞下左右区满足等级
*
@ -113,32 +91,4 @@ public interface ICuMemberTreeService extends IService<CuMemberTree> {
*/
CuMemberRetailSExt queryCuMemberTreeByPlacePkMemberTable(String settleTableName, Long pkMember);
/**
* 删除日表数据
*
* @param tableName 表名
*/
void truncateCuMemberTreeTable(String tableName);
/**
* 创建会员网体推荐人索引
*
* @param tableName 日期
*/
void createCuMemberTreeDayOnlyIndex(String tableName);
/**
* 创建会员网体推荐人索引
*
* @param tableName 日期
*/
void createCuMemberTreeParentIndex(String tableName);
/**
* 创建会员网体安置人索引
*
* @param tableName 日期
*/
void createCuMemberTreePlaceIndex(String tableName);
}

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

@ -18,7 +18,6 @@ import com.hzs.common.domain.member.base.CuMember;
import com.hzs.common.domain.member.ext.CuMemberExt;
import com.hzs.common.domain.member.ext.CuMemberSettleExt;
import com.hzs.common.domain.member.ext.CuMemberTeamExt;
import com.hzs.common.domain.sale.order.SaOrder;
import com.hzs.common.domain.system.config.BdAwards;
import com.hzs.common.security.utils.SecurityUtils;
import com.hzs.common.service.ITransactionCommonService;
@ -26,7 +25,6 @@ import com.hzs.member.account.service.ICuMemberBaseService;
import com.hzs.member.achieve.controller.vo.*;
import com.hzs.member.achieve.mapper.CuMemberAchieveMapper;
import com.hzs.member.achieve.param.MemberAchieveDisParam;
import com.hzs.member.achieve.param.MemberAchieveParam;
import com.hzs.member.achieve.param.MonthAchieveParam;
import com.hzs.member.achieve.service.ICuMemberAchieveService;
import com.hzs.member.achieve.service.ICuMemberMonthAchieveService;
@ -67,66 +65,41 @@ import java.util.stream.Collectors;
/**
* 会员业绩记录 服务实现类
*
* @author hzs
* @since 2022-10-26
*/
@Slf4j
@Service
public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMapper, CuMemberAchieve> implements ICuMemberAchieveService {
private ICuMemberTreeService cuMemberTreeService;
private CuMemberBonusSettle cuMemberBonusSettle;
private ICuMemberService cuMemberService;
@Autowired
private ICuMemberSettlePeriodService cuMemberSettlePeriodService;
private ICuMemberTreeService iCuMemberTreeService;
@Autowired
private ICuMemberService iCuMemberService;
@Autowired
private ICuMemberSettlePeriodService iCuMemberSettlePeriodService;
@Autowired
private ICuMemberBaseService iCuMemberBaseService;
@Autowired
private ICuMemberMonthAchieveService memberMonthAchieveService;
private ICuMemberMonthAchieveService iCuMemberMonthAchieveService;
@Autowired
private ITransactionCommonService iTransactionCommonService;
@DubboReference
ICountryServiceApi iCountryServiceApi;
@DubboReference
IAwardsServiceApi awardsServiceApi;
IAwardsServiceApi iAwardsServiceApi;
@DubboReference
IVertexServiceApi iVertexServiceApi;
@DubboReference
ICurrencyServiceApi currencyServiceApi;
ICurrencyServiceApi iCurrencyServiceApi;
@DubboReference
IMemberTeamServiceApi teamServiceApi;
IMemberTeamServiceApi iMemberTeamServiceApi;
@Autowired
public void setCuMemberService(ICuMemberService cuMemberService) {
this.cuMemberService = cuMemberService;
}
@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;
}
@Autowired
ITransactionCommonService iTransactionCommonService;
@Override
public CuMemberAchieve queryCuMemberAchieveByPkMember(Long pkMember, Integer pkCountry) {
Date currentDate = DateUtils.currentDate();
// 查看秒接表，秒接表不存在查询昨天的结算表
int currentPeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, currentDate)).getPkId();
int currentPeriod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, currentDate)).getPkId();
String currentTableName = TableNameConstants.CU_MEMBER_SECOND + currentPeriod;
CuMemberAchieve cuMemberAchieve = baseMapper.queryCuMemberAchieveByPkMember(pkMember, pkCountry, currentTableName);
if (cuMemberAchieve != null) {
@ -136,193 +109,24 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
}
}
// 创建日表记录表
int period = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(
int period = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(
DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, DateUtils.beforeDate(1, ChronoUnit.DAYS, currentDate))).getPkId();
String settleTableName = TableNameConstants.CU_MEMBER_SETTLE + period;
return baseMapper.queryCuMemberAchieveByPkMember(pkMember, pkCountry, settleTableName);
}
/**
* @param saOrder 订单
* @Description: 秒接
* @return: void
* @Author: sui q
* @Date: 2022/10/31 10:03
*/
@Override
public void calculateAchieveBySaOrder(SaOrder saOrder) {
}
/**
* @param saOrderMap 订单列表
* @Description: 结算7天奖金
* @return: void
* @Author: sui q
* @Date: 2022/10/31 10:04
*/
@Override
public void calculateAchieveBySaOrder(Map<String, List<SaOrder>> saOrderMap) {
// 为了结算效率 将表拆为 月表，日表
// 结算日期 当天日期的所有订单
saOrderMap.forEach((settleDate, saOrderList) -> {
// 根据日期获取头一天的业绩记录，业绩表进行分表处理 规则为 CU_MEMBER_ACHIEVE202210
Set<Long> pkMemberSet = new HashSet<>();
saOrderList.forEach(saOrder -> pkMemberSet.add(saOrder.getPkMember()));
// 查询数据库 会员历史网体、等级、奖衔、
// Future<Map<String, String>> dataBaseFuture = null;
// if (CollectionUtils.isNotEmpty(contentList)) {
// dataBaseFuture = ThreadUtils.executorService.submit(() -> this.queryTransactionListByDataBase(contentList, fromLanguage, toLanguage));
// }
});
// 会员网体记录表中查询会员网体，会员网体记录每月一张表
// 历史奖衔、等级从奖衔升级表、等级登记表中获得
}
@Override
public String createCuMemberAchieve(String date) {
// 创建业绩月表记录表
String tableName = TableNameConstants.CU_MEMBER_ACHIEVE + DateUtils.getMonth(date);
Integer num = cuMemberTreeService.queryExistOracleTable(tableName);
if (num == null || num <= 0) {
baseMapper.createCuMemberAchieveTable(tableName);
cuMemberTreeService.createCuMemberTableUniqueIndex(tableName);
cuMemberTreeService.createCuMemberTableSequence(tableName, TableNameConstants.CU_MEMBER_ACHIEVE_SEQ);
}
return tableName;
}
@Override
public void createCuMemberMonthTable(String tableName) {
baseMapper.createCuMemberMonthTable(tableName);
}
@Override
public void mergeCuMemberMonth(Integer day, String date) {
String tableName = TableNameConstants.CU_MEMBER_MONTH + DateUtils.getMonth(date);
CuMemberSettlePeriod cuMemberSettlePeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(date);
// 每月6号删除上月数据,重新生成
if (day == 6) {
Integer number = cuMemberTreeService.queryExistOracleTable(tableName);
if (number != null && number > 0) {
cuMemberTreeService.truncateCuMemberTreeTable(tableName);
}
}
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 updateCuMemberSettleAchieveBySpecialBus(String targetTable, Integer period, Long pkId) {
baseMapper.updateCuMemberSettleAchieveBySpecialBus(targetTable, period, pkId);
}
@Override
public void updateCuMemberSettleAchieveByDueDate(String currentTableName, String yesTableName, Date currentDate) {
baseMapper.updateCuMemberSettleAchieveByDueDate(currentTableName, yesTableName, currentDate);
}
@Override
public Boolean updateCuMemberAchieveEveryDay(Map<Long, MemberAchieveParam> memberAchieveParamMap, String tablaName) {
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);
});
return true;
}
@Override
public void updateCuMemberBackOldAchieveEveryDay(Map<Long, MemberAchieveParam> memberAchieveParamMap, String tablaName) {
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 CuMemberDisVO queryCuMemberAchieveDis(MemberAchieveDisParam memberAchieveDisParam) {
// 判断时间 当前时间查询cu_member
CuMemberAchieveDisVO leftMemberAchieveDisVO = new CuMemberAchieveDisVO();
CuMemberAchieveDisVO rightMemberAchieveDisVO = new CuMemberAchieveDisVO();
List<CuMemberExt> cuMemberExtList = cuMemberService.queryMemberByCondition(CuMember.builder().pkId(memberAchieveDisParam.getPkMember()).build());
CuMemberExt cuMember = cuMemberExtList.get(0);
String image = setGradeImageUrl(cuMember.getCategory(), cuMember.getGradeValue());
CuMemberDisVO cuMemberDisVO = CuMemberDisVO.builder()
.memberName(cuMember.getMemberName())
.memberCode(cuMember.getMemberCode())
.imageUrl(image)
.build();
List<CuMemberExt> lastCuMemberList = cuMemberService.queryCuMemberLastPlaceParent(memberAchieveDisParam.getPkMember());
if (CollectionUtil.isNotEmpty(lastCuMemberList)) {
for (CuMemberExt cuMemberExt : lastCuMemberList) {
String imageUrl = setGradeImageUrl(cuMemberExt.getCategory(), cuMemberExt.getGradeValue());
packageLastMember(leftMemberAchieveDisVO, rightMemberAchieveDisVO, cuMemberExt.getPlaceDept(),
cuMemberExt.getMemberCode(),
cuMemberExt.getMemberName(),
imageUrl);
}
}
if (StringUtils.isEmpty(leftMemberAchieveDisVO.getLastMemberCode())) {
leftMemberAchieveDisVO.setLastMemberCode(cuMember.getMemberCode());
leftMemberAchieveDisVO.setLastMemberName(cuMember.getMemberName());
String imageUrl = setGradeImageUrl(cuMember.getCategory(), cuMember.getGradeValue());
leftMemberAchieveDisVO.setLastImageUrl(imageUrl);
}
cuMemberDisVO.setLeftMember(leftMemberAchieveDisVO);
if (StringUtils.isEmpty(rightMemberAchieveDisVO.getLastMemberCode())) {
rightMemberAchieveDisVO.setLastMemberCode(cuMember.getMemberCode());
rightMemberAchieveDisVO.setLastMemberName(cuMember.getMemberName());
String imageUrl = setGradeImageUrl(cuMember.getCategory(), cuMember.getGradeValue());
rightMemberAchieveDisVO.setLastImageUrl(imageUrl);
}
cuMemberDisVO.setRightMember(rightMemberAchieveDisVO);
return cuMemberDisVO;
}
@Override
public CuMemberDisVO queryCuMemberDis(MemberAchieveDisParam memberAchieveDisParam) {
// Date currentDate = DateUtils.currentDate();
// if (DateUtils.compareDateBefore(memberAchieveDisParam.getSettleDate(), currentDate)) {
// // 从历史表中获取
// CuMemberSettlePeriod cuMemberSettlePeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, memberAchieveDisParam.getSettleDate()));
// CuMemberSettlePeriod cuMemberSettlePeriod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, memberAchieveDisParam.getSettleDate()));
// String tableName = TableNameConstants.CU_MEMBER_SETTLE + cuMemberSettlePeriod.getPkId();
// CuMemberExt member = cuMemberService.getMemberByCode(memberAchieveDisParam.getMemberCode());
// List<CuMemberSettleExt> cuMemberSettleExtList = cuMemberTreeService.queryCuMemberTree(tableName, member.getPkId(), null);
// CuMemberExt member = iCuMemberService.getMemberByCode(memberAchieveDisParam.getMemberCode());
// List<CuMemberSettleExt> cuMemberSettleExtList = iCuMemberTreeService.queryCuMemberTree(tableName, member.getPkId(), null);
// return BeanUtil.copyProperties(cuMemberSettleExtList.get(0), CuMemberDisVO.class);
// }else{
CuMember cuMember = cuMemberService.queryMember(memberAchieveDisParam.getMemberCode());
CuMember cuMember = iCuMemberService.queryMember(memberAchieveDisParam.getMemberCode());
CuMemberDisVO cuMemberDisVO = BeanUtil.copyProperties(cuMember, CuMemberDisVO.class);
cuMemberDisVO.setMemberCode(cuMember.getMemberCode());
cuMemberDisVO.setMemberName(cuMember.getMemberName());
@ -335,53 +139,18 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
// }
}
private String setGradeImageUrl(Integer category, Integer gradeValue) {
for (EGrade grade : EGrade.values()) {
if (ECategory.NORMAL.getValue() != category && -category == grade.getValue()) {
return grade.getImageUrl();
} else if (gradeValue == grade.getValue()) {
return grade.getImageUrl();
}
}
return MemberFrameworkConstants.xuni;
}
@Override
public BigDecimal queryCuMemberUnderBloodAchieveByPkMember(MemberAchieveDisParam memberAchieveDisParam) {
return null;
}
/**
* 最末安置人
*/
private static void packageLastMember(CuMemberAchieveDisVO leftMemberAchieveDisVO, CuMemberAchieveDisVO rightMemberAchieveDisVO, Integer placeDept, String memberCode, String memberName, String imageUrl) {
if (EPlaceDept.LEFT_DEPT.getValue() == placeDept) {
leftMemberAchieveDisVO.setLastMemberCode(memberCode);
leftMemberAchieveDisVO.setLastMemberName(memberName);
leftMemberAchieveDisVO.setLastImageUrl(imageUrl);
} else {
rightMemberAchieveDisVO.setLastMemberCode(memberCode);
rightMemberAchieveDisVO.setLastMemberName(memberName);
rightMemberAchieveDisVO.setLastImageUrl(imageUrl);
}
}
@Override
public List<CuMemberNewAddAchieveVO> selectNewAddAchieve(CuMemberNewAddAchieveVO cuMemberNewAddAchieveVO) {
LocalDate endDate = LocalDate.now();
LocalDate startDate = getStartDateByType(cuMemberNewAddAchieveVO.getDayType(), endDate);
return selectNewAddAchieveByDate(cuMemberNewAddAchieveVO, endDate, startDate);
}
@Override
public List<CuMemberNewAddAchieveVO> selectNewAddAchieveByDay(CuMemberNewAddAchieveVO cuMemberNewAddAchieveVO) {
LocalDate endDate = LocalDate.now();
LocalDate startDate = endDate.minus(cuMemberNewAddAchieveVO.getDays(), ChronoUnit.DAYS);
return selectNewAddAchieveByDate(cuMemberNewAddAchieveVO, endDate, startDate);
}
/**
* 根据日期查询会员的新增业绩
*
@ -512,7 +281,7 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
awardsList.sort(Comparator.comparing(BdAwards::getAwardsValue));
Map<Integer, BdAwards> awardsMap = awardsList.stream().collect(Collectors.toMap(BdAwards::getAwardsValue, o -> o));
if (pkAwards != null) {
BdAwards bdAwards = awardsServiceApi.getAwardsOne(pkAwards).getData();
BdAwards bdAwards = iAwardsServiceApi.getAwardsOne(pkAwards).getData();
List<BdAwards> list = awardsList.stream().filter(a -> a.getAwardsValue() > bdAwards.getAwardsValue()).collect(Collectors.toList());
//当奖衔最大级别时，目标值-1
@ -562,20 +331,13 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
public CuMemberAwardsUnderVO getBigSmallArea(Long pkMember, Integer pkCountry) {
//获取期数
String upLastMonth = DateUtils.beforeMonthLastDateStr(new Date());
int period = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(upLastMonth).getPkId();
int period = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(upLastMonth).getPkId();
//查询会员结余判断大小区
String settleTable = TableNameConstants.CU_MEMBER_SETTLE + period;
CuMemberAwardsUnderVO memberAwards = CuMemberAwardsUnderVO.builder().settleTable(settleTable).pkMember(pkMember).pkCountry(pkCountry).period(period).build();
return baseMapper.selectBalanceByPkMember(memberAwards);
}
/**
* 根据实时小区业绩获取奖衔
*
* @param pkMember 会员ID
* @param pkCountry 国家ID
* @return Integer
*/
@Override
public CuMemberAwardsUnderVO getPkAwardBySmallAchieve(Long pkMember, Integer pkCountry, boolean yesterdayFlag) {
CuMemberAwardsUnderVO cuMemberAwardsUnderVO = null;
@ -585,7 +347,7 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
if (yesterdayFlag) {
//查询历史小区业绩、昨日业绩
String localDate = LocalDate.now().minus(1, ChronoUnit.DAYS).format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
int period = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(localDate).getPkId();
int period = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(localDate).getPkId();
//查询会员昨日业绩
String settleTable = TableNameConstants.CU_MEMBER_SETTLE + period;
CuMemberAwardsUnderVO memberAwards = CuMemberAwardsUnderVO.builder().settleTable(settleTable).pkMember(pkMember).pkCountry(pkCountry).period(period).build();
@ -625,7 +387,7 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
//根据国家获取奖衔配置信息
List<BdAwards> awardsList = awardsServiceApi.queryAwards(pkCountry).getData();
List<BdAwards> awardsList = iAwardsServiceApi.queryAwards(pkCountry).getData();
cuMemberAwardsUnderVO.setAwardsList(awardsList);
//获取当前会员的奖衔
cuMemberAwardsUnderVO.setPkAwards(getMemberAwards(awardsList, cuMemberAwardsUnderVO.getSumRealPv()));
@ -639,7 +401,6 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
* @param sumRealPv 小区业绩
* @return Integer
*/
private Integer getMemberAwards(List<BdAwards> awardsList, BigDecimal sumRealPv) {
for (BdAwards awards : awardsList) {
BigDecimal communityCheck = awards.getCommunityCheck();
@ -656,10 +417,10 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
BigDecimal rate = null;
//获取期数
String date = LocalDate.now().minus(1, ChronoUnit.DAYS).format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
int period = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(date).getPkId();
int period = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(date).getPkId();
//根据国家获取奖衔配置信息
List<BdAwards> awardsList = awardsServiceApi.queryAwards(pkCountry).getData();
List<BdAwards> awardsList = iAwardsServiceApi.queryAwards(pkCountry).getData();
//升序排序
awardsList.sort(Comparator.comparing(BdAwards::getAwardsValue));
@ -675,8 +436,8 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
rate = iCuMemberBaseService.getCurrency(pkCountry).getInExchangeRate();
}
if (null == memberAwardsUnderVO) {
CuMember member = cuMemberService.getMember(pkMember);
BdAwards bdAwards = awardsServiceApi.getAwardsOne(member.getPkAwards()).getData();
CuMember member = iCuMemberService.getMember(pkMember);
BdAwards bdAwards = iAwardsServiceApi.getAwardsOne(member.getPkAwards()).getData();
//取当前奖衔值的下一个奖衔值
List<BdAwards> list = awardsList.stream().filter(awards -> awards.getAwardsValue() > bdAwards.getAwardsValue()).collect(Collectors.toList());
BigDecimal targetPv = awardsMap.get(list.get(0).getAwardsValue()).getCommunityCheck();
@ -689,7 +450,7 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
memberAwardsUnderVO.setTargetPv(targetPv.divide(new BigDecimal("10000")));
}
} else {
CuMember member = cuMemberService.getMember(pkMember);
CuMember member = iCuMemberService.getMember(pkMember);
memberAwardsUnderVO.setMemberName(member.getMemberName());
getCuMemberAwars(memberAwardsUnderVO, awardsMap, awardsList, false, pkCountry, rate);
}
@ -774,7 +535,7 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
if (null == pkAwards) {
return null;
}
BdAwards BdAwards = awardsServiceApi.getAwardsOne(pkAwards).getData();
BdAwards BdAwards = iAwardsServiceApi.getAwardsOne(pkAwards).getData();
memberAwardsUnderVO.setAwardsName(BdAwards.getAwardsName());
memberAwardsUnderVO.setPkTransaction(BdAwards.getPkTransaction());
if (!isTransaction) {
@ -815,23 +576,15 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
CuMemberMonthAchieveContrastVO lastMonthAchieve = getMonthInfo(lastMonthDate, pkMember, pkCountry);
lastMonthAchieve.setDate(lastMonthDate.format(DateTimeFormatter.ofPattern("yyyy-MM")));
//去年同月 （bug处理新需求不需要展示这部分数据）
// LocalDate lastYearDate = localDate.minus(12, ChronoUnit.MONTHS);
// CuMemberMonthAchieveContrastVO lastYearAchieve = getMonthInfo(lastYearDate, pkMember, pkCountry);
// lastYearAchieve.setDate(lastYearDate.format(DateTimeFormatter.ofPattern("yyyy-MM")));
//中国转汇率
if (pkCountry.equals(CountryConstants.CHINA_COUNTRY)) {
//根据国家查汇率
BigDecimal rate = iCuMemberBaseService.getCurrency(pkCountry).getInExchangeRate();
getAchieveContrastVOByRate(localMonthAchieve, rate);
getAchieveContrastVOByRate(lastMonthAchieve, rate);
// getAchieveContrastVOByRate(lastYearAchieve, rate);
}
// achieveContrastVOList.add(lastYearAchieve);
achieveContrastVOList.add(lastMonthAchieve);
achieveContrastVOList.add(localMonthAchieve);
return achieveContrastVOList;
@ -897,8 +650,7 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
*/
private String getAchieveTable(LocalDate localDate) {
String date = localDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
String achieveTable = TableNameConstants.CU_MEMBER_ACHIEVE + DateUtils.getMonth(date);
return achieveTable;
return TableNameConstants.CU_MEMBER_ACHIEVE + DateUtils.getMonth(date);
}
/**
@ -1001,14 +753,6 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
return baseMapper.umbrellaAchieveTop(pav);
}
/**
* @description: 业绩分布-新增业绩统计
* @author: zhang jing
* @date: 2023/5/19 10:33
* @param: []
* @return: com.hzs.member.achieve.controller.vo.PlaceNewAddAchieveVO
**/
@Override
public PlaceNewAddAchieveVO placeNewAddAchieveStat(PlaceNewAddAchieveVO pna) {
PlaceNewAddAchieveVO rtupna = new PlaceNewAddAchieveVO();
@ -1059,7 +803,7 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
pna.setStartDate(startDateStr);
pna.setEndDate(endDateStr);
pna.setAchieveTableName(achieveTableName);
R<CurrencyDTO> currency = currencyServiceApi.getCurrency(SecurityUtils.getPkCountry());
R<CurrencyDTO> currency = iCurrencyServiceApi.getCurrency(SecurityUtils.getPkCountry());
//查询左右区业绩
PlaceNewAddAchieveVO achieve = selectNewABAchieve(pna);
@ -1101,7 +845,7 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
//查询最新期数
int endperiod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(
int endperiod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(
DateUtils.parseDateToStr(endDateStr)).getPkId();
//如果是当前月，则查询最新月份数据 查询左右区人数
String monthStr = DateUtils.getMonth(endDateStr);
@ -1111,7 +855,7 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
if (CollectionUtil.isNotEmpty(monthCount)) {
//获取上一个月的最后一天
String lastMonth = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, DateUtils.beforeMonthLastDate(currentDate));
int lastendperiod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(
int lastendperiod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(
DateUtils.parseDateToStr(lastMonth)).getPkId();
treeTableNameEnd = TableNameConstants.CU_MEMBER_SETTLE + lastendperiod;
pna.setAchieveTableName(treeTableNameEnd);
@ -1145,7 +889,7 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
//当前日期
Date frontDate = DateUtils.parseStringToDate(endDateStr);
String frontLastMonth = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, DateUtils.beforeMonthLastDate(frontDate));
int frontLastendperiod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(
int frontLastendperiod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(
DateUtils.parseDateToStr(frontLastMonth)).getPkId();
String frontTreeTableNameEnd = TableNameConstants.CU_MEMBER_SETTLE + frontLastendperiod;
frontPna.setPkMember(pna.getPkMember());
@ -1236,13 +980,6 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
return rtupna;
}
/**
* @description: 根据年月获取日期
* @author: zhang jing
* @date: 2024/1/3 10:30
* @param: [year, month]
* @return: java.util.Date
**/
@Override
public Date getDateFromYearAndMonth(String year, String month) {
Calendar calendar = null;
@ -1265,80 +1002,37 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
return calendar.getTime();
}
/**
* @description: 月度业绩-左右区人数详情(最新)
* @author: zhang jing
* @date: 2023/9/28 11:38
* @param: [pna]
* @return: java.util.List<com.hzs.member.achieve.controller.vo.PlaceNewAddAchieveVO>
**/
@Override
public List<PlaceNewAddAchieveVO> placeNewAddAchieveDetails(PlaceNewAddAchieveVO pna) {
return baseMapper.placeNewAddAchieveDetails(pna);
}
/**
* @description: 月度业绩-左右区人数详情(历史)
* @author: zhang jing
* @date: 2023/11/29 11:38
* @param: [pna]
* @return: java.util.List<com.hzs.member.achieve.controller.vo.PlaceNewAddAchieveVO>
**/
@Override
public List<PlaceNewAddAchieveVO> placeNewAddAchieveHistoryDetails(PlaceNewAddAchieveVO pna) {
return baseMapper.placeNewAddAchieveHistoryDetails(pna);
}
/**
* @description: 月度业绩-左右区业绩详情
* @author: zhang jing
* @date: 2023/11/30 9:18
* @param: [pna]
* @return: java.util.List<com.hzs.member.achieve.controller.vo.PlaceNewAddAchieveVO>
**/
@Override
public List<PlaceNewAddAchieveVO> leftRightAchieveDetails(PlaceNewAddAchieveVO pna) {
return baseMapper.leftRightAchieveDetails(pna);
}
/**
* @description: 月度业绩-左右区血缘业绩详情
* @author: zhang jing
* @date: 2023/11/30 11:25
* @param: [pna]
* @return: java.util.List<com.hzs.member.achieve.controller.vo.PlaceNewAddAchieveVO>
**/
@Override
public List<PlaceNewAddAchieveVO> leftRightDirectAchieveDetails(PlaceNewAddAchieveVO pna) {
return baseMapper.leftRightDirectAchieveDetails(pna);
}
/**
* @description: 月度业绩-查询血缘业绩详情
* @author: zhang jing
* @date: 2023/11/30 14:15
* @param: [pna]
* @return: java.util.List<com.hzs.member.achieve.controller.vo.PlaceNewAddAchieveVO>
**/
@Override
public List<PlaceNewAddAchieveVO> directAchieveDetails(PlaceNewAddAchieveVO pna) {
return baseMapper.directAchieveDetails(pna);
}
/**
* @description: 业绩分布-直推业绩（右图）
* @author: zhang jing
* @date: 2023/5/20 16:20
* @param: [pa]
* @return: com.hzs.member.achieve.controller.vo.ParentAchieveVO
**/
@Override
public ParentAchieveVO parentAchieveRight(ParentAchieveVO pa) {
pa = getDateStr(pa);
R<CurrencyDTO> currency = currencyServiceApi.getCurrency(SecurityUtils.getPkCountry());
R<CurrencyDTO> currency = iCurrencyServiceApi.getCurrency(SecurityUtils.getPkCountry());
//结束期数
int endPeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(pa.getEndDate()).getPkId();
int endPeriod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(pa.getEndDate()).getPkId();
pa.setPeriod(endPeriod);
//直推等级人数和业绩
@ -1371,25 +1065,18 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
return pa;
}
/**
* @description: 业绩分布-直推业绩统计（左图）
* @author: zhang jing
* @date: 2023/5/23 14:22
* @param: [pa]
* @return: java.util.List<com.hzs.member.achieve.controller.vo.ParentAchieveVO>
**/
@Override
public List<ParentAchieveVO> parentAchieveLeft(ParentAchieveVO pa) {
pa = getDateStr(pa);
//获取期数
int endPeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(pa.getEndDate()).getPkId();
int endPeriod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(pa.getEndDate()).getPkId();
pa.setPeriod(endPeriod);
CuMember member = cuMemberService.getMember(pa.getPkMember());
CuMember member = iCuMemberService.getMember(pa.getPkMember());
List<ParentAchieveVO> parentList = new ArrayList<>();
ParentAchieveVO par = new ParentAchieveVO();
par.setMemberName(member.getMemberName());
par.setPkMember(member.getPkId());
R<CurrencyDTO> currency = currencyServiceApi.getCurrency(pa.getPkCountry());
R<CurrencyDTO> currency = iCurrencyServiceApi.getCurrency(pa.getPkCountry());
//查询本人直推业绩
List<ParentAchieveVO> endSelfParentList = selfParentCounAchieve(pa);
par.setUmbrellaList(endSelfParentList);
@ -1500,7 +1187,6 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
}
/**
* 查询安置数据
*
@ -1517,7 +1203,6 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
return param;
}
/**
* 转化VO
*
@ -1651,7 +1336,7 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
@Override
public RealPerformanceVo queryRealPerformance(Long pkMember, Integer pkCountry, Integer month) {
R<CurrencyDTO> currencyDto = currencyServiceApi.getCurrency(pkCountry);
R<CurrencyDTO> currencyDto = iCurrencyServiceApi.getCurrency(pkCountry);
CurrencyDTO currency = currencyDto.getData();
//当月
RealPerformanceVo realPerformanceVo = null;
@ -1662,7 +1347,7 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
Integer count = baseMapper.selectExistTable(achieveTable);
if (count == 1) {
realPerformanceVo = memberMonthAchieveService.queryCuMemberMonthAchieveInfo(pkMember, achieveTable);
realPerformanceVo = iCuMemberMonthAchieveService.queryCuMemberMonthAchieveInfo(pkMember, achieveTable);
if (realPerformanceVo != null) {
if (pkCountry.equals(CountryConstants.CHINA_COUNTRY)) {
realPerformanceVo.setFirstLeftPurchaseTotal(realPerformanceVo.getFirstLeftPurchaseTotal().multiply(currency.getInExchangeRate()).divide(ten));
@ -1696,23 +1381,19 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
*/
@Override
public AzAchievementPie queryRealPerformancePic(Long pkMember, Integer pkCountry, Integer month) {
R<CurrencyDTO> currencyDto = currencyServiceApi.getCurrency(pkCountry);
R<CurrencyDTO> currencyDto = iCurrencyServiceApi.getCurrency(pkCountry);
CurrencyDTO currency = currencyDto.getData();
//当月
AzAchievementPie achievementPie;
// Integer count = baseMapper.selectExistTable(achieveTable);
//左区人数
Long leftCount = cuMemberService.selectByDeptNumberCount(pkMember, EPlaceDept.LEFT_DEPT.getValue());
Long leftCount = iCuMemberService.selectByDeptNumberCount(pkMember, EPlaceDept.LEFT_DEPT.getValue());
// 右区人数
Long rightCount = cuMemberService.selectByDeptNumberCount(pkMember, EPlaceDept.RIGHT_DEPT.getValue());
// if (count.equals(1)) {
// achievementPie = getQueryRealPerformancePic(pkMember, pkCountry, achieveTable);
// }
Long rightCount = iCuMemberService.selectByDeptNumberCount(pkMember, EPlaceDept.RIGHT_DEPT.getValue());
DateTime dateTime = DateUtil.offsetDay(DateUtils.currentDate(), -1);
String time = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, dateTime);
CuMemberSettlePeriod csPeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(time);
CuMemberSettlePeriod csPeriod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(time);
String settleTableName = TableNameConstants.CU_MEMBER_SETTLE + csPeriod.getPkId();
CuMemberSettleExt memberSettleExt = cuMemberTreeService.queryCuMemberTreeByPkMemberTable(settleTableName, pkMember);
CuMemberSettleExt memberSettleExt = iCuMemberTreeService.queryCuMemberTreeByPkMemberTable(settleTableName, pkMember);
BigDecimal aSumRealPv = BigDecimal.ZERO;
BigDecimal bSumRealPv = BigDecimal.ZERO;
if (memberSettleExt.getASumRealPv() != null) {
@ -1810,7 +1491,7 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
if (CollUtil.isNotEmpty(reList)) {
Integer pkAwards = param.getPkAwards();
if (null != pkAwards) {
BdAwards bdAwards = awardsServiceApi.getAwardsOne(pkAwards).getData();
BdAwards bdAwards = iAwardsServiceApi.getAwardsOne(pkAwards).getData();
//真实奖衔值
awardsValue = bdAwards.getAwardsValue();
}
@ -1977,7 +1658,6 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
}
}
/**
* 计算大盘的总业绩
*
@ -2025,27 +1705,13 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
return null != value ? value : BigDecimal.ZERO;
}
@Override
public void updateCuMemberAchieve() {
Date startDate = DateUtils.parseStringToDate("2023-05-01");
Date endDate = DateUtils.parseStringToDate("2023-09-04");
while (DateUtils.compareDateBefore(startDate, endDate)) {
String settleDate = DateUtils.parseDateToFormat(DateUtils.YYYY_MM_DD, startDate);
CuMemberSettlePeriod cuMemberSettlePeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(settleDate);
String tableName = TableNameConstants.CU_MEMBER_ACHIEVE + DateUtils.getMonth(settleDate);
baseMapper.updateCuMemberAchieve(tableName, cuMemberSettlePeriod.getPkId());
startDate = DateUtils.afterDate(1, ChronoUnit.DAYS, startDate);
}
}
@Override
public PlacementImageDataVO selectPlaceImage(PlacementDataParam param) {
String memberCode = param.getMemberCode();
String startDate = param.getStartDate();
String endDate = param.getEndDate();
if (StringUtils.isNotEmpty(memberCode) && StringUtils.isNotEmpty(startDate) && StringUtils.isNotEmpty(endDate)) {
CuMemberExt cuMember = cuMemberService.getMemberByCode(memberCode);
CuMemberExt cuMember = iCuMemberService.getMemberByCode(memberCode);
if (null == cuMember) {
return new PlacementImageDataVO();
}
@ -2164,7 +1830,7 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
private Object[] getPeriodAndVertex(PlacementDataParam param) {
//获取期数
String localDate = LocalDate.now().minus(1, ChronoUnit.DAYS).format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
int period = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(localDate).getPkId();
int period = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(localDate).getPkId();
param.setPeriod(period);
//获取体系
List<VertexDTO> vertexDTOList = iVertexServiceApi.findAllByPkCountry(param.getPkSettleCountry()).getData();
@ -2203,7 +1869,7 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
//返回结果组装
if (MapUtil.isNotEmpty(futureMap)) {
//查询团队
List<CuMemberTeamExt> teamList = teamServiceApi.queryCuMemberTeam(param.getPkSettleCountry()).getData();
List<CuMemberTeamExt> teamList = iMemberTeamServiceApi.queryCuMemberTeam(param.getPkSettleCountry()).getData();
Map<Long, CuMemberTeamExt> teamMap = teamList.stream().collect(Collectors.toMap(CuMemberTeamExt::getPkId, o -> o));
for (Map.Entry<Long, Future<List<RecommendImageDataVO>>> entry : futureMap.entrySet()) {
@ -2247,16 +1913,6 @@ public class CuMemberAchieveServiceImpl extends ServiceImpl<CuMemberAchieveMappe
return baseMapper.queryMemberMonthAchieve(pkMember, monthList);
}
@Override
public List<Long> queryPkMemberMonthAchieve(String month, Long pkMember) {
return baseMapper.queryPkMemberMonthAchieve(month, pkMember);
}
@Override
public List<CuMemberAchieveExt> queryMemberMonthAchieveDetail(List<Long> memberList, MonthAchieveParam monthAchieveParam) {
return baseMapper.queryMemberMonthAchieveDetail(monthAchieveParam, memberList);
}
@Override
public List<CuMemberAchieveExt> queryPlaceParentMemberMonthAchieve(MonthAchieveParam monthAchieveParam) {
return baseMapper.queryPlaceParentMemberMonthAchieve(monthAchieveParam);

14
bd-business/bd-business-member/src/main/java/com/hzs/member/achieve/service/impl/CuMemberBonusSettle.java
View File

@ -4,23 +4,17 @@ import com.hzs.common.core.constant.MagicNumberConstants;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
/**
* @Description: 奖金计算工具类
* @Author: sui q
* @Time: 2022/11/2 11:25
* @Classname: CuMemberBonusSettle
* @PackageName: com.hzs.member.achieve.service.impl
* 奖金计算工具类
*/
@Component
public class CuMemberBonusSettle {
public List<List<?>> handleCutList(List<?> baseEntityList, Integer... batchNum) {
int batchUpdateNum = MagicNumberConstants.BATCH_UPDATE_NUM;
if(batchNum != null && batchNum.length >0){
if (batchNum != null && batchNum.length > 0) {
batchUpdateNum = batchNum[0];
}
List<List<?>> returnList = new ArrayList<>();
@ -39,8 +33,4 @@ public class CuMemberBonusSettle {
return returnList;
}
public List<List<?>> handleCutList(Set<?> baseEntityList, Integer... batchNum) {
List<?> oriList = Arrays.asList(baseEntityList.toArray());
return handleCutList(oriList, batchNum);
}
}

190
bd-business/bd-business-member/src/main/java/com/hzs/member/achieve/service/impl/CuMemberMonthAchieveServiceImpl.java
View File

@ -1,29 +1,11 @@
package com.hzs.member.achieve.service.impl;
import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hzs.common.core.constant.MagicNumberConstants;
import com.hzs.common.core.constant.TableNameConstants;
import com.hzs.common.core.enums.HonorWallType;
import com.hzs.common.core.utils.DateUtils;
import com.hzs.common.domain.member.achieve.CuMemberMonthAchieve;
import com.hzs.common.domain.member.achieve.CuMemberSettlePeriod;
import com.hzs.common.domain.member.ext.CuMemberMonthAchieveExt;
import com.hzs.common.domain.member.honor.CuHonorWall;
import com.hzs.common.domain.member.honor.CuMemberHonorWall;
import com.hzs.member.achieve.controller.vo.ParentAchieveVO;
import com.hzs.member.achieve.controller.vo.RealPerformanceVo;
import com.hzs.member.achieve.mapper.CuMemberMonthAchieveMapper;
import com.hzs.member.achieve.service.ICuMemberAchieveService;
import com.hzs.member.achieve.service.ICuMemberMonthAchieveService;
import com.hzs.member.achieve.service.ICuMemberSettlePeriodService;
import com.hzs.member.achieve.service.ICuMemberTreeService;
import com.hzs.member.base.service.ICuHonorWallService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
/**
* 会员月数据 服务实现类
@ -31,181 +13,9 @@ import java.util.*;
@Service
public class CuMemberMonthAchieveServiceImpl extends ServiceImpl<CuMemberMonthAchieveMapper, CuMemberMonthAchieve> implements ICuMemberMonthAchieveService {
@Autowired
private ICuMemberSettlePeriodService iCuMemberSettlePeriodService;
@Autowired
private ICuHonorWallService iCuHonorWallService;
@Autowired
private ICuMemberTreeService iCuMemberTreeService;
@Autowired
private ICuMemberAchieveService iCuMemberAchieveService;
@Override
@Transactional(rollbackFor = Exception.class)
public void insertCuMemberAchieveByEveryDay(Date settleDate) {
// 推荐业绩，复购业绩，
insertCuMemberMonthAchieve(settleDate);
// 月表统计数据
insertCuMemberCuMemberMonthYearAchieve(settleDate);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void insertCuMemberMonthAchieve(Date settleDate) {
// 判断日期 1月7日 发放去年奖章 1 4 7 10 计算季度
// 1-6号计算上个月
int month = DateUtils.currentMonth(settleDate);
int day = DateUtils.currentDay(settleDate);
String settleDateStr = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, settleDate);
String table = TableNameConstants.CU_MEMBER_ACHIEVE + DateUtils.getMonth(settleDateStr);
// 获得当前月第一天
String currentMonthDate = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, DateUtils.currentMonthFirstDate(settleDate));
CuMemberSettlePeriod cuMemberSettlePeriod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(currentMonthDate);
if (day <= 6) {
// 计算上月
String beforeFirstMonthDate = DateUtils.beforeMonthFirstDateStr(settleDate);
String beforeTable = TableNameConstants.CU_MEMBER_ACHIEVE + DateUtils.getMonth(beforeFirstMonthDate);
CuMemberSettlePeriod beforePeriod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(beforeFirstMonthDate);
baseMapper.insertCuMemberMonthAchieve(beforeTable, beforePeriod.getPkId(), DateUtils.getMonth(beforeFirstMonthDate));
}
// 计算当前月
String settleMonth = DateUtils.getMonth(currentMonthDate);
baseMapper.insertCuMemberMonthAchieve(table, cuMemberSettlePeriod.getPkId(), settleMonth);
// 每月7号发放徽章,发放上个月的
if (day == 7) {
// 查询徽章
List<CuHonorWall> cuHonorWallList = iCuHonorWallService.queryCuHonorWall();
Map<String, CuHonorWall> honorWallMap = new HashMap<>();
cuHonorWallList.forEach(cuHonorWall -> {
String key = cuHonorWall.getPkCountry().toString() + cuHonorWall.getType() + cuHonorWall.getValue();
honorWallMap.put(key, cuHonorWall);
});
List<CuMemberHonorWall> cuMemberHonorWallList = new ArrayList<>();
// 上月期间，作为结束期间
String beforeFirstMonthDate = DateUtils.beforeMonthFirstDateStr(settleDate);
CuMemberSettlePeriod beforePeriod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(beforeFirstMonthDate);
// 月徽章
grantHonorWall(beforePeriod.getPkId(), cuMemberSettlePeriod.getPkId(), settleMonth,
HonorWallType.RECOMMEND_MONTH.getValue(), HonorWallType.ANTIFADING_MONTH.getValue(), honorWallMap, cuMemberHonorWallList);
// 再发季度徽章
if (month == 1 || month == 4 || month == 7 || month == 10) {
// 3个月期间，作为开始期间
String quarterFirstMonthDate = DateUtils.beforeMonthFirstDateStr(3, settleDate);
CuMemberSettlePeriod quarterPeriod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(quarterFirstMonthDate);
grantHonorWall(quarterPeriod.getPkId(), cuMemberSettlePeriod.getPkId(), settleMonth,
HonorWallType.RECOMMEND_QUARTER.getValue(), HonorWallType.ANTIFADING_QUARTER.getValue(), honorWallMap, cuMemberHonorWallList);
if (month == 1) {
// 再发年度徽章
// 3个月期间，作为开始期间
String yearFirstMonthDate = DateUtils.beforeMonthFirstDateStr(12, settleDate);
CuMemberSettlePeriod yearPeriod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(yearFirstMonthDate);
if (yearPeriod != null) {
grantHonorWall(yearPeriod.getPkId(), cuMemberSettlePeriod.getPkId(), settleMonth,
HonorWallType.RECOMMEND_QUARTER.getValue(), HonorWallType.ANTIFADING_QUARTER.getValue(), honorWallMap, cuMemberHonorWallList);
}
}
}
}
}
@Override
public void insertCuMemberCuMemberMonthYearAchieve(Date settleDate) {
// 1-6号修改上月数据+当月数据 7号及以后只修改当月数据
// 创建业绩每月统计报表-年表
// 月表
int day = DateUtils.currentDay(settleDate);
String monthTableName = TableNameConstants.CU_MEMBER_MONTH + DateUtils.getMonth(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, settleDate));
Integer number = iCuMemberTreeService.queryExistOracleTable(monthTableName);
if (number == null || number <= 0) {
// 创建表
iCuMemberAchieveService.createCuMemberMonthTable(monthTableName);
iCuMemberTreeService.createCuMemberTreeDayOnlyIndex(monthTableName);
iCuMemberTreeService.createCuMemberTreeParentIndex(monthTableName);
iCuMemberTreeService.createCuMemberTreePlaceIndex(monthTableName);
}
if (day >= 1 && day <= 6) {
iCuMemberAchieveService.mergeCuMemberMonth(day, DateUtils.beforeMonthLastDateStr(settleDate));
}
iCuMemberAchieveService.mergeCuMemberMonth(0, DateUtils.parseDateToFormat(DateUtils.YYYY_MM_DD, settleDate));
}
@Override
public List<CuMemberMonthAchieveExt> queryCuMemberMonthAchieveRecommend(ParentAchieveVO parentAchieveVO) {
packageParamPeriod(parentAchieveVO);
return baseMapper.queryCuMemberMonthAchieveRecommend(parentAchieveVO);
}
private void packageParamPeriod(ParentAchieveVO parentAchieveVO) {
Date settleDate = DateUtils.currentDate();
if (Objects.equals(HonorWallType.RECOMMEND_MONTH.getValue(), parentAchieveVO.getWallType()) ||
Objects.equals(HonorWallType.ANTIFADING_MONTH.getValue(), parentAchieveVO.getWallType())) {
//1号取上月的
// 月
Date date = DateUtils.currentMonthFirstDate(settleDate);
if (DateUtils.compareDateEqual(settleDate, date)) {
// 取上月第一天
date = DateUtils.beforeMonthFirstDate(settleDate);
}
String currentMonthDate = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, date);
CuMemberSettlePeriod cuMemberSettlePeriod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(currentMonthDate);
parentAchieveVO.setStartPeriod(cuMemberSettlePeriod.getPkId());
parentAchieveVO.setEndPeriod(cuMemberSettlePeriod.getPkId());
} else {
// 季度
// 上月期间，作为结束期间
String beforeFirstMonthDate = DateUtils.beforeMonthFirstDateStr(settleDate);
CuMemberSettlePeriod beforePeriod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(beforeFirstMonthDate);
parentAchieveVO.setEndPeriod(beforePeriod.getPkId());
if (Objects.equals(HonorWallType.RECOMMEND_QUARTER.getValue(), parentAchieveVO.getWallType()) ||
Objects.equals(HonorWallType.ANTIFADING_QUARTER.getValue(), parentAchieveVO.getWallType())) {
// 3个月期间，作为开始期间
String quarterFirstMonthDate = DateUtils.beforeMonthFirstDateStr(3, settleDate);
CuMemberSettlePeriod quarterPeriod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(quarterFirstMonthDate);
parentAchieveVO.setStartPeriod(quarterPeriod.getPkId());
} else {
String yearFirstMonthDate = DateUtils.beforeMonthFirstDateStr(12, settleDate);
CuMemberSettlePeriod yearPeriod = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(yearFirstMonthDate);
parentAchieveVO.setStartPeriod(yearPeriod.getPkId());
}
}
}
@Override
public RealPerformanceVo queryCuMemberMonthAchieveInfo(Long pkMember, String achieveTable) {
return baseMapper.queryCuMemberMonthAchieveInfo(pkMember, achieveTable);
}
private void grantHonorWall(Integer startPeriod, Integer endPeriod, String settleMonth, Integer recommend, Integer repurchase,
Map<String, CuHonorWall> honorWallMap, List<CuMemberHonorWall> cuMemberHonorWallList) {
// 先发月徽章 查询值，查询前3名
List<CuMemberMonthAchieveExt> cuMemberMonthAchieveList = baseMapper.queryCuMemberMonthAchieveByDate(startPeriod, endPeriod, recommend, repurchase);
if (CollectionUtil.isNotEmpty(cuMemberMonthAchieveList)) {
Map<Integer, List<CuMemberMonthAchieveExt>> monthAchieveMap = new HashMap<>();
cuMemberMonthAchieveList.forEach(cuMemberMonthAchieve -> {
if (monthAchieveMap.containsKey(cuMemberMonthAchieve.getWallType())) {
monthAchieveMap.get(cuMemberMonthAchieve.getWallType()).add(cuMemberMonthAchieve);
} else {
List<CuMemberMonthAchieveExt> cuMemberMonthAchieveExtList = new ArrayList<>();
cuMemberMonthAchieveExtList.add(cuMemberMonthAchieve);
monthAchieveMap.put(cuMemberMonthAchieve.getWallType(), cuMemberMonthAchieveExtList);
}
});
monthAchieveMap.forEach((wallType, cuMemberMonthAchieveExtList) -> {
for (int i = 1; i <= cuMemberMonthAchieveExtList.size(); i++) {
CuMemberMonthAchieveExt cuMemberMonthAchieveExt = cuMemberMonthAchieveExtList.get(i - 1);
String key = cuMemberMonthAchieveExt.getPkCountry().toString() + cuMemberMonthAchieveExt.getWallType() + i;
if (honorWallMap.containsKey(key)) {
CuMemberHonorWall cuMemberHonorWall = CuMemberHonorWall.builder()
.pkMember(cuMemberMonthAchieveExt.getPkMember())
.pkHonorWall(honorWallMap.get(key).getPkId())
.settleMonth(settleMonth)
.build();
cuMemberHonorWall.setPkCountry(cuMemberMonthAchieveExt.getPkCountry());
cuMemberHonorWall.setPkCreator(MagicNumberConstants.PK_ADMIN);
cuMemberHonorWallList.add(cuMemberHonorWall);
}
}
});
}
}
}

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

@ -26,25 +26,6 @@ public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuM
return baseMapper.queryExistOracleTable(tableName);
}
@Override
public void createCuMemberTableUniqueIndex(String tableName) {
baseMapper.createCuMemberTableUniqueIndex(tableName);
}
@Override
public void createCuMemberTableSequence(String tableName, String tableNameSeq) {
baseMapper.createCuMemberTableSequence(tableName, tableNameSeq);
}
@Override
public List<CuMemberSettleExt> queryExemptCuMemberSettle(String tableName) {
List<CuMemberSettleExt> cuMemberSettleExtList = baseMapper.queryExemptCuMemberSettle(tableName);
if (cuMemberSettleExtList == null) {
return Collections.emptyList();
}
return cuMemberSettleExtList;
}
@Override
public Boolean queryCuMemberSettlePlaceUnderUmbrella(String settleTableName, Integer awardsValue, Integer placeDept, Long pkMember) {
return baseMapper.queryCuMemberSettlePlaceUnderUmbrella(settleTableName, awardsValue, placeDept, pkMember) > 0;
@ -108,24 +89,4 @@ public class CuMemberTreeServiceImpl extends ServiceImpl<CuMemberTreeMapper, CuM
return memberRetailExt;
}
@Override
public void truncateCuMemberTreeTable(String tableName) {
baseMapper.truncateCuMemberTreeTable(tableName);
}
@Override
public void createCuMemberTreeDayOnlyIndex(String tableName) {
baseMapper.createCuMemberTreeDayOnlyIndex(tableName);
}
@Override
public void createCuMemberTreeParentIndex(String tableName) {
baseMapper.createCuMemberTreeParentIndex(tableName);
}
@Override
public void createCuMemberTreePlaceIndex(String tableName) {
baseMapper.createCuMemberTreePlaceIndex(tableName);
}
}

15
bd-business/bd-business-member/src/main/java/com/hzs/member/base/mapper/CuHonorWallMapper.java
View File

@ -1,15 +0,0 @@
package com.hzs.member.base.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hzs.common.domain.member.honor.CuHonorWall;
/**
* 荣誉墙 Mapper 接口
*
* @author hzs
* @since 2023-04-26
*/
public interface CuHonorWallMapper extends BaseMapper<CuHonorWall> {
}

24
bd-business/bd-business-member/src/main/java/com/hzs/member/base/mapper/CuMemberMapper.java
View File

@ -40,11 +40,6 @@ public interface CuMemberMapper extends BaseMapper<CuMember> {
*/
List<CuMemberExt> queryMemberInfoByCondition(CuMember cuMember);
/*
* 根据条件查询会员信息，查询单表
**/
List<CuMemberExt> queryMemberByCondition(CuMember cuMember);
/**
* 查找安置人伞上
*
@ -253,11 +248,6 @@ public interface CuMemberMapper extends BaseMapper<CuMember> {
*/
List<CuMemberExt> queryMemberSelect(@Param("param") MemberSelectParam param, @Param("pkCountry") Integer pkCountry);
/*
* 查询历史网体的最末安置人，左右区一起查出来
**/
List<CuMemberExt> queryCuMemberLastPlaceParent(@Param("pkMember") Long pkMember);
/**
* 查询会员真实信息
*
@ -307,20 +297,6 @@ public interface CuMemberMapper extends BaseMapper<CuMember> {
@Param("checkEmpty") Boolean checkEmpty,
@Param("excludeMemberEmpty") Long excludeMemberEmpty);
/**
* 校验会员编号是否存在
*
* @param phoneList 会员联系方式列表
* @param checkEmpty 是否需要校验批量空单数据
* @param excludeMemberEmpty 排除的批次
* @param systemType 系统类型
* @return
*/
List<MemberCountDTO> checkMemberPhoneExist(@Param("phoneList") Collection<String> phoneList,
@Param("checkEmpty") Boolean checkEmpty,
@Param("excludeMemberEmpty") Long excludeMemberEmpty,
@Param("systemType") Integer systemType);
/**
* 查询全部用户
*

25
bd-business/bd-business-member/src/main/java/com/hzs/member/base/service/ICuHonorWallService.java
View File

@ -1,25 +0,0 @@
package com.hzs.member.base.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hzs.common.domain.member.ext.CuHonorWallExt;
import com.hzs.common.domain.member.honor.CuHonorWall;
import java.util.List;
/**
* 荣誉墙 服务类
*
* @author hzs
* @since 2023-04-26
*/
public interface ICuHonorWallService extends IService<CuHonorWall> {
/*
* @description: 查询所有的徽章
* @author: sui q
* @date: 2023/6/7 14:30
* @param: null null
**/
List<CuHonorWall> queryCuHonorWall();
}

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

@ -66,11 +66,6 @@ public interface ICuMemberService extends IService<CuMember> {
*/
List<CuMemberExt> getMemberInfoByCondition(CuMember cuMember);
/*
* 根据条件查询会员信息，查询单表
**/
List<CuMemberExt> queryMemberByCondition(CuMember cuMember);
/**
* 获取会员缓存
*
@ -471,11 +466,6 @@ public interface ICuMemberService extends IService<CuMember> {
*/
boolean updateMemberNameAndPhone(Long pkMember, String memberName, String phone, Long pkModified);
/*
* 查询历史网体的最末安置人，左右区一起查出来
**/
List<CuMemberExt> queryCuMemberLastPlaceParent(Long pkMember);
/**
* 查询会员真实信息
*
@ -523,16 +513,6 @@ public interface ICuMemberService extends IService<CuMember> {
*/
Map<String, Integer> checkMemberCodeExist(Collection<String> codeList, Boolean checkEmpty, Long excludeMemberEmpty);
/**
* 校验会员联系方式是否存在
*
* @param phoneList 会员联系方式列表
* @param checkEmpty 是否需要校验批量空单数据
* @param excludeMemberEmpty 排除的批次
* @return
*/
Map<String, Integer> checkMemberPhoneExist(Collection<String> phoneList, Boolean checkEmpty, Long excludeMemberEmpty, Integer systemType);
/**
* 查询全部用户
*
@ -853,15 +833,6 @@ public interface ICuMemberService extends IService<CuMember> {
*/
String checkRegisterRelation(String phone, Long pkParent);
/**
* 根据推荐人，校验手机号必须唯一
*
* @param phone 联系方式
* @param parentMember 推荐人
* @return
*/
String checkRegisterRelation(String phone, CuMember parentMember);
/**
* 添加等级升级记录
**/

29
bd-business/bd-business-member/src/main/java/com/hzs/member/base/service/impl/CuHonorWallServiceImpl.java
View File

@ -1,29 +0,0 @@
package com.hzs.member.base.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hzs.common.domain.member.ext.CuHonorWallExt;
import com.hzs.common.domain.member.honor.CuHonorWall;
import com.hzs.member.base.mapper.CuHonorWallMapper;
import com.hzs.member.base.service.ICuHonorWallService;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 荣誉墙 服务实现类
*
* @author hzs
* @since 2023-04-26
*/
@Service
public class CuHonorWallServiceImpl extends ServiceImpl<CuHonorWallMapper, CuHonorWall> implements ICuHonorWallService {
@Override
public List<CuHonorWall> queryCuHonorWall() {
QueryWrapper<CuHonorWall> queryWrapper = new QueryWrapper<>();
queryWrapper.select("pk_id,PK_COUNTRY,TYPE,VALUE,IMG");
return baseMapper.selectList(queryWrapper);
}
}

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

@ -170,11 +170,6 @@ public class CuMemberServiceImpl extends ServiceImpl<CuMemberMapper, CuMember> i
return baseMapper.queryMemberInfoByCondition(cuMember);
}
@Override
public List<CuMemberExt> queryMemberByCondition(CuMember cuMember) {
return baseMapper.queryMemberByCondition(cuMember);
}
@Override
public CuMember getMember(String memberCode) {
return baseMapper.queryLoginMember(memberCode, null);
@ -2465,11 +2460,6 @@ public class CuMemberServiceImpl extends ServiceImpl<CuMemberMapper, CuMember> i
return update(updateWrapper);
}
@Override
public List<CuMemberExt> queryCuMemberLastPlaceParent(Long pkMember) {
return baseMapper.queryCuMemberLastPlaceParent(pkMember);
}
@Override
public List<MemberRealInfoVO> selectByMemberRealInfo(MemberRealInfoParam memberRealInfoParam) {
return baseMapper.selectByMemberRealInfo(memberRealInfoParam);
@ -2503,19 +2493,6 @@ public class CuMemberServiceImpl extends ServiceImpl<CuMemberMapper, CuMember> i
return resultMap;
}
@Override
public Map<String, Integer> checkMemberPhoneExist(Collection<String> phoneList, Boolean checkEmpty, Long excludeMemberEmpty, Integer systemType) {
Map<String, Integer> resultMap = new HashMap<>();
List<MemberCountDTO> list = baseMapper.checkMemberPhoneExist(phoneList, checkEmpty, excludeMemberEmpty, systemType);
if (CollectionUtil.isNotEmpty(list)) {
for (MemberCountDTO memberCountDTO : list) {
resultMap.put(memberCountDTO.getPhone(), memberCountDTO.getMemberCount());
}
}
return resultMap;
}
@Override
public List<CuMemberExt> findAll() {
return baseMapper.findAll();
@ -3111,14 +3088,6 @@ public class CuMemberServiceImpl extends ServiceImpl<CuMemberMapper, CuMember> i
}
}
@Override
public String checkRegisterRelation(String phone, CuMember parentMember) {
if (null != parentMember) {
return this.checkRegisterRelation(phone, parentMember.getSystemType());
}
return "推荐人不存在";
}
/**
* 校验系统类型手机号是否可以注册
*

69
bd-business/bd-business-member/src/main/java/com/hzs/member/detail/mapper/CuMemberAssessDetailMapper.java
View File

@ -1,69 +0,0 @@
package com.hzs.member.detail.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hzs.common.domain.member.detail.CuMemberAssessDetail;
import com.hzs.common.domain.member.ext.CuMemberSettleExt;
import org.apache.ibatis.annotations.Param;
import java.util.Date;
import java.util.List;
/**
* <p>
* 考核业绩变化明细表 Mapper 接口
* </p>
*
* @author hzs
* @since 2022-10-28
*/
public interface CuMemberAssessDetailMapper extends BaseMapper<CuMemberAssessDetail> {
/*
* @description: 根据期间删除会员考核记录
* @author: sui q
* @date: 2023/5/25 10:52
* @param: null null
**/
void deleteCuMemberAssessDetailByPeriod(@Param("tableName") String tableName, @Param("period") Integer period);
/*
* @description: 每月考试将订单插入会员考核明细
* @author: sui q
* @date: 2023/5/25 11:36
* @param: null null
**/
void insertCuMemberAssesDetailByOrder(@Param("tableName") String tableName, @Param("period") Integer period,
@Param("startDate") Date startDate, @Param("endDate") Date endDate);
/**
* 插入考核记录
* @param tableName 表名
* @param period 期间
* @param cuMemberList 需要重新考核的会员
* @param assessType 类型
* @return: void
* @Author: sui q
* @Date: 2022/11/9 15:56
*/
void insertCuMemberAssessDetailByPeriod(@Param("tableName") String tableName, @Param("period") Integer period,
@Param("cuMemberList") List<?> cuMemberList, @Param("assessType") Integer assessType);
/**
* 新增或修改会员考核明细表，根据期间，重算就是修改
* @param tableName 来源表
* @param period 期间
* @return: Integer
* @Author: sui q
* @Date: 2022/11/8 11:21
*/
Integer updateCuMemberAssessDetailByPeriod(@Param("tableName") String tableName, @Param("period") Integer period);
/**
* 批量删除会员考核明细
* @param revokeDetailList 退单的明细数据
* @return: Integer
* @Author: sui q
* @Date: 2022/11/9 15:37
*/
Integer updateCuMemberAssessDetailByRevoke(@Param("revokeDetailList") List<?> revokeDetailList);
}

64
bd-business/bd-business-member/src/main/java/com/hzs/member/detail/service/ICuMemberAssessDetailService.java
View File

@ -1,64 +0,0 @@
package com.hzs.member.detail.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hzs.common.domain.member.detail.CuMemberAssessDetail;
import com.hzs.common.domain.member.ext.CuMemberSettleExt;
import org.apache.ibatis.annotations.Param;
import java.util.Date;
import java.util.List;
/**
* <p>
* 考核业绩变化明细表 服务类
* </p>
*
* @author hzs
* @since 2022-10-28
*/
public interface ICuMemberAssessDetailService extends IService<CuMemberAssessDetail> {
/*
* @description: 根据期间删除会员考核记录
* @author: sui q
* @date: 2023/5/25 10:52
* @param: null null
**/
void deleteCuMemberAssessDetailByPeriod(String tableName, Integer period);
/*
* @description: 每月考试将订单插入会员考核明细
* @author: sui q
* @date: 2023/5/25 11:36
* @param: null null
**/
void insertCuMemberAssesDetailByOrder(String tableName, Integer period, Date startDate, Date endDate);
/**
* 插入考核记录
* @param tableName 表名
* @param period 期间
* @param newCuMemberSettleExtList 会员列表
* @return: void
* @Author: sui q
* @Date: 2022/11/9 15:56
*/
void insertCuMemberAssessDetailByPeriod(String tableName, Integer period, List<CuMemberSettleExt> newCuMemberSettleExtList);
/**
* 新增或修改会员考核明细表，根据期间，重算就是修改
* @param tableName 来源表
* @param period 期间
* @Author: sui q
* @Date: 2022/11/8 11:21
*/
void updateCuMemberAssessDetailByPeriod(String tableName, Integer period);
/**
* 删除可能会发生变动的会员的考核明细
* @param revokeDetailList 变动的记录
* @Author: sui q
* @Date: 2022/11/9 15:31
*/
void deleteCuMemberAssessDetailByList(List<CuMemberAssessDetail> revokeDetailList);
}

47
bd-business/bd-business-member/src/main/java/com/hzs/member/detail/service/ICuMemberAssessService.java
View File

@ -2,56 +2,15 @@ package com.hzs.member.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.member.detail.vo.CuMemberAssessVO;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
* 会员信息-会员考核记录 服务类
*/
public interface ICuMemberAssessService extends IService<CuMemberAssess> {
/**
* 每月初，初始化考核数据，根据月底网体数据，先进行奖金计算在进行考核，考核在计算奖金之后
*
* @param settleDate 结算日期
* @param period 结算期间
*/
void initCuMemberAssessData(String settleDate, int period);
/**
* 复购考核每月第一考核调用此方法
*/
void calculationCuMemberAssess(Date currentDate);
/**
* 重算考核 奖金用、每天的重算复购考核用（复购考核、分红考核）,只重算免考的
*
* @param currentDate 哪一天进行重新复购考核，拿昨天的值跟现在的值对比
*/
void retryCalculationAssess(Date currentDate, Boolean flag);
/**
* 根据会员主键查询考核结果
*
* @param assessTableName 考核表
* @param period 期间
* @param assessType 考核类型
* @param cuMemberSettleExtList 会员列表
*/
Map<Long, CuMemberAssess> queryCuMemberAssessByMember(String assessTableName, Integer period, Integer assessType, List<CuMemberSettleExt> cuMemberSettleExtList);
/**
* 查询会员分红考核结果，只查询出免考或者考核通过的，用于分红
*
* @param tableName 表名
* @param period 期间
*/
List<CuMemberAssess> queryCuMemberShareAssess(String tableName, Integer period);
/**
* 会员-考核明细列表
**/
@ -72,10 +31,4 @@ public interface ICuMemberAssessService extends IService<CuMemberAssess> {
**/
CuMemberAssessVO getOrderAssessList(CuMemberAssessVO cuMemberAssessVO);
List<CuMemberAssessVO> getOrderByAssessList(CuMemberAssessVO cuMemberAssessVO);
/*
* 查询满足分红考核的人数，达标人数
**/
List<CuMemberAssess> queryCuMemberAssTotal(String startDate, Integer pkCountry);
}

79
bd-business/bd-business-member/src/main/java/com/hzs/member/detail/service/impl/CuMemberAssessDetailServiceImpl.java
View File

@ -1,79 +0,0 @@
package com.hzs.member.detail.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hzs.common.core.constant.MagicNumberConstants;
import com.hzs.common.core.enums.EAssessmentType;
import com.hzs.common.domain.member.detail.CuMemberAssessDetail;
import com.hzs.common.domain.member.ext.CuMemberSettleExt;
import com.hzs.member.achieve.service.impl.CuMemberBonusSettle;
import com.hzs.member.detail.mapper.CuMemberAssessDetailMapper;
import com.hzs.member.detail.service.ICuMemberAssessDetailService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
* <p>
* 考核业绩变化明细表 服务实现类
* </p>
*
* @author hzs
* @since 2022-10-28
*/
@Service
public class CuMemberAssessDetailServiceImpl extends ServiceImpl<CuMemberAssessDetailMapper, CuMemberAssessDetail> implements ICuMemberAssessDetailService {
@Autowired
private CuMemberBonusSettle cuMemberBonusSettle;
@Override
public void deleteCuMemberAssessDetailByPeriod(String tableName, Integer period) {
baseMapper.deleteCuMemberAssessDetailByPeriod(tableName, period);
}
@Override
public void insertCuMemberAssesDetailByOrder(String tableName, Integer period, Date startDate, Date endDate) {
baseMapper.insertCuMemberAssesDetailByOrder(tableName, period, startDate, endDate);
}
@Override
public void insertCuMemberAssessDetailByPeriod(String tableName, Integer period, List<CuMemberSettleExt> newCuMemberSettleExtList) {
List<CuMemberSettleExt> purchaseMemberList = new ArrayList<>();
List<CuMemberSettleExt> shareMemberList = new ArrayList<>();
newCuMemberSettleExtList.forEach(cuMemberSettleExt -> {
if (EAssessmentType.REPURCHASE_ASSESS.getValue() == cuMemberSettleExt.getAssessType()) {
purchaseMemberList.add(cuMemberSettleExt);
} else {
shareMemberList.add(cuMemberSettleExt);
}
});
if (purchaseMemberList.size() > 0) {
List<List<?>> purchaseHandleCutList = cuMemberBonusSettle.handleCutList(purchaseMemberList);
purchaseHandleCutList.forEach(cuMemberBonusSettleList ->
baseMapper.insertCuMemberAssessDetailByPeriod(tableName, period, cuMemberBonusSettleList, EAssessmentType.REPURCHASE_ASSESS.getValue()) );
}
if (shareMemberList.size() > 0) {
List<List<?>> shareHandleCutList = cuMemberBonusSettle.handleCutList(shareMemberList);
shareHandleCutList.forEach(cuMemberBonusSettleList ->
baseMapper.insertCuMemberAssessDetailByPeriod(tableName, period, cuMemberBonusSettleList, EAssessmentType.SHARE_ASSESS.getValue()));
}
}
@Override
public void updateCuMemberAssessDetailByPeriod(String tableName, Integer period) {
baseMapper.updateCuMemberAssessDetailByPeriod(tableName, period);
}
@Override
public void deleteCuMemberAssessDetailByList(List<CuMemberAssessDetail> revokeDetailList) {
List<List<?>> handleCutList = cuMemberBonusSettle.handleCutList(revokeDetailList,
MagicNumberConstants.DELETE_DATA_BATCH_UPDATE_NUM);
handleCutList.forEach(list -> {
baseMapper.updateCuMemberAssessDetailByRevoke(list);
});
}
}

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

@ -2,32 +2,16 @@ package com.hzs.member.detail.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
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.member.achieve.service.ICuMemberSettlePeriodService;
import com.hzs.member.achieve.service.ICuMemberTreeService;
import com.hzs.member.achieve.service.impl.CuMemberBonusSettle;
import com.hzs.member.detail.mapper.CuMemberAssessMapper;
import com.hzs.member.detail.service.ICuMemberAssessDetailService;
import com.hzs.member.detail.service.ICuMemberAssessService;
import com.hzs.member.detail.vo.CuMemberAssessVO;
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.*;
/**
@ -36,105 +20,8 @@ import java.util.*;
@Service
public class CuMemberAssessServiceImpl extends ServiceImpl<CuMemberAssessMapper, CuMemberAssess> implements ICuMemberAssessService {
private ICuMemberTreeService cuMemberTreeService;
private ICuMemberSettlePeriodService cuMemberSettlePeriodService;
private ICuMemberAssessDetailService cuMemberAssessDetailService;
@Autowired
private CuMemberBonusSettle cuMemberBonusSettle;
@DubboReference
IAwardsServiceApi awardsServiceApi;
@Autowired
public void setCuMemberAssessDetailService(ICuMemberAssessDetailService cuMemberAssessDetailService) {
this.cuMemberAssessDetailService = cuMemberAssessDetailService;
}
@Autowired
public void setCuMemberSettlePeriodService(ICuMemberSettlePeriodService cuMemberSettlePeriodService) {
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);
}
}
/**
* 复购考核每月第一次考核调用此方法
*/
@Override
@Transactional(rollbackFor = Exception.class)
public void calculationCuMemberAssess(Date currentDate) {
// 查询当前时间的第一天跟最后一天
// 需要验证考核国家是否有复购考核 分红考核
// 考核日期不能跨越考核，只能当月考核，当月考核上月
if (DateUtils.currentDay(currentDate) == 1) {
String currentMonthFirstDate = DateUtils.currentMonthFirstDateStr(currentDate);
Integer currentPeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(currentMonthFirstDate).getPkId();
String currentTableName = TableNameConstants.CU_MEMBER_ASSESS + DateUtils.getYear(currentMonthFirstDate);
// 清空数据 根据期数清空cu_member_assess cu_member_assess_detail表数据
initCurrentAssess(currentDate, currentTableName, currentPeriod);
// 初始化复购考核的上月结余
initCurrentAssessByBeforeMonth(currentDate, currentTableName, currentPeriod, EAssessmentType.REPURCHASE_ASSESS.getValue());
// 初始化分红考核的上月结余
initCurrentAssessByBeforeMonth(currentDate, currentTableName, currentPeriod, EAssessmentType.SHARE_ASSESS.getValue());
// 更新当月结余 结余会同时更新复购跟分红，只需要更新一次
// 1 有免考状态的 本月使用是 0，考核状态是免考通过，免考将所有的值更改一下期末 期末= 期初+本月
// 注意 不修改考核状态为通过的值，可能存在之前考核通过，又手动免考的人
baseMapper.updateAssessPeriodExemptBalanceByUsed(currentTableName, currentPeriod);
// 2 需要扣除通过的，需要记录流水
// 记录流水，新增或修改
cuMemberAssessDetailService.updateCuMemberAssessDetailByPeriod(currentTableName, currentPeriod);
baseMapper.updateAssessPeriodCheckBalanceByUsed(currentTableName, currentPeriod);
}
}
@Override
public Map<Long, CuMemberAssess> queryCuMemberAssessByMember(String assessTableName, Integer period, Integer assessType, List<CuMemberSettleExt> cuMemberSettleExtList) {
List<CuMemberAssess> cuMemberAssessList = new ArrayList<>();
List<List<?>> listList = cuMemberBonusSettle.handleCutList(cuMemberSettleExtList);
listList.forEach(list ->
cuMemberAssessList.addAll(baseMapper.queryCuMemberAssessByMember(assessTableName, period, assessType, list)));
Map<Long, CuMemberAssess> cuMemberAssessMap = new HashMap<>(ComputeUtil.mapInitCapacity(cuMemberAssessList.size()));
cuMemberAssessList.forEach(cuMemberAssess -> cuMemberAssessMap.put(cuMemberAssess.getPkMember(), cuMemberAssess));
return cuMemberAssessMap;
}
@Override
public List<CuMemberAssess> queryCuMemberShareAssess(String tableName, Integer period) {
return baseMapper.queryCuMemberShareAssess(tableName, period);
}
private ICuMemberSettlePeriodService iCuMemberSettlePeriodService;
@Override
public List<CuMemberAssessVO> selectAssessList(CuMemberAssessVO cuMemberAssessVO, List<Integer> orderTypeList) {
@ -185,17 +72,17 @@ public class CuMemberAssessServiceImpl extends ServiceImpl<CuMemberAssessMapper,
if (DateUtils.compareDateBefore(date, cuMemberAssessVO.getStartDate()) || DateUtils.compareDateEqual(date, cuMemberAssessVO.getStartDate())) {
//获取当前月第一天
Date date1 = DateUtils.currentMonthFirstDate(date);
period = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(
period = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(
DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, date1)).getPkId();
} else {
Date date1 = DateUtils.currentMonthFirstDate(cuMemberAssessVO.getStartDate());
period = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(
period = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(
DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, date1)).getPkId();
}
} else {
year = DateUtils.currentYear(date);
Date date1 = DateUtils.currentMonthFirstDate(date);
period = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(
period = iCuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(
DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, date1)).getPkId();
}
String tableName = TableNameConstants.CU_MEMBER_ASSESS + year;
@ -206,264 +93,9 @@ public class CuMemberAssessServiceImpl extends ServiceImpl<CuMemberAssessMapper,
return null;
}
@Override
@Transactional(rollbackFor = Exception.class)
public void retryCalculationAssess(Date currentDate, Boolean flag) {
String beforeDateStr = DateUtils.beforeDateStr(1, ChronoUnit.DAYS, DateUtils.YYYY_MM_DD, currentDate);
Integer beforePeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(beforeDateStr).getPkId();
Integer currentPeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, currentDate)).getPkId();
String beforeTableName = TableNameConstants.CU_MEMBER_SETTLE + beforePeriod;
// a)更新结算表会员前2部分会员免考状态 满足首次注册的会员 满足满足首次升级的会员
String tableName = TableNameConstants.CU_MEMBER_ASSESS + DateUtils.currentYear(currentDate);
String currentMonthFirstDateStr = DateUtils.currentMonthFirstDateStr(currentDate);
Integer monthFirstPeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(currentMonthFirstDateStr).getPkId();
// 结算日期月份的第一天
Date startDate = DateUtils.beforeMonthFirstDate(currentDate);
// 结算日期后一天
Date endDate = DateUtils.afterDate(1, ChronoUnit.DAYS, currentDate);
String settleTableName = TableNameConstants.CU_MEMBER_SETTLE + currentPeriod;
// 首次晋升、首次升级都是当月加下月考核，查询出上月1号到考核日期的值，
// 等级看会员表支付时间，奖衔看奖衔变更表是否免考（分组取）,手动免考查看 最新的结算表手动考核
// d)前一天不免考，后一天免考，需要做重新考核，直接变考核通过，原来考核通过的不回退考核金额，且考核状态为考核通过，不是免考通过
// todo 所有的海粉会员设置复购考核失败，存在任意订单的海粉会员复购考核成功
// 复购免考通过
baseMapper.updateAssessCuMemberToRepExempt(tableName, settleTableName, monthFirstPeriod, startDate, endDate);
// 奖金重算时更新结算表,flag=true代表奖金重算时，重算考核需要更新网体 flag=false 代表重算考核
if (flag) {
baseMapper.updateCuMemberSettleToRepExempt(settleTableName, startDate, endDate);
}
// 分红免考通过
baseMapper.updateAssessCuMemberToShareExempt(tableName, settleTableName, monthFirstPeriod);
// 查询出考核表免考的数据
List<CuMemberAssess> oldCuMemberAssessList = baseMapper.queryExemptAssessCuMember(tableName, monthFirstPeriod);
// b)查询前一天的会员免考记录，查询结算日会员免考记录
List<CuMemberSettleExt> oldCuMemberSettleExtList = cuMemberTreeService.queryExemptCuMemberSettle(beforeTableName);
// c)比较会员2天免考发生的状态，只需要计算变化的值，去掉没有发生变化的值
List<CuMemberSettleExt> newCuMemberSettleExtList = new ArrayList<>();
if (oldCuMemberAssessList.size() > 0 && oldCuMemberSettleExtList != null && oldCuMemberSettleExtList.size() > 0) {
Map<String, CuMemberAssess> cuMemberAssessMap = new HashMap<>(ComputeUtil.mapInitCapacity(oldCuMemberAssessList.size()));
oldCuMemberAssessList.forEach(cuMemberAssess ->
cuMemberAssessMap.put(cuMemberAssess.getPkMember().toString() + cuMemberAssess.getAssessType().toString(), cuMemberAssess));
oldCuMemberSettleExtList.forEach(cuMemberSettleExt -> {
String key = cuMemberSettleExt.getPkMember().toString() + cuMemberSettleExt.getAssessType().toString();
if (!cuMemberAssessMap.containsKey(key)) {
newCuMemberSettleExtList.add(cuMemberSettleExt);
}
});
}
// e)查询有没有撤单，更新撤单的数据
List<CuMemberAssessExt> cuMemberAssessExtList = handleCuMemberAssessByRevokeOrder(currentDate, newCuMemberSettleExtList, tableName, monthFirstPeriod, settleTableName);
if (cuMemberAssessExtList.size() > 0) {
// 将变更的插入临时表
baseMapper.insertTmpCuMemberAssess(cuMemberAssessExtList);
// 根据临时表里面的值进行更新会员表
baseMapper.updateAssessPeriodByRevokeOrder(tableName);
}
// f)前一天免考后一天不免考，需要做重新考核，看上月是否可以考核通过
if (newCuMemberSettleExtList.size() > 0) {
// 处理考核数据
// 记录流水，新增或修改
cuMemberAssessDetailService.insertCuMemberAssessDetailByPeriod(tableName, monthFirstPeriod, newCuMemberSettleExtList);
List<List<?>> cutCuMemberSettleExtList = cuMemberBonusSettle.handleCutList(newCuMemberSettleExtList);
cutCuMemberSettleExtList.forEach(assessExtList ->
baseMapper.updateAssessPeriodCheckBalanceByTmp(tableName, monthFirstPeriod, assessExtList));
}
// 网体数据修改，修改复购免考类型 0=正常 1=手动免考 2=注册免考 3=晋升免考，修改是否复购免考（0=是,1=否）
}
/**
* 根据撤销订单，进行重算考核数据
*
* @param currentDate 考核日期
* @param cuMemberSettleExtList 前一天的会员免考记录
* @param tableName 会员
* @param currentPeriod 考核期间
* @param settleTableName 考核表
*/
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);
CuMemberSettlePeriod cuMemberSettlePeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(beforeLastDate);
int period = cuMemberSettlePeriod.getPkId();
String sourceTable = TableNameConstants.CU_MEMBER_SETTLE + period;
// 清空子表、主表数据
cuMemberAssessDetailService.deleteCuMemberAssessDetailByPeriod(currentTableName, currentPeriod);
// baseMapper.deleteCuMemberAssessByPeriod(currentTableName, currentPeriod);
// 初始化复购考核
String month = DateUtils.getMonth(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, currentDate));
// 结算日期后一天
baseMapper.insertRepCuMemberAssess(currentTableName, sourceTable, currentPeriod, month);
// 初始化分红考核
baseMapper.insertShareCuMemberAssess(currentTableName, sourceTable, currentPeriod, month);
// 初始化订单数据，将当月新增加入数据库
// 上月第一天，上月最后一天
Date beforeFirstDate = DateUtils.beforeMonthFirstDate(currentDate);
Date currentFirstDate = DateUtils.currentMonthFirstDate(currentDate);
cuMemberAssessDetailService.insertCuMemberAssesDetailByOrder(currentTableName, currentPeriod, beforeFirstDate, currentFirstDate);
}
/**
* 初始化期初数据，将上月结余作为本月期初，更新当月新增
*
* @param currentDate 结算日期
* @param currentTableName 当前月结算表
* @param currentPeriod 当前结算期间
* @param assessmentType 考核类型 0=复购考核 1=分红考核
*/
private void initCurrentAssessByBeforeMonth(Date currentDate, String currentTableName, Integer currentPeriod, Integer assessmentType) {
List<Integer> orderTypeList = new ArrayList<>();
if (EAssessmentType.REPURCHASE_ASSESS.getValue() == assessmentType) {
orderTypeList.add(EOrderType.REPURCHASE_ORDER.getValue());
orderTypeList.add(EOrderType.MALL_ORDER.getValue());
orderTypeList.add(EOrderType.COOPERATE_ORDER.getValue());
} else {
orderTypeList.add(EOrderType.WELFARE_ORDER.getValue());
}
// 更新考核值，期初是上月考核表的当月剩余业绩
// 获取结算日月初第一天，获取期间
// 获取结算日上月最后一天，获取期间
Date beforeMonthFirstDate = DateUtils.beforeMonthFirstDate(currentDate);
String beforeMonthFirstDateStr = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, beforeMonthFirstDate);
Integer beforePeriod = cuMemberSettlePeriodService.getCuMemberSettlePeriodByDate(beforeMonthFirstDateStr).getPkId();
String beforeTableName = TableNameConstants.CU_MEMBER_ASSESS + DateUtils.getYear(beforeMonthFirstDateStr);
Date currentMonthFirstDate = DateUtils.currentMonthFirstDate(currentDate);
// 初始化复购考核的上月结余 // 更新当月结余
baseMapper.updateAssessPeriodBeginByBeforeMonth(beforeTableName, currentTableName, beforePeriod, currentPeriod, assessmentType);
// 更新当月新增
baseMapper.updateAssessPeriodAddBySaOrder(currentTableName, currentPeriod, assessmentType,
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();
String tableTable = TableNameConstants.CU_MEMBER_ASSESS + DateUtils.getYear(startDate);
return baseMapper.queryCuMemberAssTotal(tableTable, period, pkCountry);
}
}

73
bd-business/bd-business-member/src/main/java/com/hzs/member/self/controller/api/ApiSelfModifyAddressController.java
View File

@ -5,13 +5,11 @@ import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.hzs.activity.pick.IAcPickServiceApi;
import com.hzs.common.core.constant.msg.CommonMsgConstants;
import com.hzs.common.core.constant.msg.ConfigMsgConstants;
import com.hzs.common.core.domain.R;
import com.hzs.common.core.enums.EApprovalBusiness;
import com.hzs.common.core.enums.EApproveRechargeStatus;
import com.hzs.common.core.enums.EOrderType;
import com.hzs.common.core.utils.DateUtils;
import com.hzs.common.core.utils.StringUtils;
import com.hzs.common.core.web.controller.BaseController;
@ -28,28 +26,20 @@ import com.hzs.member.self.vo.*;
import com.hzs.sale.order.ISaOrderItemsServiceApi;
import com.hzs.sale.order.ISaOrderServiceApi;
import com.hzs.sale.order.dto.OrderItemsParamDTO;
import com.hzs.sale.order.dto.OrderParamDTO;
import com.hzs.sale.order.dto.WaresOrderDTO;
import com.hzs.system.base.IAreaServiceApi;
import com.hzs.system.base.ICurrencyServiceApi;
import com.hzs.system.config.IServiceChargeServiceApi;
import com.hzs.system.sys.IApprovalServiceApi;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;
/**
* @description: 自助服务-修改收货地址
* @author: zhang jing
* @date: 2023/4/17 11:57
* @param:
* @return:
* 自助服务-修改收货地址
**/
@Slf4j
@RequestMapping("/api/self-modify-address")
@ -60,27 +50,17 @@ public class ApiSelfModifyAddressController extends BaseController {
private ICuSelfServiceLogService serviceLogService;
@DubboReference
private IAreaServiceApi iAreaServiceApi;
IAreaServiceApi iAreaServiceApi;
@DubboReference
private IServiceChargeServiceApi serviceChargeServiceApi;
ISaOrderServiceApi iSaOrderServiceApi;
@DubboReference
private IApprovalServiceApi iApprovalServiceApi;
ISaOrderItemsServiceApi iSaOrderItemsServiceApi;
@DubboReference
private ISaOrderServiceApi iSaOrderServiceApi;
@DubboReference
private ISaOrderItemsServiceApi iSaOrderItemsServiceApi;
@DubboReference
private IAcPickServiceApi acPickServiceApi;
@DubboReference
private ICurrencyServiceApi iCurrencyServiceApi;
ICurrencyServiceApi iCurrencyServiceApi;
/**
* @description: 自助服务-查询已申请修改收货地址
* @author: zhang jing
* @date: 2023/4/17 14:40
* @param: [cuSelfServiceLogVO]
* @return: com.hzs.common.core.web.page.TableDataInfo
* 自助服务-查询已申请修改收货地址
**/
@GetMapping("/list")
public TableDataInfo list(SelfModifyAddressVO selfModifyAddressVO) {
@ -128,33 +108,10 @@ public class ApiSelfModifyAddressController extends BaseController {
/**
* @description: 自助服务-申请修改收货地址-发起签呈申请
* @author: zhang jing DATA_SOURCES
* @date: 2023/4/17 14:48
* @param: [cuSelfServiceLogVO]
* @return: com.hzs.common.core.web.domain.AjaxResult
* 自助服务-申请修改收货地址-发起签呈申请
**/
@PostMapping("/putin")
public AjaxResult putin(@RequestBody SelfModifyAddressVO selVO) throws Exception {
System.out.println(
"getRecName " + selVO.getRecName() +
"getRecPhone " + selVO.getRecPhone() +
"getRecAddress " + selVO.getRecAddress() +
"getOrderCode " + selVO.getOrderCode() +
"getNewRecName " + selVO.getNewRecName() +
"getNewRecPhone " + selVO.getNewRecPhone() +
"getNewRecAddress " + selVO.getNewRecAddress() +
// "getNewPostage " + selVO.getNewPostage() +
"getPostage " + selVO.getPostage() +
"getRecProvince " + selVO.getRecProvince() +
"getRecCity " + selVO.getRecCity() +
"getRecCounty " + selVO.getRecCounty() +
"getNewRecProvince " + selVO.getNewRecProvince() +
"getNewRecCity " + selVO.getNewRecCity() +
"getNewRecCounty " + selVO.getNewRecCounty() +
"getPayTime " + selVO.getPayTime()
);
public AjaxResult putin(@RequestBody SelfModifyAddressVO selVO) {
//校验是否重复提交记录
QueryWrapper<CuSelfServiceLog> queryWrapper = new QueryWrapper<>();
queryWrapper.select("ORDER_CODE", "APPROVE_STATUS")
@ -259,19 +216,5 @@ public class ApiSelfModifyAddressController extends BaseController {
return AjaxResult.success(serviceLogService.putin(selVO));
}
/**
* 检查输入的条件
*
* @param orderParam 条件
* @return boolean
*/
protected Boolean checkRecPostageMsgBoolean(OrderParamDTO orderParam) {
return orderParam.getSpecialArea() != null
&& orderParam.getDeliveryWay() != null && orderParam.getTransType() != null
&& orderParam.getRecProvince() != null && orderParam.getRecCity() != null
&& orderParam.getOrderItemsParams() != null
&& orderParam.getOrderItemsParams().size() > 0;
}
}

92
bd-business/bd-business-member/src/main/resources/mapper/member/achieve/CuMemberMonthAchieveMapper.xml
View File

@ -4,76 +4,32 @@
<!-- 通用查询映射结果 -->
<resultMap id="CuMemberMonthAchieve" type="com.hzs.common.domain.member.ext.CuMemberMonthAchieveExt">
<id column="PK_ID" property="pkId" />
<result column="DEL_FLAG" property="delFlag" />
<result column="CREATION_TIME" property="creationTime" />
<result column="MODIFIED_TIME" property="modifiedTime" />
<result column="PK_COUNTRY" property="pkCountry" />
<result column="PK_CREATOR" property="pkCreator" />
<result column="PK_MODIFIED" property="pkModified" />
<result column="PK_MEMBER" property="pkMember" />
<result column="PERIOD" property="period" />
<result column="SETTLE_MONTH" property="settleMonth" />
<result column="RECOMMEND_MONEY" property="recommendMoney" />
<result column="RECOMMEND_ACHIEVE" property="recommendAchieve" />
<result column="REPURCHASE_MONEY" property="repurchaseMoney" />
<result column="REPURCHASE_ACHIEVE" property="repurchaseAchieve" />
<result column="WALL_TYPE" property="wallType" />
<result column="MONEY" property="money" />
<result column="MEMBER_NAME" property="memberName" />
<result column="HEAD_PATH" property="headPath" />
<id column="PK_ID" property="pkId"/>
<result column="DEL_FLAG" property="delFlag"/>
<result column="CREATION_TIME" property="creationTime"/>
<result column="MODIFIED_TIME" property="modifiedTime"/>
<result column="PK_COUNTRY" property="pkCountry"/>
<result column="PK_CREATOR" property="pkCreator"/>
<result column="PK_MODIFIED" property="pkModified"/>
<result column="PK_MEMBER" property="pkMember"/>
<result column="PERIOD" property="period"/>
<result column="SETTLE_MONTH" property="settleMonth"/>
<result column="RECOMMEND_MONEY" property="recommendMoney"/>
<result column="RECOMMEND_ACHIEVE" property="recommendAchieve"/>
<result column="REPURCHASE_MONEY" property="repurchaseMoney"/>
<result column="REPURCHASE_ACHIEVE" property="repurchaseAchieve"/>
<result column="WALL_TYPE" property="wallType"/>
<result column="MONEY" property="money"/>
<result column="MEMBER_NAME" property="memberName"/>
<result column="HEAD_PATH" property="headPath"/>
</resultMap>
<insert id="insertCuMemberMonthAchieve">
merge into CU_MEMBER_MONTH_ACHIEVE a
using(
select pk_member,#{period} period,RECOMMEND_MONEY,RECOMMEND_ACHIEVE,REPURCHASE_MONEY,REPURCHASE_ACHIEVE,pk_country from(
select pk_member,pk_country,sum(REGISTER_NEW_AMOUNT+UPGRADE_NEW_AMOUNT) RECOMMEND_MONEY,sum(REGISTER_NEW_PV+UPGRADE_NEW_PV) RECOMMEND_ACHIEVE,
sum(REPURCHASE_NEW_AMOUNT+HI_FUN_NEW_AMOUNT+MALL_NEW_AMOUNT) REPURCHASE_MONEY,sum(REPURCHASE_PV+HI_FUN_NEW_PV+MALL_NEW_PV) REPURCHASE_ACHIEVE from ${tableName}
where REGISTER_NEW_AMOUNT+UPGRADE_NEW_AMOUNT>0 or REPURCHASE_NEW_AMOUNT+HI_FUN_NEW_AMOUNT+MALL_NEW_AMOUNT>0
group by pk_member,pk_country)
) b
on (a.pk_member=b.pk_member and a.period=b.period)
when matched then
update set a.RECOMMEND_MONEY = b.RECOMMEND_MONEY, a.RECOMMEND_ACHIEVE=b.RECOMMEND_ACHIEVE,
a.REPURCHASE_MONEY=b.REPURCHASE_MONEY,a.REPURCHASE_ACHIEVE=b.REPURCHASE_ACHIEVE
WHEN NOT MATCHED THEN
insert(PK_ID, PK_MEMBER, PERIOD, SETTLE_MONTH, RECOMMEND_MONEY,RECOMMEND_ACHIEVE,REPURCHASE_MONEY,
REPURCHASE_ACHIEVE,PK_COUNTRY,PK_CREATOR)
values (CU_MEMBER_MONTH_ACHIEVE_SEQ.NEXTVAL,
b.pk_member,b.period,#{month},b.RECOMMEND_MONEY,b.RECOMMEND_ACHIEVE,b.REPURCHASE_MONEY,
b.REPURCHASE_ACHIEVE,b.PK_COUNTRY,1)
</insert>
<select id="queryCuMemberMonthAchieveByDate" resultMap="CuMemberMonthAchieve">
select * from(
select * from (
select pk_member,pk_country,${recommend} wall_type,sum(recommend_money) money from CU_MEMBER_MONTH_ACHIEVE
where del_flag=0 and period >= #{startPeriod} and period &lt; #{endPeriod}
group by pk_member,pk_country
order by sum(recommend_money) desc
) where rownum &lt;= 3
union
select * from (
select pk_member,pk_country,${repurchase} wall_type,sum(repurchase_money) money from CU_MEMBER_MONTH_ACHIEVE
where del_flag=0 and period >= #{startPeriod} and period &lt; #{endPeriod}
group by pk_member,pk_country
order by sum(repurchase_money) desc
) where rownum &lt;= 3) a
order by wall_type,a.money desc
</select>
<select id="queryCuMemberMonthAchieveRecommend" resultMap="CuMemberMonthAchieve">
select rownum rank, nvl(cu.nick_name, cu.member_name) member_name, cu.HEAD_PATH,a.money from (
select pk_member,sum(recommend_money) money from CU_MEMBER_MONTH_ACHIEVE
where del_flag = 0 and pk_country= #{pkCountry}
and period between #{startPeriod} and #{endPeriod}
group by pk_member
order by sum(recommend_money) desc) a
inner join cu_member cu
on a.pk_member=cu.pk_id
where rownum &lt;= 3
</select>
<select id="queryCuMemberMonthAchieveInfo" resultType="com.hzs.member.achieve.controller.vo.RealPerformanceVo">
select nvl(sum(A_NEW_PV),0) firstLeftPurchaseTotal,nvl(sum(B_NEW_PV),0) firstRightPurchaseTotal,nvl(sum(REP_A_NEW_PV),0) firstLeftRepurchaseTotal,nvl(sum(REP_B_NEW_PV),0) firstRightRepurchaseTotal
from ${achieveTable} WHERE pk_member=#{pkMember}
select nvl(sum(A_NEW_PV), 0) firstLeftPurchaseTotal,
nvl(sum(B_NEW_PV), 0) firstRightPurchaseTotal,
nvl(sum(REP_A_NEW_PV), 0) firstLeftRepurchaseTotal,
nvl(sum(REP_B_NEW_PV), 0) firstRightRepurchaseTotal
from ${achieveTable}
WHERE pk_member = #{pkMember}
</select>
</mapper>

105
bd-business/bd-business-member/src/main/resources/mapper/member/achieve/CuMemberTreeMapper.xml
View File

@ -138,6 +138,7 @@
<include refid="CuMemberSettleDetailColumn"></include>,
<include refid="CuMemberBackColumn"></include>
</sql>
<sql id="CuMemberSettleDetailColumn">
pk_rate
NUMBER(6) ,
@ -194,6 +195,7 @@
round NUMBER(6) default 0 not null,
second NUMBER(4) default 1 not null
</sql>
<sql id="CuMemberBackColumn">
r_a_balance
NUMBER(17,6) default 0 not null,
@ -213,99 +215,6 @@
r_rep_a_sum_pv NUMBER(17,6) default 0 not null,
r_rep_b_sum_pv NUMBER(17,6) default 0 not null
</sql>
<sql id="CuMemberTableTrig">
CREATE
OR REPLACE TRIGGER
${tableName}
_
TRIG
BEFORE
INSERT
OR
UPDATE ON ${tableName}
FOR EACH ROW
DECLARE
v_newVal NUMBER(12) := 0;
v_incval
NUMBER(12) := 0;
BEGIN
IF
INSERTING AND :new.pk_id IS NULL THEN
SELECT ${tableNameSeq}.NEXTVAL
INTO v_newVal
FROM DUAL;
IF
v_newVal = 1 THEN
SELECT NVL(max(pk_id), 0)
INTO v_newVal
FROM ${tableName};
v_newVal
:= v_newVal + 1;
LOOP
EXIT WHEN v_incval >= v_newVal;
SELECT ${tableNameSeq}.nextval
INTO v_incval
FROM dual;
END LOOP;
END IF;
:new
.pk_id := v_newVal;
END IF;
END;
</sql>
<sql id="QueryMemberParent">
<foreach collection="pkMemberList" item="item" open=" " close=" " separator=" union ">
select pk_member,pk_parent,member_code,member_name,pk_awards,account_status,
register_authority,customer_type,income_status,pk_settle_country,purchase_status,share_status,is_maker_space,
a_balance,b_balance,r_a_balance,r_b_balance,rep_a_balance,rep_b_balance,r_rep_a_balance,r_rep_b_balance,
register_amount,register_pv,upgrade_amount,upgrade_pv,repurchase_amount,pk_center_code,
repurchase_pv,hi_fun_amount,hi_fun_pv,mall_amount,mall_pv,category,pk_grade,
min_achieve,round,second
from ${settleTableName}
where pay_status = 1
start with pk_member = #{item}
connect by pk_member = prior pk_parent
</foreach>
</sql>
<update id="createCuMemberTreeParentIndex">
create index ${tableName}_parent
on ${tableName} (
pk_parent
)
</update>
<update id="createCuMemberTreePlaceIndex">
create index ${tableName}_place
on ${tableName} (
pk_place_parent,
place_dept
)
</update>
<update id="createCuMemberTableUniqueIndex">
create
unique index ${tableName}_PK_M
on ${tableName} (
PK_MEMBER,
period
)
</update>
<update id="createCuMemberTreeDayOnlyIndex">
create unique index ${tableName}_PK_M
on ${tableName} (
PK_MEMBER
)
</update>
<update id="createCuMemberTableSequence" statementType="STATEMENT">
<include refid="CuMemberTableTrig"></include>
</update>
<delete id="truncateCuMemberTreeTable">
truncate table ${tableName}
</delete>
<select id="queryExistOracleTable" resultType="java.lang.Integer">
select 1
@ -343,16 +252,6 @@
where ba.awards_value >= (select awards_value from bd_awards where pk_id = #{awardsValue}))
</select>
<select id="queryExemptCuMemberSettle" resultMap="CuMemberSettleExt">
select pk_member, 0 assess_type
from ${tableName}
where purchase_status = 0
union
select pk_member, 1 assess_type
from ${tableName}
where share_status = 0
</select>
<select id="queryCuMemberTreeByPkMemberTable" resultMap="CuMemberSettleExt">
select
<if test="tableName != null and tableName != ''">

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

@ -1259,93 +1259,6 @@
order by cm.creation_time desc
</select>
<select id="queryCuMemberLastPlaceParent" resultMap="MemberResultMap">
select cu.place_dept,
cu.pk_id,
cu.member_code,
cu.member_name,
cu.phone,
cu.category,
cu.pk_settle_grade,
bg.grade_value,
nick_name,
service_code,
pk_vertex
from (
select *
from (select 1 place_dept,
t.pk_id,
t.member_code,
t.member_name,
t.phone,
t.category,
t.pk_settle_grade,
level lev,
t.nick_name,
t.service_code,
t.pk_vertex
from (select *
from cu_member start with pk_id=#{pkMember}
connect by prior pk_id = pk_place_parent) t
where t.place_dept = 1
and t.del_flag = 0
start
with t.pk_id = (select u.pk_id
from cu_member u
where u.del_flag=0 and u.pk_place_parent=#{pkMember}
and place_dept = 1)
connect by prior
t.pk_id = (select u.pk_place_parent
from cu_member u
where u.del_flag=0
and u.pk_id = t.pk_id
and u.place_dept = 1)
order by lev desc) n
where rownum = 1
union
select *
from (
select 2 place_dept,
t.pk_id,
t.member_code,
t.member_name,
t.phone,
t.category,
t.pk_settle_grade,
level lev,
t.nick_name,
t.service_code,
t.pk_vertex
from (select *
from cu_member start with pk_id=#{pkMember}
connect by prior pk_id = pk_place_parent) t
where t.place_dept = 1
and t.del_flag = 0
start
with t.pk_id = (select u.pk_id
from cu_member u
where u.del_flag=0 and u.pk_place_parent=#{pkMember}
and place_dept = 2)
connect by prior
t.pk_id = (select u.pk_place_parent
from cu_member u
where u.del_flag=0
and u.pk_id = t.pk_id
and u.place_dept = 1)
union
select t.place_dept, t.pk_id, t.member_code, t.member_name, t.phone, t.category, t.pk_settle_grade, 0 lev, t.nick_name, t.service_code, t.pk_vertex
from cu_member t
where t.place_dept = 2 and t.del_flag = 0 and t.pk_place_parent=#{pkMember}
union
select 2, t.pk_id, t.member_code, t.member_name, t.phone, t.category, t.pk_settle_grade, -1 lev, t.nick_name, t.service_code, t.pk_vertex
from cu_member t
where t.del_flag = 0 and t.pk_id=#{pkMember}
order by lev desc) n
where rownum = 1) cu
left join bd_grade bg
on cu.pk_settle_grade = bg.pk_id
</select>
<select id="selectByMemberRealInfo" resultType="com.hzs.member.base.vo.MemberRealInfoVO">
select
cm.MEMBER_CODE as memberCode,
@ -1545,44 +1458,6 @@
order by cm.CREATION_TIME desc
</select>
<select id="queryMemberByCondition" resultType="com.hzs.common.domain.member.ext.CuMemberExt">
select cm.pk_id,cm.member_code,cm.member_name,cm.phone,cm.pk_settle_country,cm.pk_parent,
cm.pk_place_parent,cm.place_dept,cm.pk_team_code,cm.pk_center_code,cm.category,cm.pk_settle_grade,
cm.pk_awards,cm.purchase_status,cm.order_source,cm.is_real_name,cm.is_bus_license,cm.is_maker_space,
cm.share_status,cm.pay_pwd,cm.register_authority,cm.nick_name,bg.grade_value,
cm.pk_vertex,
cm.nick_name,
cm.service_code
from cu_member cm
left join bd_grade bg
on cm.pk_settle_grade = bg.pk_id
where cm.del_flag=0
<if test="pkSettleCountry != null">
and cm.pk_settle_country=#{pkSettleCountry}
</if>
<if test="pkId != null ">
and cm.pk_id = #{pkId}
</if>
<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="phone != null and phone != ''">
and cm.phone = #{phone}
</if>
<if test="pkParent != null and pkParent != ''">
and cm.pk_parent = #{pkParent}
</if>
<if test="pkPlaceParent != null and pkPlaceParent != ''">
and cm.pk_place_parent = #{pkPlaceParent}
</if>
<if test="placeDept != null and placeDept != ''">
and cm.place_dept = #{placeDept}
</if>
</select>
<select id="parentList" resultType="com.hzs.member.base.vo.ParentMemberVo">
select a.* from ( select cm.CONSUME_MONEY consumeMoney,cm.CONSUME_ACHIEVE consumeAchieve,cm.member_code memberCode,cm.member_name memberName,cm.PK_REGISTER_GRADE pkRegisterGrade,
cm.PK_SETTLE_GRADE pkSettleGrade,
@ -1696,49 +1571,6 @@
group by tmp.member_code
</select>
<!-- 校验会员联系方式是否存在 -->
<select id="checkMemberPhoneExist" resultType="com.hzs.member.base.dto.MemberCountDTO">
select tmp.phone, count(tmp.phone) member_count
from (
select cm.phone
from cu_member cm
where cm.del_flag = 0
and cm.system_type = #{systemType}
and (cm.phone in ('0'
<foreach collection="phoneList" item="item" close=")" index="index">
<choose>
<when test="index % 500 == 0">) or cm.phone in (#{item}</when>
<otherwise>, #{item}</otherwise>
</choose>
</foreach>
)
<if test="checkEmpty != null and checkEmpty">
<!-- 需要校验批量空单数据 -->
union all
select cmed.phone
from CU_MEMBER_EMPTY_DETAIL cmed
inner join CU_MEMBER_EMPTY cme
on cme.pk_id = cmed.pk_member_empty
and cme.status in (1, 2, 4)
and cme.del_flag = 0
and cme.system_type = #{systemType}
where cmed.del_flag = 0
<if test="excludeMemberEmpty != null">
and cmed.pk_member_empty != #{excludeMemberEmpty}
</if>
and (cmed.phone in ('0'
<foreach collection="phoneList" item="item" close=")" index="index">
<choose>
<when test="index % 500 == 0">) or cmed.phone in (#{item}</when>
<otherwise>, #{item}</otherwise>
</choose>
</foreach>
)
</if>
) tmp
group by tmp.phone
</select>
<select id="findAll" resultMap="MemberResultMap">
select *
from cu_member

97
bd-business/bd-business-member/src/main/resources/mapper/member/detail/CuMemberAssessDetailMapper.xml
View File

@ -1,97 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.hzs.member.detail.mapper.CuMemberAssessDetailMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.hzs.common.domain.member.detail.CuMemberAssessDetail">
<id column="PK_ID" property="pkId" />
<result column="DEL_FLAG" property="delFlag" />
<result column="PK_COUNTRY" property="pkCountry" />
<result column="CREATION_TIME" property="creationTime" />
<result column="MODIFIED_TIME" property="modifiedTime" />
<result column="PK_ASSESS" property="pkAssess" />
<result column="PK_MEMBER" property="pkMember" />
<result column="PK_ORDER" property="pkOrder" />
<result column="CHANGE_TYPE" property="changeType" />
<result column="TRADE_TIME" property="tradeTime" />
<result column="PK_CREATOR" property="pkCreator" />
<result column="PK_MODIFIED" property="pkModified" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
DEL_FLAG,
PK_COUNTRY,
CREATION_TIME,
MODIFIED_TIME,
PK_ID, PK_ASSESS, PK_MEMBER, PK_ORDER, CHANGE_TYPE, TRADE_TIME, CREATOR, MODIFIED
</sql>
<insert id="insertCuMemberAssessDetailByPeriod">
merge into cu_member_assess_detail a
using (select ca.pk_id,ca.pk_member,(case when ca.assess_type=0 then 1 else 3 end) change_type,
ca.assess_target trade_achieve,ca.pk_creator,ca.pk_country from ${tableName} ca
where ca.assess_status=2 and ca.period = #{period} and pk_member in
<foreach collection="cuMemberList" item="item" open="(" close=")" separator=",">
#{item.pkMember}
</foreach>
and assess_type = #{assessType}
and ca.assess_target &lt;= ca.month_balance+ca.month_add) b
on (a.pk_assess = b.pk_id and a.pk_member = b.pk_member and a.change_type=b.change_type)
when not matched then
insert (pk_assess,pk_member,change_type,trade_achieve, pk_creator,pk_country)
values(b.pk_id,b.pk_member,b.change_type,b.trade_achieve, b.pk_creator,b.pk_country)
</insert>
<insert id="insertCuMemberAssesDetailByOrder">
insert into cu_member_assess_detail (pk_assess,pk_member,PK_ORDER,change_type,trade_achieve,TRADE_TIME, pk_creator,pk_country)
select nvl(ca.pk_id,0) PK_ASSESS,so.PK_MEMBER,so.pk_id pk_order,
0 CHANGE_TYPE,order_achieve TRADE_ACHIEVE,
pay_time TRADE_TIME,so.PK_MEMBER,so.pk_country from sa_order so
left join (select * from ${tableName} where period = #{period} and ASSESS_TYPE=0) ca
on so.pk_member = ca.pk_member
where so.del_flag=0 and so.order_status=1 and order_type in(3,12,14,22,26,31)
and so.order_achieve >0
and pay_time >=#{startDate, jdbcType=DATE}
and pay_time &lt; #{endDate, jdbcType=DATE}
union
select nvl(ca.pk_id,0) PK_ASSESS,so.PK_MEMBER,so.pk_id pk_order,
2 CHANGE_TYPE,order_ass_achieve TRADE_ACHIEVE,
pay_time TRADE_TIME,so.PK_MEMBER,so.pk_country from sa_order so
left join (select * from ${tableName} where period = #{period} and ASSESS_TYPE=1) ca
on so.pk_member = ca.pk_member
where so.del_flag=0 and so.order_status=1 and order_type =13
and pay_time >=#{startDate, jdbcType=DATE}
and pay_time &lt; #{endDate, jdbcType=DATE}
</insert>
<update id="updateCuMemberAssessDetailByPeriod">
merge into cu_member_assess_detail a
using (select pk_id,pk_member,(case when assess_type=0 then 1 else 3 end)change_type,
assess_target trade_achieve,pk_creator,pk_country from ${tableName}
where assess_status=2 and period = #{period}
and assess_target &lt;= month_balance+month_add) b
on (a.pk_assess = b.pk_id and a.pk_member = b.pk_member and a.change_type=b.change_type)
when matched then
update set a.trade_achieve = b.trade_achieve
when not matched then
insert (pk_assess,pk_member,change_type,trade_achieve, pk_creator,pk_country)
values(b.pk_id,b.pk_member,b.change_type,b.trade_achieve, b.pk_creator,b.pk_country)
</update>
<update id="updateCuMemberAssessDetailByRevoke">
merge into cu_member_assess_detail a
using(
<foreach collection="revokeDetailList" item="item" open=" " separator=" union " close=" ">
select #{item.changeType} change_type,#{item.pkMember} pk_member,#{item.pkAssess} pk_assess from dual
</foreach>
)b on (a.pk_assess=b.pk_assess and a.pk_member=b.pk_member and a.change_type=b.change_type)
when matched then
update set a.del_flag=1
</update>
<delete id="deleteCuMemberAssessDetailByPeriod">
DELETE FROM cu_member_assess_detail WHERE pk_assess IN (
SELECT pk_id FROM ${tableName} WHERE period= #{period})
</delete>
</mapper>

5
bd-business/bd-business-member/src/main/resources/mapper/member/honor/CuHonorWallMapper.xml
View File

@ -1,5 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.hzs.member.base.mapper.CuHonorWallMapper">
</mapper>

13
bd-business/bd-business-sale/src/main/java/com/hzs/activity/pick/mapper/AcPickMemberLogMapper.java
View File

@ -33,17 +33,4 @@ public interface AcPickMemberLogMapper extends BaseMapper<AcPickMemberLog> {
@Param("quantity") Integer quantity,
@Param("source") Integer source);
/**
* 批量插入提货日志
*
* @param acPickExtList 批量插入数据
* @param source 来源（1=后台，2=前台）
* @return
*/
int insertBatchPick(@Param("list") List<AcPickExt> acPickExtList, @Param("source") Integer source);
/**
* 批量删除使用记录数据
*/
int deleteBatch(@Param("acPickMemberLogList") List<AcPickMemberLog> acPickMemberLogList);
}

62
bd-business/bd-business-sale/src/main/java/com/hzs/activity/pick/provider/AcPickProviderApi.java
View File

@ -1,62 +0,0 @@
package com.hzs.activity.pick.provider;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.hzs.activity.pick.IAcPickServiceApi;
import com.hzs.activity.pick.service.IAcPickMemberLogService;
import com.hzs.activity.pick.service.IAcPickService;
import com.hzs.common.core.domain.R;
import com.hzs.common.core.exception.ServiceException;
import com.hzs.common.domain.activity.pick.AcPick;
import com.hzs.common.domain.activity.pick.AcPickMemberLog;
import com.hzs.common.domain.sale.ext.SaOrderExt;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.DubboService;
import org.springframework.beans.factory.annotation.Autowired;
import java.math.BigDecimal;
import java.util.List;
/**
* @Description: 提货相关dubbo服务入口
* @Author: jiang chao
* @Time: 2023/5/15 11:21
* @Classname: AcPickProviderApi
* @PackageName: com.hzs.activity.pick.provider
*/
@Slf4j
@DubboService
public class AcPickProviderApi implements IAcPickServiceApi {
@Autowired
private IAcPickService iAcPickService;
@Autowired
private IAcPickMemberLogService acPickMemberLogService;
@Override
public R<List<AcPickMemberLog>> queryPickMemberLog(List<SaOrderExt> saOrderExtList) {
return R.ok(acPickMemberLogService.queryPickMemberLog(saOrderExtList));
}
@Override
public R<BigDecimal> queryOrderPostage(String orderCode, Integer recProvince, Integer recCity, Integer pkCountry) {
try {
LambdaQueryWrapper<AcPickMemberLog> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(AcPickMemberLog::getPickOrder, orderCode);
AcPickMemberLog acPickMemberLog = acPickMemberLogService.getOne(queryWrapper);
if (null != acPickMemberLog) {
AcPick acPick = iAcPickService.getById(acPickMemberLog.getPkPick());
if (null != acPick) {
return R.ok(iAcPickService.postageHandle(acPick, acPickMemberLog.getPickQuantity(), recProvince, recCity, pkCountry));
}
}
return R.fail("提货数据不存在");
} catch (ServiceException se) {
log.error("撤销订单查询提货邮费异常: {}", se.getMessage(), se);
return R.fail(se.getMessage());
} catch (Exception e) {
log.error("撤销订单查询提货邮费异常", e);
}
return R.fail("查询提货邮费失败");
}
}

19
bd-business/bd-business-sale/src/main/java/com/hzs/activity/pick/service/IAcPickMemberLogService.java
View File

@ -4,7 +4,6 @@ import com.baomidou.mybatisplus.extension.service.IService;
import com.hzs.activity.pick.vo.AcPickMemberLogVO;
import com.hzs.common.domain.activity.pick.AcPickMemberLog;
import com.hzs.common.domain.activity.pick.ext.AcPickExt;
import com.hzs.common.domain.sale.ext.SaOrderExt;
import java.util.List;
@ -31,22 +30,4 @@ public interface IAcPickMemberLogService extends IService<AcPickMemberLog> {
*/
int insertBatch(List<AcPickExt> acPickExtList, Integer quantity, Integer source);
/**
* 批量插入提货日志
*
* @param acPickExtList 批量插入数据
* @param source 来源（1=后台，2=前台）
* @return
*/
int insertBatchPick(List<AcPickExt> acPickExtList, Integer source);
/**
* 批量删除使用记录数据
*/
int deleteBatch(List<AcPickMemberLog> acPickMemberLogList);
/**
* 查询会员提货使用记录
*/
List<AcPickMemberLog> queryPickMemberLog(List<SaOrderExt> saOrderExtList);
}

29
bd-business/bd-business-sale/src/main/java/com/hzs/activity/pick/service/impl/AcPickMemberLogServiceImpl.java
View File

@ -1,17 +1,14 @@
package com.hzs.activity.pick.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.hzs.activity.pick.mapper.AcPickMemberLogMapper;
import com.hzs.activity.pick.service.IAcPickMemberLogService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hzs.activity.pick.vo.AcPickMemberLogVO;
import com.hzs.common.domain.activity.pick.AcPickMemberLog;
import com.hzs.common.domain.activity.pick.ext.AcPickExt;
import com.hzs.common.domain.sale.ext.SaOrderExt;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.stream.Collectors;
/**
* 会员提货记录 服务实现类
@ -29,30 +26,4 @@ public class AcPickMemberLogServiceImpl extends ServiceImpl<AcPickMemberLogMappe
return baseMapper.insertBatch(acPickExtList, quantity, source);
}
@Override
public int insertBatchPick(List<AcPickExt> acPickExtList, Integer source) {
return baseMapper.insertBatchPick(acPickExtList, source);
}
@Override
public int deleteBatch(List<AcPickMemberLog> acPickMemberLogList) {
return baseMapper.deleteBatch(acPickMemberLogList);
}
@Override
public List<AcPickMemberLog> queryPickMemberLog(List<SaOrderExt> saOrderExtList) {
LambdaQueryWrapper<AcPickMemberLog> queryWrapper = new LambdaQueryWrapper<>();
Set<String> orderCodeSet = saOrderExtList.stream().distinct().map(SaOrderExt::getOrderCode).collect(Collectors.toSet());
queryWrapper.in(AcPickMemberLog::getPickOrder, orderCodeSet);
Set<String> orderKey = new HashSet<>();
saOrderExtList.forEach(saOrderExt -> orderKey.add(saOrderExt.getOrderCode() + saOrderExt.getPkMember()));
List<AcPickMemberLog> retPickMemberLogList = new ArrayList<>();
List<AcPickMemberLog> acPickMemberLogList = baseMapper.selectList(queryWrapper);
for (AcPickMemberLog acPickMemberLog : acPickMemberLogList) {
if (!orderKey.contains(acPickMemberLog.getPickOrder() + acPickMemberLog.getPkMember())) {
retPickMemberLogList.add(acPickMemberLog);
}
}
return retPickMemberLogList;
}
}

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

@ -42,14 +42,6 @@ public interface SaOrderMapper extends BaseMapper<SaOrder> {
List<SaOrderExt> queryRetailSaOrderByDay(@Param("startDate") Date startDate, @Param("endDate") Date endDate,
@Param("orderCode") String orderCode);
/**
* 查询时间范围内的所有订单，按照订单时间排序,只能用于奖金结算
*
* @param startDate 开始日期
* @param endDate 结束日期
*/
List<SaOrderExt> queryRepeatSaOrderByDay(@Param("startDate") Date startDate, @Param("endDate") Date endDate);
/*
* 查询订单，存在可能已经撤单的
**/
@ -237,19 +229,6 @@ public interface SaOrderMapper extends BaseMapper<SaOrder> {
*/
List<Integer> queryOrderType(@Param("memberId") Long memberId, @Param("pkCountry") Integer pkCountry);
/*
* 查询满足复购分享收益的订单
**/
List<SaOrder> querySaOrderByTimeForCouponShare(@Param("startDate") Date startDate, @Param("endDate") Date endDate,
@Param("orderTypeList") List<Integer> orderTypeList, @Param("orderAmount") BigDecimal orderAmount,
@Param("orderAchieve") BigDecimal orderAchieve, @Param("pkCountry") Integer pkCountry);
/*
* 计算店铺奖金，查询订单
**/
List<SaOrderExt> querySaOrderByTimeForStore(@Param("startDate") Date startDate, @Param("endDate") Date endDate);
/**
* 会员首页我的市场
*
@ -293,15 +272,6 @@ public interface SaOrderMapper extends BaseMapper<SaOrder> {
*/
List<MemberFirstOrderVo> checkMemberIsFirstOrder(@Param("memberCodeList") List<String> memberCodeList);
/**
* 查询最新注册订单或升级订单
*
* @param pkMember 会员ID
* @param pkCountry 所属国家
* @return
*/
SaOrder queryLastRegisterOrUpdate(@Param("pkMember") Long pkMember, @Param("pkCountry") Integer pkCountry);
/**
* 根据订单ID查询订单信息
*

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

@ -1,21 +1,16 @@
package com.hzs.sale.order.provider;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.hzs.common.core.constant.CacheConstants;
import com.hzs.common.core.constant.msg.SaOrderMsgConstants;
import com.hzs.common.core.domain.R;
import com.hzs.common.core.enums.EOrderStatus;
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.sale.ext.SaDeliverItemsExt;
import com.hzs.common.domain.member.ext.CuMemberAccountExt;
import com.hzs.common.domain.sale.ext.SaOrderExt;
import com.hzs.common.domain.sale.ext.SaOrderItemsExt;
import com.hzs.common.domain.sale.order.SaOrder;
import com.hzs.common.domain.sale.order.SaOrderItems;
import com.hzs.common.util.TransactionUtils;
import com.hzs.sale.order.ISaOrderServiceApi;
import com.hzs.sale.order.dto.*;
import com.hzs.sale.order.param.*;
@ -30,7 +25,6 @@ import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
/**
@ -50,11 +44,6 @@ public class SaOrderServiceProvider implements ISaOrderServiceApi {
return R.ok(iSaOrderService.queryRetailSaOrderByDay(startDate, endDate, orderCode));
}
@Override
public R<List<SaOrderExt>> queryRepeatSaOrderByDay(Date startDate, Date endDate) {
return R.ok(iSaOrderService.queryRepeatSaOrderByDay(startDate, endDate));
}
@Override
public R<SaOrder> querySaOrderExtByPkId(Long pkId) {
return R.ok(iSaOrderService.querySaOrderExtByPkId(pkId));
@ -65,21 +54,6 @@ public class SaOrderServiceProvider implements ISaOrderServiceApi {
return R.ok(iSaOrderService.querySaOrderByDeliverList(deliverItemExtList));
}
@Override
public R<List<SaOrder>> querySaOrderByDayForCloud(Date startDate, Date endDate, List<Integer> orderType) {
return R.ok(iSaOrderService.querySaOrderByTimeForCloud(startDate, endDate, orderType));
}
@Override
public R<List<SaOrder>> querySaOrderByTimeForCouponShare(Date startDate, Date endDate, List<Integer> orderTypeList, BigDecimal orderAmount, BigDecimal orderAchieve, Integer pkCountry) {
return R.ok(iSaOrderService.querySaOrderByTimeForCouponShare(startDate, endDate, orderTypeList, orderAmount, orderAchieve, pkCountry));
}
@Override
public R<List<SaOrderExt>> querySaOrderByTimeForStore(Date startDate, Date endDate) {
return R.ok(iSaOrderService.querySaOrderByTimeForStore(startDate, endDate));
}
@Override
public R<List<SaOrderItemsExt>> queryOrderItemsListByOrderId(List<Long> pkOrderList, Integer pkCountry) {
OrderSelectParam param = new OrderSelectParam();
@ -87,16 +61,6 @@ public class SaOrderServiceProvider implements ISaOrderServiceApi {
return R.ok(iSaOrderService.queryOrderSelect(param, pkCountry));
}
@Override
public R<SaOrderExt> queryOrderByCode(String orderCode, Long pkMember) {
SaOrderExt saOrder = redisService.getCacheObject(CacheConstants.TEMP_ORDER + pkMember + orderCode);
if (null == saOrder) {
// 直销订单
saOrder = iSaOrderService.queryOrderByCode(orderCode, null);
}
return R.ok(saOrder);
}
@Override
@Transactional(rollbackFor = Exception.class)
public R<Boolean> regEmptyOrderApproved(ApprovalBusinessResultDTO approvalBusinessResultDTO) {
@ -135,13 +99,6 @@ public class SaOrderServiceProvider implements ISaOrderServiceApi {
return R.ok(iSaOrderService.querySeqList(param));
}
/**
* @description: 自助服务-修改收货地址订单列表
* @author: zhang jing
* @date: 2023/11/15 17:24
* @param: [param, memberId, pkCountry]
* @return: com.hzs.common.core.domain.R<java.util.List < com.hzs.common.domain.sale.ext.SaOrderExt>>
**/
@Override
public R<List<SaOrderExt>> selfAddressOrderList(String orderCode, Integer editType, Long memberId, Integer pkCountry) {
MyOrderParam param = new MyOrderParam();
@ -173,19 +130,12 @@ public class SaOrderServiceProvider implements ISaOrderServiceApi {
return R.ok();
}
/**
* 查询注册订单数量
*
* @param memberCodeList
* @return
*/
@Override
public List<MemberFirstOrderDTO> checkMemberIsFirstOrder(List<String> memberCodeList) {
List<MemberFirstOrderVo> memberFirstOrderVos = iSaOrderService.checkMemberIsFirstOrder(memberCodeList);
return memberFirstOrderVos.stream().map(a -> BeanUtil.copyProperties(a, MemberFirstOrderDTO.class)).collect(Collectors.toList());
}
@Override
public R<CuMemberAccountExt> queryOrderSpendDetails(CuMemberAccountExt cuMemberAccount, SaOrder saOrder, List<SaOrderItems> orderItemList) {
try {
@ -196,11 +146,6 @@ public class SaOrderServiceProvider implements ISaOrderServiceApi {
}
}
/**
* 查询订单单品统计
*
* @return
*/
@Override
public List<SingleItemStatDTO> singleItemStat(SingleItemStatParamDTO singleItemStatParamDTO) {
SingleItemStatParam singleItemStatParam = BeanUtil.copyProperties(singleItemStatParamDTO, SingleItemStatParam.class);

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

@ -314,14 +314,6 @@ public interface ISaOrderService extends IService<SaOrder> {
*/
List<SaOrderExt> queryRetailSaOrderByDay(Date startDate, Date endDate, String orderCode);
/**
* 查询时间范围内的所有订单，按照订单时间排序,只能用于奖金结算
*
* @param startDate 开始日期
* @param endDate 结束日期
*/
List<SaOrderExt> queryRepeatSaOrderByDay(Date startDate, Date endDate);
/*
* 查询订单，存在可能已经撤单的
**/
@ -332,34 +324,6 @@ public interface ISaOrderService extends IService<SaOrder> {
**/
List<SaOrderExt> querySaOrderByDeliverList(List<SaDeliverItemsExt> deliverItemExtList);
/**
* 计算云代奖金，查询订单
*
* @param startDate 开始日期
* @param endDate 结束日期
*/
List<SaOrder> querySaOrderByTimeForCloud(Date startDate, Date endDate, List<Integer> orderType);
/**
* 计算复购券分享奖金，查询订单
*
* @param startDate 开始日期
* @param endDate 结束日期
* @param orderTypeList 订单类型
* @param orderAmount 订单金额
* @param orderAchieve 订单业绩
*/
List<SaOrder> querySaOrderByTimeForCouponShare(Date startDate, Date endDate, List<Integer> orderTypeList,
BigDecimal orderAmount, BigDecimal orderAchieve, Integer pkCountry);
/*
* 计算店铺奖金，查询订单
* @author: sui q
* @date: 2023/5/8 15:45
* @param: null null
**/
List<SaOrderExt> querySaOrderByTimeForStore(Date startDate, Date endDate);
/**
* 获取系统参数
*
@ -524,15 +488,6 @@ public interface ISaOrderService extends IService<SaOrder> {
*/
List<SaOrderItemsExt> queryOrderSelect(OrderSelectParam param, Integer pkCountry);
/**
* 验证可用量，可用量不足，不能下单
*
* @param orderParam
* @param orderCode
* @return
*/
String validateAvailableNum(OrderParam orderParam, String orderCode);
/**
* 空单注册审核通过
*
@ -600,9 +555,6 @@ public interface ISaOrderService extends IService<SaOrder> {
/*
* 根据时间端查询订单累计业绩累计金额
* @author: sui q
* @date: 2023/7/3 14:51
* @param: null null
**/
SaOrder queryOrderTotalAchieveByTime(Date startDate, Date endDate);
@ -623,7 +575,7 @@ public interface ISaOrderService extends IService<SaOrder> {
int insertBach(List<SaOrder> orderList, List<SaOrderItems> orderItemsList);
/**
* 生成三方销售订单
* 生成三方销售订单
*/
void saveSaOrderByOrderExt(SaOrderExt saOrderExt);

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

@ -15,7 +15,6 @@ import com.hzs.common.core.config.BdConfig;
import com.hzs.common.core.constant.*;
import com.hzs.common.core.constant.msg.ConfigMsgConstants;
import com.hzs.common.core.constant.msg.MemberMsgConstants;
import com.hzs.common.core.constant.msg.ScmMsgConstants;
import com.hzs.common.core.domain.R;
import com.hzs.common.core.enums.*;
import com.hzs.common.core.exception.ServiceException;
@ -33,10 +32,8 @@ import com.hzs.common.domain.member.ext.CuMemberExt;
import com.hzs.common.domain.sale.ext.*;
import com.hzs.common.domain.sale.order.*;
import com.hzs.common.domain.sale.wares.BdWares;
import com.hzs.common.domain.scm.ic.IcAvailableNum;
import com.hzs.common.domain.scm.ic.ext.IcAvailableNumExt;
import com.hzs.common.domain.system.base.BdCountry;
import com.hzs.common.domain.system.base.BdStorehouse;
import com.hzs.common.domain.system.base.ext.BdProductStorehouseExt;
import com.hzs.common.domain.system.config.BdAwards;
import com.hzs.common.domain.system.config.BdGrade;
@ -132,8 +129,6 @@ public class SaOrderServiceImpl extends ServiceImpl<SaOrderMapper, SaOrder> impl
@DubboReference
ICuMemberDetailServiceApi iCuMemberDetailServiceApi;
@DubboReference
IScmBillServiceApi scmBillServiceApi;
@DubboReference
IGradeServiceApi iGradeServiceApi;
@Autowired
@ -170,9 +165,6 @@ public class SaOrderServiceImpl extends ServiceImpl<SaOrderMapper, SaOrder> impl
@Autowired
private RedisService redisService;
@Autowired
private IBdWaresDetailService bdWaresDetailService;
@Override
public List<CuMemberExt> queryMemberExtByCondition(CuMember cuMember) {
return memberServiceApi.getMemberInfo(cuMember).getData();
@ -1600,11 +1592,6 @@ public class SaOrderServiceImpl extends ServiceImpl<SaOrderMapper, SaOrder> impl
return baseMapper.queryRetailSaOrderByDay(startDate, endDate, orderCode);
}
@Override
public List<SaOrderExt> queryRepeatSaOrderByDay(Date startDate, Date endDate) {
return baseMapper.queryRepeatSaOrderByDay(startDate, endDate);
}
@Override
public SaOrder querySaOrderExtByPkId(Long pkId) {
return baseMapper.querySaOrderExtByPkId(pkId);
@ -1615,27 +1602,6 @@ public class SaOrderServiceImpl extends ServiceImpl<SaOrderMapper, SaOrder> impl
return baseMapper.querySaOrderByDeliverList(deliverItemExtList);
}
@Override
public List<SaOrder> querySaOrderByTimeForCloud(Date startDate, Date endDate, List<Integer> orderType) {
QueryWrapper<SaOrder> queryWrapper = new QueryWrapper<>();
queryWrapper.select("pk_id,pk_member,order_code,order_type,pk_rate,order_amount,order_achieve,rec_province,rec_city,rec_county,pk_country ")
.eq(SaOrderFieldConstants.ORDER_STATUS, EOrderStatus.PAY.getValue())
.ge(SaOrderFieldConstants.PAY_TIME, startDate)
.lt(SaOrderFieldConstants.PAY_TIME, endDate)
.in(SaOrderFieldConstants.ORDER_TYPE, orderType);
return baseMapper.selectList(queryWrapper);
}
@Override
public List<SaOrder> querySaOrderByTimeForCouponShare(Date startDate, Date endDate, List<Integer> orderTypeList, BigDecimal orderAmount, BigDecimal orderAchieve, Integer pkCountry) {
return baseMapper.querySaOrderByTimeForCouponShare(startDate, endDate, orderTypeList, orderAmount, orderAchieve, pkCountry);
}
@Override
public List<SaOrderExt> querySaOrderByTimeForStore(Date startDate, Date endDate) {
return baseMapper.querySaOrderByTimeForStore(startDate, endDate);
}
@Override
public String querySystemConfigByKey(Integer pkCountry, String key) {
return systemConfigServiceApi.getBonusSystemConfig(pkCountry, key).getData();
@ -1671,38 +1637,16 @@ public class SaOrderServiceImpl extends ServiceImpl<SaOrderMapper, SaOrder> impl
return baseMapper.myOrderList(param, memberId, pkCountry);
}
/**
* @description: 自助撤单列表
* @author: zhang jing
* @date: 2023/11/21 11:24
* @param: [param, memberId, pkCountry]
* @return: java.util.List<com.hzs.common.domain.sale.ext.SaOrderExt>
**/
@Override
public List<SaOrderExt> selfRevokeOrderList(MyOrderParam param, Long memberId, Integer pkCountry) {
return baseMapper.selfRevokeOrderList(param, memberId, pkCountry);
}
/**
* @description: 自助服务-可申请订单列表
* @author: zhang jing
* @date: 2023/4/19 11:29
* @param: [param, memberId, pkCountry]
* @return: java.util.List<com.hzs.common.domain.sale.ext.SaOrderExt>
**/
@Override
public List<SaOrderExt> selfOrderList(MyOrderParam param, Long memberId, Integer pkCountry) {
return baseMapper.selfOrderList(param, memberId, pkCountry);
}
/**
* @description: 查询最新待发货订单
* @author: zhang jing
* @date: 2023/11/22 16:28
* @param: [memberId, pkCountry]
* @return: java.util.List<com.hzs.common.domain.sale.ext.SaOrderExt>
**/
@Override
public String lastOrderList(Long memberId, Integer pkCountry) {
return baseMapper.lastOrderList(memberId, pkCountry);
@ -1825,58 +1769,6 @@ public class SaOrderServiceImpl extends ServiceImpl<SaOrderMapper, SaOrder> impl
return baseMapper.queryOrderSelect(param, pkCountry);
}
@Override
public String validateAvailableNum(OrderParam orderParam, String orderCode) {
if (EYesNo.NO.getIntValue() == BdConfig.getEnable()) {
return null;
}
BdStorehouse bdStorehouse;
if (CountryConstants.CHINA_COUNTRY.equals(orderParam.getPkSettleCountry()) || orderParam.getPkStorehouse() == null) {
if (orderParam.getRecProvince() != null) {
// 根据收货省获取仓库
bdStorehouse = currencyServiceApi.queryBdStorehouseByProvince(orderParam.getRecProvince()).getData();
} else {
return MemberMsgConstants.REQUIRED_NOT_EMPTY;
}
} else {
bdStorehouse = currencyServiceApi.queryBdStorehouseById(orderParam.getPkStorehouse()).getData();
}
if (bdStorehouse == null) {
return ScmMsgConstants.AVAILABLE_NUM_NOT_ENOUGH;
}
// 验证可用量，根据参数获得产品规格
CuMember cuMember = getCuMemberByKey(orderParam.getCenterCodeId());
List<IcAvailableNum> availableNumList = bdWaresDetailService.queryWaresDetailSpecsByCondition(orderParam.getSpecialArea(), orderParam.getPkCountry(), bdStorehouse.getPkCorp(),
bdStorehouse.getPkId(), orderParam.getRecProvince(), orderParam.getParent(), cuMember, orderParam.getOrderItemsParams());
if (availableNumList != null && availableNumList.size() > 0) {
List<IcAvailableNumExt> newAvailableNumList = scmBillServiceApi.queryAvailableNumByProduct(availableNumList).getData();
if (CollectionUtil.isEmpty(newAvailableNumList)) {
return ScmMsgConstants.AVAILABLE_NUM_NOT_ENOUGH;
}
boolean flag = Boolean.FALSE;
for (IcAvailableNumExt icAvailableNum : newAvailableNumList) {
if (icAvailableNum.getPkUnit() != 0) {
flag = Boolean.TRUE;
break;
}
icAvailableNum.setOrderCode(orderCode);
icAvailableNum.setPkCountry(orderParam.getPkSettleCountry());
}
if (flag) {
return ScmMsgConstants.AVAILABLE_NUM_NOT_ENOUGH;
}
Date currentDateTime = DateUtils.currentDateTime();
for (IcAvailableNumExt icAvailableNum : newAvailableNumList) {
icAvailableNum.setPkCountry(orderParam.getPkCountry());
icAvailableNum.setPkModified(orderParam.getCenterCodeId());
icAvailableNum.setModifiedTime(currentDateTime);
icAvailableNum.setOrderCode(orderCode);
}
orderParam.setAvailableNumList(newAvailableNumList);
}
return null;
}
private CuMember calculateHaFunMemberGrade(SaOrderExt saOrderExt, CuMember newCuMember) {
CuMember cuMember = null;

48
bd-business/bd-business-sale/src/main/resources/mapper/activity/pick/AcPickMemberLogMapper.xml
View File

@ -14,13 +14,6 @@
<result column="DEL_FLAG" property="delFlag"/>
<result column="SOURCE" property="source"/>
</resultMap>
<delete id="deleteBatch">
delete from AC_PICK_MEMBER_LOG
where pk_id in
<foreach collection="acPickMemberLogList" item="item" open="(" close=")" separator=",">
#{item.pkId}
</foreach>
</delete>
<!-- 查询提货日志 -->
<select id="queryMemberLog" resultType="com.hzs.activity.pick.vo.AcPickMemberLogVO">
@ -79,45 +72,4 @@
</update>
<!-- 批量插入提货日志 -->
<update id="insertBatchPick">
merge into AC_PICK_MEMBER_LOG apml
using (
<foreach collection="list" item="item" separator=" union ">
select ap.pk_id PK_PICK,
ap.pk_member pk_member,
#{item.orderCode} PICK_ORDER,
#{item.usedQuantity} used_quantity,
ap.pk_country pk_country
from ac_pick ap
where ap.pick_type = #{item.pickType}
and ap.pk_base_config = #{item.pkBaseConfig}
and ap.pk_data_id = #{item.pkDataId}
and ap.pk_member = #{item.pkMember}
</foreach>
) tmp
on (0 = 1)
WHEN NOT MATCHED THEN
insert
(PK_ID,
PK_MEMBER,
PK_PICK,
PICK_QUANTITY,
PICK_TIME,
PICK_ORDER,
PK_COUNTRY,
DEL_FLAG,
SOURCE)
values
(ac_pick_member_log_seq.nextval,
tmp.pk_member,
tmp.pk_pick,
tmp.used_quantity,
sysdate,
tmp.pick_order,
tmp.pk_country,
0,
#{source})
</update>
</mapper>

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

@ -1159,38 +1159,6 @@
order by order_type
</select>
<select id="querySaOrderByTimeForCouponShare" resultType="com.hzs.common.domain.sale.order.SaOrder">
select pk_member,pk_rate,order_amount,order_achieve from(
select pk_member,pk_rate,sum(order_amount) order_amount,sum(order_achieve) order_achieve from sa_order
where del_flag = 0 and order_status=1 and pk_country = #{pkCountry} and order_type in
<foreach collection="orderTypeList" item="item" open="(" close=")" separator=",">
#{item}
</foreach>
and pay_time >= #{startDate, jdbcType=DATE} and pay_time &lt; #{startDate, jdbcType=DATE}
group by pk_member,pk_rate)
where order_amount>= #{orderAmount} and order_achieve>= #{orderAchieve}
</select>
<select id="querySaOrderByTimeForStore" resultMap="saOrderExtResultMap">
select cs.pk_member, cs.pk_store_level, so.pk_id, bc.in_exchange_rate, so.pk_rate, so.order_amount, so.order_achieve
from cu_store cs
inner join (
select PK_MEMBER_STORE, pk_rate, max(pk_id) pk_id, sum(order_amount) order_amount, sum(order_achieve) order_achieve
from sa_order
where del_flag = 0
and order_status = 1
and pay_time >= #{startDate, jdbcType=DATE}
and pay_time &lt; #{startDate, jdbcType=DATE}
and PK_MEMBER_STORE is not null
group by PK_MEMBER_STORE, pk_rate) so
on cs.pk_id = so.pk_member_store
left join bd_currency bc
on bc.pk_id = so.pk_rate
where cs.del_flag = 0
and so.order_achieve >= 2000
</select>
<select id="selectMyMarket" resultType="com.hzs.sale.index.vo.CuMemberMyMarketVO">
select count(distinct o.pk_country) countryNum,
count(distinct o.rec_province) regionNum
@ -1352,19 +1320,6 @@
</if>
</select>
<!-- 查询最新注册订单或升级订单 -->
<select id="queryLastRegisterOrUpdate" resultMap="SaOrder">
select *
from (select so.*
from sa_order so
where so.pk_member = #{pkMember}
and so.pk_country = #{pkCountry}
and so.order_type in (1, 2, 7, 25, 26)
and so.del_flag = 0
order by so.pay_time desc) so
where rownum = 1
</select>
<!-- 根据订单编号查询订单信息 -->
<select id="queryByPkIdOrCode" resultMap="saOrderExtResultMap">
select so.*,
@ -1477,64 +1432,6 @@
order by a.show_Time desc
</select>
<select id="queryRepeatSaOrderByDay" 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.order_amount,
so.order_achieve,
so.upload_achieve,
so.pk_reference,
so.pk_vertex,
so.pk_country,
so.pay_time,
nvl(so.order_type_extend, 0) order_type_extend,
so.pk_creator,
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
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
left join bd_wares bw
on bw.pk_id = st.pk_wares
left join sa_cabin_card_detail sd
on sd.pk_order = so.pk_id and sd.del_flag = 0
where so.order_status = 1
and so.del_flag = 0
and so.order_type in (1, 2, 24, 25)
and so.pay_time >= #{startDate}
and so.pay_time &lt; #{endDate}) od
left join bd_currency bc
on od.pk_rate = bc.pk_id
order by pay_time
</select>
<!-- 查询最新订单时间 -->
<select id="getFirstPayTime" resultType="date">

14
bd-business/bd-business-system/src/main/java/com/hzs/system/config/mapper/BdServiceChargeMapper.java
View File

@ -1,6 +1,5 @@
package com.hzs.system.config.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hzs.common.domain.serviceCharge.BdServiceCharge;
import com.hzs.system.config.dto.ServiceChargeDTO;
@ -9,25 +8,18 @@ import com.hzs.system.config.vo.ServiceChargeVo;
import java.util.List;
/**
* <p>
* 办理业务手续费配置主表 Mapper 接口
* </p>
*
* @author hzs
* @since 2023-01-03
*/
public interface BdServiceChargeMapper extends BaseMapper<BdServiceCharge> {
/**
* @description: 根据业务类型查询扣费
* @author: zhang jing
* @date: 2023/1/7 14:49
* @param: [serviceChargeVo]
* @return: com.hzs.system.config.vo.ServiceChargeVo
* 根据业务类型查询扣费
**/
ServiceChargeDTO getServiceChargeByType(ServiceChargeDTO serviceChargeDTO);
/**
* 查询列表
*
* @param serviceCharge
* @return
*/

16
bd-business/bd-business-system/src/main/java/com/hzs/system/config/mapper/BdStoreLevelMapper.java
View File

@ -1,27 +1,11 @@
package com.hzs.system.config.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hzs.common.domain.system.config.BdStoreLevel;
import com.hzs.common.domain.system.config.ext.BdStoreLevelExt;
import java.util.List;
/**
* <p>
* 店铺等级配置 Mapper 接口
* </p>
*
* @author hzs
* @since 2023-05-04
*/
public interface BdStoreLevelMapper extends BaseMapper<BdStoreLevel> {
/*
* @description: 查询店铺等级
* @author: sui q
* @date: 2023/5/8 16:41
* @param: null null
**/
List<BdStoreLevelExt> queryStoreLevel();
}

9
bd-business/bd-business-system/src/main/java/com/hzs/system/config/provider/GradeServiceProvider.java
View File

@ -6,13 +6,11 @@ import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.hzs.common.core.constant.CountryConstants;
import com.hzs.common.core.domain.R;
import com.hzs.common.domain.system.config.BdGrade;
import com.hzs.common.domain.system.config.ext.BdStoreLevelExt;
import com.hzs.common.domain.system.ext.BdGradeScopeExt;
import com.hzs.system.config.IGradeServiceApi;
import com.hzs.system.config.dto.GradeDTO;
import com.hzs.system.config.service.IBdGradeScopeService;
import com.hzs.system.config.service.IBdGradeService;
import com.hzs.system.config.service.IBdStoreLevelService;
import org.apache.dubbo.config.annotation.DubboService;
import org.springframework.beans.factory.annotation.Autowired;
@ -29,8 +27,6 @@ public class GradeServiceProvider implements IGradeServiceApi {
private IBdGradeService iBdGradeService;
@Autowired
private IBdGradeScopeService iBdGradeScopeService;
@Autowired
private IBdStoreLevelService iBdStoreLevelService;
@Override
public R<GradeDTO> getGrade(Integer pkId) {
@ -120,11 +116,6 @@ public class GradeServiceProvider implements IGradeServiceApi {
return R.ok(gradeDTOList);
}
@Override
public R<List<BdStoreLevelExt>> queryStoreLevel() {
return R.ok(iBdStoreLevelService.queryStoreLevel());
}
@Override
public R<List<BdGrade>> queryGrowUpFootmarkGrade(Integer pkCountry) {
return R.ok(iBdGradeService.queryGrowUpFootmarkGrade(pkCountry));

19
bd-business/bd-business-system/src/main/java/com/hzs/system/config/provider/ServiceChargeServiceProvider.java
View File

@ -12,28 +12,17 @@ import java.util.ArrayList;
import java.util.List;
/**
* @description: 业务办理手续费dubbo服务类
* @author: zhang jing
* @date: 2023/1/7 15:04
* @param:
* @return:
* 业务办理手续费dubbo服务类
**/
@DubboService
public class ServiceChargeServiceProvider implements IServiceChargeServiceApi {
@Autowired
private IBdServiceChargeService serviceChargeService;
private IBdServiceChargeService iBdServiceChargeService;
/**
* @description: 根据业务类型查询扣款
* @author: zhang jing
* @date: 2023/1/7 15:13
* @param: [serviceChargeDTO]
* @return: com.hzs.common.core.domain.R<com.hzs.system.config.dto.ServiceChargeDTO>
**/
@Override
public R<ServiceChargeDTO> getServiceChargeByType(ServiceChargeDTO serviceChargeDTO) {
ServiceChargeDTO dto = serviceChargeService.getServiceChargeByType(serviceChargeDTO);
ServiceChargeDTO dto = iBdServiceChargeService.getServiceChargeByType(serviceChargeDTO);
if (null == dto) {
// 如果没有配置业务办理手续费，给一个从现金币扣款为0的
dto = ServiceChargeDTO.builder()
@ -48,7 +37,7 @@ public class ServiceChargeServiceProvider implements IServiceChargeServiceApi {
public R<List<ServiceChargeDTO>> getServiceChargeByType(List<ServiceChargeDTO> serviceChargeDTOList) {
List<ServiceChargeDTO> resultList = new ArrayList<>();
for (ServiceChargeDTO serviceChargeDTO : serviceChargeDTOList) {
ServiceChargeDTO dto = serviceChargeService.getServiceChargeByType(serviceChargeDTO);
ServiceChargeDTO dto = iBdServiceChargeService.getServiceChargeByType(serviceChargeDTO);
if (null != dto) {
resultList.add(dto);
}

13
bd-business/bd-business-system/src/main/java/com/hzs/system/config/service/IBdServiceChargeService.java
View File

@ -8,14 +8,10 @@ import com.hzs.system.config.vo.ServiceChargeVo;
import java.util.List;
/**
* <p>
* 办理业务手续费配置主表 服务类
* </p>
*
* @author hzs
* @since 2023-01-03
*/
public interface IBdServiceChargeService extends IService<BdServiceCharge> {
/**
* 新增
*
@ -46,16 +42,13 @@ public interface IBdServiceChargeService extends IService<BdServiceCharge> {
ServiceChargeVo getServiceCharge(Long pkServiceCharge);
/**
* @description: 根据业务类型查询扣款
* @author: zhang jing
* @date: 2023/1/7 14:44
* @param: [serviceChargeVo]
* @return: com.hzs.system.config.vo.ServiceChargeVo
* 根据业务类型查询扣款
**/
ServiceChargeDTO getServiceChargeByType(ServiceChargeDTO serviceChargeDTO);
/**
* 查询列表
*
* @param serviceCharge
* @return
*/

8
bd-business/bd-business-system/src/main/java/com/hzs/system/config/service/IBdStoreLevelService.java
View File

@ -2,21 +2,13 @@ package com.hzs.system.config.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hzs.common.domain.system.config.BdStoreLevel;
import com.hzs.common.domain.system.config.ext.BdStoreLevelExt;
import com.hzs.system.config.vo.BdStoreLevelVO;
import java.util.List;
/**
* 店铺等级配置 服务类
*/
public interface IBdStoreLevelService extends IService<BdStoreLevel> {
/*
* 查询店铺等级
**/
List<BdStoreLevelExt> queryStoreLevel();
/**
* 新增店铺等级配置
**/

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

@ -4,9 +4,6 @@ import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hzs.common.core.constant.CacheConstants;
import com.hzs.common.core.enums.EDelFlag;
import com.hzs.common.core.service.RedisService;
import com.hzs.common.domain.serviceCharge.BdServiceCharge;
import com.hzs.common.domain.serviceCharge.BdServiceChargeDetail;
import com.hzs.common.security.utils.SecurityUtils;
@ -24,28 +21,16 @@ import java.util.Date;
import java.util.List;
/**
* <p>
* 办理业务手续费配置主表 服务实现类
* </p>
*
* @author hzs
* @since 2023-01-03
*/
@Service
public class BdServiceChargeServiceImpl extends ServiceImpl<BdServiceChargeMapper, BdServiceCharge> implements IBdServiceChargeService {
@Autowired
private IBdServiceChargeService serviceChargeService;
@Autowired
private IBdServiceChargeDetailService serviceChargeDetailService;
@Autowired
private RedisService redisService;
/**
* 新增
*
* @param serviceChargeVo
* @return
*/
@Autowired
private IBdServiceChargeService iBdServiceChargeService;
@Autowired
private IBdServiceChargeDetailService iBdServiceChargeDetailService;
@Override
@Transactional(rollbackFor = Exception.class)
public void saveServiceCharge(ServiceChargeVo serviceChargeVo) {
@ -53,91 +38,56 @@ public class BdServiceChargeServiceImpl extends ServiceImpl<BdServiceChargeMappe
bdServiceCharge.setPkCreator(SecurityUtils.getUserId());
bdServiceCharge.setCreationTime(new Date());
bdServiceCharge.setPkCountry(serviceChargeVo.getPkCountry());
serviceChargeService.save(bdServiceCharge);
iBdServiceChargeService.save(bdServiceCharge);
for (BdServiceChargeDetail bdServiceChargeDetail : serviceChargeVo.getServiceChargeDetailsList()) {
bdServiceChargeDetail.setPkServiceCharge(bdServiceCharge.getPkId());
bdServiceChargeDetail.setPkCountry(serviceChargeVo.getPkCountry());
}
serviceChargeDetailService.saveBatch(serviceChargeVo.getServiceChargeDetailsList());
iBdServiceChargeDetailService.saveBatch(serviceChargeVo.getServiceChargeDetailsList());
}
/**
* 修改
*
* @param serviceChargeVo
* @return
*/
@Override
@Transactional(rollbackFor = Exception.class)
public void updateServiceCharge(ServiceChargeVo serviceChargeVo) {
BdServiceCharge bdServiceCharge = BeanUtil.copyProperties(serviceChargeVo, BdServiceCharge.class);
bdServiceCharge.setPkModified(SecurityUtils.getUserId());
bdServiceCharge.setModifiedTime(new Date());
serviceChargeService.updateById(bdServiceCharge);
UpdateWrapper<BdServiceChargeDetail> updateWrapper =new UpdateWrapper<>();
updateWrapper.eq("PK_SERVICE_CHARGE",bdServiceCharge.getPkId());
serviceChargeDetailService.remove(updateWrapper);
iBdServiceChargeService.updateById(bdServiceCharge);
UpdateWrapper<BdServiceChargeDetail> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("PK_SERVICE_CHARGE", bdServiceCharge.getPkId());
iBdServiceChargeDetailService.remove(updateWrapper);
for (BdServiceChargeDetail bdServiceChargeDetail : serviceChargeVo.getServiceChargeDetailsList()) {
bdServiceChargeDetail.setPkServiceCharge(bdServiceCharge.getPkId());
}
serviceChargeDetailService.saveBatch(serviceChargeVo.getServiceChargeDetailsList());
iBdServiceChargeDetailService.saveBatch(serviceChargeVo.getServiceChargeDetailsList());
}
/**
* 删除
*
* @param pkServiceCharge
*/
@Override
@Transactional(rollbackFor = Exception.class)
public void deleteServiceCharge(Long pkServiceCharge) {
serviceChargeService.removeById(pkServiceCharge);
UpdateWrapper<BdServiceChargeDetail> updateWrapper =new UpdateWrapper<>();
updateWrapper.eq("PK_SERVICE_CHARGE",pkServiceCharge);
serviceChargeDetailService.remove(updateWrapper);
iBdServiceChargeService.removeById(pkServiceCharge);
UpdateWrapper<BdServiceChargeDetail> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("PK_SERVICE_CHARGE", pkServiceCharge);
iBdServiceChargeDetailService.remove(updateWrapper);
}
/**
* 查询详情
*
* @param pkServiceCharge
* @return
*/
@Override
public ServiceChargeVo getServiceCharge(Long pkServiceCharge) {
// String redisKey = CacheConstants.BD_AREA_CLASSIFY + pkServiceCharge;
// ServiceChargeVo sv = redisService.getCacheObject(redisKey);
//if (sv == null) {
BdServiceCharge serviceCharge = serviceChargeService.getById(pkServiceCharge);
ServiceChargeVo serviceChargeVo = BeanUtil.copyProperties(serviceCharge, ServiceChargeVo.class);
serviceChargeVo.setPkServiceCharge(serviceCharge.getPkId());
QueryWrapper<BdServiceChargeDetail> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("PK_SERVICE_CHARGE", serviceCharge.getPkId());
List<BdServiceChargeDetail> serviceChargeDetailsList = serviceChargeDetailService.list(queryWrapper);
serviceChargeVo.setServiceChargeDetailsList(serviceChargeDetailsList);
// sv = serviceChargeVo;
// }
BdServiceCharge serviceCharge = iBdServiceChargeService.getById(pkServiceCharge);
ServiceChargeVo serviceChargeVo = BeanUtil.copyProperties(serviceCharge, ServiceChargeVo.class);
serviceChargeVo.setPkServiceCharge(serviceCharge.getPkId());
QueryWrapper<BdServiceChargeDetail> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("PK_SERVICE_CHARGE", serviceCharge.getPkId());
List<BdServiceChargeDetail> serviceChargeDetailsList = iBdServiceChargeDetailService.list(queryWrapper);
serviceChargeVo.setServiceChargeDetailsList(serviceChargeDetailsList);
return serviceChargeVo;
}
/**
* @description: 根据业务类型查询扣费
* @author: zhang jing
* @date: 2023/1/7 14:50
* @param: [serviceChargeVo]
* @return: com.hzs.system.config.vo.ServiceChargeVo
**/
@Override
public ServiceChargeDTO getServiceChargeByType(ServiceChargeDTO serviceChargeDTO) {
return baseMapper.getServiceChargeByType(serviceChargeDTO);
}
/**
* 查询列表
* @param serviceCharge
* @return
*/
@Override
public List<ServiceChargeVo> selectByList(BdServiceCharge serviceCharge) {
return baseMapper.selectByList(serviceCharge);

Some files were not shown because too many files have changed in this diff Show More