package com.ots.project.exam.service.impl;
|
import cn.hutool.core.collection.CollUtil;
|
import com.alibaba.fastjson.JSON;
|
import com.github.pagehelper.PageInfo;
|
import com.ots.common.utils.StringUtils;
|
import com.ots.common.utils.bean.BeanUtils;
|
import com.ots.project.exam.domain.ExamPaper;
|
import com.ots.project.exam.domain.ExamUser;
|
import com.ots.project.exam.domain.TExamPaper;
|
import com.ots.project.exam.domain.TExamReport;
|
import com.ots.project.exam.domain.TQuestion;
|
import com.ots.project.exam.domain.TTextContent;
|
import com.ots.project.exam.dto.ExamPaperTitleItemObject;
|
import com.ots.project.exam.dto.PaperFilter;
|
import com.ots.project.exam.dto.PaperInfo;
|
import com.ots.project.exam.dto.QuestionPart;
|
import com.ots.project.exam.dto.QuestionReport;
|
import com.ots.project.exam.dto.RelatedParty;
|
import com.ots.project.exam.mapper.ExamPaperMapper;
|
import com.ots.project.exam.mapper.TQuestionMapper;
|
import com.ots.project.exam.service.IExamPaperService;
|
import com.ots.project.exam.service.ITExamPaperService;
|
import com.ots.project.exam.service.ITExamReportService;
|
import com.ots.project.exam.service.ITQuestionService;
|
import com.ots.project.exam.service.ITTextContentService;
|
import com.ots.project.exam.viewmodel.ExamPaperEditRequestVM;
|
import com.ots.project.exam.viewmodel.ExamPaperPageRequestVM;
|
import com.ots.project.exam.viewmodel.ExamPaperPageVM;
|
import com.ots.project.exam.viewmodel.ExamPaperTitleItemVM;
|
import com.ots.project.exam.viewmodel.QuestionEditItemVM;
|
import com.ots.project.exam.viewmodel.QuestionEditRequestVM;
|
import com.ots.project.tool.exam.ExamUtil;
|
import com.ots.project.tool.exam.JsonUtil;
|
import com.ots.project.tool.exam.ModelMapperSingle;
|
import com.ots.project.tool.gen.service.IExamUtilService;
|
import org.modelmapper.ModelMapper;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
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
|
public class ExamPaperServiceImpl implements IExamPaperService {
|
protected final static ModelMapper modelMapper = ModelMapperSingle.Instance();
|
@Autowired
|
private ExamPaperMapper examPaperMapper;
|
@Autowired
|
private ITTextContentService textContentService;
|
@Autowired
|
private TQuestionMapper questionMapper;
|
@Autowired
|
private ITQuestionService questionService;
|
@Autowired
|
private ITExamReportService examReportService;
|
@Autowired
|
private IExamUtilService examUtilService;
|
@Autowired
|
private ITExamPaperService itExamPaperService;
|
@Override
|
public List<PaperInfo> indexPaper(PaperFilter paperFilter) {
|
return examPaperMapper.indexPaper(paperFilter);
|
}
|
@Override
|
public PageInfo<ExamPaper> page(ExamPaperPageRequestVM requestVM) {
|
return null;
|
}
|
@Override
|
public PageInfo<ExamPaper> taskExamPage(ExamPaperPageRequestVM requestVM) {
|
return null;
|
}
|
@Override
|
public PageInfo<ExamPaper> studentPage(ExamPaperPageVM requestVM) {
|
return null;
|
}
|
@Override
|
public ExamPaper savePaperFromVM(ExamPaperEditRequestVM examPaperEditRequestVM, ExamUser user) {
|
return null;
|
}
|
|
@Override
|
public ExamPaperEditRequestVM examPaperToVM(Integer id, String tokenId, String langType) {
|
TExamPaper tExamPaper = itExamPaperService.selectTExamPaperById(id.longValue());
|
tExamPaper.setLangType(langType);
|
ExamPaperEditRequestVM vm = modelMapper.map(tExamPaper, ExamPaperEditRequestVM.class);
|
|
List<ExamPaperTitleItemVM> examPaperTitleItemVMS = resolveToQuestion(tExamPaper, vm);
|
|
setQuestionOrder(examPaperTitleItemVMS);
|
|
setRandomQuestionOrderAndReport(tokenId, vm, examPaperTitleItemVMS);
|
|
vm.setParts(examPaperTitleItemVMS.get(0).getParts());
|
|
multilingualTranslation(langType, vm);
|
|
return vm;
|
}
|
@Override
|
public ExamPaperEditRequestVM examPaperToVM(RelatedParty relatedParty, String token_id, String langType) {
|
ExamPaperEditRequestVM vm = examPaperToVM(relatedParty.getProdId().intValue(), token_id, langType);
|
setExtraReturnValue(relatedParty, vm);
|
return vm;
|
}
|
private void setExtraReturnValue(RelatedParty relatedParty, ExamPaperEditRequestVM vm) {
|
vm.setQuestionTemplateId(relatedParty.getQuestionTemplateId());
|
vm.setReportTemplateId(relatedParty.getReportTemplateId());
|
TExamReport tExamReport = new TExamReport();
|
tExamReport.setMemberId(relatedParty.getMemberId().intValue());
|
String demographicName = examReportService.getDemographicName(tExamReport);
|
if (StringUtils.isNotEmpty(demographicName)) {
|
vm.setMemberName(demographicName);
|
} else {
|
vm.setMemberName(relatedParty.getMemberName());
|
}
|
}
|
private void setRandomQuestionOrderAndReport(String tokenId, ExamPaperEditRequestVM vm, List<ExamPaperTitleItemVM> examPaperTitleItemVMS) {
|
List<Integer> intList = new ArrayList<>();
|
|
vm.setTitleItems(randomQuestion(examPaperTitleItemVMS, intList, tokenId,vm));
|
|
vm.setQuestionOrder(intList);
|
}
|
private void setQuestionOrder(List<ExamPaperTitleItemVM> examPaperTitleItemVMS) {
|
int questionOrederNum = 0;
|
int questionItemQONum = 0;
|
for (ExamPaperTitleItemVM examPaperTitleItemVM : examPaperTitleItemVMS) {
|
examPaperTitleItemVM.setQuestionOrder(questionOrederNum++);
|
for (QuestionEditRequestVM questionEditRequestVM : examPaperTitleItemVM.getQuestionItems()) {
|
questionEditRequestVM.setQuestionOrder(questionItemQONum++);
|
}
|
}
|
}
|
|
private List<ExamPaperTitleItemVM> resolveToQuestion(TExamPaper examPaper, ExamPaperEditRequestVM vm) {
|
vm.setLevel(examPaper.getGradeLevel().intValue());
|
TTextContent frameTextContent = textContentService.selectTTextContentById(examPaper.getFrameTextContentId().longValue());
|
List<ExamPaperTitleItemObject> examPaperTitleItemObjects = JsonUtil.toJsonListObject(frameTextContent.getContent(), ExamPaperTitleItemObject.class);
|
|
TExamPaper tExamPaper = new TExamPaper();
|
BeanUtils.copyProperties(examPaper, tExamPaper);
|
examUtilService.setTitleName(tExamPaper, examPaperTitleItemObjects);
|
List<Integer> questionIds = examPaperTitleItemObjects.stream()
|
.flatMap(t -> t.getQuestionItems().stream()
|
.map(q -> q.getId()))
|
.collect(Collectors.toList());
|
List<TQuestion> questions = questionMapper.selectByIds(questionIds);
|
|
return examPaperTitleItemObjects.stream().map(t -> {
|
ExamPaperTitleItemVM tTitleVM = modelMapper.map(t, ExamPaperTitleItemVM.class);
|
|
tTitleVM.setPermanentId(t.getPermanentId());
|
|
List<QuestionEditRequestVM> questionItemsVM = t.getQuestionItems().stream().map(i -> {
|
try {
|
TQuestion question = questions.stream().filter(q -> q.getId().equals(i.getId().longValue())).findFirst().get();
|
QuestionEditRequestVM questionEditRequestVM = questionService.getQuestionEditRequestVM(question);
|
questionEditRequestVM.setItemOrder(i.getItemOrder());
|
|
if (Objects.isNull(question.getPermanentId())) {
|
question.setPermanentId(i.getPermanentId());
|
}
|
questionEditRequestVM.setPermanentId(question.getPermanentId());
|
questionEditRequestVM.setPartOrder(i.getPartOrder());
|
questionEditRequestVM.setParentQuestionId(i.getParentQuestionId());
|
questionEditRequestVM.setTemplate(i.getTemplate());
|
return questionEditRequestVM;
|
} catch (Exception e) {
|
System.out.println(e.getMessage());
|
System.out.println("题目选项异常");
|
}
|
return null;
|
}).filter(qs -> !Objects.isNull(qs)).collect(Collectors.toList());
|
tTitleVM.setQuestionItems(questionItemsVM);
|
tTitleVM.setParts(t.getParts());
|
return tTitleVM;
|
}).collect(Collectors.toList());
|
}
|
|
private void multilingualTranslation(String langType, ExamPaperEditRequestVM vm) {
|
vm.setName(ExamUtil.getLangString(langType, vm.getName()));
|
vm.setGuide(ExamUtil.getLangString(langType, vm.getGuide()));
|
for (ExamPaperTitleItemVM titleItemVM : vm.getTitleItems()) {
|
titleItemVM.setName(ExamUtil.getLangString(langType, titleItemVM.getName()));
|
titleItemVM.setGuide(ExamUtil.getLangString(langType, titleItemVM.getGuide()));
|
titleItemVM.setDescription(ExamUtil.getLangString(langType, titleItemVM.getDescription()));
|
for (QuestionEditRequestVM questionEditItemVM : titleItemVM.getQuestionItems()) {
|
questionEditItemVM.setTitle(ExamUtil.getLangString(langType, questionEditItemVM.getTitle()));
|
for (QuestionEditItemVM questionEditItem : questionEditItemVM.getItems()) {
|
questionEditItem.setContent(ExamUtil.getLangString(langType, questionEditItem.getContent()));
|
}
|
}
|
}
|
|
if (CollUtil.isEmpty(vm.getParts())) {
|
return;
|
}
|
vm.getParts().stream().forEach(questionPart -> {
|
questionPart.getSignals().stream().forEach(signalObject -> {
|
signalObject.setSignalDescription(ExamUtil.getLangString(langType, signalObject.getSignalDescription()));
|
});
|
});
|
}
|
private List<ExamPaperTitleItemVM> randomQuestion(List<ExamPaperTitleItemVM> examPaperTitleItemVMS, List<Integer> intList, String tokenId, ExamPaperEditRequestVM vm) {
|
|
if (Objects.isNull(examPaperTitleItemVMS) || examPaperTitleItemVMS.isEmpty()) {
|
return examPaperTitleItemVMS;
|
}
|
|
if (Objects.equals(vm.getQuestionTemplateId(), "personality")) {
|
return getExamOnePaperTitleItemVMS(examPaperTitleItemVMS, intList, tokenId);
|
} else if (Objects.equals(vm.getQuestionTemplateId(), "intelligence")) {
|
return getExamPaperIntelligenceQeustionVMS(examPaperTitleItemVMS, intList, tokenId, vm);
|
} else {
|
|
return getExamJobPaperTitleItemVMS(examPaperTitleItemVMS, intList, tokenId);
|
}
|
}
|
private List<ExamPaperTitleItemVM> getExamOnePaperTitleItemVMS(List<ExamPaperTitleItemVM> examPaperTitleItemVMS, List<Integer> intList, String tokenId) {
|
|
TExamReport tExamReportQuery = new TExamReport();
|
tExamReportQuery.setTokenId(tokenId);
|
List<QuestionEditRequestVM> questionItems = examPaperTitleItemVMS.get(0).getQuestionItems();
|
|
List<TExamReport> tExamReportList = examReportService.selectTExamReportList(tExamReportQuery);
|
if (Objects.nonNull(tExamReportList) && tExamReportList.size() > 0) {
|
TExamReport tExamReport = tExamReportList.get(0);
|
intList = JSON.parseObject(tExamReport.getQuestionOrder(), ArrayList.class);
|
} else {
|
setSubscript(intList, questionItems);
|
}
|
List<QuestionEditRequestVM> questionItemsNew = new ArrayList<>();
|
for (int i = 0; i < intList.size(); i++) {
|
questionItemsNew.add(questionItems.get(intList.get(i)));
|
}
|
|
for (int i = 0; i < questionItemsNew.size(); i++) {
|
questionItemsNew.get(i).setItemOrder(i+1);
|
|
setQuestionReportForVM(tExamReportList, questionItemsNew.get(i));
|
}
|
examPaperTitleItemVMS.get(0).setQuestionItems(questionItemsNew);
|
return examPaperTitleItemVMS;
|
}
|
private List<ExamPaperTitleItemVM> getExamPaperIntelligenceQeustionVMS(List<ExamPaperTitleItemVM> examPaperTitleItemVMS, List<Integer> intList, String tokenId, ExamPaperEditRequestVM vm) {
|
|
TExamReport tExamReportQuery = new TExamReport();
|
tExamReportQuery.setTokenId(tokenId);
|
List<TExamReport> tExamReportList = examReportService.selectTExamReportList(tExamReportQuery);
|
|
|
List<QuestionEditRequestVM> questionItemsResulte = new ArrayList<>();
|
if (Objects.nonNull(tExamReportList) && tExamReportList.size() > 0) {
|
questionItemsResulte = getIntelligenceQuestionOrder(examPaperTitleItemVMS, tExamReportList, vm);
|
} else {
|
initializeIntelligenceQuestion(examPaperTitleItemVMS, intList, questionItemsResulte, vm);
|
}
|
|
calculationNumber(tExamReportList, questionItemsResulte);
|
examPaperTitleItemVMS.get(0).setQuestionItems(questionItemsResulte);
|
return examPaperTitleItemVMS;
|
}
|
private List<QuestionEditRequestVM> getIntelligenceQuestionOrder(List<ExamPaperTitleItemVM> examPaperTitleItemVMS, List<TExamReport> tExamReportList, ExamPaperEditRequestVM vm) {
|
TExamReport tExamReport = tExamReportList.get(0);
|
List<Integer> intList = JSON.parseObject(tExamReport.getQuestionOrder(), ArrayList.class);
|
List<List<String>> optionIntList = JsonUtil.parseObject(tExamReport.getOptionOrder(), ArrayList.class);
|
List<QuestionEditRequestVM> questionItems = examPaperTitleItemVMS.get(0).getQuestionItems();
|
List<QuestionEditRequestVM> questionItemsResulte = new ArrayList<>();
|
for (int i = 0; i < intList.size(); i++) {
|
int order = intList.get(i);
|
|
Map<String, QuestionEditItemVM> itemsMap = new HashMap<>();
|
List<QuestionEditItemVM> items = questionItems.get(order).getItems();
|
items.stream().forEach(item-> itemsMap.put(item.getPrefix(), item));
|
|
List<String> itemList = optionIntList.get(i);
|
|
List<QuestionEditItemVM> itemsResult = itemList.stream().map(num -> {
|
return itemsMap.get(num);
|
}).collect(Collectors.toList());
|
questionItems.get(order).setItems(itemsResult);
|
questionItemsResulte.add(questionItems.get(order));
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
vm.setOptionOrder(optionIntList);
|
return questionItemsResulte;
|
}
|
private void calculationNumber(List<TExamReport> tExamReportList, List<QuestionEditRequestVM> questionItemsResulte) {
|
Integer intelligenceTitleNum = 0;
|
Integer intelligenceNum = 0;
|
|
Integer itemSize = 0;
|
for (QuestionEditRequestVM questionEditRequestVM : questionItemsResulte) {
|
if (StringUtils.isEmpty(questionEditRequestVM.getParentQuestionId())) {
|
itemSize++;
|
}
|
}
|
|
Map<Integer, Integer> partSizeMap = new HashMap<>();
|
for (QuestionEditRequestVM questionEditRequestVM : questionItemsResulte) {
|
if (StringUtils.isNotEmpty(questionEditRequestVM.getParentQuestionId())) {
|
continue;
|
}
|
Integer partOrder = questionEditRequestVM.getPartOrder();
|
if (Objects.nonNull(partSizeMap.get(partOrder))) {
|
partSizeMap.put(partOrder, partSizeMap.get(partOrder) + 1);
|
} else {
|
partSizeMap.put(partOrder, 1);
|
}
|
}
|
Integer partOrder = 0;
|
for (Integer i = 0; i < questionItemsResulte.size(); i++) {
|
QuestionEditRequestVM questionEditRequestVM = questionItemsResulte.get(i);
|
|
if (!Objects.equals(partOrder, questionEditRequestVM.getPartOrder())) {
|
partOrder = questionEditRequestVM.getPartOrder();
|
intelligenceTitleNum = 0;
|
}
|
questionEditRequestVM.setItemOrder(i + 1);
|
|
setQuestionReportForVM(tExamReportList, questionEditRequestVM);
|
|
if (Objects.equals(questionEditRequestVM.getTemplate(), "intelligence_title")) {
|
questionEditRequestVM.setQuestionNumber(String.valueOf(++intelligenceTitleNum) + "/" + partSizeMap.get(questionEditRequestVM.getPartOrder()).toString());
|
intelligenceNum = 0;
|
} else if (StringUtils.isEmpty(questionEditRequestVM.getParentQuestionId())) {
|
questionEditRequestVM.setQuestionNumber(String.valueOf(++intelligenceTitleNum) + "/" + partSizeMap.get(questionEditRequestVM.getPartOrder()).toString());
|
} else {
|
questionEditRequestVM.setQuestionNumber("(" + ++intelligenceNum + ")");
|
}
|
}
|
}
|
private void initializeIntelligenceQuestion(List<ExamPaperTitleItemVM> examPaperTitleItemVMS, List<Integer> intList, List<QuestionEditRequestVM> questionItemsResulte, ExamPaperEditRequestVM vm) {
|
|
List<QuestionEditRequestVM> questionItems = examPaperTitleItemVMS.get(0).getQuestionItems();
|
|
|
Map<Integer, List<QuestionEditRequestVM>> questionEditRequestVMSMap = getPartOrderQuestionMap(examPaperTitleItemVMS, questionItems);
|
|
Map<String, List<QuestionEditRequestVM>> parentQuestionIdMap = getParentQuestionIdMap(questionItems);
|
|
for (Map.Entry<String, List<QuestionEditRequestVM>> entry : parentQuestionIdMap.entrySet()) {
|
entry.setValue(getQuestionEditRequestRandVMS(entry.getValue()));
|
}
|
for (Map.Entry<Integer, List<QuestionEditRequestVM>> entry : questionEditRequestVMSMap.entrySet()) {
|
|
getIntelligenceTitleResult(entry.getValue(), parentQuestionIdMap, questionItemsResulte);
|
|
getintelligenceResult(entry.getValue(), questionItemsResulte);
|
}
|
|
vm.setOptionOrder(new ArrayList<>());
|
for (QuestionEditRequestVM questionEditRequestVM : questionItemsResulte) {
|
intList.add(questionEditRequestVM.getQuestionOrder());
|
List<QuestionEditItemVM> items = questionEditRequestVM.getItems();
|
List<String> prfixList = new ArrayList<>();
|
for (QuestionEditItemVM questionEditItemVM : items) {
|
prfixList.add(questionEditItemVM.getPrefix());
|
}
|
vm.getOptionOrder().add(prfixList);
|
}
|
}
|
private void getintelligenceResult(List<QuestionEditRequestVM> questionItems, List<QuestionEditRequestVM> questionItemsResult) {
|
List<QuestionEditRequestVM> intelligenceList = questionItems.stream().filter((QuestionEditRequestVM questionEditRequestVM) -> Objects.equals(questionEditRequestVM.getTemplate(), "intelligence") && StringUtils.isEmpty(questionEditRequestVM.getParentQuestionId())).collect(Collectors.toList());
|
intelligenceList = getQuestionEditRequestRandVMS(intelligenceList);
|
questionItemsResult.addAll(intelligenceList);
|
}
|
private void getIntelligenceTitleResult(List<QuestionEditRequestVM> questionItems, Map<String, List<QuestionEditRequestVM>> parentQuestionIdMap, List<QuestionEditRequestVM> questionItemsResult) {
|
|
List<QuestionEditRequestVM> intelligenceTitleList = questionItems.stream().filter((QuestionEditRequestVM questionEditRequestVM) -> Objects.equals(questionEditRequestVM.getTemplate(), "intelligence_title")).collect(Collectors.toList());
|
intelligenceTitleList = getQuestionEditRequestRandVMS(intelligenceTitleList);
|
|
List<QuestionEditRequestVM> intelligenceTitleResultList = new ArrayList<>();
|
for (QuestionEditRequestVM questionEditRequestVM : intelligenceTitleList) {
|
intelligenceTitleResultList.add(questionEditRequestVM);
|
intelligenceTitleResultList.addAll(parentQuestionIdMap.get(questionEditRequestVM.getId().toString()));
|
}
|
questionItemsResult.addAll(intelligenceTitleResultList);
|
}
|
private Map<String, List<QuestionEditRequestVM>> getParentQuestionIdMap(List<QuestionEditRequestVM> questionItems) {
|
Map<String, List<QuestionEditRequestVM>> parentQuestionIdMap = questionItems.stream().collect(Collectors.groupingBy(QuestionEditRequestVM::getParentQuestionId));
|
parentQuestionIdMap.remove("");
|
return parentQuestionIdMap;
|
}
|
private Map<Integer, List<QuestionEditRequestVM>> getPartOrderQuestionMap(List<ExamPaperTitleItemVM> examPaperTitleItemVMS, List<QuestionEditRequestVM> questionItems) {
|
List<QuestionPart> parts = examPaperTitleItemVMS.get(0).getParts();
|
|
Map<Integer, List<QuestionEditRequestVM>> questionEditRequestVMSMap = new LinkedHashMap<>();
|
for (QuestionPart questionPart : parts) {
|
|
getPartintelligenceAndTitleMap(questionItems, questionEditRequestVMSMap, questionPart);
|
}
|
return questionEditRequestVMSMap;
|
}
|
|
private List<QuestionEditRequestVM> getQuestionEditRequestRandVMS(List<QuestionEditRequestVM> questionEditRequestVM) {
|
List<Integer> randList = new ArrayList<>();
|
for (int i = 0; i < questionEditRequestVM.size(); i++) {
|
randList.add(i);
|
}
|
Collections.shuffle(randList);
|
List<QuestionEditRequestVM> intelligenceTitleListResult = new ArrayList<>();
|
for (int i : randList) {
|
|
QuestionEditRequestVM questionEditRequestVMResult = questionEditRequestVM.get(i);
|
|
setRandQuestionItems( questionEditRequestVMResult);
|
intelligenceTitleListResult.add(questionEditRequestVMResult);
|
}
|
questionEditRequestVM = intelligenceTitleListResult;
|
return questionEditRequestVM;
|
}
|
private void setRandQuestionItems( QuestionEditRequestVM questionEditRequestVMDTO) {
|
List<QuestionEditItemVM> items = questionEditRequestVMDTO.getItems();
|
List<Integer> randItemList = new ArrayList<>();
|
if (ExamUtil.isListNotEmpty(items)) {
|
List<QuestionEditItemVM> itemsResult = new ArrayList<>();
|
for (int j = 0; j < items.size(); j++) {
|
randItemList.add(j);
|
}
|
Collections.shuffle(randItemList);
|
for (int k : randItemList) {
|
itemsResult.add(items.get(k));
|
}
|
questionEditRequestVMDTO.setItems(itemsResult);
|
}
|
}
|
private void getPartintelligenceAndTitleMap(List<QuestionEditRequestVM> intelligenceAndTitleList, Map<Integer, List<QuestionEditRequestVM>> questionEditRequestVMSMap, QuestionPart questionPart) {
|
Integer partOrder = questionPart.getPartOrder();
|
List<QuestionEditRequestVM> questionEditRequestListVMS = new ArrayList<>();
|
for (QuestionEditRequestVM questionEditRequestVM : intelligenceAndTitleList) {
|
if (Objects.equals(questionEditRequestVM.getPartOrder(), partOrder)) {
|
questionEditRequestListVMS.add(questionEditRequestVM);
|
}
|
}
|
questionEditRequestVMSMap.put(partOrder, questionEditRequestListVMS);
|
}
|
|
private void setSubscript(List<Integer> intList, List<QuestionEditRequestVM> questionItems) {
|
|
if (Objects.nonNull(questionItems.get(0).getPartOrder()) && questionItems.get(0).getPartOrder() != 0) {
|
int partOrder = questionItems.get(0).getPartOrder();
|
List<Integer> partOrderList = new ArrayList<>();
|
for (int i = 0; i < questionItems.size(); i++) {
|
if (partOrder == questionItems.get(i).getPartOrder()) {
|
partOrderList.add(i);
|
} else {
|
Collections.shuffle(partOrderList);
|
for (int partOrderTemp : partOrderList) {
|
intList.add(partOrderTemp);
|
}
|
partOrderList.clear();
|
partOrder = questionItems.get(i).getPartOrder();
|
partOrderList.add(i);
|
}
|
}
|
|
Collections.shuffle(partOrderList);
|
for (int partOrderTemp : partOrderList) {
|
intList.add(partOrderTemp);
|
}
|
} else {
|
for (int i = 0; i < questionItems.size(); i++) {
|
intList.add(i);
|
}
|
|
Collections.shuffle(intList);
|
}
|
}
|
private List<ExamPaperTitleItemVM> getExamJobPaperTitleItemVMS(List<ExamPaperTitleItemVM> examPaperTitleItemVMS, List<Integer> intList, String tokenId) {
|
|
TExamReport tExamReportQuery = new TExamReport();
|
tExamReportQuery.setTokenId(tokenId);
|
List<TExamReport> tExamReportList = examReportService.selectTExamReportList(tExamReportQuery);
|
if (Objects.nonNull(tExamReportList) && tExamReportList.size() > 0) {
|
TExamReport tExamReport = tExamReportList.get(0);
|
intList = JSON.parseObject(tExamReport.getQuestionOrder(), ArrayList.class);
|
} else {
|
|
for (int i = 0; i < examPaperTitleItemVMS.size(); i++) {
|
intList.add(i);
|
}
|
|
Collections.shuffle(intList);
|
}
|
List<ExamPaperTitleItemVM> examPaperTitleItemVMSRandoms = new ArrayList<ExamPaperTitleItemVM>();
|
int itemOrder = 0;
|
for (int i = 0; i < intList.size(); i++) {
|
examPaperTitleItemVMSRandoms.add(examPaperTitleItemVMS.get(intList.get(i)));
|
}
|
|
for (ExamPaperTitleItemVM examPaperTitleItemVM : examPaperTitleItemVMSRandoms) {
|
List<QuestionEditRequestVM> questionItems = examPaperTitleItemVM.getQuestionItems();
|
int suffixIndex = 97;
|
for (QuestionEditRequestVM questionEditRequestVM : questionItems) {
|
questionEditRequestVM.setItemOrder(++itemOrder);
|
questionEditRequestVM.setPermanentId(examPaperTitleItemVM.getPermanentId() + (char)suffixIndex++);
|
}
|
|
setQuestionReportForVM(tExamReportList, examPaperTitleItemVM);
|
}
|
return examPaperTitleItemVMSRandoms;
|
}
|
|
private void setQuestionReportForVM(List<TExamReport> tExamReportList, ExamPaperTitleItemVM examPaperTitleItemVM) {
|
for (TExamReport tExamReport : tExamReportList) {
|
List<QuestionReport> questionReportList = JsonUtil.toJsonListObject(tExamReport.getQuestionReport(), QuestionReport.class);
|
for (QuestionReport questionReport : questionReportList) {
|
if (Objects.equals(questionReport.getPermanentId(), examPaperTitleItemVM.getPermanentId())) {
|
examPaperTitleItemVM.setQuestionReport(questionReport);
|
examPaperTitleItemVM.setStartTime(questionReport.getStartTime());
|
examPaperTitleItemVM.setEndTime(questionReport.getEndTime());
|
break;
|
}
|
}
|
}
|
}
|
|
private void setQuestionReportForVM(List<TExamReport> tExamReportList, QuestionEditRequestVM editRequestVM) {
|
for (TExamReport tExamReport : tExamReportList) {
|
List<QuestionReport> questionReportList = JsonUtil.toJsonListObject(tExamReport.getQuestionReport(), QuestionReport.class);
|
for (QuestionReport questionReport : questionReportList) {
|
if (Objects.equals(questionReport.getPermanentId(), editRequestVM.getPermanentId())) {
|
editRequestVM.setQuestionReport(questionReport);
|
editRequestVM.setStartTime(questionReport.getStartTime());
|
editRequestVM.setEndTime(questionReport.getEndTime());
|
break;
|
}
|
}
|
}
|
}
|
@Override
|
public Integer selectAllCount() {
|
return examPaperMapper.selectAllCount();
|
}
|
@Override
|
public List<Integer> selectMothCount() {
|
return null;
|
}
|
@Override
|
public int deleteById(Integer id) {
|
return 0;
|
}
|
@Override
|
public int insert(ExamPaper record) {
|
return 0;
|
}
|
@Override
|
public int insertByFilter(ExamPaper record) {
|
return 0;
|
}
|
@Override
|
public ExamPaper selectById(Integer id) {
|
return null;
|
}
|
@Override
|
public int updateByIdFilter(ExamPaper record) {
|
return 0;
|
}
|
@Override
|
public int updateById(ExamPaper record) {
|
return 0;
|
}
|
}
|
