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

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

import cn.dev33.satoken.stp.StpUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
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.exception.MyException;
import com.xjrsoft.common.utils.RedisUtil;
import com.xjrsoft.common.utils.VoToColumnUtil;
import com.xjrsoft.module.banding.dto.ChangeClassDto;
import com.xjrsoft.module.banding.dto.StudentDto;
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.IBandingTaskClassStudentService;
import com.xjrsoft.module.banding.vo.SyncStudentDataListVo;
import com.xjrsoft.module.base.entity.BaseClass;
import com.xjrsoft.module.base.entity.BaseSemester;
import com.xjrsoft.module.base.service.IBaseClassService;
import com.xjrsoft.module.base.service.IBaseSemesterService;
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.BaseNewStudentPageDto;
import com.xjrsoft.module.student.entity.BaseNewStudent;
import com.xjrsoft.module.student.entity.StudentReportPlan;
import com.xjrsoft.module.student.entity.StudentReportRecord;
import com.xjrsoft.module.student.mapper.StudentReportRecordMapper;
import com.xjrsoft.module.student.service.IBaseNewStudentService;
import com.xjrsoft.module.student.service.IStudentReportPlanService;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

/**
* @title: 新生分班任务
* @Author dzx
* @Date: 2024-07-01
* @Version 1.0
*/
@Service
@AllArgsConstructor
public class BandingTaskClassStudentServiceImpl extends MPJBaseServiceImpl<BandingTaskClassStudentMapper, BandingTaskClassStudent> implements IBandingTaskClassStudentService {

    private final BandingTaskMapper taskMapper;
    private final BandingTaskClassMapper taskClassMapper;
    private final IStudentReportPlanService reportPlanService;
    private final IBaseSemesterService semesterService;
    private final IBaseNewStudentService newStudentService;
    private final StudentReportRecordMapper reportRecordMapper;

    private final IBaseClassService classService;
    private final IUserService userService;
    private final IUserRoleRelationService roleRelationService;
    private final RedisUtil redisUtil;

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

    @Override
    public Boolean update(BandingTaskClassStudent 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;
    }

