SubjectTreeServiceImpl.java

package com.meishu.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.meishu.dto.subject.GetSubjectTreeDTO;
import com.meishu.dto.subject.UpdateTreeOrderDTO;
import com.meishu.mapper.*;
import com.meishu.model.*;
import com.meishu.service.SubjectTreeService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.meishu.util.ConstantUtils;
import com.meishu.util.tree.SerialNumber;
import com.meishu.vo.subject.GetSubjectTreeVO;
import com.meishu.vo.subject.SubjectTreeOrder;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author Tuyp
 * @since 2021-04-27
 */
@Service
public class SubjectTreeServiceImpl extends ServiceImpl<SubjectTreeMapper, SubjectTreeDO> implements SubjectTreeService {

    @Autowired
    private KnowledgeSubjectDictMapper knowledgeSubjectDictMapper;

    @Autowired
    private SubjectTreeMapper subjectTreeMapper;

    @Autowired
    private VodSubjectTreeMappingMapper vodSubjectTreeMappingMapper;

    @Autowired
    private ExerciseTreeMappingMapper exerciseTreeMappingMapper;

    @Autowired
    private AdministerMapper administerMapper;

    @Autowired
    private VodDictMapper vodDictMapper;

    @Autowired
    private ExerciseDictMapper exerciseDictMapper;

    public String updateSubjectTree(SubjectTreeDO subjectTreeDO) {
        this.baseMapper.updateSubjectTree(subjectTreeDO);
        return ConstantUtils.SUCCESS_UPDATE;
    }

    @Transactional(rollbackFor = Exception.class)
    public String addSubjectTree(SubjectTreeDO subjectTreeDO) {

        KnowledgeSubjectDictDO subjectDict = knowledgeSubjectDictMapper.selectById(subjectTreeDO.getSubjectId());


        subjectTreeDO.setSchool(ConstantUtils.SCHOOL);
        subjectTreeDO.setSubjectType("高中");
        subjectTreeDO.setSubject(subjectDict.getSubjectName());
        subjectTreeDO.setSubjectEn(subjectDict.getSubjectEn());

        List<SubjectTreeDO> subjectTreeDOS = new ArrayList<>();
        //编号
        if (null != subjectTreeDO.getParentId()) {
            subjectTreeDOS = this.baseMapper.selectList(new QueryWrapper<SubjectTreeDO>()
                    .lambda()
                    .eq(SubjectTreeDO::getParentId, subjectTreeDO.getParentId())
                    .eq(SubjectTreeDO::getSubjectEn, subjectDict.getSubjectEn())
                    .orderByDesc(SubjectTreeDO::getTreeOrder));
        } else {
            subjectTreeDOS = this.baseMapper.selectList(new QueryWrapper<SubjectTreeDO>()
                    .lambda()
                    .isNull(SubjectTreeDO::getParentId)
                    .eq(SubjectTreeDO::getSubjectEn, subjectDict.getSubjectEn())
                    .orderByDesc(SubjectTreeDO::getTreeOrder));
        }

        if (subjectTreeDOS.size() == 0) {
            subjectTreeDO.setTreeOrder(0);
        } else {
            subjectTreeDO.setTreeOrder(subjectTreeDOS.get(0).getTreeOrder() + 1);
        }

        this.baseMapper.insert(subjectTreeDO);

        return ConstantUtils.ADD_SUCCESS;
    }

    @Transactional(rollbackFor = Exception.class)
    public String deleteSubjectTree(SubjectTreeDO subjectTreeDO) {

        List<SubjectTreeDO> subjectTreeDOS = this.baseMapper.selectList(new QueryWrapper<SubjectTreeDO>()
                .lambda()
                .eq(SubjectTreeDO::getParentId, subjectTreeDO.getId()));

        for (SubjectTreeDO subjectTreeDO1 : subjectTreeDOS) {
            deleteChildNode(subjectTreeDO1);
        }

        this.baseMapper.deleteById(subjectTreeDO.getId());

        return ConstantUtils.DELETE_SUCCESS;
    }

    public String updateTreeOrder(UpdateTreeOrderDTO updateTreeOrderDTO) {

        List<Long> longs = updateTreeOrderDTO.getIds();
        for (int i = 0; i < longs.size(); i++) {
            SubjectTreeDO subjectTreeDO = this.baseMapper.selectById(longs.get(i));
            subjectTreeDO.setTreeOrder(i);
            subjectTreeDO.setParentId(updateTreeOrderDTO.getParentId());
            this.baseMapper.updateSubjectTree(subjectTreeDO);

//            //课程下的知识点的顺序也要跟着变
//            List<CourseTreeDO> courseDictDOS = courseTreeMapper.selectList(new QueryWrapper<CourseTreeDO>()
//                    .lambda()
//                    .eq(CourseTreeDO::getTreeId, longs.get(i)));
//
//            for (CourseTreeDO courseTreeDO : courseDictDOS) {
//                courseTreeDO.setTreeOrder(i);
//                courseTreeDO.setParentId(updateTreeOrderDTO.getParentId());
//                courseTreeDO.setChapterId(null);
//                courseTreeMapper.updateTreeOrderNo(courseTreeDO);
//            }
        }
        return ConstantUtils.SUCCESS_UPDATE;
    }


    //科目递归删除
    public void deleteChildNode(SubjectTreeDO subjectTreeDO) {

        List<SubjectTreeDO> subjectTreeDOS = this.baseMapper.selectList(new QueryWrapper<SubjectTreeDO>()
                .lambda()
                .eq(SubjectTreeDO::getParentId, subjectTreeDO.getId()));

        for (SubjectTreeDO subjectTreeDO1 : subjectTreeDOS) {
            deleteChildNode(subjectTreeDO1);
        }
        this.baseMapper.deleteById(subjectTreeDO.getId());

    }

    public List<GetSubjectTreeVO> getTreesCnt(GetSubjectTreeDTO getSubjectTreeDTO) {

        List<GetSubjectTreeVO> getSubjectTreeVOS = new ArrayList<>();

        //判断老师角色
        List<RoleDictDO> roleDictDOS = administerMapper.getTeacherRoles(getSubjectTreeDTO.getUserId());

        SerialNumber number = new SerialNumber();
        SubjectTreeOrder treeNode = new SubjectTreeOrder(".", number);

        boolean flag = false; //true 可以看全部的    false 没权限或者是授课老师 只能看三级

        for (RoleDictDO roleDictDO : roleDictDOS) {
            if (roleDictDO.getId() == 1 || roleDictDO.getId() == 2 || roleDictDO.getId() == 4) {
                flag = true;
            }
        }

        GetSubjectTreeVO root = treeNode.getRoot(treeNode.getNodeList());

        List<GetSubjectTreeVO> nodeList = new ArrayList<>();

        int chapterId = 1;

        //获取科目的父节点
        List<SubjectTreeDO> subjectTreeDOS = subjectTreeMapper.selectList(new QueryWrapper<SubjectTreeDO>()
                .lambda()
                .eq(SubjectTreeDO::getSubjectId, getSubjectTreeDTO.getSubjectId())
                .isNull(SubjectTreeDO::getParentId)
                .orderByAsc(SubjectTreeDO::getTreeOrder));

        for (SubjectTreeDO std : subjectTreeDOS) {
            GetSubjectTreeVO getSubjectTreeVO = SubjectTreeOrder.getNextNode(treeNode,root,nodeList);
            List<Integer> vodCnt = new ArrayList<>();
            List<Integer> publicVodCnt = new ArrayList<>();
            List<Integer> exerciseCnt = new ArrayList<>();
            List<Integer> publicExerciseCnt = new ArrayList<>();
            BeanUtils.copyProperties(std, getSubjectTreeVO);

            int k = 0;  //第k层

            getSubjectTreeVO.setChildren(getChildNodes(chapterId,getSubjectTreeDTO.getUserId(),getSubjectTreeVO,publicVodCnt,publicExerciseCnt, vodCnt, exerciseCnt, k, flag, getSubjectTreeDTO.getShareStatus(),treeNode,nodeList));
            int i = 0;
            for (Integer integer : vodCnt) {
                i += integer;
            }
            getSubjectTreeVO.setVodCounts(i);
            int j = 0;
            for (Integer integer : exerciseCnt) {
                j += integer;
            }
            getSubjectTreeVO.setExerciseCounts(j);
            int m =0;
            for (Integer integer : publicVodCnt) {
                m += integer;
            }
            getSubjectTreeVO.setPublicVodCounts(m);
            int n =0;
            for (Integer integer : publicExerciseCnt) {
                n += integer;
            }
            getSubjectTreeVO.setPublicExerciseVodCounts(n);
            getSubjectTreeVO.setLayer(chapterId+"");
            chapterId++;
            getSubjectTreeVO.setText(getSubjectTreeVO.getText().replace("0.1",getSubjectTreeVO.getLayer()));
            getSubjectTreeVO.setTreeNode(getSubjectTreeVO.getText());

            getSubjectTreeVOS.add(getSubjectTreeVO);
        }
        return getSubjectTreeVOS;

    }

    public List<GetSubjectTreeVO> getTreesCheckCnt(GetSubjectTreeDTO getSubjectTreeDTO) {

        List<GetSubjectTreeVO> getSubjectTreeVOS = new ArrayList<>();

        //判断老师角色
        List<RoleDictDO> roleDictDOS = administerMapper.getTeacherRoles(getSubjectTreeDTO.getUserId());

        boolean flag = false; //true 可以看全部的    false 没权限或者是授课老师 只能看三级

        for (RoleDictDO roleDictDO : roleDictDOS) {
            if (roleDictDO.getId() == 1 || roleDictDO.getId() == 2 || roleDictDO.getId() == 4) {
                flag = true;
            }
        }

        SerialNumber number = new SerialNumber();
        SubjectTreeOrder treeNode = new SubjectTreeOrder(".", number);


        GetSubjectTreeVO root = treeNode.getRoot(treeNode.getNodeList());

        List<GetSubjectTreeVO> nodeList = new ArrayList<>();

        //获取科目的父节点
        List<SubjectTreeDO> subjectTreeDOS = subjectTreeMapper.selectList(new QueryWrapper<SubjectTreeDO>()
                .lambda()
                .eq(SubjectTreeDO::getSubjectId, getSubjectTreeDTO.getSubjectId())
                .isNull(SubjectTreeDO::getParentId)
                .orderByAsc(SubjectTreeDO::getTreeOrder));

        int chapterId = 1 ;

        for (SubjectTreeDO std : subjectTreeDOS) {
            GetSubjectTreeVO getSubjectTreeVO = SubjectTreeOrder.getNextNode(treeNode,root,nodeList);
            List<Integer> toCheckVodCnt = new ArrayList<>();
            List<Integer> checkVodCnt = new ArrayList<>();
            List<Integer> toCheckExerciseCnt = new ArrayList<>();
            List<Integer> checkExerciseCnt = new ArrayList<>();
            BeanUtils.copyProperties(std, getSubjectTreeVO);

            int k = 0;


            getSubjectTreeVO.setLayer(chapterId+"");
            chapterId++;
            getSubjectTreeVO.setText(getSubjectTreeVO.getText().replace("0.1",getSubjectTreeVO.getLayer()));
            getSubjectTreeVO.setTreeNode(getSubjectTreeVO.getText());

            getSubjectTreeVO.setChildren(getCheckChildNodes(chapterId,getSubjectTreeVO, toCheckVodCnt, checkVodCnt,toCheckExerciseCnt,checkExerciseCnt, k, flag, getSubjectTreeDTO.getShareStatus(),treeNode,nodeList));
            int i = 0;
            for (Integer integer : toCheckExerciseCnt) {
                i += integer;
            }
            getSubjectTreeVO.setToCheckExerciseCounts(i);
            int j = 0;
            for (Integer integer : toCheckVodCnt) {
                j += integer;
            }
            getSubjectTreeVO.setToCheckVodCounts(j);
            int m = 0;
            for (Integer integer : checkExerciseCnt) {
                m += integer;
            }
            getSubjectTreeVO.setCheckExerciseCounts(m);
            int l = 0;
            for (Integer integer : checkVodCnt) {
                l += integer;
            }
            getSubjectTreeVO.setCheckVodCounts(l);

            getSubjectTreeVOS.add(getSubjectTreeVO);
        }
        return getSubjectTreeVOS;

    }


    /**
     * 递归遍历子节点
     *
     * @param getSubjectTreeVO 父节点填充子节点
     * @return
     */
    public List<GetSubjectTreeVO> getChildNodes(Integer chapterId,Long userId,GetSubjectTreeVO getSubjectTreeVO, List<Integer> publicVodCnt, List<Integer> publicExerciseCnt,List<Integer> vodCnt, List<Integer> exerciseCnt, Integer k, boolean flag, String shareStatus,SubjectTreeOrder treeNode,List<GetSubjectTreeVO> nodeList ) {

        List<GetSubjectTreeVO> getSubjectTreeVOS = new ArrayList<>();

        KnowledgeSubjectDictDO subjectDictDO = knowledgeSubjectDictMapper.selectById(getSubjectTreeVO.getSubjectId());

        //查找该父节点下的子节点
        List<SubjectTreeDO> subjectTreeDOS = subjectTreeMapper.selectList(new QueryWrapper<SubjectTreeDO>()
                .lambda()
                .eq(SubjectTreeDO::getParentId, getSubjectTreeVO.getId())
                .orderByAsc(SubjectTreeDO::getTreeOrder));

        getSubjectTreeVO.setChildNodeCounts(subjectTreeDOS.size());

        getSubjectTreeVO.setLayer(chapterId+"");
        getSubjectTreeVO.setText(getSubjectTreeVO.getText().replace("0.1",getSubjectTreeVO.getLayer()));
        getSubjectTreeVO.setTreeNode(getSubjectTreeVO.getText());

        //查找该节点下的视频数  个人库
        Integer vodCntTmp = vodSubjectTreeMappingMapper.getTreeVodCount(userId,getSubjectTreeVO.getId(),"0",subjectDictDO.getSubjectEn(),null);
        getSubjectTreeVO.setVodCounts(vodCntTmp);
        vodCnt.add(vodCntTmp);

        //查找该节点下的视频数 公共库
        Integer publicVodCntTmp = vodSubjectTreeMappingMapper.getTreeVodCount(null,getSubjectTreeVO.getId(),"1",subjectDictDO.getSubjectEn(),null);
        getSubjectTreeVO.setPublicVodCounts(publicVodCntTmp);
        publicVodCnt.add(publicVodCntTmp);

        //查找该节点下的题目数  个人库
        Integer exerciseTmp = exerciseTreeMappingMapper.getTreeExerciseCount(userId,getSubjectTreeVO.getId(),"0",subjectDictDO.getSubjectEn(),null);
        getSubjectTreeVO.setExerciseCounts(exerciseTmp);
        exerciseCnt.add(exerciseTmp);

        //查找该节点下的题目数  公共库
        Integer publicExerciseTmp = exerciseTreeMappingMapper.getTreeExerciseCount(null,getSubjectTreeVO.getId(),"1",subjectDictDO.getSubjectEn(),null);
        getSubjectTreeVO.setPublicExerciseVodCounts(publicExerciseTmp);
        publicExerciseCnt.add(publicExerciseTmp);

        getSubjectTreeVO.setCheckVodCounts(vodCntTmp);
        getSubjectTreeVO.setCheckExerciseCounts(exerciseTmp);

        k++;

        if (k == 3 && !flag) {
            return null;
        }

        for (SubjectTreeDO subjectTreeDO1 : subjectTreeDOS) {
            GetSubjectTreeVO getSubjectTreeVO1 = SubjectTreeOrder.getNextNode(treeNode,getSubjectTreeVO,nodeList);
            BeanUtils.copyProperties(subjectTreeDO1, getSubjectTreeVO1);
            getSubjectTreeVO1.setParentTreeName(getSubjectTreeVO.getTreeName());
            getSubjectTreeVOS.add(getSubjectTreeVO1);
            getSubjectTreeVO1.setChildren(getChildNodes(chapterId,userId,getSubjectTreeVO1, publicVodCnt,publicExerciseCnt,vodCnt, exerciseCnt, k, flag, shareStatus,treeNode,nodeList));
        }
        if (subjectTreeDOS.size() == 0) {
            return null;
        }
        return getSubjectTreeVOS;
    }

