lottery-application/src/main/java/cn/happy/lottery/application/mq/consumer/LotteryActivityPartakeRecordListener.java

+package cn.happy.lottery.application.mq.consumer;
+
+import cn.happy.lottery.domain.activity.model.vo.ActivityPartakeRecordVO;
+import cn.happy.lottery.domain.activity.service.partake.IActivityPartake;
+import com.alibaba.fastjson.JSON;
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+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;
+
+/**
+ * @author: happy
+ * @date: 2022/4/6
+ * @description: 抽奖活动领取记录监听消息
+ */
+@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());
+        
+        // 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);
+    }
+
+
+}

lottery-application/src/main/java/cn/happy/lottery/application/mq/producer/KafkaProducer.java

 package cn.happy.lottery.application.mq.producer;
 
+import cn.happy.lottery.domain.activity.model.vo.ActivityPartakeRecordVO;
 import cn.happy.lottery.domain.activity.model.vo.InvoiceVO;
 import com.alibaba.fastjson.JSON;
 import org.slf4j.Logger;
@@ -33,6 +34,14 @@ public class KafkaProducer {
      */
     public static final String TOPIC_INVOICE = "lottery_invoice";
 
+    /**
+     * MQ主题：活动领取记录
+     *
+     * 创建topic：bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic lottery_activity_partake
+     */
+    public static final String TOPIC_ACTIVITY_PARTAKE = "lottery_activity_partake";
+
+
     /**
      * 发送中奖物品发货单消息
      *
@@ -40,9 +49,19 @@ public class KafkaProducer {
      */
     public ListenableFuture<SendResult<String, Object>> sendLotteryInvoice(InvoiceVO invoice) {
         String objJson = JSON.toJSONString(invoice);
-        logger.info("发送MQ消息 topic：{} bizId：{} message：{}", TOPIC_INVOICE, invoice.getuId(), objJson);
+        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);
+    }
 
 }

lottery-application/src/main/java/cn/happy/lottery/application/process/deploy/IActivityDeployProcess.java

 package cn.happy.lottery.application.process.deploy;
 
+import cn.happy.lottery.common.Result;
 import cn.happy.lottery.domain.activity.model.aggregates.ActivityConfigRich;
 import cn.happy.lottery.domain.activity.model.aggregates.ActivityInfoLimitPageRich;
 import cn.happy.lottery.domain.activity.model.req.ActivityInfoLimitPageReq;
@@ -39,11 +40,13 @@ public interface IActivityDeployProcess {
      * 删除活动
      * @param activityReq
      */
-    void deleteActivity(ActivityReq activityReq);
+    Result deleteActivity(ActivityReq activityReq);
 
     /**
      * 修改活动
      * @param activityReq
      */
-    void updateActivity(ActivityReq activityReq);
+    Result updateActivity(ActivityReq activityReq);
+
+    Long queryUserLeftCount(String uId);
 }

lottery-application/src/main/java/cn/happy/lottery/application/process/deploy/IAwardDeployProcess.java

+package cn.happy.lottery.application.process.deploy;
+
+import cn.happy.lottery.domain.activity.model.aggregates.ActivityConfigRich;
+import cn.happy.lottery.domain.activity.model.aggregates.ActivityInfoLimitPageRich;
+import cn.happy.lottery.domain.activity.model.req.ActivityInfoLimitPageReq;
+import cn.happy.lottery.domain.activity.model.req.ActivityReq;
+import cn.happy.lottery.domain.award.model.aggregates.AwardInfoLimitPageRich;
+import cn.happy.lottery.domain.award.model.req.AwardInfoLimitPageReq;
+import cn.happy.lottery.domain.award.model.req.AwardReq;
+
+/**
+ * @author: happy
+ * @date: 2022/4/14
+ * @description:
+ */
+public interface IAwardDeployProcess {
+
+
+    AwardInfoLimitPageRich queryAwardInfoLimitPage(AwardInfoLimitPageReq awardInfoLimitPageReq);
+
+    void createAward(AwardReq awardReq);
+
+    void deleteAward(AwardReq awardReq);
+
+    void updateAward(AwardReq awardReq);
+}

lottery-application/src/main/java/cn/happy/lottery/application/process/deploy/IStrategyDeployProcess.java

+package cn.happy.lottery.application.process.deploy;
+
+import cn.happy.lottery.common.Result;
+import cn.happy.lottery.domain.activity.model.aggregates.ActivityInfoLimitPageRich;
+import cn.happy.lottery.domain.activity.model.req.ActivityInfoLimitPageReq;
+import cn.happy.lottery.domain.activity.model.req.ActivityReq;
+import cn.happy.lottery.domain.strategy.model.aggregates.StrategyInfoLimitPageRich;
+import cn.happy.lottery.domain.strategy.model.req.StrategyInfoLimitPageReq;
+import cn.happy.lottery.domain.strategy.model.req.StrategyReq;
+
+public interface IStrategyDeployProcess {
+
+    /**
+     * 查询策略分页查询聚合对象
+     *
+     * @param req 请求参数；分页、活动
+     * @return 查询结果
+     */
+    StrategyInfoLimitPageRich queryStrategyInfoLimitPage(StrategyInfoLimitPageReq req);
+
+
+    void createStrategy(StrategyReq strategyReq);
+
+    Result deleteStrategy(StrategyReq strategyReq);
+
+    void updateStrategy(StrategyReq strategyReq);
+}

lottery-application/src/main/java/cn/happy/lottery/application/process/deploy/IStrategyDetailDeployProcess.java

+package cn.happy.lottery.application.process.deploy;
+
+import cn.happy.lottery.common.Result;
+import cn.happy.lottery.domain.strategy.model.aggregates.StrategyDetailInfoLimitPageRich;
+import cn.happy.lottery.domain.strategy.model.aggregates.StrategyInfoLimitPageRich;
+import cn.happy.lottery.domain.strategy.model.req.StrategyDetailReq;
+import cn.happy.lottery.domain.strategy.model.req.StrategyInfoLimitPageReq;
+import cn.happy.lottery.domain.strategy.model.req.StrategyReq;
+
+public interface IStrategyDetailDeployProcess {
+
+    /**
+     * 查询策略详情分页查询聚合对象
+     *
+     * @param req 请求参数；分页、活动
+     * @return 查询结果
+     */
+    StrategyDetailInfoLimitPageRich queryStrategyDetailInfoLimitPage(StrategyInfoLimitPageReq req);
+
+    void createStrategyDetail(StrategyDetailReq strategyDetailReq);
+
+    Result deleteStrategyDetail(StrategyDetailReq strategyDetailReq);
+
+    void updateStrategyDetail(StrategyDetailReq strategyDetailReq);
+
+}

lottery-application/src/main/java/cn/happy/lottery/application/process/deploy/impl/ActivityDeployProcessImpl.java

 package cn.happy.lottery.application.process.deploy.impl;
 
 import cn.happy.lottery.application.process.deploy.IActivityDeployProcess;
+import cn.happy.lottery.common.Result;
 import cn.happy.lottery.domain.activity.model.aggregates.ActivityConfigRich;
 import cn.happy.lottery.domain.activity.model.aggregates.ActivityInfoLimitPageRich;
 import cn.happy.lottery.domain.activity.model.req.ActivityConfigReq;
@@ -45,16 +46,20 @@ public class ActivityDeployProcessImpl implements IActivityDeployProcess {
     }
 
     @Override
-    public void deleteActivity(ActivityReq activityReq) {
-        activityDeploy.deleteActivity(activityReq);
+    public Result deleteActivity(ActivityReq activityReq) {
+        return activityDeploy.deleteActivity(activityReq);
     }
 
     @Override
-    public void updateActivity(ActivityReq activityReq) {
+    public Result updateActivity(ActivityReq activityReq) {
         ActivityVO activityVO = new ActivityVO();
         BeanUtils.copyProperties(activityReq, activityVO);
-        activityDeploy.updateActivity(new ActivityConfigReq(activityVO));
+        return activityDeploy.updateActivity(new ActivityConfigReq(activityVO));
+    }
 
+    @Override
+    public Long queryUserLeftCount(String uId) {
+        return activityDeploy.queryUserLeftCount(uId);
     }
 
 }

lottery-application/src/main/java/cn/happy/lottery/application/process/deploy/impl/AwardDeployProcess.java

+package cn.happy.lottery.application.process.deploy.impl;
+
+import cn.happy.lottery.application.process.deploy.IAwardDeployProcess;
+import cn.happy.lottery.domain.award.model.aggregates.AwardInfoLimitPageRich;
+import cn.happy.lottery.domain.award.model.req.AwardInfoLimitPageReq;
+import cn.happy.lottery.domain.award.model.req.AwardReq;
+import cn.happy.lottery.domain.award.repository.IAwardRepository;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+
+@Service
+public class AwardDeployProcess implements IAwardDeployProcess {
+
+    @Resource
+    private IAwardRepository awardRepository;
+
+    @Override
+    public AwardInfoLimitPageRich queryAwardInfoLimitPage(AwardInfoLimitPageReq awardInfoLimitPageReq) {
+        return awardRepository.queryAwardInfoLimitPage(awardInfoLimitPageReq);
+    }
+
+    @Override
+    public void createAward(AwardReq awardReq) {
+        awardRepository.createAward(awardReq);
+    }
+
+    @Override
+    public void deleteAward(AwardReq awardReq) {
+        awardRepository.deleteAward(awardReq);
+    }
+
+    @Override
+    public void updateAward(AwardReq awardReq) {
+        awardRepository.updateAward(awardReq);
+    }
+}

lottery-application/src/main/java/cn/happy/lottery/application/process/deploy/impl/StrategyDeployProcessImpl.java

+package cn.happy.lottery.application.process.deploy.impl;
+
+import cn.happy.lottery.application.process.deploy.IActivityDeployProcess;
+import cn.happy.lottery.application.process.deploy.IStrategyDeployProcess;
+import cn.happy.lottery.common.Result;
+import cn.happy.lottery.domain.activity.model.aggregates.ActivityConfigRich;
+import cn.happy.lottery.domain.activity.model.aggregates.ActivityInfoLimitPageRich;
+import cn.happy.lottery.domain.activity.model.req.ActivityConfigReq;
+import cn.happy.lottery.domain.activity.model.req.ActivityInfoLimitPageReq;
+import cn.happy.lottery.domain.activity.model.req.ActivityReq;
+import cn.happy.lottery.domain.activity.model.vo.ActivityVO;
+import cn.happy.lottery.domain.activity.model.vo.StrategyVO;
+import cn.happy.lottery.domain.activity.service.deploy.IActivityDeploy;
+import cn.happy.lottery.domain.strategy.model.aggregates.StrategyInfoLimitPageRich;
+import cn.happy.lottery.domain.strategy.model.req.StrategyInfoLimitPageReq;
+import cn.happy.lottery.domain.strategy.model.req.StrategyReq;
+import cn.happy.lottery.domain.strategy.service.deploy.IStrategyDeploy;
+import org.springframework.beans.BeanUtils;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+
+/**
+ * @author: happy
+ * @date: 2022/4/14
+ * @description:
+ */
+@Service
+public class StrategyDeployProcessImpl implements IStrategyDeployProcess {
+
+    @Resource
+    private IStrategyDeploy strategyDeploy;
+
+    @Override
+    public StrategyInfoLimitPageRich queryStrategyInfoLimitPage(StrategyInfoLimitPageReq req) {
+        return strategyDeploy.queryStrategyInfoLimitPage(req);
+    }
+
+    @Override
+    public void createStrategy(StrategyReq strategyReq) {
+        strategyDeploy.createStrategy(strategyReq);
+    }
+
+    @Override
+    public Result deleteStrategy(StrategyReq strategyReq) {
+        return strategyDeploy.deleteStrategy(strategyReq);
+    }
+
+    @Override
+    public void updateStrategy(StrategyReq strategyReq) {
+        strategyDeploy.updateStrategy(strategyReq);
+    }
+}

lottery-application/src/main/java/cn/happy/lottery/application/process/deploy/impl/StrategyDetailDeployProcessImpl.java

+package cn.happy.lottery.application.process.deploy.impl;
+
+import cn.happy.lottery.application.process.deploy.IStrategyDeployProcess;
+import cn.happy.lottery.application.process.deploy.IStrategyDetailDeployProcess;
+import cn.happy.lottery.common.Result;
+import cn.happy.lottery.domain.strategy.model.aggregates.StrategyDetailInfoLimitPageRich;
+import cn.happy.lottery.domain.strategy.model.aggregates.StrategyInfoLimitPageRich;
+import cn.happy.lottery.domain.strategy.model.req.StrategyDetailReq;
+import cn.happy.lottery.domain.strategy.model.req.StrategyInfoLimitPageReq;
+import cn.happy.lottery.domain.strategy.model.req.StrategyReq;
+import cn.happy.lottery.domain.strategy.service.deploy.IStrategyDeploy;
+import cn.happy.lottery.domain.strategy.service.deploy.IStrategyDetailDeploy;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+
+/**
+ * @author: happy
+ * @date: 2022/4/14
+ * @description:
+ */
+@Service
+public class StrategyDetailDeployProcessImpl implements IStrategyDetailDeployProcess {
+
+    @Resource
+    private IStrategyDetailDeploy strategyDetailDeploy;
+
+    @Override
+    public StrategyDetailInfoLimitPageRich queryStrategyDetailInfoLimitPage(StrategyInfoLimitPageReq req) {
+        return strategyDetailDeploy.queryStrategyDetailInfoLimitPage(req);
+    }
+
+    @Override
+    public void createStrategyDetail(StrategyDetailReq strategyDetailReq) {
+        strategyDetailDeploy.createStrategyDetail(strategyDetailReq);
+    }
+
+    @Override
+    public Result deleteStrategyDetail(StrategyDetailReq strategyDetailReq) {
+        return strategyDetailDeploy.deleteStrategyDetail(strategyDetailReq);
+    }
+
+    @Override
+    public void updateStrategyDetail(StrategyDetailReq strategyDetailReq) {
+        strategyDetailDeploy.updateStrategyDetail(strategyDetailReq);
+    }
+}

lottery-application/src/main/java/cn/happy/lottery/application/process/draw/impl/ActivityProcessImpl.java

@@ -9,6 +9,7 @@ import cn.happy.lottery.common.Constants;
 import cn.happy.lottery.common.Result;
 import cn.happy.lottery.domain.activity.model.req.PartakeReq;
 import cn.happy.lottery.domain.activity.model.res.PartakeResult;
+import cn.happy.lottery.domain.activity.model.vo.ActivityPartakeRecordVO;
 import cn.happy.lottery.domain.activity.model.vo.DrawOrderVO;
 import cn.happy.lottery.domain.activity.model.vo.InvoiceVO;
 import cn.happy.lottery.domain.activity.service.partake.IActivityPartake;
@@ -60,44 +61,55 @@ public class ActivityProcessImpl implements IActivityDrawProcess {
 
         // 1. 领取活动
         PartakeResult partakeResult = activityPartake.doPartake(new PartakeReq(req.getuId(), req.getActivityId()));
-        if (!Constants.ResponseCode.SUCCESS.getCode().equals(partakeResult.getCode())) {
+        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();
 
-        // 2. 执行抽奖
+        // 3. 执行抽奖
         DrawResult drawResult = drawExec.doDrawExec(new DrawReq(req.getuId(), strategyId));
         if (Constants.DrawState.FAIL.getCode().equals(drawResult.getDrawState())) {
             return new DrawProcessResult(Constants.ResponseCode.LOSING_DRAW.getCode(), Constants.ResponseCode.LOSING_DRAW.getInfo());
         }
 
-        // 3. 结果落库
+        // 4. 结果落库
         DrawOrderVO drawOrderVO = buildDrawOrderVO(req, strategyId, takeId, drawResult.getDrawAwardInfo());
         Result recordResult = activityPartake.recordDrawOrder(drawOrderVO);
         if (!Constants.ResponseCode.SUCCESS.getCode().equals(recordResult.getCode())) {
             return new DrawProcessResult(recordResult.getCode(), recordResult.getInfo());
         }
 
-        // 4. 发送MQ，触发发奖流程
+        // 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> result) {
-                // 4.1 MQ 消息发送完成，更新数据库表 user_strategy_export.mq_state = 1
+                // 5.1 MQ 消息发送完成，更新数据库表 user_strategy_export.mq_state = 1
                 activityPartake.updateInvoiceMqState(invoiceVO.getuId(), invoiceVO.getOrderId(), Constants.MQState.COMPLETE.getCode());
             }
 
             @Override
             public void onFailure(Throwable ex) {
-                // 4.2 MQ 消息发送失败，更新数据库表 user_strategy_export.mq_state = 2 【等待定时任务扫码补偿MQ消息】
+                // 5.2 MQ 消息发送失败，更新数据库表 user_strategy_export.mq_state = 2 【等待定时任务扫码补偿MQ消息】
                 activityPartake.updateInvoiceMqState(invoiceVO.getuId(), invoiceVO.getOrderId(), Constants.MQState.FAIL.getCode());
-                }
+            }
         });
 
-        // 5. 返回结果
+        // 6. 返回结果
         return new DrawProcessResult(Constants.ResponseCode.SUCCESS.getCode(), Constants.ResponseCode.SUCCESS.getInfo(), drawResult.getDrawAwardInfo());
     }
 

lottery-common/src/main/java/cn/happy/lottery/common/Constants.java

 package cn.happy.lottery.common;
 
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
 /**
  * @author Happy
  * @date 2022/1/28
@@ -8,12 +12,16 @@ public class Constants {
 
     public enum ResponseCode{
         SUCCESS("0000", "成功"),
-        UN_ERROR("0001","未知失败"),
-        ILLEGAL_PARAMETER("0002","非法参数"),
+        UN_ERROR("0001", "未知失败"),
+        ILLEGAL_PARAMETER("0002", "非法参数"),
         INDEX_DUP("0003", "主键冲突"),
-        NO_UPDATE("0004","SQL操作无更新"),
+        NO_UPDATE("0004", "SQL操作无更新"),
         LOSING_DRAW("D001", "未中奖"),
-        RULE_ERR("D002", "量化人群规则执行失败");
+        RULE_ERR("D002", "量化人群规则执行失败"),
+        NOT_CONSUMED_TAKE("D003", "未消费活动领取记录"),
+        OUT_OF_STOCK("D004", "活动无库存"),
+        ERR_TOKEN("D005", "分布式锁失败"),
+        STRATEGY_DELETE_ERROR("D006","该策略正在使用，无法删除");
 
         private String code;
         private String info;
@@ -42,6 +50,27 @@ public class Constants {
         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;
+        }
+
+    }
+
     /**
      * 决策树节点
      */
@@ -248,6 +277,9 @@ public class Constants {
         private Integer code;
         private String info;
 
+
+        private static final Map<Integer,ActivityState> STATE_MAP;
+
         ActivityState(Integer code, String info) {
             this.code = code;
             this.info = info;
@@ -268,6 +300,18 @@ public class Constants {
         public void setInfo(String info) {
             this.info = info;
         }
+
+        static {
+            Map<Integer,ActivityState> map = new ConcurrentHashMap();
+            for (ActivityState instance : ActivityState.values()) {
+                map.put(instance.getCode(),instance);
+            }
+            STATE_MAP = Collections.unmodifiableMap(map);
+        }
+
+        public static ActivityState get (Integer code) {
+            return STATE_MAP.get(code);
+        }
     }
 
     public enum Ids {

lottery-common/src/main/java/cn/happy/lottery/common/Result.java

@@ -13,6 +13,9 @@ public class Result implements Serializable {
     private String code;
     private String info;
 
+    public Result() {
+    }
+
     public static Result buildResult(Constants.ResponseCode code) {
         return new Result(code.getCode(), code.getInfo());
     }

lottery-domain/pom.xml

@@ -53,6 +53,14 @@
             <groupId>cn.happy</groupId>
             <artifactId>db-router-happy</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+        </dependency>
     </dependencies>
 
     <artifactId>lottery-domain</artifactId>

lottery-domain/src/main/java/cn/happy/lottery/domain/activity/model/res/PartakeResult.java

@@ -9,15 +9,30 @@ import cn.happy.lottery.common.Result;
  */
 public class PartakeResult extends Result {
 
-    /**
-     * 策略ID
-     */
+    /** 策略ID */
     private Long strategyId;
-
-    /**
-     * 活动领取ID
-     */
+    /** 活动领取ID */
     private Long takeId;
+    /** 库存 */
+    private Integer stockCount;
+    /** activity 库存剩余 */
+    private Integer stockSurplusCount;
+
+    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 PartakeResult(String code, String info) {
         super(code, info);

lottery-domain/src/main/java/cn/happy/lottery/domain/activity/model/res/StockResult.java

+package cn.happy.lottery.domain.activity.model.res;
+
+import cn.happy.lottery.common.Result;
+
+/**
+ * @author: happy
+ * @date: 2022/4/6
+ * @description: 库存处理结果
+ */
+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;
+    }
+
+}

lottery-domain/src/main/java/cn/happy/lottery/domain/activity/model/vo/ActivityBillVO.java

@@ -35,6 +35,11 @@ public class ActivityBillVO {
      */
     private Date endDateTime;
 
+    /**
+     *  库存
+     */
+    private Integer stockCount;
+
     /**
      * 库存剩余
      */
@@ -101,6 +106,14 @@ public class ActivityBillVO {
         this.endDateTime = endDateTime;
     }
 
+    public Integer getStockCount() {
+        return stockCount;
+    }
+
+    public void setStockCount(Integer stockCount) {
+        this.stockCount = stockCount;
+    }
+
     public Integer getStockSurplusCount() {
         return stockSurplusCount;
     }
@@ -149,6 +162,7 @@ public class ActivityBillVO {
                 ", activityName='" + activityName + '\'' +
                 ", beginDateTime=" + beginDateTime +
                 ", endDateTime=" + endDateTime +
+                ", stockCount=" + stockCount +
                 ", stockSurplusCount=" + stockSurplusCount +
                 ", state=" + state +
                 ", strategyId=" + strategyId +

lottery-domain/src/main/java/cn/happy/lottery/domain/activity/model/vo/ActivityPartakeRecordVO.java

+package cn.happy.lottery.domain.activity.model.vo;
+
+/**
+ * @description: 活动参与记录
+ * @author: happy
+ * @date: 2022/04/06
+*/
+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 +
+                '}';
+    }
+
+}

lottery-domain/src/main/java/cn/happy/lottery/domain/activity/model/vo/ActivityVO.java

@@ -59,6 +59,12 @@ public class ActivityVO {
      */
     private Integer takeCount;
 
+
+    /**
+     * 剩余可参与次数
+     */
+    private Long leftCount;
+
     /**
      * 活动状态：编辑、提审、撤审、通过、运行、拒绝、关闭、开启
      */
@@ -152,6 +158,14 @@ public class ActivityVO {
         this.takeCount = takeCount;
     }
 
+    public Long getLeftCount() {
+        return leftCount;
+    }
+
+    public void setLeftCount(Long leftCount) {
+        this.leftCount = leftCount;
+    }
+
     public Integer getState() {
         return state;
     }

lottery-domain/src/main/java/cn/happy/lottery/domain/activity/repository/IActivityRepository.java

@@ -4,6 +4,7 @@ import cn.happy.lottery.common.Constants;
 import cn.happy.lottery.domain.activity.model.aggregates.ActivityInfoLimitPageRich;
 import cn.happy.lottery.domain.activity.model.req.ActivityInfoLimitPageReq;
 import cn.happy.lottery.domain.activity.model.req.PartakeReq;
+import cn.happy.lottery.domain.activity.model.res.StockResult;
 import cn.happy.lottery.domain.activity.model.vo.*;
 import cn.happy.lottery.domain.activity.service.stateflow.ActivityStateEnum;
 
@@ -17,7 +18,7 @@ import java.util.List;
 public interface IActivityRepository {
 
     /**
-     * 配置
+     * 添加活动配置
      * @param activity
      */
     void addActivity(ActivityVO activity);
@@ -88,6 +89,7 @@ public interface IActivityRepository {
      */
     ActivityInfoLimitPageRich queryActivityInfoLimitPage(ActivityInfoLimitPageReq req);
 
+
     /**
      * 根据策略Id 查询奖品信息
      * @param strategyId
@@ -106,4 +108,29 @@ public interface IActivityRepository {
      * @param activityVO
      */
     void updateActivity(ActivityVO activityVO);
+
+
+    /**
+     * 扣减活动库存，通过Redis
+     *
+     * @param uId        用户ID
+     * @param activityId 活动ID
+     * @param stockCount 总库存
+     * @return 扣减结果
+     */
+    StockResult subtractionActivityStockByRedis(String uId, Long activityId, Integer stockCount);
+
+    /**
+     * 恢复活动库存，通过Redis 【如果非常异常，则需要进行缓存库存恢复，只保证不超卖的特性，所以不保证一定能恢复占用库存，另外最终可以由任务进行补偿库存】
+     *
+     * @param activityId    活动ID
+     * @param tokenKey      分布式 KEY 用于清理
+     * @param code          状态
+     */
+    void recoverActivityCacheStockByRedis(Long activityId, String tokenKey, String code);
+
+    Long queryActivityByStrategyId(Long strategyId);
+
+    Long queryUserLeftCount(String uId);
+
 }

lottery-domain/src/main/java/cn/happy/lottery/domain/activity/repository/IUserTakeActivityRepository.java

 package cn.happy.lottery.domain.activity.repository;
 
+import cn.happy.lottery.domain.activity.model.vo.ActivityPartakeRecordVO;
 import cn.happy.lottery.domain.activity.model.vo.DrawOrderVO;
 import cn.happy.lottery.domain.activity.model.vo.InvoiceVO;
 import cn.happy.lottery.domain.activity.model.vo.UserTakeActivityVO;
@@ -83,4 +84,10 @@ public interface IUserTakeActivityRepository {
      */
     List<InvoiceVO> scanInvoiceMqState();
 
+    /**
+     * 更新活动库存
+     *
+     * @param activityPartakeRecordVO   活动领取记录
+     */
+    void updateActivityStock(ActivityPartakeRecordVO activityPartakeRecordVO);
 }

lottery-domain/src/main/java/cn/happy/lottery/domain/activity/service/deploy/IActivityDeploy.java

 package cn.happy.lottery.domain.activity.service.deploy;
 
+import cn.happy.lottery.common.Result;
 import cn.happy.lottery.domain.activity.model.aggregates.ActivityConfigRich;
 import cn.happy.lottery.domain.activity.model.aggregates.ActivityInfoLimitPageRich;
 import cn.happy.lottery.domain.activity.model.req.ActivityConfigReq;
@@ -27,7 +28,7 @@ public interface IActivityDeploy {
      * 修改活动信息
      * @param req   活动配置信息
      */
-    void updateActivity(ActivityConfigReq req);
+    Result updateActivity(ActivityConfigReq req);
 
     /**
      * 扫描待处理的活动列表，状态为：通过、活动中
@@ -56,7 +57,11 @@ public interface IActivityDeploy {
 
     /**
      * 删除活动信息
+     *
      * @param activityReq
+     * @return
      */
-    void deleteActivity(ActivityReq activityReq);
+    Result deleteActivity(ActivityReq activityReq);
+
+    Long queryUserLeftCount(String uId);
 }

lottery-domain/src/main/java/cn/happy/lottery/domain/activity/service/deploy/impl/ActivityDeployImpl.java

 package cn.happy.lottery.domain.activity.service.deploy.impl;
 
 import cn.happy.lottery.common.Constants;
+import cn.happy.lottery.common.Result;
 import cn.happy.lottery.domain.activity.model.aggregates.ActivityConfigRich;
 import cn.happy.lottery.domain.activity.model.aggregates.ActivityInfoLimitPageRich;
 import cn.happy.lottery.domain.activity.model.req.ActivityConfigReq;
@@ -8,16 +9,14 @@ import cn.happy.lottery.domain.activity.model.req.ActivityInfoLimitPageReq;
 import cn.happy.lottery.domain.activity.model.req.ActivityReq;
 import cn.happy.lottery.domain.activity.model.vo.ActivityVO;
 import cn.happy.lottery.domain.activity.model.vo.AwardVO;
-import cn.happy.lottery.domain.activity.model.vo.StrategyDetailVO;
-import cn.happy.lottery.domain.activity.model.vo.StrategyVO;
 import cn.happy.lottery.domain.activity.repository.IActivityRepository;
 import cn.happy.lottery.domain.activity.service.deploy.IActivityDeploy;
+import cn.happy.lottery.domain.activity.service.stateflow.IStateHandler;
 import com.alibaba.fastjson.JSON;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.dao.DuplicateKeyException;
 import org.springframework.stereotype.Component;
-import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
 import java.util.List;
@@ -35,6 +34,9 @@ public class ActivityDeployImpl implements IActivityDeploy {
     @Resource
     private IActivityRepository activityRepository;
 
+    @Resource
+    private IStateHandler stateHandler;
+
     @Override
     public void createActivity(ActivityConfigReq req) {
 
@@ -54,21 +56,54 @@ public class ActivityDeployImpl implements IActivityDeploy {
         } catch (DuplicateKeyException e) {
             logger.error("创建活动配置失败，唯一索引冲突：activityId：{}, reqJson：{}", req.getActivity().getActivityId(), JSON.toJSONString(req), e);
             throw e;
+        } catch (Exception e){
+            throw e;
         }
     }
 
     @Override
-    public void updateActivity(ActivityConfigReq req) {
+    public Result updateActivity(ActivityConfigReq req) {
         // 日志打印
         logger.info("修改活动配置开始, activityId：{}", req.getActivity().getActivityId());
 
         try {
-            // 添加活动配置
-            ActivityVO activity = req.getActivity();
-            activityRepository.updateActivity(activity);
+            // 检查状态流转
+            ActivityVO activityVO = req.getActivity();
+            Integer preState = activityRepository.queryActivityInfo(activityVO.getActivityId()).getState();
+            Integer changState = activityVO.getState();
+            Result result = new Result();
+            switch (changState) {
+                case 2:
+                    result = stateHandler.arraignment(activityVO.getActivityId(), Constants.ActivityState.get(preState));
+                    break;
+                case 3:
+                    result = stateHandler.checkRevoke(activityVO.getActivityId(), Constants.ActivityState.get(preState));
+                    break;
+                case 4:
+                    result = stateHandler.checkPass(activityVO.getActivityId(), Constants.ActivityState.get(preState));
+                    break;
+                case 5:
+                    result = stateHandler.doing(activityVO.getActivityId(), Constants.ActivityState.get(preState));
+                    break;
+                case 6:
+                    result = stateHandler.checkRefuse(activityVO.getActivityId(), Constants.ActivityState.get(preState));
+                    break;
+                case 7:
+                    result = stateHandler.close(activityVO.getActivityId(), Constants.ActivityState.get(preState));
+                    break;
+                case 8:
+                    result = stateHandler.open(activityVO.getActivityId(), Constants.ActivityState.get(preState));
+                    break;
+            }
+
+            if (!Constants.ResponseCode.SUCCESS.getCode().equals(result.getCode())) {
+                return Result.buildErrorResult(result.getInfo());
+            }
 
             // 日志打印
+            activityRepository.updateActivity(activityVO);
             logger.info("修改活动配置完成，activityId：{}", req.getActivity().getActivityId());
+            return Result.buildSuccessResult();
         } catch (DuplicateKeyException e) {
             logger.error("修改活动配置失败，唯一索引冲突：activityId：{}, reqJson：{}", req.getActivity().getActivityId(), JSON.toJSONString(req), e);
             throw e;
@@ -103,8 +138,18 @@ public class ActivityDeployImpl implements IActivityDeploy {
     }
 
     @Override
-    public void deleteActivity(ActivityReq activityReq) {
+    public Result deleteActivity(ActivityReq activityReq) {
+        ActivityVO activityVO = activityRepository.queryActivityInfo(activityReq.getActivityId());
+        if (!activityVO.getState().equals(Constants.ActivityState.DOING.getCode())) {
+            return Result.buildErrorResult(Constants.ActivityState.DOING.getInfo());
+        }
+
         activityRepository.deleteActivity(activityReq.getActivityId());
+        return Result.buildSuccessResult();
     }
 
+    @Override
+    public Long queryUserLeftCount(String uId) {
+        return activityRepository.queryUserLeftCount(uId);
+    }
 }

lottery-domain/src/main/java/cn/happy/lottery/domain/activity/service/partake/BaseActivityPartake.java

@@ -4,6 +4,7 @@ import cn.happy.lottery.common.Constants;
 import cn.happy.lottery.common.Result;
 import cn.happy.lottery.domain.activity.model.req.PartakeReq;
 import cn.happy.lottery.domain.activity.model.res.PartakeResult;
+import cn.happy.lottery.domain.activity.model.res.StockResult;
 import cn.happy.lottery.domain.activity.model.vo.ActivityBillVO;
 import cn.happy.lottery.domain.activity.model.vo.UserTakeActivityVO;
 import cn.happy.lottery.domain.support.ids.IIdGenerator;
@@ -27,7 +28,7 @@ public abstract class BaseActivityPartake extends ActivityPartakeSupport impleme
         // 1. 查询是否存在未执行抽奖的领取活动单【user_take_activity 存在 state = 0，领取了但抽奖过程失败的，可以直接返回领取结果继续抽奖】
         UserTakeActivityVO userTakeActivityVO = this.queryNoConsumedTakeActivityOrder(req.getActivityId(), req.getuId());
         if (null != userTakeActivityVO) {
-            return buildPartakeResult(userTakeActivityVO.getStrategyId(), userTakeActivityVO.getTakeId());
+            return buildPartakeResult(userTakeActivityVO.getStrategyId(), userTakeActivityVO.getTakeId(), Constants.ResponseCode.NOT_CONSUMED_TAKE);
         }
 
         // 2. 查询活动账单
@@ -39,9 +40,10 @@ public abstract class BaseActivityPartake extends ActivityPartakeSupport impleme
             return new PartakeResult(checkResult.getCode(), checkResult.getInfo());
         }
 
-        // 4. 扣减活动库存【目前为直接对配置库中的 lottery.activity 直接操作表扣减库存，后续优化为Redis扣减】
-        Result subtractionActivityResult = this.subtractionActivityStock(req);
+        // 4. 扣减活动库存，通过 Redis【活动库存扣减编号，作为锁的 key，缩小锁粒度】 Begin
+        StockResult subtractionActivityResult = subtractionActivityStockByRedis(req.getuId(), req.getActivityId(), activityBillVO.getStockCount());
         if (!Constants.ResponseCode.SUCCESS.getCode().equals(subtractionActivityResult.getCode())) {
+            this.recoverActivityCacheStockByRedis(req.getActivityId(), subtractionActivityResult.getStockKey(), subtractionActivityResult.getCode());
             return new PartakeResult(subtractionActivityResult.getCode(), subtractionActivityResult.getInfo());
         }
 
@@ -49,11 +51,34 @@ public abstract class BaseActivityPartake extends ActivityPartakeSupport impleme
         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.封装结果【返回的策略ID，用于继续完成抽奖步骤】
-        return buildPartakeResult(activityBillVO.getStrategyId(), takeId);
+        // 6. 扣减活动库存，通过  Redis End
+        this.recoverActivityCacheStockByRedis(req.getActivityId(), subtractionActivityResult.getStockKey(), Constants.ResponseCode.SUCCESS.getCode());
+
+        // 7.封装结果【返回的策略ID，用于继续完成抽奖步骤】
+        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;
     }
 
     /**
@@ -61,15 +86,35 @@ public abstract class BaseActivityPartake extends ActivityPartakeSupport impleme
      *
      * @param strategyId 策略ID
      * @param takeId     领取ID
+     * @param code       状态码
      * @return 封装结果
      */
-    private PartakeResult buildPartakeResult(Long strategyId, Long takeId) {
-        PartakeResult partakeResult = new PartakeResult(Constants.ResponseCode.SUCCESS.getCode(), Constants.ResponseCode.SUCCESS.getInfo());
+    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;
     }
 
+    /**
+     * 扣减活动库存，通过 Redis
+     *
+     * @param uId
+     * @param activityId
+     * @param stockCount
+     * @return
+     */
+    protected abstract StockResult subtractionActivityStockByRedis(String uId, Long activityId, Integer stockCount);
+
+    /**
+     * 恢复活动库存，通过 Redis 【如果非常异常，则要进行缓存库存恢复，只保证不超卖的特性，所以不保证一定能恢复占用库存，另外最终可以由任务进行补偿库存】
+     *
+     * @param activityId
+     * @param tokenKey
+     * @param code
+     */
+    protected abstract void recoverActivityCacheStockByRedis(Long activityId, String tokenKey, String code);
+
     /**
      * 查询是否存在未执行抽奖领取活动单【user_take_activity 存在 state = 0，领取了但抽奖过程失败的，可以直接返回领取结果继续抽奖】
      *

lottery-domain/src/main/java/cn/happy/lottery/domain/activity/service/partake/IActivityPartake.java

@@ -3,6 +3,7 @@ package cn.happy.lottery.domain.activity.service.partake;
 import cn.happy.lottery.common.Result;
 import cn.happy.lottery.domain.activity.model.req.PartakeReq;
 import cn.happy.lottery.domain.activity.model.res.PartakeResult;
+import cn.happy.lottery.domain.activity.model.vo.ActivityPartakeRecordVO;
 import cn.happy.lottery.domain.activity.model.vo.DrawOrderVO;
 import cn.happy.lottery.domain.activity.model.vo.InvoiceVO;
 
@@ -46,4 +47,10 @@ public interface IActivityPartake {
      */
     List<InvoiceVO> scanInvoiceMqState(int dbCount, int tbCount);
 
+    /**
+     * 更新活动库存
+     *
+     * @param activityPartakeRecordVO   活动领取记录
+     */
+    void updateActivityStock(ActivityPartakeRecordVO activityPartakeRecordVO);
 }

lottery-domain/src/main/java/cn/happy/lottery/domain/activity/service/partake/impl/ActivityPartakeImpl.java

@@ -3,10 +3,8 @@ package cn.happy.lottery.domain.activity.service.partake.impl;
 import cn.happy.lottery.common.Constants;
 import cn.happy.lottery.common.Result;
 import cn.happy.lottery.domain.activity.model.req.PartakeReq;
-import cn.happy.lottery.domain.activity.model.vo.ActivityBillVO;
-import cn.happy.lottery.domain.activity.model.vo.DrawOrderVO;
-import cn.happy.lottery.domain.activity.model.vo.InvoiceVO;
-import cn.happy.lottery.domain.activity.model.vo.UserTakeActivityVO;
+import cn.happy.lottery.domain.activity.model.res.StockResult;
+import cn.happy.lottery.domain.activity.model.vo.*;
 import cn.happy.lottery.domain.activity.repository.IUserTakeActivityRepository;
 import cn.happy.lottery.domain.activity.service.partake.BaseActivityPartake;
 import cn.happy.middleware.db.router.strategy.IDBRouterStrategy;
@@ -40,6 +38,16 @@ public class ActivityPartakeImpl extends BaseActivityPartake {
     private IDBRouterStrategy dbRouter;
 
 
+    @Override
+    protected StockResult subtractionActivityStockByRedis(String uId, Long activityId, Integer stockCount) {
+        return activityRepository.subtractionActivityStockByRedis(uId, activityId, stockCount);
+    }
+
+    @Override
+    protected void recoverActivityCacheStockByRedis(Long activityId, String tokenKey, String code) {
+        activityRepository.recoverActivityCacheStockByRedis(activityId, tokenKey, code);
+    }
+
     @Override
     protected UserTakeActivityVO queryNoConsumedTakeActivityOrder(Long activityId, String uId) {
         return userTakeActivityRepository.queryNoConsumedTakeActivityOrder(activityId, uId);
@@ -161,4 +169,9 @@ public class ActivityPartakeImpl extends BaseActivityPartake {
             dbRouter.clear();
         }
     }
+
+    @Override
+    public void updateActivityStock(ActivityPartakeRecordVO activityPartakeRecordVO) {
+        userTakeActivityRepository.updateActivityStock(activityPartakeRecordVO);
+    }
 }

lottery-domain/src/main/java/cn/happy/lottery/domain/activity/service/stateflow/events/RevokeState.java

+package cn.happy.lottery.domain.activity.service.stateflow.events;
+
+import cn.happy.lottery.common.Constants;
+import cn.happy.lottery.common.Result;
+import cn.happy.lottery.domain.activity.service.stateflow.AbstractState;
+import org.springframework.stereotype.Component;
+
+/**
+ * @description: 活动撤审状态
+ * @author Happy
+ * @date 2022/2/18
+ */
+@Component
+public class RevokeState 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) {
+        return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动撤审中,不可运行");
+    }
+
+}

lottery-domain/src/main/java/cn/happy/lottery/domain/award/model/aggregates/AwardInfoLimitPageRich.java

+package cn.happy.lottery.domain.award.model.aggregates;
+
+import cn.happy.lottery.domain.activity.model.vo.ActivityVO;
+import cn.happy.lottery.domain.activity.model.vo.AwardVO;
+
+import java.util.List;
+
+/**
+ * @description: 活动分页查询聚合对象
+ * @author: happy
+ * @date: 2022/04/14
+*/
+public class AwardInfoLimitPageRich {
+
+    private Long count;
+    private List<AwardVO> awardVOList;
+
+    public AwardInfoLimitPageRich() {
+    }
+
+    public AwardInfoLimitPageRich(Long count, List<AwardVO> awardVOList) {
+        this.count = count;
+        this.awardVOList = awardVOList;
+    }
+
+    public Long getCount() {
+        return count;
+    }
+
+    public void setCount(Long count) {
+        this.count = count;
+    }
+
+    public List<AwardVO> getAwardVOList() {
+        return awardVOList;
+    }
+
+    public void setAwardVOList(List<AwardVO> awardVOList) {
+        this.awardVOList = awardVOList;
+    }
+}

lottery-domain/src/main/java/cn/happy/lottery/domain/award/model/req/AwardInfoLimitPageReq.java

+package cn.happy.lottery.domain.award.model.req;
+
+
+import cn.happy.lottery.common.PageRequest;
+
+/**
+ * @description: 奖品分页查询请求对象
+ * @author: happy
+ * @date: 2022/04/14
+*/
+public class AwardInfoLimitPageReq extends PageRequest {
+
+    /**
+     * 奖品ID
+     */
+    private String awardId;
+
+    /**
+     * 活动名称
+     */
+    private String awardName;
+
+    public AwardInfoLimitPageReq(int page, int rows) {
+        super(page, rows);
+    }
+
+    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;
+    }
+}

lottery-domain/src/main/java/cn/happy/lottery/domain/award/model/req/AwardReq.java

+package cn.happy.lottery.domain.award.model.req;
+
+import cn.happy.lottery.domain.activity.model.vo.AwardVO;
+
+public class AwardReq {
+
+    AwardVO awardVO;
+
+    public AwardReq() {
+    }
+
+    public AwardReq(AwardVO awardVO) {
+        this.awardVO = awardVO;
+    }
+
+    public AwardVO getAwardVO() {
+        return awardVO;
+    }
+
+    public void setAwardVO(AwardVO awardVO) {
+        this.awardVO = awardVO;
+    }
+}

lottery-domain/src/main/java/cn/happy/lottery/domain/award/repository/IAwardRepository.java

 package cn.happy.lottery.domain.award.repository;
 
+import cn.happy.lottery.domain.award.model.aggregates.AwardInfoLimitPageRich;
+import cn.happy.lottery.domain.award.model.req.AwardInfoLimitPageReq;
+import cn.happy.lottery.domain.award.model.req.AwardReq;
+
 /**
  * @author Happy
  * @description: 奖品表仓储服务接口
@@ -16,4 +20,12 @@ public interface IAwardRepository {
      * @param grantState
      */
     void updateUserAwardState(String uId, Long orderId, String awardId, Integer grantState);
+
+    AwardInfoLimitPageRich queryAwardInfoLimitPage(AwardInfoLimitPageReq awardInfoLimitPageReq);
+
+    void createAward(AwardReq awardReq);
+
+    void deleteAward(AwardReq awardReq);
+
+    void updateAward(AwardReq awardReq);
 }

lottery-domain/src/main/java/cn/happy/lottery/domain/strategy/model/aggregates/StrategyDetailInfoLimitPageRich.java

+package cn.happy.lottery.domain.strategy.model.aggregates;
+
+import cn.happy.lottery.domain.activity.model.vo.StrategyDetailVO;
+import cn.happy.lottery.domain.activity.model.vo.StrategyVO;
+
+import java.util.List;
+
+/**
+ * @description: 活动分页查询聚合对象
+ * @author: happy
+ * @date: 2022/04/14
+*/
+public class StrategyDetailInfoLimitPageRich {
+
+    private Long count;
+    private List<StrategyDetailVO> strategyDetailVOList;
+
+    public StrategyDetailInfoLimitPageRich() {
+    }
+
+    public StrategyDetailInfoLimitPageRich(Long count, List<StrategyDetailVO> strategyDetailVOList) {
+        this.count = count;
+        this.strategyDetailVOList = strategyDetailVOList;
+    }
+
+    public Long getCount() {
+        return count;
+    }
+
+    public void setCount(Long count) {
+        this.count = count;
+    }
+
+    public List<StrategyDetailVO> getStrategyVOList() {
+        return strategyDetailVOList;
+    }
+
+    public void setStrategyVOList(List<StrategyDetailVO> strategyDetailVOList) {
+        this.strategyDetailVOList = strategyDetailVOList;
+    }
+}

lottery-domain/src/main/java/cn/happy/lottery/domain/strategy/model/aggregates/StrategyInfoLimitPageRich.java

+package cn.happy.lottery.domain.strategy.model.aggregates;
+
+import cn.happy.lottery.domain.activity.model.vo.ActivityVO;
+import cn.happy.lottery.domain.activity.model.vo.StrategyVO;
+
+import java.util.List;
+
+/**
+ * @description: 活动分页查询聚合对象
+ * @author: happy
+ * @date: 2022/04/14
+*/
+public class StrategyInfoLimitPageRich {
+
+    private Long count;
+    private List<StrategyVO> strategyVOList;
+
+    public StrategyInfoLimitPageRich() {
+    }
+
+    public StrategyInfoLimitPageRich(Long count, List<StrategyVO> strategyVOList) {
+        this.count = count;
+        this.strategyVOList = strategyVOList;
+    }
+
+    public Long getCount() {
+        return count;
+    }
+
+    public void setCount(Long count) {
+        this.count = count;
+    }
+
+    public List<StrategyVO> getStrategyVOList() {
+        return strategyVOList;
+    }
+
+    public void setStrategyVOList(List<StrategyVO> strategyVOList) {
+        this.strategyVOList = strategyVOList;
+    }
+}

lottery-domain/src/main/java/cn/happy/lottery/domain/strategy/model/req/StrategyDetailReq.java

+package cn.happy.lottery.domain.strategy.model.req;
+
+import cn.happy.lottery.domain.activity.model.vo.StrategyDetailVO;
+import cn.happy.lottery.domain.activity.model.vo.StrategyVO;
+
+public class StrategyDetailReq {
+
+
+    StrategyDetailVO strategyDetailVO;
+
+    public StrategyDetailReq() {
+    }
+
+    public StrategyDetailReq(StrategyDetailVO strategyDetailVO) {
+        this.strategyDetailVO = strategyDetailVO;
+    }
+
+    public StrategyDetailVO getStrategyDetailVO() {
+        return strategyDetailVO;
+    }
+
+    public void setStrategyDetailVO(StrategyDetailVO strategyDetailVO) {
+        this.strategyDetailVO = strategyDetailVO;
+    }
+
+    @Override
+    public String toString() {
+        return "StrategyDetailReq{" +
+                "strategyDetailVO=" + strategyDetailVO +
+                '}';
+    }
+}

lottery-domain/src/main/java/cn/happy/lottery/domain/strategy/model/req/StrategyInfoLimitPageReq.java

+package cn.happy.lottery.domain.strategy.model.req;
+
+
+import cn.happy.lottery.common.PageRequest;
+
+/**
+ * @description: 活动分页查询请求对象
+ * @author: happy
+ * @date: 2022/04/14
+*/
+public class StrategyInfoLimitPageReq extends PageRequest {
+
+    private Long id;
+
+    /**
+     * 活动ID
+     */
+    private Long strategyId;
+
+    /**
+     * 活动名称
+     */
+    private String strategyDesc;
+
+    public StrategyInfoLimitPageReq(int page, int rows) {
+        super(page, rows);
+    }
+
+
+    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;
+    }
+}

lottery-domain/src/main/java/cn/happy/lottery/domain/strategy/model/req/StrategyReq.java

+package cn.happy.lottery.domain.strategy.model.req;
+
+import cn.happy.lottery.domain.activity.model.vo.StrategyVO;
+
+import java.util.List;
+
+public class StrategyReq {
+
+    StrategyVO strategyVO;
+
+    public StrategyReq(StrategyVO strategyVO) {
+        this.strategyVO = strategyVO;
+    }
+
+    public StrategyVO getStrategyVO() {
+        return strategyVO;
+    }
+
+    public void setStrategyVO(StrategyVO strategyVO) {
+        this.strategyVO = strategyVO;
+    }
+}

lottery-domain/src/main/java/cn/happy/lottery/domain/strategy/repository/IStrategyRepository.java

 package cn.happy.lottery.domain.strategy.repository;
 
+import cn.happy.lottery.common.Result;
+import cn.happy.lottery.domain.activity.model.vo.StrategyVO;
+import cn.happy.lottery.domain.strategy.model.aggregates.StrategyDetailInfoLimitPageRich;
+import cn.happy.lottery.domain.strategy.model.aggregates.StrategyInfoLimitPageRich;
 import cn.happy.lottery.domain.strategy.model.aggregates.StrategyRich;
+import cn.happy.lottery.domain.strategy.model.req.StrategyDetailReq;
+import cn.happy.lottery.domain.strategy.model.req.StrategyInfoLimitPageReq;
+import cn.happy.lottery.domain.strategy.model.req.StrategyReq;
 import cn.happy.lottery.domain.strategy.model.vo.AwardBriefVO;
 
 import java.util.List;
@@ -41,4 +48,20 @@ public interface IStrategyRepository {
      * @return           扣减结果
      */
     boolean deductStock(Long strategyId, String awardId);
+
+    StrategyInfoLimitPageRich queryStrategyInfoLimitPage(StrategyInfoLimitPageReq req);
+
+    void createStrategy(StrategyVO strategyVO);
+
+    void deleteStrategy(Long strategyId);
+
+    void updateStrategy(StrategyVO strategyVO);
+
+    StrategyDetailInfoLimitPageRich queryStrategyDetailInfoLimitPage(StrategyInfoLimitPageReq req);
+
+    void createStrategyDetail(StrategyDetailReq strategyDetailReq);
+
+    void deleteStrategyDetail(StrategyDetailReq strategyDetailReq);
+
+    void updateStrategyDetail(StrategyDetailReq strategyDetailReq);
 }

lottery-domain/src/main/java/cn/happy/lottery/domain/strategy/service/deploy/IStrategyDeploy.java

+package cn.happy.lottery.domain.strategy.service.deploy;
+
+import cn.happy.lottery.common.Result;
+import cn.happy.lottery.domain.strategy.model.aggregates.StrategyInfoLimitPageRich;
+import cn.happy.lottery.domain.strategy.model.req.StrategyInfoLimitPageReq;
+import cn.happy.lottery.domain.strategy.model.req.StrategyReq;
+
+public interface IStrategyDeploy {
+    StrategyInfoLimitPageRich queryStrategyInfoLimitPage(StrategyInfoLimitPageReq req);
+
+    void createStrategy(StrategyReq req);
+
+    Result deleteStrategy(StrategyReq req);
+
+    void updateStrategy(StrategyReq req);
+}

lottery-domain/src/main/java/cn/happy/lottery/domain/strategy/service/deploy/IStrategyDetailDeploy.java

+package cn.happy.lottery.domain.strategy.service.deploy;
+
+import cn.happy.lottery.common.Result;
+import cn.happy.lottery.domain.strategy.model.aggregates.StrategyDetailInfoLimitPageRich;
+import cn.happy.lottery.domain.strategy.model.aggregates.StrategyInfoLimitPageRich;
+import cn.happy.lottery.domain.strategy.model.req.StrategyDetailReq;
+import cn.happy.lottery.domain.strategy.model.req.StrategyInfoLimitPageReq;
+import cn.happy.lottery.domain.strategy.model.req.StrategyReq;
+
+public interface IStrategyDetailDeploy {
+
+    StrategyDetailInfoLimitPageRich queryStrategyDetailInfoLimitPage(StrategyInfoLimitPageReq req);
+
+    void createStrategyDetail(StrategyDetailReq strategyDetailReq);
+
+    Result deleteStrategyDetail(StrategyDetailReq strategyDetailReq);
+
+    void updateStrategyDetail(StrategyDetailReq strategyDetailReq);
+}

lottery-domain/src/main/java/cn/happy/lottery/domain/strategy/service/deploy/impl/StrategyDeployImpl.java

+package cn.happy.lottery.domain.strategy.service.deploy.impl;
+
+import cn.happy.lottery.common.Constants;
+import cn.happy.lottery.common.Result;
+import cn.happy.lottery.domain.activity.model.vo.ActivityVO;
+import cn.happy.lottery.domain.activity.repository.IActivityRepository;
+import cn.happy.lottery.domain.strategy.model.aggregates.StrategyInfoLimitPageRich;
+import cn.happy.lottery.domain.strategy.model.req.StrategyInfoLimitPageReq;
+import cn.happy.lottery.domain.strategy.model.req.StrategyReq;
+import cn.happy.lottery.domain.strategy.repository.IStrategyRepository;
+import cn.happy.lottery.domain.strategy.service.deploy.IStrategyDeploy;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+
+@Component
+public class StrategyDeployImpl implements IStrategyDeploy {
+
+    @Resource
+    private IStrategyRepository strategyRepository;
+
+    @Resource
+    private IActivityRepository activityRepository;
+
+    @Override
+    public StrategyInfoLimitPageRich queryStrategyInfoLimitPage(StrategyInfoLimitPageReq req) {
+        return strategyRepository.queryStrategyInfoLimitPage(req);
+    }
+
+    @Override
+    public void createStrategy(StrategyReq req) {
+        strategyRepository.createStrategy(req.getStrategyVO());
+    }
+
+    @Override
+    public Result deleteStrategy(StrategyReq req) {
+
+        // 查看该策略是否关联活动
+        Long strategyId = req.getStrategyVO().getStrategyId();
+        Long count = activityRepository.queryActivityByStrategyId(strategyId);
+        if (count != 0) {
+            return new Result(Constants.ResponseCode.STRATEGY_DELETE_ERROR.getInfo(), Constants.ResponseCode.STRATEGY_DELETE_ERROR.getCode());
+        }
+
+        strategyRepository.deleteStrategy(req.getStrategyVO().getStrategyId());
+        return Result.buildSuccessResult();
+    }
+
+    @Override
+    public void updateStrategy(StrategyReq req) {
+        strategyRepository.updateStrategy(req.getStrategyVO());
+    }
+}

lottery-domain/src/main/java/cn/happy/lottery/domain/strategy/service/deploy/impl/StrategyDetailDeployImpl.java

+package cn.happy.lottery.domain.strategy.service.deploy.impl;
+
+import cn.happy.lottery.common.Constants;
+import cn.happy.lottery.common.Result;
+import cn.happy.lottery.domain.activity.repository.IActivityRepository;
+import cn.happy.lottery.domain.strategy.model.aggregates.StrategyDetailInfoLimitPageRich;
+import cn.happy.lottery.domain.strategy.model.aggregates.StrategyInfoLimitPageRich;
+import cn.happy.lottery.domain.strategy.model.req.StrategyDetailReq;
+import cn.happy.lottery.domain.strategy.model.req.StrategyInfoLimitPageReq;
+import cn.happy.lottery.domain.strategy.model.req.StrategyReq;
+import cn.happy.lottery.domain.strategy.repository.IStrategyRepository;
+import cn.happy.lottery.domain.strategy.service.deploy.IStrategyDeploy;
+import cn.happy.lottery.domain.strategy.service.deploy.IStrategyDetailDeploy;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+
+@Component
+public class StrategyDetailDeployImpl implements IStrategyDetailDeploy {
+
+    @Resource
+    private IStrategyRepository strategyRepository;
+
+    @Override
+    public StrategyDetailInfoLimitPageRich queryStrategyDetailInfoLimitPage(StrategyInfoLimitPageReq req) {
+        return strategyRepository.queryStrategyDetailInfoLimitPage(req);
+    }
+
+    @Override
+    public void createStrategyDetail(StrategyDetailReq strategyDetailReq) {
+        strategyRepository.createStrategyDetail(strategyDetailReq);
+    }
+
+    @Override
+    public Result deleteStrategyDetail(StrategyDetailReq strategyDetailReq) {
+
+//        Long strategyId = strategyDetailReq.getStrategyDetailVO().getStrategyId();
+        strategyRepository.deleteStrategyDetail(strategyDetailReq);
+        return Result.buildSuccessResult();
+    }
+
+    @Override
+    public void updateStrategyDetail(StrategyDetailReq strategyDetailReq) {
+        strategyRepository.updateStrategyDetail(strategyDetailReq);
+    }
+}

lottery-domain/src/main/java/cn/happy/lottery/domain/strategy/service/draw/impl/DrawExecImpl.java

@@ -11,7 +11,7 @@ import java.util.List;
 
 /**
  * @author Happy
- * @description:
+ * @description: 抽奖策略流程实现
  * @date 2022/2/7
  */
 @Service("drawExec")

lottery-domain/src/main/java/cn/happy/lottery/domain/support/redis/RedisConfig.java

+package cn.happy.lottery.domain.support.redis;
+
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.cache.annotation.CachingConfigurerSupport;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.core.*;
+import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+/**
+ * @author: happy
+ * @date: 2022/4/6
+ * @description:
+ */
+@Configuration
+@EnableCaching
+public class RedisConfig extends CachingConfigurerSupport {
+
+
+    /**
+     * template 相关配置
+     *
+     * @param factory RedisConnectionFactory
+     * @return RedisTemplate
+     */
+    @Bean
+    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
+
+        // 配置连接工厂
+        RedisTemplate<String, Object> template = new RedisTemplate<>();
+        template.setConnectionFactory(factory);
+
+        // 使用 Jackson2JsonRedisSerializer 来序列化和反序列化 redis 的 value 值（默认使用 JDK 的序列化方式）
+        Jackson2JsonRedisSerializer jacksonSerial = new Jackson2JsonRedisSerializer(Object.class);
+
+        ObjectMapper om = new ObjectMapper();
+        // 指定要序列化的域，field，get，set 以及修饰符范围，ANY 是都由包括 private 和 public
+        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
+        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如 String, Integer 会出异常
+        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
+        jacksonSerial.setObjectMapper(om);
+
+        // 值采用json序列化
+        template.setValueSerializer(jacksonSerial);
+        // 使用StringRedisSerializer来序列化和反序列化redis的key值
+        template.setKeySerializer(new StringRedisSerializer());
+
+        // 设置 hash key 和 value 序列化模式
+        template.setHashKeySerializer(new StringRedisSerializer());
+        template.setHashValueSerializer(jacksonSerial);
+        template.afterPropertiesSet();
+
+        return template;
+    }
+
+    /**
+     * 对 HASH 类型的数据操作
+     *
+     * @param redisTemplate RedisTemplate
+     * @return HashOperations
+     */
+    @Bean
+    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
+        return redisTemplate.opsForHash();
+    }
+
+    /**
+     * 对redis字符串类型数据操作
+     *
+     * @param redisTemplate RedisTemplate
+     * @return ValueOperations
+     */
+    @Bean
+    public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
+        return redisTemplate.opsForValue();
+    }
+
+    /**
+     * 对链表类型的数据操作
+     *
+     * @param redisTemplate RedisTemplate
+     * @return ListOperations
+     */
+    @Bean
+    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
+        return redisTemplate.opsForList();
+    }
+
+    /**
+     * 对无序集合类型的数据操作
+     *
+     * @param redisTemplate RedisTemplate
+     * @return SetOperations
+     */
+    @Bean
+    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
+        return redisTemplate.opsForSet();
+    }
+
+    /**
+     * 对有序集合类型的数据操作
+     *
+     * @param redisTemplate RedisTemplate
+     * @return ZSetOperations
+     */
+    @Bean
+    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
+        return redisTemplate.opsForZSet();
+    }
+
+}

