clunt
/
ghy-all
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity

修改订单超时与自动完成

This commit is contained in:
HH 2022-09-10 17:08:33 +08:00
parent 6e4a2ec471
commit e20e08bbe0
6 changed files with 110 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
ghy-order/src/main/java/com/ghy/order/service/impl/OrderDetailServiceImpl.java
View File

@ -285,12 +285,10 @@ public class OrderDetailServiceImpl implements OrderDetailService {
@Transactional(rollbackFor = Exception.class)
// 暂时先用 synchronized 来避免重复提交
public synchronized void finish(Long orderDetailId) throws BaseAdaPayException {
// 更新订单状态
orderDetailMapper.updateStatus(orderDetailId, OrderStatus.FINISH.code());
// 校验订单
OrderDetail orderDetail = selectById(orderDetailId);
Assert.notNull(orderDetail, "找不到对应的子订单");
Assert.isTrue(orderDetail.getOrderStatus().equals(OrderStatus.FINISH.code()), "找不到对应的子订单");
Assert.isTrue(!orderDetail.getOrderStatus().equals(OrderStatus.FINISH.code()), "订单已经是完成状态");
FinancialMaster financialMaster = financialMasterService.selectByOrderMasterId(orderDetail.getOrderMasterId());
Assert.notNull(financialMaster, "找不到主财务单");
PaymentDTO payment = financialMasterService.selectPaymentById(financialMaster.getPaymentId());
@ -298,7 +296,8 @@ public class OrderDetailServiceImpl implements OrderDetailService {
FinancialDetail financialDetail = financialDetailService.selectByOrderDetailId(orderDetailId);
Assert.notNull(financialDetail, "找不到子财务单");
Assert.isTrue(financialDetail.getPayStatus() == 1, "订单不是“已支付”状态");
// 更新订单状态
orderDetailMapper.updateStatus(orderDetailId, OrderStatus.FINISH.code());
if (BigDecimal.ZERO.compareTo(financialDetail.getPayMoney()) > -1) {
logger.info("子财务单[code={}]支付金额<=0，不需要分账", financialDetail.getCode());
// 支付金额<=0的话 不需要走下面的流程了

33
ghy-payment/src/main/java/com/ghy/payment/domain/OrderFineRecord.java
View File

@ -1,33 +0,0 @@
package com.ghy.payment.domain;
import lombok.Data;
import java.util.Date;
/**
* 订单扣款记录
*
* @author HH 2022/8/4
*/
@Data
public class OrderFineRecord {
private Long id;
private Long orderDetailId;
private Integer fineType;
private Integer orderStatus;
private Date createTime;
public OrderFineRecord() {
}
public OrderFineRecord(Long orderDetailId, Integer fineType, Integer orderStatus) {
this.orderDetailId = orderDetailId;
this.fineType = fineType;
this.orderStatus = orderStatus;
}
}

44
ghy-payment/src/main/java/com/ghy/payment/domain/OrderTimeoutRecord.java Normal file
View File

@ -0,0 +1,44 @@
package com.ghy.payment.domain;
import lombok.Data;
import java.util.Date;
/**
* 订单超时扣款记录表
*
* @author HH 2022/8/4
*/
@Data
public class OrderTimeoutRecord {
private Long id;
/**
* 子订单ID
*/
private Long orderDetailId;
/**
* 超时时的订单状态
*/
private Integer orderStatus;
/**
* 扣款状态 0未扣款 1已扣款
*/
private Integer fineStatus;
/**
* 创建时间
*/
private Date createTime;
public OrderTimeoutRecord() {
}
public OrderTimeoutRecord(Long orderDetailId, Integer orderStatus) {
this.orderDetailId = orderDetailId;
this.orderStatus = orderStatus;
}
}

8
ghy-payment/src/main/java/com/ghy/payment/mapper/OrderFineRecordMapper.java
View File

@ -1,6 +1,6 @@
package com.ghy.payment.mapper;
import com.ghy.payment.domain.OrderFineRecord;
import com.ghy.payment.domain.OrderTimeoutRecord;
import java.util.List;
@ -9,7 +9,9 @@ import java.util.List;
*/
public interface OrderFineRecordMapper {
List<OrderFineRecord> selectList(OrderFineRecord orderFineRecord);
List<OrderTimeoutRecord> selectList(OrderTimeoutRecord orderTimeoutRecord);
int insert(OrderFineRecord orderFineRecord);
int insert(OrderTimeoutRecord orderTimeoutRecord);
int update(OrderTimeoutRecord orderTimeoutRecord);
}

22
ghy-payment/src/main/resources/mapper/financial/OrderFineRecordMapper.xml
View File

@ -4,20 +4,20 @@
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ghy.payment.mapper.OrderFineRecordMapper">
<resultMap id="OrderFineRecordResult" type="com.ghy.payment.domain.OrderFineRecord">
<resultMap id="OrderFineRecordResult" type="com.ghy.payment.domain.OrderTimeoutRecord">
<id property="id" column="id"/>
<result property="orderDetailId" column="order_detail_id"/>
<result property="fineType" column="fine_type"/>
<result property="fineStatus" column="fine_status"/>
<result property="orderStatus" column="order_status"/>
<result property="createTime" column="create_time"/>
</resultMap>
<sql id="selectOrderFineRecord">
SELECT id, order_detail_id, fine_type, order_status, create_time
FROM order_fine_record
SELECT id, order_detail_id, fine_status, order_status, create_time
FROM order_timeout_record
</sql>
<select id="selectList" parameterType="com.ghy.payment.domain.OrderFineRecord"
<select id="selectList" parameterType="com.ghy.payment.domain.OrderTimeoutRecord"
resultMap="OrderFineRecordResult">
<include refid="selectOrderFineRecord"/>
<where>
@ -30,9 +30,15 @@
</where>
</select>
<insert id="insert" parameterType="com.ghy.payment.domain.OrderFineRecord" useGeneratedKeys="true"
<insert id="insert" parameterType="com.ghy.payment.domain.OrderTimeoutRecord" useGeneratedKeys="true"
keyProperty="id">
INSERT INTO order_fine_record (order_detail_id, fine_type, order_status)
VALUES (#{orderDetailId}, #{fineType}, #{orderStatus})
INSERT INTO order_timeout_record (order_detail_id, fine_status, order_status)
VALUES (#{orderDetailId}, #{fineStatus}, #{orderStatus})
</insert>
<update id="update">
UPDATE order_timeout_record SET fine_status = #{fineStatus}
WHERE id = #{id}
</update>
</mapper>

75
ghy-quartz/src/main/java/com/ghy/quartz/service/impl/OrderServiceImpl.java
View File

@ -7,7 +7,7 @@ import com.ghy.order.domain.OrderMaster;
import com.ghy.order.service.OrderDetailService;
import com.ghy.order.service.OrderMasterService;
import com.ghy.payment.domain.FinancialDetail;
import com.ghy.payment.domain.OrderFineRecord;
import com.ghy.payment.domain.OrderTimeoutRecord;
import com.ghy.payment.mapper.OrderFineRecordMapper;
import com.ghy.payment.service.FinancialDetailService;
import com.ghy.quartz.service.OrderService;
@ -22,7 +22,6 @@ import org.springframework.util.CollectionUtils;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
@ -44,7 +43,7 @@ public class OrderServiceImpl implements OrderService {
/**
* 需要超时扣款的订单状态
*/
@Value("${order.timeout.status:-4,-3,-2,1,2,3}")
@Value("${order.timeout.status:-4,-3,-2,1,2}")
private List<Integer> timeoutOrderStatus;
@Resource
@ -60,49 +59,63 @@ public class OrderServiceImpl implements OrderService {
@Override
public void overTimeOrder(String orderStatus) {
LocalDateTime now = LocalDateTime.now();
int nowDay = now.getDayOfMonth();
int nowHour = now.getHour();
if (nowHour > 17 || nowHour < 9) {
// 如果处于休息时间 定时任务不执行
return;
}
// 这是半小时前的时间
Date halfHour = new Date(System.currentTimeMillis() - 30 * 60 * 1000);
// 这是4小时前的时间
Date fourHour = new Date(System.currentTimeMillis() - 4 * 60 * 60 * 1000);
// 查询符合超时的单
List<OrderDetail> orders = orderDetailService.selectByStatus(timeoutOrderStatus);
for (OrderDetail order : orders) {
Date updateTime = order.getUpdateTime();
Calendar instance = Calendar.getInstance();
instance.setTime(updateTime);
if (instance.get(Calendar.DAY_OF_MONTH) == nowDay) {
// 如果订单更新的时间是今天
if (System.currentTimeMillis() - updateTime.getTime() > HOUR_TIME_MILLIS * 4) {
// 并且距离上一次更新时间已经超过4h 则判定超时
executor.execute(() -> orderTimeout(order));
if (order.getOrderStatus().equals(OrderStatus.SERVER.code())) {
// 服务中状态要按预计上门时间计算超时 4h超时并且扣款
if (order.getExpectTimeStart().before(fourHour)) {
executor.execute(() -> orderTimeout(order, true));
}
} else {
// 如果订单更新的时间不是今天
if (System.currentTimeMillis() - updateTime.getTime() > HOUR_TIME_MILLIS * 19) {
// 并且距离上一次更新时间已经超过15h 则判定超时
executor.execute(() -> orderTimeout(order));
} else if (timeoutOrderStatus.contains(order.getOrderStatus())) {
// 其它状态用update_time判断超时 30min超时 4h扣款
if (order.getUpdateTime().before(fourHour)) {
executor.execute(() -> orderTimeout(order, true));
} else if (order.getUpdateTime().before(halfHour)) {
executor.execute(() -> orderTimeout(order, false));
}
}
}
}
/**
* 处理订单超时与扣款
*
* @param order 子订单信息
* @param fine 是否需要扣款
*/
@Transactional(rollbackFor = Exception.class)
public void orderTimeout(OrderDetail order) {
// 查询扣款记录 如果已经扣过了 就不处理了
OrderFineRecord orderFineRecord = new OrderFineRecord(order.getId(), 1, order.getOrderStatus());
List<OrderFineRecord> records = orderFineRecordMapper.selectList(orderFineRecord);
if (!CollectionUtils.isEmpty(records)) {
public void orderTimeout(OrderDetail order, boolean fine) {
OrderTimeoutRecord record = new OrderTimeoutRecord(order.getId(), order.getOrderStatus());
List<OrderTimeoutRecord> records = orderFineRecordMapper.selectList(record);
if (CollectionUtils.isEmpty(records)) {
// 如果没有扣款记录 则保存一条扣款记录
record.setFineStatus(0);
orderFineRecordMapper.insert(record);
} else {
record = records.get(0);
}
if (!fine) {
// 不需要扣款
return;
}
if (record.getFineStatus() == 1) {
// 如果已经扣款 就不需要往下走了
return;
}
// 保存一条扣款记录
orderFineRecordMapper.insert(orderFineRecord);
// 把超时记录的扣款状态改为1
record.setFineStatus(1);
orderFineRecordMapper.update(record);
//下面是扣款逻辑
// 从子订单对应的财务单里扣除2元
FinancialDetail orderFinancial = financialDetailService.selectByOrderDetailId(order.getId());
orderFinancial.setPayMoney(orderFinancial.getPayMoney().subtract(TIMEOUT_MONEY));
@ -145,7 +158,7 @@ public class OrderServiceImpl implements OrderService {
executor.execute(() -> {
try {
orderMasterService.finish(orderMaster.getId());
}catch (Exception e){
} catch (Exception e) {
logger.error("主订单 Finish 失败", e);
}
});