package com.ots.project.exam.controller;
|
import com.alibaba.fastjson.JSONArray;
|
import com.ots.common.utils.StringUtils;
|
import com.ots.common.utils.bean.BeanUtils;
|
import com.ots.common.utils.poi.ExcelUtil;
|
import com.ots.common.utils.security.ShiroUtils;
|
import com.ots.framework.aspectj.lang.annotation.Log;
|
import com.ots.framework.aspectj.lang.enums.BusinessType;
|
import com.ots.framework.web.controller.BaseController;
|
import com.ots.framework.web.domain.AjaxResult;
|
import com.ots.framework.web.domain.Ztree;
|
import com.ots.framework.web.page.TableDataInfo;
|
import com.ots.project.exam.domain.TExamLevel;
|
import com.ots.project.exam.domain.TExamPaper;
|
import com.ots.project.exam.domain.TQuestion;
|
import com.ots.project.exam.dto.ExamPaperTitleItem;
|
import com.ots.project.exam.dto.QuestionItem;
|
import com.ots.project.exam.dto.QuestionJobImport;
|
import com.ots.project.exam.dto.QuestionPersonalityImport;
|
import com.ots.project.exam.service.ITExamLevelService;
|
import com.ots.project.exam.service.ITExamPaperService;
|
import com.ots.project.exam.service.ITReportTemplateService;
|
import com.ots.project.exam.service.ITTextContentService;
|
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 com.ots.project.tool.gen.service.IExamUtilService;
|
import org.apache.shiro.authz.annotation.RequiresPermissions;
|
import org.modelmapper.ModelMapper;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Controller;
|
import org.springframework.ui.ModelMap;
|
import org.springframework.web.bind.annotation.GetMapping;
|
import org.springframework.web.bind.annotation.PathVariable;
|
import org.springframework.web.bind.annotation.PostMapping;
|
import org.springframework.web.bind.annotation.RequestMapping;
|
import org.springframework.web.bind.annotation.ResponseBody;
|
import org.springframework.web.multipart.MultipartFile;
|
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;
|
|
@Controller
|
@RequestMapping("/exam/product")
|
public class TExamPaperController extends BaseController {
|
private String prefix = "exam/product";
|
@Autowired
|
private ITExamPaperService tExamPaperService;
|
@Autowired
|
private ITTextContentService tTextContentService;
|
@Autowired
|
private ITExamLevelService itExamLevelService;
|
@Autowired
|
private IDictDataService dictDataService;
|
@Autowired
|
private IExamUtilService examUtilService;
|
@Autowired
|
private ITReportTemplateService reportTemplateService;
|
protected final static ModelMapper modelMapper = ModelMapperSingle.Instance();
|
@RequiresPermissions("exam:product:view")
|
@GetMapping()
|
public String product() {
|
return prefix + "/product";
|
}
|
|
@RequiresPermissions("exam:product:list")
|
@PostMapping("/list")
|
@ResponseBody
|
public TableDataInfo list(TExamPaper tExamPaper) {
|
startPage();
|
List<TExamPaper> list = tExamPaperService.selectTExamPaperList(tExamPaper);
|
return getDataTable(list);
|
}
|
|
@RequiresPermissions("exam:product:export")
|
@PostMapping("/export")
|
@ResponseBody
|
public AjaxResult export(TExamPaper tExamPaper) {
|
List<TExamPaper> list = tExamPaperService.selectTExamPaperList(tExamPaper);
|
ExcelUtil<TExamPaper> util = new ExcelUtil<TExamPaper>(TExamPaper.class);
|
return util.exportExcel(list, "product");
|
}
|
|
@GetMapping("/add/{id}")
|
public String add(@PathVariable("id") Long id, ModelMap mmap) {
|
|
Long levelId = id;
|
TExamLevel tExamLevel = itExamLevelService.selectTExamLevelById(levelId);
|
mmap.put("tExamLevel", tExamLevel);
|
mmap.put("templateList", reportTemplateService.getReportTemplates(ShiroUtils.getSysUser()));
|
return prefix + "/add-" + tExamLevel.getQuestionTemplateId();
|
}
|
|
@RequiresPermissions("exam:product:add")
|
@Log(title = "产品包列表", businessType = BusinessType.INSERT)
|
@PostMapping("/add")
|
@ResponseBody
|
public AjaxResult addSave(TExamPaper tExamPaper) {
|
return toAjax(tExamPaperService.insertTExamPaper(tExamPaper));
|
}
|
|
@GetMapping("/edit/{id}")
|
public String edit(@PathVariable("id") Long id, ModelMap mmap) {
|
TExamPaper tExamPaper = tExamPaperService.selectTExamPaperById(id);
|
|
List<ExamPaperTitleItem> examPaperTitleItemList = tExamPaperService.getExamPaperTitleContent(tExamPaper);
|
mmap.put("examPaperTitleItemList", examPaperTitleItemList);
|
mmap.put("templateList", reportTemplateService.getReportTemplates(ShiroUtils.getSysUser()));
|
mmap.put("tExamPaper", tExamPaper);
|
|
TExamLevel tExamLevel = itExamLevelService.selectTExamLevelById(tExamPaper.getLevelId());
|
mmap.put("tExamLevel", tExamLevel);
|
return prefix + "/edit-" + tExamLevel.getQuestionTemplateId();
|
}
|
|
@RequiresPermissions("exam:product:edit")
|
@Log(title = "产品包列表", businessType = BusinessType.UPDATE)
|
@PostMapping("/edit")
|
@ResponseBody
|
public AjaxResult editSave(TExamPaper tExamPaper) {
|
return toAjax(tExamPaperService.updateTExamPaper(tExamPaper));
|
}
|
|
@RequiresPermissions("exam:product:remove")
|
@Log(title = "产品包列表", businessType = BusinessType.DELETE)
|
@PostMapping("/remove")
|
@ResponseBody
|
public AjaxResult remove(String ids) {
|
return toAjax(tExamPaperService.deleteTExamPaperByIds(ids));
|
}
|
|
@GetMapping("/addQuestion/{levelId}/{langType}")
|
public String addQuestion(@PathVariable("levelId") Long levelId, @PathVariable("langType") String langType, ModelMap mmap) {
|
mmap.put("level", levelId);
|
mmap.put("langType", langType);
|
return prefix + "/add_question";
|
}
|
@GetMapping("/addIntelligenceTitleQuestion/{levelId}/{langType}")
|
public String addIntelligenceTitleQuestion(@PathVariable("levelId") Long levelId, @PathVariable("langType") String langType, ModelMap mmap) {
|
mmap.put("level", levelId);
|
mmap.put("langType", langType);
|
mmap.put("template", "intelligence_title");
|
return prefix + "/add_question";
|
}
|
@GetMapping("/addIntelligenceQuestion/{levelId}/{langType}")
|
public String addIntelligenceQuestion(@PathVariable("levelId") Long levelId, @PathVariable("langType") String langType, ModelMap mmap) {
|
mmap.put("level", levelId);
|
mmap.put("langType", langType);
|
mmap.put("template", "intelligence");
|
return prefix + "/add_question";
|
}
|
|
@GetMapping("/addTitle/{questionTemplateId}/{langType}")
|
public String addTitle(@PathVariable("questionTemplateId") String questionTemplateId, @PathVariable("langType") String langType, ModelMap mmap) {
|
mmap.put("questionTemplateId", questionTemplateId);
|
mmap.put("langType", langType);
|
return prefix + "/add_title";
|
}
|
|
@GetMapping("/getProdList")
|
public String getProdList(String langType,String testType,ModelMap mmap) {
|
mmap.put("langType", langType);
|
mmap.put("testType", testType);
|
return prefix + "/prodtree";
|
}
|
|
@GetMapping("/treeData/{langType}/{testType}")
|
@ResponseBody
|
public List<Ztree> treeData(@PathVariable("langType") String langType,@PathVariable("testType") String testType) {
|
System.out.println(langType);
|
List<Ztree> ztrees = tExamPaperService.selectProdTree(testType);
|
|
ztrees.stream().forEach(ztree -> {
|
ztree.setName(ExamUtil.getLangString(langType, ztree.getName()));
|
});
|
return ztrees;
|
}
|
|
@RequiresPermissions("exam:product:import")
|
@PostMapping("/importJobData/{langType}/{levelId}/{levelName}")
|
@ResponseBody
|
public AjaxResult importJobData(MultipartFile file, @PathVariable("langType") String langType, @PathVariable("levelId") Long levelId, @PathVariable("levelName") String leveltName, boolean updateSupport) throws Exception {
|
ExcelUtil<QuestionJobImport> util = new ExcelUtil<>(QuestionJobImport.class);
|
QuestionJobImport questionJobImport = util.importJobExcel(file.getInputStream(),levelId, leveltName, langType);
|
List<TQuestion> questionList = questionJobImport.getQuestionList();
|
|
for (TQuestion tQuestion : questionList) {
|
tQuestion.setTemplate("job_title");
|
}
|
|
|
updateBatchImportData(langType, JsonUtil.toJsonStr(questionJobImport.getMultilingualList()), questionList);
|
if (StringUtils.isEmpty(questionJobImport.getLangType())) {
|
return AjaxResult.success(questionJobImport);
|
}
|
if (Objects.isNull(questionJobImport) || Objects.isNull(questionJobImport.getQuestionList()) || questionJobImport.getQuestionList().isEmpty()) {
|
return AjaxResult.error("导入失败");
|
}
|
|
return AjaxResult.success(questionJobImport);
|
}
|
|
@RequiresPermissions("exam:product:view")
|
@GetMapping("/importTemplate")
|
@ResponseBody
|
public AjaxResult importTemplate() {
|
ExcelUtil<QuestionJobImport> util = new ExcelUtil<>(QuestionJobImport.class);
|
return util.importTemplateQuestionExcel("JAQ题目模板.xlsx");
|
}
|
|
@RequiresPermissions("exam:product:view")
|
@GetMapping("/importMAQTemplate")
|
@ResponseBody
|
public AjaxResult importMQATemplate() {
|
ExcelUtil<QuestionPersonalityImport> util = new ExcelUtil<>(QuestionPersonalityImport.class);
|
return util.importTemplateQuestionExcel("MAQ题目模板.xlsx");
|
}
|
|
@RequiresPermissions("exam:product:import")
|
@PostMapping("/importMAQData/{langType}")
|
@ResponseBody
|
public AjaxResult importMAQData(MultipartFile file, boolean updateSupport, Long levelId, String leveltName, @PathVariable String langType) throws Exception {
|
ExcelUtil<QuestionPersonalityImport> util = new ExcelUtil<>(QuestionPersonalityImport.class);
|
QuestionPersonalityImport questionPersonalityImport = util.importPersonalityExcel(file.getInputStream(), levelId, leveltName, langType);
|
if (StringUtils.isEmpty(questionPersonalityImport.getLangType())) {
|
return AjaxResult.success(questionPersonalityImport);
|
}
|
List<TQuestion> questionList = questionPersonalityImport.getQuestionList();
|
|
if (Objects.isNull(questionPersonalityImport) || Objects.isNull(questionList) || questionList.isEmpty()) {
|
return AjaxResult.error("导入失败");
|
}
|
|
updateBatchImportData(langType, JsonUtil.toJsonStr(questionPersonalityImport.getMultilingualList()), questionList);
|
return AjaxResult.success(questionPersonalityImport);
|
}
|
|
private void updateBatchImportData(@PathVariable String langType, String multilinguag, List<TQuestion> questionList) {
|
tExamPaperService.updateInsertQuestion(questionList, multilinguag);
|
for (TQuestion tQuestion : questionList) {
|
tQuestion.setTitle(examUtilService.getLangOrLocalLangString(langType, tQuestion.getTitle()));
|
List<String> selectInput = tQuestion.getSelectInput();
|
if (ExamUtil.isListNotEmpty(selectInput)) {
|
List<String> selectInputResult = new ArrayList<>();
|
for (String value : selectInput) {
|
selectInputResult.add(examUtilService.getLangOrLocalLangString(langType, value));
|
}
|
tQuestion.setSelectInput(selectInputResult);
|
}
|
}
|
}
|
|
@RequiresPermissions("exam:product:changeDeleted")
|
@PostMapping("/changeDeleted")
|
@ResponseBody
|
public AjaxResult changeDeleted(TExamPaper tExamPaper) {
|
return toAjax(tExamPaperService.updateDeleted(tExamPaper));
|
}
|
|
@GetMapping("/addLang/{uuid}/{langType}")
|
public String addLang(@PathVariable("uuid") Long uuid, @PathVariable("langType") String langType, ModelMap mmap) {
|
TExamPaper tExamPaper = tExamPaperService.selectTExamPaperById(uuid);
|
tExamPaper.setLangType(langType);
|
tExamPaper.setLangName(getDitcByType("lang_type", langType));
|
tExamPaper.setUuid(uuid);
|
tExamPaper.setOperatingLanguage("addLang");
|
|
List<ExamPaperTitleItem> examPaperTitleItemList = getExamPaperTitleItems(mmap, tExamPaper);
|
mmap.put("templateList", reportTemplateService.getReportTemplates(ShiroUtils.getSysUser()));
|
mmap.put("tExamPaper", tExamPaper);
|
|
TExamLevel tExamLevel = itExamLevelService.selectTExamLevelById(tExamPaper.getLevelId());
|
mmap.put("tExamLevel", tExamLevel);
|
|
nmapPutQuestionItem(mmap, examPaperTitleItemList);
|
|
tExamPaper.setName("");
|
tExamPaper.setGuide("");
|
return prefix + "/edit-" + tExamLevel.getQuestionTemplateId();
|
}
|
|
@GetMapping("/editLang/{uuid}/{langType}")
|
public String editLang(@PathVariable("uuid") Long uuid, @PathVariable("langType") String langType, ModelMap mmap) {
|
TExamPaper tExamPaper = tExamPaperService.selectTExamPaperById(uuid);
|
tExamPaper.setUuid(uuid);
|
tExamPaper.setId(uuid);
|
tExamPaper.setLangType(langType);
|
tExamPaper.setOperatingLanguage("editLang");
|
|
tExamPaper.setName(ExamUtil.getStringByLang(tExamPaper.getLangType(), tExamPaper.getName()));
|
tExamPaper.setGuide(ExamUtil.getStringByLang(tExamPaper.getLangType(), tExamPaper.getGuide()));
|
tExamPaper.setLangName(getDitcByType("lang_type", langType));
|
List<ExamPaperTitleItem> examPaperTitleItemList = getExamPaperTitleItems(mmap, tExamPaper);
|
|
nmapPutQuestionItem(mmap, examPaperTitleItemList);
|
|
mmap.put("tExamPaper", tExamPaper);
|
mmap.put("templateList", reportTemplateService.getReportTemplates(ShiroUtils.getSysUser()));
|
|
TExamLevel tExamLevel = itExamLevelService.selectTExamLevelById(tExamPaper.getLevelId());
|
mmap.put("tExamLevel", tExamLevel);
|
return prefix + "/edit-" + tExamLevel.getQuestionTemplateId();
|
}
|
private List<ExamPaperTitleItem> getExamPaperTitleItems(ModelMap mmap, TExamPaper tExamPaper) {
|
|
List<ExamPaperTitleItem> examPaperTitleItemList = tExamPaperService.getExamPaperTitleContent(tExamPaper);
|
|
List<ExamPaperTitleItem> contentOriginalList = getExamDuplicateTitleItems(tExamPaper, examPaperTitleItemList);
|
|
mmap.put("examPaperTitleItemList", contentOriginalList);
|
nmapPutQuestionItem(mmap, examPaperTitleItemList);
|
return examPaperTitleItemList;
|
}
|
private List<ExamPaperTitleItem> getExamDuplicateTitleItems(TExamPaper tExamPaper, List<ExamPaperTitleItem> examPaperTitleItemList) {
|
List<ExamPaperTitleItem> contentOriginalList = JSONArray.parseArray(tExamPaper.getContent(), ExamPaperTitleItem.class);
|
Map<Integer, QuestionItem> questionItemMap = new HashMap<>();
|
for (ExamPaperTitleItem examPaperTitleItem : examPaperTitleItemList) {
|
List<QuestionItem> questionItems = examPaperTitleItem.getQuestionItems();
|
for (QuestionItem questionItem : questionItems) {
|
questionItemMap.put(questionItem.getQuestionId(), questionItem);
|
}
|
}
|
for (ExamPaperTitleItem examPaperTitleItem : contentOriginalList) {
|
List<QuestionItem> questionItems = examPaperTitleItem.getQuestionItems();
|
for (QuestionItem questionItem : questionItems) {
|
Integer partOrder = questionItem.getPartOrder();
|
|
QuestionItem questionItemSource = questionItemMap.get(questionItem.getId());
|
questionItemSource.setTemplate(questionItem.getTemplate());
|
questionItemSource.setParentQuestionId(questionItem.getParentQuestionId());
|
BeanUtils.copyProperties(questionItemSource, questionItem);
|
questionItem.setPartOrder(partOrder);
|
}
|
}
|
return contentOriginalList;
|
}
|
private void nmapPutQuestionItem(ModelMap mmap, List<ExamPaperTitleItem> examPaperTitleItemList) {
|
|
List<QuestionItem> questionItems = examPaperTitleItemList.get(0).getQuestionItems();
|
mmap.put("questionItems", questionItems);
|
mmap.put("parts", JsonUtil.toJsonStr(examPaperTitleItemList.get(0).getParts()));
|
}
|
@GetMapping("/deleteLang/{uuid}/{langType}")
|
@ResponseBody
|
public AjaxResult deleteLang(@PathVariable("uuid") Long uuid, @PathVariable("langType") String langType) {
|
|
TExamPaper tExamPaper = tExamPaperService.selectTExamPaperById(uuid);
|
tExamPaper.setLangType(langType);
|
return toAjax(tExamPaperService.deleteProductContent(tExamPaper));
|
}
|
private String getDitcByType(String type, String dictType) {
|
List<DictData> langTypeList = dictDataService.selectDictDataByType(type);
|
Map<String, String> lanTypeMap = langTypeList.stream().collect(Collectors.toMap(DictData::getDictValue, DictData::getDictLabel));
|
return lanTypeMap.get(dictType);
|
}
|
|
@GetMapping("/langType/{id}")
|
public String getLangType(@PathVariable("id") Long id, ModelMap mmap) {
|
List<DictData> dictDataList = tExamPaperService.getType(id);
|
mmap.put("dictDatas", dictDataList);
|
return prefix + "/product::langTypeDiv";
|
}
|
}
|