    @Transactional
    @Override
    public Boolean changeClass(ChangeClassDto dto) {
        this.baseMapper.delete(
                new QueryWrapper<BandingTaskClassStudent>().lambda()
                        .in(BandingTaskClassStudent::getNewStudentId, dto.getNewStudentIds())
        );

        List<BaseNewStudent> list = newStudentService.list(
                new QueryWrapper<BaseNewStudent>().lambda()
                        .in(BaseNewStudent::getId, dto.getNewStudentIds())
        );

        List<BaseNewStudent> notPaymnyList = list.stream().filter(x -> "未缴费".equals(x.getPaymnystate())).collect(Collectors.toList());
        if(!notPaymnyList.isEmpty() && dto.getIsHandle() == 1){
            throw new MyException("选择的学生中存在未交费情况，无法手动分班");
        }

        List<BandingTaskClassStudent> dataList = new ArrayList<>();
        long createUserId = StpUtil.getLoginIdAsLong();

        if(dto.getIsHandle() != null && dto.getIsHandle() == 1){
            BaseClass aClass = classService.getById(dto.getBandingTaskClassId());

            BandingTaskClass taskClass = taskClassMapper.selectOne(
                    new QueryWrapper<BandingTaskClass>().lambda()
                            .eq(BandingTaskClass::getBaseClassId, aClass.getId())
            );

            for (Long newStudentId : dto.getNewStudentIds()) {
                dataList.add(
                        new BandingTaskClassStudent(){{
                            setCreateDate(new Date());
                            setNewStudentId(newStudentId);
                            setBandingTaskClassId(taskClass.getId());
                            setCreateUserId(createUserId);
                            setStatus(0);
                            if(dto.getIsHandle() != null && dto.getIsHandle() == 1){
                                setStatus(1);
                            }
                        }}
                );
            }
            //新增报到计划，如果有多个分班任务确认，需要保证试读报到计划只有一个
            BaseSemester semester = semesterService.getCurrentSemester();
            List<StudentReportPlan> planList = reportPlanService.list(
                    new QueryWrapper<StudentReportPlan>().lambda()
                            .eq(StudentReportPlan::getDeleteMark, DeleteMark.NODELETE.getCode())
                            .eq(StudentReportPlan::getEnabledMark, EnabledMark.ENABLED.getCode())
                            .eq(StudentReportPlan::getSemesterId, semester.getId())
                            .in(StudentReportPlan::getCategory, Arrays.asList(2, 3))
            );

            for (StudentReportPlan plan : planList) {
                for (Long newStudentId : dto.getNewStudentIds()) {
                    reportRecordMapper.deleteRecordByUserIdAndPlanId(newStudentId, plan.getId());
                    StudentReportRecord record = new StudentReportRecord();
                    record.setCreateDate(new Date());
                    record.setCreateUserId(StpUtil.getLoginIdAsLong());
                    record.setUserId(newStudentId);
                    record.setStudentReportPlanId(plan.getId());
                    record.setDeleteMark(DeleteMark.NODELETE.getCode());
                    record.setEnabledMark(EnabledMark.ENABLED.getCode());
                    reportRecordMapper.insert(record);
                }
            }


            List<BaseNewStudent> updateList = new ArrayList<>();
            for (BaseNewStudent student : list) {
                student.setStatus(1);
                student.setOperateMode(2);
                student.setRemarks(dto.getRemarks());
                updateList.add(student);
            }
            if(!updateList.isEmpty()){
                newStudentService.updateBatchById(updateList);
            }
//            {
//                /**
//                 * 新增学生数据
//                 * 1、新增用户xjr_user，需要先查询用户信息是否已经存在
//                 * 2、新增用户与角色的关系xjr_user_role_relation
//                 * 3、新增学生基本信息base_student
//                 * 4、新增学籍信息表base_student_school_roll
//                 * 5、新增家庭信息表base_student_family
//                 */
//                LocalDateTime now = LocalDateTime.now();
//                List<String> idNumbers = updateList.stream().map(BaseNewStudent::getCredentialNumber).collect(Collectors.toList());
//                List<User> students = userService.list(
//                        new MPJLambdaWrapper<User>()
//                                .disableLogicDel()
//                                .in(User::getCredentialNumber, idNumbers)
//                                .orderByAsc(User::getCreateDate)
//                );
//                Map<String, Long> userSet = new HashMap<>();
//                Map<String, Integer> userDeleteMarkMap = new HashMap<>();
//                for (User student : students) {
//                    userSet.put(student.getCredentialNumber(), student.getId());
//                    userDeleteMarkMap.put(student.getCredentialNumber(), student.getDeleteMark());
//                }
//                for (BaseNewStudent student : updateList) {
//                    if(userSet.containsKey(student.getCredentialNumber())){
//                        schoolRollService.updateStudentClass(dto.getBandingTaskClassId(), userSet.get(student.getCredentialNumber()));
//                        Integer deleteMark = userDeleteMarkMap.get(student.getCredentialNumber());
//                        if(deleteMark != null && deleteMark == 1){
//                            userService.recoveryStudentInfo(userSet.get(student.getCredentialNumber()));
//                        }
//                        continue;
//                    }
//                    LocalDate birthDate = LocalDateUtil.getBirthDate(student.getCredentialNumber());
//                    User xjrUser = new User() {{
//                        setCreateDate(now);
//                        setPassword(BCrypt.hashpw(propertiesConfig.getDefaultPassword(), BCrypt.gensalt()));
//                        setName(student.getName());
//                        setUserName(student.getCredentialNumber());
//                        setCredentialNumber(student.getCredentialNumber());
//                        setCredentialType("ZZLS10007");
//                        setMobile(student.getMobile());
//                        setEnabledMark(EnabledMark.DISABLED.getCode());
//                        setGender(student.getGender());
//                        setIsChangePassword(1);
//                        setBirthDate(birthDate.atStartOfDay());
//                    }};
//                    userService.save(xjrUser);
//
//                    UserRoleRelation userRoleRelation = new UserRoleRelation() {{
//                        setRoleId(RoleEnum.STUDENT.getCode());
//                        setUserId(xjrUser.getId());
//                    }};
//                    roleRelationService.save(userRoleRelation);
//
//                    BaseStudent baseStudent = new BaseStudent() {{
//                        setUserId(xjrUser.getId());
//                        setCreateDate(now);
//                        setStudentId(student.getCredentialNumber());
//                        if(student.getHeight() != null){
//                            setHeight(student.getHeight().doubleValue());
//                        }
//                        if(student.getWeight() != null){
//                            setWeight(student.getWeight().doubleValue());
//                        }
//                    }};
//                    studentService.save(baseStudent);
//
//                    BaseStudentSchoolRoll schoolRoll = new BaseStudentSchoolRoll() {{
//                        setUserId(xjrUser.getId());
//                        if(student.getScore() != null){
//                            setGraduatedScore(student.getScore().doubleValue());
//                        }
//
//                        setGraduatedUniversity(student.getGraduateSchool());
//                        setClassId(dto.getBandingTaskClassId());
//                        setMajorSetId(aClass.getMajorSetId());
//                        setStduyStatus(student.getStduyStatus());
//                        setEnrollType(aClass.getEnrollType());
//                        setStudentSource(student.getSource());
//                        setGradeId(aClass.getGradeId());
//                        setArchivesStatus(ArchivesStatusEnum.FB2901.getCode());
//                        setCreateDate(now);
//                    }};
//                    schoolRollService.save(schoolRoll);
//
//                    BaseStudentFamily studentFamily = new BaseStudentFamily() {{
//                        setCreateDate(now);
//                        setUserId(xjrUser.getId());
//                        setTelephone(student.getFamilyMobile());
//                        setAddress(student.getFamilyAddress());
//                    }};
//                    familyService.save(studentFamily);
//                }
//            }
            CompletableFuture.runAsync(() -> {
                List<User> userList = userService.list();
                redisUtil.set(GlobalConstant.USER_CACHE_KEY, userList);

                List<UserRoleRelation> userRoleRelationList = roleRelationService.list(Wrappers.lambdaQuery(UserRoleRelation.class));
                redisUtil.set(GlobalConstant.USER_ROLE_RELATION_CACHE_KEY, userRoleRelationList);
            });
        }else{
            List<BaseNewStudent> updateList = new ArrayList<>();
            for (BaseNewStudent student : list) {
                student.setRemarks(dto.getRemarks());
                updateList.add(student);
            }
            if(!updateList.isEmpty()){
                newStudentService.updateBatchById(updateList);
            }
            for (Long newStudentId : dto.getNewStudentIds()) {
                dataList.add(
                        new BandingTaskClassStudent(){{
                            setCreateDate(new Date());
                            setNewStudentId(newStudentId);
                            setBandingTaskClassId(dto.getBandingTaskClassId());
                            setCreateUserId(createUserId);
                            setStatus(0);
                            if(dto.getIsHandle() != null && dto.getIsHandle() == 1){
                                setStatus(1);
                            }
                        }}
                );
            }
        }

        if(!dataList.isEmpty()){
            this.saveBatch(dataList);
        }
        return true;
    }

