blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
xiangpei
2024-06-28 abd1516fa39da87f70d4f69dc4ec35f8f81946f1 
 src/main/java/com/ycl/jxkg/service/impl/QuestionServiceImpl.java


@@ -1,27 +1,27 @@


package com.ycl.jxkg.service.impl;




import com.ycl.jxkg.domain.other.KeyValue;


import com.ycl.jxkg.domain.Question;


import com.ycl.jxkg.domain.TextContent;


import com.ycl.jxkg.domain.enums.QuestionStatusEnum;


import com.ycl.jxkg.domain.enums.QuestionTypeEnum;


import com.ycl.jxkg.domain.question.QuestionItemObject;


import com.ycl.jxkg.domain.question.QuestionObject;


import com.ycl.jxkg.repository.QuestionMapper;


import com.ycl.jxkg.service.QuestionService;


import com.ycl.jxkg.service.SubjectService;


import com.ycl.jxkg.service.TextContentService;


import com.ycl.jxkg.utility.DateTimeUtil;


import com.ycl.jxkg.utility.JsonUtil;


import com.ycl.jxkg.utility.ModelMapperSingle;


import com.ycl.jxkg.utility.ExamUtil;


import com.ycl.jxkg.viewmodel.admin.question.QuestionEditItemVM;


import com.ycl.jxkg.viewmodel.admin.question.QuestionEditRequestVM;


import com.ycl.jxkg.viewmodel.admin.question.QuestionPageRequestVM;


import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;


import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;


import com.github.pagehelper.PageHelper;


import com.github.pagehelper.PageInfo;


import org.modelmapper.ModelMapper;


import org.springframework.beans.factory.annotation.Autowired;


import com.ycl.jxkg.domain.entity.Question;


import com.ycl.jxkg.enums.QuestionTypeEnum;


import com.ycl.jxkg.enums.general.StatusEnum;


import com.ycl.jxkg.domain.other.KeyValue;


import com.ycl.jxkg.domain.question.QuestionItemObject;


import com.ycl.jxkg.domain.question.QuestionObject;


import com.ycl.jxkg.domain.vo.admin.question.QuestionEditItemVO;


import com.ycl.jxkg.domain.vo.admin.question.QuestionEditRequestVO;


import com.ycl.jxkg.domain.vo.admin.question.QuestionPageRequestVO;


import com.ycl.jxkg.domain.vo.admin.question.QuestionResponseVO;


import com.ycl.jxkg.mapper.QuestionMapper;


import com.ycl.jxkg.service.QuestionService;


import com.ycl.jxkg.utils.DateTimeUtil;


import com.ycl.jxkg.utils.ExamUtil;


import com.ycl.jxkg.utils.HtmlUtil;


import com.ycl.jxkg.utils.JsonUtil;


import lombok.RequiredArgsConstructor;


import org.springframework.beans.BeanUtils;


import org.springframework.stereotype.Service;


import org.springframework.transaction.annotation.Transactional;




@@ -30,24 +30,15 @@


import java.util.stream.Collectors;




@Service


public class QuestionServiceImpl extends BaseServiceImpl<Question> implements QuestionService {


@RequiredArgsConstructor


public class QuestionServiceImpl extends ServiceImpl<QuestionMapper, Question> implements QuestionService {




    protected final static ModelMapper modelMapper = ModelMapperSingle.Instance();


    private final QuestionMapper questionMapper;


    private final TextContentService textContentService;


    private final SubjectService subjectService;




    @Autowired


    public QuestionServiceImpl(QuestionMapper questionMapper, TextContentService textContentService, SubjectService subjectService) {


        super(questionMapper);


        this.textContentService = textContentService;


        this.questionMapper = questionMapper;


        this.subjectService = subjectService;


    }




    @Override


    public PageInfo<Question> page(QuestionPageRequestVM requestVM) {


        return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->


    public PageInfo<QuestionResponseVO> page(QuestionPageRequestVO requestVM) {


        return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "create_time desc").doSelectPageInfo(() ->


                questionMapper.page(requestVM)


        );


    }


@@ -55,111 +46,103 @@




    @Override


    @Transactional


