kps-backend/src/main/java/com/dayou/service/impl/CycleServiceImpl.java

package com.dayou.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.dayou.configuration.BaseEntity;
import com.dayou.configuration.ErrorCode;
import com.dayou.dao.CycleMapper;
import com.dayou.entity.*;
import com.dayou.service.*;
import com.dayou.utils.MathUtil;
import com.dayou.vo.CycleVO;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.math3.distribution.ChiSquaredDistribution;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * 类说明：
 *
 * @author: wucl
 * @since: 2023/7/20
 * created with IntelliJ IDEA.
 */
@Service
public class CycleServiceImpl extends ServiceImpl<CycleMapper, Cycle> implements ICycleService {

    @Autowired
    private CycleMapper cycleMapper;

    @Autowired
    private IProfessorResultService professorResultService;

    @Autowired
    private IQuestionAnalysisService questionAnalysisService;

    @Autowired
    private IQuestionService questionService;

    @Autowired
    private IFailQuestionService failQuestionService;

    @Override
    public IPage<CycleVO> getPage(Page page, CycleVO cycleVO) {
        IPage<CycleVO> result = cycleMapper.getPage(page,cycleVO);
        return result;
    }

    @Transactional
    @Override
    public Boolean saveCycle(Cycle cycle) {
        Integer cycleNum = cycle.getCycleNum();
        List<Cycle> list = this.list(new LambdaQueryWrapper<Cycle>().eq(Cycle::getDocumentId, cycle.getDocumentId())
                .eq(Cycle::getCycleNum, cycleNum).eq(BaseEntity::getDeleted, Boolean.FALSE));
        if (CollectionUtils.isEmpty(list)){
            Integer professorNum = cycle.getProfessorNum();
            BigDecimal probability = cycle.getProbability();
            //计算方分布的左尾概率的反函数值
            double chiSqValDouble = MathUtil.getChiSqVal(probability.doubleValue(),professorNum.doubleValue());
            BigDecimal chiSqVal = BigDecimal.valueOf(chiSqValDouble).setScale(4, RoundingMode.HALF_UP);
            cycle.setStandardValue(chiSqVal);
            this.save(cycle);
            //如果下发的是第一轮或者第二轮，就全量评分项下发
            if (cycleNum>2){
                Cycle previousCycle = this.getOne(new LambdaQueryWrapper<Cycle>().eq(Cycle::getDocumentId, cycle.getDocumentId())
                        .eq(Cycle::getCycleNum, (cycleNum - 1)));
                BigDecimal standardValue = previousCycle.getStandardValue();
                Long cycleId = previousCycle.getId();
                //获取上一轮的分析数据
                List<QuestionAnalysis> previousAnalysisData = questionAnalysisService.list(new LambdaQueryWrapper<QuestionAnalysis>().eq(QuestionAnalysis::getCycleId, cycleId));
                if (CollectionUtils.isEmpty(previousAnalysisData)){
                    return Boolean.TRUE;
                }
                //上一轮的所有评分项
                List<Long> allQuestionId = previousAnalysisData.stream().map(QuestionAnalysis::getQuestionId).collect(Collectors.toList());
                //上一轮所有父级评分项id
                Set<Long> questionsParentId = questionService.list(new LambdaQueryWrapper<Question>()
                        .in(BaseEntity::getId, allQuestionId).eq(BaseEntity::getDeleted, Boolean.FALSE)).stream().map(Question::getParentId).collect(Collectors.toSet());

                //上一轮未通过的评分项
                List<Long> notPassQuestionsId = previousAnalysisData.stream().filter(x -> x.getValidate().compareTo(standardValue) == 1).map(QuestionAnalysis::getQuestionId).collect(Collectors.toList());
                if (CollectionUtils.isEmpty(notPassQuestionsId)){
                    ErrorCode.throwBusinessException(ErrorCode.CUSTOM_ERROR,"此问卷评分项已全部通过，若需继续下发，请新建问卷。");
                }
                List<Question> questions = questionService.list(new LambdaQueryWrapper<Question>()
                        .in(BaseEntity::getId, notPassQuestionsId).eq(BaseEntity::getDeleted, Boolean.FALSE));
                Set<Long> notPassParentIds = questions.stream().map(Question::getParentId).collect(Collectors.toSet());
                questionsParentId.removeAll(notPassParentIds);
                //上轮通过的父级id
                if (CollectionUtils.isNotEmpty(questionsParentId)){
                    List<Long> passQuestionsId = questionService.list(new LambdaQueryWrapper<Question>().select(BaseEntity::getId).in(Question::getParentId, questionsParentId).eq(BaseEntity::getDeleted, Boolean.FALSE)).stream().map(BaseEntity::getId).collect(Collectors.toList());
                    if (CollectionUtils.isNotEmpty(passQuestionsId) && passQuestionsId.size()<previousAnalysisData.size()){
                        List<ProfessorResult> previousOriginData = professorResultService.list(new LambdaQueryWrapper<ProfessorResult>().eq(ProfessorResult::getCycleId, cycleId)
                                .in(ProfessorResult::getQuestionId,passQuestionsId));
                        previousOriginData.stream().forEach(x->{
                            x.setCycleId(cycle.getId());
                        });
                        professorResultService.saveBatch(previousOriginData);
                        List<FailQuestion> failQuestions = notPassParentIds.stream().map(q -> {
                            FailQuestion failQuestion = new FailQuestion();
                            failQuestion.setCycleId(cycle.getId());
                            failQuestion.setQuestionParentId(q);
                            return failQuestion;
                        }).collect(Collectors.toList());
                        failQuestionService.saveBatch(failQuestions);
                    }
                }

            }
            //如果下发的不是第一轮或者第二轮，专家端只需对上轮未通过的评分项再次评分。后端自动生成已通过评分项的评分数据。插入到professor_result
            // 找出上一轮未通过评分项的parentId,存入 fail_question
            return Boolean.TRUE;
        }else {
            ErrorCode.throwBusinessException(ErrorCode.CUSTOM_ERROR,"该问卷此轮已存在。");
            return Boolean.FALSE;
        }
    }

    @Override
    public Cycle nextCycle(Long documentId) {
        Cycle cycle = cycleMapper.nextCycle(documentId);
        if (cycle==null){
            cycle = new Cycle();
            cycle.setCycleNum(1);
        }
        return cycle;
    }

}