package com.tcm.training.admin.app.points.service;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.tcm.training.admin.app.auth.service.AppAuthSessionService;
|
import com.tcm.training.admin.app.points.vo.AppPointsExchangeOrderDetailVO;
|
import com.tcm.training.admin.app.points.vo.AppPointsExchangeOrderItemVO;
|
import com.tcm.training.admin.common.PageResponse;
|
import com.tcm.training.admin.live.entity.Clinic;
|
import com.tcm.training.admin.live.mapper.ClinicMapper;
|
import com.tcm.training.admin.member.entity.AppUser;
|
import com.tcm.training.admin.member.mapper.UserMapper;
|
import com.tcm.training.admin.points.entity.PointsExchangeOrder;
|
import com.tcm.training.admin.points.entity.PointsExchangeOrderItem;
|
import com.tcm.training.admin.points.mapper.PointsExchangeOrderItemMapper;
|
import com.tcm.training.admin.points.mapper.PointsExchangeOrderMapper;
|
import com.tcm.training.admin.points.row.PointsExchangeItemRow;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.time.LocalDateTime;
|
import java.util.ArrayList;
|
import java.util.List;
|
|
/**
|
* APP 兑换订单服务。
|
*/
|
@Service
|
public class AppPointsExchangeOrderService {
|
|
private static final int STATUS_PENDING = 0;
|
private static final int STATUS_RECEIVING = 1;
|
private static final int STATUS_COMPLETED = 2;
|
|
private final AppAuthSessionService appAuthSessionService;
|
private final PointsExchangeOrderItemMapper pointsExchangeOrderItemMapper;
|
private final PointsExchangeOrderMapper pointsExchangeOrderMapper;
|
private final UserMapper userMapper;
|
private final ClinicMapper clinicMapper;
|
|
/**
|
* 注入 APP 兑换订单所需依赖。
|
*/
|
public AppPointsExchangeOrderService(AppAuthSessionService appAuthSessionService,
|
PointsExchangeOrderItemMapper pointsExchangeOrderItemMapper,
|
PointsExchangeOrderMapper pointsExchangeOrderMapper,
|
UserMapper userMapper,
|
ClinicMapper clinicMapper) {
|
this.appAuthSessionService = appAuthSessionService;
|
this.pointsExchangeOrderItemMapper = pointsExchangeOrderItemMapper;
|
this.pointsExchangeOrderMapper = pointsExchangeOrderMapper;
|
this.userMapper = userMapper;
|
this.clinicMapper = clinicMapper;
|
}
|
|
/**
|
* 分页查询当前登录用户的兑换订单列表。
|
*/
|
public PageResponse<AppPointsExchangeOrderItemVO> page(int page, int pageSize, Integer status) {
|
Long appUserId = appAuthSessionService.requireLoginUserId();
|
int normalizedPage = page <= 0 ? 1 : page;
|
int normalizedPageSize = pageSize <= 0 ? 10 : pageSize;
|
IPage<PointsExchangeItemRow> result = pointsExchangeOrderItemMapper.selectAppItemPage(
|
new Page<PointsExchangeItemRow>(normalizedPage, normalizedPageSize),
|
appUserId,
|
normalizeStatus(status)
|
);
|
return PageResponse.of(toItemList(result.getRecords()), result.getTotal(), result.getCurrent(), result.getSize());
|
}
|
|
/**
|
* 获取当前登录用户的兑换订单详情。
|
*/
|
public AppPointsExchangeOrderDetailVO detail(Long id) {
|
Long appUserId = appAuthSessionService.requireLoginUserId();
|
PointsExchangeItemRow row = requireOwnedItemRow(id, appUserId);
|
AppUser user = userMapper.selectById(appUserId);
|
Clinic clinic = resolveClinic(user == null ? null : user.getClinicId());
|
|
AppPointsExchangeOrderDetailVO detail = new AppPointsExchangeOrderDetailVO();
|
detail.setId(row.getId());
|
detail.setOrderNo(trimToEmpty(row.getOrderNo()));
|
detail.setStatus(row.getStatus());
|
detail.setStatusText(resolveStatusText(row.getStatus()));
|
detail.setTrackingNo(trimToEmpty(row.getTrackingNo()));
|
detail.setCreatedAt(row.getCreatedAt());
|
detail.setShippedAt(row.getShippedAt());
|
detail.setCompletedAt(row.getCompletedAt());
|
detail.setCanConfirmReceived(Boolean.valueOf(isReceivable(row.getStatus())));
|
detail.setCanDelete(Boolean.valueOf(isDeletable(row.getStatus())));
|
|
AppPointsExchangeOrderDetailVO.GiftVO gift = new AppPointsExchangeOrderDetailVO.GiftVO();
|
gift.setCover(trimToEmpty(row.getGiftCover()));
|
gift.setName(trimToEmpty(row.getGiftName()));
|
gift.setRequiredPoints(defaultNumber(row.getRequiredPoints()));
|
gift.setItemCount(Integer.valueOf(1));
|
gift.setTotalPoints(defaultNumber(row.getSettledPoints()));
|
detail.setGift(gift);
|
|
AppPointsExchangeOrderDetailVO.ClinicVO clinicVO = new AppPointsExchangeOrderDetailVO.ClinicVO();
|
clinicVO.setName(trimToEmpty(clinic == null ? null : clinic.getName()));
|
clinicVO.setAddress(trimToEmpty(clinic == null ? null : clinic.getAddress()));
|
detail.setClinic(clinicVO);
|
return detail;
|
}
|
|
/**
|
* 确认当前登录用户的兑换订单已取货。
|
*/
|
@Transactional
|
public void confirmReceived(Long id) {
|
Long appUserId = appAuthSessionService.requireLoginUserId();
|
PointsExchangeOrderItem item = requireOwnedItem(id, appUserId);
|
if (!isReceivable(item.getStatus())) {
|
throw new IllegalArgumentException("当前订单不允许确认取货");
|
}
|
LocalDateTime now = LocalDateTime.now();
|
item.setStatus(STATUS_COMPLETED);
|
item.setCompletedAt(now);
|
pointsExchangeOrderItemMapper.updateById(item);
|
refreshSummaryOrderStatus(item.getOrderId(), now);
|
}
|
|
/**
|
* 删除当前登录用户已完成的兑换订单。
|
*/
|
@Transactional
|
public void delete(Long id) {
|
Long appUserId = appAuthSessionService.requireLoginUserId();
|
PointsExchangeOrderItem item = requireOwnedItem(id, appUserId);
|
if (!isDeletable(item.getStatus())) {
|
throw new IllegalArgumentException("当前订单不允许删除");
|
}
|
Long orderId = item.getOrderId();
|
pointsExchangeOrderItemMapper.deleteById(item.getId());
|
refreshSummaryOrderAfterDelete(orderId);
|
}
|
|
/**
|
* 将数据库行转换为 APP 列表展示结构。
|
*/
|
private List<AppPointsExchangeOrderItemVO> toItemList(List<PointsExchangeItemRow> rows) {
|
List<AppPointsExchangeOrderItemVO> list = new ArrayList<AppPointsExchangeOrderItemVO>();
|
if (rows == null) {
|
return list;
|
}
|
for (PointsExchangeItemRow row : rows) {
|
AppPointsExchangeOrderItemVO item = new AppPointsExchangeOrderItemVO();
|
item.setId(row.getId());
|
item.setOrderNo(trimToEmpty(row.getOrderNo()));
|
item.setGiftCover(trimToEmpty(row.getGiftCover()));
|
item.setGiftName(trimToEmpty(row.getGiftName()));
|
item.setRequiredPoints(defaultNumber(row.getRequiredPoints()));
|
item.setItemCount(Integer.valueOf(1));
|
item.setTotalPoints(defaultNumber(row.getSettledPoints()));
|
item.setStatus(row.getStatus());
|
item.setStatusText(resolveStatusText(row.getStatus()));
|
list.add(item);
|
}
|
return list;
|
}
|
|
/**
|
* 校验并返回当前登录用户名下的兑换订单行。
|
*/
|
private PointsExchangeItemRow requireOwnedItemRow(Long id, Long appUserId) {
|
PointsExchangeItemRow row = pointsExchangeOrderItemMapper.selectAppItemDetail(id, appUserId);
|
if (row == null) {
|
throw new IllegalArgumentException("兑换订单不存在");
|
}
|
return row;
|
}
|
|
/**
|
* 校验并返回当前登录用户名下的兑换订单实体。
|
*/
|
private PointsExchangeOrderItem requireOwnedItem(Long id, Long appUserId) {
|
PointsExchangeOrderItem item = pointsExchangeOrderItemMapper.selectOne(new LambdaQueryWrapper<PointsExchangeOrderItem>()
|
.eq(PointsExchangeOrderItem::getId, id)
|
.eq(PointsExchangeOrderItem::getAppUserId, appUserId)
|
.eq(PointsExchangeOrderItem::getDeleted, 0)
|
.last("limit 1"));
|
if (item == null) {
|
throw new IllegalArgumentException("兑换订单不存在");
|
}
|
return item;
|
}
|
|
/**
|
* 读取用户绑定诊所，不存在时返回空。
|
*/
|
private Clinic resolveClinic(Long clinicId) {
|
if (clinicId == null) {
|
return null;
|
}
|
Clinic clinic = clinicMapper.selectById(clinicId);
|
if (clinic == null || clinic.getDeleted() == null || clinic.getDeleted().intValue() != 0) {
|
return null;
|
}
|
return clinic;
|
}
|
|
/**
|
* 刷新汇总订单状态，保证确认取货后与明细一致。
|
*/
|
private void refreshSummaryOrderStatus(Long orderId, LocalDateTime completedAt) {
|
if (orderId == null) {
|
return;
|
}
|
PointsExchangeOrder order = pointsExchangeOrderMapper.selectById(orderId);
|
if (order == null || order.getDeleted() == null || order.getDeleted().intValue() != 0) {
|
return;
|
}
|
List<PointsExchangeOrderItem> items = pointsExchangeOrderItemMapper.selectList(new LambdaQueryWrapper<PointsExchangeOrderItem>()
|
.eq(PointsExchangeOrderItem::getDeleted, 0)
|
.eq(PointsExchangeOrderItem::getOrderId, orderId));
|
boolean allCompleted = !items.isEmpty();
|
for (PointsExchangeOrderItem item : items) {
|
if (!isCompleted(item.getStatus())) {
|
allCompleted = false;
|
break;
|
}
|
}
|
if (allCompleted) {
|
order.setStatus(STATUS_COMPLETED);
|
order.setCompletedAt(completedAt);
|
pointsExchangeOrderMapper.updateById(order);
|
}
|
}
|
|
/**
|
* 删除订单项后刷新汇总订单数量与状态；无明细时同步删除汇总单。
|
*/
|
private void refreshSummaryOrderAfterDelete(Long orderId) {
|
if (orderId == null) {
|
return;
|
}
|
PointsExchangeOrder order = pointsExchangeOrderMapper.selectById(orderId);
|
if (order == null || order.getDeleted() == null || order.getDeleted().intValue() != 0) {
|
return;
|
}
|
List<PointsExchangeOrderItem> items = pointsExchangeOrderItemMapper.selectList(new LambdaQueryWrapper<PointsExchangeOrderItem>()
|
.eq(PointsExchangeOrderItem::getDeleted, 0)
|
.eq(PointsExchangeOrderItem::getOrderId, orderId));
|
if (items == null || items.isEmpty()) {
|
pointsExchangeOrderMapper.deleteById(orderId);
|
return;
|
}
|
int totalPoints = 0;
|
boolean allCompleted = true;
|
for (PointsExchangeOrderItem item : items) {
|
totalPoints += defaultNumber(item.getSettledPoints()).intValue();
|
if (!isCompleted(item.getStatus())) {
|
allCompleted = false;
|
}
|
}
|
order.setItemCount(Integer.valueOf(items.size()));
|
order.setTotalPoints(Integer.valueOf(totalPoints));
|
if (allCompleted) {
|
order.setStatus(STATUS_COMPLETED);
|
}
|
pointsExchangeOrderMapper.updateById(order);
|
}
|
|
/**
|
* 归一化列表筛选状态，仅允许已定义状态值进入 SQL 条件。
|
*/
|
private Integer normalizeStatus(Integer status) {
|
if (status == null) {
|
return null;
|
}
|
if (status.intValue() == STATUS_PENDING || status.intValue() == STATUS_RECEIVING || status.intValue() == STATUS_COMPLETED) {
|
return status;
|
}
|
return null;
|
}
|
|
/**
|
* 判断当前状态是否允许确认取货。
|
*/
|
private boolean isReceivable(Integer status) {
|
return status != null && status.intValue() == STATUS_RECEIVING;
|
}
|
|
/**
|
* 判断当前状态是否允许删除。
|
*/
|
private boolean isDeletable(Integer status) {
|
return status != null && status.intValue() == STATUS_COMPLETED;
|
}
|
|
/**
|
* 判断当前状态是否为已完成。
|
*/
|
private boolean isCompleted(Integer status) {
|
return status != null && status.intValue() == STATUS_COMPLETED;
|
}
|
|
/**
|
* 将订单状态转换为页面展示文案。
|
*/
|
private String resolveStatusText(Integer status) {
|
if (status == null) {
|
return "";
|
}
|
if (status.intValue() == STATUS_PENDING) {
|
return "待发货";
|
}
|
if (status.intValue() == STATUS_RECEIVING) {
|
return "待取货";
|
}
|
if (status.intValue() == STATUS_COMPLETED) {
|
return "兑换完成";
|
}
|
return "";
|
}
|
|
/**
|
* 将可空文本归一化为空字符串。
|
*/
|
private String trimToEmpty(String value) {
|
if (value == null) {
|
return "";
|
}
|
return value.trim();
|
}
|
|
/**
|
* 将可空积分归一化为非空数字。
|
*/
|
private Integer defaultNumber(Integer value) {
|
return Integer.valueOf(value == null ? 0 : value.intValue());
|
}
|
}
|
