~tanyong/bositao_cloud.git

package jnpf.tmsService.impl;
 
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import jnpf.exception.DataException;
import jnpf.permission.UserApi;
import jnpf.permission.entity.UserEntity;
import jnpf.tmsEntity.TmsExamEntity;
import jnpf.tmsEntity.TmsExamItemEntity;
import jnpf.tmsEntity.TmsPaperEntity;
import jnpf.tmsEntity.examscore.TmsExamScoreDetailVO;
import jnpf.tmsEntity.examscore.TmsExamScoreOptionVO;
import jnpf.tmsEntity.examscore.TmsExamScorePaperItemVO;
import jnpf.tmsEntity.examscore.TmsExamScorePaperVO;
import jnpf.tmsEntity.examscore.TmsExamScoreQuery;
import jnpf.tmsEntity.examscore.TmsExamScoreRowVO;
import jnpf.tmsEntity.examscore.TmsExamScoreSummaryVO;
import jnpf.tmsMapper.TmsExamItemMapper;
import jnpf.tmsMapper.TmsExamMapper;
import jnpf.tmsMapper.TmsPaperMapper;
import jnpf.tmsService.TmsExamScoreService;
import jnpf.tmsUtil.TmsExcelExportHelper;
import jnpf.tmsEntity.enums.TmsPassFlag;
import jnpf.tmsEntity.enums.TmsExamStatus;
import jnpf.tmsEntity.enums.TmsOpenClosedInvalid;
import jnpf.util.DateUtil;
import jnpf.util.StringUtil;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
 
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
 
@Service
@RequiredArgsConstructor
public class TmsExamScoreServiceImpl implements TmsExamScoreService {
    private static final String FMT = "yyyy-MM-dd HH:mm:ss";
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
 
    private final TmsExamMapper examMapper;
    private final TmsExamItemMapper examItemMapper;
    private final TmsPaperMapper paperMapper;
    private final UserApi userApi;
    /**
     * 考试成绩：条件分页查询列表
     */
    @Override
    public List<TmsExamScoreSummaryVO> getList(TmsExamScoreQuery query) {
        List<TmsExamEntity> exams = loadSubmittedExams();
        Map<String, List<TmsExamEntity>> byPaper = groupByPaper(exams);
        Map<String, TmsPaperEntity> papers = loadPapers(new ArrayList<>(byPaper.keySet()));
 
        List<TmsExamScoreSummaryVO> all = new ArrayList<>();
        for (Map.Entry<String, List<TmsExamEntity>> entry : byPaper.entrySet()) {
            TmsPaperEntity paper = papers.get(entry.getKey());
            all.add(toSummary(entry.getKey(), paper, entry.getValue()));
        }
        all.sort(Comparator.comparing(TmsExamScoreSummaryVO::getPaperName, Comparator.nullsLast(String::compareTo)).reversed());
 
        String keyword = trim(query.getKeyword());
        String taskNo = trim(query.getTaskNo());
        if (StringUtil.isNotEmpty(keyword)) {
            String kw = keyword.toLowerCase();
            all = all.stream()
                    .filter(x -> contains(x.getTaskSubject(), kw)
                            || contains(x.getPaperName(), kw)
                            || contains(x.getTaskNo(), kw))
                    .collect(Collectors.toList());
        }
        if (StringUtil.isNotEmpty(taskNo)) {
            String tn = taskNo.toLowerCase();
            all = all.stream().filter(x -> contains(x.getTaskNo(), tn)).collect(Collectors.toList());
        }
 
        long current = query.getCurrentPage() > 0 ? query.getCurrentPage() : 1;
        long size = query.getPageSize() > 0 ? query.getPageSize() : 20;
        int from = (int) ((current - 1) * size);
        int to = Math.min(from + (int) size, all.size());
        List<TmsExamScoreSummaryVO> page = from >= all.size() ? new ArrayList<>() : new ArrayList<>(all.subList(from, to));
        query.setData(page, all.size());
        return page;
    }
    /**
     * 查询详情
     */
    @Override
    public TmsExamScoreDetailVO getDetail(String summaryId) {
        if (StringUtil.isEmpty(summaryId)) {
            throw new DataException("成绩汇总不存在");
        }
        List<TmsExamEntity> exams = loadSubmittedByPaper(summaryId);
        if (exams.isEmpty()) {
            throw new DataException("成绩汇总不存在");
        }
        TmsPaperEntity paper = paperMapper.selectById(summaryId);
        TmsExamScoreSummaryVO summary = toSummary(summaryId, paper, exams);
        Map<String, String> names = loadUserNames(exams.stream().map(TmsExamEntity::getUserId).collect(Collectors.toList()));
 
        List<TmsExamScoreRowVO> rows = new ArrayList<>();
        for (TmsExamEntity exam : exams) {
            TmsExamScoreRowVO row = new TmsExamScoreRowVO();
            row.setId(exam.getId());
            row.setSummaryId(summaryId);
            row.setTaskSubject(summary.getTaskSubject());
            row.setTaskNo(summary.getTaskNo());
            row.setUserId(exam.getUserId());
            row.setUserName(names.getOrDefault(exam.getUserId(), exam.getUserId()));
            row.setExamStart(fmt(exam.getStartTime()));
            row.setExamEnd(fmt(exam.getSubmitTime()));
            row.setScore(exam.getTotalScore());
            row.setPassScore(exam.getPassScore() != null ? exam.getPassScore() : summary.getPassScore());
            row.setPassFlag(exam.getPassFlag());
            rows.add(row);
        }
        rows.sort(Comparator.comparing(TmsExamScoreRowVO::getExamEnd, Comparator.nullsLast(String::compareTo)).reversed());
 
        TmsExamScoreDetailVO detail = new TmsExamScoreDetailVO();
        BeanUtils.copyProperties(summary, detail);
        detail.setRows(rows);
        return detail;
    }
    /**
     * 成绩侧试卷查看
     */
    @Override
    public TmsExamScorePaperVO getPaperView(String examId) {
        TmsExamEntity exam = examMapper.selectById(examId);
        if (exam == null || !TmsExamStatus.SUBMITTED.equalsCode(exam.getExamStatus())) {
            throw new DataException("答卷不存在或尚未交卷");
        }
        TmsPaperEntity paper = paperMapper.selectById(exam.getPaperId());
        Map<String, String> names = loadUserNames(Collections.singletonList(exam.getUserId()));
 
        LambdaQueryWrapper<TmsExamItemEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsExamItemEntity::getForeignId, examId);
        qw.orderByAsc(TmsExamItemEntity::getSortNo);
        List<TmsExamItemEntity> items = examItemMapper.selectList(qw);
 