lottery-infrastructure/src/main/java/cn/happy/lottery/infrastructure/dao/IActivityDao.java

@@ -3,6 +3,7 @@ package cn.happy.lottery.infrastructure.dao;
 import cn.happy.lottery.domain.activity.model.req.ActivityInfoLimitPageReq;
 import cn.happy.lottery.domain.activity.model.vo.AlterStateVO;
 import cn.happy.lottery.infrastructure.po.Activity;
+import cn.happy.middleware.db.router.annotation.DBRouter;
 import org.apache.ibatis.annotations.Mapper;
 
 import java.util.List;
@@ -79,4 +80,14 @@ public interface IActivityDao {
      */
     void updateActivity(Activity activity);
 
+
+    /**
+     * 更新用户领取活动后，活动库存
+     *
+     * @param activity  入参
+     */
+    void updateActivityStock(Activity activity);
+
+    Long queryActivityByStrategyId(Long strategyId);
+
 }

lottery-infrastructure/src/main/java/cn/happy/lottery/infrastructure/dao/IAwardDao.java

 package cn.happy.lottery.infrastructure.dao;
 
+import cn.happy.lottery.domain.award.model.req.AwardInfoLimitPageReq;
 import cn.happy.lottery.infrastructure.po.Award;
 import org.apache.ibatis.annotations.Mapper;
 
@@ -32,4 +33,15 @@ public interface IAwardDao {
      * @return
      */
     List<Award> queryAwardListByAwardList(List<String> awardIdList);
+
+    Long queryAwardInfoCount(AwardInfoLimitPageReq req);
+
+    List<Award> queryAwardInfoList(AwardInfoLimitPageReq req);
+
+    void insert(Award award);
+
+    void delete(Award award);
+
+    void update(Award award);
+
 }

