package com.ots.project.exam.service.impl;
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONObject;
|
import com.ots.common.enums.QuestionTypeEnum;
|
import com.ots.common.utils.DateUtils;
|
import com.ots.common.utils.StringUtils;
|
import com.ots.common.utils.bean.BeanUtils;
|
import com.ots.common.utils.text.Convert;
|
import com.ots.framework.web.service.DictService;
|
import com.ots.project.exam.domain.TQuestion;
|
import com.ots.project.exam.domain.TTextContent;
|
import com.ots.project.exam.domain.TextContent;
|
import com.ots.project.exam.dto.QuestionEditItem;
|
import com.ots.project.exam.dto.QuestionObject;
|
import com.ots.project.exam.mapper.TQuestionMapper;
|
import com.ots.project.exam.mapper.TTextContentMapper;
|
import com.ots.project.exam.service.ITQuestionService;
|
import com.ots.project.exam.service.ITTextContentService;
|
import com.ots.project.exam.viewmodel.QuestionEditItemVM;
|
import com.ots.project.exam.viewmodel.QuestionEditRequestVM;
|
import com.ots.project.system.dict.domain.DictData;
|
import com.ots.project.system.dict.service.IDictDataService;
|
import com.ots.project.tool.exam.ExamUtil;
|
import com.ots.project.tool.exam.JsonUtil;
|
import com.ots.project.tool.exam.ModelMapperSingle;
|
import org.modelmapper.ModelMapper;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.i18n.LocaleContextHolder;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.stream.Collectors;
|
import static com.ots.common.enums.ExamPaperQuestion.permanentIdDuplicate;
|
|
@Service("examQuestion")
|
public class TQuestionServiceImpl implements ITQuestionService {
|
@Autowired
|
private TQuestionMapper tQuestionMapper;
|
@Autowired
|
private TTextContentMapper tTextContentMapper;
|
@Autowired
|
private ITTextContentService textContentService;
|
@Autowired
|
private IDictDataService dictDataService;
|
@Autowired
|
private DictService dictService;
|
protected final static ModelMapper modelMapper = ModelMapperSingle.Instance();
|
|
@Override
|
public TQuestion selectTQuestionById(Long id) {
|
return tQuestionMapper.selectTQuestionById(id);
|
}
|
|
@Override
|
public List<TQuestion> selectTQuestionByIds(List<Long> ids) {
|
return tQuestionMapper.selectTQuestionByIds(ids);
|
}
|
@Override
|
public List<TQuestion> selectTQuestionByPermanentIds(List<String> permanentIds) {
|
return tQuestionMapper.selectTQuestionByPermanentIds(permanentIds);
|
}
|
|
@Override
|
public List<TQuestion> selectTQuestionList(TQuestion tQuestion) {
|
List<TQuestion> tQuestionList = tQuestionMapper.selectTQuestionList(tQuestion);
|
List<TQuestion> tQuestionResultList = new ArrayList<>();
|
|
String localLangType = dictService.getLangType(LocaleContextHolder.getLocale().toString());
|
for (TQuestion question : tQuestionList) {
|
String content = question.getContent();
|
QuestionObject questionObject = JSONObject.parseObject(content, QuestionObject.class);
|
setChioceAndSelectInput(question, questionObject);
|
question.setTitle(questionObject.getTitleContent());
|
|
Map<String, String> titleMap = JsonUtil.toJsonObject(question.getTitle(), HashMap.class);
|
if (Objects.isNull(titleMap)) {
|
TQuestion questionResult = new TQuestion();
|
BeanUtils.copyProperties(question, questionResult);
|
questionResult.setLangType("Chinese");
|
tQuestionResultList.add(questionResult);
|
} else {
|
|
if (Objects.isNull(tQuestion.getUuid())) {
|
|
if (StringUtils.isNotEmpty(tQuestion.getLangType())) {
|
|
if (StringUtils.isNotEmpty(titleMap.get(tQuestion.getLangType()))) {
|
|
if (StringUtils.isNotEmpty(titleMap.get(localLangType))) {
|
addQuestionResult(tQuestionResultList, question, localLangType, titleMap.get(localLangType));
|
} else {
|
addQuestionResult(tQuestionResultList, question, tQuestion.getLangType(), titleMap.get(tQuestion.getLangType()));
|
}
|
}
|
} else if (StringUtils.isNotEmpty(titleMap.get(localLangType))) {
|
addQuestionResult(tQuestionResultList, question, localLangType, titleMap.get(localLangType));
|
} else {
|
addQuestionResult(tQuestionResultList, question, titleMap.keySet().stream().findFirst().get(), titleMap.values().stream().findFirst().get());
|
}
|
} else {
|
|
if (StringUtils.isNotEmpty(tQuestion.getLangType())) {
|
addQuestionResult(tQuestionResultList, question, tQuestion.getLangType(), titleMap.get(tQuestion.getLangType()));
|
} else {
|
titleMap.forEach((key, value) -> {
|
addQuestionResult(tQuestionResultList, question, key, value);
|
});
|
}
|
}
|
}
|
}
|
tQuestionList.clear();
|
tQuestionList.addAll(tQuestionResultList);
|
return tQuestionList;
|
}
|
private void setChioceAndSelectInput(TQuestion question, QuestionObject questionObject) {
|
if (ExamUtil.isListEmpty(questionObject.getQuestionItemObjects())) {
|
return;
|
}
|
|
List<String> choiceInputList = questionObject.getQuestionItemObjects().stream().map(i -> {
|
return i.getPrefix();
|
}).collect(Collectors.toList());
|
question.setChoiceInput(choiceInputList);
|
|
List<String> stemList = questionObject.getQuestionItemObjects().stream().map(i -> {
|
return ExamUtil.getLangString(question.getLangType(), i.getContent());
|
}).collect(Collectors.toList());
|
question.setSelectInput(stemList);
|
}
|
private void addQuestionResult(List<TQuestion> tQuestionResultList, TQuestion question, String key, String value) {
|
TQuestion questionResult = new TQuestion();
|
BeanUtils.copyProperties(question, questionResult);
|
|
questionResult.setLangType(key);
|
|
questionResult.setTitle(value);
|
|
if (ExamUtil.isListNotEmpty(question.getChoiceInput())) {
|
setLanSelectInput(question, key);
|
}
|
tQuestionResultList.add(questionResult);
|
}
|
private void setLanSelectInput(TQuestion question, String key) {
|
|
List<String> selectInputList = question.getSelectInput();
|
|
for (String selectInput : selectInputList) {
|
selectInput = ExamUtil.getStringByLang(key, selectInput);;
|
}
|
}
|
|
@Override
|
public List<TQuestion> selectTQuestionsForProductAddQuestion(TQuestion tQuestion) {
|
List<TQuestion> tQuestionList = tQuestionMapper.selectTQuestionsForProductAddQuestion(tQuestion);
|
for (TQuestion question : tQuestionList) {
|
String content = question.getContent();
|
QuestionObject questionObject = JSONObject.parseObject(content, QuestionObject.class);
|
question.setLangType(tQuestion.getLangType());
|
setChioceAndSelectInput(question, questionObject);
|
|
Map<String, String> titleMap = JsonUtil.toJsonObject(questionObject.getTitleContent(), HashMap.class);
|
if (Objects.isNull(titleMap)) {
|
question.setTitle(questionObject.getTitleContent());
|
} else {
|
question.setTitle(ExamUtil.getLangString(tQuestion.getLangType(), questionObject.getTitleContent()));
|
}
|
}
|
return tQuestionList;
|
}
|
|
@Override
|
@Transactional
|
public int insertTQuestion(TQuestion tQuestion) {
|
if (StringUtils.isNotEmpty(tQuestion.getPermanentId())) {
|
List<TQuestion> tQuestionList = tQuestionMapper.selectTQuestionByPermanentId(tQuestion.getPermanentId());
|
if (ExamUtil.isListNotEmpty(tQuestionList)) {
|
return permanentIdDuplicate.ordinal();
|
}
|
}
|
|
TTextContent textContent = getQuestionTextContent(tQuestion);
|
|
tTextContentMapper.insertTTextContent(textContent);
|
|
tQuestion.setInfoTextContentId(textContent.getId());
|
return tQuestionMapper.insertTQuestion(tQuestion);
|
}
|
private TTextContent getQuestionTextContent(TQuestion tQuestion) {
|
|
List<QuestionEditItem> questionEditItems = new ArrayList<QuestionEditItem>();
|
List<QuestionEditItem> itemObjects = null;
|
|
if (ExamUtil.isListNotEmpty(tQuestion.getChoiceInput())) {
|
itemObjects = getQuestionEditItems(tQuestion, questionEditItems);
|
}
|
QuestionObject questionObject = new QuestionObject();
|
questionObject.setQuestionItemObjects(itemObjects);
|
questionObject.setAnalyze(tQuestion.getAnalyze());
|
|
if (StringUtils.isNotEmpty(tQuestion.getMultilingual())) {
|
questionObject.setTitleContent(tQuestion.getTitle());
|
} else {
|
questionObject.setTitleContent(ExamUtil.getStringMapJson(tQuestion.getLangType(), tQuestion.getTitle(), new HashMap<>()));
|
}
|
questionObject.setCorrect(tQuestion.getCorrect());
|
tQuestion.setCreateTime(DateUtils.getNowDate());
|
TTextContent textContent = new TTextContent();
|
textContent.setCreateTime(DateUtils.getNowDate());
|
textContent.setContent(JSON.toJSONString(questionObject));
|
|
return textContent;
|
}
|
private List<QuestionEditItem> getQuestionEditItems(TQuestion tQuestion, List<QuestionEditItem> questionEditItems) {
|
for (int i = 0; i < tQuestion.getChoiceInput().size(); i++) {
|
QuestionEditItem questionEditItem = new QuestionEditItem();
|
questionEditItem.setPrefix(tQuestion.getChoiceInput().get(i));
|
|
if (StringUtils.isNotEmpty(tQuestion.getMultilingual())) {
|
questionEditItem.setContent(tQuestion.getSelectInput().get(i));
|
} else {
|
questionEditItem.setContent(ExamUtil.getStringMapJson(tQuestion.getLangType(), tQuestion.getSelectInput().get(i), new HashMap<>()));
|
}
|
|
questionEditItem.setScore(Objects.isNull(tQuestion.getScore()) ? 0 : tQuestion.getScore().intValue());
|
questionEditItems.add(questionEditItem);
|
}
|
|
return questionEditItems.stream().map(i ->
|
{
|
QuestionEditItem item = modelMapper.map(i, QuestionEditItem.class);
|
item.setScore(ExamUtil.scoreFromVM(i.getScore().toString()));
|
return item;
|
}
|
).collect(Collectors.toList());
|
}
|
|
@Override
|
public int updateTQuestion(TQuestion tQuestion) {
|
|
if (tQuestion.getUuid() != null) {
|
TQuestion questionOld = tQuestionMapper.selectTQuestionById(tQuestion.getId());
|
|
updateQuestionLangContent(tQuestion, questionOld);
|
return tQuestionMapper.updateTQuestion(tQuestion);
|
}
|
|
List<TQuestion> questionOldlist = tQuestionMapper.selectTQuestionByPermanentId(tQuestion.getPermanentId());
|
if (ExamUtil.isListNotEmpty(questionOldlist)) {
|
|
for (TQuestion tQuestionUpdate : questionOldlist) {
|
|
if (StringUtils.isNotEmpty(tQuestion.getTemplate()) && StringUtils.isEmpty(tQuestionUpdate.getTemplate())) {
|
tQuestionUpdate.setTemplate(tQuestion.getTemplate());
|
}
|
updateQuestionLangContent(tQuestion, tQuestionUpdate);
|
}
|
return 1;
|
}
|
TQuestion questionOld = null;
|
|
if (!Objects.isNull(tQuestion.getId())) {
|
|
questionOld = tQuestionMapper.selectTQuestionById(tQuestion.getId());
|
questionOld.setDeleted(2L);
|
questionOld.setUpdateTime(DateUtils.getNowDate());
|
tQuestionMapper.updateTQuestion(questionOld);
|
}
|
|
setInsertQuestion(tQuestion);
|
|
return tQuestionMapper.insertTQuestion(tQuestion);
|
}
|
private void setInsertQuestion(TQuestion tQuestion) {
|
|
tQuestion.setUpdateTime(DateUtils.getNowDate());
|
|
TTextContent textContent = getQuestionTextContent(tQuestion);
|
textContent.setId(null);
|
|
tTextContentMapper.insertTTextContent(textContent);
|
|
tQuestion.setInfoTextContentId(textContent.getId());
|
tQuestion.setDeleted(1L);
|
|
tQuestion.setLastId(tQuestion.getId());
|
}
|
|
private int updateQuestionContent(TQuestion tQuestion, TQuestion questionOld) {
|
if (Objects.isNull(tQuestion.getId()) || tQuestion.getId() == 0) {
|
tQuestion.setId(questionOld.getId());
|
}
|
|
QuestionObject questionObject = JSONObject.parseObject(questionOld.getContent(), QuestionObject.class);
|
|
tQuestion.setUpdateTime(DateUtils.getNowDate());
|
|
|
Map<String, String> titleMap = JsonUtil.toJsonObject(questionObject.getTitleContent(), HashMap.class);
|
titleMap.put(tQuestion.getLangType(), tQuestion.getTitle());
|
questionObject.setTitleContent(JsonUtil.toJsonStr(titleMap));
|
|
List<String> selectInput = tQuestion.getSelectInput();
|
int selectInputNum = 0;
|
List<QuestionEditItem> questionItemObjects = questionObject.getQuestionItemObjects();
|
for (QuestionEditItem questionItemObject : questionItemObjects) {
|
Map<String, String> contentMap = JsonUtil.toJsonObject(questionItemObject.getContent(), HashMap.class);
|
contentMap.put(tQuestion.getLangType(), selectInput.get(selectInputNum++));
|
questionItemObject.setContent(JsonUtil.toJsonStr(contentMap));
|
}
|
TTextContent questionTextContent = tTextContentMapper.selectTTextContentById(questionOld.getInfoTextContentId());
|
questionTextContent.setUpdateTime(DateUtils.getNowDate());
|
questionTextContent.setContent(JsonUtil.toJsonStr(questionObject));
|
|
return tTextContentMapper.updateTTextContent(questionTextContent);
|
}
|
|
private int updateQuestionLangContent(TQuestion tQuestion, TQuestion questionOld) {
|
if (Objects.isNull(tQuestion.getId()) || tQuestion.getId() == 0) {
|
tQuestion.setId(questionOld.getId());
|
}
|
|
QuestionObject questionObject = JSONObject.parseObject(questionOld.getContent(), QuestionObject.class);
|
|
tQuestion.setUpdateTime(DateUtils.getNowDate());
|
|
|
String langType = tQuestion.getLangType();
|
if (Objects.isNull(tQuestion.getUuid())) {
|
langType = "ALL";
|
}
|
questionObject.setTitleContent(ExamUtil.getStringMapJson(langType, tQuestion.getTitle(), questionObject.getTitleContent()));
|
|
updateQuestionEditItem(tQuestion, questionObject);
|
TTextContent questionTextContent = tTextContentMapper.selectTTextContentById(questionOld.getInfoTextContentId());
|
questionTextContent.setUpdateTime(DateUtils.getNowDate());
|
questionTextContent.setContent(JsonUtil.toJsonStr(questionObject));
|
|
|
tQuestionMapper.updateTQuestion(questionOld);
|
return tTextContentMapper.updateTTextContent(questionTextContent);
|
}
|
private void updateQuestionEditItem(TQuestion tQuestion, QuestionObject questionObject) {
|
|
if (ExamUtil.isListEmpty(tQuestion.getChoiceInput())) {
|
return;
|
}
|
List<String> selectInput = tQuestion.getSelectInput();
|
int selectInputNum = 0;
|
List<QuestionEditItem> questionItemObjects = questionObject.getQuestionItemObjects();
|
|
String langType = tQuestion.getLangType();
|
if (Objects.isNull(tQuestion.getUuid())) {
|
langType = "ALL";
|
}
|
for (QuestionEditItem questionItemObject : questionItemObjects) {
|
if (selectInputNum < selectInput.size()) {
|
questionItemObject.setContent(ExamUtil.getStringMapJson(langType, selectInput.get(selectInputNum++), questionItemObject.getContent()));
|
}
|
}
|
|
if (selectInput.size() > questionItemObjects.size()) {
|
QuestionEditItem questionItemObject = new QuestionEditItem();
|
String prefix = tQuestion.getChoiceInput().get(tQuestion.getChoiceInput().size() - 1);
|
questionItemObject.setPrefix(prefix);
|
questionItemObject.setContent(ExamUtil.getStringMapJson(tQuestion.getLangType(), selectInput.get(selectInputNum), ""));
|
questionItemObject.setScore(0);
|
questionItemObjects.add(questionItemObject);
|
}
|
|
if (selectInput.size() < questionItemObjects.size()) {
|
for (int i = questionItemObjects.size() - 1; i > selectInput.size() - 1; i--) {
|
questionItemObjects.remove(i);
|
}
|
}
|
}
|
|
public int deleteQuestionContent(TQuestion tQuestion) {
|
TQuestion questionOld = tQuestionMapper.selectTQuestionById(tQuestion.getId());
|
|
QuestionObject questionObject = JSONObject.parseObject(questionOld.getContent(), QuestionObject.class);
|
|
tQuestion.setUpdateTime(DateUtils.getNowDate());
|
|
Map<String, String> titleMap = JsonUtil.toJsonObject(questionObject.getTitleContent(), HashMap.class);
|
titleMap.remove(tQuestion.getLangType());
|
questionObject.setTitleContent(JsonUtil.toJsonStr(titleMap));
|
|
List<QuestionEditItem> questionItemObjects = questionObject.getQuestionItemObjects();
|
if (ExamUtil.isListNotEmpty(questionItemObjects)) {
|
for (QuestionEditItem questionItemObject : questionItemObjects) {
|
Map<String, String> contentMap = JsonUtil.toJsonObject(questionItemObject.getContent(), HashMap.class);
|
contentMap.remove(tQuestion.getLangType());
|
questionItemObject.setContent(JsonUtil.toJsonStr(contentMap));
|
}
|
}
|
TTextContent questionTextContent = tTextContentMapper.selectTTextContentById(questionOld.getInfoTextContentId());
|
questionTextContent.setUpdateTime(DateUtils.getNowDate());
|
questionTextContent.setContent(JsonUtil.toJsonStr(questionObject));
|
|
return tTextContentMapper.updateTTextContent(questionTextContent);
|
}
|
|
@Override
|
public int deleteTQuestionByIds(String ids) {
|
return tQuestionMapper.updateQuetionByDelete(Convert.toStrArray(ids));
|
}
|
|
public int deleteTQuestionById(Long id) {
|
return tQuestionMapper.deleteTQuestionById(id);
|
}
|
@Override
|
public QuestionEditRequestVM getQuestionEditRequestVM(TQuestion question) {
|
|
TTextContent questionInfoTextContent = textContentService.selectTTextContentById(question.getInfoTextContentId().longValue());
|
QuestionObject questionObject = JsonUtil.toJsonObject(questionInfoTextContent.getContent(), QuestionObject.class);
|
QuestionEditRequestVM questionEditRequestVM = modelMapper.map(question, QuestionEditRequestVM.class);
|
questionEditRequestVM.setTitle(questionObject.getTitleContent());
|
|
QuestionTypeEnum questionTypeEnum = QuestionTypeEnum.fromCode(question.getQuestionType().intValue());
|
switch (questionTypeEnum) {
|
case SingleChoice:
|
case TrueFalse:
|
questionEditRequestVM.setCorrect(question.getCorrect());
|
break;
|
case MultipleChoice:
|
questionEditRequestVM.setCorrectArray(ExamUtil.contentToArray(question.getCorrect()));
|
break;
|
case GapFilling:
|
List<String> correctContent = questionObject.getQuestionItemObjects().stream().map(d -> d.getContent()).collect(Collectors.toList());
|
questionEditRequestVM.setCorrectArray(correctContent);
|
break;
|
case ShortAnswer:
|
questionEditRequestVM.setCorrect(questionObject.getCorrect());
|
break;
|
default:
|
break;
|
}
|
questionEditRequestVM.setScore(ExamUtil.scoreToVM(0));
|
questionEditRequestVM.setAnalyze(questionObject.getAnalyze());
|
|
if (Objects.nonNull(questionObject.getQuestionItemObjects())) {
|
List<QuestionEditItemVM> editItems = questionObject.getQuestionItemObjects().stream().map(o -> {
|
QuestionEditItemVM questionEditItemVM = modelMapper.map(o, QuestionEditItemVM.class);
|
if (o.getScore() != null) {
|
questionEditItemVM.setScore(ExamUtil.scoreToVM(o.getScore()));
|
}
|
return questionEditItemVM;
|
}).collect(Collectors.toList());
|
questionEditRequestVM.setItems(editItems);
|
} else {
|
List<QuestionEditItemVM> editItems = new ArrayList<>();
|
QuestionEditItemVM questionEditItemVM = new QuestionEditItemVM();
|
questionEditItemVM.setContent("0");
|
questionEditItemVM.setPrefix("1");
|
questionEditItemVM.setScore("0");
|
editItems.add(questionEditItemVM);
|
questionEditRequestVM.setItems(editItems);
|
}
|
return questionEditRequestVM;
|
}
|
@Override
|
public String insertImportQuestion(List<Map<Integer, String>> excelList) {
|
|
|
TQuestion tQuestion = new TQuestion();
|
|
Map<Integer, String> headerMap = excelList.get(0);
|
List<String> prefixList = new ArrayList<>();
|
for (int i = 6; i < headerMap.size(); i++) {
|
prefixList.add(headerMap.get(i));
|
}
|
|
StringBuilder successMsg = new StringBuilder();
|
StringBuilder failureMsg = new StringBuilder();
|
|
for (int i = 1; i < excelList.size(); i++) {
|
Map<Integer, String> excelDataMap = excelList.get(i);
|
try {
|
|
tQuestion.setPermanentId(excelDataMap.get(0));
|
|
tQuestion.setSubjectId(Long.valueOf(excelDataMap.get(1)));
|
|
tQuestion.setScore(Long.valueOf(excelDataMap.get(2)));
|
|
tQuestion.setTitle(excelDataMap.get(3));
|
|
tQuestion.setLangType(excelDataMap.get(4));
|
|
tQuestion.setCorrect(excelDataMap.get(5));
|
|
int prefixNum = 0;
|
tQuestion.setChoiceInput(new ArrayList<>());
|
List<String> choiceInput = tQuestion.getChoiceInput();
|
tQuestion.setSelectInput(new ArrayList<>());
|
List<String> selectInput = tQuestion.getSelectInput();
|
for (int j = 6; j < excelDataMap.size(); j++) {
|
choiceInput.add(prefixList.get(prefixNum++));
|
selectInput.add(excelDataMap.get(j));
|
}
|
insertTQuestion(tQuestion);
|
successMsg.append("<div>永久编号：" + excelDataMap.get(0) + " 导入成功</div>");
|
} catch (Exception e) {
|
failureMsg.append("<div style=\"color: red\">永久编号：" + excelDataMap.get(0) + " 导入失败</div>");
|
}
|
}
|
StringBuilder meg = failureMsg.append(successMsg);
|
return meg.toString();
|
}
|
public void setQuestionInfoFromVM(TextContent infoTextContent, QuestionEditRequestVM model) {
|
List<QuestionEditItem> itemObjects = model.getItems().stream().map(i ->
|
{
|
QuestionEditItem item = modelMapper.map(i, QuestionEditItem.class);
|
item.setScore(ExamUtil.scoreFromVM(i.getScore()));
|
return item;
|
}
|
).collect(Collectors.toList());
|
QuestionObject questionObject = new QuestionObject();
|
questionObject.setQuestionItemObjects(itemObjects);
|
questionObject.setAnalyze(model.getAnalyze());
|
questionObject.setTitleContent(model.getTitle());
|
questionObject.setCorrect(model.getCorrect());
|
infoTextContent.setContent(JsonUtil.toJsonStr(questionObject));
|
}
|
|
public List<DictData> getType(Long id) {
|
|
List<DictData> dictDataList = dictDataService.selectDictDataByType("lang_type");
|
|
if (Objects.nonNull(id)) {
|
TQuestion question = selectTQuestionById(id);
|
String content = question.getContent();
|
QuestionObject questionObject = JSONObject.parseObject(content, QuestionObject.class);
|
Map<String, String> titleMap = JsonUtil.toJsonObject(questionObject.getTitleContent(), HashMap.class);
|
List<DictData> dictDataListResult = new ArrayList<>();
|
for (DictData dictData : dictDataList) {
|
if (StringUtils.isEmpty(titleMap.get(dictData.getDictValue()))) {
|
dictDataListResult.add(dictData);
|
}
|
}
|
return dictDataListResult;
|
} else {
|
return dictDataList;
|
}
|
}
|
public List<TQuestion> selectTQuestionByPermanentId(String permanentId) {
|
return tQuestionMapper.selectTQuestionByPermanentId(permanentId);
|
}
|
}
|
