ieplus/ie-admin/src/main/java/com/ruoyi/web/service/LearnTeacherService.java

package com.ruoyi.web.service;

import cn.hutool.core.lang.Dict;
import com.alibaba.fastjson2.JSONObject;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.enums.ExamType;
import com.ruoyi.common.utils.NumberUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.dz.domain.DzClasses;
import com.ruoyi.dz.mapper.DzClassesMapper;
import com.ruoyi.enums.PaperType;
import com.ruoyi.ie.domain.AMarjorPlan;
import com.ruoyi.ie.mapper.AMarjorPlanMapper;
import com.ruoyi.learn.domain.*;
import com.ruoyi.learn.mapper.*;
import com.ruoyi.syzy.domain.BBusiWishUniversities;
import com.ruoyi.syzy.mapper.BBusiWishUniversitiesMapper;
import lombok.Data;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.Pair;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import javax.validation.ValidationException;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@Service
public class LearnTeacherService {
    private final DzClassesMapper dzClassesMapper;
    private final LearnKnowledgeTreeMapper learnKnowledgeTreeMapper;
    private final LearnStudentMapper learnStudentMapper;
    private final AMarjorPlanMapper marjorPlanMapper;
    private final BBusiWishUniversitiesMapper busiWishUniversitiesMapper;
    private final LearnDirectedKnowledgeMapper learnDirectedKnowledgeMapper;
    private final PaperService paperService;
    private final CommService commService;
    private final LearnTestPaperMapper learnTestPaperMapper;
    private final LearnQuestionsMapper learnQuestionsMapper;

    public LearnTeacherService(DzClassesMapper dzClassesMapper, LearnKnowledgeTreeMapper learnKnowledgeTreeMapper, LearnStudentMapper learnStudentMapper, AMarjorPlanMapper marjorPlanMapper, BBusiWishUniversitiesMapper busiWishUniversitiesMapper, LearnDirectedKnowledgeMapper learnDirectedKnowledgeMapper, PaperService paperService, CommService commService, LearnTestPaperMapper learnTestPaperMapper, LearnQuestionsMapper learnQuestionsMapper) {
        this.dzClassesMapper = dzClassesMapper;
        this.learnKnowledgeTreeMapper = learnKnowledgeTreeMapper;
        this.learnStudentMapper = learnStudentMapper;
        this.marjorPlanMapper = marjorPlanMapper;
        this.busiWishUniversitiesMapper = busiWishUniversitiesMapper;
        this.learnDirectedKnowledgeMapper = learnDirectedKnowledgeMapper;
        this.paperService = paperService;
        this.commService = commService;
        this.learnTestPaperMapper = learnTestPaperMapper;
        this.learnQuestionsMapper = learnQuestionsMapper;
    }

    public List<LearnQuestions> getQuestionTypes(Long subjectId, Collection<Long> knowledgeIds) {
        return learnQuestionsMapper.statQuestionTypes(subjectId, knowledgeIds);
    }

    public List<JSONObject> getClassesBuildStats(String buildType, Long teacherId, Long batchId, ExamType examType, Long subjectId, Long planId) {
        if("ExactIntelligent".equals(buildType)){
            return dzClassesMapper.selectClassesDirectedBuildStats(buildType, teacherId, batchId, subjectId, null);
        } else if("ExactHand".equals(buildType)){
            return dzClassesMapper.selectClassesDirectedBuildStats(buildType, teacherId, batchId, subjectId, planId);
        }
        return dzClassesMapper.selectClassesBuildStats(buildType, teacherId, batchId, subjectId, examType.name());
    }

    public List<DzClasses> getClasses(Long teacherId)
    {
        return dzClassesMapper.selectClassesForTeacher(teacherId);
    }

    public List<LearnStudent> getStudents(Long batchId, Long classId) {
        return learnStudentMapper.selectClassStudents(batchId, new Long[] {classId});
    }

    public List<BBusiWishUniversities> selectUniversityList(Long teacherId, Long batchId) {
        return busiWishUniversitiesMapper.selectUniversityListForTeacher(teacherId, batchId);
    }

