package com.tcm.training.admin.app.patient.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.patient.mapper.AppMyPatientQueryMapper;
|
import com.tcm.training.admin.app.patient.row.AppMyPatientExchangeRow;
|
import com.tcm.training.admin.app.patient.row.AppMyPatientExchangeOrderItemRow;
|
import com.tcm.training.admin.app.patient.row.AppMyPatientLiveRow;
|
import com.tcm.training.admin.app.patient.row.AppMyPatientRow;
|
import com.tcm.training.admin.app.patient.vo.AppMyPatientExchangeItemVO;
|
import com.tcm.training.admin.app.patient.vo.AppMyPatientExchangeOrderItemVO;
|
import com.tcm.training.admin.app.patient.vo.AppMyPatientItemVO;
|
import com.tcm.training.admin.app.patient.vo.AppMyPatientLiveItemVO;
|
import com.tcm.training.admin.common.PageResponse;
|
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 org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.time.format.DateTimeParseException;
|
import java.util.ArrayList;
|
import java.util.List;
|
|
/**
|
* APP 我的患者聚合服务。
|
*/
|
@Service
|
public class AppMyPatientService {
|
|
private static final int USER_TYPE_PERSONAL = 0;
|
private static final int USER_TYPE_DOCTOR = 1;
|
private static final int USER_STATUS_ENABLED = 1;
|
private static final String BUSINESS_TYPE_LIVE_WATCH = "LIVE_WATCH";
|
private static final String INCOME_EXPENSE_TYPE_INCOME = "INCOME";
|
private static final int EXCHANGE_STATUS_PENDING = 0;
|
private static final int EXCHANGE_STATUS_SHIPPED = 1;
|
private static final int EXCHANGE_STATUS_COMPLETED = 2;
|
private static final int EXCHANGE_ITEM_STATUS_PENDING = 0;
|
private static final int EXCHANGE_ITEM_STATUS_PICKUP = 1;
|
private static final int EXCHANGE_ITEM_STATUS_COMPLETED = 2;
|
private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
|
|
private final AppAuthSessionService appAuthSessionService;
|
private final UserMapper userMapper;
|
private final AppMyPatientQueryMapper appMyPatientQueryMapper;
|
private final PointsExchangeOrderMapper pointsExchangeOrderMapper;
|
private final PointsExchangeOrderItemMapper pointsExchangeOrderItemMapper;
|
|
/**
|
* 注入 APP 我的患者聚合所需依赖。
|
*/
|
public AppMyPatientService(AppAuthSessionService appAuthSessionService,
|
UserMapper userMapper,
|
AppMyPatientQueryMapper appMyPatientQueryMapper,
|
PointsExchangeOrderMapper pointsExchangeOrderMapper,
|
PointsExchangeOrderItemMapper pointsExchangeOrderItemMapper) {
|
this.appAuthSessionService = appAuthSessionService;
|
this.userMapper = userMapper;
|
this.appMyPatientQueryMapper = appMyPatientQueryMapper;
|
this.pointsExchangeOrderMapper = pointsExchangeOrderMapper;
|
this.pointsExchangeOrderItemMapper = pointsExchangeOrderItemMapper;
|
}
|
|
/**
|
* 分页查询直属患者列表。
|
*/
|
public PageResponse<AppMyPatientItemVO> pagePatients(int page, int pageSize, String keyword) {
|
Long doctorUserId = requireDoctorUserId();
|
IPage<AppMyPatientRow> result = appMyPatientQueryMapper.selectPatientPage(
|
new Page<AppMyPatientRow>(normalizePage(page), normalizePageSize(pageSize)),
|
doctorUserId,
|
trimToNull(keyword)
|
);
|
return PageResponse.of(toPatientItems(result.getRecords()), result.getTotal(), result.getCurrent(), result.getSize());
|
}
|
|
/**
|
* 分页查询直属患者直播积分记录。
|
*/
|
public PageResponse<AppMyPatientLiveItemVO> pageLiveRecords(int page,
|
int pageSize,
|
String keyword,
|
String startDate,
|
String endDate) {
|
Long doctorUserId = requireDoctorUserId();
|
IPage<AppMyPatientLiveRow> result = appMyPatientQueryMapper.selectLiveRecordPage(
|
new Page<AppMyPatientLiveRow>(normalizePage(page), normalizePageSize(pageSize)),
|
doctorUserId,
|
trimToNull(keyword),
|
parseStartDate(startDate),
|
parseEndDate(endDate),
|
BUSINESS_TYPE_LIVE_WATCH,
|
INCOME_EXPENSE_TYPE_INCOME
|
);
|
return PageResponse.of(toLiveItems(result.getRecords()), result.getTotal(), result.getCurrent(), result.getSize());
|
}
|
|
/**
|
* 分页查询直属患者兑换记录。
|
*/
|
public PageResponse<AppMyPatientExchangeItemVO> pageExchangeRecords(int page,
|
int pageSize,
|
String keyword,
|
String status) {
|
Long doctorUserId = requireDoctorUserId();
|
IPage<AppMyPatientExchangeRow> result = appMyPatientQueryMapper.selectExchangeRecordPage(
|
new Page<AppMyPatientExchangeRow>(normalizePage(page), normalizePageSize(pageSize)),
|
doctorUserId,
|
trimToNull(keyword),
|
normalizeExchangeStatus(status)
|
);
|
return PageResponse.of(toExchangeItems(result.getRecords()), result.getTotal(), result.getCurrent(), result.getSize());
|
}
|
|
/**
|
* 分页查询直属患者所属主订单下的子订单列表。
|
*/
|
public PageResponse<AppMyPatientExchangeOrderItemVO> pageExchangeOrderItems(Long orderId, int page, int pageSize) {
|
Long doctorUserId = requireDoctorUserId();
|
requireDoctorOrder(orderId, doctorUserId);
|
IPage<AppMyPatientExchangeOrderItemRow> result = appMyPatientQueryMapper.selectExchangeOrderItemPage(
|
new Page<AppMyPatientExchangeOrderItemRow>(normalizePage(page), normalizePageSize(pageSize)),
|
doctorUserId,
|
orderId
|
);
|
return PageResponse.of(toExchangeOrderItemList(result.getRecords()), result.getTotal(), result.getCurrent(), result.getSize());
|
}
|
|
/**
|
* 确认当前医生可查看的兑换主订单已收货。
|
*/
|
@Transactional
|
public void confirmExchangeOrderReceived(Long orderId) {
|
Long doctorUserId = requireDoctorUserId();
|
PointsExchangeOrder order = requireDoctorOrder(orderId, doctorUserId);
|
if (order.getStatus() == null || order.getStatus().intValue() != EXCHANGE_STATUS_SHIPPED) {
|
throw new IllegalArgumentException("当前订单不允许确认收货");
|
}
|
LocalDateTime now = LocalDateTime.now();
|
order.setStatus(EXCHANGE_STATUS_COMPLETED);
|
order.setCompletedAt(now);
|
pointsExchangeOrderMapper.updateById(order);
|
|
List<PointsExchangeOrderItem> items = pointsExchangeOrderItemMapper.selectList(new LambdaQueryWrapper<PointsExchangeOrderItem>()
|
.eq(PointsExchangeOrderItem::getDeleted, 0)
|
.eq(PointsExchangeOrderItem::getOrderId, orderId)
|
.isNull(PointsExchangeOrderItem::getCancelledAt));
|
for (PointsExchangeOrderItem item : items) {
|
if (item.getStatus() == null || item.getStatus().intValue() == EXCHANGE_ITEM_STATUS_COMPLETED) {
|
continue;
|
}
|
item.setStatus(EXCHANGE_ITEM_STATUS_PICKUP);
|
pointsExchangeOrderItemMapper.updateById(item);
|
}
|
}
|
|
/**
|
* 校验当前登录用户是启用中的医生账号。
|
*/
|
private Long requireDoctorUserId() {
|
Long userId = appAuthSessionService.requireLoginUserId();
|
AppUser user = userMapper.selectById(userId);
|
if (user == null || user.getDeleted() == null || user.getDeleted().intValue() != 0) {
|
throw new IllegalArgumentException("用户不存在");
|
}
|
if (user.getStatus() == null || user.getStatus().intValue() != USER_STATUS_ENABLED) {
|
throw new IllegalArgumentException("用户已禁用");
|
}
|
if (user.getType() == null || user.getType().intValue() != USER_TYPE_DOCTOR) {
|
throw new IllegalArgumentException("当前用户无权查看患者数据");
|
}
|
return userId;
|
}
|
|
/**
|
* 将患者列表查询结果转换为 APP 页面展示结构。
|
*/
|
private List<AppMyPatientItemVO> toPatientItems(List<AppMyPatientRow> rows) {
|
List<AppMyPatientItemVO> items = new ArrayList<AppMyPatientItemVO>();
|
if (rows == null) {
|
return items;
|
}
|
for (AppMyPatientRow row : rows) {
|
AppMyPatientItemVO item = new AppMyPatientItemVO();
|
item.setId(row.getId());
|
item.setNickname(resolveNickname(row.getNickname(), row.getPhone()));
|
item.setAvatar(trimToEmpty(row.getAvatar()));
|
item.setCreatedAt(row.getCreatedAt());
|
items.add(item);
|
}
|
return items;
|
}
|
|
/**
|
* 将直播积分记录转换为 APP 页面展示结构。
|
*/
|
private List<AppMyPatientLiveItemVO> toLiveItems(List<AppMyPatientLiveRow> rows) {
|
List<AppMyPatientLiveItemVO> items = new ArrayList<AppMyPatientLiveItemVO>();
|
if (rows == null) {
|
return items;
|
}
|
for (AppMyPatientLiveRow row : rows) {
|
AppMyPatientLiveItemVO item = new AppMyPatientLiveItemVO();
|
item.setId(row.getId());
|
item.setPatientId(row.getPatientId());
|
item.setNickname(resolveNickname(row.getPatientNickname(), row.getPatientPhone()));
|
item.setAvatar(trimToEmpty(row.getPatientAvatar()));
|
item.setCourseTitle(trimToEmpty(row.getCourseTitle()));
|
item.setOperatedAt(row.getOperatedAt());
|
item.setPoints(normalizeNumber(row.getPoints()));
|
items.add(item);
|
}
|
return items;
|
}
|
|
/**
|
* 将兑换数据查询结果转换为 APP 页面展示结构。
|
*/
|
private List<AppMyPatientExchangeItemVO> toExchangeItems(List<AppMyPatientExchangeRow> rows) {
|
List<AppMyPatientExchangeItemVO> items = new ArrayList<AppMyPatientExchangeItemVO>();
|
if (rows == null) {
|
return items;
|
}
|
for (AppMyPatientExchangeRow row : rows) {
|
AppMyPatientExchangeItemVO item = new AppMyPatientExchangeItemVO();
|
item.setId(row.getId());
|
item.setOrderNo(trimToEmpty(row.getOrderNo()));
|
item.setGiftName(trimToEmpty(row.getGiftName()));
|
item.setGiftCover(trimToEmpty(row.getGiftCover()));
|
item.setNickname(trimToEmpty(row.getNickname()));
|
item.setActivityPeriodText(buildActivityPeriodText(row.getActivityStartAt(), row.getActivityEndAt()));
|
item.setStatus(row.getStatus());
|
item.setStatusText(resolveExchangeStatusText(row.getStatus()));
|
item.setCount(normalizeNumber(row.getCount()));
|
item.setCanConfirmReceived(Boolean.valueOf(Boolean.TRUE.equals(row.getCanConfirmReceived())));
|
items.add(item);
|
}
|
return items;
|
}
|
|
/**
|
* 将主订单下子订单列表转换为 APP 页面展示结构。
|
*/
|
private List<AppMyPatientExchangeOrderItemVO> toExchangeOrderItemList(List<AppMyPatientExchangeOrderItemRow> rows) {
|
List<AppMyPatientExchangeOrderItemVO> items = new ArrayList<AppMyPatientExchangeOrderItemVO>();
|
if (rows == null) {
|
return items;
|
}
|
for (AppMyPatientExchangeOrderItemRow row : rows) {
|
AppMyPatientExchangeOrderItemVO item = new AppMyPatientExchangeOrderItemVO();
|
item.setId(row.getId());
|
item.setOrderId(row.getOrderId());
|
item.setPatientId(row.getPatientId());
|
item.setPatientName(trimToEmpty(row.getPatientName()));
|
item.setPatientPhone(trimToEmpty(row.getPatientPhone()));
|
item.setSettledPoints(normalizeNumber(row.getSettledPoints()));
|
item.setStatus(row.getStatus());
|
item.setStatusText(resolveExchangeItemStatusText(row.getStatus()));
|
item.setCreatedAt(row.getCreatedAt());
|
items.add(item);
|
}
|
return items;
|
}
|
|
/**
|
* 将兑换页状态筛选值转换为数据库状态码。
|
*/
|
private Integer normalizeExchangeStatus(String status) {
|
String normalized = trimToNull(status);
|
if (normalized == null || "all".equalsIgnoreCase(normalized)) {
|
return null;
|
}
|
if ("pending".equalsIgnoreCase(normalized)) {
|
return Integer.valueOf(EXCHANGE_STATUS_PENDING);
|
}
|
if ("received".equalsIgnoreCase(normalized)) {
|
return Integer.valueOf(EXCHANGE_STATUS_SHIPPED);
|
}
|
throw new IllegalArgumentException("兑换状态不合法");
|
}
|
|
/**
|
* 解析列表日期筛选的开始时间。
|
*/
|
private LocalDateTime parseStartDate(String value) {
|
String normalized = trimToNull(value);
|
if (normalized == null) {
|
return null;
|
}
|
try {
|
return LocalDate.parse(normalized, DATE_FORMATTER).atStartOfDay();
|
} catch (DateTimeParseException ex) {
|
throw new IllegalArgumentException("开始日期格式不正确");
|
}
|
}
|
|
/**
|
* 解析列表日期筛选的结束时间，并自动补到当天结束。
|
*/
|
private LocalDateTime parseEndDate(String value) {
|
String normalized = trimToNull(value);
|
if (normalized == null) {
|
return null;
|
}
|
try {
|
return LocalDate.parse(normalized, DATE_FORMATTER).plusDays(1).atStartOfDay().minusSeconds(1);
|
} catch (DateTimeParseException ex) {
|
throw new IllegalArgumentException("结束日期格式不正确");
|
}
|
}
|
|
/**
|
* 拼接兑换活动期数字段展示文案。
|
*/
|
private String buildActivityPeriodText(LocalDateTime activityStartAt, LocalDateTime activityEndAt) {
|
String startText = formatDate(activityStartAt);
|
String endText = formatDate(activityEndAt);
|
if (startText.isEmpty() && endText.isEmpty()) {
|
return "";
|
}
|
return startText + "-" + endText;
|
}
|
|
/**
|
* 将日期时间格式化为页面期数字段所需的 yyyy.MM.dd。
|
*/
|
private String formatDate(LocalDateTime value) {
|
if (value == null) {
|
return "";
|
}
|
return value.toLocalDate().toString().replace('-', '.');
|
}
|
|
/**
|
* 解析兑换记录状态文案。
|
*/
|
private String resolveExchangeStatusText(Integer status) {
|
if (status != null && status.intValue() == EXCHANGE_STATUS_PENDING) {
|
return "待发货";
|
}
|
if (status != null && status.intValue() == EXCHANGE_STATUS_SHIPPED) {
|
return "待收货";
|
}
|
return "已收货";
|
}
|
|
/**
|
* 解析兑换子订单状态文案。
|
*/
|
private String resolveExchangeItemStatusText(Integer status) {
|
if (status != null && status.intValue() == EXCHANGE_ITEM_STATUS_PENDING) {
|
return "待发货";
|
}
|
if (status != null && status.intValue() == EXCHANGE_ITEM_STATUS_PICKUP) {
|
return "待取货";
|
}
|
return "兑换完成";
|
}
|
|
/**
|
* 校验并返回当前医生可操作的兑换主订单。
|
*/
|
private PointsExchangeOrder requireDoctorOrder(Long orderId, Long doctorUserId) {
|
if (orderId == null) {
|
throw new IllegalArgumentException("兑换订单不存在");
|
}
|
PointsExchangeOrder order = pointsExchangeOrderMapper.selectOne(new LambdaQueryWrapper<PointsExchangeOrder>()
|
.eq(PointsExchangeOrder::getId, orderId)
|
.eq(PointsExchangeOrder::getDeleted, 0)
|
.last("limit 1"));
|
if (order == null) {
|
throw new IllegalArgumentException("兑换订单不存在");
|
}
|
Long count = pointsExchangeOrderItemMapper.selectCount(new LambdaQueryWrapper<PointsExchangeOrderItem>()
|
.eq(PointsExchangeOrderItem::getDeleted, 0)
|
.eq(PointsExchangeOrderItem::getOrderId, orderId)
|
.isNull(PointsExchangeOrderItem::getCancelledAt)
|
.inSql(PointsExchangeOrderItem::getAppUserId,
|
"select id from tcm_app_user where deleted = 0 and type = 0 and superior_clinic_user_id = " + doctorUserId));
|
if (count == null || count.longValue() <= 0L) {
|
throw new IllegalArgumentException("兑换订单不存在");
|
}
|
return order;
|
}
|
|
/**
|
* 用昵称优先、手机号兜底的策略统一展示患者名称。
|
*/
|
private String resolveNickname(String nickname, String phone) {
|
String normalizedNickname = trimToEmpty(nickname);
|
if (!normalizedNickname.isEmpty()) {
|
return normalizedNickname;
|
}
|
return trimToEmpty(phone);
|
}
|
|
/**
|
* 将空白文本统一转换为 null。
|
*/
|
private String trimToNull(String value) {
|
String text = trimToEmpty(value);
|
return text.isEmpty() ? null : text;
|
}
|
|
/**
|
* 将可空文本归一化为空字符串。
|
*/
|
private String trimToEmpty(String value) {
|
if (value == null) {
|
return "";
|
}
|
return value.trim();
|
}
|
|
/**
|
* 将分页页码归一化到合法范围。
|
*/
|
private int normalizePage(int page) {
|
return page <= 0 ? 1 : page;
|
}
|
|
/**
|
* 将分页大小归一化到合法范围。
|
*/
|
private int normalizePageSize(int pageSize) {
|
return pageSize <= 0 ? 10 : pageSize;
|
}
|
|
/**
|
* 将积分数值归一化，避免返回空值影响 APP 展示。
|
*/
|
private Integer normalizeNumber(Integer value) {
|
return value == null ? Integer.valueOf(0) : value;
|
}
|
}
|
