sourcecode/server/gateway-api/src/main/java/com/qxgmat/service/UserQuestionService.java

package com.qxgmat.service;

import com.alibaba.fastjson.JSONObject;
import com.github.pagehelper.Page;
import com.nuliji.tools.AbstractService;
import com.nuliji.tools.PageResult;
import com.nuliji.tools.Transform;
import com.nuliji.tools.exception.ParameterException;
import com.nuliji.tools.exception.SystemException;
import com.nuliji.tools.mybatis.Example;
import com.qxgmat.data.constants.enums.module.PaperModule;
import com.qxgmat.data.constants.enums.module.QuestionModule;
import com.qxgmat.data.dao.UserQuestionMapper;
import com.qxgmat.data.dao.entity.UserQuestion;
import com.qxgmat.data.dao.entity.UserReport;
import com.qxgmat.data.inline.UserQuestionStat;
import com.qxgmat.service.annotation.InitQuestion;
import com.qxgmat.service.inline.QuestionNoService;
import com.qxgmat.service.inline.SentenceQuestionService;
import com.qxgmat.util.annotation.Callback;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class UserQuestionService extends AbstractService {
    private static final Logger logger = LoggerFactory.getLogger(UserQuestionService.class);

    @Resource
    private UserQuestionMapper userQuestionMapper;

    /**
     * 用户错题记录：相同题目的最后一次做题记录及其编号
     * @param page
     * @param size
     * @param userId
     * @return
     */
    public PageResult<UserQuestion> listError(int page, int size, Integer userId){
        // todo 查询错题列表
        return new PageResult<>(null, 0);
    }

    /**
     * 根据用户题目获取该题总统计
     * @param userQuestionList
     * @return
     */
    public UserQuestionStat statQuestion(List<UserQuestion> userQuestionList){
        UserQuestionStat stat = new UserQuestionStat();
        Integer totalTime = 0;
        Integer totalNumber = 0;
        Integer totalCorrect = 0;
        for(UserQuestion question : userQuestionList){
            totalTime += question.getUserTime();
            totalNumber += 1;
            totalCorrect += question.getIsCorrect();
        }
        stat.setUserCorrect(totalCorrect);
        stat.setUserNumber(totalNumber);
        stat.setUserTime(totalTime);
        return stat;
    }

    public List<UserQuestion> listByQuestion(Integer userId, Collection questionIds){
        Example example = new Example(UserQuestion.class);
        example.and(
                example.createCriteria()
                        .andEqualTo("userId", userId)
                        .andIn("questionId", questionIds)
        );
        return select(userQuestionMapper, example);
    }

    public List<UserQuestion> listByQuestionNo(Integer userId, Collection questionNoIds){
        Example example = new Example(UserQuestion.class);
        example.and(
                example.createCriteria()
                        .andEqualTo("userId", userId)
                        .andIn("questionNoId", questionNoIds)
        );
        return select(userQuestionMapper, example);
    }

    /**
     * 根据试卷分组获取统计信息
     * @param userQuestionList
     * @return
     */
    public Map<Object, UserQuestionStat> statQuestionMap(List<UserQuestion> userQuestionList){
        Map<Object, UserQuestionStat> relationMap = new HashMap<>();
        Map<Integer, List<UserQuestion>> map = new HashMap<>();
        for (UserQuestion userQuestion: userQuestionList){
            if (!map.containsKey(userQuestion.getQuestionId())){
                map.put(userQuestion.getQuestionId(), new ArrayList<>());
            }
            List<UserQuestion> list = map.get(userQuestion.getQuestionId());
            list.add(userQuestion);
        }
        for(Integer questionId : map.keySet()){
            relationMap.put(questionId, statQuestion(map.get(questionId)));
        }

        return relationMap;
    }

    /**
     * 根据试卷分组获取统计信息
     * @param userQuestionList
     * @return
     */
    public Map<Object, UserQuestionStat> statQuestionNoMap(List<UserQuestion> userQuestionList){
        Map<Object, UserQuestionStat> relationMap = new HashMap<>();
        Map<Integer, List<UserQuestion>> map = new HashMap<>();
        for (UserQuestion userQuestion: userQuestionList){
            if (!map.containsKey(userQuestion.getQuestionNoId())){
                map.put(userQuestion.getQuestionNoId(), new ArrayList<>());
            }
            List<UserQuestion> list = map.get(userQuestion.getQuestionNoId());
            list.add(userQuestion);
        }
        for(Integer questionNoId : map.keySet()){
            relationMap.put(questionNoId, statQuestion(map.get(questionNoId)));
        }

        return relationMap;
    }

    /**
     * 获取当前报告最后一题
     * @param userId
     * @param userReportId
     * @return
     */
    public UserQuestion getLastByReport(Integer userId, Integer userReportId){
        Example example = new Example(UserQuestion.class);
        example.and(
                example.createCriteria()
                        .andEqualTo("userId", userId)
                        .andEqualTo("reportId", userReportId)
        );
        example.orderBy("id").desc();
        return one(userQuestionMapper, example);
    }

    /**
     * 获取报告对应序号题目
     * @param userId
     * @param userReportId
     * @param no
     * @return
     */
    public UserQuestion getByReportAndNo(Integer userId, Integer userReportId, Integer no){
        Example example = new Example(UserQuestion.class);
        example.and(
                example.createCriteria()
                        .andEqualTo("userId", userId)
                        .andEqualTo("reportId", userReportId)
                        .andEqualTo("no", no)
        );
        return one(userQuestionMapper, example);
    }

    /**
     * 根据用户report创建下一题
     * @param report
     * @param lastQuestion
     * @return
     */
    public UserQuestion newByReport(UserReport report, UserQuestion lastQuestion){
        // 根据report模块获取试题所属模块
        QuestionModule module = QuestionModule.WithPaper(PaperModule.ValueOf(report.getPaperModule()));
        UserQuestion question = UserQuestion.builder()
                .reportId(report.getId())
                .questionModule(module.key)
                .userId(report.getUserId())
                // 添加题目序号
                .no(lastQuestion != null ? lastQuestion.getNo() + 1: 1)
                .build();
        return question;
    }

    /**
     * 获取报告的所有做题记录
     * @param userId
     * @param userReportId
     * @return
     */
    public List<UserQuestion> listByReport(Integer userId, Integer userReportId){
        Example example = new Example(UserQuestion.class);
        example.and(
                example.createCriteria()
                        .andEqualTo("userId", userId)
                        .andEqualTo("reportId", userReportId)
        );
        example.orderBy("id").asc();
        return select(userQuestionMapper, example);
    }

    /**
     * 获取报告固定题目类型做题记录
     * @return
     */
    public List<UserQuestion> listByReportAndType(Integer userId, Integer userReportId, Collection questionTypes){
        Example example = new Example(UserQuestion.class);
        example.and(
                example.createCriteria()
                        .andEqualTo("userId", userId)
                        .andEqualTo("reportId", userReportId)
                        .andIn("questionType", questionTypes)
        );
        example.orderBy("id").asc();
        return select(userQuestionMapper, example);
    }

    public UserQuestion add(UserQuestion question){
        int result = insert(userQuestionMapper, question);
        question = one(userQuestionMapper, question.getId());
        if(question == null){
            throw new SystemException("用户题目添加失败");
        }
        return question;
    }

    public UserQuestion edit(UserQuestion question){
        UserQuestion in = one(userQuestionMapper, question.getId());
        if(in == null){
            throw new ParameterException("用户题目不存在");
        }
        int result = update(userQuestionMapper, question);
        return question;
    }

    public boolean delete(Number id){
        UserQuestion in = one(userQuestionMapper, id);
        if(in == null){
            throw new ParameterException("用户题目不存在");
        }
        int result = delete(userQuestionMapper, id);
        return result > 0;
    }

    public UserQuestion get(Number id){
        UserQuestion in = one(userQuestionMapper, id);

        if(in == null){
            throw new ParameterException("用户题目不存在");
        }
        return in;
    }

    public Page<UserQuestion> select(int page, int pageSize){
        return select(userQuestionMapper, page, pageSize);
    }

    public Page<UserQuestion> select(Integer[] ids){
        return page(()->select(userQuestionMapper, ids), 1, ids.length);
    }

    public List<UserQuestion> select(Collection ids){
        return select(userQuestionMapper, ids);
    }

}