    public List<Dict> selectMajorList(Long universityId, Integer year, Long batchId) {
        // TODO 由于未区分考生类型，好些会重复，暂取最小计划，使用这个去匹配相关的类型
        return marjorPlanMapper.selectMajorForUniversity(universityId, year, batchId).stream().map(t -> Dict.create().set("id", t.getId()).set("majorGroup", t.getMajorGroup())
                .set("majorName", t.getMajorName()).set("count", t.getXuefei()).set("total", t.getPlanTotal())).collect(Collectors.toList());
    }

    @Transactional(rollbackFor = Exception.class)
    public String buildPapersAuto(TestPaperVO.TestPapersAutoReq req) {
        if(null != req) {
            return "";
        }
        // 查询 院校，专业组，专业计划范围, 明细一级时只有一个，否则就是批量
        List<LearnStudent> studentList = learnStudentMapper.selectLearnStudentsByMap(req.toMap());
        if(CollectionUtils.isEmpty(studentList)) {
            throw new ValidationException("无可用计划可检查");
        }
        Set<Long> planIdSet = Sets.newHashSet();
        Map<Long, List<LearnStudent>> universityMap = Maps.newHashMap();
        for(LearnStudent ls : studentList){
            planIdSet.add(ls.getMajorPlanId());
            List<LearnStudent> list = universityMap.get(ls.getUniversityId());
            if(null == list) {
                list = Lists.newArrayList();
                universityMap.put(ls.getUniversityId(), list);
            }
            list.add(ls);
        }
        // 查询已经生成的
        Map<Long, Map<String, LearnTestPaper>> universityDirectPaperMap = learnTestPaperMapper.selectByBatchAndUniversityIds(req.getBatchId(), universityMap.keySet()).stream()
                .collect(Collectors.groupingBy(LearnTestPaper::getUniversityId, Collectors.toMap(LearnTestPaper::getDirectKey, a -> a)));
        if(null == req.getDirectType() || !req.getDirectType()) { // 全量
            LearnPaper paper = new LearnPaper();
            paper.setPaperName(req.getTitle());
            paper.setYear(Calendar.getInstance().get(Calendar.YEAR));
            paper.setPaperType(PaperType.Test.name());
            paper.setSubjectId(req.getSubjectId());
            paper.setDirectKey("");
            paper.setFenshu(0);
            for(Long universityId : universityMap.keySet()) {
                Map<String, LearnTestPaper> directPaperMap = universityDirectPaperMap.get(universityId);
                if(null != directPaperMap && directPaperMap.containsKey("")) {
                    continue;
                }
                if(null == paper.getId()) {
                    Pair<LearnPaper, List<LearnPaperQuestion>> paperResult = paperService.buildPaper(null, paper, req.getPaperDef());
                    paperService.savePaper(paper, paperResult.getRight());
                }
                LearnTestPaper testPaper = new LearnTestPaper();
                testPaper.setBatchId(req.getBatchId());
                testPaper.setUniversityId(universityId);
                testPaper.setDirectKey("");
                testPaper.setPaperId(paper.getId());
                learnTestPaperMapper.insertLearnTestPaper(testPaper);
            }
            return "";
        }
        TestPaperVO.PaperDef paperDef = req.getPaperDef();
        if(null != req.getPlanIds() && req.getPlanIds().size() == 1) {
            if(!CollectionUtils.isEmpty(paperDef.getKnowIds())) {
                throw new ValidationException("批量时不支持自定义知识点");
            }
        }
        Map<Long, Map<String, LearnDirectedKnowledge>> universityDirectedKnowledgeMap = learnDirectedKnowledgeMapper.selectByUniversityIds(universityMap.keySet().toArray(new Long[universityMap.size()])).stream().collect(
                Collectors.groupingBy(LearnDirectedKnowledge::getUniversityId, Collectors.toMap(LearnDirectedKnowledge::getDirectKey, a -> a)));
        Map<Long, AMarjorPlan> planMap = marjorPlanMapper.selectAMarjorPlanByIds(planIdSet.toArray(new Long[planIdSet.size()])).stream().collect(Collectors.toMap(AMarjorPlan::getId, a -> a));

        LearnDirectedKnowledge directedKnowledge = null;
        String directedKey = null;

        for(Long universityId : universityMap.keySet()) {
            Map<String, LearnDirectedKnowledge> directedKnowledgeMap = universityDirectedKnowledgeMap.get(universityId);
            for(LearnStudent ls : universityMap.get(universityId)) {
                AMarjorPlan plan = planMap.get(ls.getMajorPlanId());
                String groupName = StringUtils.trimToEmpty(plan.getMajorGroup());
                if(CollectionUtils.isEmpty(paperDef.getKnowIds())) {
                    if(null != (directedKnowledge = directedKnowledgeMap.get((directedKey = groupName + "_" + plan.getMajorName())))) {
                        paperDef.setKnowIds(Stream.of(directedKnowledge.getKnowledges().split(",")).map(t -> Long.parseLong(t.trim())).collect(Collectors.toList()));
                    } else if(null != (directedKnowledge = directedKnowledgeMap.get(directedKey = groupName))) {
                        paperDef.setKnowIds(Stream.of(directedKnowledge.getKnowledges().split(",")).map(t -> Long.parseLong(t.trim())).collect(Collectors.toList()));
                    } else {
                        throw new ValidationException("院校没有配置定向知识点，生成失败: " + universityId + ":" + groupName + ":" + plan.getMajorName());
                    }
                } else if(null != directedKnowledgeMap) {
                    if(null != (directedKnowledge = directedKnowledgeMap.get((directedKey = groupName + "_" + plan.getMajorName())))) {
                    } else if(null != (directedKnowledge = directedKnowledgeMap.get(directedKey = groupName))) {
                    } else {
                        throw new ValidationException("院校没有配置定向知识点，生成失败" + universityId + ":" + directedKey);
                    }
                } else {
                    throw new ValidationException("院校没有配置定向知识点，生成失败: " + universityId);
                }
                Map<String, LearnTestPaper> directPaperMap = universityDirectPaperMap.get(universityId);
                if(null != directPaperMap && directPaperMap.containsKey(directedKey)) {
                    continue;
                }
                LearnPaper paper = new LearnPaper();
                paper.setSubjectId(req.getSubjectId());
                paper.setPaperName(req.getTitle());
                paper.setYear(plan.getYear());
                paper.setPaperType(PaperType.Test.name());
                paper.setDirectKey(directedKey);
                paper.setFenshu(0);
                Pair<LearnPaper, List<LearnPaperQuestion>> paperResult = paperService.buildPaper(null, paper, paperDef);
                paperService.savePaper(paperResult.getKey(), paperResult.getValue());

                LearnTestPaper testPaper = new LearnTestPaper();
                testPaper.setBatchId(req.getBatchId());
                testPaper.setUniversityId(universityId);
                testPaper.setDirectKey(directedKey);
                testPaper.setPaperId(paper.getId());
                learnTestPaperMapper.insertLearnTestPaper(testPaper);
                directPaperMap.put(directedKey, testPaper);
            }
        }
        return "";
    }