lottery-infrastructure/src/main/java/cn/happy/lottery/infrastructure/dao/IStrategyDao.java

 package cn.happy.lottery.infrastructure.dao;
 
+import cn.happy.lottery.domain.strategy.model.req.StrategyInfoLimitPageReq;
 import cn.happy.lottery.infrastructure.po.Strategy;
 import org.apache.ibatis.annotations.Mapper;
 
+import java.util.List;
+
 /**
  * @author Happy
  * @description:
@@ -23,4 +26,12 @@ public interface IStrategyDao {
      * @param strategy
      */
     void insert(Strategy strategy);
+
+    Long queryStrategyInfoCount(StrategyInfoLimitPageReq req);
+
+    List<Strategy> queryStrategyInfoList(StrategyInfoLimitPageReq req);
+
+    void deleteStrategyById(Long strategyId);
+
+    void updateStrategyById(Strategy strategy);
 }

lottery-infrastructure/src/main/java/cn/happy/lottery/infrastructure/dao/IStrategyDetailDao.java

 package cn.happy.lottery.infrastructure.dao;
 
+import cn.happy.lottery.domain.strategy.model.req.StrategyInfoLimitPageReq;
 import cn.happy.lottery.infrastructure.po.StrategyDetail;
 import org.apache.ibatis.annotations.Mapper;
 
@@ -40,4 +41,16 @@ public interface IStrategyDetailDao {
      * @param strategyDetailList
      */
     void insertList(List<StrategyDetail> strategyDetailList);
+
+    void deleteStrategyDetailById(Long strategyId);
+
+    void deleteStrategyDetail(StrategyDetail strategyDetail);
+
+    void insert(StrategyDetail strategyDetail);
+
+    List<StrategyDetail> queryStrategyDetailInfoList(StrategyInfoLimitPageReq req);
+
+    Long queryStrategyDetailInfoCount(StrategyInfoLimitPageReq req);
+
+    void updateStrategyDetailById(StrategyDetail strategyDetail);
 }

lottery-infrastructure/src/main/java/cn/happy/lottery/infrastructure/dao/IUserTakeActivityCountDao.java

@@ -38,5 +38,6 @@ public interface IUserTakeActivityCountDao {
     int updateLeftCount(UserTakeActivityCount userTakeActivityCount);
 
 
-
+    @DBRouter
+    Long queryUserLeftCount(String uId);
 }

lottery-infrastructure/src/main/java/cn/happy/lottery/infrastructure/repository/ActivityRepository.java

@@ -4,12 +4,15 @@ import cn.happy.lottery.common.Constants;
 import cn.happy.lottery.domain.activity.model.aggregates.ActivityInfoLimitPageRich;
 import cn.happy.lottery.domain.activity.model.req.ActivityInfoLimitPageReq;
 import cn.happy.lottery.domain.activity.model.req.PartakeReq;
+import cn.happy.lottery.domain.activity.model.res.StockResult;
 import cn.happy.lottery.domain.activity.model.vo.*;
 import cn.happy.lottery.domain.activity.repository.IActivityRepository;
 import cn.happy.lottery.infrastructure.dao.*;
 import cn.happy.lottery.infrastructure.po.*;
+import cn.happy.lottery.infrastructure.util.RedisUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.BeanUtils;
-import org.springframework.context.annotation.Bean;
 import org.springframework.stereotype.Repository;
 
 import javax.annotation.Resource;
