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
|
|---|---|---|---|---|---|
/*
Navicat Premium Data Transfer
Source Server : localhost
Source Server Type : MySQL
Source Server Version : 50639
Source Host : localhost:3306
Source Schema : xxl_job
Target Server Type : MySQL
Target Server Version : 50639
File Encoding : 65001
Date: 04/12/2021 16:28:12
*/
create database xxl_job;
USE xxl_job;
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for xxl_job_group
-- ----------------------------
DROP TABLE IF EXISTS `xxl_job_group`;
CREATE TABLE `xxl_job_group` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`app_name` varchar(64) NOT NULL COMMENT '执行器AppName',
`title` varchar(12) NOT NULL COMMENT '执行器名称',
`address_type` tinyint(4) NOT NULL DEFAULT '0' COMMENT '执行器地址类型：0=自动注册、1=手动录入',
`address_list` text COMMENT '执行器地址列表，多地址逗号分隔',
`update_time` datetime DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4;
-- ----------------------------
-- Records of xxl_job_group
-- ----------------------------
BEGIN;
INSERT INTO `xxl_job_group` VALUES (1, 'xxl-job-executor-sample', '示例执行器', 0, NULL, '2021-11-20 20:28:29');
INSERT INTO `xxl_job_group` VALUES (2, 'lottery-job', '抽奖系统任务调度', 0, NULL, '2021-11-20 20:28:29');
COMMIT;
-- ----------------------------
-- Table structure for xxl_job_info
-- ----------------------------
DROP TABLE IF EXISTS `xxl_job_info`;
CREATE TABLE `xxl_job_info` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`job_group` int(11) NOT NULL COMMENT '执行器主键ID',
`job_desc` varchar(255) NOT NULL,
`add_time` datetime DEFAULT NULL,
`update_time` datetime DEFAULT NULL,
`author` varchar(64) DEFAULT NULL COMMENT '作者',
`alarm_email` varchar(255) DEFAULT NULL COMMENT '报警邮件',
`schedule_type` varchar(50) NOT NULL DEFAULT 'NONE' COMMENT '调度类型',
`schedule_conf` varchar(128) DEFAULT NULL COMMENT '调度配置，值含义取决于调度类型',
`misfire_strategy` varchar(50) NOT NULL DEFAULT 'DO_NOTHING' COMMENT '调度过期策略',
`executor_route_strategy` varchar(50) DEFAULT NULL COMMENT '执行器路由策略',
`executor_handler` varchar(255) DEFAULT NULL COMMENT '执行器任务handler',
`executor_param` varchar(512) DEFAULT NULL COMMENT '执行器任务参数',
`executor_block_strategy` varchar(50) DEFAULT NULL COMMENT '阻塞处理策略',
`executor_timeout` int(11) NOT NULL DEFAULT '0' COMMENT '任务执行超时时间，单位秒',
`executor_fail_retry_count` int(11) NOT NULL DEFAULT '0' COMMENT '失败重试次数',
`glue_type` varchar(50) NOT NULL COMMENT 'GLUE类型',
`glue_source` mediumtext COMMENT 'GLUE源代码',
`glue_remark` varchar(128) DEFAULT NULL COMMENT 'GLUE备注',
`glue_updatetime` datetime DEFAULT NULL COMMENT 'GLUE更新时间',
`child_jobid` varchar(255) DEFAULT NULL COMMENT '子任务ID，多个逗号分隔',
`trigger_status` tinyint(4) NOT NULL DEFAULT '0' COMMENT '调度状态：0-停止，1-运行',
`trigger_last_time` bigint(13) NOT NULL DEFAULT '0' COMMENT '上次调度时间',
`trigger_next_time` bigint(13) NOT NULL DEFAULT '0' COMMENT '下次调度时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4;
-- ----------------------------
-- Records of xxl_job_info
-- ----------------------------
BEGIN;
INSERT INTO `xxl_job_info` VALUES (1, 1, '测试任务1', '2018-11-03 22:21:31', '2021-11-06 14:54:29', 'XXL', '', 'CRON', '0/1 * * * * ?', 'DO_NOTHING', 'FIRST', 'demoJobHandler', '', 'SERIAL_EXECUTION', 0, 0, 'BEAN', '', 'GLUE代码初始化', '2018-11-03 22:21:31', '', 1, 1637411338000, 1637411339000);
INSERT INTO `xxl_job_info` VALUES (2, 2, '活动状态扫描', '2021-11-06 11:43:49', '2021-11-13 10:19:56', '小傅哥', '', 'CRON', '0/1 * * * * ?', 'DO_NOTHING', 'FIRST', 'lotteryActivityStateJobHandler', '', 'SERIAL_EXECUTION', 0, 0, 'BEAN', '', 'GLUE代码初始化', '2021-11-06 11:43:49', '', 0, 0, 0);
INSERT INTO `xxl_job_info` VALUES (3, 2, '扫描用户抽奖奖品发放MQ状态补偿', '2021-11-13 10:23:59', '2021-11-13 13:47:26', '小傅哥', '', 'CRON', '0/5 * * * * ?', 'DO_NOTHING', 'FIRST', 'lotteryOrderMQStateJobHandler', '1', 'SERIAL_EXECUTION', 0, 0, 'BEAN', '', 'GLUE代码初始化', '2021-11-13 10:23:59', '', 0, 0, 0);
COMMIT;
-- ----------------------------
-- Table structure for xxl_job_lock
-- ----------------------------
DROP TABLE IF EXISTS `xxl_job_lock`;
CREATE TABLE `xxl_job_lock` (
`lock_name` varchar(50) NOT NULL COMMENT '锁名称',
PRIMARY KEY (`lock_name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
-- ----------------------------
-- Records of xxl_job_lock
-- ----------------------------
BEGIN;
INSERT INTO `xxl_job_lock` VALUES ('schedule_lock');
COMMIT;
-- ----------------------------
-- Table structure for xxl_job_log
-- ----------------------------
DROP TABLE IF EXISTS `xxl_job_log`;
CREATE TABLE `xxl_job_log` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`job_group` int(11) NOT NULL COMMENT '执行器主键ID',
`job_id` int(11) NOT NULL COMMENT '任务，主键ID',
`executor_address` varchar(255) DEFAULT NULL COMMENT '执行器地址，本次执行的地址',
`executor_handler` varchar(255) DEFAULT NULL COMMENT '执行器任务handler',
`executor_param` varchar(512) DEFAULT NULL COMMENT '执行器任务参数',
`executor_sharding_param` varchar(20) DEFAULT NULL COMMENT '执行器任务分片参数，格式如 1/2',
`executor_fail_retry_count` int(11) NOT NULL DEFAULT '0' COMMENT '失败重试次数',
`trigger_time` datetime DEFAULT NULL COMMENT '调度-时间',
`trigger_code` int(11) NOT NULL COMMENT '调度-结果',
`trigger_msg` text COMMENT '调度-日志',
`handle_time` datetime DEFAULT NULL COMMENT '执行-时间',
`handle_code` int(11) NOT NULL COMMENT '执行-状态',
`handle_msg` text COMMENT '执行-日志',
`alarm_status` tinyint(4) NOT NULL DEFAULT '0' COMMENT '告警状态：0-默认、1-无需告警、2-告警成功、3-告警失败',
PRIMARY KEY (`id`),
KEY `I_trigger_time` (`trigger_time`),
KEY `I_handle_code` (`handle_code`)
) ENGINE=InnoDB AUTO_INCREMENT=56303 DEFAULT CHARSET=utf8mb4;
-- ----------------------------
-- Records of xxl_job_log
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Table structure for xxl_job_log_report
-- ----------------------------
DROP TABLE IF EXISTS `xxl_job_log_report`;
CREATE TABLE `xxl_job_log_report` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`trigger_day` datetime DEFAULT NULL COMMENT '调度-时间',
`running_count` int(11) NOT NULL DEFAULT '0' COMMENT '运行中-日志数量',
`suc_count` int(11) NOT NULL DEFAULT '0' COMMENT '执行成功-日志数量',
`fail_count` int(11) NOT NULL DEFAULT '0' COMMENT '执行失败-日志数量',
`update_time` datetime DEFAULT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `i_trigger_day` (`trigger_day`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8mb4;
-- ----------------------------
-- Records of xxl_job_log_report
-- ----------------------------
BEGIN;
INSERT INTO `xxl_job_log_report` VALUES (1, '2021-11-06 00:00:00', 0, 133, 17686, NULL);
INSERT INTO `xxl_job_log_report` VALUES (2, '2021-11-05 00:00:00', 0, 0, 0, NULL);
INSERT INTO `xxl_job_log_report` VALUES (3, '2021-11-04 00:00:00', 0, 0, 0, NULL);
INSERT INTO `xxl_job_log_report` VALUES (4, '2021-11-13 00:00:00', 0, 6, 13177, NULL);
INSERT INTO `xxl_job_log_report` VALUES (5, '2021-11-12 00:00:00', 0, 0, 0, NULL);
INSERT INTO `xxl_job_log_report` VALUES (6, '2021-11-11 00:00:00', 0, 0, 0, NULL);
INSERT INTO `xxl_job_log_report` VALUES (7, '2021-11-20 00:00:00', 0, 0, 25195, NULL);
INSERT INTO `xxl_job_log_report` VALUES (8, '2021-11-19 00:00:00', 0, 0, 0, NULL);
INSERT INTO `xxl_job_log_report` VALUES (9, '2021-11-18 00:00:00', 0, 0, 0, NULL);
COMMIT;
-- ----------------------------
-- Table structure for xxl_job_logglue
-- ----------------------------
DROP TABLE IF EXISTS `xxl_job_logglue`;
CREATE TABLE `xxl_job_logglue` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`job_id` int(11) NOT NULL COMMENT '任务，主键ID',
`glue_type` varchar(50) DEFAULT NULL COMMENT 'GLUE类型',
`glue_source` mediumtext COMMENT 'GLUE源代码',
`glue_remark` varchar(128) NOT NULL COMMENT 'GLUE备注',
`add_time` datetime DEFAULT NULL,
`update_time` datetime DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
-- ----------------------------
-- Records of xxl_job_logglue
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Table structure for xxl_job_registry
-- ----------------------------
DROP TABLE IF EXISTS `xxl_job_registry`;
CREATE TABLE `xxl_job_registry` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`registry_group` varchar(50) NOT NULL,
`registry_key` varchar(255) NOT NULL,
`registry_value` varchar(255) NOT NULL,
`update_time` datetime DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `i_g_k_v` (`registry_group`,`registry_key`(191),`registry_value`(191))
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
-- ----------------------------
-- Records of xxl_job_registry
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Table structure for xxl_job_user
-- ----------------------------
DROP TABLE IF EXISTS `xxl_job_user`;
CREATE TABLE `xxl_job_user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`username` varchar(50) NOT NULL COMMENT '账号',
`password` varchar(50) NOT NULL COMMENT '密码',
`role` tinyint(4) NOT NULL COMMENT '角色：0-普通用户、1-管理员',
`permission` varchar(255) DEFAULT NULL COMMENT '权限：执行器ID列表，多个逗号分割',
PRIMARY KEY (`id`),
UNIQUE KEY `i_username` (`username`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4;
-- ----------------------------
-- Records of xxl_job_user
-- ----------------------------
BEGIN;
INSERT INTO `xxl_job_user` VALUES (1, 'admin', 'e10adc3949ba59abbe56e057f20f883e', 1, NULL);
COMMIT;
SET FOREIGN_KEY_CHECKS = 1;
|
2302_77879529/lottery
|
doc/docker/mysql/db/xxl-job.sql
|
PLpgSQL
|
apache-2.0
| 10,152
|
# 基础镜像
FROM nacos/nacos-server:v2.0.3
# author
MAINTAINER bytemecc
# 复制conf文件到路径
COPY ./conf/application.properties /home/nacos/conf/application.properties
|
2302_77879529/lottery
|
doc/docker/nacos/Dockerfile
|
Dockerfile
|
apache-2.0
| 180
|
# 基础镜像
FROM redis
# author
MAINTAINER bytemecc
# 挂载目录
VOLUME /home/lottery/redis
# 创建目录
RUN mkdir -p /home/lottery/redis
# 指定路径
WORKDIR /home/lottery/redis
# 复制conf文件到路径
COPY ./conf/redis.conf /home/lottery/redis/redis.conf
|
2302_77879529/lottery
|
doc/docker/redis/Dockerfile
|
Dockerfile
|
apache-2.0
| 271
|
# 基础镜像
FROM nginx
# author
MAINTAINER bytemecc
# # 挂载目录
# VOLUME /home/trip/projects/trip-ui
# # 创建目录
# RUN mkdir -p /home/trip/projects/trip-ui
# # 指定路径
# WORKDIR /home/trip/projects/trip-ui
# 复制conf文件到路径
COPY ./conf/nginx.conf /etc/nginx/nginx.conf
# 复制html文件到路径
# COPY ./html/dist /home/trip/projects/trip-ui
|
2302_77879529/lottery
|
doc/docker/website/Dockerfile
|
Dockerfile
|
apache-2.0
| 373
|
<!DOCTYPE html>
<html>
<head>
<title>Error</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>An error occurred.</h1>
<p>Sorry, the page you are looking for is currently unavailable.<br/>
Please try again later.</p>
<p>If you are the system administrator of this resource then you should check
the error log for details.</p>
<p><em>Faithfully yours, nginx.</em></p>
</body>
</html>
|
2302_77879529/lottery
|
doc/docker/website/html/50x.html
|
HTML
|
apache-2.0
| 497
|
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>
<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>
<p><em>Thank you for using nginx.</em></p>
<h1>bytemecc</h1>
</body>
</html>
|
2302_77879529/lottery
|
doc/docker/website/html/index.html
|
HTML
|
apache-2.0
| 634
|
package cn.itedus.lottery.application.mq.consumer;
import cn.itedus.lottery.domain.activity.model.vo.ActivityPartakeRecordVO;
import cn.itedus.lottery.domain.activity.service.partake.IActivityPartake;
import com.alibaba.fastjson.JSON;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.support.Acknowledgment;
import org.springframework.kafka.support.KafkaHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Optional;
/**
* @description: 抽奖活动领取记录监听消息
* @author: 小傅哥，微信：fustack
* @date: 2021/11/20
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Component
public class LotteryActivityPartakeRecordListener {
private Logger logger = LoggerFactory.getLogger(LotteryActivityPartakeRecordListener.class);
@Resource
private IActivityPartake activityPartake;
@KafkaListener(topics = "lottery_activity_partake", groupId = "lottery")
public void onMessage(ConsumerRecord<?, ?> record, Acknowledgment ack, @Header(KafkaHeaders.RECEIVED_TOPIC) String topic) {
Optional<?> message = Optional.ofNullable(record.value());
// 0. 实际场景在消费MQ的时候，可以通过固定标识判断是否已经消费过，添加记录。对程序的处理会起到优化作用。
// 1. 判断消息是否存在
if (!message.isPresent()) {
return;
}
// 2. 转化对象（或者你也可以重写Serializer<T>）
ActivityPartakeRecordVO activityPartakeRecordVO = JSON.parseObject((String) message.get(), ActivityPartakeRecordVO.class);
logger.info("消费MQ消息，异步扣减活动库存 message：{}", message.get());
// 3. 更新数据库库存【实际场景业务体量较大，可能也会由于MQ消费引起并发，对数据库产生压力，所以如果并发量较大，可以把库存记录缓存中，并使用定时任务进行处理缓存和数据库库存同步，减少对数据库的操作次数】
activityPartake.updateActivityStock(activityPartakeRecordVO);
// 4. 消息消费完成
ack.acknowledge();
}
}
|
2302_77879529/lottery
|
lottery-application/src/main/java/cn/itedus/lottery/application/mq/consumer/LotteryActivityPartakeRecordListener.java
|
Java
|
apache-2.0
| 2,513
|
package cn.itedus.lottery.application.mq.consumer;
import cn.hutool.core.lang.Assert;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.domain.activity.model.vo.InvoiceVO;
import cn.itedus.lottery.domain.award.model.req.GoodsReq;
import cn.itedus.lottery.domain.award.model.res.DistributionRes;
import cn.itedus.lottery.domain.award.service.factory.DistributionGoodsFactory;
import cn.itedus.lottery.domain.award.service.goods.IDistributionGoods;
import com.alibaba.fastjson.JSON;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.support.Acknowledgment;
import org.springframework.kafka.support.KafkaHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Optional;
/**
* @description: 中奖发货单监听消息
* @author: 小傅哥，微信：fustack
* @date: 2021/10/30
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Component
public class LotteryInvoiceListener {
private Logger logger = LoggerFactory.getLogger(LotteryInvoiceListener.class);
@Resource
private DistributionGoodsFactory distributionGoodsFactory;
@KafkaListener(topics = "lottery_invoice", groupId = "lottery")
public void onMessage(ConsumerRecord<?, ?> record, Acknowledgment ack, @Header(KafkaHeaders.RECEIVED_TOPIC) String topic) {
Optional<?> message = Optional.ofNullable(record.value());
// 1. 判断消息是否存在
if (!message.isPresent()) {
return;
}
// 2. 处理 MQ 消息
try {
// 1. 转化对象（或者你也可以重写Serializer<T>）
InvoiceVO invoiceVO = JSON.parseObject((String) message.get(), InvoiceVO.class);
// 2. 获取发送奖品工厂，执行发奖
IDistributionGoods distributionGoodsService = distributionGoodsFactory.getDistributionGoodsService(invoiceVO.getAwardType());
DistributionRes distributionRes = distributionGoodsService.doDistribution(new GoodsReq(invoiceVO.getuId(), invoiceVO.getOrderId(), invoiceVO.getAwardId(), invoiceVO.getAwardName(), invoiceVO.getAwardContent()));
Assert.isTrue(Constants.AwardState.SUCCESS.getCode().equals(distributionRes.getCode()), distributionRes.getInfo());
// 3. 打印日志
logger.info("消费MQ消息，完成 topic：{} bizId：{} 发奖结果：{}", topic, invoiceVO.getuId(), JSON.toJSONString(distributionRes));
// 4. 消息消费完成
ack.acknowledge();
} catch (Exception e) {
// 发奖环节失败，消息重试。所有到环节，发货、更新库，都需要保证幂等。
logger.error("消费MQ消息，失败 topic：{} message：{}", topic, message.get());
throw e;
}
}
}
|
2302_77879529/lottery
|
lottery-application/src/main/java/cn/itedus/lottery/application/mq/consumer/LotteryInvoiceListener.java
|
Java
|
apache-2.0
| 3,149
|
package cn.itedus.lottery.application.mq.producer;
import cn.itedus.lottery.domain.activity.model.vo.ActivityPartakeRecordVO;
import cn.itedus.lottery.domain.activity.model.vo.InvoiceVO;
import com.alibaba.fastjson.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import org.springframework.stereotype.Component;
import org.springframework.util.concurrent.ListenableFuture;
import javax.annotation.Resource;
/**
* @description: MQ 消息发送服务
* @author: 小傅哥，微信：fustack
* @date: 2021/10/30
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Component
public class KafkaProducer {
private Logger logger = LoggerFactory.getLogger(KafkaProducer.class);
@Resource
private KafkaTemplate<String, Object> kafkaTemplate;
/**
* MQ主题：中奖发货单
*
* 启动zk：bin/zookeeper-server-start.sh -daemon config/zookeeper.properties
* 启动kafka：bin/kafka-server-start.sh -daemon config/server.properties
* 创建topic：bin/kafka-topics.sh --create --zookeeper 172.17.0.5:2181 --replication-factor 1 --partitions 1 --topic lottery_invoice
*/
public static final String TOPIC_INVOICE = "lottery_invoice";
/**
* MQ主题：活动领取记录
*
* 创建topic：bin/kafka-topics.sh --create --zookeeper 172.17.0.5:2181 --replication-factor 1 --partitions 1 --topic lottery_activity_partake
*/
public static final String TOPIC_ACTIVITY_PARTAKE = "lottery_activity_partake";
/**
* 发送中奖物品发货单消息
*
* @param invoice 发货单
*/
public ListenableFuture<SendResult<String, Object>> sendLotteryInvoice(InvoiceVO invoice) {
String objJson = JSON.toJSONString(invoice);
logger.info("发送MQ消息(中奖发货单) topic：{} bizId：{} message：{}", TOPIC_INVOICE, invoice.getuId(), objJson);
return kafkaTemplate.send(TOPIC_INVOICE, objJson);
}
/**
* 发送领取活动记录MQ
*
* @param activityPartakeRecord 领取活动记录
*/
public ListenableFuture<SendResult<String, Object>> sendLotteryActivityPartakeRecord(ActivityPartakeRecordVO activityPartakeRecord) {
String objJson = JSON.toJSONString(activityPartakeRecord);
logger.info("发送MQ消息(领取活动记录) topic：{} bizId：{} message：{}", TOPIC_ACTIVITY_PARTAKE, activityPartakeRecord.getuId(), objJson);
return kafkaTemplate.send(TOPIC_ACTIVITY_PARTAKE, objJson);
}
}
|
2302_77879529/lottery
|
lottery-application/src/main/java/cn/itedus/lottery/application/mq/producer/KafkaProducer.java
|
Java
|
apache-2.0
| 2,734
|
package cn.itedus.lottery.application.process.deploy;
import cn.itedus.lottery.domain.activity.model.aggregates.ActivityInfoLimitPageRich;
import cn.itedus.lottery.domain.activity.model.req.ActivityInfoLimitPageReq;
/**
* @description: 活动部署接口；查询列表、创建活动、修改活动、删除活动(一般实际场景为逻辑删除)，如果活动的部署需要做一些逻辑校验，那么可以在这一层做编排
* @author: 小傅哥，微信：fustack
* @date: 2021/12/11
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public interface IActivityDeployProcess {
/**
* 查询活动分页查询聚合对象
*
* @param req 请求参数；分页、活动
* @return 查询结果
*/
ActivityInfoLimitPageRich queryActivityInfoLimitPage(ActivityInfoLimitPageReq req);
}
|
2302_77879529/lottery
|
lottery-application/src/main/java/cn/itedus/lottery/application/process/deploy/IActivityDeployProcess.java
|
Java
|
apache-2.0
| 974
|
package cn.itedus.lottery.application.process.deploy.impl;
import cn.itedus.lottery.application.process.deploy.IActivityDeployProcess;
import cn.itedus.lottery.domain.activity.model.aggregates.ActivityInfoLimitPageRich;
import cn.itedus.lottery.domain.activity.model.req.ActivityInfoLimitPageReq;
import cn.itedus.lottery.domain.activity.service.deploy.IActivityDeploy;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* @description: 活动部署实现
* @author: 小傅哥，微信：fustack
* @date: 2021/12/11
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Service
public class ActivityDeployProcessImpl implements IActivityDeployProcess {
@Resource
private IActivityDeploy activityDeploy;
@Override
public ActivityInfoLimitPageRich queryActivityInfoLimitPage(ActivityInfoLimitPageReq req) {
return activityDeploy.queryActivityInfoLimitPage(req);
}
}
|
2302_77879529/lottery
|
lottery-application/src/main/java/cn/itedus/lottery/application/process/deploy/impl/ActivityDeployProcessImpl.java
|
Java
|
apache-2.0
| 1,072
|
package cn.itedus.lottery.application.process.draw;
import cn.itedus.lottery.application.process.draw.req.DrawProcessReq;
import cn.itedus.lottery.application.process.draw.res.DrawProcessResult;
import cn.itedus.lottery.application.process.draw.res.RuleQuantificationCrowdResult;
import cn.itedus.lottery.domain.rule.model.req.DecisionMatterReq;
/**
* @description: 活动抽奖流程编排接口
* @author: 小傅哥，微信：fustack
* @date: 2021/10/3
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public interface IActivityDrawProcess {
/**
* 执行抽奖流程
* @param req 抽奖请求
* @return 抽奖结果
*/
DrawProcessResult doDrawProcess(DrawProcessReq req);
/**
* 规则量化人群，返回可参与的活动ID
* @param req 规则请求
* @return 量化结果，用户可以参与的活动ID
*/
RuleQuantificationCrowdResult doRuleQuantificationCrowd(DecisionMatterReq req);
}
|
2302_77879529/lottery
|
lottery-application/src/main/java/cn/itedus/lottery/application/process/draw/IActivityDrawProcess.java
|
Java
|
apache-2.0
| 1,111
|
package cn.itedus.lottery.application.process.draw.impl;
import cn.itedus.lottery.application.mq.producer.KafkaProducer;
import cn.itedus.lottery.application.process.draw.IActivityDrawProcess;
import cn.itedus.lottery.application.process.draw.req.DrawProcessReq;
import cn.itedus.lottery.application.process.draw.res.DrawProcessResult;
import cn.itedus.lottery.application.process.draw.res.RuleQuantificationCrowdResult;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.common.Result;
import cn.itedus.lottery.domain.activity.model.req.PartakeReq;
import cn.itedus.lottery.domain.activity.model.res.PartakeResult;
import cn.itedus.lottery.domain.activity.model.vo.ActivityPartakeRecordVO;
import cn.itedus.lottery.domain.activity.model.vo.DrawOrderVO;
import cn.itedus.lottery.domain.activity.model.vo.InvoiceVO;
import cn.itedus.lottery.domain.activity.service.partake.IActivityPartake;
import cn.itedus.lottery.domain.rule.model.req.DecisionMatterReq;
import cn.itedus.lottery.domain.rule.model.res.EngineResult;
import cn.itedus.lottery.domain.rule.service.engine.EngineFilter;
import cn.itedus.lottery.domain.strategy.model.req.DrawReq;
import cn.itedus.lottery.domain.strategy.model.res.DrawResult;
import cn.itedus.lottery.domain.strategy.model.vo.DrawAwardVO;
import cn.itedus.lottery.domain.strategy.service.draw.IDrawExec;
import cn.itedus.lottery.domain.support.ids.IIdGenerator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.kafka.support.SendResult;
import org.springframework.stereotype.Service;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;
import javax.annotation.Resource;
import java.util.Map;
/**
* @description: 活动抽奖流程编排
* @author: 小傅哥，微信：fustack
* @date: 2021/10/3
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Service
public class ActivityDrawProcessImpl implements IActivityDrawProcess {
private Logger logger = LoggerFactory.getLogger(ActivityDrawProcessImpl.class);
@Resource
private IActivityPartake activityPartake;
@Resource
private IDrawExec drawExec;
@Resource(name = "ruleEngineHandle")
private EngineFilter engineFilter;
@Resource
private Map<Constants.Ids, IIdGenerator> idGeneratorMap;
@Resource
private KafkaProducer kafkaProducer;
@Override
public DrawProcessResult doDrawProcess(DrawProcessReq req) {
// 1. 领取活动
PartakeResult partakeResult = activityPartake.doPartake(new PartakeReq(req.getuId(), req.getActivityId()));
if (!Constants.ResponseCode.SUCCESS.getCode().equals(partakeResult.getCode()) && !Constants.ResponseCode.NOT_CONSUMED_TAKE.getCode().equals(partakeResult.getCode())) {
return new DrawProcessResult(partakeResult.getCode(), partakeResult.getInfo());
}
// 2. 首次成功领取活动，发送 MQ 消息
if (Constants.ResponseCode.SUCCESS.getCode().equals(partakeResult.getCode())) {
ActivityPartakeRecordVO activityPartakeRecord = new ActivityPartakeRecordVO();
activityPartakeRecord.setuId(req.getuId());
activityPartakeRecord.setActivityId(req.getActivityId());
activityPartakeRecord.setStockCount(partakeResult.getStockCount());
activityPartakeRecord.setStockSurplusCount(partakeResult.getStockSurplusCount());
// 发送 MQ 消息
kafkaProducer.sendLotteryActivityPartakeRecord(activityPartakeRecord);
}
Long strategyId = partakeResult.getStrategyId();
Long takeId = partakeResult.getTakeId();
// 3. 执行抽奖
DrawResult drawResult = drawExec.doDrawExec(new DrawReq(req.getuId(), strategyId));
if (Constants.DrawState.FAIL.getCode().equals(drawResult.getDrawState())) {
// TODO 需要做个优化，如果用户是正常流程未中奖。那么应该扣掉当前抽奖单，修改状态为1 感谢星球伙伴 @忘谷茄茄 发现bug
Result result = activityPartake.lockTackActivity(req.getuId(), req.getActivityId(), takeId);
if (!Constants.ResponseCode.SUCCESS.getCode().equals(result.getCode())) return new DrawProcessResult(Constants.ResponseCode.UN_ERROR.getCode(), Constants.ResponseCode.UN_ERROR.getInfo());
return new DrawProcessResult(Constants.ResponseCode.LOSING_DRAW.getCode(), Constants.ResponseCode.LOSING_DRAW.getInfo());
}
DrawAwardVO drawAwardVO = drawResult.getDrawAwardInfo();
// 4. 结果落库
DrawOrderVO drawOrderVO = buildDrawOrderVO(req, strategyId, takeId, drawAwardVO);
Result recordResult = activityPartake.recordDrawOrder(drawOrderVO);
if (!Constants.ResponseCode.SUCCESS.getCode().equals(recordResult.getCode())) {
return new DrawProcessResult(recordResult.getCode(), recordResult.getInfo());
}
// 5. 发送MQ，触发发奖流程
InvoiceVO invoiceVO = buildInvoiceVO(drawOrderVO);
ListenableFuture<SendResult<String, Object>> future = kafkaProducer.sendLotteryInvoice(invoiceVO);
future.addCallback(new ListenableFutureCallback<SendResult<String, Object>>() {
@Override
public void onSuccess(SendResult<String, Object> stringObjectSendResult) {
// 4.1 MQ 消息发送完成，更新数据库表 user_strategy_export.mq_state = 1
activityPartake.updateInvoiceMqState(invoiceVO.getuId(), invoiceVO.getOrderId(), Constants.MQState.COMPLETE.getCode());
}
@Override
public void onFailure(Throwable throwable) {
// 4.2 MQ 消息发送失败，更新数据库表 user_strategy_export.mq_state = 2 【等待定时任务扫码补偿MQ消息】
activityPartake.updateInvoiceMqState(invoiceVO.getuId(), invoiceVO.getOrderId(), Constants.MQState.FAIL.getCode());
}
});
// 6. 返回结果
return new DrawProcessResult(Constants.ResponseCode.SUCCESS.getCode(), Constants.ResponseCode.SUCCESS.getInfo(), drawAwardVO);
}
@Override
public RuleQuantificationCrowdResult doRuleQuantificationCrowd(DecisionMatterReq req) {
// 1. 量化决策
EngineResult engineResult = engineFilter.process(req);
if (!engineResult.isSuccess()) {
return new RuleQuantificationCrowdResult(Constants.ResponseCode.RULE_ERR.getCode(), Constants.ResponseCode.RULE_ERR.getInfo());
}
// 2. 封装结果
RuleQuantificationCrowdResult ruleQuantificationCrowdResult = new RuleQuantificationCrowdResult(Constants.ResponseCode.SUCCESS.getCode(), Constants.ResponseCode.SUCCESS.getInfo());
ruleQuantificationCrowdResult.setActivityId(Long.valueOf(engineResult.getNodeValue()));
return ruleQuantificationCrowdResult;
}
private DrawOrderVO buildDrawOrderVO(DrawProcessReq req, Long strategyId, Long takeId, DrawAwardVO drawAwardVO) {
long orderId = idGeneratorMap.get(Constants.Ids.SnowFlake).nextId();
DrawOrderVO drawOrderVO = new DrawOrderVO();
drawOrderVO.setuId(req.getuId());
drawOrderVO.setTakeId(takeId);
drawOrderVO.setActivityId(req.getActivityId());
drawOrderVO.setOrderId(orderId);
drawOrderVO.setStrategyId(strategyId);
drawOrderVO.setStrategyMode(drawAwardVO.getStrategyMode());
drawOrderVO.setGrantType(drawAwardVO.getGrantType());
drawOrderVO.setGrantDate(drawAwardVO.getGrantDate());
drawOrderVO.setGrantState(Constants.GrantState.INIT.getCode());
drawOrderVO.setAwardId(drawAwardVO.getAwardId());
drawOrderVO.setAwardType(drawAwardVO.getAwardType());
drawOrderVO.setAwardName(drawAwardVO.getAwardName());
drawOrderVO.setAwardContent(drawAwardVO.getAwardContent());
return drawOrderVO;
}
private InvoiceVO buildInvoiceVO(DrawOrderVO drawOrderVO) {
InvoiceVO invoiceVO = new InvoiceVO();
invoiceVO.setuId(drawOrderVO.getuId());
invoiceVO.setOrderId(drawOrderVO.getOrderId());
invoiceVO.setAwardId(drawOrderVO.getAwardId());
invoiceVO.setAwardType(drawOrderVO.getAwardType());
invoiceVO.setAwardName(drawOrderVO.getAwardName());
invoiceVO.setAwardContent(drawOrderVO.getAwardContent());
invoiceVO.setShippingAddress(null);
invoiceVO.setExtInfo(null);
return invoiceVO;
}
}
|
2302_77879529/lottery
|
lottery-application/src/main/java/cn/itedus/lottery/application/process/draw/impl/ActivityDrawProcessImpl.java
|
Java
|
apache-2.0
| 8,648
|
package cn.itedus.lottery.application.process.draw.req;
/**
* @description: 抽奖请求
* @author: 小傅哥，微信：fustack
* @date: 2021/10/3
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class DrawProcessReq {
/** 用户ID */
private String uId;
/** 活动ID */
private Long activityId;
public DrawProcessReq() {
}
public DrawProcessReq(String uId, Long activityId) {
this.uId = uId;
this.activityId = activityId;
}
public String getuId() {
return uId;
}
public void setuId(String uId) {
this.uId = uId;
}
public Long getActivityId() {
return activityId;
}
public void setActivityId(Long activityId) {
this.activityId = activityId;
}
}
|
2302_77879529/lottery
|
lottery-application/src/main/java/cn/itedus/lottery/application/process/draw/req/DrawProcessReq.java
|
Java
|
apache-2.0
| 919
|
package cn.itedus.lottery.application.process.draw.res;
import cn.itedus.lottery.common.Result;
import cn.itedus.lottery.domain.strategy.model.vo.DrawAwardVO;
/**
* @description: 活动抽奖结果
* @author: 小傅哥，微信：fustack
* @date: 2021/10/3
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class DrawProcessResult extends Result {
private DrawAwardVO drawAwardVO;
public DrawProcessResult(String code, String info) {
super(code, info);
}
public DrawProcessResult(String code, String info, DrawAwardVO drawAwardVO) {
super(code, info);
this.drawAwardVO = drawAwardVO;
}
public DrawAwardVO getDrawAwardVO() {
return drawAwardVO;
}
public void setDrawAwardVO(DrawAwardVO drawAwardVO) {
this.drawAwardVO = drawAwardVO;
}
}
|
2302_77879529/lottery
|
lottery-application/src/main/java/cn/itedus/lottery/application/process/draw/res/DrawProcessResult.java
|
Java
|
apache-2.0
| 971
|
package cn.itedus.lottery.application.process.draw.res;
import cn.itedus.lottery.common.Result;
/**
* @description:
* @author: 小傅哥，微信：fustack
* @date: 2021/10/16
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class RuleQuantificationCrowdResult extends Result {
/** 活动ID */
private Long activityId;
public RuleQuantificationCrowdResult(String code, String info) {
super(code, info);
}
public Long getActivityId() {
return activityId;
}
public void setActivityId(Long activityId) {
this.activityId = activityId;
}
}
|
2302_77879529/lottery
|
lottery-application/src/main/java/cn/itedus/lottery/application/process/draw/res/RuleQuantificationCrowdResult.java
|
Java
|
apache-2.0
| 750
|
package cn.itedus.lottery.application.worker;
import cn.bugstack.middleware.db.router.strategy.IDBRouterStrategy;
import cn.itedus.lottery.application.mq.producer.KafkaProducer;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.common.Result;
import cn.itedus.lottery.domain.activity.model.vo.ActivityVO;
import cn.itedus.lottery.domain.activity.model.vo.InvoiceVO;
import cn.itedus.lottery.domain.activity.service.deploy.IActivityDeploy;
import cn.itedus.lottery.domain.activity.service.partake.IActivityPartake;
import cn.itedus.lottery.domain.activity.service.stateflow.IStateHandler;
import com.alibaba.fastjson.JSON;
import com.xxl.job.core.context.XxlJobHelper;
import com.xxl.job.core.handler.annotation.XxlJob;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.kafka.support.SendResult;
import org.springframework.stereotype.Component;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;
import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
/**
* @description: 抽奖业务，任务配置
* @author: 小傅哥，微信：fustack
* @date: 2021/11/6
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Component
public class LotteryXxlJob {
private Logger logger = LoggerFactory.getLogger(LotteryXxlJob.class);
@Resource
private IActivityDeploy activityDeploy;
@Resource
private IActivityPartake activityPartake;
@Resource
private IStateHandler stateHandler;
@Resource
private IDBRouterStrategy dbRouter;
@Resource
private KafkaProducer kafkaProducer;
@XxlJob("lotteryActivityStateJobHandler")
public void lotteryActivityStateJobHandler() throws Exception {
logger.info("扫描活动状态 Begin");
List<ActivityVO> activityVOList = activityDeploy.scanToDoActivityList(0L);
if (activityVOList.isEmpty()) {
logger.info("扫描活动状态 End 暂无符合需要扫描的活动列表");
return;
}
while (!activityVOList.isEmpty()) {
for (ActivityVO activityVO : activityVOList) {
Integer state = activityVO.getState();
switch (state) {
// 活动状态为审核通过，在临近活动开启时间前，审核活动为活动中。在使用活动的时候，需要依照活动状态核时间两个字段进行判断和使用。
case 4:
Result state4Result = stateHandler.doing(activityVO.getActivityId(), Constants.ActivityState.PASS);
logger.info("扫描活动状态为活动中 结果：{} activityId：{} activityName：{} creator：{}", JSON.toJSONString(state4Result), activityVO.getActivityId(), activityVO.getActivityName(), activityVO.getCreator());
break;
// 扫描时间已过期的活动，从活动中状态变更为关闭状态【这里也可以细化为2个任务来处理，也可以把时间判断放到数据库中操作】
case 5:
if (activityVO.getEndDateTime().before(new Date())) {
Result state5Result = stateHandler.close(activityVO.getActivityId(), Constants.ActivityState.DOING);
logger.info("扫描活动状态为关闭 结果：{} activityId：{} activityName：{} creator：{}", JSON.toJSONString(state5Result), activityVO.getActivityId(), activityVO.getActivityName(), activityVO.getCreator());
}
break;
default:
break;
}
}
// 获取集合中最后一条记录，继续扫描后面10条记录
ActivityVO activityVO = activityVOList.get(activityVOList.size() - 1);
activityVOList = activityDeploy.scanToDoActivityList(activityVO.getId());
}
logger.info("扫描活动状态 End");
}
@XxlJob("lotteryOrderMQStateJobHandler")
public void lotteryOrderMQStateJobHandler() throws Exception {
// 验证参数
String jobParam = XxlJobHelper.getJobParam();
if (null == jobParam) {
logger.info("扫描用户抽奖奖品发放MQ状态[Table = 2*4] 错误 params is null");
return;
}
// 获取分布式任务配置参数信息 参数配置格式：1,2,3 也可以是指定扫描一个，也可以配置多个库，按照部署的任务集群进行数量配置，均摊分别扫描效率更高
String[] params = jobParam.split(",");
logger.info("扫描用户抽奖奖品发放MQ状态[Table = 2*4] 开始 params：{}", JSON.toJSONString(params));
if (params.length == 0) {
logger.info("扫描用户抽奖奖品发放MQ状态[Table = 2*4] 结束 params is null");
return;
}
// 获取分库分表配置下的分表数
int tbCount = dbRouter.tbCount();
// 循环获取指定扫描库
for (String param : params) {
// 获取当前任务扫描的指定分库
int dbCount = Integer.parseInt(param);
// 判断配置指定扫描库数，是否存在
if (dbCount > dbRouter.dbCount()) {
logger.info("扫描用户抽奖奖品发放MQ状态[Table = 2*4] 结束 dbCount not exist");
continue;
}
// 循环扫描对应表
for (int i = 0; i < tbCount; i++) {
// 扫描库表数据
List<InvoiceVO> invoiceVOList = activityPartake.scanInvoiceMqState(dbCount, i);
logger.info("扫描用户抽奖奖品发放MQ状态[Table = 2*4] 扫描库：{} 扫描表：{} 扫描数：{}", dbCount, i, invoiceVOList.size());
// 补偿 MQ 消息
for (InvoiceVO invoiceVO : invoiceVOList) {
ListenableFuture<SendResult<String, Object>> future = kafkaProducer.sendLotteryInvoice(invoiceVO);
future.addCallback(new ListenableFutureCallback<SendResult<String, Object>>() {
@Override
public void onSuccess(SendResult<String, Object> stringObjectSendResult) {
// MQ 消息发送完成，更新数据库表 user_strategy_export.mq_state = 1
activityPartake.updateInvoiceMqState(invoiceVO.getuId(), invoiceVO.getOrderId(), Constants.MQState.COMPLETE.getCode());
}
@Override
public void onFailure(Throwable throwable) {
// MQ 消息发送失败，更新数据库表 user_strategy_export.mq_state = 2 【等待定时任务扫码补偿MQ消息】
activityPartake.updateInvoiceMqState(invoiceVO.getuId(), invoiceVO.getOrderId(), Constants.MQState.FAIL.getCode());
}
});
}
}
}
logger.info("扫描用户抽奖奖品发放MQ状态[Table = 2*4] 完成 param：{}", JSON.toJSONString(params));
}
}
|
2302_77879529/lottery
|
lottery-application/src/main/java/cn/itedus/lottery/application/worker/LotteryXxlJob.java
|
Java
|
apache-2.0
| 7,385
|
package cn.itedus.lottery.application.worker;
import com.xxl.job.core.executor.impl.XxlJobSpringExecutor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @description: XXL-JOB 配置
* @author: 小傅哥，微信：fustack
* @date: 2021/11/6
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Configuration
public class LotteryXxlJobConfig {
private Logger logger = LoggerFactory.getLogger(LotteryXxlJobConfig.class);
@Value("${xxl.job.admin.addresses}")
private String adminAddresses;
@Value("${xxl.job.accessToken}")
private String accessToken;
@Value("${xxl.job.executor.appname}")
private String appname;
@Value("${xxl.job.executor.address}")
private String address;
@Value("${xxl.job.executor.ip}")
private String ip;
@Value("${xxl.job.executor.port}")
private int port;
@Value("${xxl.job.executor.logpath}")
private String logPath;
@Value("${xxl.job.executor.logretentiondays}")
private int logRetentionDays;
@Bean
public XxlJobSpringExecutor xxlJobExecutor() {
logger.info(">>>>>>>>>>> xxl-job config init.");
XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
xxlJobSpringExecutor.setAppname(appname);
xxlJobSpringExecutor.setAddress(address);
xxlJobSpringExecutor.setIp(ip);
xxlJobSpringExecutor.setPort(port);
xxlJobSpringExecutor.setAccessToken(accessToken);
xxlJobSpringExecutor.setLogPath(logPath);
xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);
return xxlJobSpringExecutor;
}
/**********************************************************************************************
* 针对多网卡、容器内部署等情况，可借助 "spring-cloud-commons" 提供的 "InetUtils" 组件灵活定制注册IP；
*
* 1、引入依赖：
* <dependency>
* <groupId>org.springframework.cloud</groupId>
* <artifactId>spring-cloud-commons</artifactId>
* <version>${version}</version>
* </dependency>
*
* 2、配置文件，或者容器启动变量
* spring.cloud.inetutils.preferred-networks: 'xxx.xxx.xxx.'
*
* 3、获取IP
* String ip_ = inetUtils.findFirstNonLoopbackHostInfo().getIpAddress();
**********************************************************************************************/
}
|
2302_77879529/lottery
|
lottery-application/src/main/java/cn/itedus/lottery/application/worker/LotteryXxlJobConfig.java
|
Java
|
apache-2.0
| 2,864
|
package cn.itedus.lottery.common;
/**
* @description: 枚举信息定义
* @author：小傅哥，微信：fustack
* @date: 2021/8/28
* @Copyright：公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class Constants {
public enum ResponseCode {
SUCCESS("0000", "成功"),
UN_ERROR("0001", "未知失败"),
ILLEGAL_PARAMETER("0002", "非法参数"),
INDEX_DUP("0003", "主键冲突"),
NO_UPDATE("0004", "SQL操作无更新"),
LOSING_DRAW("D001", "未中奖"),
RULE_ERR("D002", "量化人群规则执行失败"),
NOT_CONSUMED_TAKE("D003", "未消费活动领取记录"),
OUT_OF_STOCK("D004", "活动无库存"),
ERR_TOKEN("D005", "分布式锁失败");
private String code;
private String info;
ResponseCode(String code, String info) {
this.code = code;
this.info = info;
}
public String getCode() {
return code;
}
public String getInfo() {
return info;
}
}
/**
* 全局属性
*/
public static final class Global {
/**
* 空节点值
*/
public static final Long TREE_NULL_NODE = 0L;
}
/**
* 缓存 Key
*/
public static final class RedisKey {
// 抽奖活动库存 Key
private static final String LOTTERY_ACTIVITY_STOCK_COUNT = "lottery_activity_stock_count_";
public static String KEY_LOTTERY_ACTIVITY_STOCK_COUNT(Long activityId) {
return LOTTERY_ACTIVITY_STOCK_COUNT + activityId;
}
// 抽奖活动库存锁 Key
private static final String LOTTERY_ACTIVITY_STOCK_COUNT_TOKEN = "lottery_activity_stock_count_token_";
public static String KEY_LOTTERY_ACTIVITY_STOCK_COUNT_TOKEN(Long activityId, Integer stockUsedCount) {
return LOTTERY_ACTIVITY_STOCK_COUNT_TOKEN + activityId + "_" + stockUsedCount;
}
}
/**
* 决策树节点
*/
public static final class NodeType {
/**
* 树茎
*/
public static final Integer STEM = 1;
/**
* 果实
*/
public static final Integer FRUIT = 2;
}
/**
* 规则限定类型
*/
public static final class RuleLimitType {
/**
* 等于
*/
public static final int EQUAL = 1;
/**
* 大于
*/
public static final int GT = 2;
/**
* 小于
*/
public static final int LT = 3;
/**
* 大于&等于
*/
public static final int GE = 4;
/**
* 小于&等于
*/
public static final int LE = 5;
/**
* 枚举
*/
public static final int ENUM = 6;
}
/**
* 活动状态：1编辑、2提审、3撤审、4通过、5运行(审核通过后worker扫描状态)、6拒绝、7关闭、8开启
*/
public enum ActivityState {
/**
* 1：编辑
*/
EDIT(1, "编辑"),
/**
* 2：提审
*/
ARRAIGNMENT(2, "提审"),
/**
* 3：撤审
*/
REVOKE(3, "撤审"),
/**
* 4：通过
*/
PASS(4, "通过"),
/**
* 5：运行(活动中)
*/
DOING(5, "运行(活动中)"),
/**
* 6：拒绝
*/
REFUSE(6, "拒绝"),
/**
* 7：关闭
*/
CLOSE(7, "关闭"),
/**
* 8：开启
*/
OPEN(8, "开启");
private Integer code;
private String info;
ActivityState(Integer code, String info) {
this.code = code;
this.info = info;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
/**
* 抽奖策略模式：总体概率、单项概率
* 场景：两种抽奖算法描述，场景A20%、B30%、C50%
* 单项概率：如果A奖品抽空后，B和C保持目前中奖概率，用户抽奖扔有20%中为A，因A库存抽空则结果展示为未中奖。为了运营成本，通常这种情况的使用的比较多
* 总体概率：如果A奖品抽空后，B和C奖品的概率按照 3:5 均分，相当于B奖品中奖概率由 0.3 升为 0.375
*/
public enum StrategyMode {
/**
* 单项概率：如果A奖品抽空后，B和C保持目前中奖概率，用户抽奖扔有20%中为A，因A库存抽空则结果展示为未中奖。为了运营成本，通常这种情况的使用的比较多
*/
SINGLE(1, "单项概率"),
/**
* 总体概率：如果A奖品抽空后，B和C奖品的概率按照 3:5 均分，相当于B奖品中奖概率由 0.3 升为 0.375
*/
ENTIRETY(2, "总体概率");
private Integer code;
private String info;
StrategyMode(Integer code, String info) {
this.code = code;
this.info = info;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
/**
* 中奖状态：0未中奖、1已中奖、2兜底奖
*/
public enum DrawState {
/**
* 未中奖
*/
FAIL(0, "未中奖"),
/**
* 已中奖
*/
SUCCESS(1, "已中奖"),
/**
* 兜底奖
*/
Cover(2, "兜底奖");
private Integer code;
private String info;
DrawState(Integer code, String info) {
this.code = code;
this.info = info;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
/**
* 发奖状态：0等待发奖、1发奖成功、2发奖失败
*/
public enum AwardState {
/**
* 等待发奖
*/
WAIT(0, "等待发奖"),
/**
* 发奖成功
*/
SUCCESS(1, "发奖成功"),
/**
* 发奖失败
*/
FAILURE(2, "发奖失败");
private Integer code;
private String info;
AwardState(Integer code, String info) {
this.code = code;
this.info = info;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
/**
* 奖品类型（1:文字描述、2:兑换码、3:优惠券、4:实物奖品）
*/
public enum AwardType {
/**
* 文字描述
*/
DESC(1, "文字描述"),
/**
* 兑换码
*/
RedeemCodeGoods(2, "兑换码"),
/**
* 优惠券
*/
CouponGoods(3, "优惠券"),
/**
* 实物奖品
*/
PhysicalGoods(4, "实物奖品");
private Integer code;
private String info;
AwardType(Integer code, String info) {
this.code = code;
this.info = info;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
/**
* Ids 生成策略枚举
*/
public enum Ids {
/**
* 雪花算法
*/
SnowFlake,
/**
* 日期算法
*/
ShortCode,
/**
* 随机算法
*/
RandomNumeric;
}
/**
* 活动单使用状态 0未使用、1已使用
*/
public enum TaskState {
NO_USED(0, "未使用"),
USED(1, "已使用");
private Integer code;
private String info;
TaskState(Integer code, String info) {
this.code = code;
this.info = info;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
/**
* 发奖状态 0初始、1完成、2失败
*/
public enum GrantState {
INIT(0, "初始"),
COMPLETE(1, "完成"),
FAIL(2, "失败");
private Integer code;
private String info;
GrantState(Integer code, String info) {
this.code = code;
this.info = info;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
/**
* 消息发送状态（0未发送、1发送成功、2发送失败）
*/
public enum MQState {
INIT(0, "初始"),
COMPLETE(1, "完成"),
FAIL(2, "失败");
private Integer code;
private String info;
MQState(Integer code, String info) {
this.code = code;
this.info = info;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
}
|
2302_77879529/lottery
|
lottery-common/src/main/java/cn/itedus/lottery/common/Constants.java
|
Java
|
apache-2.0
| 10,714
|
package cn.itedus.lottery.common;
/**
* @description: 分页类
* @author: 小傅哥，微信：fustack
* @date: 2021/12/11
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class PageRequest {
/**
* 开始 limit 第1个入参
*/
private int pageBegin = 0;
/**
* 开始 limit 第2个入参
*/
private int pageEnd = 0;
/**
* 页数
*/
private int page;
/**
* 行数
*/
private int rows;
public PageRequest() {
}
public PageRequest(String page, String rows) {
this.setPage(page, rows);
}
public PageRequest(int page, int rows) {
this.setPage(page, rows);
}
public void setPage(String page, String rows) {
this.page = null == page ? 1 : Integer.parseInt(page);
this.rows = null == page ? 10 : Integer.parseInt(rows);
if (0 == this.page) {
this.page = 1;
}
this.pageBegin = (this.page - 1) * this.rows;
this.pageEnd = this.rows;
}
public void setPage(int page, int rows) {
this.page = page;
this.rows = rows;
if (0 == this.page) {
this.page = 1;
}
this.pageBegin = (this.page - 1) * this.rows;
this.pageEnd = this.rows;
}
public int getPage() {
return page;
}
public void setPage(int page) {
this.page = page;
}
public int getRows() {
return rows;
}
public void setRows(int rows) {
this.rows = rows;
}
public int getPageBegin() {
return pageBegin;
}
public void setPageBegin(int pageBegin) {
this.pageBegin = pageBegin;
}
public int getPageEnd() {
return pageEnd;
}
public void setPageEnd(int pageEnd) {
this.pageEnd = pageEnd;
}
}
|
2302_77879529/lottery
|
lottery-common/src/main/java/cn/itedus/lottery/common/PageRequest.java
|
Java
|
apache-2.0
| 1,975
|
package cn.itedus.lottery.common;
import java.io.Serializable;
/**
* @description: 统一返回对象中，Code码、Info描述
* @author: 小傅哥，微信：fustack
* @date: 2021/10/3
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class Result implements Serializable {
private static final long serialVersionUID = -3826891916021780628L;
private String code;
private String info;
public static Result buildResult(Constants.ResponseCode code) {
return new Result(code.getCode(), code.getInfo());
}
public static Result buildResult(Constants.ResponseCode code, String info) {
return new Result(code.getCode(), info);
}
public static Result buildResult(String code, String info) {
return new Result(code, info);
}
public static Result buildResult(Constants.ResponseCode code, Constants.ResponseCode info) {
return new Result(code.getCode(), info.getInfo());
}
public static Result buildSuccessResult() {
return new Result(Constants.ResponseCode.SUCCESS.getCode(), Constants.ResponseCode.SUCCESS.getInfo());
}
public static Result buildErrorResult() {
return new Result(Constants.ResponseCode.UN_ERROR.getCode(), Constants.ResponseCode.UN_ERROR.getInfo());
}
public static Result buildErrorResult(String info) {
return new Result(Constants.ResponseCode.UN_ERROR.getCode(), info);
}
public Result(String code, String info) {
this.code = code;
this.info = info;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
|
2302_77879529/lottery
|
lottery-common/src/main/java/cn/itedus/lottery/common/Result.java
|
Java
|
apache-2.0
| 1,937
|
package cn.itedus.lottery.domain.activity.model.aggregates;
import cn.itedus.lottery.domain.activity.model.vo.ActivityVO;
import cn.itedus.lottery.domain.activity.model.vo.AwardVO;
import cn.itedus.lottery.domain.activity.model.vo.StrategyVO;
import java.util.List;
/**
* @description: 活动配置聚合信息
* @author: 小傅哥，微信：fustack
* @date: 2021/9/11
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class ActivityConfigRich {
/** 活动配置 */
private ActivityVO activity;
/** 策略配置(含策略明细) */
private StrategyVO strategy;
/** 奖品配置 */
private List<AwardVO> awardList;
public ActivityConfigRich() {
}
public ActivityConfigRich(ActivityVO activity, StrategyVO strategy, List<AwardVO> awardList) {
this.activity = activity;
this.strategy = strategy;
this.awardList = awardList;
}
public ActivityVO getActivity() {
return activity;
}
public void setActivity(ActivityVO activity) {
this.activity = activity;
}
public StrategyVO getStrategy() {
return strategy;
}
public void setStrategy(StrategyVO strategy) {
this.strategy = strategy;
}
public List<AwardVO> getAwardList() {
return awardList;
}
public void setAwardList(List<AwardVO> awardList) {
this.awardList = awardList;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/model/aggregates/ActivityConfigRich.java
|
Java
|
apache-2.0
| 1,547
|
package cn.itedus.lottery.domain.activity.model.aggregates;
import cn.itedus.lottery.domain.activity.model.vo.ActivityVO;
import java.util.List;
/**
* @description: 活动分页查询聚合对象
* @author: 小傅哥，微信：fustack
* @date: 2021/12/11
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class ActivityInfoLimitPageRich {
private Long count;
private List<ActivityVO> activityVOList;
public ActivityInfoLimitPageRich() {
}
public ActivityInfoLimitPageRich(Long count, List<ActivityVO> activityVOList) {
this.count = count;
this.activityVOList = activityVOList;
}
public Long getCount() {
return count;
}
public void setCount(Long count) {
this.count = count;
}
public List<ActivityVO> getActivityVOList() {
return activityVOList;
}
public void setActivityVOList(List<ActivityVO> activityVOList) {
this.activityVOList = activityVOList;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/model/aggregates/ActivityInfoLimitPageRich.java
|
Java
|
apache-2.0
| 1,121
|
package cn.itedus.lottery.domain.activity.model.req;
import cn.itedus.lottery.domain.activity.model.aggregates.ActivityConfigRich;
/**
* @description: 活动配置请求对象
* @author: 小傅哥，微信：fustack
* @date: 2021/9/11
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class ActivityConfigReq {
/** 活动ID */
private Long activityId;
/** 活动配置信息 */
private ActivityConfigRich activityConfigRich;
public ActivityConfigReq() {
}
public ActivityConfigReq(Long activityId, ActivityConfigRich activityConfigRich) {
this.activityId = activityId;
this.activityConfigRich = activityConfigRich;
}
public Long getActivityId() {
return activityId;
}
public void setActivityId(Long activityId) {
this.activityId = activityId;
}
public ActivityConfigRich getActivityConfigRich() {
return activityConfigRich;
}
public void setActivityConfigRich(ActivityConfigRich activityConfigRich) {
this.activityConfigRich = activityConfigRich;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/model/req/ActivityConfigReq.java
|
Java
|
apache-2.0
| 1,225
|
package cn.itedus.lottery.domain.activity.model.req;
import cn.itedus.lottery.common.PageRequest;
/**
* @description: 活动分页查询请求对象
* @author: 小傅哥，微信：fustack
* @date: 2021/12/11
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class ActivityInfoLimitPageReq extends PageRequest {
/**
* 活动ID
*/
private Long activityId;
/**
* 活动名称
*/
private String activityName;
public ActivityInfoLimitPageReq(int page, int rows) {
super(page, rows);
}
public Long getActivityId() {
return activityId;
}
public void setActivityId(Long activityId) {
this.activityId = activityId;
}
public String getActivityName() {
return activityName;
}
public void setActivityName(String activityName) {
this.activityName = activityName;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/model/req/ActivityInfoLimitPageReq.java
|
Java
|
apache-2.0
| 1,032
|
package cn.itedus.lottery.domain.activity.model.req;
import java.util.Date;
/**
* @description: 参与活动请求
* @author: 小傅哥，微信：fustack
* @date: 2021/10/1
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class PartakeReq {
/** 用户ID */
private String uId;
/** 活动ID */
private Long activityId;
/** 活动领取时间 */
private Date partakeDate;
public PartakeReq() {
}
public PartakeReq(String uId, Long activityId) {
this.uId = uId;
this.activityId = activityId;
this.partakeDate = new Date();
}
public PartakeReq(String uId, Long activityId, Date partakeDate) {
this.uId = uId;
this.activityId = activityId;
this.partakeDate = partakeDate;
}
public String getuId() {
return uId;
}
public void setuId(String uId) {
this.uId = uId;
}
public Long getActivityId() {
return activityId;
}
public void setActivityId(Long activityId) {
this.activityId = activityId;
}
public Date getPartakeDate() {
return partakeDate;
}
public void setPartakeDate(Date partakeDate) {
this.partakeDate = partakeDate;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/model/req/PartakeReq.java
|
Java
|
apache-2.0
| 1,380
|
package cn.itedus.lottery.domain.activity.model.res;
import cn.itedus.lottery.common.Result;
/**
* @description: 活动参与结果
* @author: 小傅哥，微信：fustack
* @date: 2021/10/1
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class PartakeResult extends Result {
/** 策略ID */
private Long strategyId;
/** 活动领取ID */
private Long takeId;
/** 库存 */
private Integer stockCount;
/** activity 库存剩余 */
private Integer stockSurplusCount;
public PartakeResult(String code, String info) {
super(code, info);
}
public Long getStrategyId() {
return strategyId;
}
public void setStrategyId(Long strategyId) {
this.strategyId = strategyId;
}
public Long getTakeId() {
return takeId;
}
public void setTakeId(Long takeId) {
this.takeId = takeId;
}
public Integer getStockCount() {
return stockCount;
}
public void setStockCount(Integer stockCount) {
this.stockCount = stockCount;
}
public Integer getStockSurplusCount() {
return stockSurplusCount;
}
public void setStockSurplusCount(Integer stockSurplusCount) {
this.stockSurplusCount = stockSurplusCount;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/model/res/PartakeResult.java
|
Java
|
apache-2.0
| 1,421
|
package cn.itedus.lottery.domain.activity.model.res;
import cn.itedus.lottery.common.Result;
/**
* @description: 库存处理结果
* @author: 小傅哥，微信：fustack
* @date: 2021/11/20
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class StockResult extends Result {
/**
* 库存 Key
*/
private String stockKey;
/**
* activity 库存剩余
*/
private Integer stockSurplusCount;
public StockResult(String code, String info) {
super(code, info);
}
public StockResult(String code, String info, String stockKey, Integer stockSurplusCount) {
super(code, info);
this.stockKey = stockKey;
this.stockSurplusCount = stockSurplusCount;
}
public String getStockKey() {
return stockKey;
}
public void setStockKey(String stockKey) {
this.stockKey = stockKey;
}
public Integer getStockSurplusCount() {
return stockSurplusCount;
}
public void setStockSurplusCount(Integer stockSurplusCount) {
this.stockSurplusCount = stockSurplusCount;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/model/res/StockResult.java
|
Java
|
apache-2.0
| 1,244
|
package cn.itedus.lottery.domain.activity.model.vo;
import java.util.Date;
/**
* @description: 活动账单【库存、状态、日期、个人参与次数】
* @author: 小傅哥，微信：fustack
* @date: 2021/10/1
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class ActivityBillVO {
/** 用户ID */
private String uId;
/** activity 活动ID */
private Long activityId;
/** activity 活动名称 */
private String activityName;
/** activity 开始时间 */
private Date beginDateTime;
/** activity 结束时间 */
private Date endDateTime;
/** 库存 */
private Integer stockCount;
/** activity 库存剩余 */
private Integer stockSurplusCount;
/**
* activity 活动状态：1编辑、2提审、3撤审、4通过、5运行(审核通过后worker扫描状态)、6拒绝、7关闭、8开启
* Constants.ActivityState
*/
private Integer state;
/** activity 策略ID */
private Long strategyId;
/** activity 每人可参与次数 */
private Integer takeCount;
/** user_take_activity_count 剩余领取次数【leftCount 是剩余的，userTakeLeftCount说的是用户从剩余的拿走多少，也就是消耗多少】 */
private Integer userTakeLeftCount;
public String getuId() {
return uId;
}
public void setuId(String uId) {
this.uId = uId;
}
public Long getActivityId() {
return activityId;
}
public void setActivityId(Long activityId) {
this.activityId = activityId;
}
public String getActivityName() {
return activityName;
}
public void setActivityName(String activityName) {
this.activityName = activityName;
}
public Date getBeginDateTime() {
return beginDateTime;
}
public void setBeginDateTime(Date beginDateTime) {
this.beginDateTime = beginDateTime;
}
public Date getEndDateTime() {
return endDateTime;
}
public void setEndDateTime(Date endDateTime) {
this.endDateTime = endDateTime;
}
public Integer getStockCount() {
return stockCount;
}
public void setStockCount(Integer stockCount) {
this.stockCount = stockCount;
}
public Integer getStockSurplusCount() {
return stockSurplusCount;
}
public void setStockSurplusCount(Integer stockSurplusCount) {
this.stockSurplusCount = stockSurplusCount;
}
public Integer getState() {
return state;
}
public void setState(Integer state) {
this.state = state;
}
public Long getStrategyId() {
return strategyId;
}
public void setStrategyId(Long strategyId) {
this.strategyId = strategyId;
}
public Integer getTakeCount() {
return takeCount;
}
public void setTakeCount(Integer takeCount) {
this.takeCount = takeCount;
}
public Integer getUserTakeLeftCount() {
return userTakeLeftCount;
}
public void setUserTakeLeftCount(Integer userTakeLeftCount) {
this.userTakeLeftCount = userTakeLeftCount;
}
@Override
public String toString() {
return "ActivityBillVO{" +
"uId='" + uId + '\'' +
", activityId=" + activityId +
", activityName='" + activityName + '\'' +
", beginDateTime=" + beginDateTime +
", endDateTime=" + endDateTime +
", stockCount=" + stockCount +
", stockSurplusCount=" + stockSurplusCount +
", state=" + state +
", strategyId=" + strategyId +
", takeCount=" + takeCount +
", userTakeLeftCount=" + userTakeLeftCount +
'}';
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/model/vo/ActivityBillVO.java
|
Java
|
apache-2.0
| 3,937
|
package cn.itedus.lottery.domain.activity.model.vo;
/**
* @description: 活动参与记录
* @author: 小傅哥，微信：fustack
* @date: 2021/11/20
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class ActivityPartakeRecordVO {
/** 用户ID */
private String uId;
/** activity 活动ID */
private Long activityId;
/** 库存 */
private Integer stockCount;
/** activity 库存剩余 */
private Integer stockSurplusCount;
public String getuId() {
return uId;
}
public void setuId(String uId) {
this.uId = uId;
}
public Long getActivityId() {
return activityId;
}
public void setActivityId(Long activityId) {
this.activityId = activityId;
}
public Integer getStockCount() {
return stockCount;
}
public void setStockCount(Integer stockCount) {
this.stockCount = stockCount;
}
public Integer getStockSurplusCount() {
return stockSurplusCount;
}
public void setStockSurplusCount(Integer stockSurplusCount) {
this.stockSurplusCount = stockSurplusCount;
}
@Override
public String toString() {
return "ActivityPartakeRecordVO{" +
"uId='" + uId + '\'' +
", activityId=" + activityId +
", stockCount=" + stockCount +
", stockSurplusCount=" + stockSurplusCount +
'}';
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/model/vo/ActivityPartakeRecordVO.java
|
Java
|
apache-2.0
| 1,588
|
package cn.itedus.lottery.domain.activity.model.vo;
import java.util.Date;
/**
* @description: 活动信息配置
* @author: 小傅哥，微信：fustack
* @date: 2021/9/11
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class ActivityVO {
/**
* 自增ID
*/
private Long id;
/**
* 活动ID
*/
private Long activityId;
/**
* 活动名称
*/
private String activityName;
/**
* 活动描述
*/
private String activityDesc;
/**
* 开始时间
*/
private Date beginDateTime;
/**
* 结束时间
*/
private Date endDateTime;
/**
* 库存
*/
private Integer stockCount;
/**
* 库存剩余
*/
private Integer stockSurplusCount;
/**
* 每人可参与次数
*/
private Integer takeCount;
/**
* 策略ID
*/
private Long strategyId;
/**
* 活动状态：编辑、提审、撤审、通过、运行、拒绝、关闭、开启
*/
private Integer state;
/**
* 创建人
*/
private String creator;
/**
* 创建时间
*/
private Date createTime;
/**
* 修改时间
*/
private Date updateTime;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Long getActivityId() {
return activityId;
}
public void setActivityId(Long activityId) {
this.activityId = activityId;
}
public String getActivityName() {
return activityName;
}
public void setActivityName(String activityName) {
this.activityName = activityName;
}
public String getActivityDesc() {
return activityDesc;
}
public void setActivityDesc(String activityDesc) {
this.activityDesc = activityDesc;
}
public Date getBeginDateTime() {
return beginDateTime;
}
public void setBeginDateTime(Date beginDateTime) {
this.beginDateTime = beginDateTime;
}
public Date getEndDateTime() {
return endDateTime;
}
public void setEndDateTime(Date endDateTime) {
this.endDateTime = endDateTime;
}
public Integer getStockCount() {
return stockCount;
}
public void setStockCount(Integer stockCount) {
this.stockCount = stockCount;
}
public Integer getStockSurplusCount() {
return stockSurplusCount;
}
public void setStockSurplusCount(Integer stockSurplusCount) {
this.stockSurplusCount = stockSurplusCount;
}
public Integer getTakeCount() {
return takeCount;
}
public void setTakeCount(Integer takeCount) {
this.takeCount = takeCount;
}
public Long getStrategyId() {
return strategyId;
}
public void setStrategyId(Long strategyId) {
this.strategyId = strategyId;
}
public Integer getState() {
return state;
}
public void setState(Integer state) {
this.state = state;
}
public String getCreator() {
return creator;
}
public void setCreator(String creator) {
this.creator = creator;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getUpdateTime() {
return updateTime;
}
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
@Override
public String toString() {
return "ActivityVO{" +
"id=" + id +
", activityId=" + activityId +
", activityName='" + activityName + '\'' +
", activityDesc='" + activityDesc + '\'' +
", beginDateTime=" + beginDateTime +
", endDateTime=" + endDateTime +
", stockCount=" + stockCount +
", stockSurplusCount=" + stockSurplusCount +
", takeCount=" + takeCount +
", strategyId=" + strategyId +
", state=" + state +
", creator='" + creator + '\'' +
", createTime=" + createTime +
", updateTime=" + updateTime +
'}';
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/model/vo/ActivityVO.java
|
Java
|
apache-2.0
| 4,469
|
package cn.itedus.lottery.domain.activity.model.vo;
/**
* @description: 变更活动状态对象
* @author: 小傅哥，微信：fustack
* @date: 2021/9/12
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class AlterStateVO {
/** 活动ID */
private Long activityId;
/** 更新前状态 */
private Integer beforeState;
/** 更新后状态 */
private Integer afterState;
public AlterStateVO() {
}
public AlterStateVO(Long activityId, Integer beforeState, Integer afterState) {
this.activityId = activityId;
this.beforeState = beforeState;
this.afterState = afterState;
}
public Long getActivityId() {
return activityId;
}
public void setActivityId(Long activityId) {
this.activityId = activityId;
}
public Integer getBeforeState() {
return beforeState;
}
public void setBeforeState(Integer beforeState) {
this.beforeState = beforeState;
}
public Integer getAfterState() {
return afterState;
}
public void setAfterState(Integer afterState) {
this.afterState = afterState;
}
@Override
public String toString() {
return "AlterStateVO{" +
"activityId=" + activityId +
", beforeState=" + beforeState +
", afterState=" + afterState +
'}';
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/model/vo/AlterStateVO.java
|
Java
|
apache-2.0
| 1,546
|
package cn.itedus.lottery.domain.activity.model.vo;
/**
* @description: 奖品信息配置
* @author: 小傅哥，微信：fustack
* @date: 2021/9/11
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class AwardVO {
/** 奖品ID */
private String awardId;
/** 奖品类型（1:文字描述、2:兑换码、3:优惠券、4:实物奖品） */
private Integer awardType;
/** 奖品名称 */
private String awardName;
/** 奖品内容「描述、奖品码、sku」 */
private String awardContent;
public String getAwardId() {
return awardId;
}
public void setAwardId(String awardId) {
this.awardId = awardId;
}
public Integer getAwardType() {
return awardType;
}
public void setAwardType(Integer awardType) {
this.awardType = awardType;
}
public String getAwardName() {
return awardName;
}
public void setAwardName(String awardName) {
this.awardName = awardName;
}
public String getAwardContent() {
return awardContent;
}
public void setAwardContent(String awardContent) {
this.awardContent = awardContent;
}
@Override
public String toString() {
return "AwardVO{" +
"awardId='" + awardId + '\'' +
", awardType=" + awardType +
", awardName='" + awardName + '\'' +
", awardContent='" + awardContent + '\'' +
'}';
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/model/vo/AwardVO.java
|
Java
|
apache-2.0
| 1,637
|
package cn.itedus.lottery.domain.activity.model.vo;
import java.util.Date;
/**
* @description: 奖品单
* @author: 小傅哥，微信：fustack
* @date: 2021/10/3
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class DrawOrderVO {
/**
* 用户ID
*/
private String uId;
/**
* 活动领取ID
*/
private Long takeId;
/**
* 活动ID
*/
private Long activityId;
/**
* 订单ID
*/
private Long orderId;
/**
* 策略ID
*/
private Long strategyId;
/**
* 策略方式（1:单项概率、2:总体概率）
*/
private Integer strategyMode;
/**
* 发放奖品方式（1:即时、2:定时[含活动结束]、3:人工）
*/
private Integer grantType;
/**
* 发奖时间
*/
private Date grantDate;
/**
* 发奖状态
*/
private Integer grantState;
/**
* 发奖ID
*/
private String awardId;
/**
* 奖品类型（1:文字描述、2:兑换码、3:优惠券、4:实物奖品）
*/
private Integer awardType;
/**
* 奖品名称
*/
private String awardName;
/**
* 奖品内容「文字描述、Key、码」
*/
private String awardContent;
public String getuId() {
return uId;
}
public void setuId(String uId) {
this.uId = uId;
}
public Long getTakeId() {
return takeId;
}
public void setTakeId(Long takeId) {
this.takeId = takeId;
}
public Long getActivityId() {
return activityId;
}
public void setActivityId(Long activityId) {
this.activityId = activityId;
}
public Long getOrderId() {
return orderId;
}
public void setOrderId(Long orderId) {
this.orderId = orderId;
}
public Long getStrategyId() {
return strategyId;
}
public void setStrategyId(Long strategyId) {
this.strategyId = strategyId;
}
public Integer getStrategyMode() {
return strategyMode;
}
public void setStrategyMode(Integer strategyMode) {
this.strategyMode = strategyMode;
}
public Integer getGrantType() {
return grantType;
}
public void setGrantType(Integer grantType) {
this.grantType = grantType;
}
public Date getGrantDate() {
return grantDate;
}
public void setGrantDate(Date grantDate) {
this.grantDate = grantDate;
}
public Integer getGrantState() {
return grantState;
}
public void setGrantState(Integer grantState) {
this.grantState = grantState;
}
public String getAwardId() {
return awardId;
}
public void setAwardId(String awardId) {
this.awardId = awardId;
}
public Integer getAwardType() {
return awardType;
}
public void setAwardType(Integer awardType) {
this.awardType = awardType;
}
public String getAwardName() {
return awardName;
}
public void setAwardName(String awardName) {
this.awardName = awardName;
}
public String getAwardContent() {
return awardContent;
}
public void setAwardContent(String awardContent) {
this.awardContent = awardContent;
}
@Override
public String toString() {
return "DrawOrderVO{" +
"uId='" + uId + '\'' +
", takeId=" + takeId +
", activityId=" + activityId +
", orderId=" + orderId +
", strategyId=" + strategyId +
", strategyMode=" + strategyMode +
", grantType=" + grantType +
", grantDate=" + grantDate +
", grantState=" + grantState +
", awardId='" + awardId + '\'' +
", awardType=" + awardType +
", awardName='" + awardName + '\'' +
", awardContent='" + awardContent + '\'' +
'}';
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/model/vo/DrawOrderVO.java
|
Java
|
apache-2.0
| 4,169
|
package cn.itedus.lottery.domain.activity.model.vo;
import cn.itedus.lottery.domain.award.model.vo.ShippingAddress;
/**
* @description: 中奖物品发货单，用于发送MQ消息，异步触达发货奖品给用户
* @author: 小傅哥，微信：fustack
* @date: 2021/10/30
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class InvoiceVO {
/** 用户ID */
private String uId;
/** 抽奖单号 ID */
private Long orderId;
/** 奖品ID */
private String awardId;
/**
* 奖品类型（1:文字描述、2:兑换码、3:优惠券、4:实物奖品）
*/
private Integer awardType;
/** 奖品名称 */
private String awardName;
/** 奖品内容「描述、奖品码、sku」 */
private String awardContent;
/** 四级送货地址（只有实物类商品需要地址） */
private ShippingAddress shippingAddress;
/** 扩展信息，用于一些个性商品发放所需要的透传字段内容 */
private String extInfo;
public String getuId() {
return uId;
}
public void setuId(String uId) {
this.uId = uId;
}
public Long getOrderId() {
return orderId;
}
public void setOrderId(Long orderId) {
this.orderId = orderId;
}
public String getAwardId() {
return awardId;
}
public void setAwardId(String awardId) {
this.awardId = awardId;
}
public Integer getAwardType() {
return awardType;
}
public void setAwardType(Integer awardType) {
this.awardType = awardType;
}
public String getAwardName() {
return awardName;
}
public void setAwardName(String awardName) {
this.awardName = awardName;
}
public String getAwardContent() {
return awardContent;
}
public void setAwardContent(String awardContent) {
this.awardContent = awardContent;
}
public ShippingAddress getShippingAddress() {
return shippingAddress;
}
public void setShippingAddress(ShippingAddress shippingAddress) {
this.shippingAddress = shippingAddress;
}
public String getExtInfo() {
return extInfo;
}
public void setExtInfo(String extInfo) {
this.extInfo = extInfo;
}
@Override
public String toString() {
return "InvoiceVO{" +
"uId='" + uId + '\'' +
", orderId=" + orderId +
", awardId='" + awardId + '\'' +
", awardType=" + awardType +
", awardName='" + awardName + '\'' +
", awardContent='" + awardContent + '\'' +
", shippingAddress=" + shippingAddress +
", extInfo='" + extInfo + '\'' +
'}';
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/model/vo/InvoiceVO.java
|
Java
|
apache-2.0
| 2,928
|
package cn.itedus.lottery.domain.activity.model.vo;
import java.math.BigDecimal;
/**
* @description: 策略详情配置
* @author: 小傅哥，微信：fustack
* @date: 2021/9/11
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class StrategyDetailVO {
/**
* 策略ID
*/
private Long strategyId;
/**
* 奖品ID
*/
private String awardId;
/**
* 奖品名称
*/
private String awardName;
/**
* 奖品库存
*/
private Integer awardCount;
/**
* 奖品剩余库存
*/
private Integer awardSurplusCount;
/**
* 中奖概率
*/
private BigDecimal awardRate;
public Long getStrategyId() {
return strategyId;
}
public void setStrategyId(Long strategyId) {
this.strategyId = strategyId;
}
public String getAwardId() {
return awardId;
}
public void setAwardId(String awardId) {
this.awardId = awardId;
}
public String getAwardName() {
return awardName;
}
public void setAwardName(String awardName) {
this.awardName = awardName;
}
public Integer getAwardCount() {
return awardCount;
}
public void setAwardCount(Integer awardCount) {
this.awardCount = awardCount;
}
public Integer getAwardSurplusCount() {
return awardSurplusCount;
}
public void setAwardSurplusCount(Integer awardSurplusCount) {
this.awardSurplusCount = awardSurplusCount;
}
public BigDecimal getAwardRate() {
return awardRate;
}
public void setAwardRate(BigDecimal awardRate) {
this.awardRate = awardRate;
}
@Override
public String toString() {
return "StrategyDetailVO{" +
"strategyId=" + strategyId +
", awardId='" + awardId + '\'' +
", awardName='" + awardName + '\'' +
", awardCount=" + awardCount +
", awardSurplusCount=" + awardSurplusCount +
", awardRate=" + awardRate +
'}';
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/model/vo/StrategyDetailVO.java
|
Java
|
apache-2.0
| 2,248
|
package cn.itedus.lottery.domain.activity.model.vo;
import java.util.Date;
import java.util.List;
/**
* @description: 策略信息配置
* @author: 小傅哥，微信：fustack
* @date: 2021/9/11
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class StrategyVO {
/**
* 策略ID
*/
private Long strategyId;
/**
* 策略描述
*/
private String strategyDesc;
/**
* 策略方式「1:单项概率、2:总体概率」
*/
private Integer strategyMode;
/**
* 发放奖品方式「1:即时、2:定时[含活动结束]、3:人工」
*/
private Integer grantType;
/**
* 发放奖品时间
*/
private Date grantDate;
/**
* 扩展信息
*/
private String extInfo;
/**
* 策略详情配置
*/
private List<StrategyDetailVO> strategyDetailList;
public Long getStrategyId() {
return strategyId;
}
public void setStrategyId(Long strategyId) {
this.strategyId = strategyId;
}
public String getStrategyDesc() {
return strategyDesc;
}
public void setStrategyDesc(String strategyDesc) {
this.strategyDesc = strategyDesc;
}
public Integer getStrategyMode() {
return strategyMode;
}
public void setStrategyMode(Integer strategyMode) {
this.strategyMode = strategyMode;
}
public Integer getGrantType() {
return grantType;
}
public void setGrantType(Integer grantType) {
this.grantType = grantType;
}
public Date getGrantDate() {
return grantDate;
}
public void setGrantDate(Date grantDate) {
this.grantDate = grantDate;
}
public String getExtInfo() {
return extInfo;
}
public void setExtInfo(String extInfo) {
this.extInfo = extInfo;
}
public List<StrategyDetailVO> getStrategyDetailList() {
return strategyDetailList;
}
public void setStrategyDetailList(List<StrategyDetailVO> strategyDetailList) {
this.strategyDetailList = strategyDetailList;
}
@Override
public String toString() {
return "StrategyVO{" +
"strategyId=" + strategyId +
", strategyDesc='" + strategyDesc + '\'' +
", strategyMode=" + strategyMode +
", grantType=" + grantType +
", grantDate=" + grantDate +
", extInfo='" + extInfo + '\'' +
'}';
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/model/vo/StrategyVO.java
|
Java
|
apache-2.0
| 2,653
|
package cn.itedus.lottery.domain.activity.model.vo;
/**
* @description: 用户领取活动记录
* @author: 小傅哥，微信：fustack
* @date: 2021/10/4
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class UserTakeActivityVO {
/**
* 活动ID
*/
private Long activityId;
/**
* 活动领取ID
*/
private Long takeId;
/**
* 策略ID
*/
private Long strategyId;
/**
* 活动单使用状态 0未使用、1已使用
* Constants.TaskState
*/
private Integer state;
public Long getActivityId() {
return activityId;
}
public void setActivityId(Long activityId) {
this.activityId = activityId;
}
public Long getTakeId() {
return takeId;
}
public void setTakeId(Long takeId) {
this.takeId = takeId;
}
public Long getStrategyId() {
return strategyId;
}
public void setStrategyId(Long strategyId) {
this.strategyId = strategyId;
}
public Integer getState() {
return state;
}
public void setState(Integer state) {
this.state = state;
}
@Override
public String toString() {
return "UserTakeActivityVO{" +
"activityId=" + activityId +
", takeId=" + takeId +
", strategyId=" + strategyId +
", state=" + state +
'}';
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/model/vo/UserTakeActivityVO.java
|
Java
|
apache-2.0
| 1,580
|
package cn.itedus.lottery.domain.activity.repository;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.domain.activity.model.aggregates.ActivityInfoLimitPageRich;
import cn.itedus.lottery.domain.activity.model.req.ActivityInfoLimitPageReq;
import cn.itedus.lottery.domain.activity.model.req.PartakeReq;
import cn.itedus.lottery.domain.activity.model.res.StockResult;
import cn.itedus.lottery.domain.activity.model.vo.*;
import java.util.Date;
import java.util.List;
/**
* @description: 活动仓库服务(活动表 、 奖品表 、 策略表 、 策略明细表)
* @author: 小傅哥，微信：fustack
* @date: 2021/9/11
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public interface IActivityRepository {
/**
* 添加活动配置
*
* @param activity 活动配置
*/
void addActivity(ActivityVO activity);
/**
* 添加奖品配置集合
*
* @param awardList 奖品配置集合
*/
void addAward(List<AwardVO> awardList);
/**
* 添加策略配置
*
* @param strategy 策略配置
*/
void addStrategy(StrategyVO strategy);
/**
* 添加策略明细配置
*
* @param strategyDetailList 策略明细集合
*/
void addStrategyDetailList(List<StrategyDetailVO> strategyDetailList);
/**
* 变更活动状态
*
* @param activityId 活动ID
* @param beforeState 修改前状态
* @param afterState 修改后状态
* @return 更新结果
*/
boolean alterStatus(Long activityId, Enum<Constants.ActivityState> beforeState, Enum<Constants.ActivityState> afterState);
/**
* 查询活动账单信息【库存、状态、日期、个人参与次数】
*
* @param req 参与活动请求
* @return 活动账单
*/
ActivityBillVO queryActivityBill(PartakeReq req);
/**
* 扣减活动库存
*
* @param activityId 活动ID
* @return 扣减结果
*/
int subtractionActivityStock(Long activityId);
/**
* 扫描待处理的活动列表，状态为：通过、活动中
*
* @param id ID
* @return 待处理的活动集合
*/
List<ActivityVO> scanToDoActivityList(Long id);
/**
* 扣减活动库存，通过Redis
*
* @param uId 用户ID
* @param activityId 活动ID
* @param stockCount 总库存
* @return 扣减结果
*/
StockResult subtractionActivityStockByRedis(String uId, Long activityId, Integer stockCount, Date endDateTime);
/**
* 恢复活动库存，通过Redis 【如果非常异常，则需要进行缓存库存恢复，只保证不超卖的特性，所以不保证一定能恢复占用库存，另外最终可以由任务进行补偿库存】
*
* @param activityId 活动ID
* @param tokenKey 分布式 KEY 用于清理
* @param code 状态
*/
void recoverActivityCacheStockByRedis(Long activityId, String tokenKey, String code);
/**
* 查询活动分页查询聚合对象
*
* @param req 请求参数；分页、活动
* @return 查询结果
*/
ActivityInfoLimitPageRich queryActivityInfoLimitPage(ActivityInfoLimitPageReq req);
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/repository/IActivityRepository.java
|
Java
|
apache-2.0
| 3,397
|
package cn.itedus.lottery.domain.activity.repository;
import cn.bugstack.middleware.db.router.annotation.DBRouter;
import cn.itedus.lottery.domain.activity.model.vo.ActivityPartakeRecordVO;
import cn.itedus.lottery.domain.activity.model.vo.DrawOrderVO;
import cn.itedus.lottery.domain.activity.model.vo.InvoiceVO;
import cn.itedus.lottery.domain.activity.model.vo.UserTakeActivityVO;
import java.util.Date;
import java.util.List;
/**
* @description: 用户参与活动仓储接口
* @author: 小傅哥，微信：fustack
* @date: 2021/10/1
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public interface IUserTakeActivityRepository {
/**
* 扣减个人活动参与次数
*
* @param activityId 活动ID
* @param activityName 活动名称
* @param takeCount 活动个人可领取次数
* @param userTakeLeftCount 活动个人剩余领取次数
* @param uId 用户ID
* @return 更新结果
*/
int subtractionLeftCount(Long activityId, String activityName, Integer takeCount, Integer userTakeLeftCount, String uId);
/**
* 领取活动
*
* @param activityId 活动ID
* @param activityName 活动名称
* @param strategyId 抽奖策略ID
* @param takeCount 活动个人可领取次数
* @param userTakeLeftCount 活动个人剩余领取次数
* @param uId 用户ID
* @param takeDate 领取时间
* @param takeId 领取ID
*/
void takeActivity(Long activityId, String activityName, Long strategyId, Integer takeCount, Integer userTakeLeftCount, String uId, Date takeDate, Long takeId);
/**
* 锁定活动领取记录
*
* @param uId 用户ID
* @param activityId 活动ID
* @param takeId 领取ID
* @return 更新结果
*/
int lockTackActivity(String uId, Long activityId, Long takeId);
/**
* 保存抽奖信息
*
* @param drawOrder 中奖单
*/
void saveUserStrategyExport(DrawOrderVO drawOrder);
/**
* 查询是否存在未执行抽奖领取活动单【user_take_activity 存在 state = 0，领取了但抽奖过程失败的，可以直接返回领取结果继续抽奖】
*
* @param activityId 活动ID
* @param uId 用户ID
* @return 领取单
*/
UserTakeActivityVO queryNoConsumedTakeActivityOrder(Long activityId, String uId);
/**
* 更新发货单MQ状态
*
* @param uId 用户ID
* @param orderId 订单ID
* @param mqState MQ 发送状态
*/
void updateInvoiceMqState(String uId, Long orderId, Integer mqState);
/**
* 扫描发货单 MQ 状态，把未发送 MQ 的单子扫描出来，做补偿
*
* @return 发货单
*/
List<InvoiceVO> scanInvoiceMqState();
/**
* 更新活动库存
*
* @param activityPartakeRecordVO 活动领取记录
*/
void updateActivityStock(ActivityPartakeRecordVO activityPartakeRecordVO);
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/repository/IUserTakeActivityRepository.java
|
Java
|
apache-2.0
| 3,212
|
package cn.itedus.lottery.domain.activity.service.deploy;
import cn.itedus.lottery.domain.activity.model.aggregates.ActivityInfoLimitPageRich;
import cn.itedus.lottery.domain.activity.model.req.ActivityConfigReq;
import cn.itedus.lottery.domain.activity.model.req.ActivityInfoLimitPageReq;
import cn.itedus.lottery.domain.activity.model.vo.ActivityVO;
import java.util.List;
/**
* @description: 部署活动配置接口
* @author: 小傅哥，微信：fustack
* @date: 2021/9/11
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public interface IActivityDeploy {
/**
* 创建活动信息
*
* @param req 活动配置信息
*/
void createActivity(ActivityConfigReq req);
/**
* 修改活动信息
*
* @param req 活动配置信息
*/
void updateActivity(ActivityConfigReq req);
/**
* 扫描待处理的活动列表，状态为：通过、活动中
* <p>
* 通过 -> 时间符合时 -> 活动中
* 活动中 -> 时间到期时 -> 关闭
*
* @param id ID
* @return 待处理的活动集合
*/
List<ActivityVO> scanToDoActivityList(Long id);
/**
* 查询活动分页查询聚合对象
*
* @param req 请求参数；分页、活动
* @return 查询结果
*/
ActivityInfoLimitPageRich queryActivityInfoLimitPage(ActivityInfoLimitPageReq req);
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/service/deploy/IActivityDeploy.java
|
Java
|
apache-2.0
| 1,530
|
package cn.itedus.lottery.domain.activity.service.deploy.impl;
import cn.itedus.lottery.domain.activity.model.aggregates.ActivityConfigRich;
import cn.itedus.lottery.domain.activity.model.aggregates.ActivityInfoLimitPageRich;
import cn.itedus.lottery.domain.activity.model.req.ActivityConfigReq;
import cn.itedus.lottery.domain.activity.model.req.ActivityInfoLimitPageReq;
import cn.itedus.lottery.domain.activity.model.vo.ActivityVO;
import cn.itedus.lottery.domain.activity.model.vo.AwardVO;
import cn.itedus.lottery.domain.activity.model.vo.StrategyDetailVO;
import cn.itedus.lottery.domain.activity.model.vo.StrategyVO;
import cn.itedus.lottery.domain.activity.repository.IActivityRepository;
import cn.itedus.lottery.domain.activity.service.deploy.IActivityDeploy;
import com.alibaba.fastjson.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.List;
/**
* @description: 部署活动配置服务
* @author: 小傅哥，微信：fustack
* @date: 2021/9/11
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Service
public class ActivityDeployImpl implements IActivityDeploy {
private Logger logger = LoggerFactory.getLogger(ActivityDeployImpl.class);
@Resource
private IActivityRepository activityRepository;
@Transactional(rollbackFor = Exception.class)
@Override
public void createActivity(ActivityConfigReq req) {
logger.info("创建活动配置开始，activityId：{}", req.getActivityId());
ActivityConfigRich activityConfigRich = req.getActivityConfigRich();
try {
// 添加活动配置
ActivityVO activity = activityConfigRich.getActivity();
activityRepository.addActivity(activity);
// 添加奖品配置
List<AwardVO> awardList = activityConfigRich.getAwardList();
activityRepository.addAward(awardList);
// 添加策略配置
StrategyVO strategy = activityConfigRich.getStrategy();
activityRepository.addStrategy(strategy);
// 添加策略明细配置
List<StrategyDetailVO> strategyDetailList = activityConfigRich.getStrategy().getStrategyDetailList();
activityRepository.addStrategyDetailList(strategyDetailList);
logger.info("创建活动配置完成，activityId：{}", req.getActivityId());
} catch (DuplicateKeyException e) {
logger.error("创建活动配置失败，唯一索引冲突 activityId：{} reqJson：{}", req.getActivityId(), JSON.toJSONString(req), e);
throw e;
}
}
@Override
public void updateActivity(ActivityConfigReq req) {
// TODO: 非核心功能后续补充
}
@Override
public List<ActivityVO> scanToDoActivityList(Long id) {
return activityRepository.scanToDoActivityList(id);
}
@Override
public ActivityInfoLimitPageRich queryActivityInfoLimitPage(ActivityInfoLimitPageReq req) {
return activityRepository.queryActivityInfoLimitPage(req);
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/service/deploy/impl/ActivityDeployImpl.java
|
Java
|
apache-2.0
| 3,380
|
package cn.itedus.lottery.domain.activity.service.partake;
import cn.itedus.lottery.domain.activity.model.req.PartakeReq;
import cn.itedus.lottery.domain.activity.model.vo.ActivityBillVO;
import cn.itedus.lottery.domain.activity.repository.IActivityRepository;
import javax.annotation.Resource;
/**
* @description: 活动领取模操作，一些通用的数据服务
* @author: 小傅哥，微信：fustack
* @date: 2021/10/1
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class ActivityPartakeSupport {
@Resource
protected IActivityRepository activityRepository;
protected ActivityBillVO queryActivityBill(PartakeReq req){
return activityRepository.queryActivityBill(req);
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/service/partake/ActivityPartakeSupport.java
|
Java
|
apache-2.0
| 862
|
package cn.itedus.lottery.domain.activity.service.partake;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.common.Result;
import cn.itedus.lottery.domain.activity.model.req.PartakeReq;
import cn.itedus.lottery.domain.activity.model.res.PartakeResult;
import cn.itedus.lottery.domain.activity.model.res.StockResult;
import cn.itedus.lottery.domain.activity.model.vo.ActivityBillVO;
import cn.itedus.lottery.domain.activity.model.vo.UserTakeActivityVO;
import cn.itedus.lottery.domain.support.ids.IIdGenerator;
import javax.annotation.Resource;
import java.util.Date;
import java.util.Map;
/**
* @description: 活动领取模板抽象类
* @author: 小傅哥，微信：fustack
* @date: 2021/10/1
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public abstract class BaseActivityPartake extends ActivityPartakeSupport implements IActivityPartake {
@Resource
private Map<Constants.Ids, IIdGenerator> idGeneratorMap;
@Override
public PartakeResult doPartake(PartakeReq req) {
// 1. 查询是否存在未执行抽奖领取活动单【user_take_activity 存在 state = 0，领取了但抽奖过程失败的，可以直接返回领取结果继续抽奖】
UserTakeActivityVO userTakeActivityVO = this.queryNoConsumedTakeActivityOrder(req.getActivityId(), req.getuId());
if (null != userTakeActivityVO) {
return buildPartakeResult(userTakeActivityVO.getStrategyId(), userTakeActivityVO.getTakeId(), Constants.ResponseCode.NOT_CONSUMED_TAKE);
}
// 2. 查询活动账单
ActivityBillVO activityBillVO = super.queryActivityBill(req);
// 3. 活动信息校验处理【活动库存、状态、日期、个人参与次数】
Result checkResult = this.checkActivityBill(req, activityBillVO);
if (!Constants.ResponseCode.SUCCESS.getCode().equals(checkResult.getCode())) {
return new PartakeResult(checkResult.getCode(), checkResult.getInfo());
}
// 4. 扣减活动库存，通过Redis【活动库存扣减编号，作为锁的Key，缩小颗粒度】 Begin
StockResult subtractionActivityResult = this.subtractionActivityStockByRedis(req.getuId(), req.getActivityId(), activityBillVO.getStockCount(), activityBillVO.getEndDateTime());
if (!Constants.ResponseCode.SUCCESS.getCode().equals(subtractionActivityResult.getCode())) {
this.recoverActivityCacheStockByRedis(req.getActivityId(), subtractionActivityResult.getStockKey(), subtractionActivityResult.getCode());
return new PartakeResult(subtractionActivityResult.getCode(), subtractionActivityResult.getInfo());
}
// 5. 插入领取活动信息【个人用户把活动信息写入到用户表】
Long takeId = idGeneratorMap.get(Constants.Ids.SnowFlake).nextId();
Result grabResult = this.grabActivity(req, activityBillVO, takeId);
if (!Constants.ResponseCode.SUCCESS.getCode().equals(grabResult.getCode())) {
this.recoverActivityCacheStockByRedis(req.getActivityId(), subtractionActivityResult.getStockKey(), grabResult.getCode());
return new PartakeResult(grabResult.getCode(), grabResult.getInfo());
}
// 6. 扣减活动库存，通过Redis End
this.recoverActivityCacheStockByRedis(req.getActivityId(), subtractionActivityResult.getStockKey(), Constants.ResponseCode.SUCCESS.getCode());
return buildPartakeResult(activityBillVO.getStrategyId(), takeId, activityBillVO.getStockCount(), subtractionActivityResult.getStockSurplusCount(), Constants.ResponseCode.SUCCESS);
}
/**
* 封装结果【返回的策略ID，用于继续完成抽奖步骤】
*
* @param strategyId 策略ID
* @param takeId 领取ID
* @param stockCount 库存
* @param stockSurplusCount 剩余库存
* @param code 状态码
* @return 封装结果
*/
private PartakeResult buildPartakeResult(Long strategyId, Long takeId, Integer stockCount, Integer stockSurplusCount, Constants.ResponseCode code) {
PartakeResult partakeResult = new PartakeResult(code.getCode(), code.getInfo());
partakeResult.setStrategyId(strategyId);
partakeResult.setTakeId(takeId);
partakeResult.setStockCount(stockCount);
partakeResult.setStockSurplusCount(stockSurplusCount);
return partakeResult;
}
/**
* 封装结果【返回的策略ID，用于继续完成抽奖步骤】
*
* @param strategyId 策略ID
* @param takeId 领取ID
* @param code 状态码
* @return 封装结果
*/
private PartakeResult buildPartakeResult(Long strategyId, Long takeId, Constants.ResponseCode code) {
PartakeResult partakeResult = new PartakeResult(code.getCode(), code.getInfo());
partakeResult.setStrategyId(strategyId);
partakeResult.setTakeId(takeId);
return partakeResult;
}
/**
* 查询是否存在未执行抽奖领取活动单【user_take_activity 存在 state = 0，领取了但抽奖过程失败的，可以直接返回领取结果继续抽奖】
*
* @param activityId 活动ID
* @param uId 用户ID
* @return 领取单
*/
protected abstract UserTakeActivityVO queryNoConsumedTakeActivityOrder(Long activityId, String uId);
/**
* 活动信息校验处理，把活动库存、状态、日期、个人参与次数
*
* @param partake 参与活动请求
* @param bill 活动账单
* @return 校验结果
*/
protected abstract Result checkActivityBill(PartakeReq partake, ActivityBillVO bill);
/**
* 扣减活动库存
*
* @param req 参与活动请求
* @return 扣减结果
*/
protected abstract Result subtractionActivityStock(PartakeReq req);
/**
* 扣减活动库存，通过Redis
*
* @param uId 用户ID
* @param activityId 活动号
* @param stockCount 总库存
* @return 扣减结果
*/
protected abstract StockResult subtractionActivityStockByRedis(String uId, Long activityId, Integer stockCount, Date endDateTime);
/**
* 恢复活动库存，通过Redis 【如果非常异常，则需要进行缓存库存恢复，只保证不超卖的特性，所以不保证一定能恢复占用库存，另外最终可以由任务进行补偿库存】
*
* @param activityId 活动ID
* @param tokenKey 分布式 KEY 用于清理
* @param code 状态
*/
protected abstract void recoverActivityCacheStockByRedis(Long activityId, String tokenKey, String code);
/**
* 领取活动
*
* @param partake 参与活动请求
* @param bill 活动账单
* @param takeId 领取活动ID
* @return 领取结果
*/
protected abstract Result grabActivity(PartakeReq partake, ActivityBillVO bill, Long takeId);
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/service/partake/BaseActivityPartake.java
|
Java
|
apache-2.0
| 7,113
|
package cn.itedus.lottery.domain.activity.service.partake;
import cn.itedus.lottery.common.Result;
import cn.itedus.lottery.domain.activity.model.req.PartakeReq;
import cn.itedus.lottery.domain.activity.model.res.PartakeResult;
import cn.itedus.lottery.domain.activity.model.vo.ActivityPartakeRecordVO;
import cn.itedus.lottery.domain.activity.model.vo.DrawOrderVO;
import cn.itedus.lottery.domain.activity.model.vo.InvoiceVO;
import java.util.List;
/**
* @description: 抽奖活动参与接口
* @author: 小傅哥，微信：fustack
* @date: 2021/9/12
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public interface IActivityPartake {
/**
* 参与活动
*
* @param req 入参
* @return 领取结果
*/
PartakeResult doPartake(PartakeReq req);
/**
* 保存奖品单
*
* @param drawOrder 奖品单
* @return 保存结果
*/
Result recordDrawOrder(DrawOrderVO drawOrder);
/**
* 锁定记录
* @return
*/
Result lockTackActivity(String uId, Long activityId, Long takeId);
/**
* 更新发货单 MQ 状态
*
* @param uId 用户ID
* @param orderId 订单ID
* @param mqState MQ 发送状态
*/
void updateInvoiceMqState(String uId, Long orderId, Integer mqState);
/**
* 扫描发货单 MQ 状态，把未发送 MQ 的单子扫描出来，做补偿
*
* @param dbCount 指定分库
* @param tbCount 指定分表
* @return 发货单
*/
List<InvoiceVO> scanInvoiceMqState(int dbCount, int tbCount);
/**
* 更新活动库存
*
* @param activityPartakeRecordVO 活动领取记录
*/
void updateActivityStock(ActivityPartakeRecordVO activityPartakeRecordVO);
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/service/partake/IActivityPartake.java
|
Java
|
apache-2.0
| 1,903
|
package cn.itedus.lottery.domain.activity.service.partake.impl;
import cn.bugstack.middleware.db.router.strategy.IDBRouterStrategy;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.common.Result;
import cn.itedus.lottery.domain.activity.model.req.PartakeReq;
import cn.itedus.lottery.domain.activity.model.res.StockResult;
import cn.itedus.lottery.domain.activity.model.vo.*;
import cn.itedus.lottery.domain.activity.repository.IUserTakeActivityRepository;
import cn.itedus.lottery.domain.activity.service.partake.BaseActivityPartake;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.support.TransactionTemplate;
import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
/**
* @description: 活动参与功能实现
* @author: 小傅哥，微信：fustack
* @date: 2021/10/1
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Service
public class ActivityPartakeImpl extends BaseActivityPartake {
private Logger logger = LoggerFactory.getLogger(ActivityPartakeImpl.class);
@Resource
private IUserTakeActivityRepository userTakeActivityRepository;
@Resource
private TransactionTemplate transactionTemplate;
@Resource
private IDBRouterStrategy dbRouter;
@Override
protected UserTakeActivityVO queryNoConsumedTakeActivityOrder(Long activityId, String uId) {
return userTakeActivityRepository.queryNoConsumedTakeActivityOrder(activityId, uId);
}
@Override
protected Result checkActivityBill(PartakeReq partake, ActivityBillVO bill) {
// 校验：活动状态
if (!Constants.ActivityState.DOING.getCode().equals(bill.getState())) {
logger.warn("活动当前状态非可用 state：{}", bill.getState());
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动当前状态非可用");
}
// 校验：活动日期
if (bill.getBeginDateTime().after(partake.getPartakeDate()) || bill.getEndDateTime().before(partake.getPartakeDate())) {
logger.warn("活动时间范围非可用 beginDateTime：{} endDateTime：{}", bill.getBeginDateTime(), bill.getEndDateTime());
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动时间范围非可用");
}
// 校验：活动库存
if (bill.getStockSurplusCount() <= 0) {
logger.warn("活动剩余库存非可用 stockSurplusCount：{}", bill.getStockSurplusCount());
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动剩余库存非可用");
}
// 校验：个人库存 - 个人活动剩余可领取次数
if (null != bill.getUserTakeLeftCount() && bill.getUserTakeLeftCount() <= 0) {
logger.warn("个人领取次数非可用 userTakeLeftCount：{}", bill.getUserTakeLeftCount());
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "个人领取次数非可用");
}
return Result.buildSuccessResult();
}
@Override
protected Result subtractionActivityStock(PartakeReq req) {
int count = activityRepository.subtractionActivityStock(req.getActivityId());
if (0 == count) {
logger.error("扣减活动库存失败 activityId：{}", req.getActivityId());
return Result.buildResult(Constants.ResponseCode.NO_UPDATE);
}
return Result.buildSuccessResult();
}
@Override
protected StockResult subtractionActivityStockByRedis(String uId, Long activityId, Integer stockCount, Date endDateTime) {
return activityRepository.subtractionActivityStockByRedis(uId, activityId, stockCount, endDateTime);
}
@Override
protected void recoverActivityCacheStockByRedis(Long activityId, String tokenKey, String code) {
activityRepository.recoverActivityCacheStockByRedis(activityId, tokenKey, code);
}
@Override
protected Result grabActivity(PartakeReq partake, ActivityBillVO bill, Long takeId) {
try {
dbRouter.doRouter(partake.getuId());
return transactionTemplate.execute(status -> {
try {
// 扣减个人已参与次数
int updateCount = userTakeActivityRepository.subtractionLeftCount(bill.getActivityId(), bill.getActivityName(), bill.getTakeCount(), bill.getUserTakeLeftCount(), partake.getuId());
if (0 == updateCount) {
status.setRollbackOnly();
logger.error("领取活动，扣减个人已参与次数失败 activityId：{} uId：{}", partake.getActivityId(), partake.getuId());
return Result.buildResult(Constants.ResponseCode.NO_UPDATE);
}
// 写入领取活动记录
userTakeActivityRepository.takeActivity(bill.getActivityId(), bill.getActivityName(), bill.getStrategyId(), bill.getTakeCount(), bill.getUserTakeLeftCount(), partake.getuId(), partake.getPartakeDate(), takeId);
} catch (DuplicateKeyException e) {
status.setRollbackOnly();
logger.error("领取活动，唯一索引冲突 activityId：{} uId：{}", partake.getActivityId(), partake.getuId(), e);
return Result.buildResult(Constants.ResponseCode.INDEX_DUP);
}
return Result.buildSuccessResult();
});
} finally {
dbRouter.clear();
}
}
@Override
public Result recordDrawOrder(DrawOrderVO drawOrder) {
try {
dbRouter.doRouter(drawOrder.getuId());
return transactionTemplate.execute(status -> {
try {
// 锁定活动领取记录
int lockCount = userTakeActivityRepository.lockTackActivity(drawOrder.getuId(), drawOrder.getActivityId(), drawOrder.getTakeId());
if (0 == lockCount) {
status.setRollbackOnly();
logger.error("记录中奖单，个人参与活动抽奖已消耗完 activityId：{} uId：{}", drawOrder.getActivityId(), drawOrder.getuId());
return Result.buildResult(Constants.ResponseCode.NO_UPDATE);
}
// 保存抽奖信息
userTakeActivityRepository.saveUserStrategyExport(drawOrder);
} catch (DuplicateKeyException e) {
status.setRollbackOnly();
logger.error("记录中奖单，唯一索引冲突 activityId：{} uId：{}", drawOrder.getActivityId(), drawOrder.getuId(), e);
return Result.buildResult(Constants.ResponseCode.INDEX_DUP);
}
return Result.buildSuccessResult();
});
} finally {
dbRouter.clear();
}
}
@Override
public Result lockTackActivity(String uId, Long activityId, Long takeId) {
try {
dbRouter.doRouter(uId);
return transactionTemplate.execute(status -> {
try {
// 锁定活动领取记录
int lockCount = userTakeActivityRepository.lockTackActivity(uId, activityId, takeId);
if (0 == lockCount) {
status.setRollbackOnly();
logger.error("记录未中奖，个人参与活动抽奖已消耗完 activityId：{} uId：{}", activityId, uId);
return Result.buildResult(Constants.ResponseCode.NO_UPDATE);
}
} catch (DuplicateKeyException e) {
status.setRollbackOnly();
logger.error("记录未中奖，唯一索引冲突 activityId：{} uId：{}", activityId, uId, e);
return Result.buildResult(Constants.ResponseCode.INDEX_DUP);
}
return Result.buildSuccessResult();
});
} finally {
dbRouter.clear();
}
}
@Override
public void updateInvoiceMqState(String uId, Long orderId, Integer mqState) {
userTakeActivityRepository.updateInvoiceMqState(uId, orderId, mqState);
}
@Override
public List<InvoiceVO> scanInvoiceMqState(int dbCount, int tbCount) {
try {
// 设置路由
dbRouter.setDBKey(dbCount);
dbRouter.setTBKey(tbCount);
// 查询数据
return userTakeActivityRepository.scanInvoiceMqState();
} finally {
dbRouter.clear();
}
}
@Override
public void updateActivityStock(ActivityPartakeRecordVO activityPartakeRecordVO) {
userTakeActivityRepository.updateActivityStock(activityPartakeRecordVO);
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/service/partake/impl/ActivityPartakeImpl.java
|
Java
|
apache-2.0
| 9,089
|
package cn.itedus.lottery.domain.activity.service.stateflow;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.common.Result;
import cn.itedus.lottery.domain.activity.repository.IActivityRepository;
import javax.annotation.Resource;
/**
* @description: 活动状态抽象类
* @author: 小傅哥，微信：fustack
* @date: 2021/9/12
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public abstract class AbstractState {
@Resource
protected IActivityRepository activityRepository;
/**
* 活动提审
*
* @param activityId 活动ID
* @param currentState 当前状态
* @return 执行结果
*/
public abstract Result arraignment(Long activityId, Enum<Constants.ActivityState> currentState);
/**
* 审核通过
*
* @param activityId 活动ID
* @param currentState 当前状态
* @return 执行结果
*/
public abstract Result checkPass(Long activityId, Enum<Constants.ActivityState> currentState);
/**
* 审核拒绝
*
* @param activityId 活动ID
* @param currentState 当前状态
* @return 执行结果
*/
public abstract Result checkRefuse(Long activityId, Enum<Constants.ActivityState> currentState);
/**
* 撤审撤销
*
* @param activityId 活动ID
* @param currentState 当前状态
* @return 执行结果
*/
public abstract Result checkRevoke(Long activityId, Enum<Constants.ActivityState> currentState);
/**
* 活动关闭
*
* @param activityId 活动ID
* @param currentState 当前状态
* @return 执行结果
*/
public abstract Result close(Long activityId, Enum<Constants.ActivityState> currentState);
/**
* 活动开启
*
* @param activityId 活动ID
* @param currentState 当前状态
* @return 执行结果
*/
public abstract Result open(Long activityId, Enum<Constants.ActivityState> currentState);
/**
* 活动执行
*
* @param activityId 活动ID
* @param currentState 当前状态
* @return 执行结果
*/
public abstract Result doing(Long activityId, Enum<Constants.ActivityState> currentState);
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/service/stateflow/AbstractState.java
|
Java
|
apache-2.0
| 2,381
|
package cn.itedus.lottery.domain.activity.service.stateflow;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.common.Result;
/**
* @description: 状态处理接口
* @author: 小傅哥，微信：fustack
* @date: 2021/9/12
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public interface IStateHandler {
/**
* 提审
* @param activityId 活动ID
* @param currentStatus 当前状态
* @return 审核结果
*/
Result arraignment(Long activityId, Enum<Constants.ActivityState> currentStatus);
/**
* 审核通过
* @param activityId 活动ID
* @param currentStatus 当前状态
* @return 审核结果
*/
Result checkPass(Long activityId, Enum<Constants.ActivityState> currentStatus);
/**
* 审核拒绝
* @param activityId 活动ID
* @param currentStatus 当前状态
* @return 审核结果
*/
Result checkRefuse(Long activityId, Enum<Constants.ActivityState> currentStatus);
/**
* 撤销审核
* @param activityId 活动ID
* @param currentStatus 当前状态
* @return 审核结果
*/
Result checkRevoke(Long activityId, Enum<Constants.ActivityState> currentStatus);
/**
* 关闭
* @param activityId 活动ID
* @param currentStatus 当前状态
* @return 审核结果
*/
Result close(Long activityId, Enum<Constants.ActivityState> currentStatus);
/**
* 开启
* @param activityId 活动ID
* @param currentStatus 当前状态
* @return 审核结果
*/
Result open(Long activityId, Enum<Constants.ActivityState> currentStatus);
/**
* 运行活动中
* @param activityId 活动ID
* @param currentStatus 当前状态
* @return 审核结果
*/
Result doing(Long activityId, Enum<Constants.ActivityState> currentStatus);
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/service/stateflow/IStateHandler.java
|
Java
|
apache-2.0
| 2,136
|
package cn.itedus.lottery.domain.activity.service.stateflow;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.domain.activity.service.stateflow.event.*;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* @description: 状态流转配置
* @author: 小傅哥，微信：fustack
* @date: 2021/9/12
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class StateConfig {
@Resource
private ArraignmentState arraignmentState;
@Resource
private CloseState closeState;
@Resource
private DoingState doingState;
@Resource
private EditingState editingState;
@Resource
private OpenState openState;
@Resource
private PassState passState;
@Resource
private RefuseState refuseState;
protected Map<Enum<Constants.ActivityState>, AbstractState> stateGroup = new ConcurrentHashMap<>();
@PostConstruct
public void init() {
stateGroup.put(Constants.ActivityState.ARRAIGNMENT, arraignmentState);
stateGroup.put(Constants.ActivityState.CLOSE, closeState);
stateGroup.put(Constants.ActivityState.DOING, doingState);
stateGroup.put(Constants.ActivityState.EDIT, editingState);
stateGroup.put(Constants.ActivityState.OPEN, openState);
stateGroup.put(Constants.ActivityState.PASS, passState);
stateGroup.put(Constants.ActivityState.REFUSE, refuseState);
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/service/stateflow/StateConfig.java
|
Java
|
apache-2.0
| 1,633
|
package cn.itedus.lottery.domain.activity.service.stateflow.event;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.common.Result;
import cn.itedus.lottery.domain.activity.service.stateflow.AbstractState;
import org.springframework.stereotype.Component;
/**
* @description: 提审状态
* @author: 小傅哥，微信：fustack
* @date: 2021/9/12
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Component
public class ArraignmentState extends AbstractState {
@Override
public Result arraignment(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "待审核状态不可重复提审");
}
@Override
public Result checkPass(Long activityId, Enum<Constants.ActivityState> currentState) {
boolean isSuccess = activityRepository.alterStatus(activityId, currentState, Constants.ActivityState.PASS);
return isSuccess ? Result.buildResult(Constants.ResponseCode.SUCCESS, "活动审核通过完成") : Result.buildErrorResult("活动状态变更失败");
}
@Override
public Result checkRefuse(Long activityId, Enum<Constants.ActivityState> currentState) {
boolean isSuccess = activityRepository.alterStatus(activityId, currentState, Constants.ActivityState.REFUSE);
return isSuccess ? Result.buildResult(Constants.ResponseCode.SUCCESS, "活动审核拒绝完成") : Result.buildErrorResult("活动状态变更失败");
}
@Override
public Result checkRevoke(Long activityId, Enum<Constants.ActivityState> currentState) {
boolean isSuccess = activityRepository.alterStatus(activityId, currentState, Constants.ActivityState.EDIT);
return isSuccess ? Result.buildResult(Constants.ResponseCode.SUCCESS, "活动审核撤销回到编辑中") : Result.buildErrorResult("活动状态变更失败");
}
@Override
public Result close(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "非拒绝活动不可关闭");
}
@Override
public Result open(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "非关闭活动不可开启");
}
@Override
public Result doing(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "待审核活动不可执行活动中变更");
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/service/stateflow/event/ArraignmentState.java
|
Java
|
apache-2.0
| 2,665
|
package cn.itedus.lottery.domain.activity.service.stateflow.event;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.common.Result;
import cn.itedus.lottery.domain.activity.service.stateflow.AbstractState;
import org.springframework.stereotype.Component;
/**
* @description: 活动关闭状态
* @author: 小傅哥，微信：fustack
* @date: 2021/9/12
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Component
public class CloseState extends AbstractState {
@Override
public Result arraignment(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动关闭不可提审");
}
@Override
public Result checkPass(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动关闭不可审核通过");
}
@Override
public Result checkRefuse(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动关闭不可审核拒绝");
}
@Override
public Result checkRevoke(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动关闭不可撤销审核");
}
@Override
public Result close(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动关闭不可重复关闭");
}
@Override
public Result open(Long activityId, Enum<Constants.ActivityState> currentState) {
boolean isSuccess = activityRepository.alterStatus(activityId, currentState, Constants.ActivityState.OPEN);
return isSuccess ? Result.buildResult(Constants.ResponseCode.SUCCESS, "活动开启完成") : Result.buildErrorResult("活动状态变更失败");
}
@Override
public Result doing(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动关闭不可变更活动中");
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/service/stateflow/event/CloseState.java
|
Java
|
apache-2.0
| 2,286
|
package cn.itedus.lottery.domain.activity.service.stateflow.event;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.common.Result;
import cn.itedus.lottery.domain.activity.service.stateflow.AbstractState;
import org.springframework.stereotype.Component;
/**
* @description: 运行(活动中)状态
* @author: 小傅哥，微信：fustack
* @date: 2021/9/12
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Component
public class DoingState extends AbstractState {
@Override
public Result arraignment(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动中不可提审");
}
@Override
public Result checkPass(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动中不可审核通过");
}
@Override
public Result checkRefuse(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动中不可审核拒绝");
}
@Override
public Result checkRevoke(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动中不可撤销审核");
}
@Override
public Result close(Long activityId, Enum<Constants.ActivityState> currentState) {
boolean isSuccess = activityRepository.alterStatus(activityId, currentState, Constants.ActivityState.CLOSE);
return isSuccess ? Result.buildResult(Constants.ResponseCode.SUCCESS, "活动关闭成功") : Result.buildErrorResult("活动状态变更失败");
}
@Override
public Result open(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "非关闭活动不可开启");
}
@Override
public Result doing(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动中不可重复执行");
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/service/stateflow/event/DoingState.java
|
Java
|
apache-2.0
| 2,271
|
package cn.itedus.lottery.domain.activity.service.stateflow.event;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.common.Result;
import cn.itedus.lottery.domain.activity.service.stateflow.AbstractState;
import org.springframework.stereotype.Component;
/**
* @description: 编辑状态
* @author: 小傅哥，微信：fustack
* @date: 2021/9/12
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Component
public class EditingState extends AbstractState {
@Override
public Result arraignment(Long activityId, Enum<Constants.ActivityState> currentState) {
boolean isSuccess = activityRepository.alterStatus(activityId, currentState, Constants.ActivityState.ARRAIGNMENT);
return isSuccess ? Result.buildResult(Constants.ResponseCode.SUCCESS, "活动提审成功") : Result.buildErrorResult("活动状态变更失败");
}
@Override
public Result checkPass(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "编辑中不可审核通过");
}
@Override
public Result checkRefuse(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "编辑中不可审核拒绝");
}
@Override
public Result checkRevoke(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "编辑中不可撤销审核");
}
@Override
public Result close(Long activityId, Enum<Constants.ActivityState> currentState) {
boolean isSuccess = activityRepository.alterStatus(activityId, currentState, Constants.ActivityState.CLOSE);
return isSuccess ? Result.buildResult(Constants.ResponseCode.SUCCESS, "活动关闭成功") : Result.buildErrorResult("活动状态变更失败");
}
@Override
public Result open(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "非关闭活动不可开启");
}
@Override
public Result doing(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "编辑中活动不可执行活动中变更");
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/service/stateflow/event/EditingState.java
|
Java
|
apache-2.0
| 2,462
|
package cn.itedus.lottery.domain.activity.service.stateflow.event;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.common.Result;
import cn.itedus.lottery.domain.activity.service.stateflow.AbstractState;
import org.springframework.stereotype.Component;
/**
* @description: 活动开启状态
* @author: 小傅哥，微信：fustack
* @date: 2021/9/12
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Component
public class OpenState extends AbstractState {
@Override
public Result arraignment(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动开启不可提审");
}
@Override
public Result checkPass(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动开启不可审核通过");
}
@Override
public Result checkRefuse(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动开启不可审核拒绝");
}
@Override
public Result checkRevoke(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动开启不可撤销审核");
}
@Override
public Result close(Long activityId, Enum<Constants.ActivityState> currentState) {
boolean isSuccess = activityRepository.alterStatus(activityId, currentState, Constants.ActivityState.CLOSE);
return isSuccess ? Result.buildResult(Constants.ResponseCode.SUCCESS, "活动开启完成") : Result.buildErrorResult("活动状态变更失败");
}
@Override
public Result open(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动不可重复开启");
}
@Override
public Result doing(Long activityId, Enum<Constants.ActivityState> currentState) {
boolean isSuccess = activityRepository.alterStatus(activityId, currentState, Constants.ActivityState.DOING);
return isSuccess ? Result.buildResult(Constants.ResponseCode.SUCCESS, "活动变更活动中完成") : Result.buildErrorResult("活动状态变更失败");
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/service/stateflow/event/OpenState.java
|
Java
|
apache-2.0
| 2,456
|
package cn.itedus.lottery.domain.activity.service.stateflow.event;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.common.Result;
import cn.itedus.lottery.domain.activity.service.stateflow.AbstractState;
import org.springframework.stereotype.Component;
/**
* @description: 审核通过状态
* @author: 小傅哥，微信：fustack
* @date: 2021/9/12
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Component
public class PassState extends AbstractState {
@Override
public Result arraignment(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "已审核状态不可重复提审");
}
@Override
public Result checkPass(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "已审核状态不可重复审核");
}
@Override
public Result checkRefuse(Long activityId, Enum<Constants.ActivityState> currentState) {
boolean isSuccess = activityRepository.alterStatus(activityId, currentState, Constants.ActivityState.REFUSE);
return isSuccess ? Result.buildResult(Constants.ResponseCode.SUCCESS, "活动审核拒绝完成") : Result.buildErrorResult("活动状态变更失败");
}
@Override
public Result checkRevoke(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "审核通过不可撤销(可先拒绝审核)");
}
@Override
public Result close(Long activityId, Enum<Constants.ActivityState> currentState) {
boolean isSuccess = activityRepository.alterStatus(activityId, currentState, Constants.ActivityState.CLOSE);
return isSuccess ? Result.buildResult(Constants.ResponseCode.SUCCESS, "活动审核关闭完成") : Result.buildErrorResult("活动状态变更失败");
}
@Override
public Result open(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "非关闭活动不可开启");
}
@Override
public Result doing(Long activityId, Enum<Constants.ActivityState> currentState) {
boolean isSuccess = activityRepository.alterStatus(activityId, currentState, Constants.ActivityState.DOING);
return isSuccess ? Result.buildResult(Constants.ResponseCode.SUCCESS, "活动变更活动中完成") : Result.buildErrorResult("活动状态变更失败");
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/service/stateflow/event/PassState.java
|
Java
|
apache-2.0
| 2,668
|
package cn.itedus.lottery.domain.activity.service.stateflow.event;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.common.Result;
import cn.itedus.lottery.domain.activity.service.stateflow.AbstractState;
import org.springframework.stereotype.Component;
/**
* @description: 审核拒绝状态
* @author: 小傅哥，微信：fustack
* @date: 2021/9/12
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Component
public class RefuseState extends AbstractState {
@Override
public Result arraignment(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "已审核状态不可重复提审");
}
@Override
public Result checkPass(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "已审核状态不可重复审核");
}
@Override
public Result checkRefuse(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动审核拒绝不可重复审核");
}
@Override
public Result checkRevoke(Long activityId, Enum<Constants.ActivityState> currentState) {
boolean isSuccess = activityRepository.alterStatus(activityId, currentState, Constants.ActivityState.EDIT);
return isSuccess ? Result.buildResult(Constants.ResponseCode.SUCCESS, "撤销审核完成") : Result.buildErrorResult("活动状态变更失败");
}
@Override
public Result close(Long activityId, Enum<Constants.ActivityState> currentState) {
boolean isSuccess = activityRepository.alterStatus(activityId, currentState, Constants.ActivityState.CLOSE);
return isSuccess ? Result.buildResult(Constants.ResponseCode.SUCCESS, "活动审核关闭完成") : Result.buildErrorResult("活动状态变更失败");
}
@Override
public Result open(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "非关闭活动不可开启");
}
@Override
public Result doing(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "审核拒绝不可执行活动为进行中");
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/service/stateflow/event/RefuseState.java
|
Java
|
apache-2.0
| 2,487
|
package cn.itedus.lottery.domain.activity.service.stateflow.impl;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.common.Result;
import cn.itedus.lottery.domain.activity.service.stateflow.IStateHandler;
import cn.itedus.lottery.domain.activity.service.stateflow.StateConfig;
import org.springframework.stereotype.Service;
/**
* @description: 状态处理服务
* @author: 小傅哥，微信：fustack
* @date: 2021/9/12
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Service
public class StateHandlerImpl extends StateConfig implements IStateHandler {
@Override
public Result arraignment(Long activityId, Enum<Constants.ActivityState> currentStatus) {
return stateGroup.get(currentStatus).arraignment(activityId, currentStatus);
}
@Override
public Result checkPass(Long activityId, Enum<Constants.ActivityState> currentStatus) {
return stateGroup.get(currentStatus).checkPass(activityId, currentStatus);
}
@Override
public Result checkRefuse(Long activityId, Enum<Constants.ActivityState> currentStatus) {
return stateGroup.get(currentStatus).checkRefuse(activityId, currentStatus);
}
@Override
public Result checkRevoke(Long activityId, Enum<Constants.ActivityState> currentStatus) {
return stateGroup.get(currentStatus).checkRevoke(activityId, currentStatus);
}
@Override
public Result close(Long activityId, Enum<Constants.ActivityState> currentStatus) {
return stateGroup.get(currentStatus).close(activityId, currentStatus);
}
@Override
public Result open(Long activityId, Enum<Constants.ActivityState> currentStatus) {
return stateGroup.get(currentStatus).open(activityId, currentStatus);
}
@Override
public Result doing(Long activityId, Enum<Constants.ActivityState> currentStatus) {
return stateGroup.get(currentStatus).doing(activityId, currentStatus);
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/activity/service/stateflow/impl/StateHandlerImpl.java
|
Java
|
apache-2.0
| 2,083
|
package cn.itedus.lottery.domain.award.model.req;
import cn.itedus.lottery.domain.award.model.vo.ShippingAddress;
/**
* @description: 奖品发货信息
* @author: 小傅哥，微信：fustack
* @date: 2021/9/4
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class GoodsReq {
/** 用户ID */
private String uId;
/** 抽奖单号 ID */
private Long orderId;
/** 奖品ID */
private String awardId;
/** 奖品名称 */
private String awardName;
/** 奖品内容「描述、奖品码、sku」 */
private String awardContent;
/** 四级送货地址（只有实物类商品需要地址） */
private ShippingAddress shippingAddress;
/** 扩展信息，用于一些个性商品发放所需要的透传字段内容 */
private String extInfo;
public GoodsReq() {
}
public GoodsReq(String uId, Long orderId, String awardId, String awardName, String awardContent) {
this.uId = uId;
this.orderId = orderId;
this.awardId = awardId;
this.awardName = awardName;
this.awardContent = awardContent;
}
public GoodsReq(String uId, Long orderId, String awardId, String awardName, String awardContent, ShippingAddress shippingAddress) {
this.uId = uId;
this.orderId = orderId;
this.awardId = awardId;
this.awardName = awardName;
this.awardContent = awardContent;
this.shippingAddress = shippingAddress;
}
public String getuId() {
return uId;
}
public void setuId(String uId) {
this.uId = uId;
}
public Long getOrderId() {
return orderId;
}
public void setOrderId(Long orderId) {
this.orderId = orderId;
}
public String getAwardId() {
return awardId;
}
public void setAwardId(String awardId) {
this.awardId = awardId;
}
public String getAwardName() {
return awardName;
}
public void setAwardName(String awardName) {
this.awardName = awardName;
}
public String getAwardContent() {
return awardContent;
}
public void setAwardContent(String awardContent) {
this.awardContent = awardContent;
}
public ShippingAddress getShippingAddress() {
return shippingAddress;
}
public void setShippingAddress(ShippingAddress shippingAddress) {
this.shippingAddress = shippingAddress;
}
public String getExtInfo() {
return extInfo;
}
public void setExtInfo(String extInfo) {
this.extInfo = extInfo;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/award/model/req/GoodsReq.java
|
Java
|
apache-2.0
| 2,735
|
package cn.itedus.lottery.domain.award.model.res;
/**
* @description: 商品配送结果
* @author: 小傅哥，微信：fustack
* @date: 2021/9/4
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class DistributionRes {
/** 用户ID */
private String uId;
/** 编码 */
private Integer code;
/** 描述 */
private String info;
/** 结算单ID，如：发券后有券码、发货后有单号等，用于存根查询 */
private String statementId;
public DistributionRes() {
}
/**
* 构造函数
*
* @param uId 用户ID
* @param code 编码
* @param info 描述
*/
public DistributionRes(String uId, Integer code, String info) {
this.uId = uId;
this.code = code;
this.info = info;
}
public DistributionRes(String uId, Integer code, String info, String statementId) {
this.uId = uId;
this.code = code;
this.info = info;
this.statementId = statementId;
}
public String getuId() {
return uId;
}
public void setuId(String uId) {
this.uId = uId;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
public String getStatementId() {
return statementId;
}
public void setStatementId(String statementId) {
this.statementId = statementId;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/award/model/res/DistributionRes.java
|
Java
|
apache-2.0
| 1,721
|
package cn.itedus.lottery.domain.award.model.vo;
/**
* @description: 实物商品送货四级地址
* @author: 小傅哥，微信：fustack
* @date: 2021/9/4
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class ShippingAddress {
/** 收获人 */
private String name;
/** 一级地址ID */
private String provinceId;
/** 一级地址名称 */
private String provinceName;
/** 二级地址ID */
private String cityId;
/** 二级地址名称 */
private String cityName;
/** 三级地址ID */
private String countyId;
/** 三级地址名称 */
private String countyName;
/** 四级地址ID */
private String townId;
/** 四级地址名称 */
private String townName;
/** 详细地址 */
private String address;
/** 手机号 */
private String phone;
/** 邮箱 */
private String email;
/** 备注 */
private String remark;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getProvinceId() {
return provinceId;
}
public void setProvinceId(String provinceId) {
this.provinceId = provinceId;
}
public String getProvinceName() {
return provinceName;
}
public void setProvinceName(String provinceName) {
this.provinceName = provinceName;
}
public String getCityId() {
return cityId;
}
public void setCityId(String cityId) {
this.cityId = cityId;
}
public String getCityName() {
return cityName;
}
public void setCityName(String cityName) {
this.cityName = cityName;
}
public String getCountyId() {
return countyId;
}
public void setCountyId(String countyId) {
this.countyId = countyId;
}
public String getCountyName() {
return countyName;
}
public void setCountyName(String countyName) {
this.countyName = countyName;
}
public String getTownId() {
return townId;
}
public void setTownId(String townId) {
this.townId = townId;
}
public String getTownName() {
return townName;
}
public void setTownName(String townName) {
this.townName = townName;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/award/model/vo/ShippingAddress.java
|
Java
|
apache-2.0
| 3,035
|
package cn.itedus.lottery.domain.award.repository;
/**
* @description: 奖品表仓储服务接口
* @author: 小傅哥，微信：fustack
* @date: 2021/9/4
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public interface IOrderRepository {
/**
* 更新奖品发放状态
*
* @param uId 用户ID
* @param orderId 订单ID
* @param awardId 奖品ID
* @param grantState 奖品状态
*/
void updateUserAwardState(String uId, Long orderId, String awardId, Integer grantState);
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/award/repository/IOrderRepository.java
|
Java
|
apache-2.0
| 708
|
package cn.itedus.lottery.domain.award.service.factory;
import cn.itedus.lottery.domain.award.service.goods.IDistributionGoods;
import org.springframework.stereotype.Service;
/**
* @description: 配送商品简单工厂，提供获取配送服务
* @author: 小傅哥，微信：fustack
* @date: 2021/9/4
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Service
public class DistributionGoodsFactory extends GoodsConfig {
public IDistributionGoods getDistributionGoodsService(Integer awardType){
return goodsMap.get(awardType);
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/award/service/factory/DistributionGoodsFactory.java
|
Java
|
apache-2.0
| 698
|
package cn.itedus.lottery.domain.award.service.factory;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.domain.award.service.goods.IDistributionGoods;
import cn.itedus.lottery.domain.award.service.goods.impl.CouponGoods;
import cn.itedus.lottery.domain.award.service.goods.impl.DescGoods;
import cn.itedus.lottery.domain.award.service.goods.impl.PhysicalGoods;
import cn.itedus.lottery.domain.award.service.goods.impl.RedeemCodeGoods;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* @description: 各类发奖奖品配置类
* @author: 小傅哥，微信：fustack
* @date: 2021/9/4
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class GoodsConfig {
/** 奖品发放策略组 */
protected static Map<Integer, IDistributionGoods> goodsMap = new ConcurrentHashMap<>();
@Resource
private DescGoods descGoods;
@Resource
private RedeemCodeGoods redeemCodeGoods;
@Resource
private CouponGoods couponGoods;
@Resource
private PhysicalGoods physicalGoods;
@PostConstruct
public void init() {
goodsMap.put(Constants.AwardType.DESC.getCode(), descGoods);
goodsMap.put(Constants.AwardType.RedeemCodeGoods.getCode(), redeemCodeGoods);
goodsMap.put(Constants.AwardType.CouponGoods.getCode(), couponGoods);
goodsMap.put(Constants.AwardType.PhysicalGoods.getCode(), physicalGoods);
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/award/service/factory/GoodsConfig.java
|
Java
|
apache-2.0
| 1,638
|
package cn.itedus.lottery.domain.award.service.goods;
import cn.itedus.lottery.domain.award.repository.IOrderRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Resource;
/**
* @description: 配送货物基础共用类
* @author: 小傅哥，微信：fustack
* @date: 2021/9/4
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class DistributionBase {
protected Logger logger = LoggerFactory.getLogger(DistributionBase.class);
@Resource
private IOrderRepository awardRepository;
protected void updateUserAwardState(String uId, Long orderId, String awardId, Integer grantState) {
awardRepository.updateUserAwardState(uId, orderId, awardId, grantState);
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/award/service/goods/DistributionBase.java
|
Java
|
apache-2.0
| 883
|
package cn.itedus.lottery.domain.award.service.goods;
import cn.itedus.lottery.domain.award.model.req.GoodsReq;
import cn.itedus.lottery.domain.award.model.res.DistributionRes;
/**
* @description: 抽奖，抽象出配送货物接口，把各类奖品模拟成货物、配送代表着发货，包括虚拟奖品和实物奖品
* @author: 小傅哥，微信：fustack
* @date: 2021/9/4
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public interface IDistributionGoods {
/**
* 奖品配送接口，奖品类型（1:文字描述、2:兑换码、3:优惠券、4:实物奖品）
*
* @param req 物品信息
* @return 配送结果
*/
DistributionRes doDistribution(GoodsReq req);
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/award/service/goods/IDistributionGoods.java
|
Java
|
apache-2.0
| 868
|
package cn.itedus.lottery.domain.award.service.goods.impl;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.domain.award.model.req.GoodsReq;
import cn.itedus.lottery.domain.award.model.res.DistributionRes;
import cn.itedus.lottery.domain.award.service.goods.DistributionBase;
import cn.itedus.lottery.domain.award.service.goods.IDistributionGoods;
import org.springframework.stereotype.Component;
/**
* @description: 优惠券商品
* @author: 小傅哥，微信：fustack
* @date: 2021/9/4
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Component
public class CouponGoods extends DistributionBase implements IDistributionGoods {
@Override
public DistributionRes doDistribution(GoodsReq req) {
// 模拟调用优惠券发放接口
logger.info("模拟调用优惠券发放接口 uId：{} awardContent：{}", req.getuId(), req.getAwardContent());
// 更新用户领奖结果
super.updateUserAwardState(req.getuId(), req.getOrderId(), req.getAwardId(), Constants.GrantState.COMPLETE.getCode());
return new DistributionRes(req.getuId(), Constants.AwardState.SUCCESS.getCode(), Constants.AwardState.SUCCESS.getInfo());
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/award/service/goods/impl/CouponGoods.java
|
Java
|
apache-2.0
| 1,343
|
package cn.itedus.lottery.domain.award.service.goods.impl;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.domain.award.model.req.GoodsReq;
import cn.itedus.lottery.domain.award.model.res.DistributionRes;
import cn.itedus.lottery.domain.award.service.goods.DistributionBase;
import cn.itedus.lottery.domain.award.service.goods.IDistributionGoods;
import org.springframework.stereotype.Component;
/**
* @description: 描述类商品，以文字形式展示给用户
* @author: 小傅哥，微信：fustack
* @date: 2021/9/4
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Component
public class DescGoods extends DistributionBase implements IDistributionGoods {
@Override
public DistributionRes doDistribution(GoodsReq req) {
super.updateUserAwardState(req.getuId(), req.getOrderId(), req.getAwardId(), Constants.GrantState.COMPLETE.getCode());
return new DistributionRes(req.getuId(), Constants.AwardState.SUCCESS.getCode(), Constants.AwardState.SUCCESS.getInfo());
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/award/service/goods/impl/DescGoods.java
|
Java
|
apache-2.0
| 1,171
|
package cn.itedus.lottery.domain.award.service.goods.impl;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.domain.award.model.req.GoodsReq;
import cn.itedus.lottery.domain.award.model.res.DistributionRes;
import cn.itedus.lottery.domain.award.service.goods.DistributionBase;
import cn.itedus.lottery.domain.award.service.goods.IDistributionGoods;
import org.springframework.stereotype.Component;
/**
* @description: 实物发货类商品
* @author: 小傅哥，微信：fustack
* @date: 2021/9/4
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Component
public class PhysicalGoods extends DistributionBase implements IDistributionGoods {
@Override
public DistributionRes doDistribution(GoodsReq req) {
// 模拟调用实物发奖
logger.info("模拟调用实物发奖 uId：{} awardContent：{}", req.getuId(), req.getAwardContent());
// 更新用户领奖结果
super.updateUserAwardState(req.getuId(), req.getOrderId(), req.getAwardId(), Constants.GrantState.COMPLETE.getCode());
return new DistributionRes(req.getuId(), Constants.AwardState.SUCCESS.getCode(), Constants.AwardState.SUCCESS.getInfo());
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/award/service/goods/impl/PhysicalGoods.java
|
Java
|
apache-2.0
| 1,334
|
package cn.itedus.lottery.domain.award.service.goods.impl;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.domain.award.model.req.GoodsReq;
import cn.itedus.lottery.domain.award.model.res.DistributionRes;
import cn.itedus.lottery.domain.award.service.goods.DistributionBase;
import cn.itedus.lottery.domain.award.service.goods.IDistributionGoods;
import org.springframework.stereotype.Component;
/**
* @description: 兑换码类商品
* @author: 小傅哥，微信：fustack
* @date: 2021/9/4
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Component
public class RedeemCodeGoods extends DistributionBase implements IDistributionGoods {
@Override
public DistributionRes doDistribution(GoodsReq req) {
// 模拟调用兑换码
logger.info("模拟调用兑换码 uId：{} awardContent：{}", req.getuId(), req.getAwardContent());
// 更新用户领奖结果
super.updateUserAwardState(req.getuId(), req.getOrderId(), req.getAwardId(), Constants.GrantState.COMPLETE.getCode());
return new DistributionRes(req.getuId(), Constants.AwardState.SUCCESS.getCode(), Constants.AwardState.SUCCESS.getInfo());
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/award/service/goods/impl/RedeemCodeGoods.java
|
Java
|
apache-2.0
| 1,327
|
package cn.itedus.lottery.domain.rule.model.aggregates;
import cn.itedus.lottery.domain.rule.model.vo.TreeNodeVO;
import cn.itedus.lottery.domain.rule.model.vo.TreeRootVO;
import java.util.Map;
/**
* @description: 规则树聚合
* @author: 小傅哥，微信：fustack
* @date: 2021/10/8
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class TreeRuleRich {
/** 树根信息 */
private TreeRootVO treeRoot;
/** 树节点ID -> 子节点 */
private Map<Long, TreeNodeVO> treeNodeMap;
public TreeRootVO getTreeRoot() {
return treeRoot;
}
public void setTreeRoot(TreeRootVO treeRoot) {
this.treeRoot = treeRoot;
}
public Map<Long, TreeNodeVO> getTreeNodeMap() {
return treeNodeMap;
}
public void setTreeNodeMap(Map<Long, TreeNodeVO> treeNodeMap) {
this.treeNodeMap = treeNodeMap;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/rule/model/aggregates/TreeRuleRich.java
|
Java
|
apache-2.0
| 1,021
|
package cn.itedus.lottery.domain.rule.model.req;
import java.util.Map;
/**
* @description: 决策物料
* @author: 小傅哥，微信：fustack
* @date: 2021/10/8
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class DecisionMatterReq {
/**
* 规则树ID
*/
private Long treeId;
/**
* 用户ID
*/
private String userId;
/**
* 决策值
*/
private Map<String, Object> valMap;
public DecisionMatterReq() {
}
public DecisionMatterReq(String userId, Long treeId, Map<String, Object> valMap) {
this.userId = userId;
this.treeId = treeId;
this.valMap = valMap;
}
public Long getTreeId() {
return treeId;
}
public void setTreeId(Long treeId) {
this.treeId = treeId;
}
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public Map<String, Object> getValMap() {
return valMap;
}
public void setValMap(Map<String, Object> valMap) {
this.valMap = valMap;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/rule/model/req/DecisionMatterReq.java
|
Java
|
apache-2.0
| 1,260
|
package cn.itedus.lottery.domain.rule.model.res;
/**
* @description: 决策结果
* @author: 小傅哥，微信：fustack
* @date: 2021/10/8
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class EngineResult {
/** 执行结果 */
private boolean isSuccess;
/** 用户ID */
private String userId;
/** 规则树ID */
private Long treeId;
/** 果实节点ID */
private Long nodeId;
/** 果实节点值 */
private String nodeValue;
public EngineResult() {
}
public EngineResult(boolean isSuccess) {
this.isSuccess = isSuccess;
}
public EngineResult(String userId, Long treeId, Long nodeId, String nodeValue) {
this.isSuccess = true;
this.userId = userId;
this.treeId = treeId;
this.nodeId = nodeId;
this.nodeValue = nodeValue;
}
public boolean isSuccess() {
return isSuccess;
}
public void setSuccess(boolean success) {
isSuccess = success;
}
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public Long getTreeId() {
return treeId;
}
public void setTreeId(Long treeId) {
this.treeId = treeId;
}
public Long getNodeId() {
return nodeId;
}
public void setNodeId(Long nodeId) {
this.nodeId = nodeId;
}
public String getNodeValue() {
return nodeValue;
}
public void setNodeValue(String nodeValue) {
this.nodeValue = nodeValue;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/rule/model/res/EngineResult.java
|
Java
|
apache-2.0
| 1,723
|
package cn.itedus.lottery.domain.rule.model.vo;
/**
* @description: 规则树线信息
* @author: 小傅哥，微信：fustack
* @date: 2021/10/8
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class TreeNodeLineVO {
/** 节点From */
private Long nodeIdFrom;
/** 节点To */
private Long nodeIdTo;
/** 限定类型；1:=;2:>;3:<;4:>=;5<=;6:enum[枚举范围] */
private Integer ruleLimitType;
/** 限定值 */
private String ruleLimitValue;
public Long getNodeIdFrom() {
return nodeIdFrom;
}
public void setNodeIdFrom(Long nodeIdFrom) {
this.nodeIdFrom = nodeIdFrom;
}
public Long getNodeIdTo() {
return nodeIdTo;
}
public void setNodeIdTo(Long nodeIdTo) {
this.nodeIdTo = nodeIdTo;
}
public Integer getRuleLimitType() {
return ruleLimitType;
}
public void setRuleLimitType(Integer ruleLimitType) {
this.ruleLimitType = ruleLimitType;
}
public String getRuleLimitValue() {
return ruleLimitValue;
}
public void setRuleLimitValue(String ruleLimitValue) {
this.ruleLimitValue = ruleLimitValue;
}
@Override
public String toString() {
return "TreeNodeLineVO{" +
"nodeIdFrom=" + nodeIdFrom +
", nodeIdTo=" + nodeIdTo +
", ruleLimitType=" + ruleLimitType +
", ruleLimitValue='" + ruleLimitValue + '\'' +
'}';
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/rule/model/vo/TreeNodeLineVO.java
|
Java
|
apache-2.0
| 1,632
|
package cn.itedus.lottery.domain.rule.model.vo;
import java.util.List;
/**
* @description: 规则树节点信息
* @author: 小傅哥，微信：fustack
* @date: 2021/10/8
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class TreeNodeVO {
/** 规则树ID */
private Long treeId;
/** 规则树节点ID */
private Long treeNodeId;
/** 节点类型；1子叶、2果实 */
private Integer nodeType;
/** 节点值[nodeType=2]；果实值 */
private String nodeValue;
/** 规则Key */
private String ruleKey;
/** 规则描述 */
private String ruleDesc;
/** 节点链路 */
private List<TreeNodeLineVO> treeNodeLineInfoList;
public Long getTreeId() {
return treeId;
}
public void setTreeId(Long treeId) {
this.treeId = treeId;
}
public Long getTreeNodeId() {
return treeNodeId;
}
public void setTreeNodeId(Long treeNodeId) {
this.treeNodeId = treeNodeId;
}
public Integer getNodeType() {
return nodeType;
}
public void setNodeType(Integer nodeType) {
this.nodeType = nodeType;
}
public String getNodeValue() {
return nodeValue;
}
public void setNodeValue(String nodeValue) {
this.nodeValue = nodeValue;
}
public String getRuleKey() {
return ruleKey;
}
public void setRuleKey(String ruleKey) {
this.ruleKey = ruleKey;
}
public String getRuleDesc() {
return ruleDesc;
}
public void setRuleDesc(String ruleDesc) {
this.ruleDesc = ruleDesc;
}
public List<TreeNodeLineVO> getTreeNodeLineInfoList() {
return treeNodeLineInfoList;
}
public void setTreeNodeLineInfoList(List<TreeNodeLineVO> treeNodeLineInfoList) {
this.treeNodeLineInfoList = treeNodeLineInfoList;
}
@Override
public String toString() {
return "TreeNodeVO{" +
"treeId=" + treeId +
", treeNodeId=" + treeNodeId +
", nodeType=" + nodeType +
", nodeValue='" + nodeValue + '\'' +
", ruleKey='" + ruleKey + '\'' +
", ruleDesc='" + ruleDesc + '\'' +
", treeNodeLineInfoList=" + treeNodeLineInfoList +
'}';
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/rule/model/vo/TreeNodeVO.java
|
Java
|
apache-2.0
| 2,456
|
package cn.itedus.lottery.domain.rule.model.vo;
/**
* @description: 规则树根配置
* @author: 小傅哥，微信：fustack
* @date: 2021/10/8
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class TreeRootVO {
/** 规则树ID */
private Long treeId;
/** 规则树根ID */
private Long treeRootNodeId;
/** 规则树名称 */
private String treeName;
public Long getTreeId() {
return treeId;
}
public void setTreeId(Long treeId) {
this.treeId = treeId;
}
public Long getTreeRootNodeId() {
return treeRootNodeId;
}
public void setTreeRootNodeId(Long treeRootNodeId) {
this.treeRootNodeId = treeRootNodeId;
}
public String getTreeName() {
return treeName;
}
public void setTreeName(String treeName) {
this.treeName = treeName;
}
@Override
public String toString() {
return "TreeRootVO{" +
"treeId=" + treeId +
", treeRootNodeId=" + treeRootNodeId +
", treeName='" + treeName + '\'' +
'}';
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/rule/model/vo/TreeRootVO.java
|
Java
|
apache-2.0
| 1,258
|
package cn.itedus.lottery.domain.rule.repository;
import cn.itedus.lottery.domain.rule.model.aggregates.TreeRuleRich;
/**
* @description: 规则信息仓储服务接口
* @author: 小傅哥，微信：fustack
* @date: 2021/10/8
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public interface IRuleRepository {
/**
* 查询规则决策树配置
*
* @param treeId 决策树ID
* @return 决策树配置
*/
TreeRuleRich queryTreeRuleRich(Long treeId);
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/rule/repository/IRuleRepository.java
|
Java
|
apache-2.0
| 646
|
package cn.itedus.lottery.domain.rule.service.engine;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.domain.rule.model.aggregates.TreeRuleRich;
import cn.itedus.lottery.domain.rule.model.res.EngineResult;
import cn.itedus.lottery.domain.rule.model.req.DecisionMatterReq;
import cn.itedus.lottery.domain.rule.model.vo.TreeNodeVO;
import cn.itedus.lottery.domain.rule.model.vo.TreeRootVO;
import cn.itedus.lottery.domain.rule.service.logic.LogicFilter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Map;
/**
* @description: 规则引擎基础类
* @author: 小傅哥，微信：fustack
* @date: 2021/10/8
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public abstract class EngineBase extends EngineConfig implements EngineFilter {
private Logger logger = LoggerFactory.getLogger(EngineBase.class);
@Override
public EngineResult process(DecisionMatterReq matter) {
throw new RuntimeException("未实现规则引擎服务");
}
protected TreeNodeVO engineDecisionMaker(TreeRuleRich treeRuleRich, DecisionMatterReq matter) {
TreeRootVO treeRoot = treeRuleRich.getTreeRoot();
Map<Long, TreeNodeVO> treeNodeMap = treeRuleRich.getTreeNodeMap();
// 规则树根ID
Long rootNodeId = treeRoot.getTreeRootNodeId();
TreeNodeVO treeNodeInfo = treeNodeMap.get(rootNodeId);
// 节点类型[NodeType]；1子叶、2果实
while (Constants.NodeType.STEM.equals(treeNodeInfo.getNodeType())) {
String ruleKey = treeNodeInfo.getRuleKey();
LogicFilter logicFilter = logicFilterMap.get(ruleKey);
String matterValue = logicFilter.matterValue(matter);
Long nextNode = logicFilter.filter(matterValue, treeNodeInfo.getTreeNodeLineInfoList());
treeNodeInfo = treeNodeMap.get(nextNode);
logger.info("决策树引擎=>{} userId：{} treeId：{} treeNode：{} ruleKey：{} matterValue：{}", treeRoot.getTreeName(), matter.getUserId(), matter.getTreeId(), treeNodeInfo.getTreeNodeId(), ruleKey, matterValue);
}
return treeNodeInfo;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/rule/service/engine/EngineBase.java
|
Java
|
apache-2.0
| 2,286
|
package cn.itedus.lottery.domain.rule.service.engine;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.domain.rule.service.logic.LogicFilter;
import cn.itedus.lottery.domain.rule.service.logic.impl.UserAgeFilter;
import cn.itedus.lottery.domain.rule.service.logic.impl.UserGenderFilter;
import jdk.nashorn.internal.ir.annotations.Reference;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* @description: 规则配置
* @author: 小傅哥，微信：fustack
* @date: 2021/10/8
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class EngineConfig {
protected static Map<String, LogicFilter> logicFilterMap = new ConcurrentHashMap<>();
@Resource
private UserAgeFilter userAgeFilter;
@Resource
private UserGenderFilter userGenderFilter;
@PostConstruct
public void init() {
logicFilterMap.put("userAge", userAgeFilter);
logicFilterMap.put("userGender", userGenderFilter);
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/rule/service/engine/EngineConfig.java
|
Java
|
apache-2.0
| 1,195
|
package cn.itedus.lottery.domain.rule.service.engine;
import cn.itedus.lottery.domain.rule.model.res.EngineResult;
import cn.itedus.lottery.domain.rule.model.req.DecisionMatterReq;
/**
* @description: 规则过滤器引擎
* @author: 小傅哥，微信：fustack
* @date: 2021/10/8
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public interface EngineFilter {
/**
* 规则过滤器接口
*
* @param matter 规则决策物料
* @return 规则决策结果
*/
EngineResult process(final DecisionMatterReq matter);
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/rule/service/engine/EngineFilter.java
|
Java
|
apache-2.0
| 714
|
package cn.itedus.lottery.domain.rule.service.engine.impl;
import cn.itedus.lottery.domain.rule.model.aggregates.TreeRuleRich;
import cn.itedus.lottery.domain.rule.model.res.EngineResult;
import cn.itedus.lottery.domain.rule.model.req.DecisionMatterReq;
import cn.itedus.lottery.domain.rule.model.vo.TreeNodeVO;
import cn.itedus.lottery.domain.rule.repository.IRuleRepository;
import cn.itedus.lottery.domain.rule.service.engine.EngineBase;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* @description: 规则引擎处理器
* @author: 小傅哥，微信：fustack
* @date: 2021/10/8
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Service("ruleEngineHandle")
public class RuleEngineHandle extends EngineBase {
@Resource
private IRuleRepository ruleRepository;
@Override
public EngineResult process(DecisionMatterReq matter) {
// 决策规则树
TreeRuleRich treeRuleRich = ruleRepository.queryTreeRuleRich(matter.getTreeId());
if (null == treeRuleRich) {
throw new RuntimeException("Tree Rule is null!");
}
// 决策节点
TreeNodeVO treeNodeInfo = engineDecisionMaker(treeRuleRich, matter);
// 决策结果
return new EngineResult(matter.getUserId(), treeNodeInfo.getTreeId(), treeNodeInfo.getTreeNodeId(), treeNodeInfo.getNodeValue());
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/rule/service/engine/impl/RuleEngineHandle.java
|
Java
|
apache-2.0
| 1,533
|
package cn.itedus.lottery.domain.rule.service.logic;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.domain.rule.model.req.DecisionMatterReq;
import cn.itedus.lottery.domain.rule.model.vo.TreeNodeLineVO;
import java.util.List;
/**
* @description: 规则基础抽象类
* @author: 小傅哥，微信：fustack
* @date: 2021/10/8
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public abstract class BaseLogic implements LogicFilter {
@Override
public Long filter(String matterValue, List<TreeNodeLineVO> treeNodeLineInfoList) {
for (TreeNodeLineVO nodeLine : treeNodeLineInfoList) {
if (decisionLogic(matterValue, nodeLine)) {
return nodeLine.getNodeIdTo();
}
}
return Constants.Global.TREE_NULL_NODE;
}
/**
* 获取规则比对值
* @param decisionMatter 决策物料
* @return 比对值
*/
@Override
public abstract String matterValue(DecisionMatterReq decisionMatter);
private boolean decisionLogic(String matterValue, TreeNodeLineVO nodeLine) {
switch (nodeLine.getRuleLimitType()) {
case Constants.RuleLimitType.EQUAL:
return matterValue.equals(nodeLine.getRuleLimitValue());
case Constants.RuleLimitType.GT:
return Double.parseDouble(matterValue) > Double.parseDouble(nodeLine.getRuleLimitValue());
case Constants.RuleLimitType.LT:
return Double.parseDouble(matterValue) < Double.parseDouble(nodeLine.getRuleLimitValue());
case Constants.RuleLimitType.GE:
return Double.parseDouble(matterValue) >= Double.parseDouble(nodeLine.getRuleLimitValue());
case Constants.RuleLimitType.LE:
return Double.parseDouble(matterValue) <= Double.parseDouble(nodeLine.getRuleLimitValue());
default:
return false;
}
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/rule/service/logic/BaseLogic.java
|
Java
|
apache-2.0
| 2,080
|
package cn.itedus.lottery.domain.rule.service.logic;
import cn.itedus.lottery.domain.rule.model.req.DecisionMatterReq;
import cn.itedus.lottery.domain.rule.model.vo.TreeNodeLineVO;
import java.util.List;
/**
* @description: 规则过滤器接口
* @author: 小傅哥，微信：fustack
* @date: 2021/10/8
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public interface LogicFilter {
/**
* 逻辑决策器
* @param matterValue 决策值
* @param treeNodeLineInfoList 决策节点
* @return 下一个节点Id
*/
Long filter(String matterValue, List<TreeNodeLineVO> treeNodeLineInfoList);
/**
* 获取决策值
*
* @param decisionMatter 决策物料
* @return 决策值
*/
String matterValue(DecisionMatterReq decisionMatter);
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/rule/service/logic/LogicFilter.java
|
Java
|
apache-2.0
| 989
|
package cn.itedus.lottery.domain.rule.service.logic.impl;
import cn.itedus.lottery.domain.rule.model.req.DecisionMatterReq;
import cn.itedus.lottery.domain.rule.service.logic.BaseLogic;
import org.springframework.stereotype.Component;
/**
* @description: 年龄规则
* @author: 小傅哥，微信：fustack
* @date: 2021/10/8
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Component
public class UserAgeFilter extends BaseLogic {
@Override
public String matterValue(DecisionMatterReq decisionMatter) {
return decisionMatter.getValMap().get("age").toString();
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/rule/service/logic/impl/UserAgeFilter.java
|
Java
|
apache-2.0
| 736
|
package cn.itedus.lottery.domain.rule.service.logic.impl;
import cn.itedus.lottery.domain.rule.model.req.DecisionMatterReq;
import cn.itedus.lottery.domain.rule.service.logic.BaseLogic;
import org.springframework.stereotype.Component;
/**
* @description: 性别规则
* @author: 小傅哥，微信：fustack
* @date: 2021/10/8
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Component
public class UserGenderFilter extends BaseLogic {
@Override
public String matterValue(DecisionMatterReq decisionMatter) {
return decisionMatter.getValMap().get("gender").toString();
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/rule/service/logic/impl/UserGenderFilter.java
|
Java
|
apache-2.0
| 746
|
package cn.itedus.lottery.domain.strategy.annotation;
import cn.itedus.lottery.common.Constants;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @description: 抽奖策略模型注解
* @author: 小傅哥，微信：fustack
* @date: 2022/1/11
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Strategy {
Constants.StrategyMode strategyMode();
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/strategy/annotation/Strategy.java
|
Java
|
apache-2.0
| 699
|
package cn.itedus.lottery.domain.strategy.model.aggregates;
import cn.itedus.lottery.domain.strategy.model.vo.StrategyBriefVO;
import cn.itedus.lottery.domain.strategy.model.vo.StrategyDetailBriefVO;
import java.util.List;
/**
* @description: 抽奖策略聚合对象
* @author: 小傅哥，微信：fustack
* @date: 2021/9/4
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class StrategyRich {
/**
* 策略ID
*/
private Long strategyId;
/**
* 策略配置
*/
private StrategyBriefVO strategy;
/**
* 策略明细
*/
private List<StrategyDetailBriefVO> strategyDetailList;
public StrategyRich() {
}
public StrategyRich(Long strategyId, StrategyBriefVO strategy, List<StrategyDetailBriefVO> strategyDetailList) {
this.strategyId = strategyId;
this.strategy = strategy;
this.strategyDetailList = strategyDetailList;
}
public Long getStrategyId() {
return strategyId;
}
public void setStrategyId(Long strategyId) {
this.strategyId = strategyId;
}
public StrategyBriefVO getStrategy() {
return strategy;
}
public void setStrategy(StrategyBriefVO strategy) {
this.strategy = strategy;
}
public List<StrategyDetailBriefVO> getStrategyDetailList() {
return strategyDetailList;
}
public void setStrategyDetailList(List<StrategyDetailBriefVO> strategyDetailList) {
this.strategyDetailList = strategyDetailList;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/strategy/model/aggregates/StrategyRich.java
|
Java
|
apache-2.0
| 1,663
|
package cn.itedus.lottery.domain.strategy.model.req;
/**
* @description: 抽奖请求对象
* @author: 小傅哥，微信：fustack
* @date: 2021/9/4
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class DrawReq {
/**
* 用户ID
*/
private String uId;
/**
* 策略ID
*/
private Long strategyId;
/**
* 防重ID
*/
private String uuid;
public DrawReq() {
}
public DrawReq(String uId, Long strategyId) {
this.uId = uId;
this.strategyId = strategyId;
}
public DrawReq(String uId, Long strategyId, String uuid) {
this.uId = uId;
this.strategyId = strategyId;
this.uuid = uuid;
}
public String getuId() {
return uId;
}
public void setuId(String uId) {
this.uId = uId;
}
public Long getStrategyId() {
return strategyId;
}
public void setStrategyId(Long strategyId) {
this.strategyId = strategyId;
}
public String getUuid() {
return uuid;
}
public void setUuid(String uuid) {
this.uuid = uuid;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/strategy/model/req/DrawReq.java
|
Java
|
apache-2.0
| 1,271
|
package cn.itedus.lottery.domain.strategy.model.res;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.domain.strategy.model.vo.DrawAwardVO;
/**
* @description: 抽奖结果
* @author：小傅哥，微信：fustack
* @date: 2021/8/28
* @Copyright：公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class DrawResult {
/**
* 用户ID
*/
private String uId;
/**
* 策略ID
*/
private Long strategyId;
/**
* 中奖状态：0未中奖、1已中奖、2兜底奖 Constants.DrawState
*/
private Integer drawState = Constants.DrawState.FAIL.getCode();
/**
* 中奖奖品信息
*/
private DrawAwardVO drawAwardInfo;
public DrawResult() {
}
public DrawResult(String uId, Long strategyId, Integer drawState) {
this.uId = uId;
this.strategyId = strategyId;
this.drawState = drawState;
}
public DrawResult(String uId, Long strategyId, Integer drawState, DrawAwardVO drawAwardInfo) {
this.uId = uId;
this.strategyId = strategyId;
this.drawState = drawState;
this.drawAwardInfo = drawAwardInfo;
}
public String getuId() {
return uId;
}
public void setuId(String uId) {
this.uId = uId;
}
public Long getStrategyId() {
return strategyId;
}
public void setStrategyId(Long strategyId) {
this.strategyId = strategyId;
}
public Integer getDrawState() {
return drawState;
}
public void setDrawState(Integer drawState) {
this.drawState = drawState;
}
public DrawAwardVO getDrawAwardInfo() {
return drawAwardInfo;
}
public void setDrawAwardInfo(DrawAwardVO drawAwardInfo) {
this.drawAwardInfo = drawAwardInfo;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/strategy/model/res/DrawResult.java
|
Java
|
apache-2.0
| 1,901
|
package cn.itedus.lottery.domain.strategy.model.vo;
/**
* @description: 奖品简要信息
* @author: 小傅哥，微信：fustack
* @date: 2021/9/11
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class AwardBriefVO {
/** 奖品ID */
private String awardId;
/** 奖品类型（1:文字描述、2:兑换码、3:优惠券、4:实物奖品） */
private Integer awardType;
/** 奖品名称 */
private String awardName;
/** 奖品内容「描述、奖品码、sku」 */
private String awardContent;
public String getAwardId() {
return awardId;
}
public void setAwardId(String awardId) {
this.awardId = awardId;
}
public Integer getAwardType() {
return awardType;
}
public void setAwardType(Integer awardType) {
this.awardType = awardType;
}
public String getAwardName() {
return awardName;
}
public void setAwardName(String awardName) {
this.awardName = awardName;
}
public String getAwardContent() {
return awardContent;
}
public void setAwardContent(String awardContent) {
this.awardContent = awardContent;
}
@Override
public String toString() {
return "AwardBriefVO{" +
"awardId='" + awardId + '\'' +
", awardType=" + awardType +
", awardName='" + awardName + '\'' +
", awardContent='" + awardContent + '\'' +
'}';
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/strategy/model/vo/AwardBriefVO.java
|
Java
|
apache-2.0
| 1,647
|
package cn.itedus.lottery.domain.strategy.model.vo;
import java.math.BigDecimal;
/**
* @description: 奖品概率信息，奖品编号、库存、概率
* @author: 小傅哥，微信：fustack
* @date: 2021/9/4
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class AwardRateVO {
/**
* 奖品ID
*/
private String awardId;
/**
* 中奖概率
*/
private BigDecimal awardRate;
public AwardRateVO() {
}
public AwardRateVO(String awardId, BigDecimal awardRate) {
this.awardId = awardId;
this.awardRate = awardRate;
}
public String getAwardId() {
return awardId;
}
public void setAwardId(String awardId) {
this.awardId = awardId;
}
public BigDecimal getAwardRate() {
return awardRate;
}
public void setAwardRate(BigDecimal awardRate) {
this.awardRate = awardRate;
}
@Override
public String toString() {
return "AwardRateVO{" +
"awardId='" + awardId + '\'' +
", awardRate=" + awardRate +
'}';
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/strategy/model/vo/AwardRateVO.java
|
Java
|
apache-2.0
| 1,253
|
package cn.itedus.lottery.domain.strategy.model.vo;
import java.util.Date;
/**
* @description: 中奖奖品信息
* @author：小傅哥，微信：fustack
* @date: 2021/8/28
* @Copyright： 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class DrawAwardVO {
/**
* 用户ID
*/
private String uId;
/**
* 奖品ID
*/
private String awardId;
/**
* 奖品类型（1:文字描述、2:兑换码、3:优惠券、4:实物奖品）
*/
private Integer awardType;
/**
* 奖品名称
*/
private String awardName;
/**
* 奖品内容「描述、奖品码、sku」
*/
private String awardContent;
/**
* 策略方式（1:单项概率、2:总体概率）
*/
private Integer strategyMode;
/**
* 发放奖品方式（1:即时、2:定时[含活动结束]、3:人工）
*/
private Integer grantType;
/**
* 发奖时间
*/
private Date grantDate;
public DrawAwardVO() {
}
public DrawAwardVO(String uId, String awardId, Integer awardType, String awardName, String awardContent) {
this.uId = uId;
this.awardId = awardId;
this.awardType = awardType;
this.awardName = awardName;
this.awardContent = awardContent;
}
public String getuId() {
return uId;
}
public void setuId(String uId) {
this.uId = uId;
}
public DrawAwardVO(String uId) {
this.uId = uId;
}
public String getAwardId() {
return awardId;
}
public void setAwardId(String awardId) {
this.awardId = awardId;
}
public Integer getAwardType() {
return awardType;
}
public void setAwardType(Integer awardType) {
this.awardType = awardType;
}
public String getAwardName() {
return awardName;
}
public void setAwardName(String awardName) {
this.awardName = awardName;
}
public String getAwardContent() {
return awardContent;
}
public void setAwardContent(String awardContent) {
this.awardContent = awardContent;
}
public Integer getStrategyMode() {
return strategyMode;
}
public void setStrategyMode(Integer strategyMode) {
this.strategyMode = strategyMode;
}
public Integer getGrantType() {
return grantType;
}
public void setGrantType(Integer grantType) {
this.grantType = grantType;
}
public Date getGrantDate() {
return grantDate;
}
public void setGrantDate(Date grantDate) {
this.grantDate = grantDate;
}
@Override
public String toString() {
return "DrawAwardVO{" +
"awardId='" + awardId + '\'' +
", awardType=" + awardType +
", awardName='" + awardName + '\'' +
", awardContent='" + awardContent + '\'' +
", strategyMode=" + strategyMode +
", grantType=" + grantType +
", grantDate=" + grantDate +
'}';
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/strategy/model/vo/DrawAwardVO.java
|
Java
|
apache-2.0
| 3,186
|
package cn.itedus.lottery.domain.strategy.model.vo;
import java.util.Date;
/**
* @description: 策略简要信息
* @author: 小傅哥，微信：fustack
* @date: 2021/9/11
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class StrategyBriefVO {
/**
* 策略ID
*/
private Long strategyId;
/**
* 策略描述
*/
private String strategyDesc;
/**
* 策略方式「1:单项概率、2:总体概率」
*/
private Integer strategyMode;
/**
* 发放奖品方式「1:即时、2:定时[含活动结束]、3:人工」
*/
private Integer grantType;
/**
* 发放奖品时间
*/
private Date grantDate;
/**
* 扩展信息
*/
private String extInfo;
public Long getStrategyId() {
return strategyId;
}
public void setStrategyId(Long strategyId) {
this.strategyId = strategyId;
}
public String getStrategyDesc() {
return strategyDesc;
}
public void setStrategyDesc(String strategyDesc) {
this.strategyDesc = strategyDesc;
}
public Integer getStrategyMode() {
return strategyMode;
}
public void setStrategyMode(Integer strategyMode) {
this.strategyMode = strategyMode;
}
public Integer getGrantType() {
return grantType;
}
public void setGrantType(Integer grantType) {
this.grantType = grantType;
}
public Date getGrantDate() {
return grantDate;
}
public void setGrantDate(Date grantDate) {
this.grantDate = grantDate;
}
public String getExtInfo() {
return extInfo;
}
public void setExtInfo(String extInfo) {
this.extInfo = extInfo;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/strategy/model/vo/StrategyBriefVO.java
|
Java
|
apache-2.0
| 1,891
|
package cn.itedus.lottery.domain.strategy.model.vo;
import java.math.BigDecimal;
/**
* @description: 策略明细简要信息
* @author: 小傅哥，微信：fustack
* @date: 2021/9/11
* @github: https://github.com/fuzhengwei
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class StrategyDetailBriefVO {
/**
* 策略ID
*/
private Long strategyId;
/**
* 奖品ID
*/
private String awardId;
/**
* 奖品名称
*/
private String awardName;
/**
* 奖品库存
*/
private Integer awardCount;
/**
* 奖品剩余库存
*/
private Integer awardSurplusCount;
/**
* 中奖概率
*/
private BigDecimal awardRate;
public Long getStrategyId() {
return strategyId;
}
public void setStrategyId(Long strategyId) {
this.strategyId = strategyId;
}
public String getAwardId() {
return awardId;
}
public void setAwardId(String awardId) {
this.awardId = awardId;
}
public String getAwardName() {
return awardName;
}
public void setAwardName(String awardName) {
this.awardName = awardName;
}
public Integer getAwardCount() {
return awardCount;
}
public void setAwardCount(Integer awardCount) {
this.awardCount = awardCount;
}
public Integer getAwardSurplusCount() {
return awardSurplusCount;
}
public void setAwardSurplusCount(Integer awardSurplusCount) {
this.awardSurplusCount = awardSurplusCount;
}
public BigDecimal getAwardRate() {
return awardRate;
}
public void setAwardRate(BigDecimal awardRate) {
this.awardRate = awardRate;
}
@Override
public String toString() {
return "StrategyDetailBriefVO{" +
"strategyId=" + strategyId +
", awardId='" + awardId + '\'' +
", awardName='" + awardName + '\'' +
", awardCount=" + awardCount +
", awardSurplusCount=" + awardSurplusCount +
", awardRate=" + awardRate +
'}';
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/strategy/model/vo/StrategyDetailBriefVO.java
|
Java
|
apache-2.0
| 2,264
|
package cn.itedus.lottery.domain.strategy.repository;
import cn.itedus.lottery.domain.strategy.model.aggregates.StrategyRich;
import cn.itedus.lottery.domain.strategy.model.vo.AwardBriefVO;
import java.util.List;
/**
* @description: 策略表仓储服务
* @author：小傅哥，微信：fustack
* @date: 2021/8/28
* @Copyright：公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public interface IStrategyRepository {
/**
* 查询策略信息
*
* @param strategyId 策略ID
* @return 策略信息
*/
StrategyRich queryStrategyRich(Long strategyId);
/**
* 查询奖励配置
*
* @param awardId 奖励ID
* @return 奖励信息
*/
AwardBriefVO queryAwardInfo(String awardId);
/**
* 查询无库存奖品
*
* @param strategyId 策略ID
* @return 无库存奖品
*/
List<String> queryNoStockStrategyAwardList(Long strategyId);
/**
* 扣减库存
* @param strategyId 策略ID
* @param awardId 奖品ID
* @return 扣减结果
*/
boolean deductStock(Long strategyId, String awardId);
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/strategy/repository/IStrategyRepository.java
|
Java
|
apache-2.0
| 1,251
|
package cn.itedus.lottery.domain.strategy.service.algorithm;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.domain.strategy.model.vo.AwardRateVO;
import java.math.BigDecimal;
import java.security.SecureRandom;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* @description: 共用的算法逻辑抽象类
* @author：小傅哥，微信：fustack
* @date: 2021/8/28
* @Copyright：公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public abstract class BaseAlgorithm implements IDrawAlgorithm {
/**
* 斐波那契散列增量，逻辑：黄金分割点：(√5 - 1) / 2 = 0.6180339887，Math.pow(2, 32) * 0.6180339887 = 0x61c88647
*/
private final int HASH_INCREMENT = 0x61c88647;
/**
* 数组初始化长度 128，保证数据填充时不发生碰撞的最小初始化值
*/
private final int RATE_TUPLE_LENGTH = 128;
/**
* 存放概率与奖品对应的散列结果，strategyId -> rateTuple
*/
protected Map<Long, String[]> rateTupleMap = new ConcurrentHashMap<>();
/**
* 奖品区间概率值，strategyId -> [awardId->begin、awardId->end]
*/
protected Map<Long, List<AwardRateVO>> awardRateInfoMap = new ConcurrentHashMap<>();
@Override
public synchronized void initRateTuple(Long strategyId, Integer strategyMode, List<AwardRateVO> awardRateInfoList) {
// 前置判断
if (isExist(strategyId)){
return;
}
// 保存奖品概率信息
awardRateInfoMap.put(strategyId, awardRateInfoList);
// 非单项概率，不必存入缓存，因为这部分抽奖算法需要实时处理中奖概率。
if (!Constants.StrategyMode.SINGLE.getCode().equals(strategyMode)) {
return;
}
String[] rateTuple = rateTupleMap.computeIfAbsent(strategyId, k -> new String[RATE_TUPLE_LENGTH]);
int cursorVal = 0;
for (AwardRateVO awardRateInfo : awardRateInfoList) {
int rateVal = awardRateInfo.getAwardRate().multiply(new BigDecimal(100)).intValue();
// 循环填充概率范围值
for (int i = cursorVal + 1; i <= (rateVal + cursorVal); i++) {
rateTuple[hashIdx(i)] = awardRateInfo.getAwardId();
}
cursorVal += rateVal;
}
}
@Override
public boolean isExist(Long strategyId) {
return awardRateInfoMap.containsKey(strategyId);
}
/**
* 斐波那契（Fibonacci）散列法，计算哈希索引下标值
*
* @param val 值
* @return 索引
*/
protected int hashIdx(int val) {
int hashCode = val * HASH_INCREMENT + HASH_INCREMENT;
return hashCode & (RATE_TUPLE_LENGTH - 1);
}
/**
* 生成百位随机抽奖码
*
* @return 随机值
*/
protected int generateSecureRandomIntCode(int bound) {
return new SecureRandom().nextInt(bound) + 1;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/strategy/service/algorithm/BaseAlgorithm.java
|
Java
|
apache-2.0
| 3,086
|
package cn.itedus.lottery.domain.strategy.service.algorithm;
import cn.itedus.lottery.domain.strategy.model.vo.AwardRateVO;
import java.util.List;
/**
* @description: 抽奖算法接口
* @author：小傅哥，微信：fustack
* @date: 2021/8/28
* @Copyright：公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public interface IDrawAlgorithm {
/**
* 程序启动时初始化概率元祖，在初始化完成后使用过程中不允许修改元祖数据
* <p>
* 元祖数据作用在于讲百分比内(0.2、0.3、0.5)的数据，转换为一整条数组上分区数据，如下；
* 0.2 = 0 ~ 0.2
* 0.3 = 0 + 0.2 ~ 0.2 + 0.3 = 0.2 ~ 0.5
* 0.5 = 0.5 ~ 1 （计算方式同上）
* <p>
* 通过数据拆分为整条后，再根据0-100中各个区间的奖品信息，使用斐波那契散列计算出索引位置，把奖品数据存放到元祖中。比如：
* <p>
* 1. 把 0.2 转换为 20
* 2. 20 对应的斐波那契值哈希值：（20 * HASH_INCREMENT + HASH_INCREMENT）= -1549107828 HASH_INCREMENT = 0x61c88647
* 3. 再通过哈希值计算索引位置：hashCode & (rateTuple.length - 1) = 12
* 4. 那么tup[14] = 0.2 中奖概率对应的奖品
* 5. 当后续通过随机数获取到1-100的值后，可以直接定位到对应的奖品信息，通过这样的方式把轮训算奖的时间复杂度从O(n) 降低到 0(1)
*
* @param strategyId 策略ID
* @param strategyMode 抽奖策略模式
* @param awardRateInfoList 奖品概率配置集合 「值示例：AwardRateInfo.awardRate = 0.04」
*/
void initRateTuple(Long strategyId,Integer strategyMode, List<AwardRateVO> awardRateInfoList);
/**
* 判断是否已经，做了数据初始化
* @param strategyId 策略ID
* @return 判断结果
*/
boolean isExist(Long strategyId);
/**
* SecureRandom 生成随机数，索引到对应的奖品信息返回结果
*
* @param strategyId 策略ID
* @param excludeAwardIds 排除掉已经不能作为抽奖的奖品ID，留给风控和空库存使用
* @return 中奖结果
*/
String randomDraw(Long strategyId, List<String> excludeAwardIds);
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/strategy/service/algorithm/IDrawAlgorithm.java
|
Java
|
apache-2.0
| 2,370
|
package cn.itedus.lottery.domain.strategy.service.algorithm.impl;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.domain.strategy.annotation.Strategy;
import cn.itedus.lottery.domain.strategy.model.vo.AwardRateVO;
import cn.itedus.lottery.domain.strategy.service.algorithm.BaseAlgorithm;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
/**
* @description: 必中奖策略抽奖，排掉已经中奖的概率，重新计算中奖范围
* @author：小傅哥，微信：fustack
* @date: 2021/8/28
* @Copyright：公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Component("entiretyRateRandomDrawAlgorithm")
@Strategy(strategyMode = Constants.StrategyMode.ENTIRETY)
public class EntiretyRateRandomDrawAlgorithm extends BaseAlgorithm {
@Override
public String randomDraw(Long strategyId, List<String> excludeAwardIds) {
BigDecimal differenceDenominator = BigDecimal.ZERO;
// 排除掉不在抽奖范围的奖品ID集合
List<AwardRateVO> differenceAwardRateList = new ArrayList<>();
List<AwardRateVO> awardRateIntervalValList = awardRateInfoMap.get(strategyId);
for (AwardRateVO awardRateInfo : awardRateIntervalValList) {
String awardId = awardRateInfo.getAwardId();
if (excludeAwardIds.contains(awardId)) {
continue;
}
differenceAwardRateList.add(awardRateInfo);
differenceDenominator = differenceDenominator.add(awardRateInfo.getAwardRate());
}
// 前置判断：奖品列表为0，返回NULL
if (differenceAwardRateList.size() == 0) {
return null;
}
// 前置判断：奖品列表为1，直接返回
if (differenceAwardRateList.size() == 1) {
return differenceAwardRateList.get(0).getAwardId();
}
// 获取随机概率值
int randomVal = this.generateSecureRandomIntCode(100);
// 循环获取奖品
String awardId = null;
int cursorVal = 0;
for (AwardRateVO awardRateInfo : differenceAwardRateList) {
int rateVal = awardRateInfo.getAwardRate().divide(differenceDenominator, 2, BigDecimal.ROUND_UP).multiply(new BigDecimal(100)).intValue();
if (randomVal <= (cursorVal + rateVal)) {
awardId = awardRateInfo.getAwardId();
break;
}
cursorVal += rateVal;
}
// 返回中奖结果
return awardId;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/strategy/service/algorithm/impl/EntiretyRateRandomDrawAlgorithm.java
|
Java
|
apache-2.0
| 2,657
|
package cn.itedus.lottery.domain.strategy.service.algorithm.impl;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.domain.strategy.annotation.Strategy;
import cn.itedus.lottery.domain.strategy.service.algorithm.BaseAlgorithm;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* @description: 单项随机概率抽奖，抽到一个已经排掉的奖品则未中奖
* @author：小傅哥，微信：fustack
* @date: 2021/8/28
* @Copyright：公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
@Component("singleRateRandomDrawAlgorithm")
@Strategy(strategyMode = Constants.StrategyMode.SINGLE)
public class SingleRateRandomDrawAlgorithm extends BaseAlgorithm {
@Override
public String randomDraw(Long strategyId, List<String> excludeAwardIds) {
// 获取策略对应的元祖
String[] rateTuple = super.rateTupleMap.get(strategyId);
assert rateTuple != null;
// 随机索引
int randomVal = this.generateSecureRandomIntCode(100);
int idx = super.hashIdx(randomVal);
// 返回结果
String awardId = rateTuple[idx];
// 如果中奖ID命中排除奖品列表，则返回NULL
if (excludeAwardIds.contains(awardId)) {
return null;
}
return awardId;
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/strategy/service/algorithm/impl/SingleRateRandomDrawAlgorithm.java
|
Java
|
apache-2.0
| 1,408
|
package cn.itedus.lottery.domain.strategy.service.draw;
import cn.itedus.lottery.common.Constants;
import cn.itedus.lottery.domain.strategy.model.aggregates.StrategyRich;
import cn.itedus.lottery.domain.strategy.model.req.DrawReq;
import cn.itedus.lottery.domain.strategy.model.res.DrawResult;
import cn.itedus.lottery.domain.strategy.model.vo.*;
import cn.itedus.lottery.domain.strategy.service.algorithm.IDrawAlgorithm;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
/**
* @description: 定义抽象抽奖过程，模板模式
* @author：小傅哥，微信：fustack
* @date: 2021/8/28
* @Copyright：公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public abstract class AbstractDrawBase extends DrawStrategySupport implements IDrawExec {
private Logger logger = LoggerFactory.getLogger(AbstractDrawBase.class);
@Override
public DrawResult doDrawExec(DrawReq req) {
// 1. 获取抽奖策略
StrategyRich strategyRich = super.queryStrategyRich(req.getStrategyId());
StrategyBriefVO strategy = strategyRich.getStrategy();
// 2. 校验抽奖策略是否已经初始化到内存
this.checkAndInitRateData(req.getStrategyId(), strategy.getStrategyMode(), strategyRich.getStrategyDetailList());
// 3. 获取不在抽奖范围内的列表，包括：奖品库存为空、风控策略、临时调整等
List<String> excludeAwardIds = this.queryExcludeAwardIds(req.getStrategyId());
// 4. 执行抽奖算法
String awardId = this.drawAlgorithm(req.getStrategyId(), drawAlgorithmGroup.get(strategy.getStrategyMode()), excludeAwardIds);
// 5. 包装中奖结果
return buildDrawResult(req.getuId(), req.getStrategyId(), awardId, strategy);
}
/**
* 获取不在抽奖范围内的列表，包括：奖品库存为空、风控策略、临时调整等，这类数据是含有业务逻辑的，所以需要由具体的实现方决定
*
* @param strategyId 策略ID
* @return 排除的奖品ID集合
*/
protected abstract List<String> queryExcludeAwardIds(Long strategyId);
/**
* 执行抽奖算法
*
* @param strategyId 策略ID
* @param drawAlgorithm 抽奖算法模型
* @param excludeAwardIds 排除的抽奖ID集合
* @return 中奖奖品ID
*/
protected abstract String drawAlgorithm(Long strategyId, IDrawAlgorithm drawAlgorithm, List<String> excludeAwardIds);
/**
* 校验抽奖策略是否已经初始化到内存
*
* @param strategyId 抽奖策略ID
* @param strategyMode 抽奖策略模式
* @param strategyDetailList 抽奖策略详情
*/
private void checkAndInitRateData(Long strategyId, Integer strategyMode, List<StrategyDetailBriefVO> strategyDetailList) {
// 根据抽奖策略模式，获取对应的抽奖服务
IDrawAlgorithm drawAlgorithm = drawAlgorithmGroup.get(strategyMode);
// 判断已处理过的的数据
if (drawAlgorithm.isExist(strategyId)) {
return;
}
// 解析并初始化中奖概率数据到散列表
List<AwardRateVO> awardRateInfoList = new ArrayList<>(strategyDetailList.size());
for (StrategyDetailBriefVO strategyDetail : strategyDetailList) {
awardRateInfoList.add(new AwardRateVO(strategyDetail.getAwardId(), strategyDetail.getAwardRate()));
}
drawAlgorithm.initRateTuple(strategyId, strategyMode, awardRateInfoList);
}
/**
* 包装抽奖结果
*
* @param uId 用户ID
* @param strategyId 策略ID
* @param awardId 奖品ID，null 情况：并发抽奖情况下，库存临界值1 -> 0，会有用户中奖结果为 null
* @return 中奖结果
*/
private DrawResult buildDrawResult(String uId, Long strategyId, String awardId, StrategyBriefVO strategy) {
if (null == awardId) {
logger.info("执行策略抽奖完成【未中奖】，用户：{} 策略ID：{}", uId, strategyId);
return new DrawResult(uId, strategyId, Constants.DrawState.FAIL.getCode());
}
AwardBriefVO award = super.queryAwardInfoByAwardId(awardId);
DrawAwardVO drawAwardInfo = new DrawAwardVO(uId, award.getAwardId(), award.getAwardType(), award.getAwardName(), award.getAwardContent());
drawAwardInfo.setStrategyMode(strategy.getStrategyMode());
drawAwardInfo.setGrantType(strategy.getGrantType());
drawAwardInfo.setGrantDate(strategy.getGrantDate());
logger.info("执行策略抽奖完成【已中奖】，用户：{} 策略ID：{} 奖品ID：{} 奖品名称：{}", uId, strategyId, awardId, award.getAwardName());
return new DrawResult(uId, strategyId, Constants.DrawState.SUCCESS.getCode(), drawAwardInfo);
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/strategy/service/draw/AbstractDrawBase.java
|
Java
|
apache-2.0
| 4,985
|
package cn.itedus.lottery.domain.strategy.service.draw;
import cn.itedus.lottery.domain.strategy.annotation.Strategy;
import cn.itedus.lottery.domain.strategy.service.algorithm.IDrawAlgorithm;
import org.springframework.core.annotation.AnnotationUtils;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* @description: 抽奖统一配置信息类
* @author: 小傅哥，微信：fustack
* @date: 2021/8/28
* @Copyright: 公众号：bugstack虫洞栈 | 博客：https://bugstack.cn - 沉淀、分享、成长，让自己和他人都能有所收获！
*/
public class DrawConfig {
@Resource
private List<IDrawAlgorithm> algorithmList;
/**
* 抽奖策略组
*/
protected static Map<Integer, IDrawAlgorithm> drawAlgorithmGroup = new ConcurrentHashMap<>();
@PostConstruct
public void init() {
algorithmList.forEach(algorithm -> {
Strategy strategy = AnnotationUtils.findAnnotation(algorithm.getClass(), Strategy.class);
if (null != strategy) {
drawAlgorithmGroup.put(strategy.strategyMode().getCode(), algorithm);
}
});
}
}
|
2302_77879529/lottery
|
lottery-domain/src/main/java/cn/itedus/lottery/domain/strategy/service/draw/DrawConfig.java
|
Java
|
apache-2.0
| 1,284
|