    @Override
    @Transactional
    public Boolean removeStudent(ChangeClassDto dto) {
        this.baseMapper.delete(
                new QueryWrapper<BandingTaskClassStudent>().lambda()
                        .in(BandingTaskClassStudent::getNewStudentId, dto.getNewStudentIds())
                        .eq(BandingTaskClassStudent::getBandingTaskClassId, dto.getBandingTaskClassId())
        );
        return true;
    }

    @Override
    @Transactional
    public Boolean removeStudent(List<Long> studentIds, Long bandingTaskId) {
        List<BandingTaskClassStudent> classStudents = this.baseMapper.selectList(
                new MPJLambdaWrapper<BandingTaskClassStudent>()
                        .select(BandingTaskClassStudent::getId)
                        .select(BandingTaskClassStudent.class, x -> VoToColumnUtil.fieldsToColumns(BandingTaskClassStudent.class).contains(x.getProperty()))
                        .innerJoin(BandingTaskClass.class, BandingTaskClass::getId, BandingTaskClassStudent::getBandingTaskClassId)
                        .in(BandingTaskClassStudent::getNewStudentId, studentIds)
                        .eq(BandingTaskClass::getBandingTaskId, bandingTaskId)
        );
        this.removeBatchByIds(classStudents);
        return true;
    }

    @Override
    public List<BaseNewStudentPageDto> satisfyStudent(StudentDto dto) {
        BandingTaskClass taskClass = taskClassMapper.selectById(dto.getBandingTaskClassId());
        dto.setBandingTaskId(taskClass.getBandingTaskId());

        BandingTask task = taskMapper.selectById(taskClass.getBandingTaskId());
        if(task != null && task.getStatus() != null && task.getStatus() == 1){
            return this.baseMapper.satisfyStudentSure(dto);
        }

        return this.baseMapper.satisfyStudent(dto);
    }

    @Override
    public List<BaseNewStudentPageDto> surplusStudent(StudentDto dto) {
        BandingTaskClass taskClass = taskClassMapper.selectById(dto.getBandingTaskClassId());
        dto.setMajorSetId(taskClass.getMajorSetId());
        dto.setBandingTaskId(taskClass.getBandingTaskId());

        BandingTask task = taskMapper.selectById(taskClass.getBandingTaskId());
        if(task != null && task.getStatus() != null && task.getStatus() == 1){
            return this.baseMapper.satisfyStudentSure(dto);
        }

        return this.baseMapper.surplusStudent(dto);
    }