    @Transactional(rollbackFor = Exception.class)
    public String buildPapersManual(TestPaperVO.TestPapersHandReq req) {
        if(null != req) {
            return "";
        }
        if(null == req.getSubjectId()) {
            throw new ValidationException("未选择科目");
        }
        // 查询 院校，专业组，专业计划范围, 明细一级时只有一个，否则就是批量
        List<LearnStudent> studentList = learnStudentMapper.selectLearnStudentsByMap(req.toMap());
        if(CollectionUtils.isEmpty(studentList)) {
            throw new ValidationException("无可用计划可检查");
        }
        Set<Long> planIdSet = Sets.newHashSet();
        Map<Long, List<LearnStudent>> universityMap = Maps.newHashMap();
        for(LearnStudent ls : studentList){
            planIdSet.add(ls.getMajorPlanId());
            List<LearnStudent> list = universityMap.get(ls.getUniversityId());
            if(null == list) {
                list = Lists.newArrayList();
                universityMap.put(ls.getUniversityId(), list);
            }
            list.add(ls);
        }
        // 查询已经生成的
        Map<Long, Map<String, LearnTestPaper>> universityDirectPaperMap = learnTestPaperMapper.selectByBatchAndUniversityIds(req.getBatchId(), universityMap.keySet()).stream()
                .collect(Collectors.groupingBy(LearnTestPaper::getUniversityId, Collectors.toMap(LearnTestPaper::getDirectKey, a -> a)));

        LearnPaper paper = new LearnPaper();
        paper.setPaperName(req.getTitle());
        paper.setYear(Calendar.getInstance().get(Calendar.YEAR));
        paper.setPaperType(PaperType.Test.name());
        if(null == req.getDirectType() || !req.getDirectType()) { // 全量
            paper.setSubjectId(req.getSubjectId());
            paper.setDirectKey("");
            paper.setFenshu(0);
            for(Long universityId : universityMap.keySet()) {
                Map<String, LearnTestPaper> directPaperMap = universityDirectPaperMap.get(universityId);
                if(null != directPaperMap && directPaperMap.containsKey("")) {
                    continue;
                }
                if(null == paper.getId()) {
                    paperService.savePaper(paper, req.getQuestions());
                }
                LearnTestPaper testPaper = new LearnTestPaper();
                testPaper.setBatchId(req.getBatchId());
                testPaper.setUniversityId(universityId);
                testPaper.setDirectKey("");
                testPaper.setPaperId(paper.getId());
                testPaper.setConditions("");
                testPaper.setCreatorId(SecurityUtils.getUserId());
                learnTestPaperMapper.insertLearnTestPaper(testPaper);
            }
            return "";
        } // 定向
        // 准备定向数据
        Map<Long, Map<String, LearnDirectedKnowledge>> universityDirectedKnowledgeMap = learnDirectedKnowledgeMapper.selectByUniversityIds(universityMap.keySet().toArray(new Long[universityMap.size()])).stream().collect(
                Collectors.groupingBy(LearnDirectedKnowledge::getUniversityId, Collectors.toMap(LearnDirectedKnowledge::getDirectKey, a -> a)));
        Map<Long, AMarjorPlan> planMap = marjorPlanMapper.selectAMarjorPlanByIds(planIdSet.toArray(new Long[planIdSet.size()])).stream().collect(Collectors.toMap(AMarjorPlan::getId, a -> a));

        String directedKey = null;
        for(Long universityId : universityMap.keySet()) {
            Map<String, LearnTestPaper> directPaperMap = universityDirectPaperMap.get(universityId);
            Map<String, LearnDirectedKnowledge> directedKnowledgeMap = universityDirectedKnowledgeMap.get(universityId);
            for(LearnStudent ls : universityMap.get(universityId)) { // Group+Name
                AMarjorPlan plan = planMap.get(ls.getMajorPlanId());
                String groupName = StringUtils.trimToEmpty(plan.getMajorGroup());
                if(null != (directedKnowledgeMap.get(directedKey = groupName + "_" + plan.getMajorName()))) {
                    if(null != directPaperMap.get(directedKey)) {
                        continue;
                    }
                } else if(null != directedKnowledgeMap.get(directedKey = groupName)) {
                    if(null != directPaperMap.get(directedKey)) {
                        continue;
                    }
                } else {
                    continue;
                }
                if(null == paper.getId()) {
                    paperService.savePaper(paper, req.getQuestions());
                }
                LearnTestPaper testPaper = new LearnTestPaper();
                testPaper.setBatchId(req.getBatchId());
                testPaper.setUniversityId(universityId);
                testPaper.setDirectKey(directedKey);
                testPaper.setPaperId(paper.getId());
                learnTestPaperMapper.insertLearnTestPaper(testPaper);
                directPaperMap.put(directedKey, testPaper);
            }
        }
        return "";
    }

