Commit 61470e0e authored by wujipeng's avatar wujipeng
Browse files

成绩导出优化

parent df776d52
package com.platform.business.model.vo;
import lombok.Data;
import java.util.Date;
/**
* 管理员成绩汇总表使用的考试元数据。
*
* <p>该对象只服务于 Excel 导出,不作为查询接口的响应模型,避免为了模板字段而改变
* 现有成绩分页和详情接口的 JSON 结构。</p>
*/
@Data
public class ScoreAdminExportExamVO {
private Integer examId;
private Integer classId;
private String examName;
private String examType;
private String className;
private String occupation;
private Integer trainingYear;
private String levelName;
private String location;
private Date examTime;
private Integer duration;
private Integer actualCount;
private Boolean published;
}
package com.platform.business.model.vo;
import lombok.Data;
import java.math.BigDecimal;
/** 管理员成绩汇总表中的单个学员实训项目成绩。 */
@Data
public class ScoreAdminExportPracticeItemVO {
private String studentId;
private String code;
private String title;
private BigDecimal score;
}
......@@ -99,7 +99,7 @@ public class ScoreAdminController extends BaseController {
return Result.data(scoreAdminService.questionStatistics(examId));
}
@ApiOperation("导出单场考试正式成绩")
@ApiOperation("按人社局模板导出所选考试及配对考试成绩")
@GetMapping("/exams/{examId}/export")
public void exportExam(@PathVariable Integer examId, HttpServletRequest request,
HttpServletResponse response) {
......
......@@ -4,6 +4,8 @@ import com.platform.business.model.dto.ScoreAdminExamQueryDTO;
import com.platform.business.model.dto.ScoreAdminStudentQueryDTO;
import com.platform.business.model.entity.FzGradesEntity;
import com.platform.business.model.vo.ExamReviewQuestionVO;
import com.platform.business.model.vo.ScoreAdminExportExamVO;
import com.platform.business.model.vo.ScoreAdminExportPracticeItemVO;
import com.platform.business.model.vo.ScoreAdminExamVO;
import com.platform.business.model.vo.ScoreAdminQuestionStatisticsVO;
import com.platform.business.model.vo.ScoreAdminStudentDetailVO;
......@@ -39,4 +41,18 @@ public interface ScoreAdminMapper {
List<ScoreAdminStudentVO> queryPublishedStudents(@Param("examId") Integer examId);
List<ScoreAdminExamVO> queryClassExams(@Param("classId") Integer classId);
/** 查询单场汇总表所需元数据,不扩展现有对外成绩响应对象。 */
ScoreAdminExportExamVO findExportExam(@Param("examId") Integer examId);
/** 为所选考试匹配同班级另一类型中最近一场已结束、已发布考试。 */
ScoreAdminExportExamVO findLatestPublishedExportExam(
@Param("classId") Integer classId, @Param("examType") String examType);
/** 导出使用完整应考名单,缺考学员也必须保留在人社局汇总表中。 */
List<ScoreAdminStudentVO> queryExportCandidates(@Param("examId") Integer examId);
/** 查询实训考试各学员每个项目的最新正式成绩。 */
List<ScoreAdminExportPracticeItemVO> queryExportPracticeItems(
@Param("examId") Integer examId);
}
......@@ -5,6 +5,8 @@ import com.platform.business.mapper.ScoreAdminMapper;
import com.platform.business.model.dto.ScoreAdminExamQueryDTO;
import com.platform.business.model.dto.ScoreAdminStudentQueryDTO;
import com.platform.business.model.vo.ClassAdminTreeVO;
import com.platform.business.model.vo.ScoreAdminExportExamVO;
import com.platform.business.model.vo.ScoreAdminExportPracticeItemVO;
import com.platform.business.model.vo.ScoreAdminExamVO;
import com.platform.business.model.vo.ScoreAdminQuestionStatisticsVO;
import com.platform.business.model.vo.ScoreAdminStudentDetailVO;
......@@ -22,7 +24,9 @@ import org.apache.poi.ss.usermodel.IndexedColors;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.VerticalAlignment;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.core.io.ClassPathResource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
......@@ -30,18 +34,24 @@ import javax.annotation.Resource;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigDecimal;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.TimeZone;
/**
* 管理员端学员成绩管理实现。
......@@ -62,6 +72,13 @@ public class ScoreAdminServiceImpl implements ScoreAdminService {
private static final Set<String> SCORE_BANDS = new HashSet<>(
Arrays.asList(BAND_ALL, "EXCELLENT", "GOOD", "PASS", "FAIL"));
private static final String EXPORT_TEMPLATE_PATH = "templates/score-summary-template.xls";
private static final int EXPORT_STUDENTS_PER_SHEET = 27;
private static final int EXPORT_PROJECT_LIMIT = 5;
private static final int EXPORT_FIRST_STUDENT_ROW = 6;
private static final int EXPORT_SECOND_SECTION_ROW = 24;
private static final int EXPORT_FIRST_SECTION_SIZE = 16;
@Resource
private ScoreAdminMapper scoreAdminMapper;
......@@ -153,19 +170,376 @@ public class ScoreAdminServiceImpl implements ScoreAdminService {
@Override
@Transactional(readOnly = true)
public void exportExam(Integer examId, HttpServletResponse response) {
ScoreAdminExamVO exam = requirePublishedExam(examId);
List<ScoreAdminStudentVO> students = scoreAdminMapper.queryPublishedStudents(examId);
if (students == null || students.isEmpty()) {
throw new BusinessException("本场考试暂无可导出的正式成绩");
ScoreAdminExportExamVO selectedExam = requirePublishedExportExam(examId);
ScoreAdminExportExamVO pairedExam = scoreAdminMapper.findLatestPublishedExportExam(
selectedExam.getClassId(), oppositeExamType(selectedExam.getExamType()));
ScoreAdminExportExamVO theoryExam = isTheory(selectedExam.getExamType())
? selectedExam : pairedExam;
ScoreAdminExportExamVO practiceExam = isPractice(selectedExam.getExamType())
? selectedExam : pairedExam;
List<ScoreAdminStudentVO> selectedCandidates = exportCandidates(selectedExam);
List<ScoreAdminStudentVO> pairedCandidates = exportCandidates(pairedExam);
List<ExportStudent> students = mergeExportStudents(
selectedCandidates, isTheory(selectedExam.getExamType()),
pairedCandidates, isTheory(pairedExam == null ? null : pairedExam.getExamType()));
if (students.isEmpty()) {
throw new BusinessException("本场考试及配对考试均无应考学员,不能导出成绩汇总表");
}
List<ScoreAdminExportPracticeItemVO> practiceItems = practiceExam == null
? Collections.emptyList()
: safeList(scoreAdminMapper.queryExportPracticeItems(practiceExam.getExamId()));
PracticeExportData practiceData = buildPracticeExportData(practiceItems);
try (HSSFWorkbook workbook = loadExportTemplate()) {
writeSummaryWorkbook(workbook, selectedExam, theoryExam, practiceExam,
students, practiceData);
writeHssfWorkbook(response, workbook,
safeFileName(selectedExam.getClassName()) + "_成绩汇总表.xls");
} catch (IOException e) {
throw new BusinessException("成绩汇总表导出失败,请稍后重试");
}
}
try (XSSFWorkbook workbook = new XSSFWorkbook()) {
ExcelStyles styles = new ExcelStyles(workbook);
Sheet sheet = workbook.createSheet("成绩明细");
writeStudentSheet(sheet, students, styles);
writeWorkbook(response, workbook, safeFileName(exam.getExamName()) + "_成绩单.xlsx");
} catch (IOException e) {
throw new BusinessException("成绩单导出失败,请稍后重试");
/**
* 读取独立导出元数据并执行与原单场导出一致的结束、发布校验。
* 独立 VO 可以承载地点等模板字段,同时不向现有考试分页 JSON 增加无关属性。
*/
private ScoreAdminExportExamVO requirePublishedExportExam(Integer examId) {
requirePositiveId(examId, "考试ID");
ScoreAdminExportExamVO exam = scoreAdminMapper.findExportExam(examId);
if (exam == null) {
throw new BusinessException("考试不存在或已删除");
}
requireEnded(exam);
if (!Boolean.TRUE.equals(exam.getPublished())) {
throw new BusinessException("本场考试成绩尚未正式发布,不能导出");
}
// 模板只定义理论和实训两类分数,未知历史类型不能被默认为其中任意一类。
oppositeExamType(exam.getExamType());
return exam;
}
/** 配对场次可不存在;存在时读取完整应考名单,缺考人员仍由模板备注反映。 */
private List<ScoreAdminStudentVO> exportCandidates(ScoreAdminExportExamVO exam) {
if (exam == null) {
return Collections.emptyList();
}
return safeList(scoreAdminMapper.queryExportCandidates(exam.getExamId()));
}
private <T> List<T> safeList(List<T> values) {
return values == null ? Collections.emptyList() : values;
}
/**
* 先写入所选考试名单,再追加配对考试独有学员,LinkedHashMap 保证最终顺序与业务约定一致。
* 同一考试若出现重复学员记录则直接拒绝导出,避免官方表出现两个互相冲突的成绩。
*/
private List<ExportStudent> mergeExportStudents(
List<ScoreAdminStudentVO> selectedCandidates, boolean selectedIsTheory,
List<ScoreAdminStudentVO> pairedCandidates, boolean pairedIsTheory) {
Map<String, ExportStudent> merged = new LinkedHashMap<>();
mergeCandidates(merged, selectedCandidates, selectedIsTheory);
mergeCandidates(merged, pairedCandidates, pairedIsTheory);
return new ArrayList<>(merged.values());
}
private void mergeCandidates(Map<String, ExportStudent> merged,
List<ScoreAdminStudentVO> candidates, boolean theory) {
for (ScoreAdminStudentVO candidate : candidates) {
String studentId = trimToNull(candidate.getStudentId());
if (studentId == null) {
throw new BusinessException("应考名单存在缺少学员ID的数据,无法合并成绩");
}
ExportStudent target = merged.get(studentId);
if (target == null) {
target = new ExportStudent(studentId, valueOrBlank(candidate.getStudentName()));
merged.put(studentId, target);
} else if (!hasText(target.name) && hasText(candidate.getStudentName())) {
target.name = candidate.getStudentName().trim();
}
if (theory) {
if (target.theory != null) {
throw new BusinessException("理论考试应考名单存在重复学员:" + target.name);
}
target.theory = candidate;
} else {
if (target.practice != null) {
throw new BusinessException("实训考试应考名单存在重复学员:" + target.name);
}
target.practice = candidate;
}
}
}
/**
* 项目定义来自实训上报的真实 code/title。相同编号出现不同非空标题说明源数据冲突;
* 超过五项则拒绝静默截断,因为模板没有第六个项目列。
*/
private PracticeExportData buildPracticeExportData(
List<ScoreAdminExportPracticeItemVO> items) {
Map<String, String> projectTitles = new LinkedHashMap<>();
Map<String, Map<String, BigDecimal>> scores = new LinkedHashMap<>();
for (ScoreAdminExportPracticeItemVO item : items) {
String studentId = trimToNull(item.getStudentId());
String code = trimToNull(item.getCode());
if (studentId == null || code == null) {
throw new BusinessException("实训项目存在缺少学员ID或项目编号的数据,无法导出");
}
String title = valueOrBlank(item.getTitle());
if (!projectTitles.containsKey(code)) {
if (projectTitles.size() >= EXPORT_PROJECT_LIMIT) {
throw new BusinessException("实训项目超过成绩汇总表最多5项的限制,无法导出");
}
projectTitles.put(code, title);
} else {
String existingTitle = projectTitles.get(code);
if (hasText(existingTitle) && hasText(title)
&& !existingTitle.equals(title)) {
throw new BusinessException("实训项目编号" + code + "对应多个名称,无法导出");
}
if (!hasText(existingTitle) && hasText(title)) {
projectTitles.put(code, title);
}
}
scores.computeIfAbsent(studentId, key -> new LinkedHashMap<>())
.put(code, item.getScore());
}
return new PracticeExportData(projectTitles, scores);
}
private HSSFWorkbook loadExportTemplate() throws IOException {
ClassPathResource resource = new ClassPathResource(EXPORT_TEMPLATE_PATH);
try (InputStream inputStream = resource.getInputStream()) {
HSSFWorkbook workbook = new HSSFWorkbook(inputStream);
if (workbook.getNumberOfSheets() != 1) {
workbook.close();
throw new IOException("成绩汇总表模板工作表数量不正确");
}
return workbook;
}
}
/** 克隆未填充的原始模板后逐页写值,从而完整保留打印版式和两组签字行。 */
private void writeSummaryWorkbook(HSSFWorkbook workbook,
ScoreAdminExportExamVO selectedExam,
ScoreAdminExportExamVO theoryExam,
ScoreAdminExportExamVO practiceExam,
List<ExportStudent> students,
PracticeExportData practiceData) {
int sheetCount = Math.max(1,
(students.size() + EXPORT_STUDENTS_PER_SHEET - 1) / EXPORT_STUDENTS_PER_SHEET);
for (int i = 1; i < sheetCount; i++) {
workbook.cloneSheet(0);
}
String sheetBaseName = exportYear(selectedExam) + "年";
for (int page = 0; page < sheetCount; page++) {
Sheet sheet = workbook.getSheetAt(page);
workbook.setSheetName(page, page == 0 ? sheetBaseName : sheetBaseName + "-" + (page + 1));
writeSummarySheet(sheet, selectedExam, theoryExam, practiceExam,
students, practiceData, page);
}
workbook.setActiveSheet(0);
}
private void writeSummarySheet(Sheet sheet,
ScoreAdminExportExamVO selectedExam,
ScoreAdminExportExamVO theoryExam,
ScoreAdminExportExamVO practiceExam,
List<ExportStudent> students,
PracticeExportData practiceData,
int page) {
writeText(sheet, 1, 1, String.valueOf(selectedExam.getClassId()));
writeText(sheet, 1, 5, combinedLocation(theoryExam, practiceExam));
writeText(sheet, 1, 8, "理论" + actualCount(theoryExam)
+ "人,操作" + actualCount(practiceExam) + "人");
writeText(sheet, 2, 1, valueOrBlank(selectedExam.getOccupation()));
writeText(sheet, 2, 5, valueOrBlank(selectedExam.getLevelName()));
writeText(sheet, 2, 8, combinedDate(theoryExam, practiceExam));
List<Map.Entry<String, String>> projects =
new ArrayList<>(practiceData.projectTitles.entrySet());
for (int i = 0; i < EXPORT_PROJECT_LIMIT; i++) {
String label = i < projects.size()
? projects.get(i).getKey() + projects.get(i).getValue() : "";
writeText(sheet, 5, 4 + i, label);
}
for (int slot = 0; slot < EXPORT_STUDENTS_PER_SHEET; slot++) {
int globalIndex = page * EXPORT_STUDENTS_PER_SHEET + slot;
int rowIndex = templateStudentRow(slot);
if (globalIndex >= students.size()) {
clearStudentRow(sheet, rowIndex);
continue;
}
ExportStudent student = students.get(globalIndex);
writeNumber(sheet, rowIndex, 0, BigDecimal.valueOf(globalIndex + 1L));
writeText(sheet, rowIndex, 1, student.name);
writeScore(sheet, rowIndex, 2, scoreOf(student.theory));
writeScore(sheet, rowIndex, 3, scoreOf(student.practice));
Map<String, BigDecimal> studentProjectScores = practiceData.scores.get(student.studentId);
for (int i = 0; i < EXPORT_PROJECT_LIMIT; i++) {
BigDecimal itemScore = null;
if (i < projects.size() && studentProjectScores != null) {
itemScore = studentProjectScores.get(projects.get(i).getKey());
}
writeScore(sheet, rowIndex, 4 + i, itemScore);
}
writeText(sheet, rowIndex, 9, exportRemark(student));
}
}
private int templateStudentRow(int slot) {
return slot < EXPORT_FIRST_SECTION_SIZE
? EXPORT_FIRST_STUDENT_ROW + slot
: EXPORT_SECOND_SECTION_ROW + slot - EXPORT_FIRST_SECTION_SIZE;
}
private void clearStudentRow(Sheet sheet, int rowIndex) {
for (int column = 0; column < 10; column++) {
cell(sheet, rowIndex, column).setBlank();
}
}
private BigDecimal scoreOf(ScoreAdminStudentVO candidate) {
return candidate == null || !Boolean.TRUE.equals(candidate.getPublished())
? null : candidate.getScore();
}
/** 备注明确区分未安排、缺考和已提交但成绩异常未发布三种情况。 */
private String exportRemark(ExportStudent student) {
List<String> remarks = new ArrayList<>();
appendExamRemark(remarks, "理论", student.theory);
appendExamRemark(remarks, "操作", student.practice);
return String.join(";", remarks);
}
private void appendExamRemark(List<String> remarks, String type,
ScoreAdminStudentVO candidate) {
if (candidate == null) {
remarks.add("未列入" + type + "应考名单");
} else if (!Boolean.TRUE.equals(candidate.getSubmitted())) {
remarks.add(type + "缺考");
} else if (!Boolean.TRUE.equals(candidate.getPublished()) || candidate.getScore() == null) {
remarks.add(type + "成绩未发布");
}
}
private String combinedLocation(ScoreAdminExportExamVO theoryExam,
ScoreAdminExportExamVO practiceExam) {
return combineExamMetadata(valueOrBlank(theoryExam == null ? null : theoryExam.getLocation()),
valueOrBlank(practiceExam == null ? null : practiceExam.getLocation()));
}
private String combinedDate(ScoreAdminExportExamVO theoryExam,
ScoreAdminExportExamVO practiceExam) {
return combineExamMetadata(formatExportDate(theoryExam), formatExportDate(practiceExam));
}
private String combineExamMetadata(String theoryValue, String practiceValue) {
if (hasText(theoryValue) && theoryValue.equals(practiceValue)) {
return theoryValue;
}
if (!hasText(theoryValue) && !hasText(practiceValue)) {
return "";
}
if (!hasText(theoryValue)) {
return "操作:" + practiceValue;
}
if (!hasText(practiceValue)) {
return "理论:" + theoryValue;
}
return "理论:" + theoryValue + ";操作:" + practiceValue;
}
private String formatExportDate(ScoreAdminExportExamVO exam) {
if (exam == null || exam.getExamTime() == null) {
return "";
}
SimpleDateFormat formatter = new SimpleDateFormat("yyyy年M月d日");
formatter.setTimeZone(TimeZone.getTimeZone(ExamAdminConstants.BUSINESS_ZONE));
return formatter.format(exam.getExamTime());
}
private int exportYear(ScoreAdminExportExamVO exam) {
if (exam.getTrainingYear() != null) {
return exam.getTrainingYear();
}
Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone(ExamAdminConstants.BUSINESS_ZONE));
if (exam.getExamTime() != null) {
calendar.setTime(exam.getExamTime());
}
return calendar.get(Calendar.YEAR);
}
private int actualCount(ScoreAdminExportExamVO exam) {
return exam == null || exam.getActualCount() == null ? 0 : exam.getActualCount();
}
private String oppositeExamType(String examType) {
if (isTheory(examType)) {
return ExamAdminConstants.TYPE_PRACTICE;
}
if (isPractice(examType)) {
return ExamAdminConstants.TYPE_THEORY;
}
throw new BusinessException("考试类型不是理论或实训,无法生成成绩汇总表");
}
private boolean isTheory(String type) {
return type != null && (ExamAdminConstants.TYPE_THEORY.equals(type.trim())
|| "理论".equals(type.trim())
|| "THEORY".equalsIgnoreCase(type.trim()));
}
private void writeText(Sheet sheet, int rowIndex, int columnIndex, String value) {
cell(sheet, rowIndex, columnIndex).setCellValue(valueOrBlank(value));
}
private void writeScore(Sheet sheet, int rowIndex, int columnIndex, BigDecimal value) {
if (value == null) {
cell(sheet, rowIndex, columnIndex).setBlank();
} else {
writeNumber(sheet, rowIndex, columnIndex, value);
}
}
private void writeNumber(Sheet sheet, int rowIndex, int columnIndex, BigDecimal value) {
cell(sheet, rowIndex, columnIndex).setCellValue(value.doubleValue());
}
/** 获取模板既有单元格;仅在模板缺失时补建,正常路径不会改变原样式。 */
private Cell cell(Sheet sheet, int rowIndex, int columnIndex) {
Row row = sheet.getRow(rowIndex);
if (row == null) {
row = sheet.createRow(rowIndex);
}
Cell cell = row.getCell(columnIndex);
return cell == null ? row.createCell(columnIndex) : cell;
}
private String valueOrBlank(String value) {
return value == null ? "" : value.trim();
}
private boolean hasText(String value) {
return value != null && !value.trim().isEmpty();
}
private void writeHssfWorkbook(HttpServletResponse response, HSSFWorkbook workbook,
String fileName) throws IOException {
response.reset();
response.setContentType("application/vnd.ms-excel");
String encoded = URLEncoder.encode(fileName, StandardCharsets.UTF_8.name()).replace("+", "%20");
response.setHeader("Content-Disposition", "attachment; filename*=UTF-8''" + encoded);
try (ServletOutputStream outputStream = response.getOutputStream()) {
workbook.write(outputStream);
outputStream.flush();
}
}
......@@ -258,15 +632,6 @@ public class ScoreAdminServiceImpl implements ScoreAdminService {
query.setScoreBand(band);
}
private ScoreAdminExamVO requirePublishedExam(Integer examId) {
ScoreAdminExamVO exam = requireExam(examId);
requireEnded(exam);
if (!Boolean.TRUE.equals(exam.getPublished())) {
throw new BusinessException("本场考试成绩尚未正式发布,不能导出");
}
return exam;
}
private ScoreAdminExamVO requireExam(Integer examId) {
requirePositiveId(examId, "考试ID");
ScoreAdminExamVO exam = scoreAdminMapper.findExam(examId);
......@@ -287,6 +652,17 @@ public class ScoreAdminServiceImpl implements ScoreAdminService {
}
}
/** 导出专用元数据执行同一套历史考试边界,避免数据库异常数据进入正式表格。 */
private void requireEnded(ScoreAdminExportExamVO exam) {
if (exam.getExamTime() == null) {
throw new BusinessException("考试时间缺失,无法判断历史状态");
}
long durationMillis = Math.max(0, exam.getDuration() == null ? 0 : exam.getDuration()) * 60_000L;
if (exam.getExamTime().getTime() + durationMillis > System.currentTimeMillis()) {
throw new BusinessException("考试尚未结束,不能进入历史成绩管理");
}
}
/**
* 按管理端统一规则计算考试生命周期,避免前端根据本地时钟自行推断状态。
* 开始时刻计入进行中,结束时刻计入已结束;异常的负时长按零分钟处理。
......@@ -325,6 +701,7 @@ public class ScoreAdminServiceImpl implements ScoreAdminService {
private boolean isPractice(String type) {
return type != null && (ExamAdminConstants.TYPE_PRACTICE.equals(type.trim())
|| "实训".equals(type.trim())
|| "PRACTICE".equalsIgnoreCase(type.trim()));
}
......@@ -438,6 +815,31 @@ public class ScoreAdminServiceImpl implements ScoreAdminService {
return value == null ? "—" : value.stripTrailingZeros().toPlainString();
}
/** 合并后的单个学员,理论与实训记录分别保存,防止同名学员被错误合并。 */
private static final class ExportStudent {
private final String studentId;
private String name;
private ScoreAdminStudentVO theory;
private ScoreAdminStudentVO practice;
private ExportStudent(String studentId, String name) {
this.studentId = studentId;
this.name = name;
}
}
/** 动态项目顺序和按学员索引的逐项分数在构建后保持同一份导出快照。 */
private static final class PracticeExportData {
private final Map<String, String> projectTitles;
private final Map<String, Map<String, BigDecimal>> scores;
private PracticeExportData(Map<String, String> projectTitles,
Map<String, Map<String, BigDecimal>> scores) {
this.projectTitles = projectTitles;
this.scores = scores;
}
}
/** 工作簿级样式只创建一次,避免逐单元格创建样式触发POI样式数量上限。 */
private static final class ExcelStyles {
private final CellStyle header;
......
......@@ -81,6 +81,31 @@
chief.nick_name, e.mark_flag
</sql>
<!--
人社局成绩汇总表需要考试地点和完整应考人数,但这些字段不应被强行加入现有分页
返回对象,因此使用独立的导出元数据列集合。
-->
<sql id="exportExamColumns">
e.id AS examId,
e.class_id AS classId,
e.name AS examName,
e.type AS examType,
c.name AS className,
c.occupation,
c.training_year AS trainingYear,
sl.name AS levelName,
e.location,
e.exam_time AS examTime,
e.duration,
COALESCE(SUM(CASE WHEN IFNULL(es.submit, 0) = 1 THEN 1 ELSE 0 END), 0) AS actualCount,
CASE WHEN IFNULL(e.mark_flag, 0) = 1 THEN TRUE ELSE FALSE END AS published
</sql>
<sql id="exportExamGroup">
GROUP BY e.id, e.class_id, e.name, e.type, c.name, c.occupation, c.training_year,
sl.name, e.location, e.exam_time, e.duration, e.mark_flag
</sql>
<select id="queryExams" resultType="com.platform.business.model.vo.ScoreAdminExamVO">
SELECT <include refid="examSummaryColumns"/>
<include refid="examSummaryJoins"/>
......@@ -378,4 +403,98 @@
ORDER BY e.exam_time DESC, e.id DESC
</select>
<select id="findExportExam" resultType="com.platform.business.model.vo.ScoreAdminExportExamVO">
SELECT <include refid="exportExamColumns"/>
<include refid="examSummaryJoins"/>
WHERE e.id = #{examId}
<include refid="exportExamGroup"/>
</select>
<select id="findLatestPublishedExportExam"
resultType="com.platform.business.model.vo.ScoreAdminExportExamVO">
SELECT <include refid="exportExamColumns"/>
<include refid="examSummaryJoins"/>
WHERE e.class_id = #{classId}
<!-- 同时兼容当前“实训考试/理论考试”和历史“实训/理论”短值。 -->
AND e.type IN (#{examType}, REPLACE(#{examType}, '考试', ''))
AND IFNULL(e.mark_flag, 0) = 1
AND DATE_ADD(e.exam_time, INTERVAL IFNULL(e.duration, 0) MINUTE) &lt;= NOW()
<include refid="exportExamGroup"/>
ORDER BY e.exam_time DESC, e.id DESC
LIMIT 1
</select>
<!--
汇总表必须区分缺考与零分,因此这里返回完整应考名单,只在考试和学员成绩都发布时
暴露成绩。ORDER BY es.id 为跨两场考试合并时提供稳定的原始名单顺序。
-->
<select id="queryExportCandidates" resultType="com.platform.business.model.vo.ScoreAdminStudentVO">
SELECT
es.id AS examStudentId,
es.exam_id AS examId,
es.class_id AS classId,
es.student_id AS studentId,
u.nick_name AS studentName,
u.id_card AS idCard,
c.name AS className,
e.name AS examName,
e.type AS examType,
e.exam_time AS examTime,
CASE WHEN IFNULL(es.submit, 0) = 1 THEN TRUE ELSE FALSE END AS submitted,
CASE
WHEN IFNULL(e.mark_flag, 0) = 1 AND IFNULL(es.mark_flag, 0) = 1
THEN TRUE ELSE FALSE
END AS published,
CASE
WHEN IFNULL(e.mark_flag, 0) = 1 AND IFNULL(es.mark_flag, 0) = 1
THEN es.score ELSE NULL
END AS score,
CASE
WHEN IFNULL(e.mark_flag, 0) = 0 OR IFNULL(es.mark_flag, 0) = 0 OR es.score IS NULL THEN NULL
WHEN es.score &gt;= 90 THEN '优秀'
WHEN es.score &gt;= 80 THEN '良好'
WHEN es.score &gt;= 60 THEN '及格'
ELSE '不及格'
END AS grade,
CASE
WHEN IFNULL(e.mark_flag, 0) = 0 OR IFNULL(es.mark_flag, 0) = 0 OR es.score IS NULL THEN NULL
WHEN es.score &gt;= IFNULL(e.pass_score, 60) THEN TRUE ELSE FALSE
END AS passed,
es.answer_time AS answerTime,
es.duration,
NULL AS comment
FROM exam_student es
INNER JOIN exam e ON e.id = es.exam_id
LEFT JOIN user u ON u.id = es.student_id
LEFT JOIN class c ON c.id = es.class_id
WHERE es.exam_id = #{examId}
ORDER BY es.id
</select>
<!--
fz_grades 可能保留同一项目的历史复核记录;每名学员、每个项目只取雪花 ID 最大的
当前记录,并同时校验整场和个人成绩均已发布。
-->
<select id="queryExportPracticeItems"
resultType="com.platform.business.model.vo.ScoreAdminExportPracticeItemVO">
SELECT
g.user_id AS studentId,
g.code,
g.title,
g.score
FROM fz_grades g
INNER JOIN (
SELECT user_id, code, MAX(id) AS id
FROM fz_grades
WHERE exam_id = #{examId}
GROUP BY user_id, code
) latest ON latest.id = g.id
INNER JOIN exam_student es
ON es.exam_id = g.exam_id AND es.student_id = g.user_id
AND IFNULL(es.mark_flag, 0) = 1
INNER JOIN exam e ON e.id = g.exam_id AND IFNULL(e.mark_flag, 0) = 1
WHERE g.exam_id = #{examId}
ORDER BY g.code, g.id
</select>
</mapper>
......@@ -71,11 +71,16 @@ JWT解析当前用户并校验 `phone_role.role_name=管理员`。本模块只
## 5. Excel导出
- `GET /exam/admin/scores/exams/{examId}/export`:导出单场已发布成绩。
- `GET /exam/admin/scores/exams/{examId}/export`:按人社局成绩汇总表模板导出。所选考试必须
已结束且已发布;服务端自动匹配同班级另一类型中最近一场已结束、已发布考试。找不到配对
考试时仍生成部分汇总表,缺少类型的人数为0,成绩列留空。
- `GET /exam/admin/scores/classes/{classId}/export`:导出班级历史考试汇总和所有正式学员成绩。
响应类型为 `application/vnd.openxmlformats-officedocument.spreadsheetml.sheet`,文件名通过
RFC 5987 UTF-8编码。未发布考试禁止导出。
单场汇总表响应类型为 `application/vnd.ms-excel`,文件名为“班级名称_成绩汇总表.xls”。名单
取两场应考学员并集,缺考或未列入另一场名单时对应成绩留空并写入备注;实训项目按实际
编号与标题动态填充,最多5项。每27名学员生成一张同版式分表,序号跨分表连续。
班级历史导出继续返回 `.xlsx`。两类文件名均通过 RFC 5987 UTF-8 编码。
## 6. 仿真实训完整成绩上报
......
......@@ -28,6 +28,41 @@ class ScoreAdminMapperXmlTest {
"com.platform.business.mapper.ScoreAdminMapper.queryTheoryStatistics"));
assertTrue(configuration.hasStatement(
"com.platform.business.mapper.ScoreAdminMapper.queryPracticeStatistics"));
assertTrue(configuration.hasStatement(
"com.platform.business.mapper.ScoreAdminMapper.findExportExam"));
assertTrue(configuration.hasStatement(
"com.platform.business.mapper.ScoreAdminMapper.findLatestPublishedExportExam"));
assertTrue(configuration.hasStatement(
"com.platform.business.mapper.ScoreAdminMapper.queryExportCandidates"));
assertTrue(configuration.hasStatement(
"com.platform.business.mapper.ScoreAdminMapper.queryExportPracticeItems"));
}
@Test
void humanResourcesExportQueriesShouldUsePublishedLatestPairAndStableRoster() throws Exception {
Configuration configuration = parse("com/platform/business/mapper/ScoreAdminMapper.xml");
Map<String, Object> pairParameters = new HashMap<>();
pairParameters.put("classId", 1);
pairParameters.put("examType", "实训考试");
String pairSql = normalizeSql(configuration.getMappedStatement(
"com.platform.business.mapper.ScoreAdminMapper.findLatestPublishedExportExam")
.getBoundSql(pairParameters).getSql());
assertTrue(pairSql.contains("ifnull(e.mark_flag, 0) = 1"));
assertTrue(pairSql.contains("date_add(e.exam_time"));
assertTrue(pairSql.contains("order by e.exam_time desc, e.id desc limit 1"));
String rosterSql = normalizeSql(configuration.getMappedStatement(
"com.platform.business.mapper.ScoreAdminMapper.queryExportCandidates")
.getBoundSql(1).getSql());
assertTrue(rosterSql.contains("where es.exam_id = ? order by es.id"));
assertFalse(rosterSql.contains("es.score is not null"));
String itemSql = normalizeSql(configuration.getMappedStatement(
"com.platform.business.mapper.ScoreAdminMapper.queryExportPracticeItems")
.getBoundSql(1).getSql());
assertTrue(itemSql.contains("max(id) as id"));
assertTrue(itemSql.contains("ifnull(es.mark_flag, 0) = 1"));
}
@Test
......
......@@ -4,12 +4,14 @@ import com.platform.business.constant.ExamAdminConstants;
import com.platform.business.mapper.ScoreAdminMapper;
import com.platform.business.model.dto.ScoreAdminExamQueryDTO;
import com.platform.business.model.dto.ScoreAdminStudentQueryDTO;
import com.platform.business.model.vo.ScoreAdminExportExamVO;
import com.platform.business.model.vo.ScoreAdminExportPracticeItemVO;
import com.platform.business.model.vo.ScoreAdminExamVO;
import com.platform.business.model.vo.ScoreAdminStudentDetailVO;
import com.platform.business.model.vo.ScoreAdminStudentVO;
import com.platform.business.service.ExamAdminService;
import com.platform.exception.BusinessException;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
......@@ -20,6 +22,7 @@ import org.springframework.mock.web.MockHttpServletResponse;
import java.io.ByteArrayInputStream;
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
......@@ -114,15 +117,16 @@ class ScoreAdminServiceImplTest {
@Test
void upcomingExamShouldStillBeRejectedByScoreExport() {
ScoreAdminExamVO upcoming = examAt(new Date(System.currentTimeMillis() + 3_600_000L), 60);
ScoreAdminExportExamVO upcoming = exportExamAt(
new Date(System.currentTimeMillis() + 3_600_000L), 60);
upcoming.setPublished(true);
when(scoreAdminMapper.findExam(1)).thenReturn(upcoming);
when(scoreAdminMapper.findExportExam(1)).thenReturn(upcoming);
BusinessException error = assertThrows(BusinessException.class,
() -> service.exportExam(1, new MockHttpServletResponse()));
assertEquals("考试尚未结束,不能进入历史成绩管理", error.getMessage());
verify(scoreAdminMapper, never()).queryPublishedStudents(1);
verify(scoreAdminMapper, never()).queryExportCandidates(1);
}
@Test
......@@ -171,32 +175,154 @@ class ScoreAdminServiceImplTest {
}
@Test
void exportExamShouldCreateChineseXlsxWithPublishedRows() throws Exception {
ScoreAdminExamVO exam = endedExam(true);
exam.setExamName("污水一级期末考试");
when(scoreAdminMapper.findExam(1)).thenReturn(exam);
ScoreAdminStudentVO student = new ScoreAdminStudentVO();
student.setExamName(exam.getExamName());
student.setExamType("理论");
student.setClassName("污水一级一班");
student.setStudentName("张三");
student.setIdCard("310000000000000001");
student.setScore(new BigDecimal("88.5"));
student.setGrade("良好");
student.setPassed(true);
when(scoreAdminMapper.queryPublishedStudents(1)).thenReturn(Collections.singletonList(student));
void exportExamShouldCreateHumanResourcesTemplateWithPairedScores() throws Exception {
ScoreAdminExportExamVO theoryExam = endedExportExam(1, 10, "理论");
theoryExam.setClassName("污水一级一班");
theoryExam.setOccupation("污水");
theoryExam.setLevelName("一级");
theoryExam.setTrainingYear(2026);
theoryExam.setLocation("理论考场");
theoryExam.setExamTime(Timestamp.valueOf("2026-08-20 09:00:00"));
theoryExam.setActualCount(1);
ScoreAdminExportExamVO practiceExam = endedExportExam(2, 10, "实训");
practiceExam.setLocation("实训室");
practiceExam.setExamTime(Timestamp.valueOf("2026-08-21 09:00:00"));
practiceExam.setActualCount(2);
when(scoreAdminMapper.findExportExam(1)).thenReturn(theoryExam);
when(scoreAdminMapper.findLatestPublishedExportExam(10, ExamAdminConstants.TYPE_PRACTICE))
.thenReturn(practiceExam);
ScoreAdminStudentVO theoryStudent = exportStudent("student-1", "张三", "88.5", true, true);
ScoreAdminStudentVO practiceStudent = exportStudent("student-1", "张三", "91", true, true);
ScoreAdminStudentVO practiceOnlyStudent = exportStudent("student-2", "李四", "80", true, true);
when(scoreAdminMapper.queryExportCandidates(1))
.thenReturn(Collections.singletonList(theoryStudent));
when(scoreAdminMapper.queryExportCandidates(2))
.thenReturn(Arrays.asList(practiceStudent, practiceOnlyStudent));
when(scoreAdminMapper.queryExportPracticeItems(2)).thenReturn(Arrays.asList(
practiceItem("student-1", "1.1", "日常运行管理", "20"),
practiceItem("student-2", "1.1", "日常运行管理", "18"),
practiceItem("student-1", "1.2", "基础操作", "19")
));
MockHttpServletResponse response = new MockHttpServletResponse();
service.exportExam(1, response);
assertEquals("application/vnd.ms-excel", response.getContentType());
assertTrue(response.getHeader("Content-Disposition").contains("UTF-8''"));
try (XSSFWorkbook workbook = new XSSFWorkbook(
assertTrue(response.getHeader("Content-Disposition").endsWith(".xls"));
try (HSSFWorkbook workbook = new HSSFWorkbook(
new ByteArrayInputStream(response.getContentAsByteArray()))) {
assertEquals("2026年", workbook.getSheetAt(0).getSheetName());
assertTrue(workbook.getSheetAt(0).getNumMergedRegions() > 0);
assertEquals("10", text(workbook, 0, 1, 1));
assertEquals("理论:理论考场;操作:实训室", text(workbook, 0, 1, 5));
assertEquals("理论1人,操作2人", text(workbook, 0, 1, 8));
assertEquals("理论:2026年8月20日;操作:2026年8月21日", text(workbook, 0, 2, 8));
assertEquals("1.1日常运行管理", text(workbook, 0, 5, 4));
assertEquals("张三", text(workbook, 0, 6, 1));
assertEquals(88.5D, workbook.getSheetAt(0).getRow(6).getCell(2).getNumericCellValue());
assertEquals(91D, workbook.getSheetAt(0).getRow(6).getCell(3).getNumericCellValue());
assertEquals(20D, workbook.getSheetAt(0).getRow(6).getCell(4).getNumericCellValue());
assertEquals("李四", text(workbook, 0, 7, 1));
assertEquals("未列入理论应考名单", text(workbook, 0, 7, 9));
assertEquals("考评员签字", text(workbook, 0, 22, 0));
}
verify(scoreAdminMapper).findLatestPublishedExportExam(
10, ExamAdminConstants.TYPE_PRACTICE);
}
@Test
void exportExamShouldAllowMissingOppositeExamAndKeepAbsentStudent() throws Exception {
ScoreAdminExportExamVO theoryExam = endedExportExam(1, 10, "理论");
when(scoreAdminMapper.findExportExam(1)).thenReturn(theoryExam);
when(scoreAdminMapper.findLatestPublishedExportExam(10, ExamAdminConstants.TYPE_PRACTICE))
.thenReturn(null);
when(scoreAdminMapper.queryExportCandidates(1)).thenReturn(Collections.singletonList(
exportStudent("student-1", "张三", null, false, false)));
MockHttpServletResponse response = new MockHttpServletResponse();
service.exportExam(1, response);
try (HSSFWorkbook workbook = new HSSFWorkbook(
new ByteArrayInputStream(response.getContentAsByteArray()))) {
assertEquals("成绩明细", workbook.getSheetAt(0).getSheetName());
assertEquals("学员姓名", workbook.getSheetAt(0).getRow(0).getCell(5).getStringCellValue());
assertEquals("张三", workbook.getSheetAt(0).getRow(1).getCell(5).getStringCellValue());
assertEquals("理论0人,操作0人", text(workbook, 0, 1, 8));
assertEquals("理论缺考;未列入操作应考名单", text(workbook, 0, 6, 9));
assertEquals(org.apache.poi.ss.usermodel.CellType.BLANK,
workbook.getSheetAt(0).getRow(6).getCell(2).getCellType());
assertEquals(org.apache.poi.ss.usermodel.CellType.BLANK,
workbook.getSheetAt(0).getRow(6).getCell(3).getCellType());
}
verify(scoreAdminMapper, never()).queryExportPracticeItems(org.mockito.ArgumentMatchers.anyInt());
}
@Test
void exportExamShouldCreateAnotherTemplateSheetAfterTwentySevenStudents() throws Exception {
ScoreAdminExportExamVO practiceExam = endedExportExam(1, 10, "实训");
when(scoreAdminMapper.findExportExam(1)).thenReturn(practiceExam);
when(scoreAdminMapper.findLatestPublishedExportExam(10, ExamAdminConstants.TYPE_THEORY))
.thenReturn(null);
List<ScoreAdminStudentVO> candidates = new ArrayList<>();
for (int i = 1; i <= 28; i++) {
candidates.add(exportStudent("student-" + i, "学员" + i,
String.valueOf(100 - i), true, true));
}
when(scoreAdminMapper.queryExportCandidates(1)).thenReturn(candidates);
when(scoreAdminMapper.queryExportPracticeItems(1)).thenReturn(Collections.emptyList());
MockHttpServletResponse response = new MockHttpServletResponse();
service.exportExam(1, response);
try (HSSFWorkbook workbook = new HSSFWorkbook(
new ByteArrayInputStream(response.getContentAsByteArray()))) {
assertEquals(2, workbook.getNumberOfSheets());
assertEquals("2026年", workbook.getSheetName(0));
assertEquals("2026年-2", workbook.getSheetName(1));
assertEquals(27D, workbook.getSheetAt(0).getRow(34).getCell(0).getNumericCellValue());
assertEquals("学员27", text(workbook, 0, 34, 1));
assertEquals(28D, workbook.getSheetAt(1).getRow(6).getCell(0).getNumericCellValue());
assertEquals("学员28", text(workbook, 1, 6, 1));
assertEquals(org.apache.poi.ss.usermodel.CellType.BLANK,
workbook.getSheetAt(1).getRow(7).getCell(0).getCellType());
assertEquals("督导员签字", text(workbook, 1, 36, 0));
}
}
@Test
void exportExamShouldRejectMoreThanFivePracticeProjects() {
ScoreAdminExportExamVO practiceExam = endedExportExam(1, 10, "实训");
when(scoreAdminMapper.findExportExam(1)).thenReturn(practiceExam);
when(scoreAdminMapper.queryExportCandidates(1)).thenReturn(Collections.singletonList(
exportStudent("student-1", "张三", "90", true, true)));
List<ScoreAdminExportPracticeItemVO> items = new ArrayList<>();
for (int i = 1; i <= 6; i++) {
items.add(practiceItem("student-1", "P" + i, "项目" + i, "10"));
}
when(scoreAdminMapper.queryExportPracticeItems(1)).thenReturn(items);
BusinessException error = assertThrows(BusinessException.class,
() -> service.exportExam(1, new MockHttpServletResponse()));
assertEquals("实训项目超过成绩汇总表最多5项的限制,无法导出", error.getMessage());
}
@Test
void exportExamShouldPairLatestTheoryWhenSelectedExamIsPractice() throws Exception {
ScoreAdminExportExamVO practiceExam = endedExportExam(1, 10, "实训");
ScoreAdminExportExamVO theoryExam = endedExportExam(2, 10, "理论");
when(scoreAdminMapper.findExportExam(1)).thenReturn(practiceExam);
when(scoreAdminMapper.findLatestPublishedExportExam(10, ExamAdminConstants.TYPE_THEORY))
.thenReturn(theoryExam);
when(scoreAdminMapper.queryExportCandidates(1)).thenReturn(Collections.singletonList(
exportStudent("student-1", "张三", "90", true, true)));
when(scoreAdminMapper.queryExportCandidates(2)).thenReturn(Collections.singletonList(
exportStudent("student-1", "张三", "80", true, true)));
when(scoreAdminMapper.queryExportPracticeItems(1)).thenReturn(Collections.emptyList());
service.exportExam(1, new MockHttpServletResponse());
verify(scoreAdminMapper).findLatestPublishedExportExam(
10, ExamAdminConstants.TYPE_THEORY);
}
private ScoreAdminExamVO endedExam(boolean published) {
......@@ -206,6 +332,53 @@ class ScoreAdminServiceImplTest {
return exam;
}
private ScoreAdminExportExamVO endedExportExam(int examId, int classId, String type) {
ScoreAdminExportExamVO exam = exportExamAt(
new Date(System.currentTimeMillis() - 3_600_000L), 30);
exam.setExamId(examId);
exam.setClassId(classId);
exam.setExamType(type);
exam.setClassName("污水一级一班");
exam.setTrainingYear(2026);
exam.setPublished(true);
exam.setActualCount(0);
return exam;
}
private ScoreAdminExportExamVO exportExamAt(Date examTime, int duration) {
ScoreAdminExportExamVO exam = new ScoreAdminExportExamVO();
exam.setExamId(1);
exam.setClassId(10);
exam.setExamTime(examTime);
exam.setDuration(duration);
return exam;
}
private ScoreAdminStudentVO exportStudent(String studentId, String name, String score,
boolean submitted, boolean published) {
ScoreAdminStudentVO student = new ScoreAdminStudentVO();
student.setStudentId(studentId);
student.setStudentName(name);
student.setSubmitted(submitted);
student.setPublished(published);
student.setScore(score == null ? null : new BigDecimal(score));
return student;
}
private ScoreAdminExportPracticeItemVO practiceItem(
String studentId, String code, String title, String score) {
ScoreAdminExportPracticeItemVO item = new ScoreAdminExportPracticeItemVO();
item.setStudentId(studentId);
item.setCode(code);
item.setTitle(title);
item.setScore(new BigDecimal(score));
return item;
}
private String text(HSSFWorkbook workbook, int sheet, int row, int column) {
return workbook.getSheetAt(sheet).getRow(row).getCell(column).getStringCellValue();
}
/** 构造仅包含生命周期判断所需字段的考试,减少各状态测试的重复样板。 */
private ScoreAdminExamVO examAt(Date examTime, int duration) {
ScoreAdminExamVO exam = new ScoreAdminExamVO();
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment