api/src/main/java/com/xjrsoft/module/banding/service/impl/BandingTaskClassServiceImpl.java

package com.xjrsoft.module.banding.service.impl;

import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.NumberUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.xjrsoft.common.constant.GlobalConstant;
import com.xjrsoft.common.enums.DeleteMark;
import com.xjrsoft.common.enums.EnabledMark;
import com.xjrsoft.common.enums.GenderDictionaryEnum;
import com.xjrsoft.common.enums.RoleEnum;
import com.xjrsoft.common.enums.YesOrNoEnum;
import com.xjrsoft.common.exception.MyException;
import com.xjrsoft.common.utils.RedisUtil;
import com.xjrsoft.common.utils.VoToColumnUtil;
import com.xjrsoft.module.banding.dto.BandingTaskClassPageDto;
import com.xjrsoft.module.banding.dto.BandingTaskClassStudentPageDto;
import com.xjrsoft.module.banding.dto.UpdateBandingClassDto;
import com.xjrsoft.module.banding.entity.BandingTask;
import com.xjrsoft.module.banding.entity.BandingTaskClass;
import com.xjrsoft.module.banding.entity.BandingTaskClassStudent;
import com.xjrsoft.module.banding.mapper.BandingTaskClassMapper;
import com.xjrsoft.module.banding.mapper.BandingTaskClassStudentMapper;
import com.xjrsoft.module.banding.mapper.BandingTaskMapper;
import com.xjrsoft.module.banding.service.IBandingTaskClassService;
import com.xjrsoft.module.banding.vo.BandingTaskClassPageVo;
import com.xjrsoft.module.banding.vo.BandingTaskClassReportStatisticsVo;
import com.xjrsoft.module.banding.vo.BandingTaskClassStudentListVo;
import com.xjrsoft.module.banding.vo.BandingTaskClassSureListVo;
import com.xjrsoft.module.base.entity.BaseClass;
import com.xjrsoft.module.base.entity.BaseClassTeacherChange;
import com.xjrsoft.module.base.entity.BaseClassroom;
import com.xjrsoft.module.base.entity.BaseGrade;
import com.xjrsoft.module.base.entity.BaseMajorSet;
import com.xjrsoft.module.base.mapper.BaseClassMapper;
import com.xjrsoft.module.base.mapper.BaseClassTeacherChangeMapper;
import com.xjrsoft.module.base.mapper.BaseGradeMapper;
import com.xjrsoft.module.base.service.IBaseClassroomService;
import com.xjrsoft.module.base.service.IBaseMajorSetService;
import com.xjrsoft.module.organization.entity.User;
import com.xjrsoft.module.organization.entity.UserRoleRelation;
import com.xjrsoft.module.organization.service.IUserRoleRelationService;
import com.xjrsoft.module.organization.service.IUserService;
import com.xjrsoft.module.student.dto.StudentTryReadingReportPageDto;
import com.xjrsoft.module.student.entity.EnrollmentPlan;
import com.xjrsoft.module.student.entity.StudentReportPlan;
import com.xjrsoft.module.student.mapper.EnrollmentPlanMapper;
import com.xjrsoft.module.student.mapper.StudentReportRecordMapper;
import com.xjrsoft.module.student.service.IStudentReportPlanService;
import com.xjrsoft.module.student.vo.StudentReportRecordPlanPageVo;
import com.xjrsoft.module.system.entity.DictionaryDetail;
import com.xjrsoft.module.system.entity.DictionaryItem;
import com.xjrsoft.module.system.mapper.DictionarydetailMapper;
import com.xjrsoft.module.teacher.entity.BaseTeacher;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

/**
* @title: 新生分班任务
* @Author dzx
* @Date: 2024-07-01
* @Version 1.0
*/
@Service
@AllArgsConstructor
public class BandingTaskClassServiceImpl extends MPJBaseServiceImpl<BandingTaskClassMapper, BandingTaskClass> implements IBandingTaskClassService {

    private final BandingTaskMapper bandingTaskMapper;
    private final BandingTaskClassStudentMapper classStudentMapper;
    private final IBaseClassroomService classroomService;
    private final IUserService userService;
    private final IBaseMajorSetService majorSetService;
    private final DictionarydetailMapper detailMapper;
    private final BaseClassMapper classMapper;
    private final StudentReportRecordMapper reportRecordMapper;
    private final EnrollmentPlanMapper enrollmentPlanMapper;
    private final IStudentReportPlanService reportPlanService;
    private final BaseGradeMapper gradeMapper;
    private final IUserRoleRelationService roleRelationService;
    private final RedisUtil redisUtil;
    private final BaseClassTeacherChangeMapper teacherChangeMapper;

    @Override
    public Boolean add(BandingTaskClass bandingTaskClass) {
        bandingTaskClass.setCreateDate(new Date());
        this.baseMapper.insert(bandingTaskClass);
        return true;
    }

    @Override
    public Boolean update(BandingTaskClass bandingTaskClass) {
        bandingTaskClass.setModifyDate(new Date());
        this.baseMapper.updateById(bandingTaskClass);
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean delete(List<Long> ids) {
        this.baseMapper.deleteBatchIds(ids);
        return true;
    }

    @Override
    public List<BandingTaskClassPageVo> getList(BandingTaskClassPageDto dto) {
        BandingTask bandingTask = bandingTaskMapper.selectById(dto.getBandingTaskId());
        dto.setGradeId(bandingTask.getGradeId());
        dto.setEnrollType(bandingTask.getEnrollType());
        return this.baseMapper.getList(dto);
    }

    @Override
    public Boolean reset(Long bandingTaskId) {
        List<BandingTaskClass> classList = this.baseMapper.selectList(
                new QueryWrapper<BandingTaskClass>().lambda()
                        .eq(BandingTaskClass::getBandingTaskId, bandingTaskId)
                        .eq(BandingTaskClass::getStatus, 0)
        );

        for (BandingTaskClass bandingTaskClass : classList) {
            bandingTaskClass.setModifyDate(new Date());
            bandingTaskClass.setHeight(null);
            bandingTaskClass.setScore(null);
            this.baseMapper.updateById(bandingTaskClass);
        }

        List<Long> classIds = classList.stream().map(BandingTaskClass::getId).collect(Collectors.toList());
        if(!classIds.isEmpty()){
            classStudentMapper.delete(
                    new QueryWrapper<BandingTaskClassStudent>().lambda()
                            .in(BandingTaskClassStudent::getBandingTaskClassId, classIds)
            );
        }
        return true;
    }

    @Override
    public List<BandingTaskClassStudentListVo> classStudent(BandingTaskClassStudentPageDto dto) {
        BandingTask bandingTask = bandingTaskMapper.selectById(dto.getBandingTaskId());
        dto.setGradeId(bandingTask.getGradeId());
        dto.setEnrollType(bandingTask.getEnrollType());
        return this.baseMapper.getClassStudent(dto);
    }

    @Override
    public List<BandingTaskClassSureListVo> getClassSure(BandingTaskClassStudentPageDto dto) {
        return this.baseMapper.getClassSure(dto);
    }

    @Override
    public Boolean importData(Long bandingTaskId, List<Map<Integer, Object>> excelDataList) {
        List<BaseClassroom> classroomList = classroomService.list(
                new QueryWrapper<BaseClassroom>().lambda()
                        .eq(BaseClassroom::getDeleteMark, DeleteMark.NODELETE.getCode())
        );
        Map<String, Long> classroomMap = new HashMap<>();
        for (BaseClassroom classroom : classroomList) {
            classroomMap.put(classroom.getName(), classroom.getId());
        }
        List<User> userList = userService.list(
                new MPJLambdaWrapper<User>()
                        .select(User::getId)
                        .select(User.class, x -> VoToColumnUtil.fieldsToColumns(User.class).contains(x.getProperty()))
                        .innerJoin(BaseTeacher.class, BaseTeacher::getUserId, User::getId)
        );
        Map<String, Long> userMap = new HashMap<>();
        for (User user : userList) {
            userMap.put(user.getName(), user.getId());
        }

        List<BaseMajorSet> majorSetList = majorSetService.list(
                new QueryWrapper<BaseMajorSet>().lambda()
        );

        Map<String, Long> majorSetMap = new HashMap<>();
        for (BaseMajorSet majorSet : majorSetList) {
            majorSetMap.put(majorSet.getName(), majorSet.getId());
        }
        List<DictionaryDetail> classType = detailMapper.selectJoinList(DictionaryDetail.class,
                new MPJLambdaWrapper<DictionaryDetail>()
                        .select(DictionaryDetail::getId)
                        .select(DictionaryDetail.class, x -> VoToColumnUtil.fieldsToColumns(DictionaryDetail.class).contains(x.getProperty()))
                        .innerJoin(DictionaryItem.class, DictionaryItem::getId, DictionaryDetail::getItemId)
                        .eq(DictionaryItem::getCode, "class_type")
        );
        Map<String, String> classTypeMap = classType.stream().collect(Collectors.toMap(DictionaryDetail::getName, DictionaryDetail::getCode));
        List<BandingTaskClass> classList = new ArrayList<>();
        Date createDate = new Date();
        for (Map<Integer, Object> taskClass : excelDataList) {
            classList.add(new BandingTaskClass(){{
                setBandingTaskId(bandingTaskId);
                setCreateDate(createDate);
                setName(taskClass.get(1).toString());
                setMajorSetId(majorSetMap.get(taskClass.get(0).toString().trim()));
                setNumber(Integer.parseInt(taskClass.get(2).toString()));
                setClassroomId(classroomMap.get(taskClass.get(4).toString()));
                if(taskClass.get(5) != null){
                    setClassType(classTypeMap.get(taskClass.get(5).toString()));
                }
                if(taskClass.get(6) != null){
                    setIsOrderClass(YesOrNoEnum.getCode(taskClass.get(6).toString()));
                }
                if(taskClass.get(7) != null){
                    setSortCode(Integer.parseInt(taskClass.get(7).toString()));
                }
                setTeacherId(userMap.get(taskClass.get(3).toString()));
            }});
        }
        Boolean result = this.saveBatch(classList);
        return result;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean updateNull(List<BandingTaskClass> updNullList) {
        for (BandingTaskClass taskClass : updNullList) {
            UpdateWrapper<BandingTaskClass> updateWrapper = new UpdateWrapper<>();
            updateWrapper.eq("id", taskClass.getId());
            updateWrapper.setSql("sort_code = null");
            this.baseMapper.update(taskClass, updateWrapper);
        }

        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean saveClass(List<UpdateBandingClassDto> dtoList) {
        List<BandingTaskClass> insList = new ArrayList<>();//新增班级
        List<BandingTaskClass> updList = new ArrayList<>();//修改班级
        List<BandingTaskClass> updNullList = new ArrayList<>();//修改班级
        List<String> errorList = new ArrayList<>();//修改班级

        UpdateBandingClassDto updateBandingClassDto = dtoList.get(0);
        BandingTask task;
        if(updateBandingClassDto.getBandingTaskId() == null){
            BandingTaskClass taskClass = this.getById(updateBandingClassDto.getId());
            task = bandingTaskMapper.selectById(taskClass.getBandingTaskId());
        }else{
            task = bandingTaskMapper.selectById(updateBandingClassDto.getBandingTaskId());
        }
        List<BaseClass> classList = classMapper.selectList(
                new QueryWrapper<BaseClass>().lambda()
                        .eq(BaseClass::getDeleteMark, DeleteMark.NODELETE.getCode())
                        .eq(BaseClass::getGradeId, task.getGradeId())
                        .eq(BaseClass::getEnrollType, task.getEnrollType())
        );
        List<BaseClass> classCodes = classList.stream().filter(x -> x.getCode() != null).collect(Collectors.toList());
        Collections.sort(classCodes, Comparator.comparing(BaseClass::getCode));
        String classCode = null;
        if(!classCodes.isEmpty()){
            classCode = classCodes.get(0).getCode();
        }

        Map<Long, BaseClass> classMap = classList.stream().collect(Collectors.toMap(BaseClass::getId, x -> x));

        List<BaseMajorSet> majorSetList = majorSetService.list(
                new QueryWrapper<BaseMajorSet>().lambda()
                        .eq(BaseMajorSet::getDeleteMark, DeleteMark.NODELETE.getCode())
        );

        Map<Long, Long> majorDeptMap = majorSetList.stream().collect(Collectors.toMap(BaseMajorSet::getId, BaseMajorSet::getDepartmentId));
        BaseGrade baseGrade = gradeMapper.selectById(task.getGradeId());
        int i = 0;
        if(NumberUtil.isNumber(classCode)){
            i = Integer.parseInt(classCode.trim().substring(classCode.length() - 3));
        }
        for (UpdateBandingClassDto dto : dtoList) {
            if(dto.getSortCode() != null){
                List<BandingTaskClass> list = this.list(
                        new QueryWrapper<BandingTaskClass>().lambda()
                                .eq(BandingTaskClass::getSortCode, dto.getSortCode())
                                .eq(BandingTaskClass::getBandingTaskId, dto.getBandingTaskId())
                                .ne(dto.getId() != null,BandingTaskClass::getId, dto.getId())
                );
                if(!list.isEmpty()){
                    errorList.add(dto.getName());
                }
            }

            if(dto.getId() != null){
                //修改
                BandingTaskClass sourceObj = this.getById(dto.getId());
                BeanUtil.copyProperties(dto, sourceObj);
                sourceObj.setModifyDate(new Date());

                if(sourceObj.getBaseClassId() != null){
                    BaseClass baseClass = classMap.get(sourceObj.getBaseClassId());
                    baseClass.setName(sourceObj.getName());
                    baseClass.setClassType(sourceObj.getClassType());
                    baseClass.setTeacherId(sourceObj.getTeacherId());
                    baseClass.setMajorSetId(sourceObj.getMajorSetId());
                    baseClass.setClassroomId(sourceObj.getClassroomId());
                    baseClass.setIsOrderClass(sourceObj.getIsOrderClass());
                    baseClass.setOrgId(majorDeptMap.get(sourceObj.getMajorSetId()));
                    baseClass.setEnrollType(task.getEnrollType());
                    if(baseClass.getCode() == null){
                        i ++;
                        baseClass.setCode(baseGrade.getTitle().replace("年", "") + String.format("%03d", i));
                    }
                    classMapper.updateById(baseClass);

                    teacherChangeMapper.insert(new BaseClassTeacherChange(){{
                        setClassId(baseClass.getId());
                        setBeforeTeacherId(baseClass.getTeacherId());
                        setAfterTeacherId(sourceObj.getTeacherId());
                        setDeleteMark(DeleteMark.NODELETE.getCode());
                        setEnabledMark(EnabledMark.ENABLED.getCode());
                        setCreateDate(LocalDateTime.now());
                    }});

                    //给该老师添加班主任角色
                    if (baseClass.getTeacherId() != null) {
                        long count = roleRelationService.count(
                                new QueryWrapper<UserRoleRelation>().lambda()
                                        .eq(UserRoleRelation::getUserId, baseClass.getTeacherId())
                                        .eq(UserRoleRelation::getRoleId, RoleEnum.CLASSTE.getCode())
                        );
                        if (count == 0) {
                            roleRelationService.save(
                                    new UserRoleRelation() {{
                                        setRoleId(RoleEnum.CLASSTE.getCode());
                                        setUserId(baseClass.getTeacherId());
                                    }}
                            );
                        }
                    }
                }else{
                    i ++;
                    BaseClass baseClass = new BaseClass();
                    baseClass.setClassType(sourceObj.getClassType());
                    baseClass.setTeacherId(sourceObj.getTeacherId());
                    baseClass.setMajorSetId(sourceObj.getMajorSetId());
                    baseClass.setClassroomId(sourceObj.getClassroomId());
                    baseClass.setIsOrderClass(sourceObj.getIsOrderClass());
                    baseClass.setOrgId(majorDeptMap.get(sourceObj.getMajorSetId()));
                    baseClass.setName(sourceObj.getName());
                    baseClass.setGradeId(task.getGradeId());
                    baseClass.setEnrollType(task.getEnrollType());
                    baseClass.setIsGraduate(1);
                    baseClass.setCreateUserId(StpUtil.getLoginIdAsLong());
                    baseClass.setCreateDate(new Date());
                    baseClass.setCode(baseGrade.getTitle().replace("年", "") + String.format("%03d", i));
                    classMapper.insert(baseClass);
                    sourceObj.setBaseClassId(baseClass.getId());

                    teacherChangeMapper.insert(new BaseClassTeacherChange(){{
                        setClassId(baseClass.getId());
                        setAfterTeacherId(sourceObj.getTeacherId());
                        setDeleteMark(DeleteMark.NODELETE.getCode());
                        setEnabledMark(EnabledMark.ENABLED.getCode());
                        setCreateDate(LocalDateTime.now());
                    }});

                    if (baseClass.getTeacherId() != null) {
                        long count = roleRelationService.count(
                                new QueryWrapper<UserRoleRelation>().lambda()
                                        .eq(UserRoleRelation::getUserId, baseClass.getTeacherId())
                                        .eq(UserRoleRelation::getRoleId, RoleEnum.CLASSTE.getCode())
                        );
                        if (count == 0) {
                            roleRelationService.save(
                                    new UserRoleRelation() {{
                                        setRoleId(RoleEnum.CLASSTE.getCode());
                                        setUserId(baseClass.getTeacherId());
                                    }}
                            );
                        }
                    }
                }
                if(sourceObj.getSortCode() == null){
                    updNullList.add(sourceObj);
                }else{
                    updList.add(sourceObj);
                }
            }else{
                //新增
                i ++;
                BandingTaskClass taskClass = BeanUtil.toBean(dto, BandingTaskClass.class);
                taskClass.setCreateDate(new Date());

                BaseClass baseClass = new BaseClass();
                baseClass.setClassType(taskClass.getClassType());
                baseClass.setTeacherId(taskClass.getTeacherId());
                baseClass.setMajorSetId(taskClass.getMajorSetId());
                baseClass.setClassroomId(taskClass.getClassroomId());
                baseClass.setIsOrderClass(taskClass.getIsOrderClass());
                baseClass.setOrgId(majorDeptMap.get(taskClass.getMajorSetId()));
                baseClass.setName(taskClass.getName());
                baseClass.setGradeId(task.getGradeId());
                baseClass.setEnrollType(task.getEnrollType());
                baseClass.setIsGraduate(1);
                baseClass.setCreateUserId(StpUtil.getLoginIdAsLong());
                baseClass.setCreateDate(new Date());
                baseClass.setCode(baseGrade.getTitle().replace("年", "") + String.format("%03d", i));
                classMapper.insert(baseClass);
                if (baseClass.getTeacherId() != null) {
                    long count = roleRelationService.count(
                            new QueryWrapper<UserRoleRelation>().lambda()
                                    .eq(UserRoleRelation::getUserId, baseClass.getTeacherId())
                                    .eq(UserRoleRelation::getRoleId, RoleEnum.CLASSTE.getCode())
                    );
                    if (count == 0) {
                        roleRelationService.save(
                                new UserRoleRelation() {{
                                    setRoleId(RoleEnum.CLASSTE.getCode());
                                    setUserId(baseClass.getTeacherId());
                                }}
                        );
                    }
                }

                taskClass.setBaseClassId(baseClass.getId());
                insList.add(taskClass);
            }
        }
        if(!errorList.isEmpty()){
            throw new MyException(errorList.toString().replace("[", "").replace("]", "") + "，分班排序重复");
        }

        if(!updNullList.isEmpty()){
            this.updateNull(updNullList);
        }

        CompletableFuture.runAsync(() -> {
            List<UserRoleRelation> userRoleRelationList = roleRelationService.list(Wrappers.lambdaQuery(UserRoleRelation.class));
            redisUtil.set(GlobalConstant.USER_ROLE_RELATION_CACHE_KEY, userRoleRelationList);
        });

        this.saveBatch(insList);
        return this.updateBatchById(updList);
    }


    /**
     * 班级管理中，修改信息时同步修改新生分班中的班级信息
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean updateByBaseClass(BaseClass baseClass) {
        List<BandingTask> bandingTasks = bandingTaskMapper.selectList(
                new QueryWrapper<BandingTask>().lambda()
                        .eq(BandingTask::getDeleteMark, DeleteMark.NODELETE.getCode())
                        .eq(BandingTask::getGradeId, baseClass.getGradeId())
                        .eq(BandingTask::getEnrollType, baseClass.getEnrollType())
                        .orderByDesc(BandingTask::getId)
        );
        if(bandingTasks.isEmpty()){
            return true;
        }
        BandingTaskClass one = this.getOne(
                new MPJLambdaWrapper<BandingTaskClass>()
                        .select(BandingTaskClass::getId)
                        .select(BandingTaskClass.class, x -> VoToColumnUtil.fieldsToColumns(BandingTaskClass.class).contains(x.getProperty()))
                        .eq(BandingTaskClass::getDeleteMark, DeleteMark.NODELETE.getCode())
                        .eq(BandingTaskClass::getBaseClassId, baseClass.getId())
        );
        if(one == null){
            BandingTask task = bandingTasks.get(0);
            one = new BandingTaskClass();
            one.setBandingTaskId(task.getId());
            one.setIsOrderClass(baseClass.getIsOrderClass());
            one.setClassType(baseClass.getClassType());
            one.setTeacherId(baseClass.getTeacherId());
            one.setMajorSetId(baseClass.getMajorSetId());
            one.setClassroomId(baseClass.getClassroomId());
            one.setDeleteMark(DeleteMark.NODELETE.getCode());
            one.setCreateDate(new Date());
            one.setEnabledMark(EnabledMark.ENABLED.getCode());
            one.setName(baseClass.getName());
            one.setCreateUserId(StpUtil.getLoginIdAsLong());
            this.save(one);
        }else{
            one.setIsOrderClass(baseClass.getIsOrderClass());
            one.setClassType(baseClass.getClassType());
            one.setTeacherId(baseClass.getTeacherId());
            one.setMajorSetId(baseClass.getMajorSetId());
            one.setClassroomId(baseClass.getClassroomId());
            one.setModifyDate(new Date());
            one.setModifyUserId(StpUtil.getLoginIdAsLong());
            this.updateById(one);
        }
        return true;
    }

    /**
     * 新增分班任务后，自动初始化班级数据
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean initClassByBaseClass(BandingTask bandingTask) {
        List<BaseClass> classList = classMapper.selectList(
                new QueryWrapper<BaseClass>().lambda()
                        .eq(BaseClass::getDeleteMark, DeleteMark.NODELETE.getCode())
                        .eq(BaseClass::getGradeId, bandingTask.getGradeId())
                        .eq(BaseClass::getIsGraduate, 1)
                        .eq(BaseClass::getEnrollType, bandingTask.getEnrollType())
        );
        List<BandingTaskClass> insList = new ArrayList<>();//新增班级
        for (BaseClass baseClass : classList) {
            BandingTaskClass one = new BandingTaskClass();
            one.setBandingTaskId(bandingTask.getId());
            one.setIsOrderClass(baseClass.getIsOrderClass());
            one.setClassType(baseClass.getClassType());
            one.setTeacherId(baseClass.getTeacherId());
            one.setMajorSetId(baseClass.getMajorSetId());
            one.setClassroomId(baseClass.getClassroomId());
            one.setDeleteMark(DeleteMark.NODELETE.getCode());
            one.setCreateDate(new Date());
            one.setEnabledMark(EnabledMark.ENABLED.getCode());
            one.setName(baseClass.getName());
            one.setCreateUserId(StpUtil.getLoginIdAsLong());
            one.setStatus(0);
            one.setBaseClassId(baseClass.getId());
            insList.add(one);
        }
        if(!insList.isEmpty()){
           this.saveBatch(insList);
        }
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean deleteClass(List<Long> ids) {
        if(!ids.isEmpty()){
            List<BandingTaskClassStudent> list = classStudentMapper.selectList(
                    new QueryWrapper<BandingTaskClassStudent>().lambda()
                            .in(BandingTaskClassStudent::getBandingTaskClassId, ids)
                            .eq(BandingTaskClassStudent::getDeleteMark, DeleteMark.NODELETE.getCode())
            );
            if(!list.isEmpty()){
                throw new MyException("该班级下已分配学生，无法删除");
            }
        }

        List<BandingTaskClass> classList = this.listByIds(ids);
        for (BandingTaskClass taskClass : classList) {

            BandingTask bandingTask = bandingTaskMapper.selectById(taskClass.getBandingTaskId());
            BaseClass baseClass = classMapper.selectOne(
                    new QueryWrapper<BaseClass>().lambda()
                            .eq(BaseClass::getDeleteMark, DeleteMark.NODELETE.getCode())
                            .eq(BaseClass::getGradeId, bandingTask.getGradeId())
                            .eq(BaseClass::getName, taskClass.getName())
                            .eq(BaseClass::getIsGraduate, 1)
                            .eq(BaseClass::getEnrollType, bandingTask.getEnrollType())
            );

            classMapper.deleteById(baseClass);
            this.removeById(taskClass);
        }
        return true;
    }

    @Override
    public BandingTaskClassReportStatisticsVo getTryReadingReportClassStatistics(StudentTryReadingReportPageDto dto) {
        BandingTaskClassReportStatisticsVo result = new BandingTaskClassReportStatisticsVo();
        if(dto.getClassId() == 0L){
            StudentReportPlan plan = reportPlanService.getLastTryReadingPlan();
            BandingTask bandingTask = bandingTaskMapper.selectById(plan.getBandingTaskId());
            List<EnrollmentPlan> enrollmentPlans = enrollmentPlanMapper.selectList(
                    new QueryWrapper<EnrollmentPlan>().lambda()
                            .eq(EnrollmentPlan::getDeleteMark, DeleteMark.NODELETE.getCode())
                            .eq(EnrollmentPlan::getEnabledMark, EnabledMark.ENABLED.getCode())
                            .eq(EnrollmentPlan::getEnrollType, bandingTask.getEnrollType())
                            .eq(EnrollmentPlan::getGradeId, bandingTask.getGradeId())
                            .orderByDesc(EnrollmentPlan::getId)
            );
            if(!enrollmentPlans.isEmpty()){
                dto.setEnrollmentPlanId(enrollmentPlans.get(0).getId());
            }
        }else{
            BandingTaskClass taskClass = this.getById(dto.getClassId());
            BandingTask task = bandingTaskMapper.selectById(taskClass.getBandingTaskId());
            List<EnrollmentPlan> enrollmentPlanList = enrollmentPlanMapper.selectList(
                    new QueryWrapper<EnrollmentPlan>().lambda()
                            .eq(EnrollmentPlan::getEnrollType, task.getEnrollType())
                            .eq(EnrollmentPlan::getGradeId, task.getGradeId())
                            .eq(EnrollmentPlan::getEnabledMark, EnabledMark.ENABLED.getCode())
                            .eq(EnrollmentPlan::getDeleteMark, DeleteMark.NODELETE.getCode())
                            .orderByDesc(EnrollmentPlan::getId)
            );
            if(!enrollmentPlanList.isEmpty()){
                dto.setEnrollmentPlanId(enrollmentPlanList.get(0).getId());
            }
        }

        dto.setClassId(dto.getClassId());
        List<StudentReportRecordPlanPageVo> tryReadingList = reportRecordMapper.getTryReadingList(dto);

        result.setAllCount(tryReadingList.size());

        //女生人数
        List<StudentReportRecordPlanPageVo> femaleList = tryReadingList.stream()
                .filter(x -> x.getGender() != null && GenderDictionaryEnum.MALE.getValue().equals(x.getGender()))
                .collect(Collectors.toList());
        result.setMaleCount(femaleList.size());
        //男生人数
        List<StudentReportRecordPlanPageVo> maleList = tryReadingList.stream()
                .filter(x -> x.getGender() != null && GenderDictionaryEnum.FEMALE.getValue().equals(x.getGender()))
                .collect(Collectors.toList());
        result.setFemaleCount(maleList.size());
        //已到人数
        List<StudentReportRecordPlanPageVo> arrivedList = tryReadingList.stream()
                .filter(x -> x.getIsReport() == 1)
                .collect(Collectors.toList());
        result.setArrivedCount(arrivedList.size());
        //未到人数
        List<StudentReportRecordPlanPageVo> notArrivedList = tryReadingList.stream()
                .filter(x -> x.getIsReport() == 0)
                .collect(Collectors.toList());
        result.setNotArrivedCount(notArrivedList.size());
        if(result.getAllCount() != 0){
            BigDecimal divide = BigDecimal.valueOf(result.getArrivedCount()).divide(BigDecimal.valueOf(result.getAllCount()), 4, RoundingMode.HALF_UP);
            result.setReportRate(divide.doubleValue() + "");
        }

        return result;
    }

    @Override
    public Boolean removeByBaseClass(BaseClass baseClass) {
        boolean remove = this.remove(
                new QueryWrapper<BandingTaskClass>().lambda()
                        .eq(BandingTaskClass::getBaseClassId, baseClass.getId())
        );
        return remove;
    }
}