@@ -24,6 +27,9 @@ import java.util.List;
 @Repository
 public class ActivityRepository implements IActivityRepository {
 
+    private Logger logger = LoggerFactory.getLogger(ActivityRepository.class);
+
+
     @Resource
     private IActivityDao activityDao;
 
@@ -39,11 +45,17 @@ public class ActivityRepository implements IActivityRepository {
     @Resource
     private IUserTakeActivityCountDao userTakeActivityCountDao;
 
+    @Resource
+    private RedisUtil redisUtil;
+
     @Override
     public void addActivity(ActivityVO activity) {
         Activity req = new Activity();
         BeanUtils.copyProperties(activity, req);
         activityDao.insert(req);
+
+        // 设置活动库存 KEY
+        redisUtil.set(Constants.RedisKey.KEY_LOTTERY_ACTIVITY_STOCK_COUNT(activity.getActivityId()), 0);
     }
 
     @Override
@@ -96,6 +108,9 @@ public class ActivityRepository implements IActivityRepository {
         // 查询活动信息
         Activity activity = activityDao.queryActivityById(req.getActivityId());
 
+        // 从缓存中获取库存
+        Object usedStockCountObj = redisUtil.get(Constants.RedisKey.KEY_LOTTERY_ACTIVITY_STOCK_COUNT(req.getActivityId()));
+
         // 查询领取次数
         UserTakeActivityCount userTakeActivityCountReq = new UserTakeActivityCount();
         userTakeActivityCountReq.setuId(req.getuId());
@@ -110,7 +125,8 @@ public class ActivityRepository implements IActivityRepository {
         activityBillVO.setBeginDateTime(activity.getBeginDateTime());
         activityBillVO.setEndDateTime(activity.getEndDateTime());
         activityBillVO.setTakeCount(activity.getTakeCount());
-        activityBillVO.setStockSurplusCount(activity.getStockSurplusCount());
+        activityBillVO.setStockCount(activity.getStockCount());
+        activityBillVO.setStockSurplusCount(null == usedStockCountObj ? activity.getStockSurplusCount() : Integer.parseInt(String.valueOf(usedStockCountObj)));
         activityBillVO.setStrategyId(activity.getStrategyId());
         activityBillVO.setState(activity.getState());
         activityBillVO.setUserTakeLeftCount(null == userTakeActivityCount ? null : userTakeActivityCount.getLeftCount());
@@ -193,4 +209,50 @@ public class ActivityRepository implements IActivityRepository {
         activityDao.updateActivity(activity);
     }
 
+
+    @Override
+    public StockResult subtractionActivityStockByRedis(String uId, Long activityId, Integer stockCount) {
+
+        // 1. 获取抽奖活动库存 Key
+        String stockKey = Constants.RedisKey.KEY_LOTTERY_ACTIVITY_STOCK_COUNT(activityId);
+
+        // 2. 扣减库存，目前占用库存数【以增代减】
+        Integer stockUsedCount = (int) redisUtil.incr(stockKey, 1);
+
+        // 3. 超出库存判断，进行恢复原始库存
+        if (stockUsedCount > stockCount) {
+            redisUtil.decr(stockKey, 1);
+            return new StockResult(Constants.ResponseCode.OUT_OF_STOCK.getCode(), Constants.ResponseCode.OUT_OF_STOCK.getInfo());
+        }
+
+        // 4. 以活动库存占用编号，生成对应加锁Key，细化锁粒度
+        String stockTokenKey = Constants.RedisKey.KEY_LOTTERY_ACTIVITY_STOCK_COUNT_TOKEN(activityId, stockUsedCount);
+
+        // 5. 使用 Redis.setNx 加一个分布式锁
+        boolean lockToken = redisUtil.setNx(stockTokenKey, 350L);
+        if (!lockToken) {
+            logger.info("抽奖活动: {} 用户秒杀: {} 扣减库存，分布式锁失败: {}", activityId, uId, stockTokenKey);
+            return new StockResult(Constants.ResponseCode.ERR_TOKEN.getCode(), Constants.ResponseCode.ERR_TOKEN.getInfo());
+        }
+
+        return new StockResult(Constants.ResponseCode.SUCCESS.getCode(), Constants.ResponseCode.SUCCESS.getInfo(), stockTokenKey, stockCount - stockUsedCount);
+    }
+
+    @Override
+    public void recoverActivityCacheStockByRedis(Long activityId, String tokenKey, String code) {
+        // 删除分布式锁 Key
+        redisUtil.del(tokenKey);
+    }
+
+    @Override
+    public Long queryActivityByStrategyId(Long strategyId) {
+        return activityDao.queryActivityByStrategyId(strategyId);
+    }
+
+    @Override
+    public Long queryUserLeftCount(String uId) {
+        return userTakeActivityCountDao.queryUserLeftCount(uId);
+    }
+
+
 }

lottery-infrastructure/src/main/java/cn/happy/lottery/infrastructure/repository/AwardRepository.java

 package cn.happy.lottery.infrastructure.repository;
 
+import cn.happy.lottery.domain.activity.model.vo.AwardVO;
+import cn.happy.lottery.domain.activity.model.vo.StrategyDetailVO;
+import cn.happy.lottery.domain.award.model.aggregates.AwardInfoLimitPageRich;
+import cn.happy.lottery.domain.award.model.req.AwardInfoLimitPageReq;
+import cn.happy.lottery.domain.award.model.req.AwardReq;
 import cn.happy.lottery.domain.award.repository.IAwardRepository;
+import cn.happy.lottery.domain.strategy.model.aggregates.StrategyDetailInfoLimitPageRich;
+import cn.happy.lottery.infrastructure.dao.IAwardDao;
 import cn.happy.lottery.infrastructure.dao.IUserStrategyExportDao;
+import cn.happy.lottery.infrastructure.po.Award;
+import cn.happy.lottery.infrastructure.po.StrategyDetail;
 import cn.happy.lottery.infrastructure.po.UserStrategyExport;
+import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Component;
 import org.springframework.stereotype.Repository;
 
 import javax.annotation.Resource;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * @author Happy
@@ -19,6 +31,9 @@ public class AwardRepository implements IAwardRepository {
     @Resource
     private IUserStrategyExportDao userStrategyExportDao;
 
+    @Resource
+    private IAwardDao awardDao;
+
     @Override
     public void updateUserAwardState(String uId, Long orderId, String awardId, Integer grantState) {
         UserStrategyExport userStrategyExport = new UserStrategyExport();
@@ -29,4 +44,40 @@ public class AwardRepository implements IAwardRepository {
         userStrategyExportDao.updateUserAwardState(userStrategyExport);
     }
 
+    @Override
+    public AwardInfoLimitPageRich queryAwardInfoLimitPage(AwardInfoLimitPageReq req) {
+        Long count = awardDao.queryAwardInfoCount(req);
+        List<Award> list = awardDao.queryAwardInfoList(req);
+
+        List<AwardVO> awardVOList = new ArrayList<>();
+        for (Award award : list) {
+            AwardVO awardVO = new AwardVO();
+            BeanUtils.copyProperties(award, awardVO);
+            awardVOList.add(awardVO);
+        }
+
+        return new AwardInfoLimitPageRich(count, awardVOList);
+    }
+
+    @Override
+    public void createAward(AwardReq awardReq) {
+        Award award = new Award();
+        BeanUtils.copyProperties(awardReq.getAwardVO(), award);
+        awardDao.insert(award);
+    }
+
+    @Override
+    public void deleteAward(AwardReq awardReq) {
+        Award award = new Award();
+        BeanUtils.copyProperties(awardReq.getAwardVO(), award);
+        awardDao.delete(award);
+    }
+
+    @Override
+    public void updateAward(AwardReq awardReq) {
+        Award award = new Award();
+        BeanUtils.copyProperties(awardReq.getAwardVO(), award);
+        awardDao.update(award);
+    }
+
 }

lottery-infrastructure/src/main/java/cn/happy/lottery/infrastructure/repository/StrategyRepository.java

 package cn.happy.lottery.infrastructure.repository;
 
+import cn.happy.lottery.common.Result;
+import cn.happy.lottery.domain.activity.model.aggregates.ActivityInfoLimitPageRich;
+import cn.happy.lottery.domain.activity.model.vo.StrategyDetailVO;
+import cn.happy.lottery.domain.activity.model.vo.StrategyVO;
+import cn.happy.lottery.domain.strategy.model.aggregates.StrategyDetailInfoLimitPageRich;
+import cn.happy.lottery.domain.strategy.model.aggregates.StrategyInfoLimitPageRich;
 import cn.happy.lottery.domain.strategy.model.aggregates.StrategyRich;
+import cn.happy.lottery.domain.strategy.model.req.StrategyDetailReq;
+import cn.happy.lottery.domain.strategy.model.req.StrategyInfoLimitPageReq;
+import cn.happy.lottery.domain.strategy.model.req.StrategyReq;
 import cn.happy.lottery.domain.strategy.model.vo.AwardBriefVO;
 import cn.happy.lottery.domain.strategy.model.vo.StrategyBriefVO;
 import cn.happy.lottery.domain.strategy.model.vo.StrategyDetailBriefVO;
@@ -12,7 +21,6 @@ import cn.happy.lottery.infrastructure.po.Award;
 import cn.happy.lottery.infrastructure.po.Strategy;
 import cn.happy.lottery.infrastructure.po.StrategyDetail;
 import org.springframework.beans.BeanUtils;
-import org.springframework.stereotype.Component;
 import org.springframework.stereotype.Repository;
 
 import javax.annotation.Resource;
@@ -82,4 +90,76 @@ public class StrategyRepository implements IStrategyRepository {
         return count == 1;
     }
 
+    @Override
+    public StrategyInfoLimitPageRich queryStrategyInfoLimitPage(StrategyInfoLimitPageReq req) {
+        Long count = strategyDao.queryStrategyInfoCount(req);
+        List<Strategy> list = strategyDao.queryStrategyInfoList(req);
+
+        List<StrategyVO> strategyVOList = new ArrayList<>();
+        for (Strategy strategy : list) {
+            StrategyVO strategyVO = new StrategyVO();
+            BeanUtils.copyProperties(strategy, strategyVO);
+            strategyVOList.add(strategyVO);
+        }
+
+        return new StrategyInfoLimitPageRich(count, strategyVOList);
+    }
+
+    @Override
+    public void createStrategy(StrategyVO strategyVO) {
+        Strategy strategy = new Strategy();
+        BeanUtils.copyProperties(strategyVO, strategy);
+        strategyDao.insert(strategy);
+    }
+
+    @Override
+    public void deleteStrategy(Long strategyId) {
+        strategyDao.deleteStrategyById(strategyId);
+        strategyDetailDao.deleteStrategyDetailById(strategyId);
+    }
+
+    @Override
+    public void updateStrategy(StrategyVO strategyVO) {
+        Strategy strategy = new Strategy();
+        BeanUtils.copyProperties(strategyVO, strategy);
+
+        strategyDao.updateStrategyById(strategy);
+    }
+
+    @Override
+    public StrategyDetailInfoLimitPageRich queryStrategyDetailInfoLimitPage(StrategyInfoLimitPageReq req) {
+        Long count = strategyDetailDao.queryStrategyDetailInfoCount(req);
+        List<StrategyDetail> list = strategyDetailDao.queryStrategyDetailInfoList(req);
+
+        List<StrategyDetailVO> strategyDetailVOList = new ArrayList<>();
+        for (StrategyDetail strategyDetail : list) {
+            StrategyDetailVO strategyDetailVO = new StrategyDetailVO();
+            BeanUtils.copyProperties(strategyDetail, strategyDetailVO);
+            strategyDetailVOList.add(strategyDetailVO);
+        }
+
+        return new StrategyDetailInfoLimitPageRich(count, strategyDetailVOList);
+    }
+
+    @Override
+    public void createStrategyDetail(StrategyDetailReq strategyDetailReq) {
+        StrategyDetail strategyDetail = new StrategyDetail();
+        BeanUtils.copyProperties(strategyDetailReq.getStrategyDetailVO(), strategyDetail);
+        strategyDetailDao.insert(strategyDetail);
+    }
+
+    @Override
+    public void deleteStrategyDetail(StrategyDetailReq strategyDetailReq) {
+        StrategyDetail strategyDetail = new StrategyDetail();
+        BeanUtils.copyProperties(strategyDetailReq.getStrategyDetailVO(), strategyDetail);
+        strategyDetailDao.deleteStrategyDetail(strategyDetail);
+    }
+
+    @Override
+    public void updateStrategyDetail(StrategyDetailReq strategyDetailReq) {
+        StrategyDetail strategyDetail = new StrategyDetail();
+        BeanUtils.copyProperties(strategyDetailReq.getStrategyDetailVO(), strategyDetail);
+        strategyDetailDao.updateStrategyDetailById(strategyDetail);
+    }
+
 }

lottery-infrastructure/src/main/java/cn/happy/lottery/infrastructure/repository/UserTakeActivityRepository.java

 package cn.happy.lottery.infrastructure.repository;
 
 import cn.happy.lottery.common.Constants;
+import cn.happy.lottery.domain.activity.model.vo.ActivityPartakeRecordVO;
 import cn.happy.lottery.domain.activity.model.vo.DrawOrderVO;
 import cn.happy.lottery.domain.activity.model.vo.InvoiceVO;
 import cn.happy.lottery.domain.activity.model.vo.UserTakeActivityVO;
 import cn.happy.lottery.domain.activity.repository.IUserTakeActivityRepository;
+import cn.happy.lottery.infrastructure.dao.IActivityDao;
 import cn.happy.lottery.infrastructure.dao.IUserStrategyExportDao;
 import cn.happy.lottery.infrastructure.dao.IUserTakeActivityCountDao;
 import cn.happy.lottery.infrastructure.dao.IUserTakeActivityDao;
+import cn.happy.lottery.infrastructure.po.Activity;
 import cn.happy.lottery.infrastructure.po.UserStrategyExport;
 import cn.happy.lottery.infrastructure.po.UserTakeActivity;
 import cn.happy.lottery.infrastructure.po.UserTakeActivityCount;
@@ -27,6 +30,9 @@ import java.util.List;
 @Repository
 public class UserTakeActivityRepository implements IUserTakeActivityRepository {
 
+    @Resource
+    private IActivityDao activityDao;
+
     @Resource
     private IUserTakeActivityCountDao userTakeActivityCountDao;
 
@@ -65,7 +71,7 @@ public class UserTakeActivityRepository implements IUserTakeActivityRepository {
         userTakeActivity.setTakeDate(takeDate);
 
         if (null == userTakeLeftCount) {
-            userTakeActivity.setTakeCount(1);
+            userTakeActivity.setTakeCount(0);
         } else {
             userTakeActivity.setTakeCount(takeCount - userTakeLeftCount);
         }
@@ -159,4 +165,12 @@ public class UserTakeActivityRepository implements IUserTakeActivityRepository {
         }
         return invoiceVOList;
     }
+
+    @Override
+    public void updateActivityStock(ActivityPartakeRecordVO activityPartakeRecordVO) {
+        Activity activity = new Activity();
+        activity.setActivityId(activityPartakeRecordVO.getActivityId());
+        activity.setStockSurplusCount(activityPartakeRecordVO.getStockSurplusCount());
+        activityDao.updateActivityStock(activity);
+    }
 }

lottery-infrastructure/src/main/java/cn/happy/lottery/infrastructure/util/RedisUtil.java

+package cn.happy.lottery.infrastructure.util;
+
+import org.springframework.data.redis.core.BoundListOperations;
+import org.springframework.data.redis.core.RedisCallback;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Component;
+import org.springframework.util.CollectionUtils;
+
+import javax.annotation.Resource;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @author: happy
+ * @date: 2022/4/6
+ * @description: Redis 工具类
+ */
+@Component
+public class RedisUtil {
+
+    @Resource
+    private RedisTemplate<String, Object> redisTemplate;
+
+    public RedisUtil(RedisTemplate<String, Object> redisTemplate) {
+        this.redisTemplate = redisTemplate;
+    }
+
+    /**
+     * 指定缓存失效时间
+     *
+     * @param key  键
+     * @param time 时间(秒)
+     * @return
+     */
+    public boolean expire(String key, long time) {
+        try {
+            if (time > 0) {
+                redisTemplate.expire(key, time, TimeUnit.SECONDS);
+            }
+            return true;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    /**
+     * 根据key 获取过期时间
+     *
+     * @param key 键 不能为null
+     * @return 时间(秒) 返回0代表为永久有效
+     */
+    public long getExpire(String key) {
+        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
+    }
+
+    /**
+     * 判断key是否存在
+     *
+     * @param key 键
+     * @return true 存在 false不存在
+     */
+    public boolean hasKey(String key) {
+        try {
+            return redisTemplate.hasKey(key);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    /**
+     * 删除缓存
+     *
+     * @param key 可以传一个值 或多个
+     */
+    @SuppressWarnings("unchecked")
+    public void del(String... key) {
+        if (key != null && key.length > 0) {
+            if (key.length == 1) {
+                redisTemplate.delete(key[0]);
+            } else {
+                redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
+            }
+        }
+    }
+
+    //============================String=============================
+
+    /**
+     * 普通缓存获取
+     *
+     * @param key 键
+     * @return 值
+     */
+    public Object get(String key) {
+        return key == null ? null : redisTemplate.opsForValue().get(key);
+    }
+
+    /**
+     * 普通缓存放入
+     *
+     * @param key   键
+     * @param value 值
+     * @return true成功 false失败
+     */
+    public boolean set(String key, Object value) {
+        try {
+            redisTemplate.opsForValue().set(key, value);
+            return true;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    /**
+     * 普通缓存放入并设置时间
+     *
+     * @param key   键
+     * @param value 值
+     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
+     * @return true成功 false 失败
+     */
+    public boolean set(String key, Object value, long time) {
+        try {
+            if (time > 0) {
+                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
+            } else {
+                set(key, value);
+            }
+            return true;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    /**
+     * 分布式锁
+     * @param key               锁住的key
+     * @param lockExpireMils    锁住的时长。如果超时未解锁，视为加锁线程死亡，其他线程可夺取锁
+     * @return
+     */
+    public boolean setNx(String key, Long lockExpireMils) {
+        return (boolean) redisTemplate.execute((RedisCallback) connection -> {
+            //获取锁
+            return connection.setNX(key.getBytes(), String.valueOf(System.currentTimeMillis() + lockExpireMils + 1).getBytes());
+        });
+    }
+
+    /**
+     * 递增
+     *
+     * @param key   键
+     * @param delta 要增加几(大于0)
+     * @return
+     */
+    public long incr(String key, long delta) {
+        if (delta < 0) {
+            throw new RuntimeException("递增因子必须大于0");
+        }
+        return redisTemplate.opsForValue().increment(key, delta);
+    }
+
+    /**
+     * 递减
+     *
+     * @param key   键
+     * @param delta 要减少几(小于0)
+     * @return
+     */
+    public long decr(String key, long delta) {
+        if (delta < 0) {
+            throw new RuntimeException("递减因子必须大于0");
+        }
+        return redisTemplate.opsForValue().increment(key, -delta);
+    }
+
+    //================================Map=================================
+
+    /**
+     * HashGet
+     *
+     * @param key  键 不能为null
+     * @param item 项 不能为null
+     * @return 值
+     */
+    public Object hget(String key, String item) {
+        return redisTemplate.opsForHash().get(key, item);
+    }
+
+    /**
+     * 获取hashKey对应的所有键值
+     *
+     * @param key 键
+     * @return 对应的多个键值
+     */
+    public Map<Object, Object> hmget(String key) {
+        return redisTemplate.opsForHash().entries(key);
+    }
+
+    /**
+     * HashSet
+     *
+     * @param key 键
+     * @param map 对应多个键值
+     * @return true 成功 false 失败
+     */
+    public boolean hmset(String key, Map<String, Object> map) {
+        try {
+            redisTemplate.opsForHash().putAll(key, map);
+            return true;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    /**
+     * HashSet 并设置时间
+     *
+     * @param key  键
+     * @param map  对应多个键值
+     * @param time 时间(秒)
+     * @return true成功 false失败
+     */
+    public boolean hmset(String key, Map<String, Object> map, long time) {
+        try {
+            redisTemplate.opsForHash().putAll(key, map);
+            if (time > 0) {
+                expire(key, time);
+            }
+            return true;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    /**
+     * 向一张hash表中放入数据,如果不存在将创建
+     *
+     * @param key   键
+     * @param item  项
+     * @param value 值
+     * @return true 成功 false失败
+     */
+    public boolean hset(String key, String item, Object value) {
+        try {
+            redisTemplate.opsForHash().put(key, item, value);
+            return true;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    /**
+     * 向一张hash表中放入数据,如果不存在将创建
+     *
+     * @param key   键
+     * @param item  项
+     * @param value 值
+     * @param time  时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
+     * @return true 成功 false失败
+     */
+    public boolean hset(String key, String item, Object value, long time) {
+        try {
+            redisTemplate.opsForHash().put(key, item, value);
+            if (time > 0) {
+                expire(key, time);
+            }
+            return true;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    /**
+     * 删除hash表中的值
+     *
+     * @param key  键 不能为null
+     * @param item 项 可以使多个 不能为null
+     */
+    public void hdel(String key, Object... item) {
+        redisTemplate.opsForHash().delete(key, item);
+    }
+
+    /**
+     * 判断hash表中是否有该项的值
+     *
+     * @param key  键 不能为null
+     * @param item 项 不能为null
+     * @return true 存在 false不存在
+     */
+    public boolean hHasKey(String key, String item) {
+        return redisTemplate.opsForHash().hasKey(key, item);
+    }
+
+    /**
+     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
+     *
+     * @param key  键
+     * @param item 项
+     * @param by   要增加几(大于0)
+     * @return
+     */
+    public double hincr(String key, String item, double by) {
+        return redisTemplate.opsForHash().increment(key, item, by);
+    }
+
+    /**
+     * hash递减
+     *
+     * @param key  键
+     * @param item 项
+     * @param by   要减少记(小于0)
+     * @return
+     */
+    public double hdecr(String key, String item, double by) {
+        return redisTemplate.opsForHash().increment(key, item, -by);
+    }
+
+    //============================set=============================
+
+    /**
+     * 根据key获取Set中的所有值
+     *
+     * @param key 键
+     * @return
+     */
+    public Set<Object> sGet(String key) {
+        try {
+            return redisTemplate.opsForSet().members(key);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    /**
+     * 根据value从一个set中查询,是否存在
+     *
+     * @param key   键
+     * @param value 值
+     * @return true 存在 false不存在
+     */
+    public boolean sHasKey(String key, Object value) {
+        try {
+            return redisTemplate.opsForSet().isMember(key, value);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    /**
+     * 将数据放入set缓存
+     *
+     * @param key    键
+     * @param values 值 可以是多个
+     * @return 成功个数
+     */
+    public long sSet(String key, Object... values) {
+        try {
+            return redisTemplate.opsForSet().add(key, values);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return 0;
+        }
+    }
+
+    /**
+     * 将set数据放入缓存
+     *
+     * @param key    键
+     * @param time   时间(秒)
+     * @param values 值 可以是多个
+     * @return 成功个数
+     */
+    public long sSetAndTime(String key, long time, Object... values) {
+        try {
+            Long count = redisTemplate.opsForSet().add(key, values);
+            if (time > 0) {
+                expire(key, time);
+            }
+            return count;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return 0;
+        }
+    }
+
+    /**
+     * 获取set缓存的长度
+     *
+     * @param key 键
+     * @return
+     */
+    public long sGetSetSize(String key) {
+        try {
+            return redisTemplate.opsForSet().size(key);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return 0;
+        }
+    }
+
+    /**
+     * 移除值为value的
+     *
+     * @param key    键
+     * @param values 值 可以是多个
+     * @return 移除的个数
+     */
+    public long setRemove(String key, Object... values) {
+        try {
+            Long count = redisTemplate.opsForSet().remove(key, values);
+            return count;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return 0;
+        }
+    }
+    //===============================list=================================
+
+    /**
+     * 获取list缓存的内容
+     *
+     * @param key   键
+     * @param start 开始
+     * @param end   结束  0 到 -1代表所有值
+     * @return
+     */
+    public List<Object> lGet(String key, long start, long end) {
+        try {
+            return redisTemplate.opsForList().range(key, start, end);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    /**
+     * 获取list缓存的长度
+     *
+     * @param key 键
+     * @return
+     */
+    public long lGetListSize(String key) {
+        try {
+            return redisTemplate.opsForList().size(key);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return 0;
+        }
+    }
+
+    /**
+     * 通过索引 获取list中的值
+     *
+     * @param key   键
+     * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
+     * @return
+     */
+    public Object lGetIndex(String key, long index) {
+        try {
+            return redisTemplate.opsForList().index(key, index);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    /**
+     * 将list放入缓存
+     *
+     * @param key   键
+     * @param value 值
+     * @return
+     */
+    public boolean lSet(String key, Object value) {
+        try {
+            redisTemplate.opsForList().rightPush(key, value);
+            return true;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    /**
+     * 将list放入缓存
+     *
+     * @param key   键
+     * @param value 值
+     * @param time  时间(秒)
+     * @return
+     */
+    public boolean lSet(String key, Object value, long time) {
+        try {
+            redisTemplate.opsForList().rightPush(key, value);
+            if (time > 0) {
+                expire(key, time);
+            }
+            return true;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    /**
+     * 将list放入缓存
+     *
+     * @param key   键
+     * @param value 值
+     * @return
+     */
+    public boolean lSet(String key, List<Object> value) {
+        try {
+            redisTemplate.opsForList().rightPushAll(key, value);
+            return true;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    /**
+     * 将list放入缓存
+     *
+     * @param key   键
+     * @param value 值
+     * @param time  时间(秒)
+     * @return
+     */
+    public boolean lSet(String key, List<Object> value, long time) {
+        try {
+            redisTemplate.opsForList().rightPushAll(key, value);
+            if (time > 0) {
+                expire(key, time);
+            }
+            return true;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    /**
+     * 根据索引修改list中的某条数据
+     *
+     * @param key   键
+     * @param index 索引
+     * @param value 值
+     * @return
+     */
+    public boolean lUpdateIndex(String key, long index, Object value) {
+        try {
+            redisTemplate.opsForList().set(key, index, value);
+            return true;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    /**
+     * 移除N个值为value
+     *
+     * @param key   键
+     * @param count 移除多少个
+     * @param value 值
+     * @return 移除的个数
+     */
+    public long lRemove(String key, long count, Object value) {
+        try {
+            Long remove = redisTemplate.opsForList().remove(key, count, value);
+            return remove;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return 0;
+        }
+    }
+
+    /**
+     * 模糊查询获取key值
+     *
+     * @param pattern
+     * @return
+     */
+    public Set keys(String pattern) {
+        return redisTemplate.keys(pattern);
+    }
+
+    /**
+     * 使用Redis的消息队列
+     *
+     * @param channel
+     * @param message 消息内容
+     */
+    public void convertAndSend(String channel, Object message) {
+        redisTemplate.convertAndSend(channel, message);
+    }
+
+
+    //=========BoundListOperations 用法 start============
+
+    /**
+     * 将数据添加到Redis的list中（从右边添加）
+     *
+     * @param listKey
+     * @param timeout 有效时间
+     * @param unit    时间类型
+     * @param values  待添加的数据
+     */
+    public void addToListRight(String listKey, long timeout, TimeUnit unit, Object... values) {
+        //绑定操作
+        BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
+        //插入数据
+        boundValueOperations.rightPushAll(values);
+        //设置过期时间
+        boundValueOperations.expire(timeout, unit);
+    }
+
+    /**
+     * 根据起始结束序号遍历Redis中的list
+     *
+     * @param listKey
+     * @param start   起始序号
+     * @param end     结束序号
+     * @return
+     */
+    public List<Object> rangeList(String listKey, long start, long end) {
+        //绑定操作
+        BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
+        //查询数据
+        return boundValueOperations.range(start, end);
+    }
+
+    /**
+     * 弹出右边的值 --- 并且移除这个值
+     *
+     * @param listKey
+     */
+    public Object rightPop(String listKey) {
+        //绑定操作
+        BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
+        return boundValueOperations.rightPop();
+    }
+
+    //=========BoundListOperations 用法 End============
+
+}

lottery-interfaces/src/main/java/cn/happy/lottery/interfaces/assembler/AwardMapping.java

 package cn.happy.lottery.interfaces.assembler;
 
+import cn.happy.lottery.domain.activity.model.vo.AwardVO;
 import cn.happy.lottery.domain.strategy.model.vo.DrawAwardVO;
 import cn.happy.lottery.rpc.activity.booth.dto.AwardDTO;
 import org.mapstruct.Mapper;
@@ -12,12 +13,11 @@ import org.mapstruct.ReportingPolicy;
  * @date 2022/3/3
  */
 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE, unmappedSourcePolicy = ReportingPolicy.IGNORE)
-public interface AwardMapping extends IMapping<DrawAwardVO, AwardDTO> {
+public interface AwardMapping extends IMapping<AwardVO, AwardDTO> {
 
-    @Mapping(target = "userId", source = "uId")
     @Override
-    AwardDTO sourceToTarget(DrawAwardVO var1);
+    AwardDTO sourceToTarget(AwardVO var1);
 
     @Override
-    DrawAwardVO targetToSource(AwardDTO var1);
+    AwardVO targetToSource(AwardDTO var1);
 }

lottery-interfaces/src/main/java/cn/happy/lottery/interfaces/assembler/DrawAwardMapping.java

+package cn.happy.lottery.interfaces.assembler;
+
+import cn.happy.lottery.domain.strategy.model.vo.DrawAwardVO;
+import cn.happy.lottery.rpc.activity.booth.dto.AwardDTO;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import org.mapstruct.ReportingPolicy;
+
+/**
+ * @author Happy
+ * @description:
+ * @date 2022/3/3
+ */
+@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE, unmappedSourcePolicy = ReportingPolicy.IGNORE)
+public interface DrawAwardMapping extends IMapping<DrawAwardVO, AwardDTO> {
+
+    @Mapping(target = "userId", source = "uId")
+    @Override
+    AwardDTO sourceToTarget(DrawAwardVO var1);
+
+    @Override
+    DrawAwardVO targetToSource(AwardDTO var1);
+}

lottery-interfaces/src/main/java/cn/happy/lottery/interfaces/assembler/StrategyDetailMapping.java

+package cn.happy.lottery.interfaces.assembler;
+
+import cn.happy.lottery.domain.activity.model.vo.StrategyDetailVO;
+import cn.happy.lottery.domain.activity.model.vo.StrategyVO;
+import cn.happy.lottery.rpc.strategy.deploy.dto.StrategyDTO;
+import cn.happy.lottery.rpc.strategyDetail.deploy.dto.StrategyDetailDTO;
+import org.mapstruct.Mapper;
+import org.mapstruct.ReportingPolicy;
+
+/**
+ * @author Happy
+ * @description:
+ * @date 2022/3/3
+ */
+@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE, unmappedSourcePolicy = ReportingPolicy.IGNORE)
+public interface StrategyDetailMapping extends IMapping<StrategyDetailVO, StrategyDetailDTO> {
+
+    @Override
+    StrategyDetailDTO sourceToTarget(StrategyDetailVO var1);
+
+    @Override
+    StrategyDetailVO targetToSource(StrategyDetailDTO var1);
+}

lottery-interfaces/src/main/java/cn/happy/lottery/interfaces/assembler/StrategyMapping.java

+package cn.happy.lottery.interfaces.assembler;
+
+import cn.happy.lottery.domain.activity.model.vo.StrategyVO;
+import cn.happy.lottery.rpc.strategy.deploy.dto.StrategyDTO;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import org.mapstruct.ReportingPolicy;
+
+/**
+ * @author Happy
+ * @description:
+ * @date 2022/3/3
+ */
+@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE, unmappedSourcePolicy = ReportingPolicy.IGNORE)
+public interface StrategyMapping extends IMapping<StrategyVO, StrategyDTO> {
+
+    @Override
+    StrategyDTO sourceToTarget(StrategyVO var1);
+
+    @Override
+    StrategyVO targetToSource(StrategyDTO var1);
+}

lottery-interfaces/src/main/java/cn/happy/lottery/interfaces/facade/LotteryActivityBooth.java

@@ -138,6 +138,13 @@ public class LotteryActivityBooth implements ILotteryActivityBooth {
             activityReq.setActivityId(ruleQuantificationCrowdResult.getActivityId());
             ActivityConfigRich activityConfigRich = activityDeploy.queryActivityInfo(activityReq);
 
+            // 更新个人可参与次数
+            Long leftCount = activityDeploy.queryUserLeftCount(req.getuId());
+            if (null != leftCount) {
+                activityConfigRich.getActivity().setLeftCount(leftCount);
+            }
+
+
             // 数据转换
             ActivityDTO activityDTO = activityMapping.sourceToTarget(activityConfigRich.getActivity());
             List<AwardVO> awardList = activityConfigRich.getAwardList();

lottery-interfaces/src/main/java/cn/happy/lottery/interfaces/facade/LotteryActivityDeploy.java

 package cn.happy.lottery.interfaces.facade;
 
 import cn.happy.lottery.application.process.deploy.IActivityDeployProcess;
+import cn.happy.lottery.common.Constants;
 import cn.happy.lottery.common.Result;
 import cn.happy.lottery.domain.activity.model.aggregates.ActivityInfoLimitPageRich;
 import cn.happy.lottery.domain.activity.model.req.ActivityInfoLimitPageReq;
@@ -83,6 +84,7 @@ public class LotteryActivityDeploy implements ILotteryActivityDeploy {
             ActivityReq activityReq = new ActivityReq();
             BeanUtils.copyProperties(activityRpcReq, activityReq);
             activityDeploy.createActivity(activityReq);
+            logger.info("创建活动成功，reqStr：{}", JSON.toJSONString(activityRpcReq));
 
             return new ActivityRes(Result.buildSuccessResult());
         } catch (ClassCastException e) {
@@ -102,10 +104,14 @@ public class LotteryActivityDeploy implements ILotteryActivityDeploy {
 
             ActivityReq activityReq = new ActivityReq();
             activityReq.setActivityId(activityRpcReq.getActivityId());
-            activityDeploy.deleteActivity(activityReq);
+            Result res = activityDeploy.deleteActivity(activityReq);
+            if (!Constants.ResponseCode.SUCCESS.getCode().equals(res.getCode())) {
+                logger.info("删除活动失败，activityId：{}, reason: {}", activityRpcReq.getActivityId(), res.getInfo());
+                return new ActivityRes(res);
+            }
 
             logger.info("删除活动成功，activityId：{}", activityRpcReq.getActivityId());
-            return new ActivityRes(Result.buildSuccessResult());
+            return new ActivityRes(res);
         } catch (Exception e) {
             logger.error("删除活动失败，activityId：{}", activityRpcReq.getActivityId(), e);
             return new ActivityRes(Result.buildErrorResult());
@@ -120,7 +126,11 @@ public class LotteryActivityDeploy implements ILotteryActivityDeploy {
 
             ActivityReq activityReq = new ActivityReq();
             BeanUtils.copyProperties(activityRpcReq, activityReq);
-            activityDeploy.updateActivity(activityReq);
+            Result res = activityDeploy.updateActivity(activityReq);
+            if (!Constants.ResponseCode.SUCCESS.getCode().equals(res.getCode())) {
+                logger.info("修改活动动失败，activityId：{}, reason: {}", activityRpcReq.getActivityId(), res.getInfo());
+                return new ActivityRes(res);
+            }
 
             return new ActivityRes(Result.buildSuccessResult());
         } catch (ClassCastException e) {

lottery-interfaces/src/main/java/cn/happy/lottery/interfaces/facade/LotteryAwardDeploy.java

+package cn.happy.lottery.interfaces.facade;
+
+import cn.happy.lottery.application.process.deploy.IAwardDeployProcess;
+import cn.happy.lottery.common.Result;
+import cn.happy.lottery.domain.activity.model.vo.AwardVO;
+import cn.happy.lottery.domain.award.model.aggregates.AwardInfoLimitPageRich;
+import cn.happy.lottery.domain.award.model.req.AwardInfoLimitPageReq;
+import cn.happy.lottery.domain.award.model.req.AwardReq;
+import cn.happy.lottery.interfaces.assembler.IMapping;
+import cn.happy.lottery.rpc.activity.booth.dto.AwardDTO;
+import cn.happy.lottery.rpc.award.deploy.ILotteryAwardDeploy;
+import cn.happy.lottery.rpc.award.deploy.req.AwardPageReq;
+import cn.happy.lottery.rpc.award.deploy.req.AwardRpcReq;
+import cn.happy.lottery.rpc.award.deploy.res.AwardRes;
+import com.alibaba.fastjson.JSON;
+import org.apache.dubbo.config.annotation.Service;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.BeanUtils;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+@Service(version = "1.0.0", timeout = 6000)
+@Component
+public class LotteryAwardDeploy implements ILotteryAwardDeploy {
+
+    private Logger logger = LoggerFactory.getLogger(LotteryAwardDeploy.class);
+
+    @Resource
+    private IAwardDeployProcess awardDeploy;
+
+    @Resource
+    private IMapping<AwardVO, AwardDTO> awardMapping;
+
+    @Override
+    public AwardRes queryAwardListByPageForErp(AwardPageReq req) {
+        try {
+            logger.info("奖品分页数据查询开始 erpID: {}", req.getErpId());
+
+            //1. 包装入参
+            AwardInfoLimitPageReq awardInfoLimitPageReq = new AwardInfoLimitPageReq(req.getPage(), req.getRows());
+            awardInfoLimitPageReq.setAwardId(req.getAwardId());
+            awardInfoLimitPageReq.setAwardName(req.getAwardName());
+
+            // 2. 查询结果
+            AwardInfoLimitPageRich awardInfoLimitPageRich = awardDeploy.queryAwardInfoLimitPage(awardInfoLimitPageReq);
+            Long count = awardInfoLimitPageRich.getCount();
+            List<AwardVO> awardVOList = awardInfoLimitPageRich.getAwardVOList();
+
+            // 3. 转换对象
+            List<AwardDTO> awardDTOList = awardMapping.sourceToTarget(awardVOList);
+
+            // 4. 封装数据
+            AwardRes awardRes = new AwardRes(Result.buildSuccessResult());
+            awardRes.setCount(count);
+            awardRes.setAwardDTOList(awardDTOList);
+
+            logger.info("奖品分页数据查询完成 erpId: {} count: {}", req.getErpId(), count);
+
+            // 5. 返回结果
+            return awardRes;
+        } catch (Exception e) {
+            logger.error("奖品分页数据查询失败 erpID：{} reqStr：{}", req.getErpId(), JSON.toJSON(req), e);
+            return new AwardRes(Result.buildErrorResult());
+        }
+    }
+
+    @Override
+    public AwardRes addAwardForErp(AwardRpcReq awardRpcReq) {
+        try {
+            logger.info("创建奖品开始，reqStr：{}", JSON.toJSONString(awardRpcReq));
+
+            AwardVO awardVO = new AwardVO();
+            BeanUtils.copyProperties(awardRpcReq, awardVO);
+            AwardReq awardReq = new AwardReq(awardVO);
+            awardDeploy.createAward(awardReq);
+            logger.info("创建奖品成功，reqStr：{}", JSON.toJSONString(awardRpcReq));
+
+            return new AwardRes(Result.buildSuccessResult());
+        } catch (ClassCastException e) {
+            logger.error("创建奖品失败，类型转换异常，reqStr：{}", JSON.toJSONString(awardRpcReq), e);
+            return new AwardRes(Result.buildErrorResult());
+        } catch (Exception e) {
+            logger.error("创建奖品配置失败：activityId：{}, reqJson：{}", awardRpcReq.getAwardId(), JSON.toJSONString(awardRpcReq), e);
+            return new AwardRes(Result.buildErrorResult());
+        }
+    }
+
+    @Override
+    public AwardRes deleteAwardForErp(AwardRpcReq awardRpcReq) {
+        try {
+            logger.info("删除奖品开始，reqStr：{}", JSON.toJSONString(awardRpcReq));
+
+            AwardVO awardVO = new AwardVO();
+            BeanUtils.copyProperties(awardRpcReq, awardVO);
+            AwardReq awardReq = new AwardReq(awardVO);
+            awardDeploy.deleteAward(awardReq);
+            logger.info("删除奖品成功，reqStr：{}", JSON.toJSONString(awardRpcReq));
+
+            return new AwardRes(Result.buildSuccessResult());
+        } catch (ClassCastException e) {
+            logger.error("删除奖品失败，类型转换异常，reqStr：{}", JSON.toJSONString(awardRpcReq), e);
+            return new AwardRes(Result.buildErrorResult());
+        } catch (Exception e) {
+            logger.error("删除奖品配置失败：activityId：{}, reqJson：{}", awardRpcReq.getAwardId(), JSON.toJSONString(awardRpcReq), e);
+            return new AwardRes(Result.buildErrorResult());
+        }
+    }
+
+    @Override
+    public AwardRes updateAwardForErp(AwardRpcReq awardRpcReq) {
+        try {
+            logger.info("更新奖品开始，reqStr：{}", JSON.toJSONString(awardRpcReq));
+
+            AwardVO awardVO = new AwardVO();
+            BeanUtils.copyProperties(awardRpcReq, awardVO);
+            AwardReq awardReq = new AwardReq(awardVO);
+            awardDeploy.updateAward(awardReq);
+            logger.info("更新奖品成功，reqStr：{}", JSON.toJSONString(awardRpcReq));
+
+            return new AwardRes(Result.buildSuccessResult());
+        } catch (ClassCastException e) {
+            logger.error("更新奖品失败，类型转换异常，reqStr：{}", JSON.toJSONString(awardRpcReq), e);
+            return new AwardRes(Result.buildErrorResult());
+        } catch (Exception e) {
+            logger.error("更新奖品失败：activityId：{}, reqJson：{}", awardRpcReq.getAwardId(), JSON.toJSONString(awardRpcReq), e);
+            return new AwardRes(Result.buildErrorResult());
+        }
+    }
+}

lottery-interfaces/src/main/java/cn/happy/lottery/interfaces/facade/LotteryStrategyDeploy.java

+package cn.happy.lottery.interfaces.facade;
+
+import cn.happy.lottery.application.process.deploy.IStrategyDeployProcess;
+import cn.happy.lottery.common.Constants;
+import cn.happy.lottery.common.Result;
+import cn.happy.lottery.domain.activity.model.req.ActivityReq;
+import cn.happy.lottery.domain.activity.model.vo.StrategyVO;
+import cn.happy.lottery.domain.strategy.model.aggregates.StrategyInfoLimitPageRich;
+import cn.happy.lottery.domain.strategy.model.req.StrategyInfoLimitPageReq;
+import cn.happy.lottery.domain.strategy.model.req.StrategyReq;
+import cn.happy.lottery.interfaces.assembler.IMapping;
+import cn.happy.lottery.rpc.activity.deploy.res.ActivityRes;
+import cn.happy.lottery.rpc.strategy.ILotteryStrategyDeploy;
+import cn.happy.lottery.rpc.strategy.deploy.dto.StrategyDTO;
+import cn.happy.lottery.rpc.strategy.deploy.req.StrategyPageReq;
+import cn.happy.lottery.rpc.strategy.deploy.req.StrategyRpcReq;
+import cn.happy.lottery.rpc.strategy.deploy.res.StrategyRes;
+import cn.happy.lottery.rpc.strategy.deploy.res.UserStrategyExportRes;
+import com.alibaba.fastjson.JSON;
+import org.apache.dubbo.config.annotation.Service;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.BeanUtils;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+@Service(version = "1.0.0", timeout = 6000)
+@Component
+public class LotteryStrategyDeploy implements ILotteryStrategyDeploy {
+
+    private Logger logger = LoggerFactory.getLogger(LotteryStrategyDeploy.class);
+
+    @Resource
+    private IStrategyDeployProcess strategyDeploy;
+
+    @Resource
+    private IMapping<StrategyVO, StrategyDTO> strategyMapping;
+
+    @Override
+    public StrategyRes queryStrategyListByPageForErp(StrategyPageReq req) {
+        try {
+            logger.info("策略配置分页数据查询开始 erpID: {}", req.getErpId());
+
+            //1. 包装入参
+            StrategyInfoLimitPageReq strategyInfoLimitPageReq = new StrategyInfoLimitPageReq(req.getPage(), req.getRows());
+            strategyInfoLimitPageReq.setStrategyId(req.getStrategyId());
+            strategyInfoLimitPageReq.setStrategyDesc(req.getStrategyDesc());
+
+            // 2. 查询结果
+            StrategyInfoLimitPageRich strategyInfoLimitPageRich = strategyDeploy.queryStrategyInfoLimitPage(strategyInfoLimitPageReq);
+            Long count = strategyInfoLimitPageRich.getCount();
+            List<StrategyVO> strategyVOList = strategyInfoLimitPageRich.getStrategyVOList();
+
+            // 3. 转换对象
+            List<StrategyDTO> strategyDTOList = strategyMapping.sourceToTarget(strategyVOList);
+
+            // 4. 封装数据
+            StrategyRes strategyRes = new StrategyRes(Result.buildSuccessResult());
+            strategyRes.setCount(count);
+            strategyRes.setStrategyDTOList(strategyDTOList);
+
+            logger.info("策略配置分页数据查询完成 erpId: {} count: {}", req.getErpId(), count);
+
+            // 5. 返回结果
+            return strategyRes;
+        } catch (Exception e) {
+            logger.error("策略配置分页数据查询失败 erpID：{} reqStr：{}", req.getErpId(), JSON.toJSON(req), e);
+            return new StrategyRes(Result.buildErrorResult());
+        }
+    }
+
+    @Override
+    public StrategyRes addStrategyForErp(StrategyRpcReq strategyRpcReq) {
+        try {
+            logger.info("创建策略开始，reqStr：{}", JSON.toJSONString(strategyRpcReq));
+
+            // 包装入参
+            StrategyVO strategyVO = new StrategyVO();
+            BeanUtils.copyProperties(strategyRpcReq, strategyVO);
+            StrategyReq strategyReq = new StrategyReq(strategyVO);
+            strategyDeploy.createStrategy(strategyReq);
+
+            logger.info("创建策略成功，reqStr：{}", JSON.toJSONString(strategyRpcReq));
+            return new StrategyRes(Result.buildSuccessResult());
+        } catch (ClassCastException e) {
+            logger.error("创建策略失败，类型转换异常，reqStr：{}", JSON.toJSONString(strategyRpcReq), e);
+            return new StrategyRes(Result.buildErrorResult());
+        } catch (Exception e) {
+            logger.error("创建策略配置失败：strategyId：{}, reqJson：{}", strategyRpcReq.getStrategyId(), JSON.toJSONString(strategyRpcReq), e);
+            return new StrategyRes(Result.buildErrorResult());
+        }
+    }
+
+    @Override
+    public StrategyRes deleteStrategyForErp(StrategyRpcReq strategyRpcReq) {
+        try {
+            logger.info("删除策略开始，reqStr：{}", JSON.toJSONString(strategyRpcReq));
+
+            // 包装入参
+            StrategyVO strategyVO = new StrategyVO();
+            BeanUtils.copyProperties(strategyRpcReq, strategyVO);
+            StrategyReq strategyReq = new StrategyReq(strategyVO);
+            Result res = strategyDeploy.deleteStrategy(strategyReq);
+
+            if (!Constants.ResponseCode.SUCCESS.getCode().equals(res.getCode())) {
+                logger.info("删除策略失败，reqStr：{}, reason: {}", JSON.toJSONString(strategyRpcReq), res.getInfo());
+                return new StrategyRes(res);
+            }
+
+            logger.info("删除策略成功，reqStr：{}", JSON.toJSONString(strategyRpcReq));
+            return new StrategyRes(res);
+        } catch (ClassCastException e) {
+            logger.error("删除策略失败，类型转换异常，reqStr：{}", JSON.toJSONString(strategyRpcReq), e);
+            return new StrategyRes(Result.buildErrorResult());
+        } catch (Exception e) {
+            logger.error("删除策略配置失败：strategyId：{}, reqJson：{}", strategyRpcReq.getStrategyId(), JSON.toJSONString(strategyRpcReq), e);
+            return new StrategyRes(Result.buildErrorResult());
+        }
+    }
+
+    @Override
+    public StrategyRes updateStrategyForErp(StrategyRpcReq strategyRpcReq) {
+        try {
+            logger.info("修改策略开始，reqStr：{}", JSON.toJSONString(strategyRpcReq));
+
+            // 包装入参
+            StrategyVO strategyVO = new StrategyVO();
+            BeanUtils.copyProperties(strategyRpcReq, strategyVO);
+            StrategyReq strategyReq = new StrategyReq(strategyVO);
+            BeanUtils.copyProperties(strategyRpcReq, strategyReq);
+            strategyDeploy.updateStrategy(strategyReq);
+
+            logger.info("修改策略成功，reqStr：{}", JSON.toJSONString(strategyRpcReq));
+            return new StrategyRes(Result.buildSuccessResult());
+        } catch (ClassCastException e) {
+            logger.error("修改策略失败，类型转换异常，reqStr：{}", JSON.toJSONString(strategyRpcReq), e);
+            return new StrategyRes(Result.buildErrorResult());
+        } catch (Exception e) {
+            logger.error("修改策略配置失败：strategyId：{}, reqJson：{}", strategyRpcReq.getStrategyId(), JSON.toJSONString(strategyRpcReq), e);
+            return new StrategyRes(Result.buildErrorResult());
+        }
+    }
+
+    @Override
+    public UserStrategyExportRes queryUserStrategyExport() {
+        try {
+            logger.info("查询用户抽奖策略记录开始");
+
+
+
+            logger.info("查询用户抽奖策略记录结束");
+            return null;
+        } catch (Exception e) {
+            logger.error("查询用户抽奖策略记录失败", e);
+            return new UserStrategyExportRes(Result.buildErrorResult());
+        }
+    }
+}

lottery-interfaces/src/main/java/cn/happy/lottery/interfaces/facade/LotteryStrategyDetailDeploy.java

+package cn.happy.lottery.interfaces.facade;
+
+import cn.happy.lottery.application.process.deploy.IStrategyDeployProcess;
+import cn.happy.lottery.application.process.deploy.IStrategyDetailDeployProcess;
+import cn.happy.lottery.common.Constants;
+import cn.happy.lottery.common.Result;
+import cn.happy.lottery.domain.activity.model.vo.StrategyDetailVO;
+import cn.happy.lottery.domain.activity.model.vo.StrategyVO;
+import cn.happy.lottery.domain.strategy.model.aggregates.StrategyDetailInfoLimitPageRich;
+import cn.happy.lottery.domain.strategy.model.aggregates.StrategyInfoLimitPageRich;
+import cn.happy.lottery.domain.strategy.model.req.StrategyDetailReq;
+import cn.happy.lottery.domain.strategy.model.req.StrategyInfoLimitPageReq;
+import cn.happy.lottery.domain.strategy.model.req.StrategyReq;
+import cn.happy.lottery.infrastructure.po.StrategyDetail;
+import cn.happy.lottery.interfaces.assembler.IMapping;
+import cn.happy.lottery.rpc.strategy.deploy.dto.StrategyDTO;
+import cn.happy.lottery.rpc.strategy.deploy.req.StrategyPageReq;
+import cn.happy.lottery.rpc.strategy.deploy.req.StrategyRpcReq;
+import cn.happy.lottery.rpc.strategy.deploy.res.StrategyRes;
+import cn.happy.lottery.rpc.strategyDetail.deploy.ILotteryStrategyDetailDeploy;
+import cn.happy.lottery.rpc.strategyDetail.deploy.dto.StrategyDetailDTO;
+import cn.happy.lottery.rpc.strategyDetail.deploy.req.StrategyDetailPageReq;
+import cn.happy.lottery.rpc.strategyDetail.deploy.req.StrategyDetailRpcReq;
+import cn.happy.lottery.rpc.strategyDetail.deploy.res.StrategyDetailRes;
+import com.alibaba.fastjson.JSON;
+import org.apache.dubbo.config.annotation.Service;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.BeanUtils;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+@Service(version = "1.0.0", timeout = 6000)
+@Component
+public class LotteryStrategyDetailDeploy implements ILotteryStrategyDetailDeploy {
+
+    private Logger logger = LoggerFactory.getLogger(LotteryStrategyDetailDeploy.class);
+
+    @Resource
+    private IStrategyDetailDeployProcess strategyDetailDeploy;
+
+    @Resource
+    private IMapping<StrategyDetailVO, StrategyDetailDTO> strategyDetailMapping;
+
+    @Override
+    public StrategyDetailRes queryStrategyDetailListByPageForErp(StrategyDetailPageReq req) {
+        try {
+            logger.info("策略详情配置分页数据查询开始 erpID: {}", req.getErpId());
+
+            //1. 包装入参
+            StrategyInfoLimitPageReq strategyInfoLimitPageReq = new StrategyInfoLimitPageReq(req.getPage(), req.getRows());
+            strategyInfoLimitPageReq.setStrategyId(req.getStrategyId());
+
+            // 2. 查询结果
+            StrategyDetailInfoLimitPageRich strategyDetailInfoLimitPageRich = strategyDetailDeploy.queryStrategyDetailInfoLimitPage(strategyInfoLimitPageReq);
+            Long count = strategyDetailInfoLimitPageRich.getCount();
+            List<StrategyDetailVO> strategyDetailVOList = strategyDetailInfoLimitPageRich.getStrategyVOList();
+
+            // 3. 转换对象
+            List<StrategyDetailDTO> strategyDetailDTOList = strategyDetailMapping.sourceToTarget(strategyDetailVOList);
+
+            // 4. 封装数据
+            StrategyDetailRes strategyDetailRes = new StrategyDetailRes(Result.buildSuccessResult());
+            strategyDetailRes.setCount(count);
+            strategyDetailRes.setStrategyDetailDTOList(strategyDetailDTOList);
+
+            logger.info("策略详情配置分页数据查询完成 erpId: {} count: {}", req.getErpId(), count);
+
+            // 5. 返回结果
+            return strategyDetailRes;
+        } catch (Exception e) {
+            logger.error("策略详情配置分页数据查询失败 erpID：{} reqStr：{}", req.getErpId(), JSON.toJSON(req), e);
+            return new StrategyDetailRes(Result.buildErrorResult());
+        }
+    }
+
+    @Override
+    public StrategyDetailRes addStrategyDetailForErp(StrategyDetailRpcReq strategyDetailRpcReq) {
+        try {
+            logger.info("创建策略开始，reqStr：{}", JSON.toJSONString(strategyDetailRpcReq));
+
+            // 包装入参
+            StrategyDetailVO strategyDetailVO = new StrategyDetailVO();
+            BeanUtils.copyProperties(strategyDetailRpcReq, strategyDetailVO);
+            StrategyDetailReq strategyDetailReq = new StrategyDetailReq(strategyDetailVO);
+            strategyDetailDeploy.createStrategyDetail(strategyDetailReq);
+
+            logger.info("创建策略成功，reqStr：{}", JSON.toJSONString(strategyDetailRpcReq));
+            return new StrategyDetailRes(Result.buildSuccessResult());
+        } catch (ClassCastException e) {
+            logger.error("创建策略失败，类型转换异常，reqStr：{}", JSON.toJSONString(strategyDetailRpcReq), e);
+            return new StrategyDetailRes(Result.buildErrorResult());
+        } catch (Exception e) {
+            logger.error("创建策略配置失败：strategyId：{}, reqJson：{}", strategyDetailRpcReq.getStrategyId(), JSON.toJSONString(strategyDetailRpcReq), e);
+            return new StrategyDetailRes(Result.buildErrorResult());
+        }
+    }
+
+    @Override
+    public StrategyDetailRes deleteStrategyDetailForErp(StrategyDetailRpcReq strategyDetailRpcReq) {
+        try {
+            logger.info("删除策略开始，reqStr：{}", JSON.toJSONString(strategyDetailRpcReq));
+
+            // 包装入参
+            StrategyDetailVO strategyDetailVO = new StrategyDetailVO();
+            BeanUtils.copyProperties(strategyDetailRpcReq, strategyDetailVO);
+            StrategyDetailReq strategyDetailReq = new StrategyDetailReq(strategyDetailVO);
+            Result res = strategyDetailDeploy.deleteStrategyDetail(strategyDetailReq);
+
+            if (!Constants.ResponseCode.SUCCESS.getCode().equals(res.getCode())) {
+                logger.info("删除策略失败，reqStr：{}, reason: {}", JSON.toJSONString(strategyDetailRpcReq), res.getInfo());
+                return new StrategyDetailRes(res);
+            }
+
+            logger.info("删除策略成功，reqStr：{}", JSON.toJSONString(strategyDetailRpcReq));
+            return new StrategyDetailRes(res);
+        } catch (ClassCastException e) {
+            logger.error("删除策略失败，类型转换异常，reqStr：{}", JSON.toJSONString(strategyDetailRpcReq), e);
+            return new StrategyDetailRes(Result.buildErrorResult());
+        } catch (Exception e) {
+            logger.error("删除策略配置失败：strategyId：{}, reqJson：{}", strategyDetailRpcReq.getStrategyId(), JSON.toJSONString(strategyDetailRpcReq), e);
+            return new StrategyDetailRes(Result.buildErrorResult());
+        }
+    }
+
+    @Override
+    public StrategyDetailRes updateStrategyDetailForErp(StrategyDetailRpcReq strategyDetailRpcReq) {
+        try {
+            logger.info("修改策略开始，reqStr：{}", JSON.toJSONString(strategyDetailRpcReq));
+
+            // 包装入参
+            StrategyDetailVO strategyDetailVO = new StrategyDetailVO();
+            BeanUtils.copyProperties(strategyDetailRpcReq, strategyDetailVO);
+            StrategyDetailReq strategyDetailReq = new StrategyDetailReq(strategyDetailVO);
+            BeanUtils.copyProperties(strategyDetailRpcReq, strategyDetailReq);
+            strategyDetailDeploy.updateStrategyDetail(strategyDetailReq);
+
+            logger.info("修改策略成功，reqStr：{}", JSON.toJSONString(strategyDetailRpcReq));
+            return new StrategyDetailRes(Result.buildSuccessResult());
+        } catch (ClassCastException e) {
+            logger.error("修改策略失败，类型转换异常，reqStr：{}", JSON.toJSONString(strategyDetailRpcReq), e);
+            return new StrategyDetailRes(Result.buildErrorResult());
+        } catch (Exception e) {
+            logger.error("修改策略配置失败：strategyId：{}, reqJson：{}", strategyDetailRpcReq.getStrategyId(), JSON.toJSONString(strategyDetailRpcReq), e);
+            return new StrategyDetailRes(Result.buildErrorResult());
+        }
+    }
+}

lottery-interfaces/src/main/resources/application.yml

 server:
   port: 8089
 
+# Redis 云服务器搭建后配置并重启 【否则会 Unable to connect to 39.96.*.*:6379】
+# 防火墙放行：firewall-cmd --zone=public --add-port=6379/tcp --permanent
+# 防火墙重启：firewall-cmd --reload
+# redis.conf 注释掉 bind 127.0.0.1
+# redis.conf protected-mode yes 改为 protected-mode no
+redis:
+  database: 0
+  host: localhost         # Redis服务器地址，修改为你的地址
+  port: 6379              # Redis服务器连接端口
+  password:               # Redis服务器连接密码（默认为空）
+  timeout: 3000           # Redis服务器链接超时配置
+
+
+
 # xxl-job
 # 官网：https://github.com/xuxueli/xxl-job/
 # 地址：http://localhost:7397/xxl-job-admin 【需要先启动 xxl-job】
@@ -9,13 +23,13 @@ server:
 xxl:
   job:
     admin:
-      addresses: http://127.0.0.1:7397/xxl-job-admin
+      addresses: http://localhost:7397/xxl-job-admin
     executor:
       address:
       appname: lottery-job
       ip:
       port: 9999
-      logpath: D:\A_learnFile\projects\lottery-702-happy\logFile\data\applogs\xxl-job\jobhandler
+      logpath: F:\data\applogs\xxl-job
       logretentiondays: 50
     accessToken:
 
@@ -111,7 +125,7 @@ dubbo:
       unicast: false
   registry:
     timeout: 6000
-    address: zookeeper://127.0.0.1:2181 #N/A #multicast://224.5.6.7:1234
+    address: zookeeper://localhost:2181 #N/A #multicast://224.5.6.7:1234
   protocol:
     name: dubbo
     port: 20880

lottery-interfaces/src/main/resources/mybatis/mapper/Activity_Mapper.xml

@@ -142,4 +142,17 @@
         LIMIT #{pageBegin}, #{pageEnd}
     </select>
 
+    <select id="queryActivityByStrategyId" resultType="java.lang.Long">
+        SELECT count(*)
+        FROM
+        activity
+        WHERE
+        strategy_id = #{strategyId}
+    </select>
+
+    <update id="updateActivityStock" parameterType="cn.happy.lottery.infrastructure.po.Activity">
+        UPDATE activity SET stock_surplus_count = #{stockSurplusCount}
+        WHERE activity_id = #{activityId} AND stock_surplus_count > #{stockSurplusCount}
+    </update>
+
 </mapper>

lottery-interfaces/src/main/resources/mybatis/mapper/Award_Mapper.xml

@@ -48,4 +48,65 @@
         </foreach>
     </select>
 
+    <select id="queryAwardInfoCount" parameterType="cn.happy.lottery.domain.award.model.req.AwardInfoLimitPageReq" resultType="java.lang.Long">
+        SELECT count(*) FROM award
+        <trim prefix="where" prefixOverrides="AND | OR" suffixOverrides="and">
+            <if test="null != awardId">
+                award_id = #{awardId}
+            </if>
+            <if test="null != awardName">
+                And award_name = #{awardName}
+            </if>
+        </trim>
+    </select>
+
+    <select id="queryAwardInfoList" parameterType="cn.happy.lottery.domain.award.model.req.AwardInfoLimitPageReq" resultMap="awardMap">
+        SELECT
+        id,
+        award_id,
+        award_type,
+        award_name,
+        award_content
+        FROM award
+        <trim prefix="where" prefixOverrides="AND | OR" suffixOverrides="and">
+            <if test="null != awardId">
+                award_id = #{awardId}
+            </if>
+            <if test="null != awardName">
+                And award_name = #{awardName}
+            </if>
+        </trim>
+        ORDER BY id DESC
+        LIMIT #{pageBegin}, #{pageEnd}
+    </select>
+
+    <insert id="insert" parameterType="cn.happy.lottery.infrastructure.po.Award">
+        INSERT INTO award(award_id, award_type, award_name, award_content, create_time, update_time)
+        VALUES (#{awardId}, #{awardType}, #{awardName}, #{awardContent}, NOW(), NOW())
+    </insert>
+
+    <update id="update" parameterType="cn.happy.lottery.infrastructure.po.Award">
+        UPDATE award
+        <set>
+            <if test="awardType != null and awardType != ''">
+                award_type = #{awardType},
+            </if>
+            <if test="awardName != null and awardName != ''">
+                award_name = #{awardName},
+            </if>
+            <if test="awardContent != null and awardContent != ''">
+                award_content = #{awardContent},
+            </if>
+        </set>
+        where
+        award_id = #{awardId}
+    </update>
+
+    <delete id="delete" parameterType="cn.happy.lottery.infrastructure.po.Award">
+        DELETE
+        FROM award
+        WHERE
+        award_id = #{awardId}
+    </delete>
+
 </mapper>

lottery-interfaces/src/main/resources/mybatis/mapper/StrategyDetail_Mapper.xml

@@ -16,14 +16,15 @@
     </resultMap>
 
     <select id="queryStrategyDetailList" parameterType="java.lang.Long" resultMap="strategyDetailMap">
-        SELECT id,
-               strategy_id,
-               award_id,
-               award_count,
-               award_surplus_count,
-               award_rate,
-               create_time,
-               update_time
+        SELECT
+        id,
+        strategy_id,
+        award_id,
+        award_count,
+        award_surplus_count,
+        award_rate,
+        create_time,
+        update_time
         FROM strategy_detail
         WHERE strategy_id = #{strategyId}
     </select>
@@ -32,15 +33,15 @@
         SELECT award_id AS awardId
         FROM strategy_detail
         WHERE strategy_id = #{strategyId}
-          AND award_surplus_count = 0
+        AND award_surplus_count = 0
     </select>
 
     <update id="deductStock" parameterType="cn.happy.lottery.infrastructure.po.StrategyDetail">
         UPDATE strategy_detail
         SET award_surplus_count = award_surplus_count - 1
         WHERE strategy_id = #{strategyId}
-          AND award_id = #{awardId}
-          AND award_surplus_count > 0
+        AND award_id = #{awardId}
+        AND award_surplus_count > 0
     </update>
 
     <insert id="insertList" parameterType="java.util.List">
@@ -61,4 +62,101 @@
         </foreach>
     </insert>
 
+    <insert id="insert" parameterType="cn.happy.lottery.infrastructure.po.StrategyDetail">
+        INSERT INTO strategy_detail(strategy_id, award_id, award_name, award_count, award_surplus_count,
+        award_rate, create_time, update_time)
+        VALUES
+        (#{strategyId},#{awardId},#{awardName},#{awardCount},#{awardSurplusCount},#{awardRate},NOW(),NOW())
+    </insert>
+
+    <delete id="deleteStrategyDetailById" parameterType="java.lang.Long">
+        DELETE
+        FROM
+        strategy_detail
+        where
+        strategy_id = #{strategyId}
+    </delete>
+
+    <delete id="deleteStrategyDetail" parameterType="cn.happy.lottery.infrastructure.po.StrategyDetail">
+        DELETE
+        FROM
+        strategy_detail
+        <where>
+            <if test="null != strategyId">
+                AND strategy_id = #{strategyId}
+            </if>
+            <if test="null != awardId and '' != awardId">
+                AND award_id = #{awardId}
+            </if>
+            <!--            <if test="null != strategyId">-->
+            <!--                AND strategy_id = #{strategyId}-->
+            <!--            </if>-->
+            <!--            <if test="null != strategyId">-->
+            <!--                AND strategy_id = #{strategyId}-->
+            <!--            </if>-->
+            <!--            <if test="null != strategyId">-->
+            <!--                AND strategy_id = #{strategyId}-->
+            <!--            </if>-->
+            <!--            <if test="null != strategyId">-->
+            <!--                AND strategy_id = #{strategyId}-->
+            <!--            </if>-->
+        </where>
+    </delete>
+
+
+    <select id="queryStrategyDetailInfoCount"
+            parameterType="cn.happy.lottery.domain.strategy.model.req.StrategyInfoLimitPageReq"
+            resultType="java.lang.Long">
+        SELECT count(*) FROM strategy_detail
+        <trim prefix="where" prefixOverrides="AND | OR" suffixOverrides="and">
+            <if test="null != strategyId">
+                strategy_id = #{strategyId}
+            </if>
+        </trim>
+    </select>
+
+    <select id="queryStrategyDetailInfoList"
+            parameterType="cn.happy.lottery.domain.strategy.model.req.StrategyInfoLimitPageReq"
+            resultMap="strategyDetailMap">
+        SELECT
+        id,
+        strategy_id,
+        award_id,
+        award_name,
+        award_count,
+        award_surplus_count,
+        award_rate,
+        create_time,
+        update_time
+        FROM strategy_detail
+        <trim prefix="where" prefixOverrides="AND | OR" suffixOverrides="and">
+            <if test="null != strategyId">
+                strategy_id = #{strategyId}
+            </if>
+        </trim>
+        ORDER BY id DESC
+        LIMIT #{pageBegin}, #{pageEnd}
+    </select>
+
+    <update id="updateStrategyDetailById" parameterType="cn.happy.lottery.infrastructure.po.StrategyDetail">
+        UPDATE strategy_detail
+        <set>
+            <if test="awardName != null and awardName != ''">
+                award_name = #{awardName},
+            </if>
+            <if test="awardCount != null and awardCount != ''">
+                award_count = #{awardCount},
+            </if>
+            <if test="awardSurplusCount != null and awardSurplusCount != ''">
+                award_surplus_count = #{awardSurplusCount},
+            </if>
+            <if test="awardRate != null and awardRate != ''">
+                award_rate = #{awardRate},
+            </if>
+        </set>
+        where
+        strategy_id = #{strategyId}
+        AND
+        award_id = #{awardId}
+    </update>
 </mapper>

lottery-interfaces/src/main/resources/mybatis/mapper/Strategy_Mapper.xml

@@ -14,6 +14,7 @@
         <result column="update_time" property="updateTime"/>
     </resultMap>
 
+
     <select id="queryStrategyInfo" parameterType="java.lang.Long" resultMap="strategyMap">
         SELECT id,
                strategy_id,
@@ -28,6 +29,42 @@
         WHERE strategy_id = #{strategyId}
     </select>
 
+    <select id="queryStrategyInfoCount" parameterType="cn.happy.lottery.domain.strategy.model.req.StrategyInfoLimitPageReq" resultType="java.lang.Long">
+        SELECT count(*) FROM strategy
+        <trim prefix="where" prefixOverrides="AND | OR" suffixOverrides="and">
+            <if test="null != strategyId">
+                strategy_id = #{strategyId}
+            </if>
+            <if test="null != strategyDesc">
+                And strategy_desc = #{strategyDesc}
+            </if>
+        </trim>
+    </select>
+
+    <select id="queryStrategyInfoList" parameterType="cn.happy.lottery.domain.strategy.model.req.StrategyInfoLimitPageReq" resultMap="strategyMap">
+        SELECT id,
+            strategy_id,
+            strategy_desc,
+            strategy_mode,
+            grant_type,
+            grant_date,
+            ext_info,
+            create_time,
+            update_time
+        FROM strategy
+        <trim prefix="where" prefixOverrides="AND | OR" suffixOverrides="and">
+            <if test="null != strategyId">
+                strategy_id = #{strategyId}
+            </if>
+            <if test="null != strategyDesc">
+                And strategy_desc = #{strategyDesc}
+            </if>
+        </trim>
+        ORDER BY id DESC
+        LIMIT #{pageBegin}, #{pageEnd}
+    </select>
+
+
     <insert id="insert" parameterType="cn.happy.lottery.infrastructure.po.Strategy">
         INSERT INTO strategy(strategy_id, strategy_desc, strategy_mode, grant_type,
         grant_date, ext_info, create_time, update_time)
@@ -35,4 +72,41 @@
         #{grantDate}, #{extInfo}, NOW(), NOW())
     </insert>
 
+
+    <update id="updateStrategyById" parameterType="cn.happy.lottery.infrastructure.po.Strategy">
+        UPDATE strategy
+        <set>
+            <if test="strategyDesc != null and strategyDesc != ''">
+                strategy_desc = #{strategyDesc},
+            </if>
+            <if test="strategyMode != null and strategyMode != ''">
+                strategy_mode = #{strategyMode},
+            </if>
+            <if test="grantType != null and grantType != ''">
+                grant_type = #{grantType},
+            </if>
+            <if test="grantDate != null">
+                grant_date = #{grantDate},
+            </if>
+            <if test="extInfo != null and extInfo != ''">
+                ext_info = #{extInfo},
+            </if>
+            <if test="createTime != null">
+                create_time = #{createTime},
+            </if>
+            <if test="updateTime != null">
+                update_time = #{updateTime}
+            </if>
+        </set>
+        where
+        strategy_id = #{strategyId}
+    </update>
+
+    <delete id="deleteStrategyById" parameterType="java.lang.Long">
+        DELETE
+        FROM strategy
+        WHERE
+        strategy_id = #{strategyId}
+    </delete>
+
 </mapper>

lottery-interfaces/src/main/resources/mybatis/mapper/UserTakeActivityCount_Mapper.xml

@@ -26,6 +26,14 @@
           AND activity_id = #{activityId}
     </select>
 
+    <select id="queryUserLeftCount" resultType="java.lang.Long" parameterType="java.lang.String">
+        SELECT
+        left_count
+        FROM
+        user_take_activity_count
+        WHERE u_id = #{uId};
+    </select>
+
     <update id="updateLeftCount" parameterType="cn.happy.lottery.infrastructure.po.UserTakeActivityCount">
         UPDATE user_take_activity_count
         SET left_count = left_count - 1

lottery-interfaces/src/test/java/cn/happy/lottery/test/application/ActivityProcessTest.java

@@ -16,7 +16,7 @@ import javax.annotation.Resource;
 /**
  * @author Happy
  * @description:
- * @date 2022/2/28
+ * @date 2022/2/281
  */
 @RunWith(SpringRunner.class)
 @SpringBootTest
@@ -37,7 +37,6 @@ public class ActivityProcessTest {
         logger.info("请求入参：{}", JSON.toJSONString(req));
         logger.info("测试结果：{}", JSON.toJSONString(drawProcessResult));
 
-
     }
 
 

lottery-interfaces/src/test/java/cn/happy/lottery/test/domain/StrategyTest.java

+package cn.happy.lottery.test.domain;
+
+import cn.happy.lottery.test.SpringRunnerTest;
+import org.junit.runner.RunWith;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest
+public class StrategyTest {
+
+
+    private Logger logger = LoggerFactory.getLogger(SpringRunnerTest.class);
+
+
+}

lottery-interfaces/src/test/java/cn/happy/lottery/test/domain/SupportTest.java

 package cn.happy.lottery.test.domain;
 
 import cn.happy.lottery.common.Constants;
+import cn.happy.lottery.domain.support.elasticsearch.model.po.userStrategyExport;
 import cn.happy.lottery.domain.support.ids.IIdGenerator;
+import org.elasticsearch.search.sort.FieldSortBuilder;
+import org.elasticsearch.search.sort.SortBuilders;
+import org.elasticsearch.search.sort.SortOrder;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
+import org.springframework.data.elasticsearch.core.IndexOperations;
+import org.springframework.data.elasticsearch.core.SearchHit;
+import org.springframework.data.elasticsearch.core.SearchHits;
+import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
+import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
 import org.springframework.test.context.junit4.SpringRunner;
 
 import javax.annotation.Resource;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -46,4 +61,45 @@ public class SupportTest {
     }
 
 
+
+    @Resource
+    ElasticsearchRestTemplate template;
+
+    @Test
+    public void test_elastic() {
+        IndexOperations indexOperations = template.indexOps(userStrategyExport.class);
+        boolean exists = indexOperations.exists();
+        System.out.println("========================" + exists);
+
+        // 倒序
+        FieldSortBuilder fsb = SortBuilders.fieldSort("_create_time").order(SortOrder.DESC);
+
+        // 分页取前五条
+        Pageable pageable = PageRequest.of(0, 10);
+
+        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
+        queryBuilder.withPageable(pageable);
+        queryBuilder.withSorts(fsb);
+
+        NativeSearchQuery searchQuery = queryBuilder.build();
+
+        SearchHits<userStrategyExport> searchHits = template.search(searchQuery, userStrategyExport.class);
+        List<userStrategyExport> result = new ArrayList<>();
+        final Iterator<SearchHit<userStrategyExport>> iterator = searchHits.iterator();
+        while(iterator.hasNext()){
+            result.add(iterator.next().getContent());
+        }
+
+        for (userStrategyExport userStrategyExport : result) {
+            System.out.println(userStrategyExport);
+        }
+
+        //查询所有
+//        final SearchHits<userTakeActivity> search = template.search(Query.findAll(), userTakeActivity.class);
+//        final Iterator<SearchHit<userTakeActivity>> iterator = search.iterator();
+//        while(iterator.hasNext()){
+//            System.out.println(iterator.next());
+//        }
+    }
+
 }

lottery-interfaces/src/test/java/cn/happy/lottery/test/dao/ActivityDaoTest.java → lottery-interfaces/src/test/java/cn/happy/lottery/test/infrastructure/ActivityDaoTest.java

-package cn.happy.lottery.test.dao;
+package cn.happy.lottery.test.infrastructure;
 
-import cn.happy.lottery.common.Constants;
-import cn.happy.lottery.domain.activity.model.aggregates.ActivityConfigRich;
-import cn.happy.lottery.domain.activity.model.req.ActivityConfigReq;
-import cn.happy.lottery.domain.activity.model.vo.ActivityVO;
-import cn.happy.lottery.domain.activity.model.vo.AwardVO;
-import cn.happy.lottery.domain.activity.model.vo.StrategyDetailVO;
-import cn.happy.lottery.domain.activity.model.vo.StrategyVO;
-import cn.happy.lottery.domain.activity.service.deploy.IActivityDeploy;
-import cn.happy.lottery.domain.activity.service.stateflow.IStateHandler;
 import cn.happy.lottery.infrastructure.dao.IActivityDao;
 import cn.happy.lottery.infrastructure.po.Activity;
 import cn.happy.lottery.test.SpringRunnerTest;
 import com.alibaba.fastjson.JSON;
-import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.slf4j.Logger;
@@ -22,10 +12,7 @@ import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.test.context.junit4.SpringRunner;
 
 import javax.annotation.Resource;
-import java.math.BigDecimal;
-import java.util.ArrayList;
 import java.util.Date;
-import java.util.List;
 
 /**
  * @author Happy

lottery-interfaces/src/test/java/cn/happy/lottery/test/dao/AwardDaoTest.java → lottery-interfaces/src/test/java/cn/happy/lottery/test/infrastructure/AwardDaoTest.java

-package cn.happy.lottery.test.dao;
+package cn.happy.lottery.test.infrastructure;
 
 import cn.happy.lottery.common.Constants;
 import cn.happy.lottery.domain.activity.model.vo.AwardVO;

lottery-interfaces/src/test/java/cn/happy/lottery/test/infrastructure/RedisUtilTest.java

+package cn.happy.lottery.test.infrastructure;
+
+import cn.happy.lottery.infrastructure.util.RedisUtil;
+import com.alibaba.fastjson.JSON;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import javax.annotation.Resource;
+
+/**
+ * @author: happy
+ * @date: 2022/4/6
+ * @description: Redis 使用测试
+ */
+@RunWith(SpringRunner.class)
+@SpringBootTest
+public class RedisUtilTest {
+
+    private Logger logger = LoggerFactory.getLogger(RedisUtilTest.class);
+
+    @Resource
+    private RedisUtil redisUtil;
+
+    @Test
+    public void test_set() {
+        redisUtil.set("lottery_user_key", "happy");
+    }
+
+    @Test
+    public void test_get() {
+        Object user = redisUtil.get("lottery_user_key");
+        logger.info("测试结果：{}", JSON.toJSONString(user));
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}

lottery-interfaces/src/test/java/cn/happy/lottery/test/dao/StrategyDaoTest.java → lottery-interfaces/src/test/java/cn/happy/lottery/test/infrastructure/StrategyDaoTest.java

-package cn.happy.lottery.test.dao;
+package cn.happy.lottery.test.infrastructure;
 
 import cn.happy.lottery.common.Constants;
 import cn.happy.lottery.infrastructure.dao.IStrategyDao;

lottery-interfaces/src/test/java/cn/happy/lottery/test/dao/StrategyDetailTest.java → lottery-interfaces/src/test/java/cn/happy/lottery/test/infrastructure/StrategyDetailTest.java

-package cn.happy.lottery.test.dao;
+package cn.happy.lottery.test.infrastructure;
 
 import cn.happy.lottery.common.Constants;
 import cn.happy.lottery.infrastructure.dao.IStrategyDetailDao;

lottery-interfaces/src/test/java/cn/happy/lottery/test/dao/UserStrategyExportDaoTest.java → lottery-interfaces/src/test/java/cn/happy/lottery/test/infrastructure/UserStrategyExportDaoTest.java

-package cn.happy.lottery.test.dao;
+package cn.happy.lottery.test.infrastructure;
 
 import cn.happy.lottery.common.Constants;
 import cn.happy.lottery.domain.support.ids.IIdGenerator;

lottery-interfaces/src/test/java/cn/happy/lottery/test/dao/UserTakeActivityDaoTest.java → lottery-interfaces/src/test/java/cn/happy/lottery/test/infrastructure/UserTakeActivityDaoTest.java

-package cn.happy.lottery.test.dao;
+package cn.happy.lottery.test.infrastructure;
 
 import cn.happy.lottery.infrastructure.dao.IUserTakeActivityDao;
 import cn.happy.lottery.infrastructure.po.UserTakeActivity;

lottery-interfaces/src/test/java/cn/happy/lottery/test/interfaces/LotteryActivityBoothTest.java

@@ -62,7 +62,7 @@ public class LotteryActivityBoothTest {
     @Test
     public void test_doQuantification() {
         QuantificationDrawReq req = new QuantificationDrawReq();
-        req.setuId("xiaofuge");
+        req.setuId("happy");
         req.setTreeId(2110081902L);
         req.setValMap(new HashMap<String, Object>() {{
             put("gender", "man");

lottery-interfaces/src/test/java/cn/happy/lottery/test/interfaces/LotteryStrategyDeployTest.java

+package cn.happy.lottery.test.interfaces;
+
+import cn.happy.lottery.domain.activity.model.vo.StrategyVO;
+import cn.happy.lottery.domain.strategy.model.req.StrategyReq;
+import cn.happy.lottery.rpc.activity.deploy.ILotteryActivityDeploy;
+import cn.happy.lottery.rpc.activity.deploy.req.ActivityPageReq;
+import cn.happy.lottery.rpc.activity.deploy.req.ActivityRpcReq;
+import cn.happy.lottery.rpc.activity.deploy.res.ActivityRes;
+import cn.happy.lottery.rpc.strategy.ILotteryStrategyDeploy;
+import cn.happy.lottery.rpc.strategy.deploy.req.StrategyPageReq;
+import cn.happy.lottery.rpc.strategy.deploy.req.StrategyRpcReq;
+import cn.happy.lottery.rpc.strategy.deploy.res.StrategyRes;
+import com.alibaba.fastjson.JSON;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import javax.annotation.Resource;
+import java.util.Date;
+
+/**
+ * @author: happy
+ * @date: 2022/4/14
+ * @description: 策略部署测试
+ */
+@RunWith(SpringRunner.class)
+@SpringBootTest
+public class LotteryStrategyDeployTest {
+
+
+    private Logger logger = LoggerFactory.getLogger(LotteryStrategyDeployTest.class);
+
+    @Resource
+    private ILotteryStrategyDeploy strategyDeploy;
+
+    /**
+     * TODO：后面编写ID生成策略
+     */
+    private Long activityId = 120981321L;
+
+
+    @Test
+    public void test_queryStrategyListByPageForErp() {
+        StrategyPageReq req = new StrategyPageReq(1, 10);
+        req.setErpId("xiaofuge");
+        req.setStrategyId(100001L);
+        req.setStrategyDesc("test");
+        StrategyRes res = strategyDeploy.queryStrategyListByPageForErp(req);
+
+        logger.info("请求参数：{}", JSON.toJSONString(req));
+        logger.info("测试结果：{}", JSON.toJSONString(res));
+    }
+
+    @Test
+    public void test_addStrategyForErp(){
+
+//        StrategyVO strategyVO = new StrategyVO();
+//        strategyVO.setStrategyId(100002L);
+//        strategyVO.setStrategyDesc("test111");
+//        strategyVO.setStrategyMode(1);
+//        strategyVO.setGrantType(1);
+//        strategyVO.setGrantDate(new Date());
+//        strategyVO.setExtInfo("json");
+        StrategyRpcReq strategyReq = new StrategyRpcReq();
+        strategyReq.setStrategyId(100002L);
+        strategyReq.setStrategyDesc("test111");
+        strategyReq.setStrategyMode(1);
+        strategyReq.setGrantType(1);
+        strategyReq.setGrantDate(new Date());
+        strategyReq.setExtInfo("json");
+        strategyDeploy.addStrategyForErp(strategyReq);
+    }
+
+    @Test
+    public void test_deleteStrategyForErp(){
+        StrategyRpcReq strategyReq = new StrategyRpcReq();
+        strategyReq.setStrategyId(10006L);
+        strategyDeploy.deleteStrategyForErp(strategyReq);
+    }
+
+    @Test
+    public void test_updateStrategyForErp(){
+        StrategyRpcReq strategyReq = new StrategyRpcReq();
+        strategyReq.setStrategyId(10002L);
+        strategyReq.setStrategyDesc("test222");
+        strategyReq.setStrategyMode(1);
+        strategyReq.setGrantType(1);
+        strategyReq.setGrantDate(new Date());
+        strategyReq.setExtInfo("json");
+        strategyDeploy.updateStrategyForErp(strategyReq);
+    }
+
+}

lottery-rpc/src/main/java/cn/happy/lottery/rpc/activity/booth/ILotteryActivityBooth.java

@@ -37,4 +37,6 @@ public interface ILotteryActivityBooth {
      */
     QuantificationRes doQuantification(QuantificationDrawReq quantificationDrawReq);
 
+
+
 }

lottery-rpc/src/main/java/cn/happy/lottery/rpc/activity/booth/res/DrawRes.java

@@ -18,6 +18,23 @@ public class DrawRes extends Result implements Serializable {
         return awardDTO;
     }
 
+
+    public DrawRes(AwardDTO awardDTO) {
+        this.awardDTO = awardDTO;
+    }
+
+    public DrawRes(String code, String info, AwardDTO awardDTO) {
+        super(code, info);
+        this.awardDTO = awardDTO;
+    }
+
+    public DrawRes() {
+    }
+
+    public DrawRes(Result result) {
+        super(result.getCode(),result.getInfo());
+    }
+
     public void setAwardDTO(AwardDTO awardDTO) {
         this.awardDTO = awardDTO;
     }

lottery-rpc/src/main/java/cn/happy/lottery/rpc/activity/deploy/dto/ActivityDTO.java

@@ -55,6 +55,11 @@ public class ActivityDTO implements Serializable {
      */
     private Integer takeCount;
 
+    /**
+     * 剩余可参与次数
+     */
+    private Long leftCount;
+
     /**
      * 策略ID
      */
@@ -152,6 +157,14 @@ public class ActivityDTO implements Serializable {
         this.takeCount = takeCount;
     }
 
+    public Long getLeftCount() {
+        return leftCount;
+    }
+
+    public void setLeftCount(Long leftCount) {
+        this.leftCount = leftCount;
+    }
+
     public Long getStrategyId() {
         return strategyId;
     }
@@ -204,6 +217,7 @@ public class ActivityDTO implements Serializable {
                 ", stockCount=" + stockCount +
                 ", stockSurplusCount=" + stockSurplusCount +
                 ", takeCount=" + takeCount +
+                ", leftCount=" + leftCount +
                 ", strategyId=" + strategyId +
                 ", state=" + state +
                 ", creator='" + creator + '\'' +

lottery-rpc/src/main/java/cn/happy/lottery/rpc/award/deploy/ILotteryAwardDeploy.java

+package cn.happy.lottery.rpc.award.deploy;
+
+import cn.happy.lottery.rpc.award.deploy.req.AwardPageReq;
+import cn.happy.lottery.rpc.award.deploy.req.AwardRpcReq;
+import cn.happy.lottery.rpc.award.deploy.res.AwardRes;
+import cn.happy.lottery.rpc.strategy.deploy.req.StrategyPageReq;
+import cn.happy.lottery.rpc.strategyDetail.deploy.req.StrategyDetailRpcReq;
+import cn.happy.lottery.rpc.strategyDetail.deploy.res.StrategyDetailRes;
+
+public interface ILotteryAwardDeploy {
+    /**
+     * 通过分页查询策略详情列表信息，给ERP运营使用
+     *
+     * @param req 查询参数
+     * @return 查询结果
+     */
+    AwardRes queryAwardListByPageForErp(AwardPageReq req);
+
+    AwardRes addAwardForErp(AwardRpcReq req);
+
+    AwardRes deleteAwardForErp(AwardRpcReq req);
+
+    AwardRes updateAwardForErp(AwardRpcReq req);
+}

lottery-rpc/src/main/java/cn/happy/lottery/rpc/award/deploy/req/AwardPageReq.java

+package cn.happy.lottery.rpc.award.deploy.req;
+
+import cn.happy.lottery.common.PageRequest;
+
+import java.io.Serializable;
+
+public class AwardPageReq extends PageRequest implements Serializable {
+
+    /**
+     * ERP ID，记录谁在操作
+     */
+    private String erpId;
+
+    private String awardId;
+
+    private String awardName;
+
+    public AwardPageReq(int page, int rows) {
+        super(page, rows);
+    }
+
+    public AwardPageReq(String page, String rows) {
+        super(page, rows);
+    }
+
+    public String getErpId() {
+        return erpId;
+    }
+
+    public void setErpId(String erpId) {
+        this.erpId = erpId;
+    }
+
+    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;
+    }
+
+    @Override
+    public String toString() {
+        return "AwardPageReq{" +
+                "erpId='" + erpId + '\'' +
+                ", awardId='" + awardId + '\'' +
+                ", awardName='" + awardName + '\'' +
+                '}';
+    }
+}

lottery-rpc/src/main/java/cn/happy/lottery/rpc/award/deploy/req/AwardRpcReq.java

+package cn.happy.lottery.rpc.award.deploy.req;
+
+import java.io.Serializable;
+import java.util.Date;
+
+public class AwardRpcReq implements Serializable {
+
+    /**
+     * 自增ID
+     */
+    private Long id;
+
+    /**
+     * 奖品ID
+     */
+    private String awardId;
+
+    /**
+     * 奖品类型（文字描述、兑换码、优惠券、实物奖品暂无）
+     */
+    private Integer awardType;
+
+    /**
+     * 奖品名称
+     */
+    private String awardName;
+
+    /**
+     * 奖品内容
+     */
+    private String awardContent;
+
+    /**
+     * 创建时间
+     */
+    private Date createTime;
+
+    /**
+     * 修改时间
+     */
+    private Date updateTime;
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    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 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 "AwardRpcReq{" +
+                "id=" + id +
+                ", awardId='" + awardId + '\'' +
+                ", awardType=" + awardType +
+                ", awardName='" + awardName + '\'' +
+                ", awardContent='" + awardContent + '\'' +
+                ", createTime=" + createTime +
+                ", updateTime=" + updateTime +
+                '}';
+    }
+}

lottery-rpc/src/main/java/cn/happy/lottery/rpc/award/deploy/res/AwardRes.java

+package cn.happy.lottery.rpc.award.deploy.res;
+
+import cn.happy.lottery.common.Result;
+import cn.happy.lottery.rpc.activity.booth.dto.AwardDTO;
+import cn.happy.lottery.rpc.activity.deploy.dto.ActivityDTO;
+
+import java.io.Serializable;
+import java.util.List;
+
+public class AwardRes implements Serializable {
+
+    private Result result;
+    private Long count;
+    private List<AwardDTO> awardDTOList;
+
+    public AwardRes(Result result) {
+        this.result = result;
+    }
+
+    public Result getResult() {
+        return result;
+    }
+
+    public void setResult(Result result) {
+        this.result = result;
+    }
+
+    public Long getCount() {
+        return count;
+    }
+
+    public void setCount(Long count) {
+        this.count = count;
+    }
+
+    public List<AwardDTO> getAwardDTOList() {
+        return awardDTOList;
+    }
+
+    public void setAwardDTOList(List<AwardDTO> awardDTOList) {
+        this.awardDTOList = awardDTOList;
+    }
+
+    @Override
+    public String toString() {
+        return "AwardRes{" +
+                "result=" + result +
+                ", count=" + count +
+                ", awardDTOList=" + awardDTOList +
+                '}';
+    }
+}

lottery-rpc/src/main/java/cn/happy/lottery/rpc/strategy/ILotteryStrategyDeploy.java

+package cn.happy.lottery.rpc.strategy;
+
+import cn.happy.lottery.rpc.strategy.deploy.req.StrategyPageReq;
+import cn.happy.lottery.rpc.strategy.deploy.req.StrategyRpcReq;
+import cn.happy.lottery.rpc.strategy.deploy.res.StrategyRes;
+import cn.happy.lottery.rpc.strategy.deploy.res.UserStrategyExportRes;
+
+public interface ILotteryStrategyDeploy {
+
+    /**
+     * 通过分页查询策略列表信息，给ERP运营使用
+     *
+     * @param req 查询参数
+     * @return 查询结果
+     */
+    StrategyRes queryStrategyListByPageForErp(StrategyPageReq req);
+
+    StrategyRes addStrategyForErp(StrategyRpcReq strategyRpcReq);
+
+    StrategyRes deleteStrategyForErp(StrategyRpcReq strategyRpcReq);
+
+    StrategyRes updateStrategyForErp(StrategyRpcReq strategyRpcReq);
+
+    UserStrategyExportRes queryUserStrategyExport();
+
+}

lottery-rpc/src/main/java/cn/happy/lottery/rpc/strategy/deploy/dto/StrategyDTO.java

+package cn.happy.lottery.rpc.strategy.deploy.dto;
+
+import java.io.Serializable;
+import java.util.Date;
+
+public class StrategyDTO implements Serializable {
+
+    /**
+     * 策略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;
+    }
+
+    @Override
+    public String toString() {
+        return "StrategyDTO{" +
+                "strategyId=" + strategyId +
+                ", strategyDesc='" + strategyDesc + '\'' +
+                ", strategyMode=" + strategyMode +
+                ", grantType=" + grantType +
+                ", grantDate=" + grantDate +
+                ", extInfo='" + extInfo + '\'' +
+                '}';
+    }
+}

lottery-rpc/src/main/java/cn/happy/lottery/rpc/strategy/deploy/dto/UserStrategyExportDTO.java

+package cn.happy.lottery.rpc.strategy.deploy.dto;
+
+import java.io.Serializable;
+import java.util.Date;
+
+public class UserStrategyExportDTO implements Serializable {
+
+    /** 自增ID */
+    private Long id;
+    /** 用户ID */
+    private String uId;
+    /** 活动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;
+    /** 防重ID */
+    private String uuid;
+    /**
+     * 消息发送状态（0未发送、1发送成功、2发送失败）
+     */
+    private Integer mqState;
+    /** 创建时间 */
+    private Date createTime;
+    /** 更新时间 */
+    private Date updateTime;
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    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 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;
+    }
+
+    public String getUuid() {
+        return uuid;
+    }
+
+    public void setUuid(String uuid) {
+        this.uuid = uuid;
+    }
+
+    public Integer getMqState() {
+        return mqState;
+    }
+
+    public void setMqState(Integer mqState) {
+        this.mqState = mqState;
+    }
+
+    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 "UserStrategyExportDTO{" +
+                "id=" + id +
+                ", uId='" + uId + '\'' +
+                ", activityId=" + activityId +
+                ", orderId=" + orderId +
+                ", strategyId=" + strategyId +
+                ", strategyMode=" + strategyMode +
+                ", grantType=" + grantType +
+                ", grantDate=" + grantDate +
+                ", grantState=" + grantState +
+                ", awardId='" + awardId + '\'' +
+                ", awardType=" + awardType +
+                ", awardName='" + awardName + '\'' +
+                ", awardContent='" + awardContent + '\'' +
+                ", uuid='" + uuid + '\'' +
+                ", mqState=" + mqState +
+                ", createTime=" + createTime +
+                ", updateTime=" + updateTime +
+                '}';
+    }
+}

lottery-rpc/src/main/java/cn/happy/lottery/rpc/strategy/deploy/req/StrategyPageReq.java

+package cn.happy.lottery.rpc.strategy.deploy.req;
+
+import cn.happy.lottery.common.PageRequest;
+
+import java.io.Serializable;
+
+
+/**
+ * @description: 分页查询策略
+ * @author: happy
+ * @date: 2022/4/14
+ */
+public class StrategyPageReq extends PageRequest implements Serializable {
+
+    /**
+     * ERP ID，记录谁在操作
+     */
+    private String erpId;
+
+    /**
+     * 活动ID
+     */
+    private Long strategyId;
+
+    /**
+     * 活动名称
+     */
+    private String strategyDesc;
+
+    public StrategyPageReq(int page, int rows) {
+        super(page, rows);
+    }
+
+    public String getErpId() {
+        return erpId;
+    }
+
+    public void setErpId(String erpId) {
+        this.erpId = erpId;
+    }
+
+    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;
+    }
+
+
+    @Override
+    public String toString() {
+        return "StrategyPageReq{" +
+                "erpId='" + erpId + '\'' +
+                ", strategyId=" + strategyId +
+                ", strategyDesc='" + strategyDesc + '\'' +
+                '}';
+    }
+}

lottery-rpc/src/main/java/cn/happy/lottery/rpc/strategy/deploy/req/StrategyRpcReq.java

+package cn.happy.lottery.rpc.strategy.deploy.req;
+
+import java.io.Serializable;
+import java.util.Date;
+
+public class StrategyRpcReq implements Serializable {
+
+    /**
+     * 策略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;
+    }
+
+    @Override
+    public String toString() {
+        return "StrategyRpcReq{" +
+                "strategyId=" + strategyId +
+                ", strategyDesc='" + strategyDesc + '\'' +
+                ", strategyMode=" + strategyMode +
+                ", grantType=" + grantType +
+                ", grantDate=" + grantDate +
+                ", extInfo='" + extInfo + '\'' +
+                '}';
+    }
+}

lottery-rpc/src/main/java/cn/happy/lottery/rpc/strategy/deploy/res/StrategyRes.java

+package cn.happy.lottery.rpc.strategy.deploy.res;
+
+import cn.happy.lottery.common.Result;
+import cn.happy.lottery.rpc.strategy.deploy.dto.StrategyDTO;
+
+import java.io.Serializable;
+import java.util.List;
+
+public class StrategyRes implements Serializable {
+
+    private Result result;
+    private Long count;
+    private List<StrategyDTO> strategyDTOList;
+
+    public StrategyRes() {
+    }
+
+    public StrategyRes(Result result) {
+        this.result = result;
+    }
+
+    public Result getResult() {
+        return result;
+    }
+
+    public void setResult(Result result) {
+        this.result = result;
+    }
+
+    public Long getCount() {
+        return count;
+    }
+
+    public void setCount(Long count) {
+        this.count = count;
+    }
+
+    public List<StrategyDTO> getStrategyDTOList() {
+        return strategyDTOList;
+    }
+
+    public void setStrategyDTOList(List<StrategyDTO> strategyDTOList) {
+        this.strategyDTOList = strategyDTOList;
+    }
+
+    @Override
+    public String toString() {
+        return "StrategyRes{" +
+                "result=" + result +
+                ", count=" + count +
+                ", strategyDTOList=" + strategyDTOList +
+                '}';
+    }
+}

lottery-rpc/src/main/java/cn/happy/lottery/rpc/strategyDetail/deploy/ILotteryStrategyDetailDeploy.java

+package cn.happy.lottery.rpc.strategyDetail.deploy;
+
+import cn.happy.lottery.rpc.strategy.deploy.req.StrategyPageReq;
+import cn.happy.lottery.rpc.strategy.deploy.req.StrategyRpcReq;
+import cn.happy.lottery.rpc.strategy.deploy.res.StrategyRes;
+import cn.happy.lottery.rpc.strategyDetail.deploy.req.StrategyDetailPageReq;
+import cn.happy.lottery.rpc.strategyDetail.deploy.req.StrategyDetailRpcReq;
+import cn.happy.lottery.rpc.strategyDetail.deploy.res.StrategyDetailRes;
+
+public interface ILotteryStrategyDetailDeploy {
+
+    /**
+     * 通过分页查询策略详情列表信息，给ERP运营使用
+     *
+     * @param req 查询参数
+     * @return 查询结果
+     */
+    StrategyDetailRes queryStrategyDetailListByPageForErp(StrategyDetailPageReq req);
+
+    StrategyDetailRes addStrategyDetailForErp(StrategyDetailRpcReq strategyDetailRpcReq);
+
+    StrategyDetailRes deleteStrategyDetailForErp(StrategyDetailRpcReq strategyDetailRpcReq);
+
+    StrategyDetailRes updateStrategyDetailForErp(StrategyDetailRpcReq strategyDetailRpcReq);
+
+}

pom.xml

@@ -26,7 +26,7 @@
     <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
-        <version>2.3.5.RELEASE</version>
+        <version>2.6.0</version>
         <relativePath/> <!-- lookup parent from repository -->
     </parent>