    @Override
    public Boolean insertStudent(ChangeClassDto dto) {
        List<BandingTaskClassStudent> dataList = new ArrayList<>();
        Date createDate = new Date();
        for (Long newStudentId : dto.getNewStudentIds()) {
            dataList.add(
                    new BandingTaskClassStudent(){{
                        setNewStudentId(newStudentId);
                        setCreateDate(createDate);
                        setStatus(0);
                        setBandingTaskClassId(dto.getBandingTaskClassId());
                    }}
            );
        }
        if(!dataList.isEmpty()){
           this.saveBatch(dataList);
        }

        return true;
    }

    /**
     * 同步修改学生的班级信息
     */
    @Override
    @Transactional
    public Boolean syncStudentData(StudentReportPlan studentReportPlan) {
        //先删除所有的
        reportRecordMapper.deleteRecordByPlanId(studentReportPlan.getId());
        
        //拷贝试读报到的数据过来
        StudentReportPlan tryReadingReportPlan = reportPlanService.getOne(
                new QueryWrapper<StudentReportPlan>().lambda()
                        .eq(StudentReportPlan::getCategory, 2)
                        .eq(StudentReportPlan::getBandingTaskId, studentReportPlan.getBandingTaskId())
        );

        List<StudentReportRecord> records = reportRecordMapper.selectList(
                new QueryWrapper<StudentReportRecord>().lambda()
                        .eq(StudentReportRecord::getStudentReportPlanId, tryReadingReportPlan.getId())
        );
        Date createDate = new Date();
        Set<Long> existInsertUserIds = new HashSet<>();
        for (StudentReportRecord record : records) {
            if(existInsertUserIds.contains(record.getUserId())){
                continue;
            }
            record.setReportTime(null);
            record.setModifyUserId(null);
            record.setModifyDate(null);
            record.setCreateDate(createDate);
            record.setStudentReportPlanId(studentReportPlan.getId());
            record.setId(null);
            reportRecordMapper.insert(record);
            existInsertUserIds.add(record.getUserId());
        }


        List<SyncStudentDataListVo> syncStudentDataList = this.baseMapper.getSyncStudentDataList(studentReportPlan.getId());
        List<Long> newStudentIds = syncStudentDataList.stream().map(SyncStudentDataListVo::getNewStudentId).collect(Collectors.toList());

        //修改新生基本信息
        Map<Long, String> stduyStatusMap = syncStudentDataList.stream().collect(Collectors.toMap(SyncStudentDataListVo::getNewStudentId, SyncStudentDataListVo::getStduyStatus));
        List<BaseNewStudent> studentList = newStudentService.listByIds(newStudentIds);
        for (BaseNewStudent student : studentList) {
            student.setStduyStatus(stduyStatusMap.get(student.getId()));
        }
        newStudentService.updateBatchById(studentList);

        //修改班级信息
        Map<Long, Long> bandingTaskClassMap = syncStudentDataList.stream().filter(x -> x.getBandingTaskClassId() != null).collect(Collectors.toMap(SyncStudentDataListVo::getNewStudentId, SyncStudentDataListVo::getBandingTaskClassId));

        List<BandingTaskClass> taskClassList = taskClassMapper.selectList(
                new QueryWrapper<BandingTaskClass>().lambda()
                        .eq(BandingTaskClass::getBandingTaskId, studentReportPlan.getBandingTaskId())
        );
        Map<Long, Long> taskClassMap = taskClassList.stream().collect(Collectors.toMap(BandingTaskClass::getBaseClassId, BandingTaskClass::getId));

        List<BandingTaskClassStudent> insertList = new ArrayList<>();
        for (BaseNewStudent student : studentList) {
            Long bandingTaskClassId = bandingTaskClassMap.get(student.getId());
            if(bandingTaskClassId == null){
                continue;
            }
            insertList.add(new BandingTaskClassStudent(){{
                setBandingTaskClassId(taskClassMap.get(bandingTaskClassId));
                setNewStudentId(student.getId());
                setCreateDate(new Date());
                setStatus(1);
            }});
        }

        if(!insertList.isEmpty()){
            this.remove(
                    new QueryWrapper<BandingTaskClassStudent>().lambda()
                            .in(BandingTaskClassStudent::getNewStudentId, newStudentIds)
            );
            this.saveBatch(insertList);
        }
        return true;
    }

}