code
stringlengths 1
1.05M
| repo_name
stringlengths 6
83
| path
stringlengths 3
242
| language
stringclasses 222
values | license
stringclasses 20
values | size
int64 1
1.05M
|
|---|---|---|---|---|---|
package zack.project.domain.activity.service.discount.Impl;
import zack.project.domain.activity.model.valobj.GroupBuyActivityDiscountVO;
import zack.project.domain.activity.service.discount.AbstractDiscountCalculateService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.math.RoundingMode;
/**
* @author zack.project
* @description 折扣优惠计算
* @create 2024-12-22 12:12
*/
@Slf4j
@Service("ZK")
public class ZKCalculateService extends AbstractDiscountCalculateService {
@Override
public BigDecimal doCalculate(BigDecimal originalPrice, GroupBuyActivityDiscountVO.GroupBuyDiscount groupBuyDiscount) {
log.info("优惠策略折扣计算:{}", groupBuyDiscount.getDiscountType().getCode());
// 折扣表达式 - 折扣百分比
String marketExpr = groupBuyDiscount.getMarketExpr();
// 折扣价格 + 四舍五入
BigDecimal deductionPrice = originalPrice.multiply(new BigDecimal(marketExpr))
.setScale(0, RoundingMode.DOWN);
// 判断折扣后金额，最低支付1分钱
if (deductionPrice.compareTo(BigDecimal.ZERO) <= 0) {
return new BigDecimal("0.01");
}
return deductionPrice;
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/activity/service/discount/Impl/ZKCalculateService.java
|
Java
|
unknown
| 1,290
|
package zack.project.domain.activity.service.trial;
import zack.project.domain.activity.adapter.repository.IActivityRepository;
import zack.project.domain.activity.service.trial.factory.DefaultActivityStrategyFactory;
import cn.bugstack.wrench.design.framework.tree.AbstractMultiThreadStrategyRouter;
import javax.annotation.Resource;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeoutException;
/**
* @description 抽象的拼团营销支撑类
* @create 2024-12-14 13:42
*/
public abstract class AbstractGroupBuyMarketSupport<MarketProductEntity, DynamicContext, TrialBalanceEntity>
extends AbstractMultiThreadStrategyRouter<zack.project.domain.activity.model.entity.MarketProductEntity, DefaultActivityStrategyFactory.DynamicContext, zack.project.domain.activity.model.entity.TrialBalanceEntity> {
protected long timeout = 5000;
@Resource
protected IActivityRepository repository;
@Override
protected void multiThread(zack.project.domain.activity.model.entity.MarketProductEntity requestParameter,
DefaultActivityStrategyFactory.DynamicContext dynamicContext) throws ExecutionException, InterruptedException, TimeoutException {
// 缺省的方法
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/activity/service/trial/AbstractGroupBuyMarketSupport.java
|
Java
|
unknown
| 1,268
|
package zack.project.domain.activity.service.trial.factory;
import zack.project.domain.activity.model.entity.MarketProductEntity;
import zack.project.domain.activity.model.entity.TrialBalanceEntity;
import zack.project.domain.activity.model.valobj.GroupBuyActivityDiscountVO;
import zack.project.domain.activity.model.valobj.SkuVO;
import zack.project.domain.activity.service.trial.node.RootNode;
import cn.bugstack.wrench.design.framework.tree.StrategyHandler;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
/**
* @description 活动策略工厂
* @create 2024-12-14 13:41
*/
@Service
public class DefaultActivityStrategyFactory {
private final RootNode rootNode;
public DefaultActivityStrategyFactory(RootNode rootNode) {
this.rootNode = rootNode;
}
public StrategyHandler<MarketProductEntity, DynamicContext, TrialBalanceEntity> strategyHandler() {
return rootNode;
}
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public static class DynamicContext {
// 拼团活动营销配置值对象
private GroupBuyActivityDiscountVO groupBuyActivityDiscountVO;
// 商品信息
private SkuVO skuVO;
// 折扣金额
private BigDecimal deductionPrice;
// 支付金额
private BigDecimal payPrice;
// 活动可见性限制
private boolean visible;
// 活动
private boolean enable;
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/activity/service/trial/factory/DefaultActivityStrategyFactory.java
|
Java
|
unknown
| 1,589
|
package zack.project.domain.activity.service.trial.node;
import zack.project.domain.activity.model.entity.MarketProductEntity;
import zack.project.domain.activity.model.entity.TrialBalanceEntity;
import zack.project.domain.activity.model.valobj.GroupBuyActivityDiscountVO;
import zack.project.domain.activity.model.valobj.SkuVO;
import zack.project.domain.activity.service.trial.AbstractGroupBuyMarketSupport;
import zack.project.domain.activity.service.trial.factory.DefaultActivityStrategyFactory;
import cn.bugstack.wrench.design.framework.tree.StrategyHandler;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
/**
* @author zack.project
* @description 正常结束节点
* @create 2024-12-14 14:31
*/
@Slf4j
@Service
public class EndNode extends AbstractGroupBuyMarketSupport<MarketProductEntity, DefaultActivityStrategyFactory.DynamicContext, TrialBalanceEntity> {
@Override
public TrialBalanceEntity doApply(MarketProductEntity requestParameter, DefaultActivityStrategyFactory.DynamicContext dynamicContext) throws Exception {
log.info("拼团商品查询试算服务-EndNode userId:{} requestParameter:{}", requestParameter.getUserId(), JSON.toJSONString(requestParameter));
// 拼团活动配置
GroupBuyActivityDiscountVO groupBuyActivityDiscountVO =
dynamicContext.getGroupBuyActivityDiscountVO();
// 商品信息
SkuVO skuVO = dynamicContext.getSkuVO();
// 折扣金额
BigDecimal deductionPrice = dynamicContext.getDeductionPrice();
// 支付金额
BigDecimal payPrice = dynamicContext.getPayPrice();
// 返回空结果
return TrialBalanceEntity.builder()
.goodsId(skuVO.getGoodsId())
.goodsName(skuVO.getGoodsName())
.originalPrice(skuVO.getOriginalPrice())
.deductionPrice(deductionPrice)
.payPrice(payPrice)
.targetCount(groupBuyActivityDiscountVO.getTarget())
.startTime(groupBuyActivityDiscountVO.getStartTime())
.endTime(groupBuyActivityDiscountVO.getEndTime())
.isVisible(dynamicContext.isVisible())
.isEnable(dynamicContext.isEnable())
.groupBuyActivityDiscountVO(groupBuyActivityDiscountVO)
.build();
}
@Override
public StrategyHandler<MarketProductEntity, DefaultActivityStrategyFactory.DynamicContext, TrialBalanceEntity> get(MarketProductEntity requestParameter, DefaultActivityStrategyFactory.DynamicContext dynamicContext) throws Exception {
return defaultStrategyHandler;
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/activity/service/trial/node/EndNode.java
|
Java
|
unknown
| 2,740
|
package zack.project.domain.activity.service.trial.node;
import zack.project.domain.activity.model.entity.MarketProductEntity;
import zack.project.domain.activity.model.entity.TrialBalanceEntity;
import zack.project.domain.activity.service.trial.AbstractGroupBuyMarketSupport;
import zack.project.domain.activity.service.trial.factory.DefaultActivityStrategyFactory;
import zack.project.types.enums.ResponseCode;
import zack.project.types.exception.AppException;
import cn.bugstack.wrench.design.framework.tree.StrategyHandler;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
/**
* @author zack.project
* @description 异常节点处理；无营销、流程降级、超时调用等，都可以路由到 ErrorNode 节点统一处理
* @create 2025-01-01 13:47
*/
@Slf4j
@Service
public class ErrorNode extends AbstractGroupBuyMarketSupport<MarketProductEntity, DefaultActivityStrategyFactory.DynamicContext, TrialBalanceEntity> {
@Override
protected TrialBalanceEntity doApply(MarketProductEntity requestParameter, DefaultActivityStrategyFactory.DynamicContext dynamicContext) throws Exception {
log.info("拼团商品查询试算服务-NoMarketNode userId:{} requestParameter:{}", requestParameter.getUserId(), JSON.toJSONString(requestParameter));
// 无营销配置
if (null == dynamicContext.getGroupBuyActivityDiscountVO() || null == dynamicContext.getSkuVO()) {
log.info("商品无拼团营销配置 {}", requestParameter.getGoodsId());
throw new AppException(ResponseCode.E0002.getCode(), ResponseCode.E0002.getInfo());
}
return TrialBalanceEntity.builder().build();
}
@Override
public StrategyHandler<MarketProductEntity, DefaultActivityStrategyFactory.DynamicContext, TrialBalanceEntity> get(MarketProductEntity requestParameter, DefaultActivityStrategyFactory.DynamicContext dynamicContext) throws Exception {
return defaultStrategyHandler;
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/activity/service/trial/node/ErrorNode.java
|
Java
|
unknown
| 2,028
|
package zack.project.domain.activity.service.trial.node;
import zack.project.domain.activity.model.entity.MarketProductEntity;
import zack.project.domain.activity.model.entity.TrialBalanceEntity;
import zack.project.domain.activity.model.valobj.GroupBuyActivityDiscountVO;
import zack.project.domain.activity.model.valobj.SkuVO;
import zack.project.domain.activity.service.discount.IDiscountCalculateService;
import zack.project.domain.activity.service.trial.AbstractGroupBuyMarketSupport;
import zack.project.domain.activity.service.trial.factory.DefaultActivityStrategyFactory;
import zack.project.domain.activity.service.trial.thread.QueryGroupBuyActivityDiscountVOThreadTask;
import zack.project.domain.activity.service.trial.thread.QuerySkuVOFromDBThreadTask;
import zack.project.types.enums.ResponseCode;
import zack.project.types.exception.AppException;
import cn.bugstack.wrench.design.framework.tree.StrategyHandler;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.Map;
import java.util.concurrent.*;
/**
* @description 营销优惠节点
* @create 2024-12-14 14:30
*/
@Slf4j
@Service
public class MarketNode extends AbstractGroupBuyMarketSupport<MarketProductEntity, DefaultActivityStrategyFactory.DynamicContext, TrialBalanceEntity> {
@Resource
private ThreadPoolExecutor threadPoolExecutor;
/**
* <a href="https://bugstack.cn/md/road-map/spring-dependency-injection.html">Spring 注入详细说明</a>
*/
@Resource
private Map<String, IDiscountCalculateService> discountCalculateServiceMap;
@Resource
private ErrorNode errorNode;
@Resource
private TagNode tagNode;
/**
* 在 MarketNode2CompletableFuture 继承的子类实现一个 CompletableFuture 多线程方式。
* <p>
* 1. CompletableFuture：适用于大多数现代 Java 应用，尤其在需要灵活任务编排时。
* 2. FutureTask：任务极度简单，适合简单场景。
* <p>
* | 对比维度 | FutureTask | CompletableFuture |
* | :--------------- | :-------------------------- | :------------------------------------- |
* | 任务编排能力 | 弱（需手动管理多个 Future） | 强（内置 `thenApply`、`allOf` 等方法） |
* | 代码简洁性 | 冗余（显式调用 `get()`） | 简洁（链式调用，逻辑内聚） |
* | 异常处理 | 繁琐（需捕获多个异常） | 优雅（支持 `exceptionally` 统一处理） |
* | 线程阻塞 | 可能多次阻塞主线程 | 非阻塞或单次阻塞（如 `join()`） |
* | 适用场景 | 简单任务、低版本 Java 环境 | 复杂异步流程、Java 8+ 环境 |
* <p>
* 使用；MarketNode 的 @Service 注释掉，MarketNode2CompletableFuture 的 @Service 打开，就可以使用了。
*/
@Override
protected void multiThread(MarketProductEntity requestParameter,
DefaultActivityStrategyFactory.DynamicContext dynamicContext) throws ExecutionException, InterruptedException, TimeoutException {
// 异步查询活动配置
QueryGroupBuyActivityDiscountVOThreadTask queryGroupBuyActivityDiscountVOThreadTask =
new QueryGroupBuyActivityDiscountVOThreadTask(requestParameter.getActivityId(),
requestParameter.getSource(),
requestParameter.getChannel(),
requestParameter.getGoodsId(), repository);
FutureTask<GroupBuyActivityDiscountVO> groupBuyActivityDiscountVOFutureTask =
new FutureTask<>(queryGroupBuyActivityDiscountVOThreadTask);
threadPoolExecutor.execute(groupBuyActivityDiscountVOFutureTask);
// 异步查询商品信息 - 在实际生产中，商品有同步库或者调用接口查询。这里暂时使用DB方式查询。
QuerySkuVOFromDBThreadTask querySkuVOFromDBThreadTask = new QuerySkuVOFromDBThreadTask(requestParameter.getGoodsId(), repository);
FutureTask<SkuVO> skuVOFutureTask = new FutureTask<>(querySkuVOFromDBThreadTask);
threadPoolExecutor.execute(skuVOFutureTask);
// 写入上下文 - 对于一些复杂场景，获取数据的操作，有时候会在下N个节点获取，这样前置查询数据，可以提高接口响应效率
dynamicContext
.setGroupBuyActivityDiscountVO(groupBuyActivityDiscountVOFutureTask.get(timeout, TimeUnit.MILLISECONDS));
dynamicContext
.setSkuVO(skuVOFutureTask.get(timeout, TimeUnit.MILLISECONDS));
log.info("拼团商品查询试算服务-MarketNode userId:{} 异步线程加载数据「GroupBuyActivityDiscountVO、SkuVO」完成", requestParameter.getUserId());
}
@Override
public TrialBalanceEntity doApply(MarketProductEntity requestParameter,
DefaultActivityStrategyFactory.DynamicContext dynamicContext) throws Exception {
log.info("拼团商品查询试算服务-MarketNode userId:{} requestParameter:{}", requestParameter.getUserId(), JSON.toJSONString(requestParameter));
// 获取上下文数据
GroupBuyActivityDiscountVO groupBuyActivityDiscountVO =
dynamicContext.getGroupBuyActivityDiscountVO();
if (null == groupBuyActivityDiscountVO) {
return router(requestParameter, dynamicContext);
}
GroupBuyActivityDiscountVO.GroupBuyDiscount groupBuyDiscount =
groupBuyActivityDiscountVO.getGroupBuyDiscount();
SkuVO skuVO = dynamicContext.getSkuVO();
if (null == groupBuyDiscount || null == skuVO) {
return router(requestParameter, dynamicContext);
}
// 优惠试算
IDiscountCalculateService discountCalculateService =
discountCalculateServiceMap.get(groupBuyDiscount.getMarketPlan());
if (null == discountCalculateService) {
log.info("不存在{}类型的折扣计算服务，支持类型为:{}", groupBuyDiscount.getMarketPlan(), JSON.toJSONString(discountCalculateServiceMap.keySet()));
throw new AppException(ResponseCode.E0001.getCode(), ResponseCode.E0001.getInfo());
}
// 折扣价格
BigDecimal payPrice =
discountCalculateService.calculate(requestParameter.getUserId(),
skuVO.getOriginalPrice(),
groupBuyDiscount);
dynamicContext.setDeductionPrice(skuVO.getOriginalPrice().subtract(payPrice));
dynamicContext.setPayPrice(payPrice);
return router(requestParameter, dynamicContext);
}
@Override
public StrategyHandler<MarketProductEntity, DefaultActivityStrategyFactory.DynamicContext, TrialBalanceEntity> get(MarketProductEntity requestParameter, DefaultActivityStrategyFactory.DynamicContext dynamicContext) throws Exception {
// 不存在配置的拼团活动，走异常节点
if (null == dynamicContext.getGroupBuyActivityDiscountVO() ||
null == dynamicContext.getSkuVO() ||
null == dynamicContext.getDeductionPrice()) {
return errorNode;
}
return tagNode;
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/activity/service/trial/node/MarketNode.java
|
Java
|
unknown
| 7,388
|
package zack.project.domain.activity.service.trial.node;
import zack.project.domain.activity.model.entity.MarketProductEntity;
import zack.project.domain.activity.model.valobj.GroupBuyActivityDiscountVO;
import zack.project.domain.activity.model.valobj.SCSkuActivityVO;
import zack.project.domain.activity.model.valobj.SkuVO;
import zack.project.domain.activity.service.trial.factory.DefaultActivityStrategyFactory;
import lombok.extern.slf4j.Slf4j;
import javax.annotation.Resource;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeoutException;
/**
* @description 线程案例举例
* @create 2025-04-03 07:44
*/
@Slf4j
//@Service
public class MarketNode2CompletableFuture extends MarketNode {
@Resource
private ThreadPoolExecutor threadPoolExecutor;
/**
* 异步加载拼团活动配置
* 通过请求锁单dto构建营销商品实体对象，该实体对象的sc，goodsId -> 查询{sc_sku_activity}获得scSkuActivityVO(渠道商品的活动配置)->
* 聚到商品活动的活动id去查询group_buy_activity的discountId获取该商品对应活动的折扣配置。
* 一个渠道下的商品 -> 一个拼团活动 -> 一个折扣配置
*
* @param requestParameter
* @param dynamicContext
* @throws ExecutionException
* @throws InterruptedException
* @throws TimeoutException
*/
@Override
protected void multiThread(MarketProductEntity requestParameter, DefaultActivityStrategyFactory.DynamicContext dynamicContext) throws ExecutionException, InterruptedException, TimeoutException {
// 异步查询活动配置
CompletableFuture<GroupBuyActivityDiscountVO> groupBuyActivityDiscountVOCompletableFuture =
CompletableFuture.supplyAsync(() -> {
try {
Long availableActivityId = requestParameter.getActivityId();
if (null == requestParameter.getActivityId()) {
// 查询渠道商品活动配置关联配置
SCSkuActivityVO scSkuActivityVO = repository.querySCSkuActivityBySCGoodsId(requestParameter.getSource(),
requestParameter.getChannel(),
requestParameter.getGoodsId());
if (null == scSkuActivityVO) return null;
availableActivityId = scSkuActivityVO.getActivityId();
}
// 查询活动配置
return repository.queryGroupBuyActivityDiscountVO(availableActivityId);
} catch (Exception e) {
log.error("异步查询活动配置异常", e);
return null;
}
}, threadPoolExecutor);
// 异步查询商品信息 - 在实际生产中，商品有同步库或者调用接口查询。这里暂时使用DB方式查询。
//查询数据库表{sku}获取sku商品的原价，用于优惠试算
CompletableFuture<SkuVO> skuVOCompletableFuture = CompletableFuture.supplyAsync(() -> {
try {
return repository.querySkuByGoodsId(requestParameter.getGoodsId());
} catch (Exception e) {
log.error("异步查询商品信息异常", e);
return null;
}
}, threadPoolExecutor);
// 等待所有异步任务完成并写入上下文
CompletableFuture.allOf(groupBuyActivityDiscountVOCompletableFuture, skuVOCompletableFuture)
.thenRun(() -> {
dynamicContext.setGroupBuyActivityDiscountVO(groupBuyActivityDiscountVOCompletableFuture.join());
dynamicContext.setSkuVO(skuVOCompletableFuture.join());
;
}).join();
log.info("拼团商品查询试算服务-MarketNode userId:{} 异步线程加载数据「GroupBuyActivityDiscountVO、SkuVO」完成", requestParameter.getUserId());
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/activity/service/trial/node/MarketNode2CompletableFuture.java
|
Java
|
unknown
| 4,164
|
package zack.project.domain.activity.service.trial.node;
import zack.project.domain.activity.model.entity.MarketProductEntity;
import zack.project.domain.activity.model.entity.TrialBalanceEntity;
import zack.project.domain.activity.service.trial.AbstractGroupBuyMarketSupport;
import zack.project.domain.activity.service.trial.factory.DefaultActivityStrategyFactory;
import zack.project.types.enums.ResponseCode;
import zack.project.types.exception.AppException;
import cn.bugstack.wrench.design.framework.tree.StrategyHandler;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* @author zack.project
* @description 根节点
* @create 2024-12-14 14:17
*/
@Slf4j
@Service
public class RootNode extends AbstractGroupBuyMarketSupport<MarketProductEntity, DefaultActivityStrategyFactory.DynamicContext, TrialBalanceEntity> {
@Resource
private SwitchNode switchNode;
@Override
protected TrialBalanceEntity doApply(MarketProductEntity requestParameter, DefaultActivityStrategyFactory.DynamicContext dynamicContext) throws Exception {
log.info("拼团商品查询试算服务-RootNode userId:{} requestParameter:{}", requestParameter.getUserId(), JSON.toJSONString(requestParameter));
// 参数判断
if (StringUtils.isBlank(requestParameter.getUserId()) || StringUtils.isBlank(requestParameter.getGoodsId()) ||
StringUtils.isBlank(requestParameter.getSource()) || StringUtils.isBlank(requestParameter.getChannel())) {
throw new AppException(ResponseCode.ILLEGAL_PARAMETER.getCode(), ResponseCode.ILLEGAL_PARAMETER.getInfo());
}
return router(requestParameter, dynamicContext);
}
@Override
public StrategyHandler<MarketProductEntity, DefaultActivityStrategyFactory.DynamicContext, TrialBalanceEntity> get(MarketProductEntity requestParameter, DefaultActivityStrategyFactory.DynamicContext dynamicContext) throws Exception {
return switchNode;
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/activity/service/trial/node/RootNode.java
|
Java
|
unknown
| 2,108
|
package zack.project.domain.activity.service.trial.node;
import zack.project.domain.activity.model.entity.MarketProductEntity;
import zack.project.domain.activity.model.entity.TrialBalanceEntity;
import zack.project.domain.activity.service.trial.AbstractGroupBuyMarketSupport;
import zack.project.domain.activity.service.trial.factory.DefaultActivityStrategyFactory;
import zack.project.types.enums.ResponseCode;
import zack.project.types.exception.AppException;
import cn.bugstack.wrench.design.framework.tree.StrategyHandler;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* @author zack.project
* @description 开关节点
* @create 2024-12-14 14:27
*/
@Slf4j
@Service
public class SwitchNode extends AbstractGroupBuyMarketSupport<MarketProductEntity, DefaultActivityStrategyFactory.DynamicContext, TrialBalanceEntity> {
@Resource
private MarketNode marketNode;
@Override
public TrialBalanceEntity doApply(MarketProductEntity requestParameter, DefaultActivityStrategyFactory.DynamicContext dynamicContext) throws Exception {
log.info("拼团商品查询试算服务-SwitchNode userId:{} requestParameter:{}", requestParameter.getUserId(), JSON.toJSONString(requestParameter));
// 根据用户ID切量
String userId = requestParameter.getUserId();
// 判断是否降级
if (repository.downgradeSwitch()) {
log.info("拼团活动降级拦截 {}", userId);
throw new AppException(ResponseCode.E0003.getCode(), ResponseCode.E0003.getInfo());
}
// 切量范围判断
if (!repository.cutRange(userId)) {
log.info("拼团活动切量拦截 {}", userId);
throw new AppException(ResponseCode.E0004.getCode(), ResponseCode.E0004.getInfo());
}
return router(requestParameter, dynamicContext);
}
@Override
public StrategyHandler<MarketProductEntity, DefaultActivityStrategyFactory.DynamicContext, TrialBalanceEntity> get(MarketProductEntity requestParameter, DefaultActivityStrategyFactory.DynamicContext dynamicContext) throws Exception {
return marketNode;
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/activity/service/trial/node/SwitchNode.java
|
Java
|
unknown
| 2,243
|
package zack.project.domain.activity.service.trial.node;
import zack.project.domain.activity.model.entity.MarketProductEntity;
import zack.project.domain.activity.model.entity.TrialBalanceEntity;
import zack.project.domain.activity.model.valobj.GroupBuyActivityDiscountVO;
import zack.project.domain.activity.service.trial.AbstractGroupBuyMarketSupport;
import zack.project.domain.activity.service.trial.factory.DefaultActivityStrategyFactory;
import cn.bugstack.wrench.design.framework.tree.StrategyHandler;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* @author zack.project
* @description 人群标签判断
* @create 2025-01-02 10:36
*/
@Slf4j
@Service
public class TagNode extends AbstractGroupBuyMarketSupport<MarketProductEntity, DefaultActivityStrategyFactory.DynamicContext, TrialBalanceEntity> {
@Resource
private EndNode endNode;
@Override
protected TrialBalanceEntity doApply(MarketProductEntity requestParameter, DefaultActivityStrategyFactory.DynamicContext dynamicContext) throws Exception {
// 获取拼团活动配置
GroupBuyActivityDiscountVO groupBuyActivityDiscountVO =
dynamicContext.getGroupBuyActivityDiscountVO();
String tagId = groupBuyActivityDiscountVO.getTagId();
//这个是根据{group_buy_activity}里面配置的tagScope字段来判断是否可见或可参与
//它针对的是非tagId标签的人群，非人群标签会根据scope的配置不可见或不可参与
//人群标签内的则根据userId在redis位图中看该用户是否在tagId的人群标签下
boolean visible = groupBuyActivityDiscountVO.isVisible();
boolean enable = groupBuyActivityDiscountVO.isEnable();
// 人群标签配置为空，则走默认值
if (StringUtils.isBlank(tagId)) {
dynamicContext.setVisible(true);
dynamicContext.setEnable(true);
return router(requestParameter, dynamicContext);
}
// 是否在人群范围内；visible、enable 如果值为 ture 则表示没有配置拼团限制，那么就直接保证为 true 即可
//tagScope用来初步过滤，如果用户是活动配置tagId下的成员，则可见并参与
boolean isWithin = repository.isTagCrowdRange(tagId, requestParameter.getUserId());
dynamicContext.setVisible(visible || isWithin);
dynamicContext.setEnable(enable || isWithin);
return router(requestParameter, dynamicContext);
}
@Override
public StrategyHandler<MarketProductEntity, DefaultActivityStrategyFactory.DynamicContext, TrialBalanceEntity> get(MarketProductEntity requestParameter, DefaultActivityStrategyFactory.DynamicContext dynamicContext) throws Exception {
return endNode;
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/activity/service/trial/node/TagNode.java
|
Java
|
unknown
| 2,896
|
package zack.project.domain.activity.service.trial.thread;
import zack.project.domain.activity.adapter.repository.IActivityRepository;
import zack.project.domain.activity.model.valobj.GroupBuyActivityDiscountVO;
import zack.project.domain.activity.model.valobj.SCSkuActivityVO;
import java.util.concurrent.Callable;
/**
* @author zack.project
* @description 查询营销配置任务
* @create 2024-12-21 09:46
*/
public class QueryGroupBuyActivityDiscountVOThreadTask implements Callable<GroupBuyActivityDiscountVO> {
/**
* 活动ID
*/
private final Long activityId;
/**
* 来源
*/
private final String source;
/**
* 渠道
*/
private final String channel;
/**
* 商品ID
*/
private final String goodsId;
/**
* 活动仓储
*/
private final IActivityRepository activityRepository;
public QueryGroupBuyActivityDiscountVOThreadTask(Long activityId, String source, String channel, String goodsId, IActivityRepository activityRepository) {
this.activityId = activityId;
this.source = source;
this.channel = channel;
this.goodsId = goodsId;
this.activityRepository = activityRepository;
}
@Override
public GroupBuyActivityDiscountVO call() throws Exception {
// 判断是否存在可用的活动ID
Long availableActivityId = activityId;
if (null == activityId){
// 查询渠道商品活动配置关联配置
SCSkuActivityVO scSkuActivityVO =
activityRepository.querySCSkuActivityBySCGoodsId(source, channel, goodsId);
if (null == scSkuActivityVO) return null;
availableActivityId = scSkuActivityVO.getActivityId();
}
// 查询活动配置
return activityRepository.queryGroupBuyActivityDiscountVO(availableActivityId);
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/activity/service/trial/thread/QueryGroupBuyActivityDiscountVOThreadTask.java
|
Java
|
unknown
| 1,900
|
package zack.project.domain.activity.service.trial.thread;
import zack.project.domain.activity.adapter.repository.IActivityRepository;
import zack.project.domain.activity.model.valobj.SkuVO;
import java.util.concurrent.Callable;
/**
* @author zack.project
* @description 查询商品信息任务
* @create 2024-12-21 10:51
*/
public class QuerySkuVOFromDBThreadTask implements Callable<SkuVO> {
private final String goodsId;
private final IActivityRepository activityRepository;
public QuerySkuVOFromDBThreadTask(String goodsId, IActivityRepository activityRepository) {
this.goodsId = goodsId;
this.activityRepository = activityRepository;
}
@Override
public SkuVO call() throws Exception {
return activityRepository.querySkuByGoodsId(goodsId);
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/activity/service/trial/thread/QuerySkuVOFromDBThreadTask.java
|
Java
|
unknown
| 814
|
package zack.project.domain.tag.adapter.repository;
import zack.project.domain.tag.model.entity.CrowdTagsJobEntity;
/**
* @author zack.project
* @description 人群标签仓储接口
* @create 2024-12-28 11:26
*/
public interface ITagRepository {
CrowdTagsJobEntity queryCrowdTagsJobEntity(String tagId, String batchId);
void addCrowdTagsUserId(String tagId, String userId);
void updateCrowdTagsStatistics(String tagId, int count);
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/tag/adapter/repository/ITagRepository.java
|
Java
|
unknown
| 456
|
package zack.project.domain.tag.adapter.repository;
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/tag/adapter/repository/package-info.java
|
Java
|
unknown
| 51
|
/**
* 聚合对象；
* 1. 聚合实体和值对象
* 2. 聚合是聚合的对象，和提供基础处理对象的方法。但不建议在聚合中引入仓储和接口来做过大的逻辑。而这些复杂的操作应该放到service中处理
* 3. 对象名称 XxxAggregate
*/
package zack.project.domain.tag.model.aggregate;
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/tag/model/aggregate/package-info.java
|
Java
|
unknown
| 332
|
package zack.project.domain.tag.model.entity;
import lombok.*;
import java.util.Date;
@Getter
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class CrowdTagJobEntity {
/** 标签类型（参与量、消费金额） */
private Integer tagType;
/** 标签规则（限定类型 N次） */
private String tagRule;
/** 统计数据，开始时间 */
private Date statStartTime;
/** 统计数据，结束时间 */
private Date statEndTime;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/tag/model/entity/CrowdTagJobEntity.java
|
Java
|
unknown
| 478
|
package zack.project.domain.tag.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* @author zack.project
* @description 批次任务对象
* @create 2024-12-28 13:00
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class CrowdTagsJobEntity {
/** 标签类型（参与量、消费金额） */
private Integer tagType;
/** 标签规则（限定类型 N次） */
private String tagRule;
/** 统计数据，开始时间 */
private Date statStartTime;
/** 统计数据，结束时间 */
private Date statEndTime;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/tag/model/entity/CrowdTagsJobEntity.java
|
Java
|
unknown
| 667
|
/**
* 实体对象；
* 1. 一般和数据库持久化对象1v1的关系，但因各自开发系统的不同，也有1vn的可能。
* 2. 如果是老系统改造，那么旧的库表冗余了太多的字段，可能会有nv1的情况
* 3. 对象名称 XxxEntity
*/
package zack.project.domain.tag.model.entity;
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/tag/model/entity/package-info.java
|
Java
|
unknown
| 316
|
/**
* 值对象；
* 1. 用于描述对象属性的值，如一个库表中有json后者一个字段多个属性信息的枚举对象
* 2. 对象名称如；XxxVO
*/
package zack.project.domain.tag.model.valobj;
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/tag/model/valobj/package-info.java
|
Java
|
unknown
| 215
|
package zack.project.domain.tag.service;
/**
* @author zack.project
* @description 人群标签服务接口
* @create 2024-12-28 11:26
*/
public interface ITagService {
/**
* 执行人群标签批次任务
*
* @param tagId 人群ID
* @param batchId 批次ID
*/
void execTagBatchJob(String tagId, String batchId);
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/tag/service/ITagService.java
|
Java
|
unknown
| 357
|
package zack.project.domain.tag.service;
import zack.project.domain.tag.adapter.repository.ITagRepository;
import zack.project.domain.tag.model.entity.CrowdTagsJobEntity;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
/**
* @author zack.project
* @description 人群标签服务
* @create 2024-12-28 12:51
*/
@Slf4j
@Service
public class TagService implements ITagService {
@Resource
private ITagRepository repository;
@Override
public void execTagBatchJob(String tagId, String batchId) {
log.info("人群标签批次任务 tagId:{} batchId:{}", tagId, batchId);
// 1. 查询批次任务
CrowdTagsJobEntity crowdTagsJobEntity = repository.queryCrowdTagsJobEntity(tagId, batchId);
// 2. 采集用户数据 - 这部分需要采集用户的消费类数据，后续有用户发起拼单后再处理。
// 3. 数据写入记录
List<String> userIdList = new ArrayList<String>() {{
add("xiaofuge");
add("liergou");
add("xfg01");
add("xfg02");
add("xfg03");
add("xfg04");
add("xfg05");
add("xfg06");
add("xfg07");
add("xfg08");
add("xfg09");
}};
// 4. 一般人群标签的处理在公司中，会有专门的数据数仓团队通过脚本方式写入到数据库，就不用这样一个个或者批次来写。
for (String userId : userIdList) {
repository.addCrowdTagsUserId(tagId, userId);
}
// 5. 更新人群标签统计量
repository.updateCrowdTagsStatistics(tagId, userIdList.size());
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/tag/service/TagService.java
|
Java
|
unknown
| 1,784
|
package zack.project.domain.trade.adapter.port;
import zack.project.domain.trade.model.entity.NotifyTaskEntity;
/**
* @author A1793
*/
public interface IRebatePort {
String sendRebate(NotifyTaskEntity notifyTaskEntity);
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/adapter/port/IRebatePort.java
|
Java
|
unknown
| 232
|
package zack.project.domain.trade.adapter.port;
import zack.project.domain.trade.model.entity.NotifyTaskEntity;
/**
* @description 交易接口服务接口
* @create 2025-01-31 10:38
*/
public interface ITradePort {
String groupBuyNotify(NotifyTaskEntity notifyTask) throws Exception;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/adapter/port/ITradePort.java
|
Java
|
unknown
| 298
|
package zack.project.domain.trade.adapter.repository;
import zack.project.domain.activity.model.entity.UserGroupBuyOrderDetailEntity;
import zack.project.domain.trade.model.aggregate.GroupBuyOrderAggregate;
import zack.project.domain.trade.model.aggregate.GroupBuyRefundAggregate;
import zack.project.domain.trade.model.aggregate.GroupBuyTeamSettlementAggregate;
import zack.project.domain.trade.model.entity.GroupBuyActivityEntity;
import zack.project.domain.trade.model.entity.GroupBuyTeamEntity;
import zack.project.domain.trade.model.entity.MarketPayOrderEntity;
import zack.project.domain.trade.model.entity.NotifyTaskEntity;
import zack.project.domain.trade.model.valobj.GroupBuyProgressVO;
import java.util.List;
/**
* @author zack.project
* @description 交易仓储服务接口
* @create 2025-01-11 09:07
*/
public interface ITradeRepository {
MarketPayOrderEntity queryMarketPayOrderEntityByOutTradeNo(String userId, String outTradeNo);
MarketPayOrderEntity lockMarketPayOrder(GroupBuyOrderAggregate groupBuyOrderAggregate);
GroupBuyProgressVO queryGroupBuyProgress(String teamId);
GroupBuyActivityEntity queryGroupBuyActivityEntityByActivityId(Long activityId);
Integer queryOrderCountByActivityId(Long activityId, String userId);
GroupBuyTeamEntity queryGroupBuyTeamByTeamId(String teamId);
List<NotifyTaskEntity> settlementMarketPayOrder(GroupBuyTeamSettlementAggregate groupBuyTeamSettlementAggregate);
boolean isSCBlackIntercept(String source, String channel);
List<NotifyTaskEntity> queryUnExecutedNotifyTaskList();
List<NotifyTaskEntity> queryUnExecutedNotifyTaskList(String teamId);
int updateNotifyTaskStatusSuccess(NotifyTaskEntity notifyTaskEntity);
int updateNotifyTaskStatusError(NotifyTaskEntity notifyTaskEntity);
int updateNotifyTaskStatusRetry(NotifyTaskEntity notifyTaskEntity);
boolean occupyTeamStock(String teamStockKey, String recoveryTeamStockKey, Integer target, Integer validTime);
void recoveryTeamStock(String recoveryTeamStockKey, Integer validTime);
NotifyTaskEntity unpaid2Refund(GroupBuyRefundAggregate groupBuyRefundAggregate);
NotifyTaskEntity paid2Refund(GroupBuyRefundAggregate groupBuyRefundAggregate);
NotifyTaskEntity paidTeam2Refund(GroupBuyRefundAggregate groupBuyRefundAggregate);
void refund2AddRecovery(String recoveryTeamStockKey, String orderId);
List<UserGroupBuyOrderDetailEntity> queryTimeoutUnpaidOrderList();
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/adapter/repository/ITradeRepository.java
|
Java
|
unknown
| 2,479
|
package zack.project.domain.trade.model.aggregate;
import zack.project.domain.trade.model.entity.PayActivityEntity;
import zack.project.domain.trade.model.entity.PayDiscountEntity;
import zack.project.domain.trade.model.entity.UserEntity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @description 拼团订单聚合对象；聚合可以理解用各个四肢、身体、头等组装出来一个人
* @create 2025-01-11 10:07
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class GroupBuyOrderAggregate {
/** 用户实体对象 */
private UserEntity userEntity;
/** 支付活动实体对象 */
private PayActivityEntity payActivityEntity;
/** 支付优惠实体对象 */
private PayDiscountEntity payDiscountEntity;
/** 已参与拼团量 */
private Integer userTakeOrderCount;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/aggregate/GroupBuyOrderAggregate.java
|
Java
|
unknown
| 904
|
package zack.project.domain.trade.model.aggregate;
import zack.project.domain.trade.model.entity.TradeRefundOrderEntity;
import zack.project.domain.trade.model.valobj.GroupBuyProgressVO;
import zack.project.types.enums.GroupBuyOrderEnumVO;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 拼团退单聚合
*
* 2025/7/11 19:30
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class GroupBuyRefundAggregate {
/**
* 交易退单
*/
private TradeRefundOrderEntity tradeRefundOrderEntity;
/**
* 退单进度
*/
private GroupBuyProgressVO groupBuyProgress;
/**
* 拼团枚举
*/
private GroupBuyOrderEnumVO groupBuyOrderEnumVO;
public static GroupBuyRefundAggregate buildUnpaid2RefundAggregate(TradeRefundOrderEntity tradeRefundOrderEntity,
Integer lockCount) {
GroupBuyRefundAggregate groupBuyRefundAggregate = new GroupBuyRefundAggregate();
groupBuyRefundAggregate.setTradeRefundOrderEntity(tradeRefundOrderEntity);
groupBuyRefundAggregate.setGroupBuyProgress(
GroupBuyProgressVO.builder()
.lockCount(lockCount)
.build());
return groupBuyRefundAggregate;
}
public static GroupBuyRefundAggregate buildPaid2RefundAggregate(TradeRefundOrderEntity tradeRefundOrderEntity,
Integer lockCount,
Integer completeCount) {
GroupBuyRefundAggregate groupBuyRefundAggregate = new GroupBuyRefundAggregate();
groupBuyRefundAggregate.setTradeRefundOrderEntity(tradeRefundOrderEntity);
groupBuyRefundAggregate.setGroupBuyProgress(
GroupBuyProgressVO.builder()
.lockCount(lockCount)
.completeCount(completeCount)
.build());
return groupBuyRefundAggregate;
}
public static GroupBuyRefundAggregate buildPaidTeam2RefundAggregate(TradeRefundOrderEntity tradeRefundOrderEntity,
Integer lockCount,
Integer completeCount,
GroupBuyOrderEnumVO groupBuyOrderEnumVO) {
GroupBuyRefundAggregate groupBuyRefundAggregate = new GroupBuyRefundAggregate();
groupBuyRefundAggregate.setTradeRefundOrderEntity(tradeRefundOrderEntity);
groupBuyRefundAggregate.setGroupBuyProgress(
GroupBuyProgressVO.builder()
.lockCount(lockCount)
.completeCount(completeCount)
.build());
groupBuyRefundAggregate.setGroupBuyOrderEnumVO(groupBuyOrderEnumVO);
return groupBuyRefundAggregate;
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/aggregate/GroupBuyRefundAggregate.java
|
Java
|
unknown
| 3,069
|
package zack.project.domain.trade.model.aggregate;
import zack.project.domain.trade.model.entity.GroupBuyTeamEntity;
import zack.project.domain.trade.model.entity.TradePaySuccessEntity;
import zack.project.domain.trade.model.entity.UserEntity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author zack.project
* @description 拼团组队结算聚合
* @create 2025-01-26 16:38
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class GroupBuyTeamSettlementAggregate {
/** 用户实体对象 */
private UserEntity userEntity;
/** 拼团组队实体对象 */
private GroupBuyTeamEntity groupBuyTeamEntity;
/** 交易支付订单实体对象 */
private TradePaySuccessEntity tradePaySuccessEntity;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/aggregate/GroupBuyTeamSettlementAggregate.java
|
Java
|
unknown
| 813
|
package zack.project.domain.trade.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import zack.project.types.enums.ActivityStatusEnumVO;
import java.util.Date;
/**
* @author zack.project
* @description 拼团活动实体对象
* @create 2025-01-25 12:23
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class GroupBuyActivityEntity {
/** 活动ID */
private Long activityId;
/** 活动名称 */
private String activityName;
/** 折扣ID */
private String discountId;
/** 拼团方式（0自动成团、1达成目标拼团） */
private Integer groupType;
/** 拼团次数限制 */
private Integer takeLimitCount;
/** 拼团目标 */
private Integer target;
/** 拼团时长（分钟） */
private Integer validTime;
/** 活动状态（0创建、1生效、2过期、3废弃） */
private ActivityStatusEnumVO status;
/** 活动开始时间 */
private Date startTime;
/** 活动结束时间 */
private Date endTime;
/** 人群标签规则标识 */
private String tagId;
/** 人群标签规则范围 */
private String tagScope;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/entity/GroupBuyActivityEntity.java
|
Java
|
unknown
| 1,222
|
package zack.project.domain.trade.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import zack.project.domain.trade.model.valobj.NotifyConfigVO;
import zack.project.types.enums.GroupBuyOrderEnumVO;
import java.util.Date;
/**拼团队伍实体，对应{group_buy_order}
* @author A1793
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class GroupBuyTeamEntity {
/** 拼单组队ID */
private String teamId;
/** 活动ID */
private Long activityId;
/** 目标数量 */
private Integer targetCount;
/** 完成数量 */
private Integer completeCount;
/** 锁单数量 */
private Integer lockCount;
/** 状态（0-拼单中、1-完成、2-失败） */
private GroupBuyOrderEnumVO status;
/** 拼团开始时间 - 参与拼团时间 */
private Date validStartTime;
/** 拼团结束时间 - 拼团有效时长 */
private Date validEndTime;
/** 回调配置 ，在结算时，当targetCount - completeCount== 1的时候会构建回调任务插入到数据库(任务补偿)，并进行发起回调(保证实时性),
* 所以在查询拼团队伍的时候，需要把{group_buy_order}里面配置的回调信息也一起查询出来(这个回调配置是团主发起拼团的时候，由外部系统传入的)
* */
private NotifyConfigVO notifyConfigVO;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/entity/GroupBuyTeamEntity.java
|
Java
|
unknown
| 1,427
|
package zack.project.domain.trade.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import zack.project.domain.trade.model.valobj.TradeOrderStatusEnumVO;
import java.math.BigDecimal;
/**拼团详单(预购单，下单了但未支付 ||拼团详单,下单了且已支付),对应{group_buy_order_list}
* @author A1793
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class MarketPayOrderEntity {
/** 拼单组队ID */
private String teamId;
/** 预购订单ID */
private String orderId;
/** 原始价格 */
private BigDecimal originalPrice;
/** 折扣金额 */
private BigDecimal deductionPrice;
/** 支付金额 */
private BigDecimal payPrice;
/** 交易订单状态枚举 */
private TradeOrderStatusEnumVO tradeOrderStatusEnumVO;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/entity/MarketPayOrderEntity.java
|
Java
|
unknown
| 877
|
package zack.project.domain.trade.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @description 回调任务实体
* @create 2025-01-31 10:41
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class NotifyTaskEntity {
/**
* 拼单组队ID
*/
private String teamId;
/**
* 回调类型
*/
private String notifyType;
/**
* 回调消息
*/
private String notifyMQ;
/**
* 回调接口
*/
private String notifyUrl;
private String notifyRpc;
/**
* 回调次数
*/
private Integer notifyCount;
/**
* 参数对象
*/
private String parameterJson;
/**
* 唯一标识
*/
private String uuid;
public String lockKey() {
return "notify_job_lock_key_" + this.uuid;
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/entity/NotifyTaskEntity.java
|
Java
|
unknown
| 903
|
package zack.project.domain.trade.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* @description 拼团，支付活动实体对象
* 映射数据库表{group_buy_order}
* @create 2025-01-05 16:48
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class PayActivityEntity {
/** 拼单组队ID */
private String teamId;
/** 活动ID */
private Long activityId;
/** 活动名称 */
private String activityName;
/** 拼团开始时间 */
private Date startTime;
/** 拼团结束时间 */
private Date endTime;
/** 拼团时长（分钟）*/
private Integer validTime;
/** 目标数量 */
private Integer targetCount;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/entity/PayActivityEntity.java
|
Java
|
unknown
| 796
|
package zack.project.domain.trade.model.entity;
import zack.project.domain.trade.model.valobj.NotifyConfigVO;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
/**
* @description 拼团，支付优惠实体对象
* 映射数据库表{group_buy_order_list}
* @create 2025-01-05 16:46
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class PayDiscountEntity {
/** 渠道 */
private String source;
/** 来源 */
private String channel;
/** 商品ID */
private String goodsId;
/** 商品名称 */
private String goodsName;
/** 原始价格 */
private BigDecimal originalPrice;
/** 折扣金额 */
private BigDecimal deductionPrice;
/** 支付金额 */
private BigDecimal payPrice;
/** 外部交易单号-确保外部调用唯一幂等 */
private String outTradeNo;
/** 回调配置 */
private NotifyConfigVO notifyConfigVO;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/entity/PayDiscountEntity.java
|
Java
|
unknown
| 1,007
|
package zack.project.domain.trade.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author zack.project
* @description 拼团交易命令实体
* @create 2025-01-25 09:09
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class TradeLockRuleCommandEntity {
/** 用户ID */
private String userId;
/** 活动ID */
private Long activityId;
/** 组队ID */
private String teamId;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/entity/TradeLockRuleCommandEntity.java
|
Java
|
unknown
| 504
|
package zack.project.domain.trade.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author zack.project
* @description 拼团交易，过滤反馈实体
* @create 2025-01-25 14:16
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class TradeLockRuleFilterBackEntity {
// 用户参与活动的订单量
private Integer userTakeOrderCount;
// 恢复组队库存缓存key
private String recoveryTeamStockKey;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/entity/TradeLockRuleFilterBackEntity.java
|
Java
|
unknown
| 528
|
package zack.project.domain.trade.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author zack.project
* @description 交易结算订单实体
* @create 2025-01-26 14:54
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class TradePaySettlementEntity {
/** 渠道 */
private String source;
/** 来源 */
private String channel;
/** 用户ID */
private String userId;
/** 拼单组队ID */
private String teamId;
/** 活动ID */
private Long activityId;
/** 外部交易单号 */
private String outTradeNo;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/entity/TradePaySettlementEntity.java
|
Java
|
unknown
| 660
|
package zack.project.domain.trade.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**交易成功支付实体
* @author A1793
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class TradePaySuccessEntity {
/** 渠道 */
private String source;
/** 来源 */
private String channel;
/** 用户ID */
private String userId;
/** 外部交易单号 */
private String outTradeNo;
/** 外部交易时间 */
private Date outTradeTime;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/entity/TradePaySuccessEntity.java
|
Java
|
unknown
| 589
|
package zack.project.domain.trade.model.entity;
import lombok.*;
/**
* 退单行动
*
* @author zack
* 2025/7/12 07:50
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class TradeRefundBehaviorEntity {
/**
* 用户ID
*/
private String userId;
/**
* 订单ID
*/
private String orderId;
/**
* 组队ID
*/
private String teamId;
/**
* 行为枚举
*/
private TradeRefundBehaviorEnum tradeRefundBehaviorEnum;
@Getter
@AllArgsConstructor
@NoArgsConstructor
public enum TradeRefundBehaviorEnum {
SUCCESS("success", "成功"),
REPEAT("repeat", "重复"),
FAIL("fail", "失败"),
;
private String code;
private String info;
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/entity/TradeRefundBehaviorEntity.java
|
Java
|
unknown
| 791
|
package zack.project.domain.trade.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 退单实体对象
*
* 2025/7/8 08:03
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class TradeRefundCommandEntity {
/**
* 用户ID
*/
private String userId;
/**
* 外部交易单号
* 这个外部单号应和锁单时，传入的请求锁单dto的outTradeNo一致，这个单号会添加到{group_buy_order_list}中，
* 请求结算时也会传入一个outTradeNo，这个外部单号是和发起锁单的传入的外部单号一致，它们针对的是同一笔订单
* 所以退单命令实体的外部单号也是
*/
private String outTradeNo;
/** 渠道 */
private String source;
/** 来源 */
private String channel;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/entity/TradeRefundCommandEntity.java
|
Java
|
unknown
| 886
|
package zack.project.domain.trade.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 交易退单实体对象
*
* 2025/7/11 19:45
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class TradeRefundOrderEntity {
/**
* 用户ID
*/
private String userId;
/**
* 拼单组队ID
*/
private String teamId;
/**
* 活动ID
*/
private Long activityId;
/**
* 预购订单ID
*/
private String orderId;
/**
* 外部交易单号
*/
private String outTradeNo;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/entity/TradeRefundOrderEntity.java
|
Java
|
unknown
| 642
|
package zack.project.domain.trade.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**订单结算命令实体，外部已经支付完成，
* 需要将该用户的outTradeNo对应的拼团详情单{group_but_order_list}状态改为1，
* 代表已经支付的，并把拼团单{group_buy_order}的complete_count加1
* @author A1793
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class TradeSettlementRuleCommandEntity {
/** 渠道 */
private String source;
/** 来源 */
private String channel;
/** 用户ID */
private String userId;
/** 外部交易单号 */
private String outTradeNo;
/** 外部交易时间 */
private Date outTradeTime;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/entity/TradeSettlementRuleCommandEntity.java
|
Java
|
unknown
| 808
|
package zack.project.domain.trade.model.entity;
import zack.project.types.enums.GroupBuyOrderEnumVO;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class TradeSettlementRuleFilerBackEntity {
/** 拼单组队ID */
private String teamId;
/** 活动ID */
private Long activityId;
/** 目标数量 */
private Integer targetCount;
/** 完成数量 */
private Integer completeCount;
/** 锁单数量 */
private Integer lockCount;
/** 状态（0-拼单中、1-完成、2-失败） */
private GroupBuyOrderEnumVO status;
/** 拼团开始时间 - 参与拼团时间 */
private Date validStartTime;
/** 拼团结束时间 - 拼团有效时长 */
private Date validEndTime;
private String notifyUrl;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/entity/TradeSettlementRuleFilerBackEntity.java
|
Java
|
unknown
| 910
|
package zack.project.domain.trade.model.entity;
import zack.project.domain.trade.model.valobj.NotifyConfigVO;
import zack.project.types.enums.GroupBuyOrderEnumVO;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* @author zack.project
* @description 拼团交易结算规则反馈
* @create 2025-01-29 09:53
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class TradeSettlementRuleFilterBackEntity {
/** 拼单组队ID */
private String teamId;
/** 活动ID */
private Long activityId;
/** 目标数量 */
private Integer targetCount;
/** 完成数量 */
private Integer completeCount;
/** 锁单数量 */
private Integer lockCount;
/** 状态（0-拼单中、1-完成、2-失败） */
private GroupBuyOrderEnumVO status;
/** 拼团开始时间 - 参与拼团时间 */
private Date validStartTime;
/** 拼团结束时间 - 拼团有效时长 */
private Date validEndTime;
/** 回调配置 */
private NotifyConfigVO notifyConfigVO;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/entity/TradeSettlementRuleFilterBackEntity.java
|
Java
|
unknown
| 1,118
|
package zack.project.domain.trade.model.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author zack.project
* @description 用户实体对象
* @create 2025-01-11 09:21
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class UserEntity {
private String userId;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/entity/UserEntity.java
|
Java
|
unknown
| 366
|
package zack.project.domain.trade.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
/**
* @description 拼团进度值对象
* @create 2025-01-11 14:50
*/
@Getter
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class GroupBuyProgressVO {
/** 目标数量 */
private Integer targetCount;
/** 完成数量 */
private Integer completeCount;
/** 锁单数量 */
private Integer lockCount;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/valobj/GroupBuyProgressVO.java
|
Java
|
unknown
| 501
|
package zack.project.domain.trade.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
/**
* @author zack.project
* @description 回调配置值对象
* @create 2025-03-16 16:10
*/
@Getter
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class NotifyConfigVO {
/**
* 回调方式；MQ、HTTP
*/
private NotifyTypeEnumVO notifyType;
/**
* 回调消息
*/
private String notifyMQ;
/**
* 回调地址
*/
private String notifyUrl;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/valobj/NotifyConfigVO.java
|
Java
|
unknown
| 570
|
package zack.project.domain.trade.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
/**
* @author A1793
*/
@Getter
@NoArgsConstructor
@AllArgsConstructor
public enum NotifyTaskCategoryEnumVO {
TRADE_SETTLEMENT("trade_settlement","交易结算"),
TRADE_UNPAID2REFUND("trade_unpaid2refund","交易退单-未支付&未成团"),
TRADE_PAID2REFUND("trade_paid2refund","交易退单-已支付&未成团"),
TRADE_PAID_TEAM2REFUND("trade_paid_team2refund","交易退单-已支付&已成团");
String code;
String info;
public static NotifyTaskCategoryEnumVO getByCode(String code){
for(NotifyTaskCategoryEnumVO vo : NotifyTaskCategoryEnumVO.values()){
if(vo.getCode().equals(code)){
return vo;
}
}
throw new RuntimeException("任务通知类型枚举值不存在: " + code);
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/valobj/NotifyTaskCategoryEnumVO.java
|
Java
|
unknown
| 928
|
package zack.project.domain.trade.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
/**回调类型的枚举
* @author A1793
*/
@Getter
@NoArgsConstructor
@AllArgsConstructor
public enum NotifyTaskTypeEnumVO {
MQ("MQ","MQ消息通知"),
HTTP("HTTP","http方法回调");
String code;
String info;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/valobj/NotifyTaskTypeEnumVO.java
|
Java
|
unknown
| 375
|
package zack.project.domain.trade.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
/**
* @description 回调方式枚举
* @create 2025-03-16 15:47
*/
@Getter
@AllArgsConstructor
@NoArgsConstructor
public enum NotifyTypeEnumVO {
HTTP("HTTP", "HTTP 回调"),
MQ("MQ", "MQ 消息通知"),
RPC("RPC","rpc调用")
;
private String code;
private String info;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/valobj/NotifyTypeEnumVO.java
|
Java
|
unknown
| 442
|
package zack.project.domain.trade.model.valobj;
import zack.project.types.enums.GroupBuyOrderEnumVO;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import java.util.Arrays;
/**
* 退单类型枚举
*
* @author zack
* 2025/7/11 18:59
*/
@Getter
@AllArgsConstructor
@NoArgsConstructor
public enum RefundTypeEnumVO {
UNPAID_UNLOCK("unpaid_unlock", "unpaid2RefundStrategy", "未支付，未成团") {
@Override
public boolean matches(GroupBuyOrderEnumVO groupBuyOrderEnumVO, TradeOrderStatusEnumVO tradeOrderStatusEnumVO) {
return GroupBuyOrderEnumVO.PROGRESS.equals(groupBuyOrderEnumVO) &&
TradeOrderStatusEnumVO.CREATE.equals(tradeOrderStatusEnumVO);
}
},
PAID_UNFORMED("paid_unformed", "paid2RefundStrategy", "已支付，未成团") {
@Override
public boolean matches(GroupBuyOrderEnumVO groupBuyOrderEnumVO, TradeOrderStatusEnumVO tradeOrderStatusEnumVO) {
return GroupBuyOrderEnumVO.PROGRESS.equals(groupBuyOrderEnumVO) &&
TradeOrderStatusEnumVO.COMPLETE.equals(tradeOrderStatusEnumVO);
}
},
PAID_FORMED("paid_formed", "paidTeam2RefundStrategy", "已支付，已成团") {
@Override
public boolean matches(GroupBuyOrderEnumVO groupBuyOrderEnumVO, TradeOrderStatusEnumVO tradeOrderStatusEnumVO) {
// 完成、完成含退单，都做此处理
return (GroupBuyOrderEnumVO.COMPLETE.equals(groupBuyOrderEnumVO) || GroupBuyOrderEnumVO.COMPLETE_FAIL.equals(groupBuyOrderEnumVO))
&& TradeOrderStatusEnumVO.COMPLETE.equals(tradeOrderStatusEnumVO);
}
},
;
private String code;
private String strategy;
private String info;
/**
* 抽象方法，由每个枚举值实现自己的匹配逻辑
*/
public abstract boolean matches(GroupBuyOrderEnumVO groupBuyOrderEnumVO, TradeOrderStatusEnumVO tradeOrderStatusEnumVO);
/**
* 根据状态组合获取对应的退款策略枚举
*/
public static RefundTypeEnumVO getRefundStrategy(GroupBuyOrderEnumVO groupBuyOrderEnumVO,
TradeOrderStatusEnumVO tradeOrderStatusEnumVO) {
return Arrays.stream(values())
.filter(refundType -> refundType.matches(groupBuyOrderEnumVO, tradeOrderStatusEnumVO))
.findFirst()
.orElseThrow(() -> new RuntimeException("不支持的退款状态组合: groupBuyOrderStatus=" + groupBuyOrderEnumVO + ", tradeOrderStatus=" + tradeOrderStatusEnumVO));
}
public static RefundTypeEnumVO getRefundTypeEnumVOByCode(String code) {
switch (code) {
case "unpaid_unlock":
return UNPAID_UNLOCK;
case "paid_unformed":
return PAID_UNFORMED;
case "paid_formed":
return PAID_FORMED;
}
throw new RuntimeException("退单类型枚举值不存在: " + code);
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/valobj/RefundTypeEnumVO.java
|
Java
|
unknown
| 3,053
|
package zack.project.domain.trade.model.valobj;
import zack.project.types.enums.GroupBuyOrderEnumVO;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import java.util.Arrays;
/**
* 退单类型
*
* @author A1793
*/
@Getter
@NoArgsConstructor
@AllArgsConstructor
public enum RefundTypeVO {
UNPAID_UNLOCK("unpaid_unlock", "unpaid_refund", "未支付,未成团") {
@Override
public boolean match(TradeOrderStatusEnumVO tradeOrderStatusEnumVO, GroupBuyOrderEnumVO groupBuyOrderEnumVO) {
if (tradeOrderStatusEnumVO.getCode().equals(TradeOrderStatusEnumVO.CREATE.getCode())
&& groupBuyOrderEnumVO.getCode().equals(GroupBuyOrderEnumVO.PROGRESS.getCode())) {
return true;
}
return false;
}
},
PAID_UNFORMED("paid_unformed", "paid_refund", "已支付,未成团") {
@Override
public boolean match(TradeOrderStatusEnumVO tradeOrderStatusEnumVO, GroupBuyOrderEnumVO groupBuyOrderEnumVO) {
if (tradeOrderStatusEnumVO.getCode().equals(TradeOrderStatusEnumVO.COMPLETE) &&
groupBuyOrderEnumVO.getCode().equals(GroupBuyOrderEnumVO.PROGRESS.getCode())) {
return true;
}
return false;
}
},
PAID_FORMED("paid_formed", "paidTeam_refund", "已支付,已成团") {
@Override
public boolean match(TradeOrderStatusEnumVO tradeOrderStatusEnumVO, GroupBuyOrderEnumVO groupBuyOrderEnumVO) {
if ((groupBuyOrderEnumVO.getCode().equals(GroupBuyOrderEnumVO.COMPLETE.getCode()) || groupBuyOrderEnumVO.getCode().equals(GroupBuyOrderEnumVO.COMPLETE_FAIL.getCode()))
&& tradeOrderStatusEnumVO.getCode().equals(TradeOrderStatusEnumVO.COMPLETE.getCode())) {
return true;
}
return false;
}
};
String code;
String strategy;
String info;
public abstract boolean match(TradeOrderStatusEnumVO tradeOrderStatusEnumVO, GroupBuyOrderEnumVO groupBuyOrderEnumVO);
public static RefundTypeVO getRefundStrategy(TradeOrderStatusEnumVO tradeOrderStatusEnumVO, GroupBuyOrderEnumVO groupBuyOrderEnumVO) {
return Arrays.stream(values())
.filter(vo->vo.match(tradeOrderStatusEnumVO, groupBuyOrderEnumVO)).findFirst()
.orElseThrow(() -> new RuntimeException("不支持的退款状态组合: groupBuyOrderStatus=" + groupBuyOrderEnumVO + ", tradeOrderStatus=" + tradeOrderStatusEnumVO));
}
public static RefundTypeVO getRefundTypeEnumVOByCode(String code) {
switch (code) {
case "unpaid_unlock":
return UNPAID_UNLOCK;
case "paid_unformed":
return PAID_UNFORMED;
case "paid_formed":
return PAID_FORMED;
}
throw new RuntimeException("退单类型枚举值不存在: " + code);
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/valobj/RefundTypeVO.java
|
Java
|
unknown
| 2,971
|
package zack.project.domain.trade.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
/**
* 任务类型枚举
*
* 2025/7/18 21:35
*/
@Getter
@AllArgsConstructor
@NoArgsConstructor
public enum TaskNotifyCategoryEnumVO {
TRADE_SETTLEMENT("trade_settlement","交易结算"),
TRADE_UNPAID2REFUND("trade_unpaid2refund","交易退单-未支付&未成团"),
TRADE_PAID2REFUND("trade_paid2refund","交易退单-已支付&未成团"),
TRADE_PAID_TEAM2REFUND("trade_paid_team2refund","交易退单-已支付&已成团"),
GROUP_REBATE("group_rebate","拼团行为返利")
;
private String code;
private String info;
/**
* 根据code值获取对应的枚举
*/
public static TaskNotifyCategoryEnumVO getByCode(String code) {
for (TaskNotifyCategoryEnumVO enumVO : values()) {
if (enumVO.getCode().equals(code)) {
return enumVO;
}
}
throw new RuntimeException("任务通知类型枚举值不存在: " + code);
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/valobj/TaskNotifyCategoryEnumVO.java
|
Java
|
unknown
| 1,082
|
package zack.project.domain.trade.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 拼团退单消息
*
* 2025/7/29 09:15
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class TeamRefundSuccess {
/**
* 退单类型
*/
private String type;
/**
* 用户ID
*/
private String userId;
/**
* 拼单组队ID
*/
private String teamId;
/**
* 活动ID
*/
private Long activityId;
/**
* 预购订单ID
*/
private String orderId;
/**
* 外部交易单号
*/
private String outTradeNo;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/valobj/TeamRefundSuccess.java
|
Java
|
unknown
| 693
|
package zack.project.domain.trade.model.valobj;
import lombok.*;
/**
* @author A1793
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class TeamRefundSuccessVO {
//退单类型:未支付且未成团，支付且未成团，支付且成团
private String refundType;
private String userId;
private Long activityId;
private String teamId;
private String orderId;
private String outTradeNo;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/valobj/TeamRefundSuccessVO.java
|
Java
|
unknown
| 445
|
package zack.project.domain.trade.model.valobj;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
/**
* @description 交易订单状态枚举
* @create 2025-01-11 10:21
*/
@Getter
@AllArgsConstructor
@NoArgsConstructor
public enum TradeOrderStatusEnumVO {
CREATE(0, "初始创建"),
COMPLETE(1, "消费完成"),
CLOSE(2, "用户退单"),
;
private Integer code;
private String info;
public static TradeOrderStatusEnumVO valueOf(Integer code) {
switch (code) {
case 0:
return CREATE;
case 1:
return COMPLETE;
case 2:
return CLOSE;
}
return CREATE;
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/model/valobj/TradeOrderStatusEnumVO.java
|
Java
|
unknown
| 739
|
package zack.project.domain.trade.service;
import zack.project.domain.trade.model.entity.*;
import zack.project.domain.trade.model.valobj.GroupBuyProgressVO;
/**
* @author zack.project
* @description 拼团交易锁单服务接口
* @create 2025-01-05 16:42
*/
public interface ITradeLockOrderService {
/**
* 查询，未被支付消费完成的营销优惠订单
*
* @param userId 用户ID
* @param outTradeNo 外部唯一单号
* @return 拼团，预购订单营销实体对象
*/
MarketPayOrderEntity queryNoPayMarketPayOrderByOutTradeNo(String userId, String outTradeNo);
/**
* 查询拼团进度
*
* @param teamId 拼团ID
* @return 进度
*/
GroupBuyProgressVO queryGroupBuyProgress(String teamId);
/**
* 锁定，营销预支付订单；商品下单前，预购锁定。
*
* @param userEntity 用户根实体对象
* @param payActivityEntity 拼团，支付活动实体对象
* @param payDiscountEntity 拼团，支付优惠实体对象
* @return 拼团，预购订单营销实体对象
*/
MarketPayOrderEntity lockMarketPayOrder(UserEntity userEntity, PayActivityEntity payActivityEntity, PayDiscountEntity payDiscountEntity) throws Exception;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/ITradeLockOrderService.java
|
Java
|
unknown
| 1,289
|
package zack.project.domain.trade.service;
import zack.project.domain.activity.model.entity.UserGroupBuyOrderDetailEntity;
import zack.project.domain.trade.model.entity.TradeRefundBehaviorEntity;
import zack.project.domain.trade.model.entity.TradeRefundCommandEntity;
import zack.project.domain.trade.model.valobj.TeamRefundSuccess;
import java.util.List;
/**
* 退单，逆向流程接口
*
* 2025/7/8 07:24
*/
public interface ITradeRefundOrderService {
TradeRefundBehaviorEntity refundOrder(TradeRefundCommandEntity tradeRefundCommandEntity) throws Exception;
/**
* 退单恢复锁单库存
* @param teamRefundSuccess 退单消息
* @throws Exception 异常
*/
void restoreTeamLockStock(TeamRefundSuccess teamRefundSuccess) throws Exception;
/**
* 查询超时未支付订单列表
* 条件：当前时间不在活动时间范围内、状态为0（初始锁定）、out_trade_time为空
* @return 超时未支付订单列表，限制10条
*/
List<UserGroupBuyOrderDetailEntity> queryTimeoutUnpaidOrderList();
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/ITradeRefundOrderService.java
|
Java
|
unknown
| 1,085
|
package zack.project.domain.trade.service;
import zack.project.domain.trade.model.entity.TradeRefundBehaviorEntity;
import zack.project.domain.trade.model.entity.TradeRefundCommandEntity;
/**
* @author A1793
*/
public interface ITradeRefundService {
public TradeRefundBehaviorEntity refund(TradeRefundCommandEntity tradeRefundCommandEntity ) throws Exception;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/ITradeRefundService.java
|
Java
|
unknown
| 372
|
package zack.project.domain.trade.service;
import zack.project.domain.trade.model.entity.TradePaySettlementEntity;
import zack.project.domain.trade.model.entity.TradePaySuccessEntity;
/**
* @description 拼团交易结算服务接口
* @create 2025-01-26 14:34
*/
public interface ITradeSettlementOrderService {
/**
* 营销结算
*
* @param tradePaySuccessEntity 交易支付订单实体对象
* @return 交易结算订单实体
*/
TradePaySettlementEntity settlementMarketPayOrder(TradePaySuccessEntity tradePaySuccessEntity) throws Exception;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/ITradeSettlementOrderService.java
|
Java
|
unknown
| 588
|
package zack.project.domain.trade.service;
import zack.project.domain.trade.model.entity.NotifyTaskEntity;
import java.util.List;
import java.util.Map;
/**
* 交易任务（MT/HTTP）服务接口
*
* @author zack
* 2025/7/12 21:15
*/
public interface ITradeTaskService {
/**
* 执行结算通知任务
*
* @return 结算数量
* @throws Exception 异常
*/
Map<String, Integer> execNotifyJob() throws Exception;
/**
* 执行结算通知任务
*
* @param teamId 指定结算组ID
* @return 结算数量
* @throws Exception 异常
*/
Map<String, Integer> execNotifyJob(String teamId) throws Exception;
/**
* 执行结算通知任务
*
* @param notifyTaskEntity 通知任务对象
* @return 结算数量
* @throws Exception 异常
*/
Map<String, Integer> execNotifyJob(NotifyTaskEntity notifyTaskEntity) throws Exception;
Map<String, Integer> execNotifyJob(List<NotifyTaskEntity> notifyTaskEntity) throws Exception;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/ITradeTaskService.java
|
Java
|
unknown
| 1,043
|
package zack.project.domain.trade.service.lock;
import zack.project.domain.trade.adapter.repository.ITradeRepository;
import zack.project.domain.trade.model.aggregate.GroupBuyOrderAggregate;
import zack.project.domain.trade.model.entity.*;
import zack.project.domain.trade.model.valobj.GroupBuyProgressVO;
import zack.project.domain.trade.service.ITradeLockOrderService;
import zack.project.domain.trade.service.lock.factory.TradeLockRuleFilterFactory;
import cn.bugstack.wrench.design.framework.link.model2.chain.BusinessLinkedList;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
、 * @description 交易订单服务
* @create 2025-01-11 08:07
*/
@Slf4j
@Service
public class TradeLockOrderService implements ITradeLockOrderService {
@Resource
private ITradeRepository repository;
@Resource
private BusinessLinkedList<TradeLockRuleCommandEntity,
TradeLockRuleFilterFactory.DynamicContext,
TradeLockRuleFilterBackEntity> tradeRuleFilter;
/**
* 查询
* @param userId 用户ID
* @param outTradeNo 外部唯一单号
* @return
*/
@Override
public MarketPayOrderEntity queryNoPayMarketPayOrderByOutTradeNo(String userId, String outTradeNo) {
log.info("拼团交易-查询未支付营销订单:{} outTradeNo:{}", userId, outTradeNo);
return repository.queryMarketPayOrderEntityByOutTradeNo(userId, outTradeNo);
}
@Override
public GroupBuyProgressVO queryGroupBuyProgress(String teamId) {
log.info("拼团交易-查询拼单进度:{}", teamId);
return repository.queryGroupBuyProgress(teamId);
}
@Override
public MarketPayOrderEntity lockMarketPayOrder(UserEntity userEntity,
PayActivityEntity payActivityEntity,
PayDiscountEntity payDiscountEntity) throws Exception {
log.info("拼团交易-锁定营销优惠支付订单:{} activityId:{} goodsId:{}", userEntity.getUserId(), payActivityEntity.getActivityId(), payDiscountEntity.getGoodsId());
// 交易规则过滤
TradeLockRuleFilterBackEntity tradeLockRuleFilterBackEntity =
//构建锁单指令实体：
// 用户id：UserTakeLimitRuleFilter节点会根据该用户的id和dynamicContext上下文中设置的groupBuyActivity的活动id，
// 去查询{group_buy_order_list}获得该用户在该活动的参与次数，如果超过groupBuyActivity限制的参与次数会报错
// 参与拼团的队伍id：可以是空，空就是发起拼团创建拼团队伍，非空就是参与别人的拼团队伍。
// 参与的活动的id ： activityUsabilityRuleFilter根据该活动id查询拼团活动{group_buy_activity}，判断该活动是否可以有效
tradeRuleFilter.apply(TradeLockRuleCommandEntity.builder()
.activityId(payActivityEntity.getActivityId())
.userId(userEntity.getUserId())
.teamId(payActivityEntity.getTeamId())
.build(),
new TradeLockRuleFilterFactory.DynamicContext());
// 已参与拼团量 - 用于构建数据库唯一索引使用，确保用户只能在一个活动上参与固定的次数
Integer userTakeOrderCount = tradeLockRuleFilterBackEntity.getUserTakeOrderCount();
// 构建聚合对象
GroupBuyOrderAggregate groupBuyOrderAggregate = GroupBuyOrderAggregate.builder()
.userEntity(userEntity)
.payActivityEntity(payActivityEntity)
.payDiscountEntity(payDiscountEntity)
.userTakeOrderCount(userTakeOrderCount)
.build();
try {
// 锁定聚合订单 - 这会用户只是下单还没有支付。后续会有2个流程；支付成功、超时未支付（回退）
return repository.lockMarketPayOrder(groupBuyOrderAggregate);
} catch (Exception e) {
// 记录失败恢复量
//上面的逻辑出错，因为在redis里面对teamStockKey进行了incr操作，所有要给recoveryTeamStock进行incr(不对teamStockKey进行decr操作)，
// 当别的用户再对该teamId进行抢占时，要在活动的targetCount基础上加上recoveryCount再和occupy比较
repository.recoveryTeamStock(tradeLockRuleFilterBackEntity.getRecoveryTeamStockKey(),
payActivityEntity.getValidTime());
throw e;
}
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/lock/TradeLockOrderService.java
|
Java
|
unknown
| 4,717
|
package zack.project.domain.trade.service.lock.factory;
import zack.project.domain.trade.model.entity.GroupBuyActivityEntity;
import zack.project.domain.trade.model.entity.TradeLockRuleCommandEntity;
import zack.project.domain.trade.model.entity.TradeLockRuleFilterBackEntity;
import zack.project.domain.trade.service.lock.filter.ActivityUsabilityRuleFilter;
import zack.project.domain.trade.service.lock.filter.TeamStockOccupyRuleFilter;
import zack.project.domain.trade.service.lock.filter.UserTakeLimitRuleFilter;
import cn.bugstack.wrench.design.framework.link.model2.LinkArmory;
import cn.bugstack.wrench.design.framework.link.model2.chain.BusinessLinkedList;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;
/**
* @author zack.project
* @description 交易规则过滤工厂
* @create 2025-01-25 08:41
*/
@Slf4j
@Service
public class TradeLockRuleFilterFactory {
private static final String teamStockKey = "group_buy_market_team_stock_key_";
/**
* 活动可用过滤，用户参与该活动的次数过滤，用户要参与的拼团的队伍名额过滤
* @param activityUsabilityRuleFilter
* @param userTakeLimitRuleFilter
* @param teamStockOccupyRuleFilter
* @return
*/
@Bean("tradeRuleFilter")
public BusinessLinkedList<TradeLockRuleCommandEntity, DynamicContext, TradeLockRuleFilterBackEntity> tradeRuleFilter(
ActivityUsabilityRuleFilter activityUsabilityRuleFilter,
UserTakeLimitRuleFilter userTakeLimitRuleFilter,
TeamStockOccupyRuleFilter teamStockOccupyRuleFilter) {
// 组装链
LinkArmory<TradeLockRuleCommandEntity, DynamicContext, TradeLockRuleFilterBackEntity> linkArmory =
new LinkArmory<>("交易规则过滤链",
activityUsabilityRuleFilter,
userTakeLimitRuleFilter,
teamStockOccupyRuleFilter);
// 链对象
return linkArmory.getLogicLink();
}
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public static class DynamicContext {
private GroupBuyActivityEntity groupBuyActivity;
private Integer userTakeOrderCount;
public String generateTeamStockKey(String teamId) {
if (StringUtils.isBlank(teamId)) return null;
return TradeLockRuleFilterFactory.generateTeamStockKey(groupBuyActivity.getActivityId(), teamId);
}
public String generateRecoveryTeamStockKey(String teamId) {
if (StringUtils.isBlank(teamId)) return null;
return TradeLockRuleFilterFactory.generateRecoveryTeamStockKey(groupBuyActivity.getActivityId(), teamId);
}
}
public static String generateTeamStockKey(Long activityId, String teamId){
return teamStockKey + activityId + "_" + teamId;
}
public static String generateRecoveryTeamStockKey(Long activityId, String teamId) {
return teamStockKey + activityId + "_" + teamId + "_recovery";
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/lock/factory/TradeLockRuleFilterFactory.java
|
Java
|
unknown
| 3,250
|
package zack.project.domain.trade.service.lock.filter;
import zack.project.domain.trade.adapter.repository.ITradeRepository;
import zack.project.domain.trade.model.entity.GroupBuyActivityEntity;
import zack.project.domain.trade.model.entity.TradeLockRuleCommandEntity;
import zack.project.domain.trade.model.entity.TradeLockRuleFilterBackEntity;
import zack.project.domain.trade.service.lock.factory.TradeLockRuleFilterFactory;
import zack.project.types.enums.ActivityStatusEnumVO;
import zack.project.types.enums.ResponseCode;
import zack.project.types.exception.AppException;
import cn.bugstack.wrench.design.framework.link.model2.handler.ILogicHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Date;
/**
* @description 活动的可用性，规则过滤【状态、有效期】
* @create 2025-01-25 09:18
*/
@Slf4j
@Service
public class ActivityUsabilityRuleFilter implements ILogicHandler<TradeLockRuleCommandEntity, TradeLockRuleFilterFactory.DynamicContext, TradeLockRuleFilterBackEntity> {
@Resource
private ITradeRepository repository;
@Override
public TradeLockRuleFilterBackEntity apply(TradeLockRuleCommandEntity requestParameter,
TradeLockRuleFilterFactory.DynamicContext dynamicContext) throws Exception {
log.info("交易规则过滤-活动的可用性校验{} activityId:{}", requestParameter.getUserId(), requestParameter.getActivityId());
// 查询拼团活动
GroupBuyActivityEntity groupBuyActivity =
repository.queryGroupBuyActivityEntityByActivityId(requestParameter.getActivityId());
// 校验；活动状态 - 可以抛业务异常code，或者把code写入到动态上下文dynamicContext中，最后获取。
if (!ActivityStatusEnumVO.EFFECTIVE.equals(groupBuyActivity.getStatus())) {
log.info("活动的可用性校验，非生效状态 activityId:{}", requestParameter.getActivityId());
throw new AppException(ResponseCode.E0101);
}
// 校验；活动时间
Date currentTime = new Date();
if (currentTime.before(groupBuyActivity.getStartTime()) ||
currentTime.after(groupBuyActivity.getEndTime())) {
log.info("活动的可用性校验，非可参与时间范围 activityId:{}", requestParameter.getActivityId());
throw new AppException(ResponseCode.E0102);
}
// 写入动态上下文
dynamicContext.setGroupBuyActivity(groupBuyActivity);
// 走到下一个责任链节点
return next(requestParameter, dynamicContext);
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/lock/filter/ActivityUsabilityRuleFilter.java
|
Java
|
unknown
| 2,713
|
package zack.project.domain.trade.service.lock.filter;
import zack.project.domain.trade.adapter.repository.ITradeRepository;
import zack.project.domain.trade.model.entity.GroupBuyActivityEntity;
import zack.project.domain.trade.model.entity.TradeLockRuleCommandEntity;
import zack.project.domain.trade.model.entity.TradeLockRuleFilterBackEntity;
import zack.project.domain.trade.service.lock.factory.TradeLockRuleFilterFactory;
import zack.project.types.enums.ResponseCode;
import zack.project.types.exception.AppException;
import cn.bugstack.wrench.design.framework.link.model2.handler.ILogicHandler;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* @author zack.project
* @description 组队库存占用规则过滤
* @create 2025-04-05 09:41
*/
@Slf4j
@Service
public class TeamStockOccupyRuleFilter implements ILogicHandler<TradeLockRuleCommandEntity, TradeLockRuleFilterFactory.DynamicContext, TradeLockRuleFilterBackEntity> {
@Resource
private ITradeRepository repository;
@Override
public TradeLockRuleFilterBackEntity apply(TradeLockRuleCommandEntity requestParameter, TradeLockRuleFilterFactory.DynamicContext dynamicContext) throws Exception {
log.info("交易规则过滤-组队库存校验{} activityId:{}", requestParameter.getUserId(), requestParameter.getActivityId());
// 1. teamId 为空，则为首次开团，不做拼团组队目标量库存限制
String teamId = requestParameter.getTeamId();
if (StringUtils.isBlank(teamId)) {
return TradeLockRuleFilterBackEntity.builder()
.userTakeOrderCount(dynamicContext.getUserTakeOrderCount())
.build();
}
// 2. 抢占库存；通过抢占 Redis 缓存库存，来降低对数据库的操作压力。
GroupBuyActivityEntity groupBuyActivity = dynamicContext.getGroupBuyActivity();
Integer target = groupBuyActivity.getTarget();
Integer validTime = groupBuyActivity.getValidTime();
//队伍名额抢占节点在活动过滤节点(这个节点会查询拼团活动并设置到上下文)之后，
// 在生成缓存key的时候可以只转入teamId，上下文会负责将拼团活动的活动id和队伍id进行拼接
String teamStockKey = dynamicContext.generateTeamStockKey(teamId);
String recoveryTeamStockKey = dynamicContext.generateRecoveryTeamStockKey(teamId);
boolean status = repository.occupyTeamStock(teamStockKey, recoveryTeamStockKey, target, validTime);
if (!status) {
log.warn("交易规则过滤-组队库存校验{} activityId:{} 抢占失败:{}", requestParameter.getUserId(), requestParameter.getActivityId(), teamStockKey);
throw new AppException(ResponseCode.E0008);
}
return TradeLockRuleFilterBackEntity.builder()
.userTakeOrderCount(dynamicContext.getUserTakeOrderCount())
.recoveryTeamStockKey(recoveryTeamStockKey)
.build();
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/lock/filter/TeamStockOccupyRuleFilter.java
|
Java
|
unknown
| 3,127
|
package zack.project.domain.trade.service.lock.filter;
import zack.project.domain.trade.adapter.repository.ITradeRepository;
import zack.project.domain.trade.model.entity.GroupBuyActivityEntity;
import zack.project.domain.trade.model.entity.TradeLockRuleCommandEntity;
import zack.project.domain.trade.model.entity.TradeLockRuleFilterBackEntity;
import zack.project.domain.trade.service.lock.factory.TradeLockRuleFilterFactory;
import zack.project.types.enums.ResponseCode;
import zack.project.types.exception.AppException;
import cn.bugstack.wrench.design.framework.link.model2.handler.ILogicHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* @description 用户参与限制，规则过滤
* @create 2025-01-25 09:19
*/
@Slf4j
@Service
public class UserTakeLimitRuleFilter
implements ILogicHandler<TradeLockRuleCommandEntity, TradeLockRuleFilterFactory.DynamicContext, TradeLockRuleFilterBackEntity> {
@Resource
private ITradeRepository repository;
@Override
public TradeLockRuleFilterBackEntity apply(TradeLockRuleCommandEntity requestParameter, TradeLockRuleFilterFactory.DynamicContext dynamicContext) throws Exception {
log.info("交易规则过滤-用户参与次数校验{} activityId:{}", requestParameter.getUserId(), requestParameter.getActivityId());
GroupBuyActivityEntity groupBuyActivity = dynamicContext.getGroupBuyActivity();
// 查询用户在一个拼团活动上参与的次数
Integer count = repository.queryOrderCountByActivityId(requestParameter.getActivityId(),
requestParameter.getUserId());
if (null != groupBuyActivity.getTakeLimitCount() &&
count >= groupBuyActivity.getTakeLimitCount()) {
log.info("用户参与次数校验，已达可参与上限 activityId:{}", requestParameter.getActivityId());
throw new AppException(ResponseCode.E0103);
}
dynamicContext.setUserTakeOrderCount(count);
// 走到下一个责任链节点
return next(requestParameter, dynamicContext);
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/lock/filter/UserTakeLimitRuleFilter.java
|
Java
|
unknown
| 2,153
|
package zack.project.domain.trade.service.refund;
import zack.project.domain.activity.model.entity.UserGroupBuyOrderDetailEntity;
import zack.project.domain.trade.adapter.repository.ITradeRepository;
import zack.project.domain.trade.model.entity.*;
import zack.project.domain.trade.model.valobj.RefundTypeEnumVO;
import zack.project.domain.trade.model.valobj.TeamRefundSuccess;
import zack.project.domain.trade.service.ITradeRefundOrderService;
import zack.project.domain.trade.service.refund.business.IRefundOrderStrategy;
import zack.project.domain.trade.service.refund.factory.TradeRefundRuleFilterFactory;
import cn.bugstack.wrench.design.framework.link.model2.chain.BusinessLinkedList;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
/**
* 退单，逆向流程服务
*
* 2025/7/8 07:27
*/
@Slf4j
@Service
public class TradeRefundOrderService implements ITradeRefundOrderService {
@Resource
private BusinessLinkedList<TradeRefundCommandEntity,
TradeRefundRuleFilterFactory.DynamicContext,
TradeRefundBehaviorEntity> tradeRefundRuleFilter;
private final ITradeRepository repository;
private final Map<String, IRefundOrderStrategy> refundOrderStrategyMap;
public TradeRefundOrderService(ITradeRepository repository, Map<String, IRefundOrderStrategy> refundOrderStrategyMap) {
this.repository = repository;
this.refundOrderStrategyMap = refundOrderStrategyMap;
}
@Override
public TradeRefundBehaviorEntity refundOrder(TradeRefundCommandEntity tradeRefundCommandEntity) throws Exception {
log.info("逆向流程，退单操作 userId:{} outTradeNo:{}", tradeRefundCommandEntity.getUserId(), tradeRefundCommandEntity.getOutTradeNo());
return tradeRefundRuleFilter.apply(tradeRefundCommandEntity,
new TradeRefundRuleFilterFactory.DynamicContext());
}
@Override
public void restoreTeamLockStock(TeamRefundSuccess teamRefundSuccess) throws Exception {
log.info("逆向流程，恢复锁单量 userId:{} activityId:{} teamId:{}", teamRefundSuccess.getUserId(), teamRefundSuccess.getActivityId(), teamRefundSuccess.getTeamId());
//获取是什么类型的退单请求成功了:
//未支付未成团，支付未成团，支付已成团
String type = teamRefundSuccess.getType();
// 根据枚举值获取对应的退单类型
RefundTypeEnumVO refundTypeEnumVO = RefundTypeEnumVO.getRefundTypeEnumVOByCode(type);
IRefundOrderStrategy refundOrderStrategy = refundOrderStrategyMap.get(refundTypeEnumVO.getStrategy());
// 逆向库存操作，恢复锁单量
refundOrderStrategy.reverseStock(teamRefundSuccess);
}
@Override
public List<UserGroupBuyOrderDetailEntity> queryTimeoutUnpaidOrderList() {
log.info("扫描数据，超时组队未支付订单");
return repository.queryTimeoutUnpaidOrderList();
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/refund/TradeRefundOrderService.java
|
Java
|
unknown
| 3,046
|
package zack.project.domain.trade.service.refund;
import zack.project.domain.trade.model.entity.TradeRefundBehaviorEntity;
import zack.project.domain.trade.model.entity.TradeRefundCommandEntity;
import zack.project.domain.trade.service.ITradeRefundService;
import zack.project.domain.trade.service.refund.factory.TradeRefundRuleFilterFactory;
import zack.project.types.design.framework.link.model2.chain.BusinessLinkedList;
import javax.annotation.Resource;
/**
* @author A1793
*/
public class TradeRefundService implements ITradeRefundService {
@Resource
BusinessLinkedList<TradeRefundCommandEntity,
TradeRefundRuleFilterFactory.DynamicContext,
TradeRefundBehaviorEntity> refundFilter;
@Override
public TradeRefundBehaviorEntity refund(TradeRefundCommandEntity tradeRefundCommandEntity) throws Exception {
return refundFilter.apply(tradeRefundCommandEntity,new TradeRefundRuleFilterFactory.DynamicContext());
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/refund/TradeRefundService.java
|
Java
|
unknown
| 973
|
package zack.project.domain.trade.service.refund.business;
import zack.project.domain.trade.adapter.repository.ITradeRepository;
import zack.project.domain.trade.model.entity.NotifyTaskEntity;
import zack.project.domain.trade.model.valobj.TeamRefundSuccess;
import zack.project.domain.trade.service.ITradeTaskService;
import zack.project.domain.trade.service.lock.factory.TradeLockRuleFilterFactory;
import zack.project.types.exception.AppException;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import javax.annotation.Resource;
import java.util.Map;
import java.util.concurrent.ThreadPoolExecutor;
/**
* 退单策略抽象基类
* 提供共用的依赖注入和MQ消息发送功能
*
* @author zack
* @create 2025-01-01 00:00
*/
@Slf4j
public abstract class AbstractRefundOrderStrategy implements IRefundOrderStrategy {
@Resource
protected ITradeRepository repository;
@Resource
protected ITradeTaskService tradeTaskService;
@Resource
protected ThreadPoolExecutor threadPoolExecutor;
/**
* 异步发送MQ消息
* @param notifyTaskEntity 通知任务实体
* @param refundType 退单类型描述
*/
protected void sendRefundNotifyMessage(NotifyTaskEntity notifyTaskEntity, String refundType) {
if (null != notifyTaskEntity) {
threadPoolExecutor.execute(() -> {
Map<String, Integer> notifyResultMap = null;
try {
notifyResultMap = tradeTaskService.execNotifyJob(notifyTaskEntity);
log.info("回调通知交易退单({}) result:{}", refundType, JSON.toJSONString(notifyResultMap));
} catch (Exception e) {
log.error("回调通知交易退单失败({}) result:{}", refundType, JSON.toJSONString(notifyResultMap), e);
throw new AppException(e.getMessage());
}
});
}
}
/**
* 通用库存恢复逻辑
* @param teamRefundSuccess 团队退单成功信息
* @param refundType 退单类型描述
* @throws Exception 异常
*/
protected void doReverseStock(TeamRefundSuccess teamRefundSuccess,
String refundType) throws Exception {
log.info("退单；恢复锁单量 - {} {} {} {}", refundType, teamRefundSuccess.getUserId(), teamRefundSuccess.getActivityId(), teamRefundSuccess.getTeamId());
// 1. 恢复库存key
String recoveryTeamStockKey =
TradeLockRuleFilterFactory.generateRecoveryTeamStockKey(teamRefundSuccess.getActivityId(),
teamRefundSuccess.getTeamId());
// 2. 退单恢复库存
repository.refund2AddRecovery(recoveryTeamStockKey, teamRefundSuccess.getOrderId());
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/refund/business/AbstractRefundOrderStrategy.java
|
Java
|
unknown
| 2,800
|
package zack.project.domain.trade.service.refund.business;
import zack.project.domain.trade.model.entity.TradeRefundOrderEntity;
import zack.project.domain.trade.model.valobj.TeamRefundSuccess;
/**
* 退单策略接口
* 未支付，Unpaid
* 未成团，UnformedTeam
* 已成团，AlreadyFormedTeam
*
* 2025/7/8 07:37
*/
public interface IRefundOrderStrategy {
void refundOrder(TradeRefundOrderEntity tradeRefundOrderEntity) throws Exception;
void reverseStock(TeamRefundSuccess teamRefundSuccess) throws Exception;
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/refund/business/IRefundOrderStrategy.java
|
Java
|
unknown
| 538
|
package zack.project.domain.trade.service.refund.business.impl;
import zack.project.domain.trade.model.aggregate.GroupBuyRefundAggregate;
import zack.project.domain.trade.model.entity.NotifyTaskEntity;
import zack.project.domain.trade.model.entity.TradeRefundOrderEntity;
import zack.project.domain.trade.model.valobj.TeamRefundSuccess;
import zack.project.domain.trade.service.refund.business.AbstractRefundOrderStrategy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
/**
* 发起退单（已支付、未成团），锁单量-1、完成量-1、组队订单状态更新、发送退单消息（MQ）
*
* 2025/7/8 07:43
*/
@Slf4j
@Service("paid2RefundStrategy")
public class Paid2RefundStrategy extends AbstractRefundOrderStrategy {
@Override
public void refundOrder(TradeRefundOrderEntity tradeRefundOrderEntity) throws Exception {
log.info("退单；已支付，未成团 userId:{} teamId:{} orderId:{}", tradeRefundOrderEntity.getUserId(), tradeRefundOrderEntity.getTeamId(), tradeRefundOrderEntity.getOrderId());
// 1. 退单，已支付&未成团
NotifyTaskEntity notifyTaskEntity =
repository.paid2Refund(GroupBuyRefundAggregate.buildPaid2RefundAggregate(tradeRefundOrderEntity,
-1,
-1));
// 2. 发送MQ消息 - 发送MQ，恢复锁单库存量使用
sendRefundNotifyMessage(notifyTaskEntity, "已支付，未成团");
}
@Override
public void reverseStock(TeamRefundSuccess teamRefundSuccess) throws Exception {
doReverseStock(teamRefundSuccess, "已支付，未成团，但有锁单记录，要恢复锁单库存");
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/refund/business/impl/Paid2RefundStrategy.java
|
Java
|
unknown
| 1,707
|
package zack.project.domain.trade.service.refund.business.impl;
import zack.project.domain.trade.model.aggregate.GroupBuyRefundAggregate;
import zack.project.domain.trade.model.entity.GroupBuyTeamEntity;
import zack.project.domain.trade.model.entity.NotifyTaskEntity;
import zack.project.domain.trade.model.entity.TradeRefundOrderEntity;
import zack.project.domain.trade.model.valobj.TeamRefundSuccess;
import zack.project.domain.trade.service.refund.business.AbstractRefundOrderStrategy;
import zack.project.types.enums.GroupBuyOrderEnumVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
/**
* 发起退单（已成团&已支付），锁单量-1、完成量-1、组队订单状态更新、发送退单消息（MQ）
*
* 2025/7/8 07:45
*/
@Slf4j
@Service("paidTeam2RefundStrategy")
public class PaidTeam2RefundStrategy extends AbstractRefundOrderStrategy {
@Override
public void refundOrder(TradeRefundOrderEntity tradeRefundOrderEntity) {
log.info("退单；已支付，已成团 userId:{} teamId:{} orderId:{}", tradeRefundOrderEntity.getUserId(), tradeRefundOrderEntity.getTeamId(), tradeRefundOrderEntity.getOrderId());
GroupBuyTeamEntity groupBuyTeamEntity =
repository.queryGroupBuyTeamByTeamId(tradeRefundOrderEntity.getTeamId());
Integer completeCount = groupBuyTeamEntity.getCompleteCount();
// 最后一笔也退单，则更新拼团订单为失败
//这个PaidTeam2RefundStrategy节点是根据DataNodeFilter节点查询到的groupBuyTeamEntity和MarketProductEntity
// 这两个实体对应数据库的两条记录，根据拼团队伍状态和拼团详单状态获得的，当队伍状态是Complete，详单状态是已支付时会走到这个节点
//此时，队伍已经拼团成功，如果完成数是1，有两种可能:
//1.targetCount就是1，所以这个唯一的用户退单，要把队伍状态改为FAIL
//2.targetCount不是1，但别的队员都退单只剩一个人，此时这个人退单，队伍状态也要改成Fail
//总之 ： 队伍完成数不是1，则队伍状态改成COMPLETE_FAIL，队伍完成数是1，队伍只剩一个人，队伍状态改为FAIL，后续就不会再退单了，
// 在获取退单类型(RefundTypeVO)的时候没有对应的退单策略
GroupBuyOrderEnumVO groupBuyOrderEnumVO = 1 == completeCount ?
GroupBuyOrderEnumVO.FAIL : GroupBuyOrderEnumVO.COMPLETE_FAIL;
// 1. 退单，已支付&已成团
NotifyTaskEntity notifyTaskEntity =
repository.paidTeam2Refund(GroupBuyRefundAggregate.buildPaidTeam2RefundAggregate(tradeRefundOrderEntity, -1,
-1,
groupBuyOrderEnumVO));
// 2. 发送MQ消息 - 发送MQ，恢复锁单库存量使用
sendRefundNotifyMessage(notifyTaskEntity, "已支付，已成团");
}
@Override
public void reverseStock(TeamRefundSuccess teamRefundSuccess) throws Exception {
log.info("退单；已支付、已成团，队伍组队结束，不需要恢复锁单量 {} {} {}", teamRefundSuccess.getUserId(), teamRefundSuccess.getActivityId(), teamRefundSuccess.getTeamId());
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/refund/business/impl/PaidTeam2RefundStrategy.java
|
Java
|
unknown
| 3,264
|
package zack.project.domain.trade.service.refund.business.impl;
import zack.project.domain.trade.model.aggregate.GroupBuyRefundAggregate;
import zack.project.domain.trade.model.entity.NotifyTaskEntity;
import zack.project.domain.trade.model.entity.TradeRefundOrderEntity;
import zack.project.domain.trade.model.valobj.TeamRefundSuccess;
import zack.project.domain.trade.service.refund.business.AbstractRefundOrderStrategy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
/**
* 未支付，未成团；发起退单（未支付），锁单量-1、组队订单状态更新
*
* 2025/7/8 07:41
*/
@Slf4j
@Service("unpaid2RefundStrategy")
public class Unpaid2RefundStrategy extends AbstractRefundOrderStrategy {
@Override
public void refundOrder(TradeRefundOrderEntity tradeRefundOrderEntity) {
log.info("退单；未支付，未成团 userId:{} teamId:{} orderId:{}", tradeRefundOrderEntity.getUserId(), tradeRefundOrderEntity.getTeamId(), tradeRefundOrderEntity.getOrderId());
// 1. 退单；未支付，未成团
NotifyTaskEntity notifyTaskEntity =
repository.unpaid2Refund(GroupBuyRefundAggregate.buildUnpaid2RefundAggregate(tradeRefundOrderEntity,
-1));
// 2. 发送MQ消息 - 发送MQ，恢复锁单库存量使用
sendRefundNotifyMessage(notifyTaskEntity, "未支付，未成团");
}
@Override
public void reverseStock(TeamRefundSuccess teamRefundSuccess) throws Exception {
doReverseStock(teamRefundSuccess, "未支付，未成团，但有锁单记录，要恢复锁单库存");
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/refund/business/impl/Unpaid2RefundStrategy.java
|
Java
|
unknown
| 1,640
|
package zack.project.domain.trade.service.refund.factory;
import zack.project.domain.trade.model.entity.*;
import zack.project.domain.trade.service.refund.filter.DataNodeFilter;
import zack.project.domain.trade.service.refund.filter.RefundOrderNodeFilter;
import zack.project.domain.trade.service.refund.filter.UniqueRefundNodeFilter;
import cn.bugstack.wrench.design.framework.link.model2.LinkArmory;
import cn.bugstack.wrench.design.framework.link.model2.chain.BusinessLinkedList;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;
/**
* 交易退单过滤器工厂
*
* 2025/7/30 09:58
*/
@Slf4j
@Service
public class TradeRefundRuleFilterFactory {
@Bean("tradeRefundRuleFilter")
public BusinessLinkedList<TradeRefundCommandEntity, DynamicContext, TradeRefundBehaviorEntity> tradeRefundRuleFilter(
DataNodeFilter dataNodeFilter,
UniqueRefundNodeFilter uniqueRefundNodeFilter,
RefundOrderNodeFilter refundOrderNodeFilter) {
// 组装链
LinkArmory<TradeRefundCommandEntity, DynamicContext, TradeRefundBehaviorEntity> linkArmory =
new LinkArmory<>("退单规则过滤链",
dataNodeFilter,
uniqueRefundNodeFilter,
refundOrderNodeFilter);
// 链对象
return linkArmory.getLogicLink();
}
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public static class DynamicContext {
private MarketPayOrderEntity marketPayOrderEntity;
private GroupBuyTeamEntity groupBuyTeamEntity;
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/refund/factory/TradeRefundRuleFilterFactory.java
|
Java
|
unknown
| 1,793
|
package zack.project.domain.trade.service.refund.filter;
import zack.project.domain.trade.adapter.repository.ITradeRepository;
import zack.project.domain.trade.model.entity.GroupBuyTeamEntity;
import zack.project.domain.trade.model.entity.MarketPayOrderEntity;
import zack.project.domain.trade.model.entity.TradeRefundBehaviorEntity;
import zack.project.domain.trade.model.entity.TradeRefundCommandEntity;
import zack.project.domain.trade.service.refund.factory.TradeRefundRuleFilterFactory;
import cn.bugstack.wrench.design.framework.link.model2.handler.ILogicHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* 数据节点
*
* 2025/7/30 09:58
*/
@Slf4j
@Service
public class DataNodeFilter implements ILogicHandler<TradeRefundCommandEntity,
TradeRefundRuleFilterFactory.DynamicContext,
TradeRefundBehaviorEntity> {
@Resource
private ITradeRepository repository;
@Override
public TradeRefundBehaviorEntity apply(TradeRefundCommandEntity tradeRefundCommandEntity,
TradeRefundRuleFilterFactory.DynamicContext dynamicContext) throws Exception {
log.info("逆向流程-退单操作，数据加载节点 userId:{} outTradeNo:{}", tradeRefundCommandEntity.getUserId(), tradeRefundCommandEntity.getOutTradeNo());
// 1. 查询外部交易单，组队id、orderId、拼团状态
MarketPayOrderEntity marketPayOrderEntity =
repository.queryMarketPayOrderEntityByOutTradeNo(tradeRefundCommandEntity.getUserId(),
tradeRefundCommandEntity.getOutTradeNo());
String teamId = marketPayOrderEntity.getTeamId();
// 2. 查询拼团状态
GroupBuyTeamEntity groupBuyTeamEntity = repository.queryGroupBuyTeamByTeamId(teamId);
// 3. 写入上下文；如果查询数据是比较多的，可以参考 MarketNode2CompletableFuture 通过多线程进行加载
dynamicContext.setMarketPayOrderEntity(marketPayOrderEntity);
dynamicContext.setGroupBuyTeamEntity(groupBuyTeamEntity);
return next(tradeRefundCommandEntity, dynamicContext);
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/refund/filter/DataNodeFilter.java
|
Java
|
unknown
| 2,208
|
package zack.project.domain.trade.service.refund.filter;
import zack.project.domain.trade.model.entity.*;
import zack.project.domain.trade.model.valobj.RefundTypeEnumVO;
import zack.project.domain.trade.model.valobj.TradeOrderStatusEnumVO;
import zack.project.domain.trade.service.refund.business.IRefundOrderStrategy;
import zack.project.domain.trade.service.refund.factory.TradeRefundRuleFilterFactory;
import zack.project.types.enums.GroupBuyOrderEnumVO;
import cn.bugstack.wrench.design.framework.link.model2.handler.ILogicHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Map;
/**
* 退单节点
*
* 2025/7/30 10:31
*/
@Slf4j
@Service
public class RefundOrderNodeFilter implements ILogicHandler<TradeRefundCommandEntity, TradeRefundRuleFilterFactory.DynamicContext, TradeRefundBehaviorEntity> {
@Resource
private Map<String, IRefundOrderStrategy> refundOrderStrategyMap;
@Override
public TradeRefundBehaviorEntity apply(TradeRefundCommandEntity tradeRefundCommandEntity, TradeRefundRuleFilterFactory.DynamicContext dynamicContext) throws Exception {
log.info("逆向流程-退单操作，退单策略处理 userId:{} outTradeNo:{}", tradeRefundCommandEntity.getUserId(), tradeRefundCommandEntity.getOutTradeNo());
// 上下文数据
MarketPayOrderEntity marketPayOrderEntity = dynamicContext.getMarketPayOrderEntity();
TradeOrderStatusEnumVO tradeOrderStatusEnumVO = marketPayOrderEntity.getTradeOrderStatusEnumVO();
GroupBuyTeamEntity groupBuyTeamEntity = dynamicContext.getGroupBuyTeamEntity();
GroupBuyOrderEnumVO groupBuyOrderEnumVO = groupBuyTeamEntity.getStatus();
// 获取执行策略
RefundTypeEnumVO refundType =
RefundTypeEnumVO.getRefundStrategy(groupBuyOrderEnumVO, tradeOrderStatusEnumVO);
IRefundOrderStrategy refundOrderStrategy = refundOrderStrategyMap.get(refundType.getStrategy());
// 执行退单操作
refundOrderStrategy.refundOrder(TradeRefundOrderEntity.builder()
.userId(tradeRefundCommandEntity.getUserId())
.orderId(marketPayOrderEntity.getOrderId())
.teamId(marketPayOrderEntity.getTeamId())
.activityId(groupBuyTeamEntity.getActivityId())
.outTradeNo(tradeRefundCommandEntity.getOutTradeNo())
.build());
return TradeRefundBehaviorEntity.builder()
.userId(tradeRefundCommandEntity.getUserId())
.orderId(marketPayOrderEntity.getOrderId())
.teamId(marketPayOrderEntity.getTeamId())
.tradeRefundBehaviorEnum(TradeRefundBehaviorEntity.TradeRefundBehaviorEnum.SUCCESS)
.build();
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/refund/filter/RefundOrderNodeFilter.java
|
Java
|
unknown
| 2,824
|
package zack.project.domain.trade.service.refund.filter;
import zack.project.domain.trade.model.entity.MarketPayOrderEntity;
import zack.project.domain.trade.model.entity.TradeRefundBehaviorEntity;
import zack.project.domain.trade.model.entity.TradeRefundCommandEntity;
import zack.project.domain.trade.model.valobj.TradeOrderStatusEnumVO;
import zack.project.domain.trade.service.refund.factory.TradeRefundRuleFilterFactory;
import cn.bugstack.wrench.design.framework.link.model2.handler.ILogicHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
/**
* 重复退单检查
*
* 2025/7/30 10:29
*/
@Slf4j
@Service
public class UniqueRefundNodeFilter implements ILogicHandler<TradeRefundCommandEntity, TradeRefundRuleFilterFactory.DynamicContext, TradeRefundBehaviorEntity> {
@Override
public TradeRefundBehaviorEntity apply(TradeRefundCommandEntity tradeRefundCommandEntity, TradeRefundRuleFilterFactory.DynamicContext dynamicContext) throws Exception {
log.info("逆向流程-退单操作，重复退单检查 userId:{} outTradeNo:{}", tradeRefundCommandEntity.getUserId(), tradeRefundCommandEntity.getOutTradeNo());
MarketPayOrderEntity marketPayOrderEntity = dynamicContext.getMarketPayOrderEntity();
TradeOrderStatusEnumVO tradeOrderStatusEnumVO = marketPayOrderEntity.getTradeOrderStatusEnumVO();
// 返回幂等，已完成退单
if (TradeOrderStatusEnumVO.CLOSE.equals(tradeOrderStatusEnumVO)) {
log.info("逆向流程，退单操作(幂等-重复退单) userId:{} outTradeNo:{}", tradeRefundCommandEntity.getUserId(), tradeRefundCommandEntity.getOutTradeNo());
return TradeRefundBehaviorEntity.builder()
.userId(tradeRefundCommandEntity.getUserId())
.orderId(marketPayOrderEntity.getOrderId())
.teamId(marketPayOrderEntity.getTeamId())
.tradeRefundBehaviorEnum(TradeRefundBehaviorEntity.TradeRefundBehaviorEnum.REPEAT)
.build();
}
return next(tradeRefundCommandEntity, dynamicContext);
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/refund/filter/UniqueRefundNodeFilter.java
|
Java
|
unknown
| 2,136
|
package zack.project.domain.trade.service.settlement;
import zack.project.domain.trade.adapter.repository.ITradeRepository;
import zack.project.domain.trade.model.aggregate.GroupBuyTeamSettlementAggregate;
import zack.project.domain.trade.model.entity.*;
import zack.project.domain.trade.service.ITradeSettlementOrderService;
import zack.project.domain.trade.service.ITradeTaskService;
import zack.project.domain.trade.service.settlement.factory.TradeSettlementRuleFilterFactory;
import zack.project.types.exception.AppException;
import cn.bugstack.wrench.design.framework.link.model2.chain.BusinessLinkedList;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ThreadPoolExecutor;
/**
* @description 拼团交易结算服务
* @create 2025-01-26 15:22
*/
@Slf4j
@Service
public class TradeSettlementOrderService implements ITradeSettlementOrderService {
@Resource
private ITradeRepository repository;
@Resource
private ThreadPoolExecutor threadPoolExecutor;
@Resource
private ITradeTaskService tradeTaskService;
@Resource
private BusinessLinkedList<TradeSettlementRuleCommandEntity,
TradeSettlementRuleFilterFactory.DynamicContext,
TradeSettlementRuleFilterBackEntity> tradeSettlementRuleFilter;
/**
* @param tradePaySuccessEntity 交易支付订单实体对象，
* 这个支付成功的实体类的outTradeNo字段在{group_buy_order_list}表中，是请求锁单dto实体对象外部传入的
* 并传递给外部服务在对该笔拼团详单进行支付后产生的TradePaySuccessEntity的outTradeNo
* @return
* @throws Exception
*/
@Override
public TradePaySettlementEntity settlementMarketPayOrder(TradePaySuccessEntity tradePaySuccessEntity) throws Exception {
log.info("拼团交易-支付订单结算:{} outTradeNo:{}", tradePaySuccessEntity.getUserId(), tradePaySuccessEntity.getOutTradeNo());
// 1. 结算规则过滤
TradeSettlementRuleFilterBackEntity tradeSettlementRuleFilterBackEntity =
tradeSettlementRuleFilter.apply(
//构建交易结算指令实体:
//sc：结算商品的来源渠道，scRuleFilter根据dccService里面的blackList属性，如果当前的来源和渠道在黑名单中则取消结算
//userId，outTradeNo：OutTradeNoRuleFilter节点先根据用户id和外部单号id查{group_buy_order_list}找到对应的锁单记录并设置到动态上下文中(marketProductEntity)
//如果该记录是CLOSE关闭状态(被退单了)，则终止结算.
//outTradeTime：settableRuleFilter节点根据上下文的marketProduct获取teamId，根据该队伍id去查{group_buy_order}拼团记录(GroupBuyTeamEntity)，
//比较拼团的有效时间和支付完成的时间。
TradeSettlementRuleCommandEntity.builder()
.source(tradePaySuccessEntity.getSource())
.channel(tradePaySuccessEntity.getChannel())
.userId(tradePaySuccessEntity.getUserId())
.outTradeNo(tradePaySuccessEntity.getOutTradeNo())
.outTradeTime(tradePaySuccessEntity.getOutTradeTime())
.build(),
new TradeSettlementRuleFilterFactory.DynamicContext());
String teamId = tradeSettlementRuleFilterBackEntity.getTeamId();
// 2. 查询组团信息
GroupBuyTeamEntity groupBuyTeamEntity = GroupBuyTeamEntity.builder()
.teamId(tradeSettlementRuleFilterBackEntity.getTeamId())
.activityId(tradeSettlementRuleFilterBackEntity.getActivityId())
.targetCount(tradeSettlementRuleFilterBackEntity.getTargetCount())
.completeCount(tradeSettlementRuleFilterBackEntity.getCompleteCount())
.lockCount(tradeSettlementRuleFilterBackEntity.getLockCount())
.status(tradeSettlementRuleFilterBackEntity.getStatus())
.validStartTime(tradeSettlementRuleFilterBackEntity.getValidStartTime())
.validEndTime(tradeSettlementRuleFilterBackEntity.getValidEndTime())
.notifyConfigVO(tradeSettlementRuleFilterBackEntity.getNotifyConfigVO())
.build();
// 3. 构建聚合对象，用拼团队伍实体来更改拼团单的complete_count，支付成功实体更改对应的拼团详单的状态
GroupBuyTeamSettlementAggregate groupBuyTeamSettlementAggregate =
GroupBuyTeamSettlementAggregate.builder()
.userEntity(UserEntity.builder().userId(tradePaySuccessEntity.getUserId()).build())
.groupBuyTeamEntity(groupBuyTeamEntity)
.tradePaySuccessEntity(tradePaySuccessEntity)
.build();
// 4. 拼团交易结算，进行结算的时候会判断当前拼团单的完成数量和目标数量是否相等，
// 如果相等说明拼团完成，生成回调通知该笔拼团完成
List<NotifyTaskEntity> notifyTaskEntityList = repository.settlementMarketPayOrder(groupBuyTeamSettlementAggregate);
// 5. 组队回调处理 - 处理失败也会有定时任务补偿，通过这样的方式，可以减轻任务调度，提高时效性
if (null != notifyTaskEntityList) {
threadPoolExecutor.execute(() -> {
Map<String, Integer> notifyResultMap = null;
try {
notifyResultMap = tradeTaskService.execNotifyJob(notifyTaskEntityList);
log.info("回调通知拼团完结 result:{}", JSON.toJSONString(notifyResultMap));
} catch (Exception e) {
log.error("回调通知拼团完结失败 result:{}", JSON.toJSONString(notifyResultMap), e);
throw new AppException(e.getMessage());
}
});
}
// 6. 返回结算信息 - 公司中开发这样的流程时候，会根据外部需要进行值的设置
return TradePaySettlementEntity.builder()
.source(tradePaySuccessEntity.getSource())
.channel(tradePaySuccessEntity.getChannel())
.userId(tradePaySuccessEntity.getUserId())
.teamId(teamId)
.activityId(groupBuyTeamEntity.getActivityId())
.outTradeNo(tradePaySuccessEntity.getOutTradeNo())
.build();
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/settlement/TradeSettlementOrderService.java
|
Java
|
unknown
| 6,865
|
package zack.project.domain.trade.service.settlement.factory;
import zack.project.domain.trade.model.entity.GroupBuyTeamEntity;
import zack.project.domain.trade.model.entity.MarketPayOrderEntity;
import zack.project.domain.trade.model.entity.TradeSettlementRuleCommandEntity;
import zack.project.domain.trade.model.entity.TradeSettlementRuleFilterBackEntity;
import zack.project.domain.trade.service.settlement.filter.EndRuleFilter;
import zack.project.domain.trade.service.settlement.filter.OutTradeNoRuleFilter;
import zack.project.domain.trade.service.settlement.filter.SCRuleFilter;
import zack.project.domain.trade.service.settlement.filter.SettableRuleFilter;
import cn.bugstack.wrench.design.framework.link.model2.LinkArmory;
import cn.bugstack.wrench.design.framework.link.model2.chain.BusinessLinkedList;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;
/**
* @description 交易结算规则过滤工厂
* @create 2025-01-29 09:17
*/
@Slf4j
@Service
public class TradeSettlementRuleFilterFactory {
@Bean("tradeSettlementRuleFilter")
public BusinessLinkedList<TradeSettlementRuleCommandEntity,
DynamicContext, TradeSettlementRuleFilterBackEntity> tradeSettlementRuleFilter(
SCRuleFilter scRuleFilter,
OutTradeNoRuleFilter outTradeNoRuleFilter,
SettableRuleFilter settableRuleFilter,
EndRuleFilter endRuleFilter) {
// 组装链
LinkArmory<TradeSettlementRuleCommandEntity, DynamicContext, TradeSettlementRuleFilterBackEntity> linkArmory =
new LinkArmory<>("交易结算规则过滤链", scRuleFilter,
outTradeNoRuleFilter,
settableRuleFilter,
endRuleFilter);
// 链对象
return linkArmory.getLogicLink();
}
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public static class DynamicContext {
// 订单营销实体对象
private MarketPayOrderEntity marketPayOrderEntity;
// 拼团组队实体对象
private GroupBuyTeamEntity groupBuyTeamEntity;
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/settlement/factory/TradeSettlementRuleFilterFactory.java
|
Java
|
unknown
| 2,316
|
package zack.project.domain.trade.service.settlement.filter;
import zack.project.domain.trade.model.entity.GroupBuyTeamEntity;
import zack.project.domain.trade.model.entity.TradeSettlementRuleCommandEntity;
import zack.project.domain.trade.model.entity.TradeSettlementRuleFilterBackEntity;
import zack.project.domain.trade.service.settlement.factory.TradeSettlementRuleFilterFactory;
import cn.bugstack.wrench.design.framework.link.model2.handler.ILogicHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
/**
* @description 结束节点
* @create 2025-01-29 16:37
*/
@Slf4j
@Service
public class EndRuleFilter implements ILogicHandler<TradeSettlementRuleCommandEntity, TradeSettlementRuleFilterFactory.DynamicContext, TradeSettlementRuleFilterBackEntity> {
@Override
public TradeSettlementRuleFilterBackEntity apply(TradeSettlementRuleCommandEntity requestParameter, TradeSettlementRuleFilterFactory.DynamicContext dynamicContext) throws Exception {
log.info("结算规则过滤-结束节点{} outTradeNo:{}", requestParameter.getUserId(), requestParameter.getOutTradeNo());
// 获取上下文对象
GroupBuyTeamEntity groupBuyTeamEntity = dynamicContext.getGroupBuyTeamEntity();
// 返回封装数据，交易结算过滤结果实体
return TradeSettlementRuleFilterBackEntity.builder()
.teamId(groupBuyTeamEntity.getTeamId())
.activityId(groupBuyTeamEntity.getActivityId())
.targetCount(groupBuyTeamEntity.getTargetCount())
.completeCount(groupBuyTeamEntity.getCompleteCount())
.lockCount(groupBuyTeamEntity.getLockCount())
.status(groupBuyTeamEntity.getStatus())
.validStartTime(groupBuyTeamEntity.getValidStartTime())
.validEndTime(groupBuyTeamEntity.getValidEndTime())
.notifyConfigVO(groupBuyTeamEntity.getNotifyConfigVO())
.build();
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/settlement/filter/EndRuleFilter.java
|
Java
|
unknown
| 2,003
|
package zack.project.domain.trade.service.settlement.filter;
import zack.project.domain.trade.adapter.repository.ITradeRepository;
import zack.project.domain.trade.model.entity.MarketPayOrderEntity;
import zack.project.domain.trade.model.entity.TradeSettlementRuleCommandEntity;
import zack.project.domain.trade.model.entity.TradeSettlementRuleFilterBackEntity;
import zack.project.domain.trade.model.valobj.TradeOrderStatusEnumVO;
import zack.project.domain.trade.service.settlement.factory.TradeSettlementRuleFilterFactory;
import zack.project.types.enums.ResponseCode;
import zack.project.types.exception.AppException;
import cn.bugstack.wrench.design.framework.link.model2.handler.ILogicHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* @description 外部交易单号过滤；外部交易单号是否为退单
* @create 2025-01-29 09:37
*/
@Slf4j
@Service
public class OutTradeNoRuleFilter implements ILogicHandler<TradeSettlementRuleCommandEntity, TradeSettlementRuleFilterFactory.DynamicContext, TradeSettlementRuleFilterBackEntity> {
@Resource
private ITradeRepository repository;
@Override
public TradeSettlementRuleFilterBackEntity apply(TradeSettlementRuleCommandEntity requestParameter, TradeSettlementRuleFilterFactory.DynamicContext dynamicContext) throws Exception {
log.info("结算规则过滤-外部单号校验{} outTradeNo:{}", requestParameter.getUserId(), requestParameter.getOutTradeNo());
// 查询拼团信息
MarketPayOrderEntity marketPayOrderEntity =
repository.queryMarketPayOrderEntityByOutTradeNo(requestParameter.getUserId(),
requestParameter.getOutTradeNo());
//看要结算的这笔拼团详单是否被退单
if (null == marketPayOrderEntity ||
TradeOrderStatusEnumVO.CLOSE.equals(marketPayOrderEntity.getTradeOrderStatusEnumVO())) {
log.error("不存在的外部交易单号或用户已退单，不需要做支付订单结算:{} outTradeNo:{}", requestParameter.getUserId(), requestParameter.getOutTradeNo());
throw new AppException(ResponseCode.E0104);
}
dynamicContext.setMarketPayOrderEntity(marketPayOrderEntity);
return next(requestParameter, dynamicContext);
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/settlement/filter/OutTradeNoRuleFilter.java
|
Java
|
unknown
| 2,361
|
package zack.project.domain.trade.service.settlement.filter;
import zack.project.domain.trade.adapter.repository.ITradeRepository;
import zack.project.domain.trade.model.entity.TradeSettlementRuleCommandEntity;
import zack.project.domain.trade.model.entity.TradeSettlementRuleFilterBackEntity;
import zack.project.domain.trade.service.settlement.factory.TradeSettlementRuleFilterFactory;
import zack.project.types.enums.ResponseCode;
import zack.project.types.exception.AppException;
import cn.bugstack.wrench.design.framework.link.model2.handler.ILogicHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* @description SC 渠道来源过滤 - 当某个签约渠道下架后，则不会记账
* @create 2025-01-29 09:16
*/
@Slf4j
@Service
public class SCRuleFilter implements ILogicHandler<TradeSettlementRuleCommandEntity, TradeSettlementRuleFilterFactory.DynamicContext, TradeSettlementRuleFilterBackEntity> {
@Resource
private ITradeRepository repository;
@Override
public TradeSettlementRuleFilterBackEntity apply(TradeSettlementRuleCommandEntity requestParameter, TradeSettlementRuleFilterFactory.DynamicContext dynamicContext) throws Exception {
log.info("结算规则过滤-渠道黑名单校验{} outTradeNo:{}", requestParameter.getUserId(), requestParameter.getOutTradeNo());
// sc 渠道黑名单拦截，
// 通过DCCService里面有DCCValue注解的blackList属性的值进行匹配，如果存在则说明该sc下的商品不能结算
boolean intercept = repository.isSCBlackIntercept(requestParameter.getSource(), requestParameter.getChannel());
if (intercept) {
log.error("{}{} 渠道黑名单拦截", requestParameter.getSource(), requestParameter.getChannel());
throw new AppException(ResponseCode.E0105);
}
return next(requestParameter, dynamicContext);
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/settlement/filter/SCRuleFilter.java
|
Java
|
unknown
| 1,964
|
package zack.project.domain.trade.service.settlement.filter;
import zack.project.domain.trade.adapter.repository.ITradeRepository;
import zack.project.domain.trade.model.entity.GroupBuyTeamEntity;
import zack.project.domain.trade.model.entity.MarketPayOrderEntity;
import zack.project.domain.trade.model.entity.TradeSettlementRuleCommandEntity;
import zack.project.domain.trade.model.entity.TradeSettlementRuleFilterBackEntity;
import zack.project.domain.trade.service.settlement.factory.TradeSettlementRuleFilterFactory;
import zack.project.types.enums.ResponseCode;
import zack.project.types.exception.AppException;
import cn.bugstack.wrench.design.framework.link.model2.handler.ILogicHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Date;
/**判断当前商品是否可以结算(支付完成时间是否在拼团队伍的有效期内)
* 这个判断的是锁单时，团主向{group_buy_order}添加一个拼团队伍时的时间，这里需要拿支付完成时间和拼团队伍的有效时间进行比较
* 所以需要根据outTradeNoRuleFilter节点查询到marketProductEntity拼团详单的teamId去查询{group_buy_order}获取拼团队伍，
* 再获取队伍的有效时间
* @author A1793
*/
@Slf4j
@Service
public class SettableRuleFilter implements ILogicHandler<TradeSettlementRuleCommandEntity, TradeSettlementRuleFilterFactory.DynamicContext, TradeSettlementRuleFilterBackEntity> {
@Resource
private ITradeRepository repository;
@Override
public TradeSettlementRuleFilterBackEntity apply(TradeSettlementRuleCommandEntity requestParameter, TradeSettlementRuleFilterFactory.DynamicContext dynamicContext) throws Exception {
log.info("结算规则过滤-有效时间校验{} outTradeNo:{}", requestParameter.getUserId(), requestParameter.getOutTradeNo());
// 上下文；获取数据
MarketPayOrderEntity marketPayOrderEntity = dynamicContext.getMarketPayOrderEntity();
// 查询拼团对象
GroupBuyTeamEntity groupBuyTeamEntity =
repository.queryGroupBuyTeamByTeamId(marketPayOrderEntity.getTeamId());
// 外部交易时间 - 也就是用户支付完成的时间，这个时间要在拼团有效时间范围内
Date outTradeTime = requestParameter.getOutTradeTime();
// 判断，外部交易时间，要小于拼团结束时间。否则抛异常。
if (!outTradeTime.before(groupBuyTeamEntity.getValidEndTime())) {
log.error("订单交易时间不在拼团有效时间范围内");
throw new AppException(ResponseCode.E0106);
}
// 设置上下文
dynamicContext.setGroupBuyTeamEntity(groupBuyTeamEntity);
return next(requestParameter, dynamicContext);
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/settlement/filter/SettableRuleFilter.java
|
Java
|
unknown
| 2,847
|
package zack.project.domain.trade.service.task;
import zack.project.domain.trade.adapter.port.ITradePort;
import zack.project.domain.trade.adapter.repository.ITradeRepository;
import zack.project.domain.trade.model.entity.NotifyTaskEntity;
import zack.project.domain.trade.service.ITradeTaskService;
import zack.project.types.enums.NotifyTaskHTTPEnumVO;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ThreadPoolExecutor;
/**
* 交易任务（MT/HTTP）服务
*
* 2025/7/12 21:15
*/
@Slf4j
@Service
public class TradeTaskService implements ITradeTaskService {
@Resource
private ITradeRepository repository;
@Resource
private ITradePort port;
@Resource
private ThreadPoolExecutor threadPoolExecutor;
@Override
public Map<String, Integer> execNotifyJob() throws Exception {
log.info("拼团交易-执行回调通知任务");
// 查询未执行任务
List<NotifyTaskEntity> notifyTaskEntityList = repository.queryUnExecutedNotifyTaskList();
return execNotifyJob(notifyTaskEntityList);
}
@Override
public Map<String, Integer> execNotifyJob(String teamId) throws Exception {
log.info("拼团交易-执行回调通知回调，指定 teamId:{}", teamId);
List<NotifyTaskEntity> notifyTaskEntityList = repository.queryUnExecutedNotifyTaskList(teamId);
return execNotifyJob(notifyTaskEntityList);
}
@Override
public Map<String, Integer> execNotifyJob(NotifyTaskEntity notifyTaskEntity) throws Exception {
log.info("拼团交易-执行回调通知回调，指定 teamId:{} notifyTaskEntity:{}", notifyTaskEntity.getTeamId(), JSON.toJSONString(notifyTaskEntity));
return execNotifyJob(Collections.singletonList(notifyTaskEntity));
}
/**
* taskService封装了ITradePort，port里面封装了网关调用和消息发送器，网关调用封装了okHttp调用，消息发送器封装了rabbitTemplate
* @param notifyTaskEntityList
* @return
* @throws Exception
*/
@Override
public Map<String, Integer> execNotifyJob(List<NotifyTaskEntity> notifyTaskEntityList) throws Exception {
//统计回调任务的执行结果
int successCount = 0, errorCount = 0, retryCount = 0;
for (NotifyTaskEntity notifyTask : notifyTaskEntityList) {
// 回调处理 success 成功，error 失败
//port在调用网关或者发送消息之前要先根据回调任务的uuid的粒度加一个分布式锁，防止回调任务被别的节点重复执行
String response = port.groupBuyNotify(notifyTask);
// 更新状态判断&变更数据库表回调任务状态
if (NotifyTaskHTTPEnumVO.SUCCESS.getCode().equals(response)) {
int updateCount = repository.updateNotifyTaskStatusSuccess(notifyTask);
if (1 == updateCount) {
successCount += 1;
}
}
//如果回调失败，先进行回调重试次数判断，小于等于4等待后续重试，大于4直接将数据库回调任务设置为失败
else if (NotifyTaskHTTPEnumVO.ERROR.getCode().equals(response)) {
if (notifyTask.getNotifyCount() > 4) {
int updateCount = repository.updateNotifyTaskStatusError(notifyTask);
if (1 == updateCount) {
errorCount += 1;
}
} else {
int updateCount = repository.updateNotifyTaskStatusRetry(notifyTask);
if (1 == updateCount) {
retryCount += 1;
}
}
}
}
Map<String, Integer> resultMap = new HashMap<>();
resultMap.put("waitCount", notifyTaskEntityList.size());
resultMap.put("successCount", successCount);
resultMap.put("errorCount", errorCount);
resultMap.put("retryCount", retryCount);
return resultMap;
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-domain/src/main/java/zack/project/domain/trade/service/task/TradeTaskService.java
|
Java
|
unknown
| 4,259
|
package zack.project.infrastructure.adapter.port;
import zack.project.domain.activity.adapter.port.IActivityPort;
import zack.project.infrastructure.gateway.LotteryRpcService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* @author A1793
*/
@Service
@Slf4j
public class ActivityPort implements IActivityPort {
@Resource
private LotteryRpcService lotteryRpcService;
@Override
public String getRandomAward(Integer takeCount, Long strategyId) {
try{
log.info("开始调用营销抽奖,获取随即折扣 takeCount:{},strategyId:{} ", takeCount, strategyId);
return lotteryRpcService.lottery(takeCount, strategyId);
}catch (Exception e){
log.error("错误信息:{}",e.getMessage());
}
return "1";
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-infrastructure/src/main/java/zack/project/infrastructure/adapter/port/ActivityPort.java
|
Java
|
unknown
| 880
|
package zack.project.infrastructure.adapter.port;
import zack.project.domain.trade.adapter.port.ITradePort;
import zack.project.domain.trade.model.entity.NotifyTaskEntity;
import zack.project.domain.trade.model.valobj.NotifyTypeEnumVO;
import zack.project.infrastructure.event.EventPublisher;
import zack.project.infrastructure.gateway.GroupBuyNotifyService;
import zack.project.infrastructure.gateway.RebateRpcService;
import zack.project.infrastructure.redis.IRedisService;
import zack.project.types.enums.NotifyTaskHTTPEnumVO;
import org.apache.commons.lang3.StringUtils;
import org.redisson.api.RLock;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;
/**
* @description 交易接口服务
* @create 2025-01-31 13:34
*/
@Service
public class TradePort implements ITradePort {
//网关调用服务(http)
@Resource
private GroupBuyNotifyService groupBuyNotifyService;
@Resource
private IRedisService redisService;
//mq消息
@Resource
private EventPublisher publisher;
@Resource
private RebateRpcService rebateRpcService;
@Override
public String groupBuyNotify(NotifyTaskEntity notifyTask) throws Exception {
//锁的粒度是单个任务
// public String lockKey() {
// return "notify_job_lock_key_" + this.uuid;
// }
//当该任务因某种原因(jvm长时间的gc)导致redis的锁一直续约，这种锁粒度不会影响别的回调任务执行
RLock lock = redisService.getLock(notifyTask.lockKey());
try {
// group-buy-market 拼团服务端会被部署到多台应用服务器上，
// 那么就会有很多任务一起执行。这个时候要进行抢占，避免被多次执行
//用redisson分布式锁的时候设置了过期时间，看门狗机制就不会启用,此处是获取锁最多等3秒，释放时间是0(默认启用看门狗，持有30秒，自动续约)
if (lock.tryLock(3, 0, TimeUnit.SECONDS)) {
try {
// 回调方式 HTTP
if (NotifyTypeEnumVO.HTTP.getCode().equals(notifyTask.getNotifyType())) {
// 无效的 notifyUrl 则直接返回成功
if (StringUtils.isBlank(notifyTask.getNotifyUrl()) ||
"暂无".equals(notifyTask.getNotifyUrl())) {
return NotifyTaskHTTPEnumVO.SUCCESS.getCode();
}
return groupBuyNotifyService.groupBuyNotify(notifyTask.getNotifyUrl(),
notifyTask.getParameterJson());
}
// 回调方式 MQ
if (NotifyTypeEnumVO.MQ.getCode().equals(notifyTask.getNotifyType())) {
publisher.publish(notifyTask.getNotifyMQ(), notifyTask.getParameterJson());
return NotifyTaskHTTPEnumVO.SUCCESS.getCode();
}
//rpc调用
if(NotifyTypeEnumVO.RPC.getCode().equals(notifyTask.getNotifyType())){
return rebateRpcService.
sendRebate(notifyTask.getNotifyRpc(),notifyTask.getParameterJson());
}
} finally {
if (lock.isLocked() && lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}
return NotifyTaskHTTPEnumVO.NULL.getCode();
} catch (Exception e) {
Thread.currentThread().interrupt();
return NotifyTaskHTTPEnumVO.NULL.getCode();
}
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-infrastructure/src/main/java/zack/project/infrastructure/adapter/port/TradePort.java
|
Java
|
unknown
| 3,753
|
package zack.project.infrastructure.adapter.repository;
import zack.project.infrastructure.dcc.DCCService;
import zack.project.infrastructure.redis.IRedisService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Resource;
import java.util.function.Supplier;
/**
* @description 仓储抽象类
*/
public abstract class AbstractRepository {
private final Logger logger = LoggerFactory.getLogger(AbstractRepository.class);
@Resource
protected IRedisService redisService;
@Resource
protected DCCService dccService;
/**
* 通用缓存处理方法
* 优先从缓存获取，缓存不存在则从数据库获取并写入缓存
*
* @param cacheKey 缓存键
* @param dbFallback 数据库查询函数
* @param <T> 返回类型
* @return 查询结果
*/
protected <T> T getFromCacheOrDb(String cacheKey, Supplier<T> dbFallback) {
// 判断是否开启缓存
if (dccService.isCacheOpenSwitch()) {
// 从缓存获取
T cacheResult = redisService.getValue(cacheKey);
// 缓存存在则直接返回
if (null != cacheResult) {
return cacheResult;
}
// 缓存不存在则从数据库获取
T dbResult = dbFallback.get();
// 数据库查询结果为空则直接返回
if (null == dbResult) {
return null;
}
// 写入缓存
redisService.setValue(cacheKey, dbResult);
return dbResult;
} else {
// 缓存未开启，直接从数据库获取
logger.warn("缓存降级 {}", cacheKey);
return dbFallback.get();
}
}
/**
* 通用缓存处理方法（带过期时间）
* 优先从缓存获取，缓存不存在则从数据库获取并写入缓存
*
* @param cacheKey 缓存键
* @param dbFallback 数据库查询函数
* @param expired 过期时间
* @param <T> 返回类型
* @return 查询结果
*/
protected <T> T getFromCacheOrDb(String cacheKey, Supplier<T> dbFallback, long expired) {
// 判断是否开启缓存
if (dccService.isCacheOpenSwitch()) {
// 从缓存获取
T cacheResult = redisService.getValue(cacheKey);
// 缓存存在则直接返回
if (null != cacheResult) {
return cacheResult;
}
// 缓存不存在则从数据库获取
T dbResult = dbFallback.get();
// 数据库查询结果为空则直接返回
if (null == dbResult) {
return null;
}
// 写入缓存（带过期时间）
redisService.setValue(cacheKey, dbResult, expired);
return dbResult;
} else {
// 缓存未开启，直接从数据库获取
logger.warn("缓存降级 {}", cacheKey);
return dbFallback.get();
}
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-infrastructure/src/main/java/zack/project/infrastructure/adapter/repository/AbstractRepository.java
|
Java
|
unknown
| 3,126
|
package zack.project.infrastructure.adapter.repository;
import zack.project.domain.activity.adapter.repository.IActivityRepository;
import zack.project.domain.activity.model.entity.UserGroupBuyOrderDetailEntity;
import zack.project.domain.activity.model.valobj.*;
import zack.project.infrastructure.dao.*;
import zack.project.infrastructure.dao.po.*;
import zack.project.infrastructure.dcc.DCCService;
import zack.project.infrastructure.redis.IRedisService;
import org.redisson.api.RBitSet;
import org.springframework.stereotype.Repository;
import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author zack
* @description 活动仓储
* @create 2024-12-21 10:10
*/
@Repository
public class ActivityRepository extends AbstractRepository implements IActivityRepository {
@Resource
private IGroupBuyActivityDao groupBuyActivityDao;
@Resource
private IGroupBuyDiscountDao groupBuyDiscountDao;
@Resource
private ISkuDao skuDao;
@Resource
private ISCSkuActivityDao skuActivityDao;
@Resource
private IRedisService redisService;
@Resource
private DCCService dccService;
@Resource
private IGroupBuyOrderDao groupBuyOrderDao;
@Resource
private IGroupBuyOrderListDao groupBuyOrderListDao;
@Override
public GroupBuyActivityDiscountVO queryGroupBuyActivityDiscountVO(Long activityId) {
// 优先从缓存获取&写缓存，注意如果实现了后台配置，在更新时要更库，删缓存。
GroupBuyActivity groupBuyActivityRes = getFromCacheOrDb(GroupBuyActivity.cacheRedisKey(activityId),
() -> groupBuyActivityDao.queryValidGroupBuyActivityId(activityId));
if (null == groupBuyActivityRes) return null;
String discountId = groupBuyActivityRes.getDiscountId();
// 优先从缓存获取&写缓存
GroupBuyDiscount groupBuyDiscountRes = getFromCacheOrDb(GroupBuyDiscount.cacheRedisKey(discountId),
() -> groupBuyDiscountDao.queryGroupBuyActivityDiscountByDiscountId(discountId));
if (null == groupBuyDiscountRes) return null;
GroupBuyActivityDiscountVO.GroupBuyDiscount groupBuyDiscount = GroupBuyActivityDiscountVO.GroupBuyDiscount.builder()
.discountName(groupBuyDiscountRes.getDiscountName())
.discountDesc(groupBuyDiscountRes.getDiscountDesc())
.discountType(DiscountTypeEnum.get(groupBuyDiscountRes.getDiscountType()))
.marketPlan(groupBuyDiscountRes.getMarketPlan())
.marketExpr(groupBuyDiscountRes.getMarketExpr())
.tagId(groupBuyDiscountRes.getTagId())
.build();
return GroupBuyActivityDiscountVO.builder()
.activityId(groupBuyActivityRes.getActivityId())
.activityName(groupBuyActivityRes.getActivityName())
.groupBuyDiscount(groupBuyDiscount)
.groupType(groupBuyActivityRes.getGroupType())
.takeLimitCount(groupBuyActivityRes.getTakeLimitCount())
.target(groupBuyActivityRes.getTarget())
.validTime(groupBuyActivityRes.getValidTime())
.status(groupBuyActivityRes.getStatus())
.startTime(groupBuyActivityRes.getStartTime())
.endTime(groupBuyActivityRes.getEndTime())
.tagId(groupBuyActivityRes.getTagId())
.tagScope(groupBuyActivityRes.getTagScope())
.build();
}
@Override
public SkuVO querySkuByGoodsId(String goodsId) {
Sku sku = skuDao.querySkuByGoodsId(goodsId);
if (null == sku) return null;
return SkuVO.builder()
.goodsId(sku.getGoodsId())
.goodsName(sku.getGoodsName())
.originalPrice(sku.getOriginalPrice())
.build();
}
@Override
public SCSkuActivityVO querySCSkuActivityBySCGoodsId(String source, String channel, String goodsId) {
SCSkuActivity scSkuActivityReq = new SCSkuActivity();
scSkuActivityReq.setSource(source);
scSkuActivityReq.setChannel(channel);
scSkuActivityReq.setGoodsId(goodsId);
SCSkuActivity scSkuActivity = skuActivityDao.querySCSkuActivityBySCGoodsId(scSkuActivityReq);
if (null == scSkuActivity) return null;
return SCSkuActivityVO.builder()
.source(scSkuActivity.getSource())
.chanel(scSkuActivity.getChannel())
.activityId(scSkuActivity.getActivityId())
.goodsId(scSkuActivity.getGoodsId())
.build();
}
@Override
public boolean isTagCrowdRange(String tagId, String userId) {
RBitSet bitSet = redisService.getBitSet(tagId);
if (!bitSet.isExists()) return true;
// 判断用户是否存在人群中
return bitSet.get(redisService.getIndexFromUserId(userId));
}
@Override
public boolean downgradeSwitch() {
return dccService.isDowngradeSwitch();
}
@Override
public boolean cutRange(String userId) {
return dccService.isCutRange(userId);
}
@Override
public List<UserGroupBuyOrderDetailEntity> queryInProgressUserGroupBuyOrderDetailListByOwner(Long activityId, String userId, Integer ownerCount) {
// 1. 根据用户ID、活动ID，查询用户参与的拼团队伍
GroupBuyOrderList groupBuyOrderListReq = new GroupBuyOrderList();
groupBuyOrderListReq.setActivityId(activityId);
groupBuyOrderListReq.setUserId(userId);
groupBuyOrderListReq.setCount(ownerCount);
List<GroupBuyOrderList> groupBuyOrderLists = groupBuyOrderListDao.queryInProgressUserGroupBuyOrderDetailListByUserId(groupBuyOrderListReq);
if (null == groupBuyOrderLists || groupBuyOrderLists.isEmpty()) return null;
// 2. 过滤队伍获取 TeamId
Set<String> teamIds = groupBuyOrderLists.stream()
.map(GroupBuyOrderList::getTeamId)
.filter(teamId -> teamId != null && !teamId.isEmpty()) // 过滤非空和非空字符串
.collect(Collectors.toSet());
// 3. 查询队伍明细，组装Map结构
List<GroupBuyOrder> groupBuyOrders = groupBuyOrderDao.queryGroupBuyProgressByTeamIds(teamIds);
if (null == groupBuyOrders || groupBuyOrders.isEmpty()) return null;
Map<String, GroupBuyOrder> groupBuyOrderMap = groupBuyOrders.stream()
.collect(Collectors.toMap(GroupBuyOrder::getTeamId, order -> order));
// 4. 转换数据
List<UserGroupBuyOrderDetailEntity> userGroupBuyOrderDetailEntities = new ArrayList<>();
for (GroupBuyOrderList groupBuyOrderList : groupBuyOrderLists) {
String teamId = groupBuyOrderList.getTeamId();
GroupBuyOrder groupBuyOrder = groupBuyOrderMap.get(teamId);
if (null == groupBuyOrder) continue;
UserGroupBuyOrderDetailEntity userGroupBuyOrderDetailEntity = UserGroupBuyOrderDetailEntity.builder()
.userId(groupBuyOrderList.getUserId())
.teamId(groupBuyOrder.getTeamId())
.activityId(groupBuyOrder.getActivityId())
.targetCount(groupBuyOrder.getTargetCount())
.completeCount(groupBuyOrder.getCompleteCount())
.lockCount(groupBuyOrder.getLockCount())
.validStartTime(groupBuyOrder.getValidStartTime())
.validEndTime(groupBuyOrder.getValidEndTime())
.outTradeNo(groupBuyOrderList.getOutTradeNo())
.build();
userGroupBuyOrderDetailEntities.add(userGroupBuyOrderDetailEntity);
}
return userGroupBuyOrderDetailEntities;
}
@Override
public List<UserGroupBuyOrderDetailEntity> queryInProgressUserGroupBuyOrderDetailListByRandom(Long activityId, String userId, Integer randomCount) {
// 1. 根据用户ID、活动ID，查询用户参与的拼团队伍
GroupBuyOrderList groupBuyOrderListReq = new GroupBuyOrderList();
groupBuyOrderListReq.setActivityId(activityId);
groupBuyOrderListReq.setUserId(userId);
groupBuyOrderListReq.setCount(randomCount * 2); // 查询2倍的量，之后其中 randomCount 数量
List<GroupBuyOrderList> groupBuyOrderLists = groupBuyOrderListDao.queryInProgressUserGroupBuyOrderDetailListByRandom(groupBuyOrderListReq);
if (null == groupBuyOrderLists || groupBuyOrderLists.isEmpty()) return null;
// 判断总量是否大于 randomCount
if (groupBuyOrderLists.size() > randomCount) {
// 随机打乱列表
Collections.shuffle(groupBuyOrderLists);
// 获取前 randomCount 个元素
groupBuyOrderLists = groupBuyOrderLists.subList(0, randomCount);
}
// 2. 过滤队伍获取 TeamId
Set<String> teamIds = groupBuyOrderLists.stream()
.map(GroupBuyOrderList::getTeamId)
.filter(teamId -> teamId != null && !teamId.isEmpty()) // 过滤非空和非空字符串
.collect(Collectors.toSet());
// 3. 查询队伍明细，组装Map结构
List<GroupBuyOrder> groupBuyOrders = groupBuyOrderDao.queryGroupBuyProgressByTeamIds(teamIds);
if (null == groupBuyOrders || groupBuyOrders.isEmpty()) return null;
Map<String, GroupBuyOrder> groupBuyOrderMap = groupBuyOrders.stream()
.collect(Collectors.toMap(GroupBuyOrder::getTeamId, order -> order));
// 4. 转换数据
List<UserGroupBuyOrderDetailEntity> userGroupBuyOrderDetailEntities = new ArrayList<>();
for (GroupBuyOrderList groupBuyOrderList : groupBuyOrderLists) {
String teamId = groupBuyOrderList.getTeamId();
GroupBuyOrder groupBuyOrder = groupBuyOrderMap.get(teamId);
if (null == groupBuyOrder) continue;
UserGroupBuyOrderDetailEntity userGroupBuyOrderDetailEntity = UserGroupBuyOrderDetailEntity.builder()
.userId(groupBuyOrderList.getUserId())
.teamId(groupBuyOrder.getTeamId())
.activityId(groupBuyOrder.getActivityId())
.targetCount(groupBuyOrder.getTargetCount())
.completeCount(groupBuyOrder.getCompleteCount())
.lockCount(groupBuyOrder.getLockCount())
.validStartTime(groupBuyOrder.getValidStartTime())
.validEndTime(groupBuyOrder.getValidEndTime())
.build();
userGroupBuyOrderDetailEntities.add(userGroupBuyOrderDetailEntity);
}
return userGroupBuyOrderDetailEntities;
}
@Override
public TeamStatisticVO queryTeamStatisticByActivityId(Long activityId) {
// 1. 根据活动ID查询拼团队伍
List<GroupBuyOrderList> groupBuyOrderLists = groupBuyOrderListDao.queryInProgressUserGroupBuyOrderDetailListByActivityId(activityId);
if (null == groupBuyOrderLists || groupBuyOrderLists.isEmpty()) {
return new TeamStatisticVO(0, 0, 0);
}
// 2. 过滤队伍获取 TeamId
Set<String> teamIds = groupBuyOrderLists.stream()
.map(GroupBuyOrderList::getTeamId)
.filter(teamId -> teamId != null && !teamId.isEmpty()) // 过滤非空和非空字符串
.collect(Collectors.toSet());
// 3. 统计数据
Integer allTeamCount = groupBuyOrderDao.queryAllTeamCount(teamIds);
Integer allTeamCompleteCount = groupBuyOrderDao.queryAllTeamCompleteCount(teamIds);
Integer allTeamUserCount = groupBuyOrderDao.queryAllUserCount(teamIds);
// 4. 构建对象
return TeamStatisticVO.builder()
.allTeamCount(allTeamCount)
.allTeamCompleteCount(allTeamCompleteCount)
.allTeamUserCount(allTeamUserCount)
.build();
}
@Override
public Integer queryUserTakeOutInAllActivity(String userId) {
GroupBuyOrderList req = new GroupBuyOrderList();
req.setUserId(userId);
Integer count = groupBuyOrderListDao.queryTotalOrderCountByActivityId(req);
return count;
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-infrastructure/src/main/java/zack/project/infrastructure/adapter/repository/ActivityRepository.java
|
Java
|
unknown
| 12,314
|
package zack.project.infrastructure.adapter.repository;
import zack.project.domain.tag.adapter.repository.ITagRepository;
import zack.project.domain.tag.model.entity.CrowdTagsJobEntity;
import zack.project.infrastructure.dao.ICrowdTagsDao;
import zack.project.infrastructure.dao.ICrowdTagsDetailDao;
import zack.project.infrastructure.dao.ICrowdTagsJobDao;
import zack.project.infrastructure.dao.po.CrowdTags;
import zack.project.infrastructure.dao.po.CrowdTagsDetail;
import zack.project.infrastructure.dao.po.CrowdTagsJob;
import zack.project.infrastructure.redis.IRedisService;
import org.redisson.api.RBitSet;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Repository;
import javax.annotation.Resource;
/**
* @author zack
* @description 人群标签仓储
* @create 2024-12-28 13:12
*/
@Repository
public class TagRepository implements ITagRepository {
@Resource
private ICrowdTagsDao crowdTagsDao;
@Resource
private ICrowdTagsDetailDao crowdTagsDetailDao;
@Resource
private ICrowdTagsJobDao crowdTagsJobDao;
@Resource
private IRedisService redisService;
@Override
public CrowdTagsJobEntity queryCrowdTagsJobEntity(String tagId, String batchId) {
CrowdTagsJob crowdTagsJobReq = new CrowdTagsJob();
crowdTagsJobReq.setTagId(tagId);
crowdTagsJobReq.setBatchId(batchId);
CrowdTagsJob crowdTagsJobRes = crowdTagsJobDao.queryCrowdTagsJob(crowdTagsJobReq);
if (null == crowdTagsJobRes) return null;
return CrowdTagsJobEntity.builder()
.tagType(crowdTagsJobRes.getTagType())
.tagRule(crowdTagsJobRes.getTagRule())
.statStartTime(crowdTagsJobRes.getStatStartTime())
.statEndTime(crowdTagsJobRes.getStatEndTime())
.build();
}
@Override
public void addCrowdTagsUserId(String tagId, String userId) {
CrowdTagsDetail crowdTagsDetailReq = new CrowdTagsDetail();
crowdTagsDetailReq.setTagId(tagId);
crowdTagsDetailReq.setUserId(userId);
try {
crowdTagsDetailDao.addCrowdTagsUserId(crowdTagsDetailReq);
} catch (DuplicateKeyException ignore) {
// 忽略唯一索引冲突
}
// 获取BitSet
RBitSet bitSet = redisService.getBitSet(tagId);
bitSet.set(redisService.getIndexFromUserId(userId), true);
}
@Override
public void updateCrowdTagsStatistics(String tagId, int count) {
CrowdTags crowdTagsReq = new CrowdTags();
crowdTagsReq.setTagId(tagId);
crowdTagsReq.setStatistics(count);
crowdTagsDao.updateCrowdTagsStatistics(crowdTagsReq);
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-infrastructure/src/main/java/zack/project/infrastructure/adapter/repository/TagRepository.java
|
Java
|
unknown
| 2,715
|
package zack.project.infrastructure.adapter.repository;
import zack.project.domain.activity.model.entity.UserGroupBuyOrderDetailEntity;
import zack.project.domain.trade.adapter.repository.ITradeRepository;
import zack.project.domain.trade.model.aggregate.GroupBuyOrderAggregate;
import zack.project.domain.trade.model.aggregate.GroupBuyRefundAggregate;
import zack.project.domain.trade.model.aggregate.GroupBuyTeamSettlementAggregate;
import zack.project.domain.trade.model.entity.*;
import zack.project.domain.trade.model.valobj.*;
import zack.project.infrastructure.dao.IGroupBuyActivityDao;
import zack.project.infrastructure.dao.IGroupBuyOrderDao;
import zack.project.infrastructure.dao.IGroupBuyOrderListDao;
import zack.project.infrastructure.dao.INotifyTaskDao;
import zack.project.infrastructure.dao.po.GroupBuyActivity;
import zack.project.infrastructure.dao.po.GroupBuyOrder;
import zack.project.infrastructure.dao.po.GroupBuyOrderList;
import zack.project.infrastructure.dao.po.NotifyTask;
import zack.project.infrastructure.dcc.DCCService;
import zack.project.infrastructure.redis.IRedisService;
import zack.project.types.common.Constants;
import zack.project.types.enums.ActivityStatusEnumVO;
import zack.project.types.enums.GroupBuyOrderEnumVO;
import zack.project.types.enums.ResponseCode;
import zack.project.types.exception.AppException;
import com.alibaba.fastjson2.JSON;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
/**
* @author zack
* @description 交易仓储服务
* @create 2025-01-11 09:17
*/
@Slf4j
@Repository
public class TradeRepository implements ITradeRepository {
@Resource
private IGroupBuyActivityDao groupBuyActivityDao;
@Resource
private IGroupBuyOrderDao groupBuyOrderDao;
@Resource
private IGroupBuyOrderListDao groupBuyOrderListDao;
@Resource
private INotifyTaskDao notifyTaskDao;
@Resource
private DCCService dccService;
@Value("${spring.rabbitmq.config.producer.topic_team_success.routing_key}")
private String topic_team_success;
@Value("${spring.rabbitmq.config.producer.topic_team_refund.routing_key}")
private String topic_team_refund;
@Resource
private IRedisService redisService;
@Override
public MarketPayOrderEntity queryMarketPayOrderEntityByOutTradeNo(String userId, String outTradeNo) {
GroupBuyOrderList groupBuyOrderListReq = new GroupBuyOrderList();
groupBuyOrderListReq.setUserId(userId);
groupBuyOrderListReq.setOutTradeNo(outTradeNo);
GroupBuyOrderList groupBuyOrderListRes =
groupBuyOrderListDao.queryGroupBuyOrderRecordByOutTradeNo(groupBuyOrderListReq);
if (null == groupBuyOrderListRes) return null;
return MarketPayOrderEntity.builder()
.teamId(groupBuyOrderListRes.getTeamId())
.orderId(groupBuyOrderListRes.getOrderId())
.originalPrice(groupBuyOrderListRes.getOriginalPrice())
.deductionPrice(groupBuyOrderListRes.getDeductionPrice())
.payPrice(groupBuyOrderListRes.getPayPrice())
.tradeOrderStatusEnumVO(TradeOrderStatusEnumVO.valueOf(groupBuyOrderListRes.getStatus()))
.build();
}
@Transactional(timeout = 500)
@Override
public MarketPayOrderEntity lockMarketPayOrder(GroupBuyOrderAggregate groupBuyOrderAggregate) {
// 聚合对象信息
UserEntity userEntity = groupBuyOrderAggregate.getUserEntity();
PayActivityEntity payActivityEntity = groupBuyOrderAggregate.getPayActivityEntity();
PayDiscountEntity payDiscountEntity = groupBuyOrderAggregate.getPayDiscountEntity();
NotifyConfigVO notifyConfigVO = payDiscountEntity.getNotifyConfigVO();
Integer userTakeOrderCount = groupBuyOrderAggregate.getUserTakeOrderCount();
// 判断是否有团 - teamId 为空 - 新团、为不空 - 老团
//向{group_buy_order}插入/修改一笔拼团队伍记录
String teamId = payActivityEntity.getTeamId();
if (StringUtils.isBlank(teamId)) {
// 使用 RandomStringUtils.randomNumeric 替代公司里使用的雪花算法UUID
teamId = RandomStringUtils.randomNumeric(8);
Date currentDate = new Date();
Calendar calendar = Calendar.getInstance();
calendar.setTime(currentDate);
calendar.add(Calendar.MINUTE, payActivityEntity.getValidTime());
// 构建拼团订单
GroupBuyOrder groupBuyOrder = GroupBuyOrder.builder()
.teamId(teamId)
.activityId(payActivityEntity.getActivityId())
.source(payDiscountEntity.getSource())
.channel(payDiscountEntity.getChannel())
.originalPrice(payDiscountEntity.getOriginalPrice())
.deductionPrice(payDiscountEntity.getDeductionPrice())
.payPrice(payDiscountEntity.getPayPrice())
.targetCount(payActivityEntity.getTargetCount())
//此时只锁了一笔订单还未完成支付
.completeCount(0)
//
.lockCount(1)
.validStartTime(currentDate)
.validEndTime(calendar.getTime())
.notifyType(notifyConfigVO.getNotifyType().getCode())
.notifyUrl(notifyConfigVO.getNotifyUrl())
.build();
// 写入记录
groupBuyOrderDao.insert(groupBuyOrder);
} else {
// 更新记录 - 如果更新记录不等于1，则表示拼团已满，抛出异常
int updateAddTargetCount = groupBuyOrderDao.updateAddLockCount(teamId);
if (1 != updateAddTargetCount) {
throw new AppException(ResponseCode.E0005);
}
}
// 日期处理
// 使用 RandomStringUtils.randomNumeric 替代公司里使用的雪花算法UUID
//向{group_buy_order_list}插入一笔拼团详单记录(此处是锁单，还未完成支付)
String orderId = RandomStringUtils.randomNumeric(12);
GroupBuyOrderList groupBuyOrderListReq = GroupBuyOrderList.builder()
.userId(userEntity.getUserId())
.teamId(teamId)
.orderId(orderId)
.activityId(payActivityEntity.getActivityId())
.startTime(payActivityEntity.getStartTime())
.endTime(payActivityEntity.getEndTime())
.goodsId(payDiscountEntity.getGoodsId())
.source(payDiscountEntity.getSource())
.channel(payDiscountEntity.getChannel())
.originalPrice(payDiscountEntity.getOriginalPrice())
.deductionPrice(payDiscountEntity.getDeductionPrice())
.payPrice(payDiscountEntity.getPayPrice())
.status(TradeOrderStatusEnumVO.CREATE.getCode())
//外部订单号，由外部对接系统传进来
.outTradeNo(payDiscountEntity.getOutTradeNo())
// 构建 bizId 唯一值；活动id_用户id_参与次数累加
.bizId(payActivityEntity.getActivityId() +
Constants.UNDERLINE +
userEntity.getUserId() +
Constants.UNDERLINE +
(userTakeOrderCount + 1))
.build();
try {
// 写入拼团记录
groupBuyOrderListDao.insert(groupBuyOrderListReq);
} catch (DuplicateKeyException e) {
throw new AppException(ResponseCode.INDEX_EXCEPTION);
}
return MarketPayOrderEntity.builder()
.orderId(orderId)
.originalPrice(payDiscountEntity.getOriginalPrice())
.deductionPrice(payDiscountEntity.getDeductionPrice())
.payPrice(payDiscountEntity.getPayPrice())
.tradeOrderStatusEnumVO(TradeOrderStatusEnumVO.CREATE)
.teamId(teamId)
.build();
}
@Override
public GroupBuyProgressVO queryGroupBuyProgress(String teamId) {
GroupBuyOrder groupBuyOrder = groupBuyOrderDao.queryGroupBuyProgress(teamId);
if (null == groupBuyOrder) return null;
return GroupBuyProgressVO.builder()
.completeCount(groupBuyOrder.getCompleteCount())
.targetCount(groupBuyOrder.getTargetCount())
.lockCount(groupBuyOrder.getLockCount())
.build();
}
@Override
public GroupBuyActivityEntity queryGroupBuyActivityEntityByActivityId(Long activityId) {
GroupBuyActivity groupBuyActivity = groupBuyActivityDao.queryGroupBuyActivityByActivityId(activityId);
return GroupBuyActivityEntity.builder()
.activityId(groupBuyActivity.getActivityId())
.activityName(groupBuyActivity.getActivityName())
.discountId(groupBuyActivity.getDiscountId())
.groupType(groupBuyActivity.getGroupType())
.takeLimitCount(groupBuyActivity.getTakeLimitCount())
.target(groupBuyActivity.getTarget())
.validTime(groupBuyActivity.getValidTime())
.status(ActivityStatusEnumVO.valueOf(groupBuyActivity.getStatus()))
.startTime(groupBuyActivity.getStartTime())
.endTime(groupBuyActivity.getEndTime())
.tagId(groupBuyActivity.getTagId())
.tagScope(groupBuyActivity.getTagScope())
.build();
}
@Override
public Integer queryOrderCountByActivityId(Long activityId, String userId) {
GroupBuyOrderList groupBuyOrderListReq = new GroupBuyOrderList();
groupBuyOrderListReq.setActivityId(activityId);
groupBuyOrderListReq.setUserId(userId);
return groupBuyOrderListDao.queryOrderCountByActivityId(groupBuyOrderListReq);
}
@Override
public GroupBuyTeamEntity queryGroupBuyTeamByTeamId(String teamId) {
GroupBuyOrder groupBuyOrder = groupBuyOrderDao.queryGroupBuyTeamByTeamId(teamId);
return GroupBuyTeamEntity.builder()
.teamId(groupBuyOrder.getTeamId())
.activityId(groupBuyOrder.getActivityId())
.targetCount(groupBuyOrder.getTargetCount())
.completeCount(groupBuyOrder.getCompleteCount())
.lockCount(groupBuyOrder.getLockCount())
.status(GroupBuyOrderEnumVO.valueOf(groupBuyOrder.getStatus()))
.validStartTime(groupBuyOrder.getValidStartTime())
.validEndTime(groupBuyOrder.getValidEndTime())
.notifyConfigVO(NotifyConfigVO.builder()
.notifyType(NotifyTypeEnumVO.valueOf(groupBuyOrder.getNotifyType()))
.notifyUrl(groupBuyOrder.getNotifyUrl())
// MQ 是固定的
.notifyMQ(topic_team_success)
.build())
.build();
}
@Transactional(timeout = 5000)
@Override
public List<NotifyTaskEntity> settlementMarketPayOrder(GroupBuyTeamSettlementAggregate groupBuyTeamSettlementAggregate) {
UserEntity userEntity = groupBuyTeamSettlementAggregate.getUserEntity();
//
GroupBuyTeamEntity groupBuyTeamEntity = groupBuyTeamSettlementAggregate.getGroupBuyTeamEntity();
NotifyConfigVO notifyConfigVO = groupBuyTeamEntity.getNotifyConfigVO();
TradePaySuccessEntity tradePaySuccessEntity = groupBuyTeamSettlementAggregate.getTradePaySuccessEntity();
// 1. 更新拼团订单明细状态
GroupBuyOrderList groupBuyOrderListReq = new GroupBuyOrderList();
groupBuyOrderListReq.setUserId(userEntity.getUserId());
groupBuyOrderListReq.setOutTradeNo(tradePaySuccessEntity.getOutTradeNo());
groupBuyOrderListReq.setOutTradeTime(tradePaySuccessEntity.getOutTradeTime());
int updateOrderListStatusCount = groupBuyOrderListDao.updateOrderStatus2COMPLETE(groupBuyOrderListReq);
if (1 != updateOrderListStatusCount) {
throw new AppException(ResponseCode.UPDATE_ZERO);
}
// 2. 更新拼团达成数量(这里可能有问题，如果target = 3，completeCount = 1，如果此时有两个请求同时到达，
// 根据teamId查询到GroupBuyTeamEntity，然后进行结算更新数据库的完成数量，此时数据库完成数量和目标数量相等，但不会给数据库写入回调任务)
int updateAddCount = groupBuyOrderDao.updateAddCompleteCount(groupBuyTeamEntity.getTeamId());
if (1 != updateAddCount) {
throw new AppException(ResponseCode.UPDATE_ZERO);
}
// 3. 更新拼团完成状态
//这个是进行结算时在SettableRuleFilter节点根据teamId查询到的拼团队伍状态，
//在当前状态下，如果目标数量-当前完成数量是1的话，
//说明本笔结算单就是最后一笔(在步骤2的时候，将拼团队伍的完成数量+1，所以数据库内部目标数量和完成数量已经是相等的了)
if (groupBuyTeamEntity.getTargetCount() - groupBuyTeamEntity.getCompleteCount() == 1) {
int updateOrderStatusCount = groupBuyOrderDao.updateOrderStatus2COMPLETE(groupBuyTeamEntity.getTeamId());
if (1 != updateOrderStatusCount) {
throw new AppException(ResponseCode.UPDATE_ZERO);
}
// 查询{group_buy_order_list}拼团交易完成外部单号列表
//本次拼团完成，在{group_buy_order_list}里面查找该队伍id下的外部订单号，
List<GroupBuyOrderList> groupBuyOrderLists =
groupBuyOrderListDao.queryGroupBuyCompleteOrderOutTradeNoListByTeamId(groupBuyTeamEntity.getTeamId());
Map<String, GroupBuyOrderList> orderMap = groupBuyOrderLists.stream().collect(Collectors.toMap(GroupBuyOrderList::getUserId, k -> k));
List<String> outTradeNoList = new ArrayList<>();
List<String> userIdList = new ArrayList<>();
for (GroupBuyOrderList groupBuyOrderList : groupBuyOrderLists) {
outTradeNoList.add(groupBuyOrderList.getOutTradeNo());
userIdList.add(groupBuyOrderList.getUserId());
}
// 拼团完成写入回调任务记录
NotifyTask notifyTask = new NotifyTask();
notifyTask.setActivityId(groupBuyTeamEntity.getActivityId());
notifyTask.setTeamId(groupBuyTeamEntity.getTeamId());
//设置回调类型是拼团交易结算
notifyTask.setNotifyCategory(TaskNotifyCategoryEnumVO.TRADE_SETTLEMENT.getCode());
//设置回调方式是http还是mq
notifyTask.setNotifyType(notifyConfigVO.getNotifyType().getCode());
//设置mq消息的topic
notifyTask.setNotifyMQ(NotifyTypeEnumVO.MQ.equals(notifyConfigVO.getNotifyType()) ?
notifyConfigVO.getNotifyMQ() : null);
//设置http回调的url地址
notifyTask.setNotifyUrl(NotifyTypeEnumVO.HTTP.equals(notifyConfigVO.getNotifyType()) ?
notifyConfigVO.getNotifyUrl() : null);
notifyTask.setNotifyRpc(null);
//重试次数
notifyTask.setNotifyCount(0);
//回调任务状态(0初始，1完成，2需要重试，3失败)
notifyTask.setNotifyStatus(0);
notifyTask.setUuid(groupBuyTeamEntity.getTeamId() +
Constants.UNDERLINE +
TaskNotifyCategoryEnumVO.TRADE_SETTLEMENT.getCode() +
Constants.UNDERLINE +
tradePaySuccessEntity.getOutTradeNo());
notifyTask.setParameterJson(JSON.toJSONString(new HashMap<String, Object>() {{
put("teamId", groupBuyTeamEntity.getTeamId());
put("outTradeNoList", outTradeNoList);
}}));
List<NotifyTask> notifyTasks = new ArrayList<>();
notifyTasks.add(notifyTask);
for (String userId : userIdList) {
GroupBuyOrderList groupBuyOrderList = orderMap.get(userId);
NotifyTask rebateTask = new NotifyTask();
rebateTask.setActivityId(groupBuyTeamEntity.getActivityId());
rebateTask.setTeamId(groupBuyTeamEntity.getTeamId());
rebateTask.setNotifyCategory(TaskNotifyCategoryEnumVO.GROUP_REBATE.getCode());
rebateTask.setNotifyType("RPC");
rebateTask.setNotifyRpc("rebate");
rebateTask.setNotifyMQ(null);
rebateTask.setNotifyUrl(null);
rebateTask.setNotifyCount(0);
rebateTask.setNotifyStatus(0);
rebateTask.setParameterJson(JSON.toJSONString(new HashMap<String, Object>() {{
put("behaviorType", "group");
put("outTradeNo", groupBuyOrderList.getOutTradeNo());
put("userId", userId);
}}));
rebateTask.setUuid(groupBuyTeamEntity.getTeamId() +
Constants.UNDERLINE +
TaskNotifyCategoryEnumVO.GROUP_REBATE.getCode() +
tradePaySuccessEntity.getOutTradeNo()
);
notifyTasks.add(rebateTask);
}
notifyTaskDao.insertList(notifyTasks);
List<NotifyTaskEntity> taskEntities = new ArrayList<>();
notifyTasks.forEach(task -> {
taskEntities.add( NotifyTaskEntity.builder()
.teamId(task.getTeamId())
.notifyType(task.getNotifyType())
.notifyMQ(task.getNotifyMQ())
.notifyUrl(task.getNotifyUrl())
.notifyRpc(task.getNotifyRpc())
.notifyCount(task.getNotifyCount())
.parameterJson(task.getParameterJson())
.uuid(task.getUuid())
.build());
});
return taskEntities;
}
return null;
}
@Override
public boolean isSCBlackIntercept(String source, String channel) {
return dccService.isSCBlackIntercept(source, channel);
}
@Override
public List<NotifyTaskEntity> queryUnExecutedNotifyTaskList() {
List<NotifyTask> notifyTaskList = notifyTaskDao.queryUnExecutedNotifyTaskList();
if (notifyTaskList.isEmpty()) return new ArrayList<>();
List<NotifyTaskEntity> notifyTaskEntities = new ArrayList<>();
for (NotifyTask notifyTask : notifyTaskList) {
NotifyTaskEntity notifyTaskEntity = NotifyTaskEntity.builder()
.teamId(notifyTask.getTeamId())
.notifyType(notifyTask.getNotifyType())
.notifyMQ(notifyTask.getNotifyMQ())
.notifyUrl(notifyTask.getNotifyUrl())
.notifyCount(notifyTask.getNotifyCount())
.parameterJson(notifyTask.getParameterJson())
.uuid(notifyTask.getUuid())
.build();
notifyTaskEntities.add(notifyTaskEntity);
}
return notifyTaskEntities;
}
@Override
public List<NotifyTaskEntity> queryUnExecutedNotifyTaskList(String teamId) {
NotifyTask notifyTask = notifyTaskDao.queryUnExecutedNotifyTaskByTeamId(teamId);
if (null == notifyTask) return new ArrayList<>();
return Collections.singletonList(NotifyTaskEntity.builder()
.teamId(notifyTask.getTeamId())
.notifyType(notifyTask.getNotifyType())
.notifyMQ(notifyTask.getNotifyMQ())
.notifyUrl(notifyTask.getNotifyUrl())
.notifyCount(notifyTask.getNotifyCount())
.parameterJson(notifyTask.getParameterJson())
.uuid(notifyTask.getUuid())
.build());
}
@Override
public int updateNotifyTaskStatusSuccess(NotifyTaskEntity notifyTaskEntity) {
NotifyTask notifyTask = NotifyTask.builder()
.teamId(notifyTaskEntity.getTeamId())
.uuid(notifyTaskEntity.getUuid())
.build();
return notifyTaskDao.updateNotifyTaskStatusSuccess(notifyTask);
}
@Override
public int updateNotifyTaskStatusError(NotifyTaskEntity notifyTaskEntity) {
NotifyTask notifyTask = NotifyTask.builder()
.teamId(notifyTaskEntity.getTeamId())
.uuid(notifyTaskEntity.getUuid())
.build();
return notifyTaskDao.updateNotifyTaskStatusError(notifyTask);
}
@Override
public int updateNotifyTaskStatusRetry(NotifyTaskEntity notifyTaskEntity) {
NotifyTask notifyTask = NotifyTask.builder()
.teamId(notifyTaskEntity.getTeamId())
.uuid(notifyTaskEntity.getUuid())
.build();
return notifyTaskDao.updateNotifyTaskStatusRetry(notifyTask);
}
/**
* 占用库存
* <p>
* 关于 Redis 独占锁和无锁化设计；<a href="https://bugstack.cn/md/road-map/redis.html">Redis 缓存、加锁(独占/分段)、发布/订阅，
* 常用特性的使用和高级编码操作</a>
*/
@Override
public boolean occupyTeamStock(String teamStockKey, String recoveryTeamStockKey, Integer target, Integer validTime) {
// 失败恢复量
Long recoveryCount = redisService.getAtomicLong(recoveryTeamStockKey);
recoveryCount = null == recoveryCount ? 0 : recoveryCount;
// 1. incr 得到值，与总量和恢复量做对比。恢复量为系统失败时候记录的量。
// 2. 从有组队量开始，相当于已经有了一个占用量，所以要 +1
//这个incr是对redis里面的teamStockKey的value+1，incr后面的+1是在java程序里面+1(这个+1不会影响到redis里面teamStockKey)
//举例：
//第一个用户发起拼团不再redis里面抢占名额(stock:0)，第二个用户参与第一用户发起的拼团，此时teamId非空需要在redis抢占名额(stock++,stock=1)，
//redis自增之后返回给第二个用户，第二个用户再+1，occupy = 2,stock=1，将这个2设置到redis抢占名额。第三个用户incr(stock++,stock=2),在java程序+1，
// occupy=3，再设置到redis抢占。
//这个teamStockKey代表的是历史队伍名额
long occupy = redisService.incr(teamStockKey) + 1;
//即使拼团人数限制为2，这里也可以正常允许，不会返回false
if (occupy > target + recoveryCount) {
return false;
}
// 1. 给每个产生的值加锁为兜底设计，虽然incr操作是原子的，基本不会产生一样的值。
// 但在实际生产中，遇到过集群的运维配置问题，以及业务运营配置数据问题，导致incr得到的值相同。
// 2. validTime + 60分钟，是一个延后时间的设计，让数据保留时间稍微长一些，便于排查问题。
String lockKey = teamStockKey + Constants.UNDERLINE + occupy;
Boolean lock = redisService.setNx(lockKey, validTime + 60, TimeUnit.MINUTES);
if (!lock) {
log.info("组队库存加锁失败 {}", lockKey);
}
return lock;
}
@Override
public void recoveryTeamStock(String recoveryTeamStockKey, Integer validTime) {
// 首次组队拼团，是没有 teamId 的，所以不需要这个做处理。
if (StringUtils.isBlank(recoveryTeamStockKey)) return;
redisService.incr(recoveryTeamStockKey);
}
/**
* 更新{group_buy_order_list}中userId和orderId对应的拼团详单(这个详单是dataNodeFilter节点根据userId和outTradeNo查出来的)的status，
* 订单状态从0(未支付)到2(关闭)，并构建回调任务，修改redis的队伍名额
*
* @param groupBuyRefundAggregate
* @return
*/
@Override
@Transactional(timeout = 5000)
public NotifyTaskEntity unpaid2Refund(GroupBuyRefundAggregate groupBuyRefundAggregate) {
TradeRefundOrderEntity tradeRefundOrderEntity = groupBuyRefundAggregate.getTradeRefundOrderEntity();
GroupBuyProgressVO groupBuyProgress = groupBuyRefundAggregate.getGroupBuyProgress();
GroupBuyOrderList groupBuyOrderListReq = new GroupBuyOrderList();
// 保留userId，企业中往往会根据 userId 作为分库分表路由键，如果将来做分库分表也可以方便处理
groupBuyOrderListReq.setUserId(tradeRefundOrderEntity.getUserId());
groupBuyOrderListReq.setOrderId(tradeRefundOrderEntity.getOrderId());
//更新{group_buy_order}和{group_buy_order_list}
int updateUnpaid2RefundCount = groupBuyOrderListDao.unpaid2Refund(groupBuyOrderListReq);
if (1 != updateUnpaid2RefundCount) {
log.error("逆向流程-unpaid2Refund，更新订单状态(退单)失败 {} {}", tradeRefundOrderEntity.getUserId(), tradeRefundOrderEntity.getOrderId());
throw new AppException(ResponseCode.UPDATE_ZERO);
}
GroupBuyOrder groupBuyOrderReq = new GroupBuyOrder();
groupBuyOrderReq.setTeamId(tradeRefundOrderEntity.getTeamId());
groupBuyOrderReq.setLockCount(groupBuyProgress.getLockCount());
//修改该teamId对应拼团队伍(状态是拼团中)的lockCount
int updateTeamUnpaid2Refund = groupBuyOrderDao.unpaid2Refund(groupBuyOrderReq);
if (1 != updateTeamUnpaid2Refund) {
log.error("逆向流程-unpaid2Refund，更新组队记录(退单)失败 {} {}", tradeRefundOrderEntity.getUserId(), tradeRefundOrderEntity.getOrderId());
throw new AppException(ResponseCode.UPDATE_ZERO);
}
// 本地消息任务表
NotifyTask notifyTask = new NotifyTask();
notifyTask.setActivityId(tradeRefundOrderEntity.getActivityId());
notifyTask.setTeamId(tradeRefundOrderEntity.getTeamId());
notifyTask.setNotifyCategory(TaskNotifyCategoryEnumVO.TRADE_UNPAID2REFUND.getCode());
notifyTask.setNotifyType(NotifyTypeEnumVO.MQ.getCode());
notifyTask.setNotifyMQ(topic_team_refund);
notifyTask.setNotifyCount(0);
notifyTask.setNotifyStatus(0);
notifyTask.setUuid(tradeRefundOrderEntity.getTeamId() + Constants.UNDERLINE + TaskNotifyCategoryEnumVO.TRADE_UNPAID2REFUND.getCode() + Constants.UNDERLINE + tradeRefundOrderEntity.getOrderId());
//这里parameterJson用hashMap转成json，hashMap里面的键是和后续TeamRefundSuccess消息用Json.parseObject进行反序列化时是一致的，
//所以这个键要和TeamRefundSuccess的字段一致
notifyTask.setParameterJson(JSON.toJSONString(new HashMap<String, Object>() {{
put("type", RefundTypeEnumVO.UNPAID_UNLOCK.getCode());
put("userId", tradeRefundOrderEntity.getUserId());
put("teamId", tradeRefundOrderEntity.getTeamId());
put("orderId", tradeRefundOrderEntity.getOrderId());
put("outTradeNo", tradeRefundOrderEntity.getOutTradeNo());
put("activityId", tradeRefundOrderEntity.getActivityId());
}}));
notifyTaskDao.insert(notifyTask);
return NotifyTaskEntity.builder()
.teamId(notifyTask.getTeamId())
.notifyType(notifyTask.getNotifyType())
.notifyMQ(notifyTask.getNotifyMQ())
.notifyCount(notifyTask.getNotifyCount())
.parameterJson(notifyTask.getParameterJson())
.uuid(notifyTask.getUuid())
.build();
}
@Override
@Transactional(timeout = 5000)
public NotifyTaskEntity paid2Refund(GroupBuyRefundAggregate groupBuyRefundAggregate) {
TradeRefundOrderEntity tradeRefundOrderEntity = groupBuyRefundAggregate.getTradeRefundOrderEntity();
GroupBuyProgressVO groupBuyProgress = groupBuyRefundAggregate.getGroupBuyProgress();
GroupBuyOrderList groupBuyOrderListReq = new GroupBuyOrderList();
// 保留userId，企业中往往会根据 userId 作为分库分表路由键，如果将来做分库分表也可以方便处理
groupBuyOrderListReq.setUserId(tradeRefundOrderEntity.getUserId());
groupBuyOrderListReq.setOrderId(tradeRefundOrderEntity.getOrderId());
//修改{group_buy_order_list}中userId和orderId对应的拼团详单(状态是1，已完成支付)的status
int updatePaid2RefundCount = groupBuyOrderListDao.paid2Refund(groupBuyOrderListReq);
if (1 != updatePaid2RefundCount) {
log.error("逆向流程-paid2Refund，更新订单状态(退单)失败 {} {}", tradeRefundOrderEntity.getUserId(), tradeRefundOrderEntity.getOrderId());
throw new AppException(ResponseCode.UPDATE_ZERO);
}
GroupBuyOrder groupBuyOrderReq = new GroupBuyOrder();
groupBuyOrderReq.setTeamId(tradeRefundOrderEntity.getTeamId());
groupBuyOrderReq.setLockCount(groupBuyProgress.getLockCount());
groupBuyOrderReq.setCompleteCount(groupBuyProgress.getCompleteCount());
//修改{group_buy_order}的拼团队伍状态，锁单量和完成量都-1
int updateTeamPaid2Refund = groupBuyOrderDao.paid2Refund(groupBuyOrderReq);
if (1 != updateTeamPaid2Refund) {
log.error("逆向流程-paid2Refund，更新组队记录(退单)失败 {} {}", tradeRefundOrderEntity.getUserId(), tradeRefundOrderEntity.getOrderId());
throw new AppException(ResponseCode.UPDATE_ZERO);
}
// 本地消息任务表
NotifyTask notifyTask = new NotifyTask();
notifyTask.setActivityId(tradeRefundOrderEntity.getActivityId());
notifyTask.setTeamId(tradeRefundOrderEntity.getTeamId());
notifyTask.setNotifyCategory(TaskNotifyCategoryEnumVO.TRADE_PAID2REFUND.getCode());
notifyTask.setNotifyType(NotifyTypeEnumVO.MQ.getCode());
notifyTask.setNotifyMQ(topic_team_refund);
notifyTask.setNotifyCount(0);
notifyTask.setNotifyStatus(0);
notifyTask.setUuid(tradeRefundOrderEntity.getTeamId() +
Constants.UNDERLINE +
TaskNotifyCategoryEnumVO.TRADE_PAID2REFUND.getCode() +
Constants.UNDERLINE +
tradeRefundOrderEntity.getOrderId());
notifyTask.setParameterJson(JSON.toJSONString(new HashMap<String, Object>() {{
put("type", RefundTypeEnumVO.PAID_UNFORMED.getCode());
put("userId", tradeRefundOrderEntity.getUserId());
put("teamId", tradeRefundOrderEntity.getTeamId());
put("orderId", tradeRefundOrderEntity.getOrderId());
put("outTradeNo", tradeRefundOrderEntity.getOutTradeNo());
put("activityId", tradeRefundOrderEntity.getActivityId());
}}));
notifyTaskDao.insert(notifyTask);
return NotifyTaskEntity.builder()
.teamId(notifyTask.getTeamId())
.notifyType(notifyTask.getNotifyType())
.notifyMQ(notifyTask.getNotifyMQ())
.notifyCount(notifyTask.getNotifyCount())
.parameterJson(notifyTask.getParameterJson())
.uuid(notifyTask.getUuid())
.build();
}
@Override
@Transactional(timeout = 5000)
public NotifyTaskEntity paidTeam2Refund(GroupBuyRefundAggregate groupBuyRefundAggregate) {
TradeRefundOrderEntity tradeRefundOrderEntity = groupBuyRefundAggregate.getTradeRefundOrderEntity();
GroupBuyProgressVO groupBuyProgress = groupBuyRefundAggregate.getGroupBuyProgress();
GroupBuyOrderEnumVO groupBuyOrderEnumVO = groupBuyRefundAggregate.getGroupBuyOrderEnumVO();
GroupBuyOrderList groupBuyOrderListReq = new GroupBuyOrderList();
// 保留userId，企业中往往会根据 userId 作为分库分表路由键，如果将来做分库分表也可以方便处理
groupBuyOrderListReq.setUserId(tradeRefundOrderEntity.getUserId());
groupBuyOrderListReq.setOrderId(tradeRefundOrderEntity.getOrderId());
int updatePaid2RefundCount =
groupBuyOrderListDao.paidTeam2Refund(groupBuyOrderListReq);
if (1 != updatePaid2RefundCount) {
log.error("逆向流程-paidTeam2Refund，更新订单状态(退单)失败 {} {}", tradeRefundOrderEntity.getUserId(), tradeRefundOrderEntity.getOrderId());
throw new AppException(ResponseCode.UPDATE_ZERO);
}
GroupBuyOrder groupBuyOrderReq = new GroupBuyOrder();
groupBuyOrderReq.setTeamId(tradeRefundOrderEntity.getTeamId());
groupBuyOrderReq.setLockCount(groupBuyProgress.getLockCount());
groupBuyOrderReq.setCompleteCount(groupBuyProgress.getCompleteCount());
// 根据拼团组队量更新状态。组队最后一个人->更新组队失败，组队还有其他人->更新组队完成含退单
if (GroupBuyOrderEnumVO.COMPLETE_FAIL.equals(groupBuyOrderEnumVO)) {
//此处要求原拼团队伍状态的完成数大于1，且队伍状态是完成或者完成含退单
int updateTeamPaid2Refund = groupBuyOrderDao.paidTeam2Refund(groupBuyOrderReq);
if (1 != updateTeamPaid2Refund) {
log.error("逆向流程-paidTeam2Refund，更新组队记录(退单)失败 {} {}", tradeRefundOrderEntity.getUserId(), tradeRefundOrderEntity.getOrderId());
throw new AppException(ResponseCode.UPDATE_ZERO);
}
} else if (GroupBuyOrderEnumVO.FAIL.equals(groupBuyOrderEnumVO)) {
//此处要求拼团队伍完成数是1，且队伍状态是完成或者完成含退单
int updateTeamPaid2RefundFail = groupBuyOrderDao.paidTeam2RefundFail(groupBuyOrderReq);
if (1 != updateTeamPaid2RefundFail) {
log.error("逆向流程-updateTeamPaid2RefundFail，更新组队记录(退单)失败 {} {}", tradeRefundOrderEntity.getUserId(), tradeRefundOrderEntity.getOrderId());
throw new AppException(ResponseCode.UPDATE_ZERO);
}
}
// 本地消息任务表
NotifyTask notifyTask = new NotifyTask();
notifyTask.setActivityId(tradeRefundOrderEntity.getActivityId());
notifyTask.setTeamId(tradeRefundOrderEntity.getTeamId());
notifyTask.setNotifyCategory(TaskNotifyCategoryEnumVO.TRADE_PAID_TEAM2REFUND.getCode());
notifyTask.setNotifyType(NotifyTypeEnumVO.MQ.getCode());
notifyTask.setNotifyMQ(topic_team_refund);
notifyTask.setNotifyCount(0);
notifyTask.setNotifyStatus(0);
notifyTask.setUuid(tradeRefundOrderEntity.getTeamId() +
Constants.UNDERLINE +
TaskNotifyCategoryEnumVO.TRADE_PAID_TEAM2REFUND.getCode() +
Constants.UNDERLINE + tradeRefundOrderEntity.getOrderId());
notifyTask.setParameterJson(JSON.toJSONString(new HashMap<String, Object>() {{
put("type", RefundTypeEnumVO.PAID_FORMED.getCode());
put("userId", tradeRefundOrderEntity.getUserId());
put("teamId", tradeRefundOrderEntity.getTeamId());
put("orderId", tradeRefundOrderEntity.getOrderId());
put("outTradeNo", tradeRefundOrderEntity.getOutTradeNo());
put("activityId", tradeRefundOrderEntity.getActivityId());
}}));
notifyTaskDao.insert(notifyTask);
return NotifyTaskEntity.builder()
.teamId(notifyTask.getTeamId())
.notifyType(notifyTask.getNotifyType())
.notifyMQ(notifyTask.getNotifyMQ())
.notifyCount(notifyTask.getNotifyCount())
.parameterJson(notifyTask.getParameterJson())
.build();
}
@Override
public void refund2AddRecovery(String recoveryTeamStockKey, String orderId) {
// 如果恢复库存key为空，直接返回
if (StringUtils.isBlank(recoveryTeamStockKey) || StringUtils.isBlank(orderId)) {
return;
}
// 使用orderId作为锁的key，避免同一订单重复恢复库存
String lockKey = "refund_lock_" + orderId;
// 尝试获取分布式锁，防止重复操作 30天过期
Boolean lockAcquired = redisService.setNx(lockKey, 30 * 24 * 60 * 60 * 1000L, TimeUnit.MINUTES);
if (!lockAcquired) {
log.warn("订单 {} 恢复库存操作已在进行中，跳过重复操作", orderId);
return;
}
try {
// 在锁保护下执行库存恢复操作
//这个recoveryKey是和锁单时抢占队伍名额时出错时进行recovery的key是一致的，它们都是针对的同一个活动id和队伍id
redisService.incr(recoveryTeamStockKey);
log.info("订单 {} 恢复库存成功，恢复库存key: {}", orderId, recoveryTeamStockKey);
} catch (Exception e) {
log.error("订单 {} 恢复库存失败，恢复库存key: {}", orderId, recoveryTeamStockKey, e);
// 如果抛异常则释放锁，允许MQ重新消费恢复库存
redisService.remove(lockKey);
throw e;
}
}
@Override
public List<UserGroupBuyOrderDetailEntity> queryTimeoutUnpaidOrderList() {
List<GroupBuyOrderList> groupBuyOrderLists = groupBuyOrderListDao.queryTimeoutUnpaidOrderList();
if (null == groupBuyOrderLists || groupBuyOrderLists.isEmpty()) {
return new ArrayList<>();
}
// 获取所有teamId
Set<String> teamIds = groupBuyOrderLists.stream()
.map(GroupBuyOrderList::getTeamId)
.collect(Collectors.toSet());
// 查询团队信息
List<GroupBuyOrder> groupBuyOrders = groupBuyOrderDao.queryGroupBuyTeamByTeamIds(teamIds);
if (null == groupBuyOrders || groupBuyOrders.isEmpty()) {
return new ArrayList<>();
}
Map<String, GroupBuyOrder> groupBuyOrderMap = groupBuyOrders.stream()
.collect(Collectors.toMap(GroupBuyOrder::getTeamId, order -> order));
// 转换数据
List<UserGroupBuyOrderDetailEntity> userGroupBuyOrderDetailEntities = new ArrayList<>();
for (GroupBuyOrderList groupBuyOrderList : groupBuyOrderLists) {
String teamId = groupBuyOrderList.getTeamId();
GroupBuyOrder groupBuyOrder = groupBuyOrderMap.get(teamId);
if (null == groupBuyOrder) continue;
UserGroupBuyOrderDetailEntity userGroupBuyOrderDetailEntity = UserGroupBuyOrderDetailEntity.builder()
.userId(groupBuyOrderList.getUserId())
.teamId(groupBuyOrder.getTeamId())
.activityId(groupBuyOrder.getActivityId())
.targetCount(groupBuyOrder.getTargetCount())
.completeCount(groupBuyOrder.getCompleteCount())
.lockCount(groupBuyOrder.getLockCount())
.validStartTime(groupBuyOrder.getValidStartTime())
.validEndTime(groupBuyOrder.getValidEndTime())
.outTradeNo(groupBuyOrderList.getOutTradeNo())
.source(groupBuyOrderList.getSource())
.channel(groupBuyOrderList.getChannel())
.build();
userGroupBuyOrderDetailEntities.add(userGroupBuyOrderDetailEntity);
}
return userGroupBuyOrderDetailEntities;
}
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-infrastructure/src/main/java/zack/project/infrastructure/adapter/repository/TradeRepository.java
|
Java
|
unknown
| 40,137
|
/**
* 仓储实现；用于实现 domain 中定义的仓储接口，如；IXxxRepository 在 Repository 中调用服务
*/
package zack.project.infrastructure.adapter.repository;
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-infrastructure/src/main/java/zack/project/infrastructure/adapter/repository/package-info.java
|
Java
|
unknown
| 180
|
package zack.project.infrastructure.dao;
import zack.project.infrastructure.dao.po.CrowdTags;
import org.apache.ibatis.annotations.Mapper;
/**
* @author zack
* @description 人群标签
* @create 2024-12-28 11:49
*/
@Mapper
public interface ICrowdTagsDao {
void updateCrowdTagsStatistics(CrowdTags crowdTagsReq);
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-infrastructure/src/main/java/zack/project/infrastructure/dao/ICrowdTagsDao.java
|
Java
|
unknown
| 327
|
package zack.project.infrastructure.dao;
import zack.project.infrastructure.dao.po.CrowdTagsDetail;
import org.apache.ibatis.annotations.Mapper;
/**
* @author zack
* @description 人群标签明细
* @create 2024-12-28 11:49
*/
@Mapper
public interface ICrowdTagsDetailDao {
void addCrowdTagsUserId(CrowdTagsDetail crowdTagsDetailReq);
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-infrastructure/src/main/java/zack/project/infrastructure/dao/ICrowdTagsDetailDao.java
|
Java
|
unknown
| 350
|
package zack.project.infrastructure.dao;
import zack.project.infrastructure.dao.po.CrowdTagsJob;
import org.apache.ibatis.annotations.Mapper;
/**
* @author zack
* @description 人群标签任务
* @create 2024-12-28 11:50
*/
@Mapper
public interface ICrowdTagsJobDao {
CrowdTagsJob queryCrowdTagsJob(CrowdTagsJob crowdTagsJobReq);
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-infrastructure/src/main/java/zack/project/infrastructure/dao/ICrowdTagsJobDao.java
|
Java
|
unknown
| 345
|
package zack.project.infrastructure.dao;
import zack.project.infrastructure.dao.po.GroupBuyActivity;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* @author zack
* @description 拼团活动Dao
* @create 2024-12-07 10:10
*/
@Mapper
public interface IGroupBuyActivityDao {
List<GroupBuyActivity> queryGroupBuyActivityList();
GroupBuyActivity queryValidGroupBuyActivity(GroupBuyActivity groupBuyActivityReq);
GroupBuyActivity queryValidGroupBuyActivityId(Long activityId);
GroupBuyActivity queryGroupBuyActivityByActivityId(Long activityId);
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-infrastructure/src/main/java/zack/project/infrastructure/dao/IGroupBuyActivityDao.java
|
Java
|
unknown
| 595
|
package zack.project.infrastructure.dao;
import zack.project.infrastructure.dao.po.GroupBuyDiscount;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* @author zack
* @description 折扣配置Dao
* @create 2024-12-07 10:10
*/
@Mapper
public interface IGroupBuyDiscountDao {
List<GroupBuyDiscount> queryGroupBuyDiscountList();
GroupBuyDiscount queryGroupBuyActivityDiscountByDiscountId(String discountId);
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-infrastructure/src/main/java/zack/project/infrastructure/dao/IGroupBuyDiscountDao.java
|
Java
|
unknown
| 448
|
package zack.project.infrastructure.dao;
import zack.project.infrastructure.dao.po.GroupBuyOrder;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Set;
/**
* @author zack
* @description 用户拼单
* @create 2025-01-11 10:33
*/
@Mapper
public interface IGroupBuyOrderDao {
void insert(GroupBuyOrder groupBuyOrder);
int updateAddLockCount(String teamId);
int updateSubtractionLockCount(String teamId);
GroupBuyOrder queryGroupBuyProgress(String teamId);
GroupBuyOrder queryGroupBuyTeamByTeamId(String teamId);
List<GroupBuyOrder> queryGroupBuyTeamByTeamIds(@Param("teamIds") Set<String> teamIds);
int updateAddCompleteCount(String teamId);
int updateOrderStatus2COMPLETE(String teamId);
List<GroupBuyOrder> queryGroupBuyProgressByTeamIds(@Param("teamIds") Set<String> teamIds);
Integer queryAllTeamCount(@Param("teamIds") Set<String> teamIds);
Integer queryAllTeamCompleteCount(@Param("teamIds") Set<String> teamIds);
Integer queryAllUserCount(@Param("teamIds") Set<String> teamIds);
int unpaid2Refund(GroupBuyOrder groupBuyOrderReq);
int paid2Refund(GroupBuyOrder groupBuyOrderReq);
int paidTeam2Refund(GroupBuyOrder groupBuyOrderReq);
int paidTeam2RefundFail(GroupBuyOrder groupBuyOrderReq);
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-infrastructure/src/main/java/zack/project/infrastructure/dao/IGroupBuyOrderDao.java
|
Java
|
unknown
| 1,364
|
package zack.project.infrastructure.dao;
import zack.project.infrastructure.dao.po.GroupBuyOrderList;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* @author zack
* @description 用户拼单明细
* @create 2025-01-11 09:07
*/
@Mapper
public interface IGroupBuyOrderListDao {
void insert(GroupBuyOrderList groupBuyOrderListReq);
GroupBuyOrderList queryGroupBuyOrderRecordByOutTradeNo(GroupBuyOrderList groupBuyOrderListReq);
Integer queryOrderCountByActivityId(GroupBuyOrderList groupBuyOrderListReq);
int updateOrderStatus2COMPLETE(GroupBuyOrderList groupBuyOrderListReq);
List<GroupBuyOrderList> queryGroupBuyCompleteOrderOutTradeNoListByTeamId(String teamId);
List<GroupBuyOrderList> queryInProgressUserGroupBuyOrderDetailListByUserId(GroupBuyOrderList groupBuyOrderListReq);
List<GroupBuyOrderList> queryInProgressUserGroupBuyOrderDetailListByRandom(GroupBuyOrderList groupBuyOrderListReq);
List<GroupBuyOrderList> queryInProgressUserGroupBuyOrderDetailListByActivityId(Long activityId);
int unpaid2Refund(GroupBuyOrderList groupBuyOrderListReq);
int paid2Refund(GroupBuyOrderList groupBuyOrderListReq);
int paidTeam2Refund(GroupBuyOrderList groupBuyOrderListReq);
/**
* 查询超时未支付订单列表
* 条件：当前时间不在活动时间范围内、状态为0（初始锁定）、out_trade_time为空
* @return 超时未支付订单列表，限制10条
*/
List<GroupBuyOrderList> queryTimeoutUnpaidOrderList();
Integer queryTotalOrderCountByActivityId(GroupBuyOrderList groupBuyOrderListReq);
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-infrastructure/src/main/java/zack/project/infrastructure/dao/IGroupBuyOrderListDao.java
|
Java
|
unknown
| 1,630
|
package zack.project.infrastructure.dao;
import zack.project.infrastructure.dao.po.NotifyTask;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* @description 回调任务
* @create 2025-01-26 18:23
*/
@Mapper
public interface INotifyTaskDao {
void insert(NotifyTask notifyTask);
void insertList(List<NotifyTask> notifyTaskList);
List<NotifyTask> queryUnExecutedNotifyTaskList();
NotifyTask queryUnExecutedNotifyTaskByTeamId(String teamId);
int updateNotifyTaskStatusSuccess(NotifyTask notifyTask);
int updateNotifyTaskStatusError(NotifyTask notifyTask);
int updateNotifyTaskStatusRetry(NotifyTask notifyTask);
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-infrastructure/src/main/java/zack/project/infrastructure/dao/INotifyTaskDao.java
|
Java
|
unknown
| 678
|
package zack.project.infrastructure.dao;
import zack.project.infrastructure.dao.po.SCSkuActivity;
import org.apache.ibatis.annotations.Mapper;
/**
* @description 渠道商品活动配置关联表Dao
* @create 2025-01-01 09:30
*/
@Mapper
public interface ISCSkuActivityDao {
SCSkuActivity querySCSkuActivityBySCGoodsId(SCSkuActivity scSkuActivity);
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-infrastructure/src/main/java/zack/project/infrastructure/dao/ISCSkuActivityDao.java
|
Java
|
unknown
| 361
|
package zack.project.infrastructure.dao;
import zack.project.infrastructure.dao.po.Sku;
import org.apache.ibatis.annotations.Mapper;
/**
* @author zack
* @description 商品查询
* @create 2024-12-21 10:48
*/
@Mapper
public interface ISkuDao {
Sku querySkuByGoodsId(String goodsId);
}
|
2301_82000044/group-buy-market-z
|
group-buy-market-z-infrastructure/src/main/java/zack/project/infrastructure/dao/ISkuDao.java
|
Java
|
unknown
| 298
|