        BigDecimal paperTotal = BigDecimal.ZERO;
        List<TmsExamScorePaperItemVO> itemVos = new ArrayList<>();
        for (TmsExamItemEntity item : items) {
            paperTotal = paperTotal.add(nvl(item.getScore()));
            TmsExamScorePaperItemVO vo = new TmsExamScorePaperItemVO();
            vo.setId(item.getId());
            vo.setQuestionType(item.getQuestionType());
            vo.setStem(item.getStem());
            vo.setOptions(toOptions(item.getOptionsJson()));
            vo.setCorrectAnswer(item.getCorrectAnswer());
            vo.setUserAnswer(item.getUserAnswer());
            vo.setAnalysis(item.getAnalysis());
            vo.setScore(item.getScore());
            vo.setGotScore(item.getGotScore());
            vo.setIsSubjective(item.getIsSubjective());
            if ("1".equals(item.getIsSubjective())) {
                vo.setIsCorrect(null);
            } else if (item.getScore() != null && item.getScore().compareTo(BigDecimal.ZERO) > 0) {
                vo.setIsCorrect(nvl(item.getGotScore()).compareTo(item.getScore()) >= 0);
            } else {
                vo.setIsCorrect(Objects.equals(normalize(item.getCorrectAnswer()), normalize(item.getUserAnswer())));
            }
            itemVos.add(vo);
        }
 
