code
stringlengths 1
1.05M
| repo_name
stringlengths 6
83
| path
stringlengths 3
242
| language
stringclasses 222
values | license
stringclasses 20
values | size
int64 1
1.05M
|
|---|---|---|---|---|---|
package zack.project.domain.award.adapter.repository;
import zack.project.domain.award.model.aggregate.GiveOutPrizesAggregate;
import zack.project.domain.award.model.aggregate.UserAwardRecordAggregate;
/**
* @author A1793
*/
public interface IAwardRepository {
void saveUserAwardRecord(UserAwardRecordAggregate userAwardRecordAggregate);
void saveGiveOutPrizesAggregate(GiveOutPrizesAggregate giveOutPrizesAggregate);
String queryAwardKey(Integer awardId);
String queryAwardConfig(Integer awardId);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/award/adapter/repository/IAwardRepository.java
|
Java
|
unknown
| 524
|
package zack.project.domain.award.event;
import zack.project.types.event.BaseEvent;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.RandomStringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import java.util.Date;
/**
* @author A1793
* 注意：只有注解service可以通过value注解在yml中获取值，并且在使用的时候不可以new该对象否则获取不到注入的值
*/
@Service
public class SendAwardMessageEvent extends BaseEvent<SendAwardMessageEvent.SendAwardMessage> {
@Value("${spring.rabbitmq.topic.send_award}")
private String topic;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public static class SendAwardMessage{
/**
* 用户ID
*/
private String userId;
/**
* 奖品ID
*/
private Integer awardId;
/**
* 奖品标题（名称）
*/
private String awardTitle;
private String awardConfig;
private String orderId;
}
@Override
public EventMessage<SendAwardMessage> buildEventMessage(SendAwardMessage data) {
return EventMessage.<SendAwardMessage>builder().
data(data).
id(RandomStringUtils.randomNumeric(11)).
timestamp(new Date()).
build();
}
@Override
public String topic() {
return topic;
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/award/event/SendAwardMessageEvent.java
|
Java
|
unknown
| 1,556
|
package zack.project.domain.award.model.aggregate;
import zack.project.domain.award.model.entity.UserAwardRecordEntity;
import zack.project.domain.award.model.entity.UserCreditAwardEntity;
import zack.project.domain.award.model.valobj.AwardStateVO;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
/**
* @author A1793
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class GiveOutPrizesAggregate {
private String userId;
private UserAwardRecordEntity userAwardRecord;
private UserCreditAwardEntity userCreditAwardEntity;
public static UserAwardRecordEntity buildUserAwardRecordEntity(String userId, String orderId, Integer awardId, AwardStateVO state) {
UserAwardRecordEntity userAwardRecordEntity = new UserAwardRecordEntity();
userAwardRecordEntity.setUserId(userId);
userAwardRecordEntity.setOrderId(orderId);
userAwardRecordEntity.setAwardId(awardId);
userAwardRecordEntity.setAwardState(state);
return userAwardRecordEntity;
}
public static UserCreditAwardEntity buildUserCreditAwardEntity(String userId, BigDecimal creditAmount) {
UserCreditAwardEntity userCreditAwardEntity = new UserCreditAwardEntity();
userCreditAwardEntity.setCreditAmount(creditAmount);
userCreditAwardEntity.setUserId(userId);
return userCreditAwardEntity;
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/award/model/aggregate/GiveOutPrizesAggregate.java
|
Java
|
unknown
| 1,465
|
package zack.project.domain.award.model.aggregate;
import zack.project.domain.award.model.entity.TaskEntity;
import zack.project.domain.award.model.entity.UserAwardRecordEntity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author A1793
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class UserAwardRecordAggregate {
private UserAwardRecordEntity userAwardRecordEntity;
private TaskEntity taskEntity;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/award/model/aggregate/UserAwardRecordAggregate.java
|
Java
|
unknown
| 504
|
package zack.project.domain.award.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author A1793
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class DistributeAwardEntity {
private String userId;
private String orderId;
private Integer awardId;
private String awardConfig;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/award/model/entity/DistributeAwardEntity.java
|
Java
|
unknown
| 399
|
package zack.project.domain.award.model.entity;
import zack.project.domain.award.event.SendAwardMessageEvent;
import zack.project.domain.award.model.valobj.TaskStateVO;
import zack.project.types.event.BaseEvent;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class TaskEntity {
/** 活动ID */
private String userId;
/** 消息主题 */
private String topic;
/** 消息编号 */
private String messageId;
/** 消息主体 */
private BaseEvent.EventMessage<SendAwardMessageEvent.SendAwardMessage> message;
/** 任务状态；create-创建、completed-完成、fail-失败 */
private TaskStateVO state;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/award/model/entity/TaskEntity.java
|
Java
|
unknown
| 771
|
package zack.project.domain.award.model.entity;
import zack.project.domain.award.model.valobj.AwardStateVO;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**用户中奖记录
* @author A1793
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class UserAwardRecordEntity {
/** 用户ID */
private String userId;
/** 活动ID */
private Long activityId;
/** 抽奖策略ID */
private Long strategyId;
/** 抽奖订单ID【作为幂等使用】 */
private String orderId;
/** 奖品ID */
private Integer awardId;
/** 奖品标题（名称） */
private String awardTitle;
/** 中奖时间 */
private Date awardTime;
/** 奖品状态；create-创建、completed-发奖完成 */
private AwardStateVO awardState;
/** 奖励配置*/
private String awardConfig;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/award/model/entity/UserAwardRecordEntity.java
|
Java
|
unknown
| 936
|
package zack.project.domain.award.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class UserCreditAwardEntity {
private String userId;
private BigDecimal creditAmount;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/award/model/entity/UserCreditAwardEntity.java
|
Java
|
unknown
| 352
|
package zack.project.domain.award.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
/**
* @author A1793
*/
@Getter
@AllArgsConstructor
@NoArgsConstructor
public enum AccountStatusVO {
open("open", "开启"),
close("close", "冻结"),
;
private String code;
private String desc;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/award/model/valobj/AccountStatusVO.java
|
Java
|
unknown
| 361
|
package zack.project.domain.award.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* @author A1793
*/
@Getter
@AllArgsConstructor
public enum AwardStateVO {
create("create", "创建"),
complete("complete", "发奖完成"),
fail("fail", "发奖失败"),
;
private final String code;
private final String desc;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/award/model/valobj/AwardStateVO.java
|
Java
|
unknown
| 367
|
package zack.project.domain.award.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* @author A1793
*/
@Getter
@AllArgsConstructor
public enum TaskStateVO {
create("create", "创建"),
complete("complete", "发送完成"),
fail("fail", "发送失败"),
;
private final String code;
private final String desc;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/award/model/valobj/TaskStateVO.java
|
Java
|
unknown
| 364
|
package zack.project.domain.award.service;
import zack.project.domain.award.adapter.repository.IAwardRepository;
import zack.project.domain.award.model.aggregate.UserAwardRecordAggregate;
import zack.project.domain.award.event.SendAwardMessageEvent;
import zack.project.domain.award.model.entity.DistributeAwardEntity;
import zack.project.domain.award.model.entity.TaskEntity;
import zack.project.domain.award.model.entity.UserAwardRecordEntity;
import zack.project.domain.award.model.valobj.TaskStateVO;
import zack.project.domain.award.service.distribute.IDistributeAward;
import zack.project.types.event.BaseEvent;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import java.util.Map;
/**
* @author A1793
*/
@Slf4j
@Service
public class AwardService implements IAwardService {
private final IAwardRepository awardRepository;
private final SendAwardMessageEvent sendAwardMessageEvent;
//策略模式, <节点名,发奖节点>
private final Map<String, IDistributeAward> distributeAwardMap;
public AwardService(IAwardRepository awardRepository, SendAwardMessageEvent sendAwardMessageEvent, Map<String, IDistributeAward> distributeAwardMap) {
this.awardRepository = awardRepository;
this.sendAwardMessageEvent = sendAwardMessageEvent;
this.distributeAwardMap = distributeAwardMap;
}
/**
* 构建发奖的补偿任务，保存中奖记录{user_raffle_record}，更新用户抽奖单
* @param userAwardRecordEntity
*/
@Override
public void saveUserAwardRecord(UserAwardRecordEntity userAwardRecordEntity) {
//先生成消息的内容,设置奖品信息和抽奖单单号
SendAwardMessageEvent.SendAwardMessage sendAwardMessage = new SendAwardMessageEvent.SendAwardMessage();
sendAwardMessage.setAwardId(userAwardRecordEntity.getAwardId());
sendAwardMessage.setUserId(userAwardRecordEntity.getUserId());
sendAwardMessage.setAwardTitle(userAwardRecordEntity.getAwardTitle());
sendAwardMessage.setOrderId(userAwardRecordEntity.getOrderId());
sendAwardMessage.setAwardConfig(userAwardRecordEntity.getAwardConfig());
//通过消息事件来构建统一的消息体，均为BaseEvent.EventMessage<T>的消息内容，{int code，String info，T data}
BaseEvent.EventMessage<SendAwardMessageEvent.SendAwardMessage> sendAwardMessageEventMessage =
sendAwardMessageEvent.buildEventMessage(sendAwardMessage);
//创建任务实体，因为是发奖模块，
// 所以message类型就是BaseEvent.EventMessage<SendAwardMessageEvent.SendAwardMessage>
TaskEntity taskEntity = new TaskEntity();
taskEntity.setUserId(userAwardRecordEntity.getUserId());
taskEntity.setTopic(sendAwardMessageEvent.topic());
taskEntity.setMessage(sendAwardMessageEventMessage);
taskEntity.setMessageId(sendAwardMessageEventMessage.getId());
taskEntity.setState(TaskStateVO.create);
//创建中奖的聚合实体传递给仓储层做事务操作，保存奖品信息和发奖任务
UserAwardRecordAggregate userAwardRecordAggregate = new UserAwardRecordAggregate();
userAwardRecordAggregate.setUserAwardRecordEntity(userAwardRecordEntity);
userAwardRecordAggregate.setTaskEntity(taskEntity);
//保存中奖记录(更新数据库表{user_raffle_award})和发奖的任务(该任务是为了防止本方法中发送消息失败的补偿任务，更新数据库表{task})，
//更新抽奖单状态为used(更新库表{user_raffle_order}) 并 向SendAwardCustomer监听的消息队列投入发奖消息
awardRepository.saveUserAwardRecord(userAwardRecordAggregate);
log.info("中奖记录保存完成 userId:{} orderId:{}", userAwardRecordEntity.getUserId(), userAwardRecordEntity.getOrderId());
}
@Override
public void distributeAward(DistributeAwardEntity distributeAwardEntity) {
//查询奖品id去数据库表{award}查询对应奖品awardKey
//id award_id award_key award_value award_desc
//1 101 user_credit_random 1,100 用户积分【优先透彻规则范围，如果没有则走配置】 2023-12-09 11:07:06 2023-12-09 11:21:31
//2 102 openai_use_count 5 OpenAI 增加使用次数 2023-12-09 11:07:06 2023-12-09 11:12:59
//3 103 openai_use_count 10 OpenAI 增加使用次数 2023-12-09 11:07:06 2023-12-09 11:12:59
String awardKey =
awardRepository.queryAwardKey(distributeAwardEntity.getAwardId());
if (StringUtils.isBlank(awardKey)) {
log.error("分发奖品，奖品ID不存在。awardKey:{}", awardKey);
return;
}
//根据这个奖品key去找对应的发奖节点
IDistributeAward iDistributeAward = distributeAwardMap.get(awardKey);
if (iDistributeAward == null) {
log.error("分发奖品，对应的服务不存在。awardKey:{}", awardKey);
throw new RuntimeException("分发奖品，奖品" + awardKey + "对应的服务不存在");
}
//发奖节点执行发奖流程
iDistributeAward.giveOutPrize(distributeAwardEntity);
}
@Override
public String queryAwardConfig(Integer awardId) {
return awardRepository.queryAwardConfig(awardId);
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/award/service/AwardService.java
|
Java
|
unknown
| 5,499
|
package zack.project.domain.award.service;
import zack.project.domain.award.model.entity.DistributeAwardEntity;
import zack.project.domain.award.model.entity.UserAwardRecordEntity;
/**
* @author A1793
*/
public interface IAwardService {
/**
* 保存中奖记录(更新数据库表{user_raffle_award})和发奖的任务(该任务是为了防止本方法中发送消息失败的补偿任务，更新数据库表{task})，
* 更新抽奖单状态为used(更新库表{user_raffle_order}) 并 向SendAwardCustomer监听的消息队列投入发奖消息
* @param userAwardRecordEntity
*/
void saveUserAwardRecord(UserAwardRecordEntity userAwardRecordEntity);
void distributeAward(DistributeAwardEntity distributeAwardEntity);
String queryAwardConfig(Integer awardId);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/award/service/IAwardService.java
|
Java
|
unknown
| 807
|
package zack.project.domain.award.service.distribute;
import zack.project.domain.award.model.entity.DistributeAwardEntity;
/**
* @author A1793
*/
public interface IDistributeAward {
void giveOutPrize(DistributeAwardEntity distributeAward);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/award/service/distribute/IDistributeAward.java
|
Java
|
unknown
| 253
|
package zack.project.domain.award.service.distribute.impl;
import zack.project.domain.award.adapter.repository.IAwardRepository;
import zack.project.domain.award.model.aggregate.GiveOutPrizesAggregate;
import zack.project.domain.award.model.entity.DistributeAwardEntity;
import zack.project.domain.award.model.entity.UserAwardRecordEntity;
import zack.project.domain.award.model.entity.UserCreditAwardEntity;
import zack.project.domain.award.model.valobj.AwardStateVO;
import zack.project.domain.award.service.distribute.IDistributeAward;
import zack.project.types.common.Constants;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.MathContext;
/**积分奖品的发奖节点
* @author A1793
*/
@Component("user_credit_random")
public class UserCreditRandomAward implements IDistributeAward {
@Resource
private IAwardRepository awardRepository;
@Override
public void giveOutPrize(DistributeAwardEntity distributeAward) {
//获得奖品配置
String awardConfig = distributeAward.getAwardConfig();
Integer awardId = distributeAward.getAwardId();
if( StringUtils.isBlank(awardConfig)) {
awardConfig = awardRepository.queryAwardConfig(awardId);
}
String[] split = awardConfig.split(Constants.SPLIT);
if(split.length != 2) {
throw new RuntimeException("award_config 「" + awardConfig + "」配置不是一个范围值，如 1,100");
}
//获取配置的积分范围之间的一个随机值
BigDecimal creditAmount = generateRandom(new BigDecimal(split[0]),new BigDecimal(split[1]));
//构建用户积分奖品实体
UserCreditAwardEntity userCreditAwardEntity = GiveOutPrizesAggregate.
buildUserCreditAwardEntity(distributeAward.getUserId(), creditAmount);
//根据奖品id和抽奖单id构建用户中奖记录实体，
// 该中奖记录在数据库表{user_raffle_award}中存在，本次操作要将该记录的状态改为completed
UserAwardRecordEntity userAwardRecordEntity = GiveOutPrizesAggregate.
buildUserAwardRecordEntity(distributeAward.getUserId(), distributeAward.getOrderId(), distributeAward.getAwardId(), AwardStateVO.complete);
GiveOutPrizesAggregate giveOutPrizesAggregate = new GiveOutPrizesAggregate();
giveOutPrizesAggregate.setUserCreditAwardEntity(userCreditAwardEntity);
giveOutPrizesAggregate.setUserAwardRecord(userAwardRecordEntity);
giveOutPrizesAggregate.setUserId(distributeAward.getUserId());
//
awardRepository.saveGiveOutPrizesAggregate(giveOutPrizesAggregate);
}
private BigDecimal generateRandom(BigDecimal min, BigDecimal max) {
if (min.equals(max)) {
return min;
}
BigDecimal randomBigDecimal = min.add(BigDecimal.valueOf(Math.random()).multiply(max.subtract(min)));
return randomBigDecimal.round(new MathContext(3));
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/award/service/distribute/impl/UserCreditRandomAward.java
|
Java
|
unknown
| 3,091
|
package zack.project.domain.credit.adapter.repository;
import zack.project.domain.credit.model.aggregate.TradeAggregate;
import zack.project.domain.credit.model.entity.CreditAccountEntity;
/**
* @author A1793
*/
public interface ICreditRepository {
void saveUserCreditTradeOrder(TradeAggregate tradeAggregate);
CreditAccountEntity queryUserCreditAccount(String userId);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/credit/adapter/repository/ICreditRepository.java
|
Java
|
unknown
| 387
|
package zack.project.domain.credit.event;
import zack.project.types.event.BaseEvent;
import lombok.*;
import org.apache.commons.lang3.RandomStringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.util.Date;
@Component
public class CreditAdjustSuccessMessageEvent extends
BaseEvent<CreditAdjustSuccessMessageEvent.CreditAdjustSuccessMessage> {
@Value("${spring.rabbitmq.topic.credit_adjust_success}")
private String topic;
@Override
public EventMessage<CreditAdjustSuccessMessage> buildEventMessage(CreditAdjustSuccessMessage data) {
return EventMessage.<CreditAdjustSuccessMessage>builder()
.timestamp(new Date())
.data(data)
.id(RandomStringUtils.randomNumeric(11))
.build();
}
@Override
public String topic() {
return topic;
}
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public static class CreditAdjustSuccessMessage{
/**
* 用户ID
*/
private String userId;
/**
* 订单ID
*/
private String orderId;
/**
* 交易金额
*/
private BigDecimal amount;
/**
* 业务仿重ID - 外部透传。返利、行为等唯一标识
*/
private String outBusinessNo;
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/credit/event/CreditAdjustSuccessMessageEvent.java
|
Java
|
unknown
| 1,467
|
package zack.project.domain.credit.model.aggregate;
import zack.project.domain.award.model.valobj.TaskStateVO;
import zack.project.domain.credit.event.CreditAdjustSuccessMessageEvent;
import zack.project.domain.credit.model.entity.CreditAccountEntity;
import zack.project.domain.credit.model.entity.CreditOrderEntity;
import zack.project.domain.credit.model.entity.TaskEntity;
import zack.project.domain.credit.model.valobj.TradeNameVO;
import zack.project.domain.credit.model.valobj.TradeTypeVO;
import zack.project.types.event.BaseEvent;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.RandomStringUtils;
import java.math.BigDecimal;
/**
* @author A1793
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class TradeAggregate {
private String userId;
private CreditAccountEntity accountEntity;
private CreditOrderEntity orderEntity;
private TaskEntity taskEntity;
public static CreditAccountEntity buildCreditAccountEntity(String userId, BigDecimal amount) {
return CreditAccountEntity.builder()
.adjustAmount(amount)
.userId(userId)
.build();
}
public static CreditOrderEntity buildCreditOrderEntity(String userId, BigDecimal amount, TradeNameVO tradeName, TradeTypeVO tradeType, String outBusinessNo) {
return CreditOrderEntity.builder()
.userId(userId)
.tradeAmount(amount)
.tradeName(tradeName)
.tradeType(tradeType)
.orderId(RandomStringUtils.randomNumeric(12))
.outBusinessNo(outBusinessNo)
.build();
}
public static TaskEntity buildTaskEntity(String userId,String topic, String messageId, BaseEvent.EventMessage<CreditAdjustSuccessMessageEvent.CreditAdjustSuccessMessage> message) {
return TaskEntity.builder()
.topic(topic)
.message(message)
.messageId(messageId)
.userId(userId)
.state(TaskStateVO.create)
.build();
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/credit/model/aggregate/TradeAggregate.java
|
Java
|
unknown
| 2,171
|
package zack.project.domain.credit.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
/**
* @author A1793
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CreditAccountEntity {
/** 用户ID */
private String userId;
/** 可用积分，每次扣减的值 */
private BigDecimal adjustAmount;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/credit/model/entity/CreditAccountEntity.java
|
Java
|
unknown
| 438
|
package zack.project.domain.credit.model.entity;
import zack.project.domain.credit.model.valobj.TradeNameVO;
import zack.project.domain.credit.model.valobj.TradeTypeVO;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
/**
* @author A1793
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class CreditOrderEntity {
/** 用户ID */
private String userId;
/** 订单ID */
private String orderId;
/** 交易名称 行为返利/兑换抽奖*/
private TradeNameVO tradeName;
/** 交易类型；交易类型；forward-正向、reverse-逆向 */
private TradeTypeVO tradeType;
/** 交易金额 (要增加或扣减的积分)*/
private BigDecimal tradeAmount;
/** 业务仿重ID - 外部透传。返利、行为等唯一标识 */
private String outBusinessNo;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/credit/model/entity/CreditOrderEntity.java
|
Java
|
unknown
| 915
|
package zack.project.domain.credit.model.entity;
import zack.project.domain.award.model.valobj.TaskStateVO;
import zack.project.domain.credit.event.CreditAdjustSuccessMessageEvent;
import zack.project.types.event.BaseEvent;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class TaskEntity {
/** 活动ID */
private String userId;
/** 消息主题 */
private String topic;
/** 消息编号 */
private String messageId;
/** 消息主体 */
private BaseEvent.EventMessage<CreditAdjustSuccessMessageEvent.CreditAdjustSuccessMessage> message;
/** 任务状态；create-创建、completed-完成、fail-失败 */
private TaskStateVO state;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/credit/model/entity/TaskEntity.java
|
Java
|
unknown
| 800
|
package zack.project.domain.credit.model.entity;
import zack.project.domain.credit.model.valobj.TradeNameVO;
import zack.project.domain.credit.model.valobj.TradeTypeVO;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
/**
* @author A1793
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class TradeEntity {
private String userId;
private String outBusinessNo;
private BigDecimal amount;
private TradeNameVO tradeNameVO;
private TradeTypeVO tradeTypeVO;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/credit/model/entity/TradeEntity.java
|
Java
|
unknown
| 591
|
package zack.project.domain.credit.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public enum TradeNameVO {
REBATE("行为返利"),
CONVERT_SKU("兑换抽奖"),
;
private final String name;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/credit/model/valobj/TradeNameVO.java
|
Java
|
unknown
| 272
|
package zack.project.domain.credit.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* @author A1793
*/
@Getter
@AllArgsConstructor
public enum TradeTypeVO {
FORWARD("forward", "正向交易，+ 积分"),
REVERSE("reverse", "逆向交易，- 积分"),
;
private final String code;
private final String info;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/credit/model/valobj/TradeTypeVO.java
|
Java
|
unknown
| 370
|
package zack.project.domain.credit.service;
import zack.project.domain.credit.model.entity.CreditAccountEntity;
import zack.project.domain.credit.model.entity.TradeEntity;
/**用户积分调整调整
* @author A1793
*/
public interface ICreditAdjustService {
String createOrder(TradeEntity tradeEntity);
CreditAccountEntity queryUserCreditAccount(String userId);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/credit/service/ICreditAdjustService.java
|
Java
|
unknown
| 380
|
package zack.project.domain.credit.service.adjust;
import zack.project.domain.credit.adapter.repository.ICreditRepository;
import zack.project.domain.credit.event.CreditAdjustSuccessMessageEvent;
import zack.project.domain.credit.model.aggregate.TradeAggregate;
import zack.project.domain.credit.model.entity.CreditAccountEntity;
import zack.project.domain.credit.model.entity.CreditOrderEntity;
import zack.project.domain.credit.model.entity.TaskEntity;
import zack.project.domain.credit.model.entity.TradeEntity;
import zack.project.domain.credit.service.ICreditAdjustService;
import zack.project.types.event.BaseEvent;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class CreditAdjustService implements ICreditAdjustService {
@Resource
ICreditRepository creditRepository;
@Resource
CreditAdjustSuccessMessageEvent creditAdjustSuccessMessageEvent;
/**
* 根据交易实体对象
* @param tradeEntity
* @return
*/
@Override
public String createOrder(TradeEntity tradeEntity) {
//构建用户积分实体，设置积分的变更量
CreditAccountEntity creditAccountEntity = TradeAggregate
.buildCreditAccountEntity(tradeEntity.getUserId(), tradeEntity.getAmount());
//构建积分订单实体
//id user_id order_id trade_name trade_type trade_amount out_business_no
//1 xiaofuge25 479481818661 行为返利 forward 10.00 xiaofuge25_integral_20240622 2024-06-22 10:07:41 2024-06-22 10:07:41
//2 xiaofuge25 981030218405 兑换抽奖 reverse -20.00 404066146511 2024-06-22 10:11:50 2024-06-22 10:11:50
CreditOrderEntity creditOrderEntity = TradeAggregate.buildCreditOrderEntity(
tradeEntity.getUserId(),
tradeEntity.getAmount(),
tradeEntity.getTradeNameVO(),
tradeEntity.getTradeTypeVO(),
tradeEntity.getOutBusinessNo()
);
//构建积分调整消息内容,
// 要包含积分调额订单的订单号(user_credit_order)，外部订单号(如果是积分兑换此处则是未支付的活动单号)
CreditAdjustSuccessMessageEvent.CreditAdjustSuccessMessage creditAdjustSuccessMessage =
new CreditAdjustSuccessMessageEvent.CreditAdjustSuccessMessage();
creditAdjustSuccessMessage.setOrderId(creditOrderEntity.getOrderId());
creditAdjustSuccessMessage.setAmount(tradeEntity.getAmount());
creditAdjustSuccessMessage.setOutBusinessNo(tradeEntity.getOutBusinessNo());
creditAdjustSuccessMessage.setUserId(tradeEntity.getUserId());
//构建积分调整消息
BaseEvent.EventMessage<CreditAdjustSuccessMessageEvent.CreditAdjustSuccessMessage> creditAdjustSuccessMessageEventMessage =
creditAdjustSuccessMessageEvent.buildEventMessage(creditAdjustSuccessMessage);
//构建积分调整补偿任务
TaskEntity taskEntity =
TradeAggregate.buildTaskEntity(tradeEntity.getUserId(),
creditAdjustSuccessMessageEvent.topic(),
creditAdjustSuccessMessageEventMessage.getId(),
creditAdjustSuccessMessageEventMessage);
//构建交易聚合实体:积分账户(要修改的amount)，积分订单，补偿任务
TradeAggregate tradeAggregate = new TradeAggregate();
tradeAggregate.setUserId(tradeEntity.getUserId());
tradeAggregate.setOrderEntity(creditOrderEntity);
tradeAggregate.setAccountEntity(creditAccountEntity);
tradeAggregate.setTaskEntity(taskEntity);
creditRepository.saveUserCreditTradeOrder(tradeAggregate);
log.info("变更账户积分额度完成 userId:{} orderId:{}", tradeEntity.getUserId(), creditOrderEntity.getOrderId());
return creditOrderEntity.getOrderId();
}
@Override
public CreditAccountEntity queryUserCreditAccount(String userId) {
return creditRepository.queryUserCreditAccount(userId);
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/credit/service/adjust/CreditAdjustService.java
|
Java
|
unknown
| 4,169
|
package zack.project.domain.rebate.adapter.repository;
import zack.project.domain.rebate.model.aggregate.BehaviorRebateAggregate;
import zack.project.domain.rebate.model.entity.BehaviorRebateOrderEntity;
import zack.project.domain.rebate.model.valobj.BehaviorTypeVO;
import zack.project.domain.rebate.model.valobj.DailyBehaviorRebateVO;
import java.util.List;
/**
* @author A1793
*/
public interface IBehaviorRebateRepository {
List<DailyBehaviorRebateVO> queryDailyBehaviorRebateConfig(BehaviorTypeVO behaviorTypeVO);
void saveUserRebateRecord(String userId, List<BehaviorRebateAggregate> behaviorRebateAggregates);
List<BehaviorRebateOrderEntity> queryOrderByOutBusinessNo(String userId, String outBusinessNo);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/rebate/adapter/repository/IBehaviorRebateRepository.java
|
Java
|
unknown
| 736
|
package zack.project.domain.rebate.event;
import zack.project.types.event.BaseEvent;
import lombok.*;
import org.apache.commons.lang3.RandomStringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.util.Date;
@Component
public class SendRebateMessageEvent extends BaseEvent<SendRebateMessageEvent.RebateMessage> {
@Value("${spring.rabbitmq.topic.send_rebate}")
private String topic;
@Override
public String topic() {
return topic;
}
@Override
public EventMessage<RebateMessage> buildEventMessage(RebateMessage data) {
return EventMessage.<RebateMessage>builder().
id(RandomStringUtils.randomNumeric(11)).
timestamp(new Date()).
data(data).
build();
}
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public static class RebateMessage{
/** 用户ID */
private String userId;
/** 返利描述 */
private String rebateDesc;
/** 返利类型 */
private String rebateType;
/** 返利配置 */
private String rebateConfig;
/** 业务ID - 唯一ID，确保幂等 */
private String bizId;
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/rebate/event/SendRebateMessageEvent.java
|
Java
|
unknown
| 1,288
|
package zack.project.domain.rebate.model.aggregate;
import zack.project.domain.rebate.model.entity.BehaviorRebateOrderEntity;
import zack.project.domain.rebate.model.entity.TaskEntity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author A1793
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class BehaviorRebateAggregate {
private String userId;
private BehaviorRebateOrderEntity behaviorRebateOrderEntity;
private TaskEntity taskEntity;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/rebate/model/aggregate/BehaviorRebateAggregate.java
|
Java
|
unknown
| 545
|
package zack.project.domain.rebate.model.entity;
import zack.project.domain.rebate.model.valobj.BehaviorTypeVO;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author A1793
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class BehaviorEntity {
/**
* 用户ID
*/
private String userId;
/**
* 行为类型；sign 签到、openai_pay 支付
*/
private BehaviorTypeVO behaviorTypeVO;
/**
* 业务ID；签到则是日期字符串，支付则是外部的业务ID
*/
private String outBusinessNo;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/rebate/model/entity/BehaviorEntity.java
|
Java
|
unknown
| 637
|
package zack.project.domain.rebate.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author A1793
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class BehaviorRebateOrderEntity {
private String userId;
/**
* 订单ID
*/
private String orderId;
private String behaviorType;
/**
* 返利描述
*/
private String rebateDesc;
/**
* 返利类型（sku 活动库存充值商品、integral 用户活动积分）
*/
private String rebateType;
/**
* 返利配置
*/
private String rebateConfig;
/** 业务仿重ID - 外部透传，方便查询使用 */
private String outBusinessNo;
private String bizId;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/rebate/model/entity/BehaviorRebateOrderEntity.java
|
Java
|
unknown
| 799
|
package zack.project.domain.rebate.model.entity;
import zack.project.domain.rebate.event.SendRebateMessageEvent;
import zack.project.domain.rebate.model.valobj.TaskStateVO;
import zack.project.types.event.BaseEvent;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class TaskEntity {
private String userId;
private String topic;
private String messageId;
private BaseEvent.EventMessage<SendRebateMessageEvent.RebateMessage> message;
private TaskStateVO state;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/rebate/model/entity/TaskEntity.java
|
Java
|
unknown
| 613
|
package zack.project.domain.rebate.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 行为类型值
*
* @author A1793
*/
@Getter
@AllArgsConstructor
public enum BehaviorTypeVO {
SIGN("sign", "签到（日历）"),
OPENAI_PAY("openai_pay", "openai 外部支付完成"),
GROUP("group", "拼团完成");
private final String code;
private final String info;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/rebate/model/valobj/BehaviorTypeVO.java
|
Java
|
unknown
| 412
|
package zack.project.domain.rebate.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Getter
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class DailyBehaviorRebateVO {
/**
* 行为类型（sign 签到、openai_pay 支付）
*/
private String behaviorType;
/**
* 返利描述
*/
private String rebateDesc;
/**
* 返利类型（sku 活动库存充值商品、integral 用户活动积分）
*/
private String rebateType;
/**
* 返利配置
*/
private String rebateConfig;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/rebate/model/valobj/DailyBehaviorRebateVO.java
|
Java
|
unknown
| 634
|
package zack.project.domain.rebate.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**返利类型
* @author A1793
*/
@Getter
@AllArgsConstructor
public enum RebateTypeVO {
SKU("sku", "活动库存充值商品"),
INTEGRAL("integral", "用户活动积分"),
;
private final String code;
private final String info;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/rebate/model/valobj/RebateTypeVO.java
|
Java
|
unknown
| 366
|
package zack.project.domain.rebate.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**任务状态
* @author A1793
*/
@Getter
@AllArgsConstructor
public enum TaskStateVO {
create("create", "创建"),
complete("complete", "发送完成"),
fail("fail", "发送失败"),
;
private final String code;
private final String desc;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/rebate/model/valobj/TaskStateVO.java
|
Java
|
unknown
| 380
|
package zack.project.domain.rebate.service;
import zack.project.domain.rebate.adapter.repository.IBehaviorRebateRepository;
import zack.project.domain.rebate.event.SendRebateMessageEvent;
import zack.project.domain.rebate.model.aggregate.BehaviorRebateAggregate;
import zack.project.domain.rebate.model.entity.BehaviorEntity;
import zack.project.domain.rebate.model.entity.BehaviorRebateOrderEntity;
import zack.project.domain.rebate.model.entity.TaskEntity;
import zack.project.domain.rebate.model.valobj.DailyBehaviorRebateVO;
import zack.project.domain.rebate.model.valobj.TaskStateVO;
import zack.project.types.common.Constants;
import zack.project.types.event.BaseEvent;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.RandomStringUtils;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
/**
* @author A1793
*/
@Service
@Slf4j
public class BehaviorRebateService implements IBehaviorRebateService {
@Resource
private IBehaviorRebateRepository behaviorRebateRepository;
@Resource
private SendRebateMessageEvent sendRebateMessageEvent;
@Override
public List<String> createOrder(BehaviorEntity behaviorEntity) {
//获取所有的返利
// id behavior_type rebate_desc rebate_type rebate_config state
// 1 sign 签到返利-sku额度 sku 9014 open 2024-04-30 09:32:46 2024-06-22 09:52:39
// 2 sign 签到返利-积分 integral 10 open 2024-04-30 09:32:46 2024-04-30 18:05:27
//同一个行为类型下可能会由多种返利配置，一种返利配置就对应生成一种返利单
//根据行为实体对象的行为类型查询数据库表{daily_behavior_rebate}获取行为返利配置(行为类型，返利类型，返利值，返利描述)
List<DailyBehaviorRebateVO> dailyBehaviorRebateVOS = behaviorRebateRepository.
queryDailyBehaviorRebateConfig(behaviorEntity.getBehaviorTypeVO());
if (dailyBehaviorRebateVOS == null || dailyBehaviorRebateVOS.isEmpty()) {
return new ArrayList<>();
}
//根据所有行为的返利构建聚合对象,返利订单和task任务表同一事务操作
//创建返利单的单号列表
List<String> orderIds = new ArrayList<>();
List<BehaviorRebateAggregate> behaviorRebateAggregates = new ArrayList<>();
log.info("开始构建用户行为返利单 userId:{}", behaviorEntity.getUserId());
//一种返利配置对应一个补偿任务
for (DailyBehaviorRebateVO dailyBehaviorRebateVO : dailyBehaviorRebateVOS) {
//用户id+返利类型+外部单号(签到日期)
String bizId = behaviorEntity.getUserId() +
Constants.UNDERLINE +
dailyBehaviorRebateVO.getBehaviorType() +
Constants.UNDERLINE +
dailyBehaviorRebateVO.getRebateType() +
Constants.UNDERLINE +
//此处是日期或者是外部rpc调用传入的外部单号
behaviorEntity.getOutBusinessNo();
//构建返利单{behavior_rebate_order}
BehaviorRebateOrderEntity behaviorRebateOrderEntity =
BehaviorRebateOrderEntity.builder()
.userId(behaviorEntity.getUserId())
.orderId(RandomStringUtils.randomNumeric(12))
.bizId(bizId)
.behaviorType(dailyBehaviorRebateVO.getBehaviorType())
.rebateDesc(dailyBehaviorRebateVO.getRebateDesc())
.rebateType(dailyBehaviorRebateVO.getRebateType())
.rebateConfig(dailyBehaviorRebateVO.getRebateConfig())
.outBusinessNo(behaviorEntity.getOutBusinessNo())
.build();
//构建返利消息内容
SendRebateMessageEvent.RebateMessage rebateMessage =
new SendRebateMessageEvent.RebateMessage();
rebateMessage.setUserId(behaviorEntity.getUserId());
rebateMessage.setBizId(bizId);
rebateMessage.setRebateType(dailyBehaviorRebateVO.getRebateType());
rebateMessage.setRebateConfig(dailyBehaviorRebateVO.getRebateConfig());
rebateMessage.setRebateDesc(dailyBehaviorRebateVO.getRebateDesc());
//构建返利消息
BaseEvent.EventMessage<SendRebateMessageEvent.RebateMessage> rebateMessageEventMessage =
sendRebateMessageEvent.buildEventMessage(rebateMessage);
//构建返利补偿任务
TaskEntity taskEntity = new TaskEntity();
taskEntity.setUserId(behaviorEntity.getUserId());
taskEntity.setTopic(sendRebateMessageEvent.topic());
taskEntity.setMessageId(rebateMessageEventMessage.getId());
taskEntity.setMessage(rebateMessageEventMessage);
taskEntity.setState(TaskStateVO.create);
//构建返利聚合对象，设置返利单和补偿任务
behaviorRebateAggregates.add(BehaviorRebateAggregate.builder()
.userId(behaviorEntity.getUserId())
.taskEntity(taskEntity)
.behaviorRebateOrderEntity(behaviorRebateOrderEntity)
.build());
orderIds.add(behaviorRebateOrderEntity.getOrderId());
}
//在同一事务下保存返利单实体(更新{daily_behavior_rebate})和返利补偿任务实体，
//并向RebateMessageCustomer监听的消息队列中投放一个返利消息，RebateMessageCustomer消费消息，
// 根据消息内容SendRebateMessageEvent.RebateMessage 的 返利类型 进行返利
behaviorRebateRepository.saveUserRebateRecord(behaviorEntity.getUserId(), behaviorRebateAggregates);
log.info("用户行为返利记录保存完成 userId:{}", behaviorEntity.getUserId());
return orderIds;
}
@Override
public List<BehaviorRebateOrderEntity> queryOrderByOutBusinessNo(String userId, String outBusinessNo) {
return behaviorRebateRepository.queryOrderByOutBusinessNo(userId,outBusinessNo);
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/rebate/service/BehaviorRebateService.java
|
Java
|
unknown
| 6,280
|
package zack.project.domain.rebate.service;
import zack.project.domain.rebate.model.entity.BehaviorEntity;
import zack.project.domain.rebate.model.entity.BehaviorRebateOrderEntity;
import java.util.List;
/**用户行为返利接口
* @author A1793
*/
public interface IBehaviorRebateService {
List<String> createOrder(BehaviorEntity behaviorEntity);
List<BehaviorRebateOrderEntity> queryOrderByOutBusinessNo(String userId, String outBusinessNo);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/rebate/service/IBehaviorRebateService.java
|
Java
|
unknown
| 463
|
/**
* 外部接口适配器层；当需要调用外部接口时，则创建出这一层，并定义接口，之后由基础设施层的 adapter 层具体实现
*/
package zack.project.domain.strategy.adapter.port;
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/adapter/port/package-info.java
|
Java
|
unknown
| 215
|
package zack.project.domain.strategy.adapter.repository;
import zack.project.domain.strategy.model.entity.StrategyAwardEntity;
import zack.project.domain.strategy.model.entity.StrategyEntity;
import zack.project.domain.strategy.model.entity.StrategyRuleEntity;
import zack.project.domain.strategy.model.valobj.RuleTreeVO;
import zack.project.domain.strategy.model.valobj.RuleWeightVO;
import zack.project.domain.strategy.model.valobj.StrategyAwardRuleModelVO;
import zack.project.domain.strategy.model.valobj.StrategyAwardStockKeyVO;
import java.util.Date;
import java.util.List;
import java.util.Map;
public interface IStrategyRepository {
List<StrategyAwardEntity> queryStrategyAwardList(Long strategyId);
void storeStrategyAwardSearchRateTable(String key, Integer rateRange, Map<Integer, Integer> strategyAwardSearchRateTable);
int getRateRange(Long strategyId);
int getRateRange(String key);
Integer getStrategyAwardAssemble(String key, Integer rateKey);
StrategyEntity queryStrategyEntityByStrategyId(Long strategyId);
StrategyRuleEntity queryStrategyRule(Long strategyId, String ruleModel);
String queryStrategyRuleValue(Long strategyId, Integer awardId, String ruleModel);
StrategyAwardRuleModelVO queryStrategyAwardRuleModelVO(Long strategyId, Integer randomAwardId);
String queryStrategyRuleValue(Long strategyId, String ruleModel);
RuleTreeVO queryRuleTreeVOByTreeId(String treeId);
void cacheStrategyAwardCount(String cacheKey,Integer awardCount);
boolean subtractionAwardStock(String cacheKey);
Boolean subtractionAwardStock(String cacheKey, Date endDateTime);
void awardStockConsumeSendQueue(StrategyAwardStockKeyVO build);
StrategyAwardStockKeyVO takeQueueValue();
void updateStrategyAwardStock(Long strategyId, Integer awardId);
StrategyAwardEntity queryStrategyEntity(Long strategyId, Integer awardId);
Long queryStrategyIdByActivityId(Long activityId);
Integer queryTodayUserRaffleCount(String userId, Long strategyId);
Map<String, Integer> queryAwardRuleLockCount(String[] treeIds);
List<RuleWeightVO> queryAwardRuleWeight(Long strategyId);
Integer queryActivityAccountTotalUseCount(String userId, Long strategyId);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/adapter/repository/IStrategyRepository.java
|
Java
|
unknown
| 2,254
|
/**
* 聚合对象；
* 1. 聚合实体和值对象
* 2. 聚合是聚合的对象，和提供基础处理对象的方法。但不建议在聚合中引入仓储和接口来做过大的逻辑。而这些复杂的操作应该放到service中处理
* 3. 对象名称 XxxAggregate
*/
package zack.project.domain.strategy.model.aggregate;
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/model/aggregate/package-info.java
|
Java
|
unknown
| 337
|
package zack.project.domain.strategy.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author A1793
* @description 抽奖奖品实体
* @create 2024-01-06 09:20
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class RaffleAwardEntity {
/**
* 奖品ID
*/
private Integer awardId;
/**
* 奖品配置信息
*/
private String awardConfig;
/**
* 抽奖奖品标题
*/
private String awardTitle;
private Integer sort;
/**
* 规则模型，rule配置的模型同步到此表，便于使用
*/
private String ruleModels;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/model/entity/RaffleAwardEntity.java
|
Java
|
unknown
| 697
|
package zack.project.domain.strategy.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* @author A1793
* @desc 抽奖因子，传给抽奖策略接口
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class RaffleFactorEntity {
/** 用户ID */
private String userId;
/** 策略ID */
private Long strategyId;
private Integer awardId;
private Date endTime;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/model/entity/RaffleFactorEntity.java
|
Java
|
unknown
| 506
|
package zack.project.domain.strategy.model.entity;
import lombok.*;
/**
* @author A1793
* 规则行为策略，根据用户配置的rule_model可以将抽奖行为分为抽奖前，抽奖中，抽奖后，这些抽奖行为实体都继承RaffleEntity，
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class RuleActionEntity<T extends RuleActionEntity.RaffleEntity> {
private String code;
private String info;
private T data;
private String ruleModel;
static public class RaffleEntity{
}
@EqualsAndHashCode(callSuper = true)
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
static public class RaffleBeforeEntity extends RaffleEntity{
/**
* 策略ID
*/
private Long strategyId;
/**
* 权重值Key；用于抽奖时可以选择权重抽奖。
*/
private String ruleWeightValueKey;
/**
* 奖品ID；
*/
private Integer awardId;
}
static public class RuleAfterEntity extends RaffleEntity{}
static public class RaffleCenterEntity extends RaffleEntity{}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/model/entity/RuleActionEntity.java
|
Java
|
unknown
| 1,154
|
package zack.project.domain.strategy.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author A1793
* 抽奖过程需要的数据，用料
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class RuleMatterEntity {
private String userId;
private Long strategyId;
private String ruleModel;
//过滤的规则
private Integer awardId;
//用来进行黑名单判断，如果该奖品的id是黑色类型的直接返回不继续进行过滤
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/model/entity/RuleMatterEntity.java
|
Java
|
unknown
| 565
|
package zack.project.domain.strategy.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
/**
* @author A1793
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class StrategyAwardEntity {
/** 抽奖策略ID*/
private Long strategyId;
/** 抽奖奖品ID - 内部流转使*/
private Integer awardId;
/** 奖品库存总量*/
private Integer awardCount;
/** 奖品库存剩余*/
private Integer awardCountSurplus;
/** 奖品中奖概率*/
private BigDecimal awardRate;
private String awardTitle;
private String awardSubtitle;
private Integer sort;
private String ruleModels;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/model/entity/StrategyAwardEntity.java
|
Java
|
unknown
| 754
|
package zack.project.domain.strategy.model.entity;
import zack.project.types.common.Constants;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.StringUtils;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class StrategyEntity {
/** 抽奖策略ID*/
private Long strategyId;
/** 抽奖策略描述*/
private String strategyDesc;
/** 规则模型，rule配置的模型同步到此表，便于使用*/
private String ruleModels;
public String[] ruleModels(){
if(StringUtils.isBlank(ruleModels)){
return null;
}
return ruleModels.split(Constants.SPLIT);
}
//处理在{strategy}表中查询到的rule_models
//id strategy_id strategy_desc rule_models
//4 100004 抽奖策略-随机抽奖 2023-12-09 09:37:19 2024-01-20 19:21:03
//5 100005 抽奖策略-测试概率计算 2023-12-09 09:37:19 2024-01-21 21:54:58
//6 100006 抽奖策略-规则树 rule_blacklist,rule_weight 2024-02-03 09:53:40 2024-05-03 09:02:38
public String getRuleWeight(){
String[] ruleModels = this.ruleModels();
if (null == ruleModels) return null;
for(String ruleModel : ruleModels){
if("rule_weight".equals(ruleModel)){
return ruleModel;
}
}
return null;
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/model/entity/StrategyEntity.java
|
Java
|
unknown
| 1,512
|
package zack.project.domain.strategy.model.entity;
import zack.project.types.common.Constants;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class StrategyRuleEntity {
/** 抽奖策略ID*/
private Long strategyId;
/** 抽奖奖品ID【规则类型为策略，则不需要奖品ID】*/
private Integer awardId;
/** 抽象规则类型；1-策略规则、2-奖品规则*/
private Integer ruleType;
/** 抽奖规则类型【rule_random - 随机值计算、rule_lock - 抽奖几次后解锁、rule_luck_award - 幸运奖(兜底奖品)】*/
private String ruleModel;
/** 抽奖规则比值*/
private String ruleValue;
/** 抽奖规则描述*/
private String ruleDesc;
public Map<String, List<Integer>> getRuleWeightValues(){
if(!"rule_weight".equals(ruleModel)){
return null;
}
Map<String, List<Integer>> resultMap = new HashMap<String, List<Integer>>();
String[] ruleValueGroups = ruleValue.split(Constants.SPACE);
for(String ruleValueGroup : ruleValueGroups){
if (ruleValueGroup == null || ruleValueGroup.isEmpty()) {
return resultMap;
}
String[] ruleValues = ruleValueGroup.split(Constants.COLON);
if (ruleValues.length != 2) {
throw new IllegalArgumentException("rule_weight rule_rule invalid input format" + ruleValueGroup);
}
String[] valueStrings = ruleValues[1].split(Constants.SPLIT);
List<Integer> values = new ArrayList<>();
for(String valueString : valueStrings){
values.add(Integer.parseInt(valueString));
}
resultMap.put(ruleValueGroup, values);
}
return resultMap;
//最终返回的map里，键是400:102，103，104,值是102，103，104
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/model/entity/StrategyRuleEntity.java
|
Java
|
unknown
| 2,081
|
package zack.project.domain.strategy.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public enum RuleLimitTypeVO {
EQUAL(1, "等于"),
GT(2, "大于"),
LT(3, "小于"),
GE(4, "大于&等于"),
LE(5, "小于&等于"),
ENUM(6, "枚举"),
;
private final Integer code;
private final String info;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/model/valobj/RuleLimitTypeVO.java
|
Java
|
unknown
| 396
|
package zack.project.domain.strategy.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* @author A1793
* 规则过滤结果检验的值对象
*/
@Getter
@AllArgsConstructor
public enum RuleLogicCheckTypeVO {
ALLOW("0000", "放行；执行后续的流程，不受规则引擎影响"),
TAKE_OVER("0001","接管；后续的流程，受规则引擎执行结果影响"),
;
private final String code;
private final String info;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/model/valobj/RuleLogicCheckTypeVO.java
|
Java
|
unknown
| 475
|
package zack.project.domain.strategy.model.valobj;
import lombok.*;
/**规则树连线
* @author A1793
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class RuleTreeNodeLineVO {
/** 规则树ID */
private String treeId;
/** 规则Key节点 From */
private String ruleNodeFrom;
/** 规则Key节点 To */
private String ruleNodeTo;
/** 限定类型；1:=;2:>;3:<;4:>=;5<=;6:enum[枚举范围] */
private RuleLimitTypeVO ruleLimitType;
/** 限定值（到下个节点） */
private RuleLogicCheckTypeVO ruleLimitValue;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/model/valobj/RuleTreeNodeLineVO.java
|
Java
|
unknown
| 579
|
package zack.project.domain.strategy.model.valobj;
import lombok.*;
import java.util.List;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class RuleTreeNodeVO {
/** 树的id*/
private String treeId;
/** 规则名*/
private String ruleKey;
/** 规则描述*/
private String ruleDesc;
/** 规则比值*/
private String ruleValue;
/** 规则连线*/
List<RuleTreeNodeLineVO> treeNodeLineVOList;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/model/valobj/RuleTreeNodeVO.java
|
Java
|
unknown
| 450
|
package zack.project.domain.strategy.model.valobj;
import lombok.*;
import java.util.Map;
/**
* @author A1793
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class RuleTreeVO {
//树的id
private String treeId;
//树的名字
private String treeName;
//树的描述
private String treeDesc;
//树的根节点的名字
private String treeRootRuleNode;
//存储规则节点
private Map<String,RuleTreeNodeVO> treeNodeMap;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/model/valobj/RuleTreeVO.java
|
Java
|
unknown
| 486
|
package zack.project.domain.strategy.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
/**
* @author A1793
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class RuleWeightVO {
//权重规则的原始配置
String ruleValue;
//当前权重
Integer weight;
List<Integer> awardIds;
List<Award> awardList;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public static class Award {
Integer awardId;
String awardTitle;
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/model/valobj/RuleWeightVO.java
|
Java
|
unknown
| 612
|
package zack.project.domain.strategy.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
/**
* @author A1793
*/
@Getter
@Builder
@AllArgsConstructor
public class StrategyAwardRuleModelVO {
String ruleModel;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/model/valobj/StrategyAwardRuleModelVO.java
|
Java
|
unknown
| 260
|
package zack.project.domain.strategy.model.valobj;
import lombok.*;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class StrategyAwardStockKeyVO {
private Long strategyId;
private Integer awardId;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/model/valobj/StrategyAwardStockKeyVO.java
|
Java
|
unknown
| 223
|
package zack.project.domain.strategy.service;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import zack.project.domain.strategy.adapter.repository.IStrategyRepository;
import zack.project.domain.strategy.model.entity.RaffleAwardEntity;
import zack.project.domain.strategy.model.entity.RaffleFactorEntity;
import zack.project.domain.strategy.model.entity.StrategyAwardEntity;
import zack.project.domain.strategy.service.armory.IStrategyDispatch;
import zack.project.domain.strategy.service.rule.chain.factory.DefaultChainFactory;
import zack.project.domain.strategy.service.rule.tree.factory.DefaultTreeFactory;
import zack.project.types.enums.ResponseCode;
import zack.project.types.exception.AppException;
import java.util.Date;
/**
* 抽象抽奖策略实现类,定义抽奖流程
*
* @author A1793
*/
@Slf4j
public abstract class AbstractRaffleStrategy implements IRaffleStrategy {
// 策略仓储服务 -> domain层像一个大厨，仓储层提供米面粮油
protected IStrategyRepository repository;
// 策略调度服务 -> 只负责抽奖处理，通过新增接口的方式，隔离职责，不需要使用方关心或者调用抽奖的初始化
protected IStrategyDispatch strategyDispatch;
protected DefaultChainFactory logicChainFactory;
protected DefaultTreeFactory logicTreeFactory;
public AbstractRaffleStrategy(DefaultChainFactory logicChainFactory,
DefaultTreeFactory logicTreeFactory,
IStrategyRepository repository,
IStrategyDispatch strategyDispatch) {
this.logicChainFactory = logicChainFactory;
this.logicTreeFactory = logicTreeFactory;
this.repository = repository;
this.strategyDispatch = strategyDispatch;
}
@Override
public RaffleAwardEntity performRaffle(RaffleFactorEntity raffleFactorEntity) {
Long strategyId = raffleFactorEntity.getStrategyId();
String userId = raffleFactorEntity.getUserId();
// 1. 参数校验
if (strategyId == null || StringUtils.isBlank(userId)) {
throw new AppException(ResponseCode.ILLEGAL_PARAMETER.getCode(), ResponseCode.ILLEGAL_PARAMETER.getInfo());
}
log.info("抽奖策略计算 userId:{} strategyId:{}", userId, strategyId);
// 2. 抽奖前 - 规则过滤
DefaultChainFactory.StrategyAwardVO chianStrategyAwardVO =
raffleLogicChain(userId, strategyId);
log.info("抽奖策略计算-责任链 {} {} {} {}", userId, strategyId, chianStrategyAwardVO.getAwardId(), chianStrategyAwardVO.getLogicModel());
//如果不是责任链的默认节点随机抽奖产生的奖品(是由黑名单或权重规则产生),则直接返回奖品
if (!DefaultChainFactory.LogicModel.RULE_DEFAULT.getCode()
.equals(chianStrategyAwardVO.getLogicModel())) {
return buildRaffleAwardEntity(strategyId,
chianStrategyAwardVO.getAwardId(),
chianStrategyAwardVO.getAwardRuleValue());
}
//对随机抽奖获得的奖品进行规则树检验,判断该用户是否满足获得条件(判据:已抽奖次数,该奖品库存)
DefaultTreeFactory.StrategyAwardVO treeStrategyAwardVO = raffleLogicTree(userId,
strategyId,
chianStrategyAwardVO.getAwardId(),
raffleFactorEntity.getEndTime());
log.info("抽奖策略计算-规则树 {} {} {} {}",
userId,
strategyId,
treeStrategyAwardVO.getAwardId(),
treeStrategyAwardVO.getAwardRuleValue());
return buildRaffleAwardEntity(strategyId, treeStrategyAwardVO.getAwardId(),
treeStrategyAwardVO.getAwardRuleValue());
}
private RaffleAwardEntity buildRaffleAwardEntity(Long strategyId, Integer awardId, String awardConfig) {
StrategyAwardEntity strategyAwardEntity = repository.queryStrategyEntity(strategyId, awardId);
return RaffleAwardEntity.builder()
.awardId(awardId)
.awardConfig(awardConfig)
.awardTitle(strategyAwardEntity.getAwardTitle())
.sort(strategyAwardEntity.getSort())
.ruleModels(strategyAwardEntity.getRuleModels())
.build();
}
public abstract DefaultTreeFactory.StrategyAwardVO raffleLogicTree(String userId, Long strategyId, Integer awardId);
public abstract DefaultChainFactory.StrategyAwardVO raffleLogicChain(String userId, Long strategyId);
public abstract DefaultTreeFactory.StrategyAwardVO raffleLogicTree(String userId, Long strategyId, Integer awardId, Date endDateTime);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/AbstractRaffleStrategy.java
|
Java
|
unknown
| 4,784
|
package zack.project.domain.strategy.service;
import zack.project.domain.strategy.model.entity.StrategyAwardEntity;
import java.util.List;
/**抽奖奖品接口
* @author A1793
*/
public interface IRaffleAward {
List<StrategyAwardEntity> queryRaffleStrategyAwardList(Long strategyId);
/**
* 根据活动id查询该活动的奖品列表
* @param activityId
* @return
*/
List<StrategyAwardEntity> queryRaffleStrategyAwardListByActivityId(Long activityId);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/IRaffleAward.java
|
Java
|
unknown
| 495
|
package zack.project.domain.strategy.service;
import zack.project.domain.strategy.model.valobj.RuleWeightVO;
import java.util.List;
import java.util.Map;
/**奖品查询接口
* @author A1793
*/
public interface IRaffleRule {
/**
*
* @param treeIds
* 根据传入的treeid来查询奖品的lock配置
* @return
*/
Map<String, Integer> queryAwardRuleLockCount(String[] treeIds);
List<RuleWeightVO> queryAwardRuleWeightByActivityId(Long activityId);
List<RuleWeightVO> queryAwardRuleWeight(Long strategyId);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/IRaffleRule.java
|
Java
|
unknown
| 558
|
package zack.project.domain.strategy.service;
import zack.project.domain.strategy.model.valobj.StrategyAwardStockKeyVO;
/**抽奖奖品库存接口
* @author A1793
*/
public interface IRaffleStock {
/**
* 从redis根据cacheKey来获取延迟队列,并从队列中获取对应的StrategyAwardStockKeyVO(strategyId,awardId)
* @return
*/
StrategyAwardStockKeyVO takeQueueValue();
/**
* 根据takeQueueValue()方法获得的StrategyAwardStockKeyVO(strategyId,awardId),去更新数据库表{strategy_award}的库存信息
* @param strategyId
* @param awardId
*/
void updateStrategyAwardStock(Long strategyId, Integer awardId);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/IRaffleStock.java
|
Java
|
unknown
| 682
|
package zack.project.domain.strategy.service;
import zack.project.domain.strategy.model.entity.RaffleAwardEntity;
import zack.project.domain.strategy.model.entity.RaffleFactorEntity;
/**抽奖策略接口
* @author A1793
*/
public interface IRaffleStrategy {
/**
* 执行抽奖流程
* @param raffleFactorEntity
* @return
*/
RaffleAwardEntity performRaffle(RaffleFactorEntity raffleFactorEntity);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/IRaffleStrategy.java
|
Java
|
unknown
| 438
|
package zack.project.domain.strategy.service.armory;
/**
* 抽奖策略装配接口
* 在redis中装配抽奖策概率表
* @author A1793
*/
public interface IStrategyArmory {
public boolean assembleLotteryStrategy(Long strategyId);
void assembleLotteryStrategyByActivityId(Long activityId);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/armory/IStrategyArmory.java
|
Java
|
unknown
| 310
|
package zack.project.domain.strategy.service.armory;
import java.util.Date;
/**调度库存,在概率表中获得奖品id
* @author A1793
*/
public interface IStrategyDispatch {
Integer getRandomAwardId(Long strategyId);
Integer getRandomAwardId(Long strategyId, String ruleWeightValue);
Integer getRandomAwardId(String key);
boolean subtractionAwardStock(Long strategyId, Integer awardId, Date endDateTime);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/armory/IStrategyDispatch.java
|
Java
|
unknown
| 434
|
package zack.project.domain.strategy.service.armory;
import zack.project.domain.strategy.adapter.repository.IStrategyRepository;
import zack.project.domain.strategy.model.entity.StrategyAwardEntity;
import zack.project.domain.strategy.model.entity.StrategyEntity;
import zack.project.domain.strategy.model.entity.StrategyRuleEntity;
import zack.project.types.common.Constants;
import zack.project.types.enums.ResponseCode;
import zack.project.types.exception.AppException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.security.SecureRandom;
import java.util.*;
/**抽奖策略装配和库存调度实现类
* @author A1793
*/
@Service
@Slf4j
public class StrategyArmoryDispatch implements IStrategyArmory, IStrategyDispatch {
@Resource
private IStrategyRepository repository;
private final SecureRandom random = new SecureRandom();
/**
* 根据活动id来装配抽奖策略,strategyId和activityId是一一对应的
* @param activityId
*/
@Override
public void assembleLotteryStrategyByActivityId(Long activityId) {
Long strategyId = repository.queryStrategyIdByActivityId(activityId);
assembleLotteryStrategy(strategyId);
}
/**
* 根据策略id去查询strategy_award奖品列表，
* 先进行无权重概率表的装配（装配表的时候也要缓存一份rate_range，防止分布式下无法获取随机数的范围），之后再装配带权重的概率表
* 先根据策略id去查询{strategy}获取rule_models，看这个策略下是否配置了rule_weight，如果配置了，则去strategy_rule表下，
* 查找该策略id的权重配置（获取rule_value），之后将rule_value封装成一个Map<抽奖次数：奖品id1，奖品id2···，奖品id列表>>，
* 将对应的key下的奖品列表和rateRange存到缓存中
* 后面责任链进行权重节点过滤的时候，
* 会根据策略id去查询strategy_rule表中该策略的权重配置(rule_value)并封装成Map<抽奖次数，抽奖次数：奖品id1，奖品id2···>，
* 之后他找到自己小于当前抽奖次数的最大抽奖次数(strategy_rule中rule_value中的配置)，根据这个次数获取访问redis权重概率表的key
* @param strategyId
* @return
*/
@Override
public boolean assembleLotteryStrategy(Long strategyId) {
//预热抽奖奖品配置
List<StrategyAwardEntity> strategyAwardEntityList = repository.queryStrategyAwardList(strategyId);
//向缓存中写入奖品的库存
for(StrategyAwardEntity strategyAwardEntity : strategyAwardEntityList) {
Integer awardId = strategyAwardEntity.getAwardId();
//奖品库存总量
Integer awardCount = strategyAwardEntity.getAwardCount();
//在redis中设置 <cacheKey("strategy_award_count_key_#{strategyId}_#{awardId}),awardCount>
//当决策树节点RuleStockLogicTreeNode在库存扣减以及设置库存余量锁时,会使用到此处预装配的库存总量
cacheStrategyAwardCount(strategyId,awardId,awardCount);
}
//预热strategyId对应的抽奖概率配置(无权重的概率表)
assembleLotteryStrategy(String.valueOf(strategyId), strategyAwardEntityList);
//todo 概率表中可能会因为同一个权重下(抽奖次数)奖品的中奖概率之和不为1,导致概率表出现(i,null)的entry,会返回空的awardId
//查询strategy总表来看是否配置了rule_weight
StrategyEntity strategyEntity = repository.queryStrategyEntityByStrategyId(strategyId);
String ruleWeight = strategyEntity.getRuleWeight();
//如果为空则说明没有配置rule_weight
if(null == ruleWeight){return true;}
//在数据库表{strategy_rule}中查询strategyRuleEntity
StrategyRuleEntity strategyRuleEntity = repository.queryStrategyRule(strategyId,ruleWeight);
if (null == strategyRuleEntity) {
throw new AppException(ResponseCode.STRATEGY_RULE_WEIGHT_IS_NULL.getCode(), ResponseCode.STRATEGY_RULE_WEIGHT_IS_NULL.getInfo());
}
//key(抽奖次数:奖品id1,奖品id2···),value(奖品id1,奖品id2··)
Map<String, List<Integer>> ruleWeightValueMap = strategyRuleEntity.getRuleWeightValues();
Set<String> keys = ruleWeightValueMap.keySet();
//为每个权重组设置权重概率表
for (String key : keys) {
List<Integer> ruleWeightValues = ruleWeightValueMap.get(key);
ArrayList<StrategyAwardEntity> strategyAwardEntityList1 =
new ArrayList<>(strategyAwardEntityList);
//在奖品列表中删除权重规定的奖品id中没有出现奖品
strategyAwardEntityList1.removeIf(entity ->
!ruleWeightValues.contains(entity.getAwardId()));
//再缓存一份权重抽奖概率配置和权重总坑位数,cacheKey("big_market_strategy_rate_table_key#{strategyId}_#{key}"
assembleLotteryStrategy(String.valueOf(strategyId).concat(Constants.UNDERLINE).concat(key),
strategyAwardEntityList1);
}
return true;
}
private void assembleLotteryStrategy(String key, List<StrategyAwardEntity> strategyAwardEntityList) {
//获取这些奖品里的rate最小值
BigDecimal minAwardRate = strategyAwardEntityList.stream()
.map(StrategyAwardEntity::getAwardRate)
.min(BigDecimal::compareTo)
.orElse(BigDecimal.ZERO);
//计算一共有多少个坑位,比如当total为1且min值为0.01时,此时1%0.01=100,
// 则有一百个坑位。向这些坑位填充awardid,这些坑位中的某个id数量可以表示这类id的概率
BigDecimal rateRange = BigDecimal.valueOf(convert(minAwardRate.doubleValue()));
//策略奖品概率查找表「这里指需要在list集合中,存放上对应的奖品占位即可,占位越多等于概率越高」
List<Integer> strategyAwardSearchRateTables = new ArrayList<>(rateRange.intValue());
//遍历strategyAwardEntityList,
// 通过把其中的某个元素的rate属性值与raterange相乘可以获得要往strategyAwardSearchRateTables
for (StrategyAwardEntity strategyAwardEntity : strategyAwardEntityList) {
BigDecimal awardRate = strategyAwardEntity.getAwardRate();
Integer awardId = strategyAwardEntity.getAwardId();
//概率是0.01就放一次,0.99就放99次该奖品id(这个取决于最小概率)
for (int i = 0; i < rateRange.multiply(awardRate).intValue(); i++) {
strategyAwardSearchRateTables.add(awardId);
}
}
//打乱概率查找表
Collections.shuffle(strategyAwardSearchRateTables);
//把list封装成map传给redis
Map<Integer, Integer> shuffleStrategyAwardSearchRateTable = new LinkedHashMap<>();
for (int i = 0; i < strategyAwardSearchRateTables.size(); i++) {
shuffleStrategyAwardSearchRateTable.put(i, strategyAwardSearchRateTables.get(i));
}
//向缓存存入总坑位数和抽奖概率配置
repository.storeStrategyAwardSearchRateTable(key,
shuffleStrategyAwardSearchRateTable.size(),
shuffleStrategyAwardSearchRateTable);
}
/**
* 举例说明:
* 当奖品列表中的最小概率是0.001时,max是1,此时是1:1000,此方法就是要扩大这个max一直到min为1,
* 此时的max就是总的奖品id坑位,最小概率的奖品id只有1个,剩余的999个坑位由其余奖品id填充,仍是1:1000
*
* @param min
* @return
*/
private double convert(double min) {
double current = min;
double max = 1;
while (current < 1) {
current = current * 10;
max = max * 10;
}
return max;
}
/**
* 在缓存中设置奖品库存初始值
* @param strategyId
* @param awardId
* @param awardCount
*/
private void cacheStrategyAwardCount(Long strategyId, Integer awardId, Integer awardCount) {
String cacheKey = Constants.RedisKey.STRATEGY_AWARD_COUNT_KEY + strategyId +
Constants.UNDERLINE +
awardId;
repository.cacheStrategyAwardCount(cacheKey,awardCount);
}
/**
* 根据策略id进行随机抽奖
* @param strategyId
* @return
*/
@Override
public Integer getRandomAwardId(Long strategyId) {
// 分布式部署下,不一定为当前应用做的策略装配。也就是值不一定会保存到本应用,而是分布式应用,所以需要从 Redis 中获取。
int rateRange = repository.getRateRange(strategyId);
// 通过生成的随机值,获取概率值奖品查找表的结果
return repository.getStrategyAwardAssemble(String.valueOf(strategyId), random.nextInt(rateRange));
}
/**
* 带权重的随机抽奖需要找权重概率表
* @param strategyId
* @param ruleWeightValue
* @return
*/
@Override
public Integer getRandomAwardId(Long strategyId,String ruleWeightValue) {
String key = String.valueOf(strategyId).concat(Constants.UNDERLINE).concat(ruleWeightValue);
return getRandomAwardId(key);
}
@Override
public Integer getRandomAwardId(String key) {
//获取总坑位数
int rateRange = repository.getRateRange(key);
return repository.getStrategyAwardAssemble(String.valueOf(key), random.nextInt(rateRange));
}
@Override
public boolean subtractionAwardStock(Long strategyId, Integer awardId,Date endDateTime) {
String cacheKey = Constants.RedisKey.STRATEGY_AWARD_COUNT_KEY + strategyId + Constants.UNDERLINE + awardId;
return repository.subtractionAwardStock(cacheKey,endDateTime);
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/armory/StrategyArmoryDispatch.java
|
Java
|
unknown
| 10,077
|
package zack.project.domain.strategy.service.raffle;
import zack.project.domain.strategy.adapter.repository.IStrategyRepository;
import zack.project.domain.strategy.model.entity.StrategyAwardEntity;
import zack.project.domain.strategy.model.valobj.RuleTreeVO;
import zack.project.domain.strategy.model.valobj.RuleWeightVO;
import zack.project.domain.strategy.model.valobj.StrategyAwardRuleModelVO;
import zack.project.domain.strategy.model.valobj.StrategyAwardStockKeyVO;
import zack.project.domain.strategy.service.AbstractRaffleStrategy;
import zack.project.domain.strategy.service.IRaffleAward;
import zack.project.domain.strategy.service.IRaffleRule;
import zack.project.domain.strategy.service.IRaffleStock;
import zack.project.domain.strategy.service.armory.IStrategyDispatch;
import zack.project.domain.strategy.service.rule.chain.ILogicChain;
import zack.project.domain.strategy.service.rule.chain.factory.DefaultChainFactory;
import zack.project.domain.strategy.service.rule.tree.factory.DefaultTreeFactory;
import zack.project.domain.strategy.service.rule.tree.factory.engine.impl.DecisionTreeEngine;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**1.抽奖策略的默认实现,实现抽象类定义的责任链和决策树
* 2.实现IRaffleAward:查询奖品列表
* 3.实现IRaffleStock:获取延迟消息更新数据库表
* 4.
* @author A1793
*/
@Service
@Slf4j
public class DefaultRaffleStrategy extends AbstractRaffleStrategy implements IRaffleAward,
IRaffleStock,
IRaffleRule {
public DefaultRaffleStrategy(DefaultChainFactory logicChainFactory,
DefaultTreeFactory logicTreeFactory,
IStrategyRepository repository,
IStrategyDispatch strategyDispatch) {
super(logicChainFactory, logicTreeFactory, repository, strategyDispatch);
}
/**
* 通过责任链工厂开启责任链流转
* @param userId
* @param strategyId
* @return
*/
@Override
public DefaultChainFactory.StrategyAwardVO raffleLogicChain(String userId, Long strategyId) {
log.info("抽奖策略-责任链 userId:{} strategyId:{}", userId, strategyId);
//开启责任链，用strategyId去查数据库表{strategy}，根据strategy配置rule_models构建对应的责任链节点并组装
ILogicChain iLogicChain = this.logicChainFactory.openLogicChain(strategyId);
return iLogicChain.logic(userId, strategyId);
}
@Override
public DefaultTreeFactory.StrategyAwardVO raffleLogicTree(String userId,
Long strategyId,
Integer awardId) {
return raffleLogicTree(userId, strategyId, awardId, null);
}
/**
* 决策树流程,根据决策树工厂启动决策引擎进行决策流转
* @param userId
* @param strategyId
* @param awardId
* @param endDateTime
* @return
*/
@Override
public DefaultTreeFactory.StrategyAwardVO raffleLogicTree(String userId,
Long strategyId,
Integer awardId,
Date endDateTime) {
// 根据策略id和奖品去查询{strategy_award}中对应奖品的rule_models(实际就是该奖品要走的规则树的树id)
StrategyAwardRuleModelVO strategyAwardRuleModelVO = this.repository.
queryStrategyAwardRuleModelVO(strategyId, awardId);
if (strategyAwardRuleModelVO == null) {
return DefaultTreeFactory.StrategyAwardVO.builder().build();
}
log.info("抽奖策略-规则树 userId:{} strategyId:{} awardId:{}", userId, strategyId, awardId);
//这个ruleModel就是该奖品要走的规则树的树id，
// 根据树id去查询rule_tree,rule_tree_node,rule_tree_node_line，构建规则树
RuleTreeVO ruleTreeVO =
repository.queryRuleTreeVOByTreeId(strategyAwardRuleModelVO.getRuleModel());
if (ruleTreeVO == null) {
throw new RuntimeException("存在抽奖策略配置的规则模型 Key，未在库表 rule_tree、rule_tree_node、rule_tree_line 配置对应的规则树信息 " + strategyAwardRuleModelVO.getRuleModel());
}
DecisionTreeEngine decisionTreeEngine = this.logicTreeFactory.openLogicTreeNode(ruleTreeVO);
return decisionTreeEngine.process(userId, strategyId, awardId, endDateTime);
}
/**
* IRaffleStock接口方法
* 从redis阻塞队列获取StrategyAwardStockKeyVO消息
* @return
*/
@Override
public StrategyAwardStockKeyVO takeQueueValue() {
return repository.takeQueueValue();
}
/**
* 根据从延迟队列获得消息更新数据库表{strategy_award}
* @param strategyId
* @param awardId
*/
@Override
public void updateStrategyAwardStock(Long strategyId, Integer awardId) {
repository.updateStrategyAwardStock(strategyId, awardId);
}
@Override
public List<StrategyAwardEntity> queryRaffleStrategyAwardList(Long strategyId) {
return repository.queryStrategyAwardList(strategyId);
}
@Override
public List<StrategyAwardEntity> queryRaffleStrategyAwardListByActivityId(Long activityId) {
Long strategyId = repository.queryStrategyIdByActivityId(activityId);
return repository.queryStrategyAwardList(strategyId);
}
@Override
public Map<String, Integer> queryAwardRuleLockCount(String[] treeIds) {
return repository.queryAwardRuleLockCount(treeIds);
}
@Override
public List<RuleWeightVO> queryAwardRuleWeightByActivityId(Long activityId) {
Long strategyId = repository.queryStrategyIdByActivityId(activityId);
return queryAwardRuleWeight(strategyId);
}
@Override
public List<RuleWeightVO> queryAwardRuleWeight(Long strategyId) {
return repository.queryAwardRuleWeight(strategyId);
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/raffle/DefaultRaffleStrategy.java
|
Java
|
unknown
| 6,258
|
package zack.project.domain.strategy.service.rule.chain;
public abstract class AbstractLogicChain implements ILogicChain {
private ILogicChain next;
@Override
public ILogicChain next() {
return next;
}
@Override
public ILogicChain appendNext(ILogicChain next) {
this.next = next;
return next;
}
protected abstract String ruleModels();
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/rule/chain/AbstractLogicChain.java
|
Java
|
unknown
| 401
|
package zack.project.domain.strategy.service.rule.chain;
public interface ILgoicChainArmory {
ILogicChain next();
ILogicChain appendNext(ILogicChain next);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/rule/chain/ILgoicChainArmory.java
|
Java
|
unknown
| 167
|
package zack.project.domain.strategy.service.rule.chain;
import zack.project.domain.strategy.service.rule.chain.factory.DefaultChainFactory;
public interface ILogicChain extends ILgoicChainArmory{
DefaultChainFactory.StrategyAwardVO logic(String userId, Long strategyId);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/rule/chain/ILogicChain.java
|
Java
|
unknown
| 282
|
package zack.project.domain.strategy.service.rule.chain.factory;
import zack.project.domain.strategy.adapter.repository.IStrategyRepository;
import zack.project.domain.strategy.model.entity.StrategyEntity;
import zack.project.domain.strategy.service.rule.chain.ILogicChain;
import lombok.*;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* @author A1793
*/
@Service
public class DefaultChainFactory {
private final IStrategyRepository repository;
private final ApplicationContext applicationContext;
private final Map<Long,ILogicChain> logicChainGroup;
public DefaultChainFactory(ApplicationContext applicationContext, IStrategyRepository strategyRepository) {
this.applicationContext = applicationContext;
this.repository = strategyRepository;
this.logicChainGroup = new ConcurrentHashMap<>();
}
/**
* 装配责任链，返回并将该责任链头节点存入缓存
* 根据数据库配置的rule_models,在容器中查找对应的责任链节点并装配
* @param strategyId
* @return
*/
public ILogicChain openLogicChain(Long strategyId){
ILogicChain cacheLogicChain = logicChainGroup.get(strategyId);
if(cacheLogicChain != null){
return cacheLogicChain;
}
//查找数据库是否配置了该strategyId有对应的责任链,数据库表:{strategy},查询strategyId对应的{rule_models}
StrategyEntity strategyEntity = repository.queryStrategyEntityByStrategyId(strategyId);
String[] ruleModels = strategyEntity.ruleModels();
//如果规则为空或长度是0则装配默认的责任链节点
if(ruleModels == null||ruleModels.length == 0) {
ILogicChain ruleDefault = applicationContext.getBean(LogicModel.RULE_DEFAULT.code,
ILogicChain.class);
logicChainGroup.put(strategyId, ruleDefault);
return ruleDefault;
}
//在applicationContext中根据@Component中设置的beanName去查找对应的责任链节点
ILogicChain logicChain = applicationContext.getBean(ruleModels[0], ILogicChain.class);
ILogicChain cur = logicChain;
for(int i = 1; i < ruleModels.length; i++){
ILogicChain next = applicationContext.getBean(ruleModels[i], ILogicChain.class);
cur = cur.appendNext(next);
}
cur.appendNext(applicationContext.getBean(LogicModel.RULE_DEFAULT.code, ILogicChain.class));
//缓存当前strategyId对应的责任链
logicChainGroup.put(strategyId,logicChain);
return logicChain;
}
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public static class StrategyAwardVO{
/** 抽奖奖品ID - 内部流转使用 */
private Integer awardId;
/** 奖品来自责任链的哪个节点 */
private String logicModel;
private String awardRuleValue;
}
@Getter
@AllArgsConstructor
public enum LogicModel {
RULE_DEFAULT("rule_default", "默认抽奖"),
RULE_BLACKLIST("rule_blacklist", "黑名单抽奖"),
RULE_WEIGHT("rule_weight", "权重规则"),
;
private final String code;
private final String info;
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/rule/chain/factory/DefaultChainFactory.java
|
Java
|
unknown
| 3,400
|
package zack.project.domain.strategy.service.rule.chain.impl;
import zack.project.domain.strategy.adapter.repository.IStrategyRepository;
import zack.project.domain.strategy.service.armory.IStrategyDispatch;
import zack.project.domain.strategy.service.rule.chain.AbstractLogicChain;
import zack.project.domain.strategy.service.rule.chain.factory.DefaultChainFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
/**
* @author A1793
*/
@Slf4j
@Component("rule_default")
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class DefaultLogicChain extends AbstractLogicChain {
@Resource
private IStrategyRepository repository;
@Resource
private IStrategyDispatch strategyDispatch;
@Override
protected String ruleModels() {
return DefaultChainFactory.LogicModel.RULE_DEFAULT.getCode();
}
/**
* 默认节点直接进行随机抽奖
*
* @param userId
* @param strategyId
* @return
*/
@Override
public DefaultChainFactory.StrategyAwardVO logic(String userId, Long strategyId) {
Integer awardId = strategyDispatch.getRandomAwardId(strategyId);
log.info("抽奖责任链-默认处理 userId:{} strategyId:{} ruleModel:{} awardId:{}", userId, strategyId,
ruleModels(),
awardId);
return DefaultChainFactory.StrategyAwardVO
.builder().awardId(awardId)
.logicModel(ruleModels())
.awardRuleValue(" ")
.build();
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/rule/chain/impl/DefaultLogicChain.java
|
Java
|
unknown
| 1,717
|
package zack.project.domain.strategy.service.rule.chain.impl;
import zack.project.domain.strategy.adapter.repository.IStrategyRepository;
import zack.project.domain.strategy.service.rule.chain.AbstractLogicChain;
import zack.project.domain.strategy.service.rule.chain.factory.DefaultChainFactory;
import zack.project.types.common.Constants;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
/**
* @author A1793
*/
@Slf4j
@Component("rule_blacklist")
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class RuleBlackListLogicChain extends AbstractLogicChain {
@Resource
private IStrategyRepository repository;
@Override
protected String ruleModels() {
return DefaultChainFactory.LogicModel.RULE_BLACKLIST.getCode();
}
@Override
public DefaultChainFactory.StrategyAwardVO logic(String userId, Long strategyId) {
log.info("抽奖责任链-黑名单开始 userId:{} strategyId:{} ruleModel:{}", userId, strategyId, ruleModels());
//根据抽奖策略id和ruleModels()【返回"rule_black_list"】查找数据库表{strategy_rule}获取对应策略规则的rule_value（黑名单规则配置）
String ruleValue = repository.queryStrategyRuleValue(strategyId,ruleModels());
//数据库表:{strategy_rule}中配置:rule_model:{rule_blacklist},rule_value:{奖品id：userId}
String[] split = ruleValue.split(Constants.COLON);
Integer awardId = Integer.parseInt(split[0]);
//黑名单的userId
String[] ids = split[1].split(Constants.SPLIT);
//循环比较本次userId是否在黑名单内
for(String id : ids) {
if(userId.equals(id)) {
log.info("抽奖责任链-黑名单接管 userId: {} strategyId: {} ruleModel: {} awardId: {}", userId, strategyId, ruleModels(), awardId);
DefaultChainFactory.StrategyAwardVO strategyAwardVO =
new DefaultChainFactory.StrategyAwardVO();
strategyAwardVO.setAwardId(awardId);
strategyAwardVO.setLogicModel(ruleModels());
strategyAwardVO.setAwardRuleValue("1");
return strategyAwardVO;
}
}
log.info("抽奖责任链-黑名单放行 userId:{} strategyId:{} ruleModel:{}", userId, strategyId, ruleModels());
//本用户不在黑名单,走下一个rule_model
return next().logic(userId, strategyId);
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/rule/chain/impl/RuleBlackListLogicChain.java
|
Java
|
unknown
| 2,636
|
package zack.project.domain.strategy.service.rule.chain.impl;
import zack.project.domain.strategy.adapter.repository.IStrategyRepository;
import zack.project.domain.strategy.service.armory.IStrategyDispatch;
import zack.project.domain.strategy.service.rule.chain.AbstractLogicChain;
import zack.project.domain.strategy.service.rule.chain.factory.DefaultChainFactory;
import zack.project.types.common.Constants;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.*;
/**权重过滤节点
* @author A1793
*/
@Slf4j
@Component("rule_weight")
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class RuleWeightLogicChain extends AbstractLogicChain {
@Resource
private IStrategyRepository repository;
@Resource
private IStrategyDispatch strategyDispatch;
private final IAnalytical analyticalNotEqual = new AnalyticalNotEqual();
@Override
protected String ruleModels() {
return DefaultChainFactory.LogicModel.RULE_WEIGHT.getCode();
}
@Override
public DefaultChainFactory.StrategyAwardVO logic(String userId, Long strategyId) {
log.info("抽奖责任链-权重开始 userId:{} strategyId:{} ruleModel:{}", userId, strategyId, ruleModels());
//根据抽奖策略id和ruleModels()【返回"rule_weight"】查找数据库表{strategy_rule}获取对应策略规则的rule_value（抽奖权重配置）
String ruleValue = repository.queryStrategyRuleValue(strategyId,ruleModels());
//获得次数权重map
Map<Integer, String> analyticalValueGroup = getAnalyticalValue(ruleValue);
if( analyticalValueGroup == null || analyticalValueGroup.isEmpty()){
log.warn("抽奖责任链-权重告警【策略配置权重，但ruleValue未配置相应值】 userId: {} strategyId: {} ruleModel: {}", userId, strategyId, ruleModels());
return next().logic(userId, strategyId);
}
//查询用户已抽奖次数
//根据strategyId去查询{raffle_activity}获取一个策略id对应的抽奖活动实体，
// 根据这个活动实体的活动id和userId去查询{raffle_activity_account}，查询该用户在该活动上的活动账户实体
//根据该实体的totalCount和totalSurplus获取用户的抽奖次数
Integer userScore = repository.queryActivityAccountTotalUseCount(userId,strategyId);
//在analyticalValueGroup表的键(权重配置的抽奖次数)中，
// 找一个小于当前用户抽奖次数的最大值获取一个key(这个key是:抽奖次数:奖品id列表，是在活动装配的时候预热到redis里的)，
// 根据这个key获取一个权重概率表进行随机抽奖
String nextKey = analyticalNotEqual.getAnalyticalValue(analyticalValueGroup, userScore);
//如果有对应的权重次数就进行抽奖并返回
if(nextKey != null){
Integer awardId = strategyDispatch.getRandomAwardId(strategyId, nextKey);
log.info("抽奖责任链-权重接管 userId: {} strategyId: {} ruleModel: {} awardId: {}", userId, strategyId, nextKey, awardId);
return DefaultChainFactory.StrategyAwardVO.builder()
.awardId(awardId)
.logicModel(ruleModels())
.awardRuleValue(ruleValue)
.build();
}
log.info("抽奖责任链-权重放行 userId: {} strategyId: {} ruleModel: {}", userId, strategyId, ruleModels());
//没被黑名单拦截也没有对应权重走默认节点
return next().logic(userId, strategyId);
}
/**
* 解析在数据库表{strategy_rule}中查询到的{rule-value}中的权重配置{次数1:奖品id列表1 次数2:奖品id列表2 ····}
* {rule_value} : {10:102,103 70:106,107 1000:104,105}.
* 返回一个(次数,{rule_value[i]})entry的map
* @param ruleValue
* @return
*/
private Map<Integer,String> getAnalyticalValue(String ruleValue){
String[] ruleValueGroups = ruleValue.split(Constants.SPACE);
Map<Integer,String> resultMap = new HashMap<>(ruleValueGroups.length);
for(String ruleValueGroup : ruleValueGroups){
if (ruleValue == null || ruleValue.isEmpty()) {
return resultMap;
}
String[] part = ruleValueGroup.split(Constants.COLON);
if(part.length != 2){
throw new IllegalArgumentException("rule_weight rule_rule invalid input format" + ruleValueGroup);
}
resultMap.put(Integer.parseInt(part[0]),ruleValueGroup);
}
return resultMap;
}
public interface IAnalytical{
String getAnalyticalValue(Map<Integer, String> analyticalValueGroup, Integer userScore);
}
/**
* 当用户的抽奖次数与analyticalValueGroup中的某个键值正好 相等时走这个
*/
static class AnalyticalEqual implements IAnalytical{
@Override
public String getAnalyticalValue(Map<Integer, String> analyticalValueGroup, Integer userScore) {
return analyticalValueGroup.get(userScore);
}
}
/**
* 当用户抽奖次数与analyticalValueGroup中的键不等时，找到第一个小于抽奖次数的键返回其中的奖励配置
*/
static class AnalyticalNotEqual implements IAnalytical{
@Override
public String getAnalyticalValue(Map<Integer, String> analyticalValueGroup, Integer userScore) {
List<Integer> analyticalValueGroupKeys = new ArrayList<>(analyticalValueGroup.keySet());
Collections.sort(analyticalValueGroupKeys);
//降序排序并收集小于userScore的然后找到第一个（所有小于userScore的数中找一个最大的）
Integer nextKey = analyticalValueGroupKeys.stream()
.sorted(Collections.reverseOrder())
.filter(s -> s <= userScore)
.findFirst()
.orElse(null);
return analyticalValueGroup.get(nextKey);
}
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/rule/chain/impl/RuleWeightLogicChain.java
|
Java
|
unknown
| 6,330
|
package zack.project.domain.strategy.service.rule.tree;
import zack.project.domain.strategy.service.rule.tree.factory.DefaultTreeFactory;
import java.util.Date;
/**
* @author A1793
*/
public interface ILogicTreeNode {
/**
* 根据该用户的userId和活动的策略id，抽奖的奖品id，规则树节点配置的规则值进行过滤
* @param userId
* @param strategyId
* @param awardId
* @param ruleValue
* @param endDateTime
* @return
*/
DefaultTreeFactory.TreeActionEntity logic(String userId,
Long strategyId,
Integer awardId,
String ruleValue,
Date endDateTime);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/rule/tree/ILogicTreeNode.java
|
Java
|
unknown
| 825
|
package zack.project.domain.strategy.service.rule.tree.factory;
import zack.project.domain.strategy.model.valobj.RuleLogicCheckTypeVO;
import zack.project.domain.strategy.model.valobj.RuleTreeVO;
import zack.project.domain.strategy.service.rule.tree.ILogicTreeNode;
import zack.project.domain.strategy.service.rule.tree.factory.engine.impl.DecisionTreeEngine;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.Map;
/**
* @author A1793
*/
@Service
public class DefaultTreeFactory {
//spring注入
private final Map<String, ILogicTreeNode> logicTreeNodeMap;
public DefaultTreeFactory(Map<String, ILogicTreeNode> logicTreeNodeMap) {
this.logicTreeNodeMap = logicTreeNodeMap;
}
public DecisionTreeEngine openLogicTreeNode(RuleTreeVO ruleTreeVO) {
return new DecisionTreeEngine(this.logicTreeNodeMap,ruleTreeVO);
}
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public static class TreeActionEntity {
//检查节点状态是接管还是放行
private RuleLogicCheckTypeVO ruleLogicCheckType;
//策略奖品数据
private StrategyAwardVO strategyAwardVO;
}
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public static class StrategyAwardVO {
/** 抽奖奖品ID - 内部流转使用 */
private Integer awardId;
/** 抽奖奖品规则 */
private String awardRuleValue;
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/rule/tree/factory/DefaultTreeFactory.java
|
Java
|
unknown
| 1,563
|
package zack.project.domain.strategy.service.rule.tree.factory.engine;
import zack.project.domain.strategy.service.rule.tree.factory.DefaultTreeFactory;
import java.util.Date;
/**
* @author A1793
*/
public interface IDecisionTreeEngine {
DefaultTreeFactory.StrategyAwardVO process(String userId, Long strategyId, Integer awardId, Date endDateTime);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/rule/tree/factory/engine/IDecisionTreeEngine.java
|
Java
|
unknown
| 361
|
package zack.project.domain.strategy.service.rule.tree.factory.engine.impl;
import lombok.extern.slf4j.Slf4j;
import zack.project.domain.strategy.model.valobj.RuleLogicCheckTypeVO;
import zack.project.domain.strategy.model.valobj.RuleTreeNodeLineVO;
import zack.project.domain.strategy.model.valobj.RuleTreeNodeVO;
import zack.project.domain.strategy.model.valobj.RuleTreeVO;
import zack.project.domain.strategy.service.rule.tree.ILogicTreeNode;
import zack.project.domain.strategy.service.rule.tree.factory.DefaultTreeFactory;
import zack.project.domain.strategy.service.rule.tree.factory.engine.IDecisionTreeEngine;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**决策树引擎
* @author A1793
*/
@Slf4j
public class DecisionTreeEngine implements IDecisionTreeEngine {
//决策树节点
private final Map<String, ILogicTreeNode> logicTreeNodeMap;
//数据库配置的规则树
private final RuleTreeVO ruleTreeVO;
public DecisionTreeEngine(Map<String, ILogicTreeNode> logicTreeNodeMap, RuleTreeVO ruleTreeVO) {
this.logicTreeNodeMap = logicTreeNodeMap;
this.ruleTreeVO = ruleTreeVO;
}
/**
* 执行规则树
* @param userId
* @param strategyId
* @param awardId
* @param endDateTime
* @return
*/
@Override
public DefaultTreeFactory.StrategyAwardVO process(String userId,
Long strategyId,
Integer awardId,
Date endDateTime) {
//获取规则节点表
Map<String, RuleTreeNodeVO> ruleTreeNodeVOMap = ruleTreeVO.getTreeNodeMap();
//获取规则树的根节点名
String nextNode = ruleTreeVO.getTreeRootRuleNode();
//在规则表中获取对应的规则树节点
RuleTreeNodeVO treeNodeVO = ruleTreeNodeVOMap.get(nextNode);
DefaultTreeFactory.StrategyAwardVO strategyAwardVO = null;
//这里为空的时候会退出循环
//比如:
//lockCount节点放行到stockCount节点，库存节点库存抢占成功会返回TAKE_OVER,
// 这个TakeOver在数据库没有配置stockCount节点关于takeover会路由到哪个节点，所以获取stock节点的nodeLine，
// 在循环判断（nextNode方法）的时候，只能返回空(没有nodeLineVO的ruleLimitValue是TAKEOVER)，返回空之后再从nodeMap获取只能是null，
// 退出决策树节点过滤
while (treeNodeVO != null) {
//策略模式,根据节点名来来获取对应的决策树节点
ILogicTreeNode iLogicTreeNode = logicTreeNodeMap.get(treeNodeVO.getRuleKey());
//该规则节点的规则值
String ruleValue = treeNodeVO.getRuleValue();
DefaultTreeFactory.TreeActionEntity treeActionEntity =
iLogicTreeNode.logic(userId, strategyId, awardId,ruleValue,endDateTime);
RuleLogicCheckTypeVO ruleLogicCheckType = treeActionEntity.getRuleLogicCheckType();
strategyAwardVO = treeActionEntity.getStrategyAwardVO();
log.info("决策树引擎【{}】treeId:{} node:{} code:{}", ruleTreeVO.getTreeName(), ruleTreeVO.getTreeId(), nextNode, ruleLogicCheckType.getCode());
//根据上一个决策节点的执行结果(ruleLogicCheckType),在规则节点的TreeNodeLineVOList获得下一个决策节点
nextNode = nextNode(ruleLogicCheckType.getCode(), treeNodeVO.getTreeNodeLineVOList());
treeNodeVO = ruleTreeNodeVOMap.get(nextNode);
}
return strategyAwardVO;
}
/**
* 路由到下一个决策节点
* @param matterValue
* @param ruleTreeNodeLineVOList
* @return
*/
private String nextNode(String matterValue, List<RuleTreeNodeLineVO> ruleTreeNodeLineVOList) {
if(ruleTreeNodeLineVOList == null || ruleTreeNodeLineVOList.isEmpty()) {
return null;
}
for(RuleTreeNodeLineVO ruleTreeNodeLineVO : ruleTreeNodeLineVOList) {
if(decisionLogic(matterValue, ruleTreeNodeLineVO)) {
return ruleTreeNodeLineVO.getRuleNodeTo();
}
}
return null;
}
/**
* 1 tree_lock_1 rule_lock rule_stock EQUAL ALLOW 0000-00-00 00:00:00 2024-02-15 07:55:08
* 2 tree_lock_1 rule_lock rule_luck_award EQUAL TAKE_OVER 0000-00-00 00:00:00 2024-02-15 07:55:11
* 3 tree_lock_1 rule_stock rule_luck_award EQUAL ALLOW 0000-00-00 00:00:00 2024-02-15 07:55:13
* 举例说明: 当根节点是rule_lock时且执行结果是ALLOW,此时遍历其对应的ruleTreeNodeLineVOList的ruleTreeNodeLineVO，
* 如果也匹配到了ALLOW,则返回true,走rule_stock决策节点;当执行结果是TAKE_OVER(已抽奖次数小于规则值),此时走rule_luck_award决策节点
* @param matterValue
* @param ruleTreeNodeLineVO
* @return
*/
private boolean decisionLogic(String matterValue, RuleTreeNodeLineVO ruleTreeNodeLineVO) {
switch(ruleTreeNodeLineVO.getRuleLimitType()){
//在node_line列表找rule_limit_value和传入的checkType相等的nodeLine
case EQUAL:return matterValue.equals(ruleTreeNodeLineVO.getRuleLimitValue().getCode());
case GT:
case LT:
case GE:
case LE:
case ENUM:
default:
return false;
}
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/rule/tree/factory/engine/impl/DecisionTreeEngine.java
|
Java
|
unknown
| 5,507
|
package zack.project.domain.strategy.service.rule.tree.impl;
import zack.project.domain.strategy.adapter.repository.IStrategyRepository;
import zack.project.domain.strategy.model.valobj.RuleLogicCheckTypeVO;
import zack.project.domain.strategy.service.rule.tree.ILogicTreeNode;
import zack.project.domain.strategy.service.rule.tree.factory.DefaultTreeFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Date;
/**抽奖次数限制的决策树节点,接管用户已抽奖次数大于规定的次数,放行小于规定次数(走RuleLuckAwardLogicTreeNode)
* @author A1793
*/
@Component("rule_lock")
@Slf4j
public class RuleLockLogicTreeNode implements ILogicTreeNode {
@Resource
private IStrategyRepository repository;
@Override
public DefaultTreeFactory.TreeActionEntity logic(String userId,
Long strategyId,
Integer awardId,
String ruleValue,
Date endDateTime) {
log.info("规则过滤-次数锁 userId:{} strategyId:{} awardId:{}", userId, strategyId, awardId);
long count = 0L;
try{
count = Long.parseLong(ruleValue);
}catch(NumberFormatException e){
throw new RuntimeException("规则过滤-次数锁异常 ruleValue: " + ruleValue + " 配置不正确");
}
Integer userRaffleCount = repository.queryTodayUserRaffleCount(userId,strategyId) ; ;
//用户抽奖次数大于rule_lock规则节点的rule_value规定的抽奖次数，放行到下一个节点
//decisionEngine引擎先获取当前treeNode的nodeLine列表，在列表里面根据返回的treeAction的type，
// 去找相等的nodeLine的rule_limit_value对应to_node的rule_key
if(userRaffleCount >= count){
return DefaultTreeFactory.TreeActionEntity.builder()
.ruleLogicCheckType(RuleLogicCheckTypeVO.ALLOW)
.build();
}
return DefaultTreeFactory.TreeActionEntity.builder()
.ruleLogicCheckType(RuleLogicCheckTypeVO.TAKE_OVER).
build();
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/rule/tree/impl/RuleLockLogicTreeNode.java
|
Java
|
unknown
| 2,328
|
package zack.project.domain.strategy.service.rule.tree.impl;
import zack.project.domain.strategy.adapter.repository.IStrategyRepository;
import zack.project.domain.strategy.model.valobj.RuleLogicCheckTypeVO;
import zack.project.domain.strategy.model.valobj.StrategyAwardStockKeyVO;
import zack.project.domain.strategy.service.rule.tree.ILogicTreeNode;
import zack.project.domain.strategy.service.rule.tree.factory.DefaultTreeFactory;
import zack.project.types.common.Constants;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Date;
/**兜底奖品的决策树节点
* @author A1793
*/
@Component("rule_luck_award")
@Slf4j
public class RuleLuckAwardLogicTreeNode implements ILogicTreeNode {
@Resource
private IStrategyRepository strategyRepository;
/**
*
* @param userId
* @param strategyId
* @param awardId
* @param ruleValue 兜底(积分奖品)规则节点的规则值:{101:1,100},奖品id,积分范围
* @param endDateTime
* @return
*/
@Override
public DefaultTreeFactory.TreeActionEntity logic(String userId,
Long strategyId,
Integer awardId,
String ruleValue,
Date endDateTime) {
log.info("规则过滤-兜底奖品 userId:{} strategyId:{} awardId:{} ruleValue:{}", userId, strategyId, awardId, ruleValue);
String[] split = ruleValue.split(Constants.COLON);
if (split.length == 0) {
log.error("规则过滤-兜底奖品，兜底奖品未配置告警 userId:{} strategyId:{} awardId:{}", userId, strategyId, awardId);
throw new RuntimeException("兜底奖品未配置 " + ruleValue);
}
// 兜底奖励配置
Integer luckAwardId = Integer.valueOf(split[0]);
String awardRuleValue = split.length > 1 ? split[1] : "";
//扣减兜底奖品库存,通过延迟队列消费StrategyAwardStockKeyVO消息来更新数据库表{strategy_award}
strategyRepository.
awardStockConsumeSendQueue(StrategyAwardStockKeyVO.builder().awardId(awardId).strategyId(strategyId).build());
// 返回兜底奖品
log.info("规则过滤-兜底奖品 userId:{} strategyId:{} awardId:{} awardRuleValue:{}", userId, strategyId, luckAwardId, awardRuleValue);
return DefaultTreeFactory.TreeActionEntity.builder()
//兜底奖品是最终的决策节点,应直接接管
.ruleLogicCheckType(RuleLogicCheckTypeVO.TAKE_OVER)
.strategyAwardVO(DefaultTreeFactory.StrategyAwardVO.builder()
.awardId(luckAwardId)
.awardRuleValue(awardRuleValue)
.build())
.build();
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/rule/tree/impl/RuleLuckAwardLogicTreeNode.java
|
Java
|
unknown
| 2,974
|
package zack.project.domain.strategy.service.rule.tree.impl;
import zack.project.domain.strategy.adapter.repository.IStrategyRepository;
import zack.project.domain.strategy.model.valobj.RuleLogicCheckTypeVO;
import zack.project.domain.strategy.model.valobj.StrategyAwardStockKeyVO;
import zack.project.domain.strategy.service.armory.IStrategyDispatch;
import zack.project.domain.strategy.service.rule.tree.ILogicTreeNode;
import zack.project.domain.strategy.service.rule.tree.factory.DefaultTreeFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Date;
/**抽奖库存规则节点
* @author A1793
*/
@Component("rule_stock")
@Slf4j
public class RuleStockLogicTreeNode implements ILogicTreeNode {
@Resource
IStrategyRepository strategyRepository;
@Resource
IStrategyDispatch strategyDispatch;
/**
* 在redis中扣减缓存库存后加库存余量锁,并通过redis的延迟队列更新数据库表{strategy_award}
* @param userId
* @param strategyId
* @param awardId
* @param ruleValue
* @param endDateTime
* @return
*/
@Override
public DefaultTreeFactory.TreeActionEntity logic(String userId,
Long strategyId,
Integer awardId,
String ruleValue,
Date endDateTime) {
log.info("规则过滤-库存扣减 userId:{} strategyId:{} awardId:{}", userId, strategyId, awardId);
//1.尝试在redis中扣减库存:先根据cacheKey("strategy_award_count_key_#{strategyId}_#{awardId}"),redisService.decr(cacheKey)
//并根据返回的库存余量(surplus)来新设置一个("strategy_award_count_key_#{strategyId}_#{awardId}_#{surplus}")的锁
boolean locked = strategyDispatch.subtractionAwardStock(strategyId, awardId,endDateTime);
if(locked) {
log.info("规则过滤-库存扣减-成功 userId:{} strategyId:{} awardId:{}", userId, strategyId, awardId);
//向redis中名为("strategy_award_count_query_key")的延迟队列中放一条信息(StrategyAwardStockKeyVO)，
// 在定时任务UpdateAwardStockJob中根据StrategyAwardStockKeyVO来更新库表{strategy_award}中的缓存
strategyRepository.awardStockConsumeSendQueue(StrategyAwardStockKeyVO
.builder()
.awardId(awardId)
.strategyId(strategyId).build());
return DefaultTreeFactory.TreeActionEntity.builder()
.ruleLogicCheckType(RuleLogicCheckTypeVO.TAKE_OVER)
.strategyAwardVO(DefaultTreeFactory.StrategyAwardVO.builder()
.awardRuleValue(ruleValue)
.awardId(awardId)
.build())
.build();
}
log.warn("规则过滤-库存扣减-告警，库存不足。userId:{} strategyId:{} awardId:{}", userId, strategyId, awardId);
return DefaultTreeFactory.TreeActionEntity.builder()
.ruleLogicCheckType(RuleLogicCheckTypeVO.ALLOW)
.build();
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/strategy/service/rule/tree/impl/RuleStockLogicTreeNode.java
|
Java
|
unknown
| 3,327
|
package zack.project.domain.task.adapter.repository;
import zack.project.domain.task.model.entity.TaskEntity;
import java.util.List;
/**
* @author A1793
*/
public interface ITaskRepository {
List<TaskEntity> queryNoSendMessageTaskList();
void sendMessage(TaskEntity taskEntity);
void updateTaskSendMessageCompleted(String userId, String messageId);
void updateTaskSendMessageFail(String userId, String messageId);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/task/adapter/repository/ITaskRepository.java
|
Java
|
unknown
| 440
|
package zack.project.domain.task.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class TaskEntity {
/** 活动ID */
private String userId;
/** 消息主题 */
private String topic;
/** 消息编号 */
private String messageId;
/** 消息主体 */
private String message;
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/task/model/entity/TaskEntity.java
|
Java
|
unknown
| 446
|
package zack.project.domain.task.service;
import zack.project.domain.task.model.entity.TaskEntity;
import java.util.List;
/**
* @author A1793
* 提供对task表的扫描操作和发送消息
*/
public interface ITaskService {
List<TaskEntity> queryNoSendMessageTaskList();
void sendMessage(TaskEntity taskEntity);
void updateTaskSendMessageCompleted(String userId, String messageId);
void updateTaskSendMessageFail(String userId, String messageId);
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/task/service/ITaskService.java
|
Java
|
unknown
| 478
|
package zack.project.domain.task.service;
import zack.project.domain.task.adapter.repository.ITaskRepository;
import zack.project.domain.task.model.entity.TaskEntity;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;
/**
* @author A1793
*/
@Service
public class TaskService implements ITaskService {
@Resource
private ITaskRepository taskRepository;
@Override
public List<TaskEntity> queryNoSendMessageTaskList() {
return taskRepository.queryNoSendMessageTaskList();
}
@Override
public void sendMessage(TaskEntity taskEntity) {
taskRepository.sendMessage(taskEntity);
}
@Override
public void updateTaskSendMessageCompleted(String userId, String messageId) {
taskRepository.updateTaskSendMessageCompleted(userId, messageId);
}
@Override
public void updateTaskSendMessageFail(String userId, String messageId) {
taskRepository.updateTaskSendMessageFail(userId, messageId);
}
}
|
2301_82000044/big-market-z
|
bigmarket-domain/src/main/java/zack/project/domain/task/service/TaskService.java
|
Java
|
unknown
| 1,020
|
package zack.project.infrastructure.event;
import zack.project.types.event.BaseEvent;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
/**
* @author A1793
*/
@Slf4j
@Component
public class EventPublisher {
@Resource
private RabbitTemplate rabbitTemplate;
public void publish(String topic, BaseEvent.EventMessage<?> message) {
String jsonMessage = JSON.toJSONString(message);
try{
rabbitTemplate.convertAndSend(topic, jsonMessage);
log.info("发送MQ消息 topic:{} message:{}", topic, jsonMessage);
}catch(Exception e){
log.error("发送MQ消息失败 topic:{} message:{}", topic, jsonMessage, e);
}
}
public void publish(String topic, String jsonMessage) {
try{
rabbitTemplate.convertAndSend(topic, jsonMessage);
log.info("发送MQ消息 topic:{} message:{}", topic, jsonMessage);
}catch(Exception e){
log.error("发送MQ消息失败 topic:{} message:{}", topic, jsonMessage, e);
}
}
}
|
2301_82000044/big-market-z
|
bigmarket-infrastructure/src/main/java/zack/project/infrastructure/event/EventPublisher.java
|
Java
|
unknown
| 1,210
|
/**
* 定义http、rpc接口，调用外部。在 adapter 中调用这部分内容。
*/
package zack.project.infrastructure.gateway;
|
2301_82000044/big-market-z
|
bigmarket-infrastructure/src/main/java/zack/project/infrastructure/gateway/package-info.java
|
Java
|
unknown
| 135
|
package zack.project.infrastructure.persistent.dao;
import zack.project.infrastructure.persistent.po.Award;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
@Mapper
public interface IAwardDao {
List<Award> queryAwardList();
String queryAwardConfigByAwardId(Integer awardId);
String queryAwardKeyByAwardId(Integer awardId);
}
|
2301_82000044/big-market-z
|
bigmarket-infrastructure/src/main/java/zack/project/infrastructure/persistent/dao/IAwardDao.java
|
Java
|
unknown
| 364
|
package zack.project.infrastructure.persistent.dao;
import zack.project.infrastructure.persistent.po.DailyBehaviorRebate;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
@Mapper
public interface IDailyBehaviorRebateDao {
List<DailyBehaviorRebate> queryDailyBehaviorRebateByBehaviorType(String behaviorType);
}
|
2301_82000044/big-market-z
|
bigmarket-infrastructure/src/main/java/zack/project/infrastructure/persistent/dao/IDailyBehaviorRebateDao.java
|
Java
|
unknown
| 340
|
package zack.project.infrastructure.persistent.dao;
import zack.project.infrastructure.persistent.po.RaffleActivityAccount;
import cn.bugstack.middleware.db.router.annotation.DBRouter;
import org.apache.ibatis.annotations.Mapper;
/**
* @description 抽奖活动账户表
* @create 2024-03-09 10:05
*/
@Mapper
public interface IRaffleActivityAccountDao {
int updateAccountQuota(RaffleActivityAccount raffleActivityAccount);
void insert(RaffleActivityAccount raffleActivityAccount);
int updateActivityAccountSubtractionQuota(RaffleActivityAccount build);
int updateActivityAccountMonthSubtractionQuota(RaffleActivityAccount raffleActivityAccount);
int updateActivityAccountDaySubtractionQuota(RaffleActivityAccount raffleActivityAccount);
void updateActivityAccountMonthSurplusImageQuota(RaffleActivityAccount build);
void updateActivityAccountDaySurplusImageQuota(RaffleActivityAccount build);
@DBRouter
RaffleActivityAccount queryActivityAccountByUserId(RaffleActivityAccount raffleActivityAccountReq);
RaffleActivityAccount queryAccountByUserId(RaffleActivityAccount build);
}
|
2301_82000044/big-market-z
|
bigmarket-infrastructure/src/main/java/zack/project/infrastructure/persistent/dao/IRaffleActivityAccountDao.java
|
Java
|
unknown
| 1,135
|
package zack.project.infrastructure.persistent.dao;
import zack.project.infrastructure.persistent.po.RaffleActivityAccountDay;
import cn.bugstack.middleware.db.router.annotation.DBRouter;
import org.apache.ibatis.annotations.Mapper;
/**
* @description 抽奖活动账户表-日次数
* @create 2024-04-03 15:56
*/
@Mapper
public interface IRaffleActivityAccountDayDao {
int updateActivityAccountDaySubtractionQuota(RaffleActivityAccountDay build);
void insertActivityAccountDay(RaffleActivityAccountDay build);
@DBRouter
RaffleActivityAccountDay queryActivityAccountDayByUserId(RaffleActivityAccountDay raffleActivityAccountDayReq);
@DBRouter
Integer queryRaffleActivityAccountDayPartakeCount(RaffleActivityAccountDay raffleActivityAccountDay);
void addAccountQuota(RaffleActivityAccountDay raffleActivityAccountDay);
}
|
2301_82000044/big-market-z
|
bigmarket-infrastructure/src/main/java/zack/project/infrastructure/persistent/dao/IRaffleActivityAccountDayDao.java
|
Java
|
unknown
| 857
|
package zack.project.infrastructure.persistent.dao;
import zack.project.infrastructure.persistent.po.RaffleActivityAccountMonth;
import cn.bugstack.middleware.db.router.annotation.DBRouter;
import org.apache.ibatis.annotations.Mapper;
/**
* @description 抽奖活动账户表-月次数
* @create 2024-04-03 15:57
*/
@Mapper
public interface IRaffleActivityAccountMonthDao {
int updateActivityAccountMonthSubtractionQuota(RaffleActivityAccountMonth accountMonth);
void insertActivityAccountMonth(RaffleActivityAccountMonth build);
@DBRouter
RaffleActivityAccountMonth queryActivityAccountMonthByUserId(RaffleActivityAccountMonth raffleActivityAccountMonthReq);
void addAccountQuota(RaffleActivityAccountMonth raffleActivityAccountMonth);
}
|
2301_82000044/big-market-z
|
bigmarket-infrastructure/src/main/java/zack/project/infrastructure/persistent/dao/IRaffleActivityAccountMonthDao.java
|
Java
|
unknown
| 770
|
package zack.project.infrastructure.persistent.dao;
import zack.project.infrastructure.persistent.po.RaffleActivityCount;
import org.apache.ibatis.annotations.Mapper;
/**
* @description 抽奖活动次数配置表Dao
* @create 2024-03-09 10:07
*/
@Mapper
public interface IRaffleActivityCountDao {
RaffleActivityCount queryRaffleActivityCountByActivityCountId(Long activityCountId);
}
|
2301_82000044/big-market-z
|
bigmarket-infrastructure/src/main/java/zack/project/infrastructure/persistent/dao/IRaffleActivityCountDao.java
|
Java
|
unknown
| 396
|
package zack.project.infrastructure.persistent.dao;
import zack.project.infrastructure.persistent.po.RaffleActivity;
import org.apache.ibatis.annotations.Mapper;
/**
* @description 抽奖活动表Dao
* @create 2024-03-09 10:04
*/
@Mapper
public interface IRaffleActivityDao {
RaffleActivity queryRaffleActivityByActivityId(Long activityId);
Long queryStrategyIdByActivityId(Long activityId);
Long queryActivityIdByStrategyId(Long strategyId);
}
|
2301_82000044/big-market-z
|
bigmarket-infrastructure/src/main/java/zack/project/infrastructure/persistent/dao/IRaffleActivityDao.java
|
Java
|
unknown
| 466
|
package zack.project.infrastructure.persistent.dao;
import zack.project.infrastructure.persistent.po.RaffleActivityOrder;
import cn.bugstack.middleware.db.router.annotation.DBRouter;
import cn.bugstack.middleware.db.router.annotation.DBRouterStrategy;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* @description 抽奖活动单Dao
* @create 2024-03-09 10:08
*/
@Mapper
@DBRouterStrategy(splitTable = true)
public interface IRaffleActivityOrderDao {
@DBRouter
void insert(RaffleActivityOrder raffleActivityOrder);
@DBRouter
List<RaffleActivityOrder> queryRaffleActivityOrderByUserId(String userId);
@DBRouter
RaffleActivityOrder queryRaffleActivityOrder(RaffleActivityOrder raffleActivityOrderReq);
int updateOrderCompleted(RaffleActivityOrder raffleActivityOrderReq);
@DBRouter
RaffleActivityOrder queryUnpaidActivityOrder(RaffleActivityOrder raffleActivityOrderReq);
}
|
2301_82000044/big-market-z
|
bigmarket-infrastructure/src/main/java/zack/project/infrastructure/persistent/dao/IRaffleActivityOrderDao.java
|
Java
|
unknown
| 946
|
package zack.project.infrastructure.persistent.dao;
import zack.project.infrastructure.persistent.po.RaffleActivitySku;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* @description 商品sku dao
* @create 2024-03-16 11:04
*/
@Mapper
public interface IRaffleActivitySkuDao {
RaffleActivitySku queryActivitySku(Long sku);
void updateActivitySkuStock(Long sku);
void clearActivitySkuStock(Long sku);
List<RaffleActivitySku> queryActivitySkuListByActivityId(Long activityId);
}
|
2301_82000044/big-market-z
|
bigmarket-infrastructure/src/main/java/zack/project/infrastructure/persistent/dao/IRaffleActivitySkuDao.java
|
Java
|
unknown
| 526
|
package zack.project.infrastructure.persistent.dao;
import zack.project.infrastructure.persistent.po.RuleTree;
import org.apache.ibatis.annotations.Mapper;
/**
* @description 规则树表DAO
* @create 2024-02-03 08:42
*/
@Mapper
public interface IRuleTreeDao {
RuleTree queryRuleTreeByTreeId(String treeId);
}
|
2301_82000044/big-market-z
|
bigmarket-infrastructure/src/main/java/zack/project/infrastructure/persistent/dao/IRuleTreeDao.java
|
Java
|
unknown
| 321
|
package zack.project.infrastructure.persistent.dao;
import zack.project.infrastructure.persistent.po.RuleTreeNode;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* @description 规则树节点表DAO
* @create 2024-02-03 08:43
*/
@Mapper
public interface IRuleTreeNodeDao {
List<RuleTreeNode> queryRuleTreeNodeListByTreeId(String treeId);
List<RuleTreeNode> queryRuleLocks(String[] treeIds);
}
|
2301_82000044/big-market-z
|
bigmarket-infrastructure/src/main/java/zack/project/infrastructure/persistent/dao/IRuleTreeNodeDao.java
|
Java
|
unknown
| 434
|
package zack.project.infrastructure.persistent.dao;
import zack.project.infrastructure.persistent.po.RuleTreeNodeLine;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* @description 规则树节点连线表DAO
* @create 2024-02-03 08:44
*/
@Mapper
public interface IRuleTreeNodeLineDao {
List<RuleTreeNodeLine> queryRuleTreeNodeLineListByTreeId(String treeId);
}
|
2301_82000044/big-market-z
|
bigmarket-infrastructure/src/main/java/zack/project/infrastructure/persistent/dao/IRuleTreeNodeLineDao.java
|
Java
|
unknown
| 399
|
package zack.project.infrastructure.persistent.dao;
import zack.project.infrastructure.persistent.po.StrategyAward;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* @author A1793
*/
@Mapper
public interface IStrategyAwardDao {
List<StrategyAward> queryStrategyAwardList();
List<StrategyAward> queryStrategyAwardListByStrategyId(Long strategyId);
String queryStrategyAwardRuleModels(StrategyAward strategyAward);
void updateStrategyAwardStock(StrategyAward strategyAward);
StrategyAward queryStrategyAward(StrategyAward strategyAwardReq);
}
|
2301_82000044/big-market-z
|
bigmarket-infrastructure/src/main/java/zack/project/infrastructure/persistent/dao/IStrategyAwardDao.java
|
Java
|
unknown
| 594
|
package zack.project.infrastructure.persistent.dao;
import zack.project.infrastructure.persistent.po.Strategy;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
@Mapper
public interface IStrategyDao {
List<Strategy> queryStrategyList();
Strategy queryStrategyByStrategyId(Long strategyId);
Long queryStrategyIdByActivityId(Long activityId);
}
|
2301_82000044/big-market-z
|
bigmarket-infrastructure/src/main/java/zack/project/infrastructure/persistent/dao/IStrategyDao.java
|
Java
|
unknown
| 381
|
package zack.project.infrastructure.persistent.dao;
import zack.project.infrastructure.persistent.po.StrategyRule;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
@Mapper
public interface IStrategyRuleDao {
List<StrategyRule> queryStrategyRuleList();
StrategyRule queryStrategyRule(StrategyRule strategyRuleReq);
String queryStrategyRuleValue(StrategyRule strategyRuleReq);
}
|
2301_82000044/big-market-z
|
bigmarket-infrastructure/src/main/java/zack/project/infrastructure/persistent/dao/IStrategyRuleDao.java
|
Java
|
unknown
| 414
|