package com.mindskip.xzs.service.impl;
|
|
import cn.hutool.core.lang.Dict;
|
import com.mindskip.xzs.domain.*;
|
import com.mindskip.xzs.domain.enums.QuestionTypeEnum;
|
import com.mindskip.xzs.domain.enums.RoleEnum;
|
import com.mindskip.xzs.domain.enums.UserStatusEnum;
|
import com.mindskip.xzs.domain.other.QuestionImportCellIndex;
|
import com.mindskip.xzs.repository.ClassesMapper;
|
import com.mindskip.xzs.repository.ClassesUserMapper;
|
import com.mindskip.xzs.service.*;
|
import com.mindskip.xzs.utility.ExamUtil;
|
import com.mindskip.xzs.viewmodel.admin.question.QuestionEditItemVM;
|
import com.mindskip.xzs.viewmodel.admin.question.QuestionEditRequestVM;
|
import lombok.AllArgsConstructor;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.poi.ss.usermodel.CellType;
|
import org.apache.poi.xssf.usermodel.*;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.stereotype.Service;
|
|
import java.io.*;
|
import java.util.*;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
|
@Service
|
@AllArgsConstructor
|
public class ExcelImportImportServiceImpl implements ExcelImportService {
|
|
private final ClassesService classesService;
|
private final QuestionService questionService;
|
private final SubjectService subjectService;
|
private final UserService userService;
|
private final KnowledgeService knowledgeService;
|
private final AuthenticationService authenticationService;
|
private final ClassesMapper classesMapper;
|
private final ClassesUserMapper classesUserMapper;
|
|
private final DepartmentService departmentService;
|
|
private static final Logger logger = LoggerFactory.getLogger(ExcelImportImportServiceImpl.class);
|
|
@Override
|
public void teacherQuestionImport(InputStream inputStream, String outFilePath, User user) {
|
try {
|
XSSFWorkbook workbook = new XSSFWorkbook(inputStream);
|
XSSFCellStyle cellStyle = workbook.createCellStyle();
|
cellStyle.setWrapText(true);
|
singleChoice(workbook.getSheetAt(0), cellStyle, user, new QuestionImportCellIndex(null, 0, 1, 16, 2, 11, 12, 13, 14, 3, 11, 15));
|
multipleChoice(workbook.getSheetAt(1), cellStyle, user, new QuestionImportCellIndex(null, 0, 1, 16, 2, 11, 12, 13, 14, 3, 11, 15));
|
trueFalse(workbook.getSheetAt(2), cellStyle, user, new QuestionImportCellIndex(null, 0, 1, 10, 2, 5, 6, 7, 8, 3, 4, 9));
|
gapFilling(workbook.getSheetAt(3), cellStyle, user, new QuestionImportCellIndex(null, 0, 1, 15, 2, 11, 12, 13, null, 2, null, 14));
|
shortAnswer(workbook.getSheetAt(4), cellStyle, user, new QuestionImportCellIndex(null, 0, 1, 8, 2, 4, 5, 6, 3, null, null, 7));
|
try (FileOutputStream excelOutStream = new FileOutputStream(outFilePath)) {
|
workbook.write(excelOutStream);
|
}
|
} catch (IOException e) {
|
logger.error(e.getMessage(), e);
|
}
|
}
|
|
@Override
|
public void adminQuestionImport(InputStream inputStream, String outFilePath, User user) {
|
try {
|
XSSFWorkbook workbook = new XSSFWorkbook(inputStream);
|
XSSFCellStyle cellStyle = workbook.createCellStyle();
|
cellStyle.setWrapText(true);
|
singleChoice(workbook.getSheetAt(0), cellStyle, user, new QuestionImportCellIndex(0, 1, 2, 17, 3, 12, 13, 14, 15, 4, 12, 16));
|
multipleChoice(workbook.getSheetAt(1), cellStyle, user, new QuestionImportCellIndex(0, 1, 2, 17, 3, 12, 13, 14, 15, 4, 12, 16));
|
trueFalse(workbook.getSheetAt(2), cellStyle, user, new QuestionImportCellIndex(0, 1, 2, 11, 3, 6, 7, 8, 9, 4, 5, 10));
|
gapFilling(workbook.getSheetAt(3), cellStyle, user, new QuestionImportCellIndex(0, 1, 2, 16, 3, 12, 13, 14, null, 3, null, 15));
|
shortAnswer(workbook.getSheetAt(4), cellStyle, user, new QuestionImportCellIndex(0, 1, 2, 9, 3, 5, 6, 7, 4, null, null, 8));
|
try (FileOutputStream excelOutStream = new FileOutputStream(outFilePath)) {
|
workbook.write(excelOutStream);
|
}
|
} catch (IOException e) {
|
logger.error(e.getMessage(), e);
|
}
|
}
|
|
@Override
|
public void studentImport(InputStream inputStream, String outFilePath, User user) {
|
try {
|
Date now = new Date();
|
List<Classes> classesList = classesService.getClassesByCreate(user.getId());
|
XSSFWorkbook workbook = new XSSFWorkbook(inputStream);
|
XSSFCellStyle cellStyle = workbook.createCellStyle();
|
cellStyle.setWrapText(true);
|
XSSFSheet sheet = workbook.getSheetAt(0);
|
if (null != sheet && sheet.getLastRowNum() >= 1) {
|
Integer errorIndex = 4;
|
for (int i = 1; i <= sheet.getLastRowNum(); i++) {
|
XSSFRow row = sheet.getRow(i);
|
try {
|
if (null != row.getCell(5)) { //已经导入过
|
continue;
|
}
|
|
String userName = stringCheck(row, cellStyle, 0, errorIndex, "用户名不能为空");
|
if (null == userName) {
|
continue;
|
}
|
|
String passWord = stringCheck(row, cellStyle, 1, errorIndex, "密码不能为空");
|
if (null == passWord) {
|
continue;
|
}
|
|
String realName = stringCheck(row, cellStyle, 2, errorIndex, "真实姓名不能为空");
|
if (null == realName) {
|
continue;
|
}
|
|
String classes = stringCheck(row, cellStyle, 3, errorIndex, "班级不能为空");
|
if (null == classes) {
|
continue;
|
}
|
|
User existUser = userService.getUserByUserName(userName);
|
if (null != existUser) {
|
writeError(row, cellStyle, errorIndex, "用户名已存在");
|
continue;
|
}
|
|
User newUser = new User();
|
newUser.setUserName(userName);
|
newUser.setRealName(realName);
|
String encodePwd = authenticationService.pwdEncode(passWord);
|
newUser.setUserUuid(UUID.randomUUID().toString());
|
newUser.setPassword(encodePwd);
|
newUser.setRole(RoleEnum.STUDENT.getCode());
|
newUser.setUserLevel(user.getUserLevel());
|
newUser.setStatus(UserStatusEnum.Enable.getCode());
|
newUser.setLastActiveTime(now);
|
newUser.setCreateTime(now);
|
newUser.setDeleted(false);
|
userService.insertByFilter(newUser);
|
row.createCell(5).setCellValue(newUser.getId());
|
|
for (String classItem : classes.split(" ")) {
|
if (!StringUtils.isBlank(classItem)) {
|
classesList.stream().filter(c -> c.getName().equals(classItem)).findFirst().ifPresent(d -> {
|
ClassesUser newClassesUser = new ClassesUser();
|
newClassesUser.setClassesId(d.getId());
|
newClassesUser.setUserId(newUser.getId());
|
newClassesUser.setDeleted(false);
|
newClassesUser.setCreateTime(now);
|
newClassesUser.setClassesName(d.getName());
|
classesUserMapper.insertSelective(newClassesUser);
|
classesMapper.classesNumAdd(d.getId());
|
});
|
}
|
}
|
} catch (Exception ex) {
|
writeError(row, cellStyle, errorIndex, ex.getMessage());
|
}
|
}
|
}
|
try (FileOutputStream excelOutStream = new FileOutputStream(outFilePath)) {
|
workbook.write(excelOutStream);
|
}
|
} catch (IOException e) {
|
logger.error(e.getMessage(), e);
|
}
|
}
|
|
|
private void singleChoice(XSSFSheet sheet, XSSFCellStyle cellStyle, User user, QuestionImportCellIndex questionImportCellIndex) {
|
if (null != sheet && sheet.getLastRowNum() >= 1) {
|
Integer errorIndex = questionImportCellIndex.getError();
|
for (int i = 1; i <= sheet.getLastRowNum(); i++) {
|
XSSFRow row = sheet.getRow(i);
|
try {
|
if (null != row.getCell(questionImportCellIndex.getId())) { //已经导入过
|
continue;
|
}
|
|
Integer level = user.getUserLevel();
|
if (null != questionImportCellIndex.getLevel()) {
|
level = levelCheck(row, cellStyle, questionImportCellIndex.getLevel(), errorIndex);
|
if (null == level) {
|
continue;
|
}
|
}
|
|
List<Subject> subjects = subjectService.getSubjectByLevel(level);
|
Subject subject = subjectCheck(row, cellStyle, questionImportCellIndex.getSubject(), subjects, errorIndex);
|
if (null == subject) {
|
continue;
|
}
|
String title = stringCheck(row, cellStyle, questionImportCellIndex.getTitle(), errorIndex, "题干不能为空");
|
if (null == title) {
|
continue;
|
}
|
String analyze = stringCheck(row, cellStyle, questionImportCellIndex.getAnalyze(), errorIndex, "解析不能为空");
|
if (null == analyze) {
|
continue;
|
}
|
String score = stringCheck(row, cellStyle, questionImportCellIndex.getScore(), errorIndex, "分数不能为空");
|
if (null == score) {
|
continue;
|
}
|
String difficult = stringCheck(row, cellStyle, questionImportCellIndex.getDifficult(), errorIndex, "难度不能为空");
|
if (null == difficult) {
|
continue;
|
}
|
String correct = stringCheck(row, cellStyle, questionImportCellIndex.getCorrect(), errorIndex, "答案不能为空");
|
if (null == correct) {
|
continue;
|
}
|
|
List<Integer> knowledgePointId = new ArrayList<>();
|
XSSFCell knowledgeCell = row.getCell(questionImportCellIndex.getKnowledge());
|
if (null != knowledgeCell) {
|
String stringCell = knowledgeCell.getStringCellValue();
|
if (StringUtils.isNotBlank(stringCell)) {
|
Arrays.stream(stringCell.split(" ")).forEach(d -> {
|
if (StringUtils.isNotBlank(d)) {
|
KnowledgePoint knowledgePoint = knowledgeService.getKnowledgePoint(d, subject.getId(), subject.getLevel());
|
if (null != knowledgePoint) {
|
knowledgePointId.add(knowledgePoint.getId());
|
}
|
}
|
});
|
}
|
}
|
|
List<QuestionEditItemVM> questionEditItemVMS = new ArrayList<>();
|
char prefix = 'A';
|
for (int j = questionImportCellIndex.getItemStart(); j < questionImportCellIndex.getItemEnd(); j++) {
|
XSSFCell cell = row.getCell(j);
|
if (null != cell) {
|
String value = cell.getStringCellValue();
|
if (!StringUtils.isBlank(value)) {
|
QuestionEditItemVM questionEditItemVM = new QuestionEditItemVM();
|
questionEditItemVM.setPrefix(String.valueOf(prefix));
|
questionEditItemVM.setContent(value);
|
questionEditItemVMS.add(questionEditItemVM);
|
prefix = (char) (((int) prefix) + 1);
|
}
|
}
|
}
|
if (questionEditItemVMS.size() < 1) {
|
writeError(row, cellStyle, errorIndex, "选项不能为空");
|
continue;
|
}
|
|
|
QuestionEditRequestVM questionEditRequestVM = new QuestionEditRequestVM();
|
questionEditRequestVM.setQuestionType(QuestionTypeEnum.SingleChoice.getCode());
|
|
questionEditRequestVM.setGradeLevel(level);
|
questionEditRequestVM.setSubjectId(subject.getId());
|
questionEditRequestVM.setTitle(title);
|
questionEditRequestVM.setAnalyze(analyze);
|
questionEditRequestVM.setScore(score);
|
questionEditRequestVM.setDifficult(Integer.parseInt(difficult));
|
questionEditRequestVM.setCorrect(correct);
|
questionEditRequestVM.setItems(questionEditItemVMS);
|
questionEditRequestVM.setKnowledgeIdList(knowledgePointId);
|
Question question = questionService.insertFullQuestion(questionEditRequestVM, user.getId());
|
row.createCell(questionImportCellIndex.getId()).setCellValue(question.getId());
|
} catch (Exception ex) {
|
writeError(row, cellStyle, errorIndex, ex.getMessage());
|
}
|
}
|
}
|
}
|
|
private void multipleChoice(XSSFSheet sheet, XSSFCellStyle cellStyle, User user, QuestionImportCellIndex questionImportCellIndex) {
|
if (null != sheet && sheet.getLastRowNum() >= 1) {
|
Integer errorIndex = 14;
|
for (int i = 1; i <= sheet.getLastRowNum(); i++) {
|
XSSFRow row = sheet.getRow(i);
|
try {
|
if (null != row.getCell(questionImportCellIndex.getId())) { //已经导入过
|
continue;
|
}
|
|
Integer level = user.getUserLevel();
|
if (null != questionImportCellIndex.getLevel()) {
|
level = levelCheck(row, cellStyle, questionImportCellIndex.getLevel(), errorIndex);
|
if (null == level) {
|
continue;
|
}
|
}
|
|
List<Subject> subjects = subjectService.getSubjectByLevel(level);
|
Subject subject = subjectCheck(row, cellStyle, questionImportCellIndex.getSubject(), subjects, errorIndex);
|
if (null == subject) {
|
continue;
|
}
|
String title = stringCheck(row, cellStyle, questionImportCellIndex.getTitle(), errorIndex, "题干不能为空");
|
if (null == title) {
|
continue;
|
}
|
String analyze = stringCheck(row, cellStyle, questionImportCellIndex.getAnalyze(), errorIndex, "解析不能为空");
|
if (null == analyze) {
|
continue;
|
}
|
String score = stringCheck(row, cellStyle, questionImportCellIndex.getScore(), errorIndex, "分数不能为空");
|
if (null == score) {
|
continue;
|
}
|
String difficult = stringCheck(row, cellStyle, questionImportCellIndex.getDifficult(), errorIndex, "难度不能为空");
|
if (null == difficult) {
|
continue;
|
}
|
|
List<Integer> knowledgePointId = new ArrayList<>();
|
XSSFCell knowledgeCell = row.getCell(questionImportCellIndex.getKnowledge());
|
if (null != knowledgeCell) {
|
String stringCell = knowledgeCell.getStringCellValue();
|
if (StringUtils.isNotBlank(stringCell)) {
|
Arrays.stream(stringCell.split(" ")).forEach(d -> {
|
if (StringUtils.isNotBlank(d)) {
|
KnowledgePoint knowledgePoint = knowledgeService.getKnowledgePoint(d, subject.getId(), subject.getLevel());
|
if (null != knowledgePoint) {
|
knowledgePointId.add(knowledgePoint.getId());
|
}
|
}
|
});
|
}
|
}
|
|
|
String correct = stringCheck(row, cellStyle, questionImportCellIndex.getCorrect(), errorIndex, "答案不能为空");
|
if (null == correct) {
|
continue;
|
}
|
List<String> correctArray = new ArrayList<>();
|
for (char item : correct.toCharArray()) {
|
correctArray.add(String.valueOf(item));
|
}
|
|
List<QuestionEditItemVM> questionEditItemVMS = new ArrayList<>();
|
char prefix = 'A';
|
for (int j = questionImportCellIndex.getItemStart(); j < questionImportCellIndex.getItemEnd(); j++) {
|
XSSFCell cell = row.getCell(j);
|
if (null != cell) {
|
String value = cell.getStringCellValue();
|
if (!StringUtils.isBlank(value)) {
|
QuestionEditItemVM questionEditItemVM = new QuestionEditItemVM();
|
questionEditItemVM.setPrefix(String.valueOf(prefix));
|
questionEditItemVM.setContent(value);
|
questionEditItemVMS.add(questionEditItemVM);
|
prefix = (char) (((int) prefix) + 1);
|
}
|
}
|
}
|
if (questionEditItemVMS.size() < 1) {
|
writeError(row, cellStyle, errorIndex, "选项不能为空");
|
continue;
|
}
|
QuestionEditRequestVM questionEditRequestVM = new QuestionEditRequestVM();
|
questionEditRequestVM.setQuestionType(QuestionTypeEnum.MultipleChoice.getCode());
|
questionEditRequestVM.setGradeLevel(level);
|
questionEditRequestVM.setSubjectId(subject.getId());
|
questionEditRequestVM.setTitle(title);
|
questionEditRequestVM.setAnalyze(analyze);
|
questionEditRequestVM.setScore(score);
|
questionEditRequestVM.setDifficult(Integer.parseInt(difficult));
|
questionEditRequestVM.setCorrect(correct);
|
questionEditRequestVM.setCorrectArray(correctArray);
|
questionEditRequestVM.setItems(questionEditItemVMS);
|
questionEditRequestVM.setKnowledgeIdList(knowledgePointId);
|
Question question = questionService.insertFullQuestion(questionEditRequestVM, user.getId());
|
row.createCell(questionImportCellIndex.getId()).setCellValue(question.getId());
|
} catch (Exception ex) {
|
writeError(row, cellStyle, errorIndex, ex.getMessage());
|
}
|
}
|
}
|
}
|
|
private void trueFalse(XSSFSheet sheet, XSSFCellStyle cellStyle, User user, QuestionImportCellIndex questionImportCellIndex) {
|
if (null != sheet && sheet.getLastRowNum() >= 1) {
|
Integer errorIndex = questionImportCellIndex.getError();
|
for (int i = 1; i <= sheet.getLastRowNum(); i++) {
|
XSSFRow row = sheet.getRow(i);
|
try {
|
if (null != row.getCell(questionImportCellIndex.getId())) { //已经导入过
|
continue;
|
}
|
|
Integer level = user.getUserLevel();
|
if (null != questionImportCellIndex.getLevel()) {
|
level = levelCheck(row, cellStyle, questionImportCellIndex.getLevel(), errorIndex);
|
if (null == level) {
|
continue;
|
}
|
}
|
|
List<Subject> subjects = subjectService.getSubjectByLevel(level);
|
Subject subject = subjectCheck(row, cellStyle, questionImportCellIndex.getSubject(), subjects, errorIndex);
|
if (null == subject) {
|
continue;
|
}
|
String title = stringCheck(row, cellStyle, questionImportCellIndex.getTitle(), errorIndex, "题干不能为空");
|
if (null == title) {
|
continue;
|
}
|
String analyze = stringCheck(row, cellStyle, questionImportCellIndex.getAnalyze(), errorIndex, "解析不能为空");
|
if (null == analyze) {
|
continue;
|
}
|
String score = stringCheck(row, cellStyle, questionImportCellIndex.getScore(), errorIndex, "分数不能为空");
|
if (null == score) {
|
continue;
|
}
|
String difficult = stringCheck(row, cellStyle, questionImportCellIndex.getDifficult(), errorIndex, "难度不能为空");
|
if (null == difficult) {
|
continue;
|
}
|
String correct = stringCheck(row, cellStyle, questionImportCellIndex.getCorrect(), errorIndex, "答案不能为空");
|
if (null == correct) {
|
continue;
|
}
|
|
List<Integer> knowledgePointId = new ArrayList<>();
|
XSSFCell knowledgeCell = row.getCell(questionImportCellIndex.getKnowledge());
|
if (null != knowledgeCell) {
|
String stringCell = knowledgeCell.getStringCellValue();
|
if (StringUtils.isNotBlank(stringCell)) {
|
Arrays.stream(stringCell.split(" ")).forEach(d -> {
|
if (StringUtils.isNotBlank(d)) {
|
KnowledgePoint knowledgePoint = knowledgeService.getKnowledgePoint(d, subject.getId(), subject.getLevel());
|
if (null != knowledgePoint) {
|
knowledgePointId.add(knowledgePoint.getId());
|
}
|
}
|
});
|
}
|
}
|
|
|
List<QuestionEditItemVM> questionEditItemVMS = new ArrayList<>();
|
char prefix = 'A';
|
for (int j = questionImportCellIndex.getItemStart(); j <= questionImportCellIndex.getItemEnd(); j++) {
|
XSSFCell cell = row.getCell(j);
|
if (null != cell) {
|
String value = cell.getStringCellValue();
|
if (!StringUtils.isBlank(value)) {
|
QuestionEditItemVM questionEditItemVM = new QuestionEditItemVM();
|
questionEditItemVM.setPrefix(String.valueOf(prefix));
|
questionEditItemVM.setContent(value);
|
questionEditItemVMS.add(questionEditItemVM);
|
prefix = (char) (((int) prefix) + 1);
|
}
|
}
|
}
|
if (questionEditItemVMS.size() < 1) {
|
writeError(row, cellStyle, errorIndex, "选项不能为空");
|
continue;
|
}
|
QuestionEditRequestVM questionEditRequestVM = new QuestionEditRequestVM();
|
questionEditRequestVM.setQuestionType(QuestionTypeEnum.TrueFalse.getCode());
|
questionEditRequestVM.setGradeLevel(level);
|
questionEditRequestVM.setSubjectId(subject.getId());
|
questionEditRequestVM.setTitle(title);
|
questionEditRequestVM.setAnalyze(analyze);
|
questionEditRequestVM.setScore(score);
|
questionEditRequestVM.setDifficult(Integer.parseInt(difficult));
|
questionEditRequestVM.setCorrect(correct);
|
questionEditRequestVM.setItems(questionEditItemVMS);
|
questionEditRequestVM.setKnowledgeIdList(knowledgePointId);
|
Question question = questionService.insertFullQuestion(questionEditRequestVM, user.getId());
|
row.createCell(questionImportCellIndex.getId()).setCellValue(question.getId());
|
} catch (Exception ex) {
|
writeError(row, cellStyle, errorIndex, ex.getMessage());
|
}
|
}
|
}
|
}
|
|
private void gapFilling(XSSFSheet sheet, XSSFCellStyle cellStyle, User user, QuestionImportCellIndex questionImportCellIndex) {
|
if (null != sheet && sheet.getLastRowNum() >= 1) {
|
Integer errorIndex = questionImportCellIndex.getError();
|
for (int i = 1; i <= sheet.getLastRowNum(); i++) {
|
XSSFRow row = sheet.getRow(i);
|
try {
|
if (null != row.getCell(questionImportCellIndex.getId())) { //已经导入过
|
continue;
|
}
|
|
Integer level = user.getUserLevel();
|
if (null != questionImportCellIndex.getLevel()) {
|
level = levelCheck(row, cellStyle, questionImportCellIndex.getLevel(), errorIndex);
|
if (null == level) {
|
continue;
|
}
|
}
|
|
List<Subject> subjects = subjectService.getSubjectByLevel(level);
|
Subject subject = subjectCheck(row, cellStyle, questionImportCellIndex.getSubject(), subjects, errorIndex);
|
if (null == subject) {
|
continue;
|
}
|
String title = stringCheck(row, cellStyle, questionImportCellIndex.getTitle(), errorIndex, "题干不能为空");
|
if (null == title) {
|
continue;
|
}
|
String analyze = stringCheck(row, cellStyle, questionImportCellIndex.getAnalyze(), errorIndex, "解析不能为空");
|
if (null == analyze) {
|
continue;
|
}
|
String score = stringCheck(row, cellStyle, questionImportCellIndex.getScore(), errorIndex, "分数不能为空");
|
if (null == score) {
|
continue;
|
}
|
String difficult = stringCheck(row, cellStyle, questionImportCellIndex.getDifficult(), errorIndex, "难度不能为空");
|
if (null == difficult) {
|
continue;
|
}
|
|
List<Integer> knowledgePointId = new ArrayList<>();
|
XSSFCell knowledgeCell = row.getCell(questionImportCellIndex.getKnowledge());
|
if (null != knowledgeCell) {
|
String stringCell = knowledgeCell.getStringCellValue();
|
if (StringUtils.isNotBlank(stringCell)) {
|
Arrays.stream(stringCell.split(" ")).forEach(d -> {
|
if (StringUtils.isNotBlank(d)) {
|
KnowledgePoint knowledgePoint = knowledgeService.getKnowledgePoint(d, subject.getId(), subject.getLevel());
|
if (null != knowledgePoint) {
|
knowledgePointId.add(knowledgePoint.getId());
|
}
|
}
|
});
|
}
|
}
|
|
List<QuestionEditItemVM> questionEditItemVMS = new ArrayList<>();
|
StringBuilder stringBuilder = new StringBuilder(title);
|
Pattern pattern = Pattern.compile("\\$.*?\\$");
|
Matcher matcher = pattern.matcher(stringBuilder);
|
Integer index = 0;
|
while (matcher.find()) {
|
++index;
|
String grapFormat = String.format("<span class=\"gapfilling-span %s\">%d</span>", UUID.randomUUID().toString(), index);
|
stringBuilder = stringBuilder.replace(matcher.start(), matcher.end(), grapFormat);
|
matcher = pattern.matcher(stringBuilder);
|
|
String stringCell = row.getCell(questionImportCellIndex.getItemStart() + index).getStringCellValue();
|
QuestionEditItemVM questionEditItemVM = new QuestionEditItemVM();
|
questionEditItemVM.setPrefix(index.toString());
|
questionEditItemVM.setScore(score);
|
questionEditItemVM.setContent(stringCell);
|
questionEditItemVMS.add(questionEditItemVM);
|
}
|
if (questionEditItemVMS.size() < 1) {
|
writeError(row, cellStyle, errorIndex, "空答案不能为空");
|
continue;
|
}
|
|
String qScore = ExamUtil.scoreToVM(ExamUtil.scoreFromVM(score) * questionEditItemVMS.size());
|
QuestionEditRequestVM questionEditRequestVM = new QuestionEditRequestVM();
|
questionEditRequestVM.setQuestionType(QuestionTypeEnum.GapFilling.getCode());
|
questionEditRequestVM.setGradeLevel(level);
|
questionEditRequestVM.setSubjectId(subject.getId());
|
questionEditRequestVM.setTitle(stringBuilder.toString());
|
questionEditRequestVM.setAnalyze(analyze);
|
questionEditRequestVM.setScore(qScore);
|
questionEditRequestVM.setDifficult(Integer.parseInt(difficult));
|
questionEditRequestVM.setItems(questionEditItemVMS);
|
questionEditRequestVM.setKnowledgeIdList(knowledgePointId);
|
Question question = questionService.insertFullQuestion(questionEditRequestVM, user.getId());
|
row.createCell(questionImportCellIndex.getId()).setCellValue(question.getId());
|
} catch (Exception ex) {
|
writeError(row, cellStyle, errorIndex, ex.getMessage());
|
}
|
}
|
}
|
}
|
|
private void shortAnswer(XSSFSheet sheet, XSSFCellStyle cellStyle, User user, QuestionImportCellIndex questionImportCellIndex) {
|
if (null != sheet && sheet.getLastRowNum() >= 1) {
|
Integer errorIndex = questionImportCellIndex.getError();
|
for (int i = 1; i <= sheet.getLastRowNum(); i++) {
|
XSSFRow row = sheet.getRow(i);
|
try {
|
if (null != row.getCell(questionImportCellIndex.getId())) { //已经导入过
|
continue;
|
}
|
|
Integer level = user.getUserLevel();
|
if (null != questionImportCellIndex.getLevel()) {
|
level = levelCheck(row, cellStyle, questionImportCellIndex.getLevel(), errorIndex);
|
if (null == level) {
|
continue;
|
}
|
}
|
|
List<Subject> subjects = subjectService.getSubjectByLevel(level);
|
Subject subject = subjectCheck(row, cellStyle, questionImportCellIndex.getSubject(), subjects, errorIndex);
|
if (null == subject) {
|
continue;
|
}
|
String title = stringCheck(row, cellStyle, questionImportCellIndex.getTitle(), errorIndex, "题干不能为空");
|
if (null == title) {
|
continue;
|
}
|
|
String correct = stringCheck(row, cellStyle, questionImportCellIndex.getCorrect(), errorIndex, "答案不能为空");
|
if (null == correct) {
|
continue;
|
}
|
|
String analyze = stringCheck(row, cellStyle, questionImportCellIndex.getAnalyze(), errorIndex, "解析不能为空");
|
if (null == analyze) {
|
continue;
|
}
|
String score = stringCheck(row, cellStyle, questionImportCellIndex.getScore(), errorIndex, "分数不能为空");
|
if (null == score) {
|
continue;
|
}
|
String difficult = stringCheck(row, cellStyle, questionImportCellIndex.getDifficult(), errorIndex, "难度不能为空");
|
if (null == difficult) {
|
continue;
|
}
|
|
List<Integer> knowledgePointId = new ArrayList<>();
|
XSSFCell knowledgeCell = row.getCell(questionImportCellIndex.getKnowledge());
|
if (null != knowledgeCell) {
|
String stringCell = knowledgeCell.getStringCellValue();
|
if (StringUtils.isNotBlank(stringCell)) {
|
Arrays.stream(stringCell.split(" ")).forEach(d -> {
|
if (StringUtils.isNotBlank(d)) {
|
KnowledgePoint knowledgePoint = knowledgeService.getKnowledgePoint(d, subject.getId(), subject.getLevel());
|
if (null != knowledgePoint) {
|
knowledgePointId.add(knowledgePoint.getId());
|
}
|
}
|
});
|
}
|
}
|
|
QuestionEditRequestVM questionEditRequestVM = new QuestionEditRequestVM();
|
questionEditRequestVM.setQuestionType(QuestionTypeEnum.ShortAnswer.getCode());
|
questionEditRequestVM.setGradeLevel(level);
|
questionEditRequestVM.setSubjectId(subject.getId());
|
questionEditRequestVM.setTitle(title);
|
questionEditRequestVM.setCorrect(correct);
|
questionEditRequestVM.setAnalyze(analyze);
|
questionEditRequestVM.setScore(score);
|
questionEditRequestVM.setDifficult(Integer.parseInt(difficult));
|
questionEditRequestVM.setItems(new ArrayList<>());
|
questionEditRequestVM.setKnowledgeIdList(knowledgePointId);
|
Question question = questionService.insertFullQuestion(questionEditRequestVM, user.getId());
|
row.createCell(questionImportCellIndex.getId()).setCellValue(question.getId());
|
} catch (Exception ex) {
|
writeError(row, cellStyle, errorIndex, ex.getMessage());
|
}
|
}
|
}
|
}
|
|
|
private Integer levelCheck(XSSFRow row, XSSFCellStyle cellStyle, Integer cellIndex, Integer errorIndex) {
|
List<Department> list = departmentService.gets();
|
Dict levelHash = Dict.create();
|
for (Department department : list) {
|
levelHash.set(department.getName(), department.getId());
|
}
|
// Dict levelHash = Dict.create().set("一年级", 1).set("二年级", 2).set("三年级", 3).set("四年级", 4).set("五年级", 5).set("六年级", 6).set("初一", 7).set("初二", 8).set("初三", 9).set("高一", 10).set("高二", 11).set("高三", 12);
|
String levelName = stringCheck(row, cellStyle, cellIndex, errorIndex, "年级不能为空");
|
if (null == levelName) {
|
return null;
|
}
|
|
Integer level = levelHash.getInt(levelName);
|
if (null == level) {
|
writeError(row, cellStyle, errorIndex, "年级未找到");
|
return null;
|
}
|
return level;
|
}
|
|
private Subject subjectCheck(XSSFRow row, XSSFCellStyle cellStyle, Integer cellIndex, List<Subject> subjects, Integer errorIndex) {
|
String subjectName = stringCheck(row, cellStyle, cellIndex, errorIndex, "学科不能为空");
|
if (null == subjectName) {
|
return null;
|
}
|
Subject subject = subjects.stream().filter(d -> d.getName().equals(subjectName)).findFirst().orElse(null);
|
if (null == subject) {
|
writeError(row, cellStyle, errorIndex, "学科未找到");
|
return null;
|
}
|
return subject;
|
}
|
|
|
private String stringCheck(XSSFRow row, XSSFCellStyle cellStyle, Integer cellIndex, Integer errorIndex, String errorMsg) {
|
row.getCell(cellIndex).setCellType(CellType.STRING);
|
String stringCell = row.getCell(cellIndex).getStringCellValue();
|
if (StringUtils.isBlank(stringCell)) {
|
writeError(row, cellStyle, errorIndex, errorMsg);
|
return null;
|
}
|
return stringCell;
|
}
|
|
private void writeError(XSSFRow row, XSSFCellStyle cellStyle, Integer errorIndex, String errorMsg) {
|
XSSFCell xssfCell = row.createCell(errorIndex);
|
xssfCell.setCellStyle(cellStyle);
|
xssfCell.setCellValue(errorMsg);
|
}
|
|
}
|