    public List<TreeNode> getKnowledgeTree(String examineeType, Long subjectId, Set<Long> knowledgeIdSet, Long studentId) {
        LearnKnowledgeTree ktCond = new LearnKnowledgeTree();
        ktCond.setSubjectId(subjectId);
        ktCond.setExamineeTypes(examineeType);
        List<LearnKnowledgeTree> ktList = learnKnowledgeTreeMapper.selectLearnKnowledgeTreeList(ktCond);
        Map<Long, Integer[]> knowCountMap = null;
        if(NumberUtils.isPositive(studentId) && !CollectionUtils.isEmpty(ktList)) {
            Map cond = Maps.newHashMap();
            cond.put("studentId", studentId);
            cond.put("knowIds", ktList.stream().map(LearnKnowledgeTree::getId).collect(Collectors.toList()));
            cond.put("types", Lists.newArrayList("单选题", "判断题"));
            knowCountMap = Maps.newHashMap();
            for(LearnQuestions qs : learnQuestionsMapper.statByKnowledge(cond)) {
                knowCountMap.put(qs.getKnowledgeId(), new Integer[] { qs.getNumber().intValue(), qs.getId().intValue()} );
            }
        }
        return commService.buildTree(ktList, knowledgeIdSet, knowCountMap);
    }