        TmsExamScorePaperVO vo = new TmsExamScorePaperVO();
        vo.setExamId(exam.getId());
        vo.setSummaryId(exam.getPaperId());
        vo.setTaskSubject(paper != null ? paper.getPaperName() : exam.getPaperName());
        vo.setTaskNo(paper != null && StringUtil.isNotEmpty(paper.getPaperNo()) ? paper.getPaperNo() : exam.getPaperId());
        vo.setPaperName(exam.getPaperName());
        vo.setUserId(exam.getUserId());
        vo.setUserName(names.getOrDefault(exam.getUserId(), exam.getUserId()));
        vo.setExamStart(fmt(exam.getStartTime()));
        vo.setExamEnd(fmt(exam.getSubmitTime()));
        vo.setScore(exam.getTotalScore());
        vo.setPassScore(exam.getPassScore());
        vo.setTotalScore(paper != null && paper.getTotalScore() != null ? paper.getTotalScore() : paperTotal);
        vo.setPassFlag(exam.getPassFlag());
        vo.setItems(itemVos);
        return vo;
    }
    /**
     * 导出成绩行数据
     */
    @Override
    public List<TmsExamScoreRowVO> exportRows(List<String> summaryIds) {
        if (summaryIds == null || summaryIds.isEmpty()) {
            throw new DataException("请选择要导出的考试");
        }
        List<TmsExamScoreRowVO> rows = new ArrayList<>();
        for (String id : summaryIds) {
            if (StringUtil.isEmpty(id)) {
                continue;
            }
            List<TmsExamEntity> exams = loadSubmittedByPaper(id);
            if (exams.isEmpty()) {
                continue;
            }
            TmsExamScoreDetailVO detail = getDetail(id);
            if (detail.getRows() != null) {
                rows.addAll(detail.getRows());
            }
        }
        if (rows.isEmpty()) {
            throw new DataException("所选试卷暂无已交卷成绩");
        }
        return rows;
    }
    /**
     * 导出 Excel
     */
    @Override
    public void exportExcel(List<String> summaryIds, HttpServletResponse response) {
        List<TmsExamScoreRowVO> rows = exportRows(summaryIds);
        List<String> headers = Arrays.asList(
                "试卷名称", "试卷编号", "考生", "考试开始时间", "考试结束时间", "成绩", "及格分", "是否合格");
        List<Integer> widths = Arrays.asList(180, 140, 100, 140, 140, 60, 60, 70);
        List<List<String>> data = new ArrayList<>(rows.size());
        for (TmsExamScoreRowVO row : rows) {
            data.add(Arrays.asList(
                    nvl(row.getTaskSubject()),
                    nvl(row.getTaskNo()),
                    StringUtil.isNotEmpty(row.getUserName()) ? row.getUserName() : nvl(row.getUserId()),
                    nvl(row.getExamStart()),
                    nvl(row.getExamEnd()),
                    decimalText(row.getScore()),
                    decimalText(row.getPassScore()),
                    passText(row.getPassFlag())));
        }
        String subject = rows.stream()
                .map(TmsExamScoreRowVO::getTaskSubject)
                .filter(StringUtil::isNotEmpty)
                .distinct()
                .findFirst()
                .orElse("考试成绩");
        try {
            TmsExcelExportHelper.writeSpreadsheet(response, "考试成绩_" + subject, "考试成绩", headers, widths, data);
        } catch (IOException e) {
            throw new DataException("导出考试成绩失败");
        }
    }
 
    /**
     * 空值兜底
     */
    private static String nvl(String v) {
        return v == null ? "" : v;
    }
 
    /**
     * 小数展示文本
     */
    private static String decimalText(BigDecimal v) {
        return v == null ? "" : v.stripTrailingZeros().toPlainString();
    }
 
    /**
     * 合格标识展示文本
     */
    private static String passText(String passFlag) {
        return TmsPassFlag.label(passFlag);
    }
 
    /**
     * 汇总为成绩摘要 VO
     */
    private TmsExamScoreSummaryVO toSummary(String paperId, TmsPaperEntity paper, List<TmsExamEntity> exams) {
        TmsExamScoreSummaryVO vo = new TmsExamScoreSummaryVO();
        vo.setId(paperId);
        vo.setPaperId(paperId);
        String paperName = paper != null ? paper.getPaperName() : (exams.isEmpty() ? paperId : exams.get(0).getPaperName());
        vo.setPaperName(paperName);
        vo.setTaskSubject(paperName);
        String paperNo = paper != null && StringUtil.isNotEmpty(paper.getPaperNo()) ? paper.getPaperNo() : paperId;
        vo.setTaskNo(paperNo);
        vo.setPaperInvalid(paper != null && TmsOpenClosedInvalid.INVALID.equalsCode(paper.getBizStatus()));
 
        BigDecimal passScore = paper != null && paper.getPassScore() != null
                ? paper.getPassScore()
                : exams.stream().map(TmsExamEntity::getPassScore).filter(Objects::nonNull).findFirst().orElse(BigDecimal.ZERO);
        BigDecimal totalScore = paper != null && paper.getTotalScore() != null
                ? paper.getTotalScore()
                : BigDecimal.ZERO;
        vo.setPassScore(passScore);
        vo.setTotalScore(totalScore);
 
        int fail = 0;
        BigDecimal max = null;
        BigDecimal min = null;
        BigDecimal sum = BigDecimal.ZERO;
        int scored = 0;
        for (TmsExamEntity exam : exams) {
            if (TmsPassFlag.isFail(exam.getPassFlag())) {
                fail++;
            }
            BigDecimal score = exam.getTotalScore();
            if (score == null) {
                continue;
            }
            scored++;
            sum = sum.add(score);
            if (max == null || score.compareTo(max) > 0) {
                max = score;
            }
            if (min == null || score.compareTo(min) < 0) {
                min = score;
            }
        }
        vo.setParticipantCount(exams.size());
        vo.setFailCount(fail);
        vo.setMaxScore(max == null ? BigDecimal.ZERO : max);
        vo.setMinScore(min == null ? BigDecimal.ZERO : min);
        vo.setAvgScore(scored == 0
                ? BigDecimal.ZERO
                : sum.divide(BigDecimal.valueOf(scored), 1, RoundingMode.HALF_UP));
        return vo;
    }
 
    /**
     * 加载全部已交答卷
     */
    private List<TmsExamEntity> loadSubmittedExams() {
        LambdaQueryWrapper<TmsExamEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsExamEntity::getExamStatus, TmsExamStatus.SUBMITTED.getCode());
        qw.isNotNull(TmsExamEntity::getPaperId);
        qw.orderByDesc(TmsExamEntity::getSubmitTime);
        return examMapper.selectList(qw);
    }
 
    /**
     * 按试卷加载已交答卷
     */
    private List<TmsExamEntity> loadSubmittedByPaper(String paperId) {
        LambdaQueryWrapper<TmsExamEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsExamEntity::getExamStatus, TmsExamStatus.SUBMITTED.getCode());
        qw.eq(TmsExamEntity::getPaperId, paperId);
        qw.orderByDesc(TmsExamEntity::getSubmitTime);
        return examMapper.selectList(qw);
    }
 
    /**
     * 按试卷分组答卷
     */
    private Map<String, List<TmsExamEntity>> groupByPaper(List<TmsExamEntity> exams) {
        Map<String, List<TmsExamEntity>> map = new LinkedHashMap<>();
        for (TmsExamEntity exam : exams) {
            if (StringUtil.isEmpty(exam.getPaperId())) {
                continue;
            }
            map.computeIfAbsent(exam.getPaperId(), k -> new ArrayList<>()).add(exam);
        }
        return map;
    }
 
    /**
     * 批量加载试卷
     */
    private Map<String, TmsPaperEntity> loadPapers(List<String> paperIds) {
        if (paperIds == null || paperIds.isEmpty()) {
            return Collections.emptyMap();
        }
        Map<String, TmsPaperEntity> map = new HashMap<>();
        for (TmsPaperEntity paper : paperMapper.selectBatchIds(paperIds)) {
            map.put(paper.getId(), paper);
        }
        return map;
    }
 
    /**
     * 批量加载用户姓名
     */
    private Map<String, String> loadUserNames(List<String> userIds) {
        if (userIds == null || userIds.isEmpty()) {
            return Collections.emptyMap();
        }
        List<String> ids = userIds.stream().filter(StringUtil::isNotEmpty).distinct().collect(Collectors.toList());
        if (ids.isEmpty()) {
            return Collections.emptyMap();
        }
        try {
            List<UserEntity> users = userApi.getUserName(ids);
            if (users == null || users.isEmpty()) {
                return Collections.emptyMap();
            }
            return users.stream()
                    .filter(Objects::nonNull)
                    .collect(Collectors.toMap(UserEntity::getId, UserEntity::getRealName, (a, b) -> a));
        } catch (Exception ex) {
            return Collections.emptyMap();
        }
    }
 
    /**
     * 选项 JSON 转 VO
     */
    private List<TmsExamScoreOptionVO> toOptions(String json) {
        if (StringUtil.isEmpty(json)) {
            return Collections.emptyList();
        }
        try {
            List<StoredOption> stored = OBJECT_MAPPER.readValue(json, new TypeReference<List<StoredOption>>() {
            });
            List<TmsExamScoreOptionVO> list = new ArrayList<>();
            for (StoredOption opt : stored) {
                TmsExamScoreOptionVO vo = new TmsExamScoreOptionVO();
                vo.setOptionLabel(opt.getOptionLabel());
                vo.setOptionContent(opt.getOptionContent());
                list.add(vo);
            }
            return list;
        } catch (Exception e) {
            return Collections.emptyList();
        }
    }
 
    /**
     * 文本规范化
     */
    private String normalize(String text) {
        if (StringUtil.isEmpty(text)) {
            return "";
        }
        return text.trim();
    }
 
    /**
     * 去空白
     */
    private String trim(String text) {
        if (StringUtil.isEmpty(text) || "null".equalsIgnoreCase(text)) {
            return null;
        }
        return text.trim();
    }
 
    /**
     * 包含关键字
     */
    private boolean contains(String text, String kw) {
        return text != null && text.toLowerCase().contains(kw);
    }
 
    /**
     * 格式化日期
     */
    private String fmt(java.util.Date date) {
        return date == null ? null : DateUtil.dateToString(date, FMT);
    }
 
    /**
     * 空值兜底
     */
    private BigDecimal nvl(BigDecimal value) {
        return value == null ? BigDecimal.ZERO : value;
    }
 
    @Data
    @JsonIgnoreProperties(ignoreUnknown = true)
    private static class StoredOption {
        private String optionLabel;
        private String optionContent;
        private String isCorrect;
    }
}