    public Question insertFullQuestion(QuestionEditRequestVM model, Integer userId) {


    public Question insertFullQuestion(QuestionEditRequestVO model, Integer userId) {


        Date now = new Date();


        Integer gradeLevel = subjectService.levelBySubjectId(model.getSubjectId());




        //题干、解析、选项等 插入


        TextContent infoTextContent = new TextContent();


        infoTextContent.setCreateTime(now);


        setQuestionInfoFromVM(infoTextContent, model);


        textContentService.insertByFilter(infoTextContent);


        String questionObject = setQuestionInfoFromVM(model);




        Question question = new Question();


        question.setSubjectId(model.getSubjectId());


        question.setGradeLevel(gradeLevel);


        question.setCreateTime(now);


        question.setQuestionType(model.getQuestionType());


        question.setStatus(QuestionStatusEnum.OK.getCode());


        question.setStatus(StatusEnum.ENABLE);


        question.setCorrectFromVM(model.getCorrect(), model.getCorrectArray());


        question.setScore(ExamUtil.scoreFromVM(model.getScore()));


        question.setDifficult(model.getDifficult());


        question.setInfoTextContentId(infoTextContent.getId());


        question.setContent(questionObject);


        question.setCreateUser(userId);


        question.setDeleted(false);


        questionMapper.insertSelective(question);


        question.setTitle(HtmlUtil.clear(model.getTitle()));


        question.setAudioFile(model.getAudioFile());


        question.setOriginalFile(model.getOriginalFile());


        questionMapper.insert(question);


        return question;


    }




    @Override


    @Transactional


    public Question updateFullQuestion(QuestionEditRequestVM model) {


        Integer gradeLevel = subjectService.levelBySubjectId(model.getSubjectId());


        Question question = questionMapper.selectByPrimaryKey(model.getId());


    public Question updateFullQuestion(QuestionEditRequestVO model) {


        Question question = questionMapper.selectById(model.getId());


        question.setSubjectId(model.getSubjectId());


        question.setGradeLevel(gradeLevel);


        question.setScore(ExamUtil.scoreFromVM(model.getScore()));


        question.setDifficult(model.getDifficult());


        question.setCorrectFromVM(model.getCorrect(), model.getCorrectArray());


        questionMapper.updateByPrimaryKeySelective(question);




        //题干、解析、选项等 更新


        TextContent infoTextContent = textContentService.selectById(question.getInfoTextContentId());


        setQuestionInfoFromVM(infoTextContent, model);


        textContentService.updateByIdFilter(infoTextContent);




        String questionObject = setQuestionInfoFromVM(model);


        question.setContent(questionObject);


        question.setTitle(HtmlUtil.clear(model.getTitle()));


        question.setAudioFile(model.getAudioFile());


        question.setOriginalFile(model.getOriginalFile());


        questionMapper.updateById(question);


        return question;


    }




    @Override


    public QuestionEditRequestVM getQuestionEditRequestVM(Integer questionId) {


    public QuestionEditRequestVO getQuestionEditRequestVM(Integer questionId) {


        //题目映射


        Question question = questionMapper.selectByPrimaryKey(questionId);


        Question question = questionMapper.selectById(questionId);


        return getQuestionEditRequestVM(question);


    }




    @Override


    public QuestionEditRequestVM getQuestionEditRequestVM(Question question) {


    public QuestionEditRequestVO getQuestionEditRequestVM(Question question) {


        //题目映射


        TextContent questionInfoTextContent = textContentService.selectById(question.getInfoTextContentId());


        QuestionObject questionObject = JsonUtil.toJsonObject(questionInfoTextContent.getContent(), QuestionObject.class);


        QuestionEditRequestVM questionEditRequestVM = modelMapper.map(question, QuestionEditRequestVM.class);


        questionEditRequestVM.setTitle(questionObject.getTitleContent());


        QuestionObject questionObject = JsonUtil.toJsonObject(question.getContent(), QuestionObject.class);


        QuestionEditRequestVO questionEditRequestVO = new QuestionEditRequestVO();


        BeanUtils.copyProperties(question, questionEditRequestVO);


        questionEditRequestVO.setTitle(questionObject.getTitleContent());




        //答案


        QuestionTypeEnum questionTypeEnum = QuestionTypeEnum.fromCode(question.getQuestionType());


        switch (questionTypeEnum) {


            case SingleChoice:


            case TrueFalse:


                questionEditRequestVM.setCorrect(question.getCorrect());


            case Audio:


                questionEditRequestVO.setCorrect(question.getCorrect());


                break;


            case MultipleChoice:


                questionEditRequestVM.setCorrectArray(ExamUtil.contentToArray(question.getCorrect()));


                questionEditRequestVO.setCorrectArray(ExamUtil.contentToArray(question.getCorrect()));


                break;


            case GapFilling:


                List<String> correctContent = questionObject.getQuestionItemObjects().stream().map(d -> d.getContent()).collect(Collectors.toList());


                questionEditRequestVM.setCorrectArray(correctContent);


                questionEditRequestVO.setCorrectArray(correctContent);


                break;


            case ShortAnswer:


                questionEditRequestVM.setCorrect(questionObject.getCorrect());


            case Calculate:


            case Analysis:


                questionEditRequestVO.setCorrect(questionObject.getCorrect());


                break;


            default:


                break;


        }


        questionEditRequestVM.setScore(ExamUtil.scoreToVM(question.getScore()));


        questionEditRequestVM.setAnalyze(questionObject.getAnalyze());


        questionEditRequestVO.setAnalyze(questionObject.getAnalyze());






        //题目项映射


        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;


        List<QuestionEditItemVO> editItems = questionObject.getQuestionItemObjects().stream().map(o -> {


            QuestionEditItemVO questionEditItemVO = new QuestionEditItemVO();


            BeanUtils.copyProperties(o, questionEditItemVO);


            return questionEditItemVO;


        }).collect(Collectors.toList());


        questionEditRequestVM.setItems(editItems);


        return questionEditRequestVM;


        questionEditRequestVO.setItems(editItems);


        return questionEditRequestVO;


    }




    public void setQuestionInfoFromVM(TextContent infoTextContent, QuestionEditRequestVM model) {


    public String setQuestionInfoFromVM(QuestionEditRequestVO model) {


        List<QuestionItemObject> itemObjects = model.getItems().stream().map(i ->


                {


                    QuestionItemObject item = new QuestionItemObject();


                    item.setPrefix(i.getPrefix());


                    item.setContent(i.getContent());


                    item.setItemUuid(i.getItemUuid());


                    item.setScore(ExamUtil.scoreFromVM(i.getScore()));


                    return item;


                }


        ).collect(Collectors.toList());


@@ -168,7 +151,7 @@


        questionObject.setAnalyze(model.getAnalyze());


        questionObject.setTitleContent(model.getTitle());


        questionObject.setCorrect(model.getCorrect());


        infoTextContent.setContent(JsonUtil.toJsonStr(questionObject));


        return JsonUtil.toJsonStr(questionObject);


    }




    @Override


@@ -188,5 +171,12 @@


        }).collect(Collectors.toList());


    }




    @Override


    public Boolean updateStatus(QuestionResponseVO question) {


        return new LambdaUpdateChainWrapper<>(questionMapper)


                .set(Question::getStatus, question.getStatus())


                .eq(Question::getId, question.getId())


                .update();


    }




}