    public String updateDirected(Long studentId, Long universityId, Long planId) {
        LearnStudent upStudent = new LearnStudent();
        upStudent.setStudentId(studentId);
        upStudent.setUniversityId(universityId);
        upStudent.setMajorPlanId(planId);
        upStudent.setDirectKey("");
        AMarjorPlan plan = marjorPlanMapper.selectAMarjorPlanById(planId);
        LearnDirectedKnowledge dkCond = new LearnDirectedKnowledge();
        dkCond.setUniversityId(plan.getUniversityId());
        dkCond.setYear(plan.getYear());
        SysUser sysUser = SecurityUtils.getLoginUser().getUser();
        dkCond.setLocations(sysUser.getLocation());
        dkCond.setExamineeTypes(sysUser.getExamType().name());
        Map<String, LearnDirectedKnowledge> directedKnowledgeMap = learnDirectedKnowledgeMapper.selectLearnDirectedKnowledgeList(dkCond).stream().collect(Collectors.toMap(LearnDirectedKnowledge::getDirectKey, t -> t));
        LearnDirectedKnowledge directedKnowledge = getBestLearnDirectedKnowledge(plan, directedKnowledgeMap);
        String modules = null;
        if(null != directedKnowledge) {
            upStudent.setDirectKey(directedKnowledge.getDirectKey());
            modules = directedKnowledge.getModules();
        }
        learnStudentMapper.updateLearnStudent(upStudent);
        Set<String> moduleSet = Sets.newHashSet(StringUtils.trimToEmpty(modules).split(","));
        return moduleSet.size() == 1 && moduleSet.contains("技能展示") ? "专业只考技能展示" : "";
    }

    private LearnDirectedKnowledge getBestLearnDirectedKnowledge(AMarjorPlan plan, Map<String, LearnDirectedKnowledge> directedKnowledgeMap) {
        LearnDirectedKnowledge directedKnowledge = null;
        String groupName = StringUtils.trimToEmpty(plan.getMajorGroup());
        if(null != (directedKnowledge = directedKnowledgeMap.get(groupName + "_" + plan.getMajorName()))) {
            return directedKnowledge;
        }
        for(String directKey : directedKnowledgeMap.keySet()) {
            if(directKey.contains("、") && (directKey.startsWith(groupName + "_"))) {
                Set<String> marjorSet = Arrays.stream(directKey.split("_|、")).filter(t -> !t.isEmpty()).collect(Collectors.toSet());
                if(marjorSet.contains(plan.getMajorName())) {
                    return directedKnowledgeMap.get(directKey);
                }
            }
        }
        if(null != (directedKnowledge = directedKnowledgeMap.get(groupName))) {
            return directedKnowledge;
        }
        if(null != (directedKnowledge = directedKnowledgeMap.get(""))) {
            return directedKnowledge;
        }
        return directedKnowledge;
    }

