package com.iotechn.unimall.biz.quartz;
|
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.dobbinsoft.fw.core.Const;
|
import com.dobbinsoft.fw.core.exception.AdminServiceException;
|
import com.dobbinsoft.fw.core.exception.ServiceException;
|
import com.dobbinsoft.fw.support.component.LockComponent;
|
import com.dobbinsoft.fw.support.component.MachineComponent;
|
import com.dobbinsoft.fw.support.mq.DelayedMessageQueue;
|
import com.iotechn.unimall.biz.client.erp.ErpClient;
|
import com.iotechn.unimall.biz.service.order.OrderBizService;
|
import com.iotechn.unimall.data.constant.LockConst;
|
import com.iotechn.unimall.data.domain.*;
|
import com.iotechn.unimall.data.dto.UserDTO;
|
import com.iotechn.unimall.data.enums.*;
|
import com.iotechn.unimall.data.exception.ExceptionDefinition;
|
import com.iotechn.unimall.data.mapper.*;
|
import com.iotechn.unimall.data.properties.UnimallOrderProperties;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.data.redis.core.StringRedisTemplate;
|
import org.springframework.scheduling.annotation.EnableScheduling;
|
import org.springframework.scheduling.annotation.Scheduled;
|
import org.springframework.stereotype.Component;
|
import org.springframework.transaction.TransactionStatus;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
|
import org.springframework.transaction.support.TransactionTemplate;
|
import org.springframework.util.CollectionUtils;
|
|
import java.util.Date;
|
import java.util.List;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
|
/**
|
* Created by rize on 2019/7/21.
|
*/
|
@Component
|
@EnableScheduling
|
public class CheckQuartz {
|
|
private static final Logger logger = LoggerFactory.getLogger(CheckQuartz.class);
|
|
@Autowired
|
private OrderMapper orderMapper;
|
@Autowired
|
private OrderBizService orderBizService;
|
@Autowired
|
private GroupShopMapper groupShopMapper;
|
@Autowired
|
private SpuMapper spuMapper;
|
@Autowired
|
private UserMapper userMapper;
|
@Autowired
|
private VipOrderMapper vipOrderMapper;
|
@Autowired
|
private ErpClient erpClient;
|
@Autowired
|
private UnimallOrderProperties unimallOrderProperties;
|
@Autowired
|
private LockComponent lockComponent;
|
@Autowired
|
private DelayedMessageQueue delayedMessageQueue;
|
@Autowired
|
private TransactionTemplate transactionTemplate;
|
@Autowired
|
private StringRedisTemplate userRedisTemplate;
|
@Autowired
|
private MachineComponent machineComponent;
|
|
/**
|
* 此定时任务是算是保险，防止Redis延迟消息丢失的情况
|
* 订单状态定时轮训,检查是否存在需要取消订单，需要收货订单
|
*/
|
@Scheduled(cron = "0 * * * * ?")
|
public void checkOrderStatus() {
|
if (lockComponent.tryLock(LockConst.SCHEDULED_ORDER_STATUS_CHECK_LOCK, 30)) {
|
Date now = new Date();
|
// 1.检查是否存在需要自动取消的订单（即redis过期回调失败），将检查出的订单延时一秒放入延时队列
|
QueryWrapper<OrderDO> cancelWrapper = new QueryWrapper<OrderDO>();
|
cancelWrapper.select("id", "order_no");
|
cancelWrapper.eq("status", OrderStatusType.UNPAY.getCode());
|
Date cancelTime = new Date(now.getTime() - unimallOrderProperties.getAutoCancelTime() * 1000);
|
cancelWrapper.lt("gmt_update", cancelTime);
|
List<OrderDO> cancelList = orderMapper.selectList(cancelWrapper);
|
if (!CollectionUtils.isEmpty(cancelList)) {
|
cancelList.stream().forEach(item -> {
|
delayedMessageQueue.publishTask(DMQHandlerType.ORDER_AUTO_CANCEL.getCode(), item.getOrderNo(), 1);
|
});
|
}
|
// 2.检查是否存在需要自动收货的订单（即redis过期回调失败），将检查出的订单延时一秒放入延时队列
|
QueryWrapper<OrderDO> confirmWrapper = new QueryWrapper<OrderDO>();
|
confirmWrapper.select("id", "order_no");
|
confirmWrapper.eq("status", OrderStatusType.WAIT_CONFIRM.getCode());
|
Date confirmTime = new Date(now.getTime() - unimallOrderProperties.getAutoConfirmTime() * 1000);
|
confirmWrapper.lt("gmt_update", confirmTime);
|
List<OrderDO> confirmList = orderMapper.selectList(confirmWrapper);
|
if (!CollectionUtils.isEmpty(confirmList)) {
|
confirmList.stream().forEach(item -> {
|
delayedMessageQueue.publishTask(DMQHandlerType.ORDER_AUTO_CONFIRM.getCode(), item.getOrderNo(), 1);
|
});
|
}
|
}
|
}
|
|
/**
|
* 设定60s跑一次,团购商品到期自动退款,改变状态
|
*/
|
@Scheduled(cron = "10 * * * * ?")
|
@Transactional(rollbackFor = Exception.class)
|
public void groupShopStart() throws Exception {
|
if (lockComponent.tryLock(LockConst.GROUP_SHOP_START_LOCK, 30)) {
|
Date now = new Date();
|
/**
|
* 1. 激活 团购时间开始的活动商品
|
*/
|
// 1.1 查询在活动期间,且冻结状态的团购商品
|
List<GroupShopDO> groupShopDOList = groupShopMapper.selectList(new QueryWrapper<GroupShopDO>()
|
.le("gmt_start", now)
|
.gt("gmt_end", now)
|
.eq("status", StatusType.LOCK.getCode()));
|
if (groupShopDOList != null) {
|
for (GroupShopDO groupShopDO : groupShopDOList) {
|
groupShopDO.setGmtUpdate(now);
|
groupShopDO.setStatus(StatusType.ACTIVE.getCode());
|
SpuDO spuDO = spuMapper.selectById(groupShopDO.getSpuId());
|
if (spuDO == null) {
|
throw new AdminServiceException(ExceptionDefinition.GROUP_SHOP_SPU_NO_EXITS);
|
}
|
|
// 1.2 检查商品是不是已经下架
|
if (spuDO.getStatus().equals(StatusType.ACTIVE.getCode())) {
|
if (groupShopMapper.updateById(groupShopDO) <= 0) {
|
throw new AdminServiceException(ExceptionDefinition.GROUP_SHOP_SPU_UPDATE_SQL_QUERY_ERROR);
|
}
|
}
|
}
|
}
|
}
|
|
|
}
|
|
@Scheduled(cron = "10 * * * * ?")
|
public void groupShopEnd() throws Exception {
|
if (lockComponent.tryLock(LockConst.GROUP_SHOP_END_LOCK, 30)) {
|
Date now = new Date();
|
/**
|
* 2. 冻结 团购时间结束的活动商品,并根据对应情况处理订单
|
*/
|
QueryWrapper<GroupShopDO> wrapper = new QueryWrapper<GroupShopDO>()
|
.eq("status", StatusType.ACTIVE.getCode())
|
.and(i -> i
|
.gt("gmt_start", now)
|
.or()
|
.le("gmt_end", now));
|
|
List<GroupShopDO> lockGroupShopDOList = groupShopMapper.selectList(wrapper);
|
// 2.2 将团购订单的状态转为对应的退款或待出库状态,对未达人数且自动退款的商品订单进行退款,对达到人数或不自动退款的商品订单转换状态
|
if (!CollectionUtils.isEmpty(lockGroupShopDOList)) {
|
for (GroupShopDO groupShopDO : lockGroupShopDOList) {
|
transactionTemplate.execute(new TransactionCallbackWithoutResult() {
|
@Override
|
protected void doInTransactionWithoutResult(TransactionStatus parentTransactionStatus) {
|
try {
|
// 2.1 对过期团购活动冻结.
|
GroupShopDO lockGroupShopDO = new GroupShopDO();
|
lockGroupShopDO.setId(groupShopDO.getId());
|
lockGroupShopDO.setStatus(StatusType.LOCK.getCode());
|
lockGroupShopDO.setGmtUpdate(now);
|
groupShopMapper.updateById(lockGroupShopDO);
|
|
// 2.2.1查询团购订单中数据
|
List<OrderDO> lockOrderList = orderMapper.selectList(
|
new QueryWrapper<OrderDO>()
|
.eq("group_shop_id", groupShopDO.getId())
|
.eq("status", OrderStatusType.GROUP_SHOP_WAIT.getCode()));
|
|
if (CollectionUtils.isEmpty(lockOrderList)) {
|
// 未有团购订单，直接空过
|
return;
|
}
|
|
if (groupShopDO.getAutomaticRefund() == GroupShopAutomaticRefundType.YES.getCode() && groupShopDO.getBuyerNum().compareTo(groupShopDO.getMinNum()) < 0) {
|
// 2.2.2.1.退款
|
logger.info("[团购结束] 退款逻辑 GroupShopId:" + groupShopDO.getId());
|
for (OrderDO orderDO : lockOrderList) {
|
transactionTemplate.execute(new TransactionCallbackWithoutResult() {
|
@Override
|
protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
|
try {
|
// 此处存在RPC，不一定能保证能保证一致性，所以单独加上事务，不要影响其他的订单
|
orderBizService.groupShopStatusRefund(orderDO.getOrderNo());
|
logger.info("[团购订单退款] 完成 orderNo:" + orderDO.getOrderNo());
|
} catch (Exception e) {
|
logger.error("[团购订单退款] 异常 orderNo:" + orderDO.getOrderNo(), e);
|
transactionStatus.setRollbackOnly();
|
}
|
}
|
});
|
}
|
} else {
|
logger.info("[团购结束] 发货逻辑 GroupShopId:" + groupShopDO.getId());
|
// 2.2.2.2 转换订单为待出货状态 (非自动退款场景)
|
for (OrderDO orderDO : lockOrderList) {
|
transactionTemplate.execute(new TransactionCallbackWithoutResult() {
|
@Override
|
protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
|
try {
|
// 此处存在RPC，不一定能保证能保证一致性，所以单独加上事务，不要影响其他的订单
|
OrderDO updateOrderDO = new OrderDO();
|
updateOrderDO.setStatus(OrderStatusType.WAIT_STOCK.getCode());
|
orderBizService.changeOrderSubStatus(orderDO.getOrderNo(), OrderStatusType.GROUP_SHOP_WAIT.getCode(), updateOrderDO);
|
erpClient.takeSalesHeader(orderDO.getOrderNo());
|
logger.info("[团购订单发货] 完成 orderNo:" + orderDO.getOrderNo());
|
} catch (Exception e) {
|
logger.error("[团购订单发货] 异常 orderNo:" + orderDO.getOrderNo(), e);
|
transactionStatus.setRollbackOnly();
|
}
|
}
|
});
|
}
|
}
|
} catch (Exception e) {
|
logger.error("[团购结束] 定时任务 异常 id=" + groupShopDO.getId(), e);
|
parentTransactionStatus.setRollbackOnly();
|
}
|
}
|
});
|
}
|
}
|
}
|
}
|
|
|
/**
|
* 会员过期设置
|
*
|
* @throws Exception
|
*/
|
@Scheduled(cron = "0 0 0 * * ?")
|
public void downLevel() throws Exception {
|
if (lockComponent.tryLock(LockConst.VIP_EXPIRE_LOCK, 30)) {
|
Date now = new Date();
|
transactionTemplate.execute(new TransactionCallbackWithoutResult() {
|
@Override
|
protected void doInTransactionWithoutResult(TransactionStatus status) {
|
List<Long> userIds = null;
|
try {
|
QueryWrapper<UserDO> wrapper = new QueryWrapper<>();
|
wrapper.eq("level", UserLevelType.VIP.getCode());
|
wrapper.le("gmt_vip_expire", now);
|
wrapper.select("id");
|
userIds = userMapper.selectList(wrapper.select("id")).stream().map(UserDO::getId).collect(Collectors.toList());
|
if (!CollectionUtils.isEmpty(userIds)) {
|
UserDO update = new UserDO();
|
update.setLevel(UserLevelType.COMMON.getCode());
|
userMapper.update(update, wrapper);
|
}
|
} catch (Exception e) {
|
status.setRollbackOnly();
|
return;
|
}
|
// 事务提交成功！更新用户session
|
if (!CollectionUtils.isEmpty(userIds)) {
|
for (Long userId : userIds) {
|
Set<String> keys = userRedisTemplate.keys(Const.USER_REDIS_PREFIX + userId + "-*");
|
if (!CollectionUtils.isEmpty(keys)) {
|
for (String key : keys) {
|
String userJson = userRedisTemplate.opsForValue().get(key);
|
UserDTO userDTO = JSONObject.parseObject(userJson, UserDTO.class);
|
userDTO.setLevel(UserLevelType.COMMON.getCode());
|
userRedisTemplate.opsForValue().set(key, JSONObject.toJSONString(userDTO));
|
}
|
|
}
|
}
|
}
|
}
|
});
|
}
|
}
|
|
/**
|
* 会员支付超时设置
|
*
|
* @throws Exception
|
*/
|
@Scheduled(cron = "20 * * * * ?")
|
public void checkVipOrderStatus() throws Exception {
|
if (lockComponent.tryLock(LockConst.VIP_PAY_TIMEOUT_LOCK, 30)) {
|
try {
|
QueryWrapper<VipOrderDO> wrapper = new QueryWrapper<>();
|
wrapper.eq("status", VipOrderStatusType.WAIT_REFUND.getCode());
|
wrapper.le("gmt_pay", new Date(new Date().getTime() - 7 * 24 * 60 * 60 * 1000l));
|
List<VipOrderDO> vipOrderDOS = vipOrderMapper.selectList(wrapper);
|
if (!CollectionUtils.isEmpty(vipOrderDOS)) {
|
for (VipOrderDO vipOrderDO : vipOrderDOS) {
|
delayedMessageQueue.publishTask(DMQHandlerType.VIP_ORDER_BUY_OVER.getCode(), String.valueOf(vipOrderDO.getId()), 1);
|
}
|
}
|
} finally {
|
lockComponent.release(LockConst.VIP_PAY_TIMEOUT_LOCK);
|
}
|
}
|
}
|
|
/**
|
* 续约机器号
|
*/
|
@Scheduled(cron = "0 0/5 * * * ?")
|
public void renewMachineNo() {
|
if (this.machineComponent.isInit()) {
|
this.machineComponent.renew();
|
}
|
}
|
|
}
|
