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.constants.enums.status.DirectionStatus;
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.data.relation.UserQuestionRelationMapper;
import com.qxgmat.data.relation.entity.UserRecordStatRelation;
import com.qxgmat.data.relation.entity.UserReportLimitRelation;
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;

    @Resource
    private UserQuestionRelationMapper userQuestionRelationMapper;

    /**
     * 获取报告列表：以paper进行分组
     * @param page
     * @param size
     * @param userId
     * @param startTime
     * @param endTime
     * @param order
     * @return
     */
    public Page<UserQuestion> listExerciseError(int page, int size, Integer userId, String keyword, String[] questionTypes, String[] courseModule, Integer[] structIds, Date startTime, Date endTime, String order){
        Page<UserQuestion> p = page(()->{
            userQuestionRelationMapper.listExerciseError(userId, keyword, questionTypes, courseModule, structIds, startTime, endTime, order);
        }, page, size);

        Collection ids = Transform.getIds(p, UserQuestion.class, "id");

        // 获取详细数据
        List<UserQuestion> list = select(ids);
        Transform.replace(p, list, UserQuestion.class, "id");
        return p;
    }

    /**
     * 获取报告列表：以paper进行分组
     * @param page
     * @param size
     * @param userId
     * @param startTime
     * @param endTime
     * @param order
     * @return
     */
    public Page<UserQuestion> listExaminationError(int page, int size, Integer userId, String keyword, String[] questionTypes, Integer[] structIds, Integer libraryId, String year, Date startTime, Date endTime, String order){
        Page<UserQuestion> p = page(()->{
            userQuestionRelationMapper.listExaminationError(userId, keyword, questionTypes, structIds, libraryId, year, startTime, endTime, order);
        }, page, size);

        Collection ids = Transform.getIds(p, UserQuestion.class, "id");

        // 获取详细数据
        List<UserQuestion> list = select(ids);
        Transform.replace(p, list, UserQuestion.class, "id");
        return p;
    }

    /**
     * 查找userQuestion最后一次做题记录
     * @param questionIds
     */
    public List<UserQuestion> listWithLast(Integer userId, Collection questionIds){
        if(questionIds == null || questionIds.size() == 0) return new ArrayList<>();
        List<UserQuestion> list = userQuestionRelationMapper.listLast(userId, questionIds);

        Collection reportIds = Transform.getIds(list, UserQuestion.class, "id");
        Transform.replace(list, select(reportIds), UserQuestion.class, "id");
        return list;
    }

    /**
     * 根据用户题目获取该题总统计
     * @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){
        if (questionIds == null || questionIds.size() == 0) return new ArrayList<>();
        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, QuestionModule questionModule, Collection questionNoIds){
        if (questionNoIds == null || questionNoIds.size() == 0) return new ArrayList<>();
        Example example = new Example(UserQuestion.class);
        example.and(
                example.createCriteria()
                        .andEqualTo("userId", userId)
                        .andEqualTo("questionModule", questionModule.key)
                        .andIn("questionNoId", questionNoIds)
        );
        return select(userQuestionMapper, example);
    }

    public List<UserQuestion> listByQuestionWithTime(Integer userId, QuestionModule questionModule, Collection questionNoIds, Date startTime, Date endTime){
        if (questionNoIds == null || questionNoIds.size() == 0) return new ArrayList<>();
        Example example = new Example(UserQuestion.class);
        example.and(
                example.createCriteria()
                        .andEqualTo("userId", userId)
                        .andEqualTo("questionModule", questionModule.key)
                        .andIn("questionNoId", questionNoIds)
                        .andGreaterThanOrEqualTo("createTime", startTime)
                        .andLessThan("createTime", endTime)
        );
        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 (userQuestion.getUserTime()<=0){
                continue;
            }
            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 (userQuestion.getUserTime()<=0){
                continue;
            }
            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, String stage){
        Example example = new Example(UserQuestion.class);
        example.and(
                example.createCriteria()
                        .andEqualTo("userId", userId)
                        .andEqualTo("reportId", userReportId)
        );
        if (stage == null){
            example.and(
                    example.createCriteria()
                    .andEqualTo("no", no)
            );
        }else{
            example.and(
                    example.createCriteria()
                    .andEqualTo("stage", stage)
                    .andEqualTo("stageNo", 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)
                // 子阶段序号：外部切换stage重置
                .stage(lastQuestion != null ? lastQuestion.getStage(): "")
                .stageNo(lastQuestion != null ? lastQuestion.getStageNo() + 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);
    }


    /**
     * 统计用户的做题记录
     * @param userId
     * @param startTime
     * @param endTime
     * @return
     */
    public UserRecordStatRelation stat(Integer userId, Date startTime, Date endTime){
        List<UserRecordStatRelation> list = userQuestionRelationMapper.stat(userId, startTime, endTime);
        if (list!=null && list.size() > 0){
            return list.get(0);
        }
        return null;
    }

    /**
     * 统计全站的做题记录
     * @param startTime
     * @param endTime
     * @return
     */
    public UserRecordStatRelation statAvg(Date startTime, Date endTime){
        List<UserRecordStatRelation> list = userQuestionRelationMapper.statAvg(startTime, endTime);
        if (list!=null && list.size() > 0){
            return list.get(0);
        }
        return null;
    }

    /**
     * 按report统计在限定时间内的做题结果
     * @param reportId
     * @return
     */
    public UserReportLimitRelation statLimit(Integer reportId){
        List<UserReportLimitRelation> relations =  userQuestionRelationMapper.statLimit(reportId);
        if (relations.size() > 0 && relations.get(0) != null){
            return relations.get(0);
        }else{
            return new UserReportLimitRelation();
        }
    }

    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);
    }

}