    public Set<Long> getSubjectIdSet(Long[] planIds) {
        Set<Long> subjectIdSet = Sets.newHashSet();
        if(ArrayUtils.isNotEmpty(planIds)) {
            List<AMarjorPlan> planList = marjorPlanMapper.selectAMarjorPlanByIds(planIds);
            AMarjorPlan curr = planList.get(0);
            LearnDirectedKnowledge dkCond = new LearnDirectedKnowledge();
            dkCond.setUniversityId(curr.getUniversityId());
            dkCond.setYear(curr.getYear());
            SysUser sysUser = SecurityUtils.getLoginUser().getUser();
            dkCond.setLocations(sysUser.getLocation());
            dkCond.setExamineeTypes(sysUser.getExamType().name());
            Map<String, LearnDirectedKnowledge> directedKnowledgeMap = learnDirectedKnowledgeMapper.selectLearnDirectedKnowledgeList(dkCond).stream().collect(Collectors.toMap(LearnDirectedKnowledge::getDirectKey, t -> t));
            LearnDirectedKnowledge directedKnowledge = null;
            for(AMarjorPlan plan : planList) {
                if(null != (directedKnowledge = getBestLearnDirectedKnowledge(plan, directedKnowledgeMap))) {
                    subjectIdSet.addAll(Stream.of(directedKnowledge.getSubjects().split(",")).map(t -> Long.parseLong(t.trim())).collect(Collectors.toList()));
                }
            }
        }
        return subjectIdSet;
    }

    public Set<Long> getKnowledgeIdSet(Long planId) {
        if(NumberUtils.isPositive(planId)) {
            SysUser sysUser = SecurityUtils.getLoginUser().getUser();
            List<AMarjorPlan> planList = marjorPlanMapper.selectAMarjorPlanByIds(new Long[] { planId });
            if(CollectionUtils.isEmpty(planList)) {
                return Sets.newHashSet();
            }
            return getStudentKnowledgeIdSet(planList.get(0), sysUser.getLocation(), sysUser.getExamType().name());
        }
        return Sets.newHashSet();
    }

    public Set<Long> getStudentKnowledgeIdSet(AMarjorPlan curr, String location, String examType) {
        Set<Long> knowledgeIdSet = Sets.newHashSet();
        LearnDirectedKnowledge dkCond = new LearnDirectedKnowledge();
        dkCond.setUniversityId(curr.getUniversityId());
        dkCond.setYear(curr.getYear());

        dkCond.setLocations(location);
        dkCond.setExamineeTypes(examType);
        Map<String, LearnDirectedKnowledge> directedKnowledgeMap = learnDirectedKnowledgeMapper.selectLearnDirectedKnowledgeList(dkCond).stream().collect(Collectors.toMap(LearnDirectedKnowledge::getDirectKey, t -> t));
        LearnDirectedKnowledge directedKnowledge = null;
        if(null != (directedKnowledge = getBestLearnDirectedKnowledge(curr, directedKnowledgeMap))) {
            knowledgeIdSet.addAll(Stream.of(directedKnowledge.getKnowledges().split(",")).map(t -> Long.parseLong(t.trim())).collect(Collectors.toList()));
        }
        return knowledgeIdSet;
    }

    @Data
    public static class TreeNode {
        private Long id;
        private String name;
        private Integer status;
        private Integer questionCount;
        private Integer finishedCount;

        List<TreeNode> children = Lists.newArrayList();
        public TreeNode(Long id, String name, Integer[] counts) {
            this.id = id;
            this.name = name;
            this.status = 0;
            this.questionCount = null != counts ? counts[0] : 0;
            this.finishedCount = null != counts ? counts[1] : 0;
        }

        public boolean setChecked(Set<Long> idSet) {
            boolean checkSelf = idSet.contains(id);
            if(CollectionUtils.isEmpty(children)) {
                this.status = checkSelf ? 1 : 0;
                return true;
            }
            int count = 0;
            for(TreeNode tn : children) {
                if(checkSelf || idSet.contains(tn.getId())) {
                    tn.setStatus(1);
                    count++;
                }
            }
            if(children.size() == count) {
                this.status = 1;
                return true;
            }
            return false;
        }
    }
}