    /**
     * 递归遍历子节点
     *
     * @param getSubjectTreeVO 父节点填充子节点
     * @return
     */
    public List<GetSubjectTreeVO> getCheckChildNodes(Integer chapterId,GetSubjectTreeVO getSubjectTreeVO, List<Integer>  toCheckVodCnt, List<Integer> checkVodCnt,List<Integer> toCheckExerciseCnt, List<Integer> checkExerciseCnt, Integer k, boolean flag, String shareStatus,SubjectTreeOrder treeNode,List<GetSubjectTreeVO> nodeList ) {

        List<GetSubjectTreeVO> getSubjectTreeVOS = new ArrayList<>();

        //查找该父节点下的子节点
        List<SubjectTreeDO> subjectTreeDOS = subjectTreeMapper.selectList(new QueryWrapper<SubjectTreeDO>()
                .lambda()
                .eq(SubjectTreeDO::getParentId, getSubjectTreeVO.getId())
                .orderByAsc(SubjectTreeDO::getTreeOrder));

        getSubjectTreeVO.setChildNodeCounts(subjectTreeDOS.size());

        //查找该节点下的视频数 已审核的视频
        Integer checkVod = 0;

        //查找该节点下的题目数 已审核的题目
        Integer checkExercise = 0;

        //待审核的视频数
        Integer toCheckVod = 0;

        //待审核的题目数
        Integer toCheckExercise = 0;

        KnowledgeSubjectDictDO subjectDictDO = knowledgeSubjectDictMapper.selectById(getSubjectTreeVO.getSubjectId());

        //待审核
        toCheckVod = vodSubjectTreeMappingMapper.getTreeVodCount(null,getSubjectTreeVO.getId(),null,subjectDictDO.getSubjectEn(),"2");
        toCheckVodCnt.add(toCheckVod);
        toCheckExercise = exerciseTreeMappingMapper.getTreeExerciseCount(null,getSubjectTreeVO.getId(),"0",subjectDictDO.getSubjectEn(),"2");
        getSubjectTreeVO.setToCheckExerciseCounts(toCheckExercise);
        toCheckExerciseCnt.add(toCheckExercise);
        //已审核  包括已通过 未通过
        checkVod = vodSubjectTreeMappingMapper.getTreeVodCount(null,getSubjectTreeVO.getId(),null,subjectDictDO.getSubjectEn(),"1");
        getSubjectTreeVO.setCheckVodCounts(checkVod);
        checkVodCnt.add(checkVod);
        checkExercise = exerciseTreeMappingMapper.getTreeExerciseCount(null,getSubjectTreeVO.getId(),"1",subjectDictDO.getSubjectEn(),"1");
        getSubjectTreeVO.setCheckExerciseCounts(checkExercise);
        checkExerciseCnt.add(checkExercise);
        getSubjectTreeVO.setToCheckVodCounts(toCheckVod);

        getSubjectTreeVO.setLayer(chapterId+"");
        getSubjectTreeVO.setText(getSubjectTreeVO.getText().replace("0.1",getSubjectTreeVO.getLayer()));
        getSubjectTreeVO.setTreeNode(getSubjectTreeVO.getText());

        k++;

        if (k == 3 && !flag) {
            return null;
        }

        for (SubjectTreeDO subjectTreeDO1 : subjectTreeDOS) {
            GetSubjectTreeVO getSubjectTreeVO1 =  SubjectTreeOrder.getNextNode(treeNode,getSubjectTreeVO,nodeList);
            BeanUtils.copyProperties(subjectTreeDO1, getSubjectTreeVO1);
            getSubjectTreeVO1.setParentTreeName(getSubjectTreeVO.getTreeName());
            getSubjectTreeVOS.add(getSubjectTreeVO1);
            getSubjectTreeVO1.setChildren(getCheckChildNodes(chapterId,getSubjectTreeVO1,  toCheckVodCnt, checkVodCnt,toCheckExerciseCnt,checkExerciseCnt, k, flag, shareStatus,treeNode,nodeList));
        }
        if (subjectTreeDOS.size() == 0) {
            return null;
        }
        return getSubjectTreeVOS;
    }


}