package com.guo.learningprogresstracker.service.impl;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.guo.learningprogresstracker.dto.ReviewFeedItem;
import com.guo.learningprogresstracker.dto.ReviewSortPreference;
import com.guo.learningprogresstracker.dto.ReviewSummary;
import com.guo.learningprogresstracker.dto.ReviewTaskStats;
import com.guo.learningprogresstracker.dto.StudyReportDetail;
import com.guo.learningprogresstracker.dto.request.ReviewFeedbackRequest;
import com.guo.learningprogresstracker.dto.request.UpdateStudyReportRequest;
import com.guo.learningprogresstracker.entity.StudyReportFragmentsEntity;
import com.guo.learningprogresstracker.entity.StudyReportsEntity;
import com.guo.learningprogresstracker.entity.StudySessionsEntity;
import com.guo.learningprogresstracker.entity.TaskEntity;
import com.guo.learningprogresstracker.entity.UserReviewPreferencesEntity;
import com.guo.learningprogresstracker.enums.FragmentContextTypeEnum;
import com.guo.learningprogresstracker.enums.ReviewSortPresetEnum;
import com.guo.learningprogresstracker.exception.NotFindEntitiesException;
import com.guo.learningprogresstracker.mapper.StudyReportFragmentsMapper;
import com.guo.learningprogresstracker.mapper.StudyReportsMapper;
import com.guo.learningprogresstracker.mapper.StudySessionsMapper;
import com.guo.learningprogresstracker.mapper.TasksMapper;
import com.guo.learningprogresstracker.mapper.UserReviewPreferencesMapper;
import com.guo.learningprogresstracker.service.ReviewService;
import com.guo.learningprogresstracker.service.StudyExpectationsService;
import com.guo.learningprogresstracker.service.StudyReportFragmentsService;
import com.guo.learningprogresstracker.service.recall.RecallPrivacyService;
import com.guo.learningprogresstracker.service.review.ReviewFeedService;
import com.guo.learningprogresstracker.service.review.ReviewStatsService;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
/**
* 复习模块 Service 实现
*
*
本类保留报告与碎片自身的读写(详情、修改、删除、反馈、接触、排序偏好),
* feed 的组织交给 {@link ReviewFeedService},统计口径交给 {@link ReviewStatsService}。
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class ReviewServiceImpl implements ReviewService {
/** 待归类分组在内部的键名(不会作为任务编号出现在响应里,响应里 taskNum 为 null) */
private static final String PENDING_OWNERSHIP_KEY = "__PENDING__";
private final StudyReportsMapper studyReportsMapper;
private final StudyReportFragmentsMapper studyReportFragmentsMapper;
private final StudyReportFragmentsService studyReportFragmentsService;
private final StudySessionsMapper studySessionsMapper;
private final TasksMapper tasksMapper;
private final StudyExpectationsService studyExpectationsService;
private final UserReviewPreferencesMapper userReviewPreferencesMapper;
private final RecallPrivacyService recallPrivacyService;
private final ReviewFeedService reviewFeedService;
private final ReviewStatsService reviewStatsService;
@Override
public List getReviewFeed(int limit, String mode) {
return reviewFeedService.getReviewFeed(limit, mode);
}
@Override
public ReviewSummary summary() {
return reviewStatsService.summary();
}
@Override
public Page getReviewTaskStats(int pageNum, int pageSize, String markerName) {
return reviewStatsService.getReviewTaskStats(pageNum, pageSize, markerName);
}
@Override
public List getReviewTaskStats(Collection taskNums) {
return reviewStatsService.getReviewTaskStats(taskNums);
}
@Override
public ReviewTaskStats getReviewTaskStats(String taskNum) {
return reviewStatsService.getReviewTaskStats(taskNum);
}
@Override
public List getTaskReview(String taskNum) {
return reviewFeedService.getTaskReview(taskNum);
}
@Override
public StudyReportsEntity getReportDetail(int id) throws NotFindEntitiesException {
return Optional.ofNullable(studyReportsMapper.selectById(id)).orElseThrow(() -> {
log.warn("学习报告[{}]不存在", id);
return new NotFindEntitiesException("这份学习报告不存在或已被删除");
});
}
@Override
public StudyReportDetail getReportDetailStructured(int id) throws NotFindEntitiesException {
StudyReportsEntity report = getReportDetail(id);
StudyReportDetail detail = StudyReportDetail.of(report);
// 报告所属会话与任务:用于判断哪些碎片是「旁支」(归属不等于本会话的任务)
StudySessionsEntity session = StringUtils.hasText(report.getSessionNum())
? studySessionsMapper.selectOne(Wrappers.lambdaQuery()
.eq(StudySessionsEntity::getSessionNum, report.getSessionNum())
.last("LIMIT 1"))
: null;
if (session != null) {
detail.setSessionTaskNum(session.getTaskNum());
detail.setSessionTaskName(loadTaskName(session.getTaskNum()));
}
Optional.ofNullable(studyExpectationsService.getBySessionNum(report.getSessionNum()))
.ifPresent(e -> detail.setSessionExpectation(e.getDescription()));
// 第四部分不落库:按会话产生的碎片 + 它们的**当前**内容归属实时聚合
List fragments =
studyReportFragmentsMapper.selectList(Wrappers.lambdaQuery()
.eq(StudyReportFragmentsEntity::getContextType, FragmentContextTypeEnum.SESSION.name())
.eq(StudyReportFragmentsEntity::getContextNum, report.getSessionNum())
.orderByAsc(StudyReportFragmentsEntity::getCreatedTime));
Map groups = new LinkedHashMap<>();
for (StudyReportFragmentsEntity fragment : fragments) {
String owner = fragment.getOwnerTaskNum();
String key = StringUtils.hasText(owner) ? owner : PENDING_OWNERSHIP_KEY;
StudyReportDetail.FragmentGroup group = groups.computeIfAbsent(key, k -> {
StudyReportDetail.FragmentGroup created = new StudyReportDetail.FragmentGroup();
created.setTaskNum(StringUtils.hasText(owner) ? owner : null);
created.setTaskName(StringUtils.hasText(owner) ? loadTaskName(owner) : null);
// 旁支 = 归属不是本会话所属任务的内容
created.setBranch(!StringUtils.hasText(owner) || !Objects.equals(owner, detail.getSessionTaskNum()));
return created;
});
group.getFragments().add(fragment);
}
detail.setFragmentGroups(new ArrayList<>(groups.values()));
return detail;
}
@Override
public void updateReport(int id, UpdateStudyReportRequest request) throws NotFindEntitiesException {
StudyReportsEntity existing = getReportDetail(id);
studyReportsMapper.update(
new StudyReportsEntity(),
Wrappers.lambdaUpdate()
.eq(StudyReportsEntity::getId, existing.getId())
.set(
request.getSessionSummary() != null,
StudyReportsEntity::getSessionSummary,
request.getSessionSummary())
.set(
request.getExpectationVerdict() != null,
StudyReportsEntity::getExpectationVerdict,
request.getExpectationVerdict())
.set(
request.getFreeSummary() != null,
StudyReportsEntity::getFreeSummary,
request.getFreeSummary()));
// 报告-02:报告内容作为导图参考上下文,改动后相关导图置「待更新」
studyReportFragmentsService.markMindMapsStaleForSession(existing.getSessionNum());
log.info("学习报告[{}]已修改", id);
}
@Override
@org.springframework.transaction.annotation.Transactional
public void deleteReport(int id) throws NotFindEntitiesException {
StudyReportsEntity existing = getReportDetail(id);
recallPrivacyService.sourceDeleted("REPORT", Integer.toString(id));
// 软删除。刻意不连带删除同一会话的知识碎片:碎片是独立原料,可能已被归类到其他任务
studyReportsMapper.deleteById(existing.getId());
// 报告-02:报告不再作为参考上下文,相关导图置「待更新」
studyReportFragmentsService.markMindMapsStaleForSession(existing.getSessionNum());
log.info("学习报告[{}]已删除(知识碎片保留)", id);
}
/** 取任务名,任务不存在时返回 null(任务被删除后碎片会进入待归类,报告仍可能引用旧任务号) */
@Override
public ReviewFeedbackRequest submitFeedback(Integer fragmentId, ReviewFeedbackRequest request)
throws NotFindEntitiesException {
StudyReportFragmentsEntity existing = getFragmentForUpdate(fragmentId);
boolean feedbackChanged = request.getMastered() != null || request.getRevisit() != null;
if (feedbackChanged) {
// 反馈动作同时算一次接触:用户刚刚看过这条内容
studyReportFragmentsMapper.update(
new StudyReportFragmentsEntity(),
Wrappers.lambdaUpdate()
.eq(StudyReportFragmentsEntity::getId, fragmentId)
.set(
request.getMastered() != null,
StudyReportFragmentsEntity::getMastered,
request.getMastered())
.set(
request.getRevisit() != null,
StudyReportFragmentsEntity::getRevisit,
request.getRevisit())
.set(StudyReportFragmentsEntity::getLastReviewedTime, LocalDateTime.now()));
}
ReviewFeedbackRequest result = new ReviewFeedbackRequest();
result.setMastered(request.getMastered() != null ? request.getMastered() : existing.getMastered());
result.setRevisit(request.getRevisit() != null ? request.getRevisit() : existing.getRevisit());
return result;
}
@Override
public void touchFragment(Integer fragmentId) throws NotFindEntitiesException {
getFragmentForUpdate(fragmentId);
studyReportFragmentsMapper.update(
new StudyReportFragmentsEntity(),
Wrappers.lambdaUpdate()
.eq(StudyReportFragmentsEntity::getId, fragmentId)
.set(StudyReportFragmentsEntity::getLastReviewedTime, LocalDateTime.now()));
}
/** 反馈与接触都要先确认碎片存在(属于当前用户由租户拦截器保证) */
private StudyReportFragmentsEntity getFragmentForUpdate(Integer fragmentId) throws NotFindEntitiesException {
StudyReportFragmentsEntity existing = studyReportFragmentsMapper.selectById(fragmentId);
if (existing == null) {
log.warn("未能找到知识碎片id[{}]", fragmentId);
throw new NotFindEntitiesException("这条知识碎片不存在或已被删除");
}
return existing;
}
@Override
public ReviewSortPreference getSortPreference() {
return toPreference(reviewFeedService.loadSortPreset());
}
@Override
public ReviewSortPreference saveSortPreference(String preset) {
ReviewSortPresetEnum parsed = ReviewSortPresetEnum.parse(preset);
UserReviewPreferencesEntity existing = userReviewPreferencesMapper.selectOne(
Wrappers.lambdaQuery().last("LIMIT 1"));
if (existing == null) {
UserReviewPreferencesEntity created = new UserReviewPreferencesEntity();
created.setSortPreset(parsed.name());
userReviewPreferencesMapper.insert(created);
} else {
userReviewPreferencesMapper.update(
new UserReviewPreferencesEntity(),
Wrappers.lambdaUpdate()
.eq(UserReviewPreferencesEntity::getId, existing.getId())
.set(UserReviewPreferencesEntity::getSortPreset, parsed.name()));
}
log.info("复习排序偏好已更新为[{}]", parsed);
return toPreference(parsed);
}
private static ReviewSortPreference toPreference(ReviewSortPresetEnum preset) {
return new ReviewSortPreference(preset.name(), preset.getDescription());
}
private String loadTaskName(String taskNum) {
if (!StringUtils.hasText(taskNum)) {
return null;
}
return tasksMapper
.selectOne(Wrappers.lambdaQuery()
.eq(TaskEntity::getTaskNum, taskNum)
.select(TaskEntity::getTaskName)
.last("LIMIT 1"))
.getTaskName();
}
@Override
public StudyReportFragmentsEntity getFragmentDetail(int id) throws NotFindEntitiesException {
return Optional.ofNullable(studyReportFragmentsMapper.selectById(id)).orElseThrow(() -> {
log.warn("学习残片[{}]不存在", id);
return new NotFindEntitiesException("这条学习残片不存在或已被删除");
});
}
private void ensureTaskExists(String taskNum) throws NotFindEntitiesException {
if (!StringUtils.hasText(taskNum)
|| !tasksMapper.exists(Wrappers.lambdaQuery().eq(TaskEntity::getTaskNum, taskNum))) {
log.warn("任务[{}]不存在", taskNum);
throw new NotFindEntitiesException("这个任务不存在或已被删除");
}
}
}