api/src/main/java/com/xjrsoft/module/base/service/impl/BaseClassMergeServiceImpl.java

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

import cn.dev33.satoken.stp.StpUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.xjrsoft.common.enums.DeleteMark;
import com.xjrsoft.common.enums.StudentChangeTypeEnum;
import com.xjrsoft.common.exception.MyException;
import com.xjrsoft.common.page.ConventPage;
import com.xjrsoft.common.utils.VoToColumnUtil;
import com.xjrsoft.module.base.dto.BaseClassMergeStudentPageDto;
import com.xjrsoft.module.base.entity.BaseClass;
import com.xjrsoft.module.base.entity.BaseClassMerge;
import com.xjrsoft.module.base.entity.BaseClassMergeStudent;
import com.xjrsoft.module.base.mapper.BaseClassMapper;
import com.xjrsoft.module.base.mapper.BaseClassMergeMapper;
import com.xjrsoft.module.base.mapper.BaseClassMergeStudentMapper;
import com.xjrsoft.module.base.service.IBaseClassMergeService;
import com.xjrsoft.module.base.vo.BaseClassMergeStudentVo;
import com.xjrsoft.module.organization.entity.User;
import com.xjrsoft.module.student.entity.StudentChangeRecord;
import com.xjrsoft.module.student.mapper.BaseStudentSchoolRollMapper;
import com.xjrsoft.module.student.service.IStudentChangeRecordService;
import com.xjrsoft.module.system.entity.DictionaryDetail;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;

/**
* @title: 班级合并
* @Author dzx
* @Date: 2025-04-08
* @Version 1.0
*/
@Service
@AllArgsConstructor
public class BaseClassMergeServiceImpl extends MPJBaseServiceImpl<BaseClassMergeMapper, BaseClassMerge> implements IBaseClassMergeService {

    private final BaseClassMergeStudentMapper mergeStudentMapper;
    private final BaseClassMapper baseClassMapper;
    private final BaseStudentSchoolRollMapper schoolRollMapper;
    private final IStudentChangeRecordService changeRecordService;


    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean add(BaseClassMerge baseClassMerge) {
        Set<Long> collect = baseClassMerge.getBaseClassMergeStudentList().stream().map(BaseClassMergeStudent::getClassId).collect(Collectors.toSet());
        if(collect.contains(baseClassMerge.getTargetClassId())){
            throw new MyException("原有班级中不能包含目标班级，请重新选择原有班级");
        }
        baseClassMerge.setStudentCount(baseClassMerge.getBaseClassMergeStudentList().size());
        this.baseMapper.insert(baseClassMerge);
        BaseClass baseClass = baseClassMapper.selectById(baseClassMerge.getTargetClassId());


        List<BaseClass> classList = baseClassMapper.selectBatchIds(collect);
        Map<Long, String> classMap = classList.stream().collect(Collectors.toMap(BaseClass::getId, BaseClass::getName));

        for (BaseClassMergeStudent baseClassMergeStudent : baseClassMerge.getBaseClassMergeStudentList()) {
            baseClassMergeStudent.setBaseClassMergeId(baseClassMerge.getId());
            mergeStudentMapper.insert(baseClassMergeStudent);
            schoolRollMapper.updateStudentClass(baseClass.getId(), baseClass.getGradeId(), baseClass.getMajorSetId(), baseClassMergeStudent.getUserId());
            changeRecordService.insertData(
                    classMap.get(baseClassMergeStudent.getClassId()),
                    baseClassMergeStudent.getClassId().toString(),
                    baseClass.getName(),
                    baseClass.getId().toString(),
                    baseClassMergeStudent.getUserId(),
                    StpUtil.getLoginIdAsLong(),
                    StudentChangeTypeEnum.ChangeClass.getCode(),
                    3
            );
        }
        
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean update(BaseClassMerge baseClassMerge) {
        this.baseMapper.updateById(baseClassMerge);
        //********************************* BaseClassMergeStudent  增删改  开始 *******************************************/
        {
            // 查出所有子级的id
            List<BaseClassMergeStudent> baseClassMergeStudentList = mergeStudentMapper.selectList(Wrappers.lambdaQuery(BaseClassMergeStudent.class).eq(BaseClassMergeStudent::getBaseClassMergeId, baseClassMerge.getId()).select(BaseClassMergeStudent::getId));
            List<Long> baseClassMergeStudentIds = baseClassMergeStudentList.stream().map(BaseClassMergeStudent::getId).collect(Collectors.toList());
            //原有子表单 没有被删除的主键
            List<Long> baseClassMergeStudentOldIds = baseClassMerge.getBaseClassMergeStudentList().stream().map(BaseClassMergeStudent::getId).filter(Objects::nonNull).collect(Collectors.toList());
            //找到需要删除的id
            List<Long> baseClassMergeStudentRemoveIds = baseClassMergeStudentIds.stream().filter(item -> !baseClassMergeStudentOldIds.contains(item)).collect(Collectors.toList());

            for (BaseClassMergeStudent baseClassMergeStudent : baseClassMerge.getBaseClassMergeStudentList()) {
                //如果不等于空则修改
                if (baseClassMergeStudent.getId() != null) {
                    mergeStudentMapper.updateById(baseClassMergeStudent);
                }
                //如果等于空 则新增
                else {
                    //已经不存在的id 删除
                    baseClassMergeStudent.setBaseClassMergeId(baseClassMerge.getId());
                    mergeStudentMapper.insert(baseClassMergeStudent);
                }
            }
            //已经不存在的id 删除
            if(!baseClassMergeStudentRemoveIds.isEmpty()){
                mergeStudentMapper.deleteBatchIds(baseClassMergeStudentRemoveIds);
            }
        }
        //********************************* BaseClassMergeStudent  增删改  结束 *******************************************/

        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean delete(List<Long> ids) {
        this.baseMapper.deleteBatchIds(ids);
        mergeStudentMapper.delete(Wrappers.lambdaQuery(BaseClassMergeStudent.class).in(BaseClassMergeStudent::getBaseClassMergeId, ids));

        return true;
    }

    @Override
    public List<BaseClass> getClassListByMergeId(Long id) {
        List<BaseClass> classList = baseClassMapper.selectList(
                new MPJLambdaWrapper<BaseClass>()
                        .select(BaseClass::getId)
                        .select(BaseClass.class, x -> VoToColumnUtil.fieldsToColumns(BaseClass.class).contains(x.getProperty()))
                        .innerJoin(BaseClassMergeStudent.class, BaseClassMergeStudent::getClassId, BaseClass::getId)
                        .eq(BaseClassMergeStudent::getDeleteMark, DeleteMark.NODELETE.getCode())
                        .eq(BaseClassMergeStudent::getBaseClassMergeId, id)
                        .orderByAsc(BaseClass::getName)
        );
        return classList;
    }

    @Override
    public String getClassNamesByMergeId(Long id) {
        List<BaseClass> classList = getClassListByMergeId(id);
        if(!classList.isEmpty()){
            Set<String> classNameSet = classList.stream().map(BaseClass::getName).collect(Collectors.toSet());
            return classNameSet.toString().replace("[", "").replace("]", "").replace(" ", "");
        }
        return null;
    }

    @Override
    public IPage<BaseClassMergeStudentVo> getStudentPage(BaseClassMergeStudentPageDto dto) {
        MPJLambdaWrapper<BaseClassMergeStudent> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper
                .select(BaseClassMergeStudent::getId)
                .select(BaseClassMergeStudent.class,x -> VoToColumnUtil.fieldsToColumns(BaseClassMergeStudent.class).contains(x.getProperty()))
                .selectAs(BaseClass::getName, BaseClassMergeStudentVo::getClassName)
                .selectAs(User::getName, BaseClassMergeStudentVo::getName)
                .selectAs(User::getCredentialNumber, BaseClassMergeStudentVo::getCredentialNumber)
                .select("t4.name", BaseClassMergeStudentVo::getGender)
                .select("t3.name", BaseClassMergeStudentVo::getTeacherName)
                .innerJoin(User.class, User::getId, BaseClassMergeStudent::getUserId)
                .innerJoin(BaseClass.class, BaseClass::getId, BaseClassMergeStudent::getClassId)
                .leftJoin(User.class, User::getId, BaseClass::getTeacherId)
                .innerJoin("xjr_dictionary_detail t4 ON (t4.code = t1.gender) ")
                .eq(BaseClassMergeStudent::getBaseClassMergeId, dto.getBaseClassMergeId())
                .orderByDesc(BaseClassMergeStudent::getId);
        IPage<BaseClassMergeStudentVo> page = mergeStudentMapper.selectJoinPage(ConventPage.getPage(dto), BaseClassMergeStudentVo.class, queryWrapper);
        return page;
    }

    @Override
    public List<Long> getClassIdsByClassName(String className) {
        List<BaseClassMergeStudent> classList = mergeStudentMapper.selectList(
                new MPJLambdaWrapper<BaseClassMergeStudent>()
                        .distinct()
                        .select(BaseClassMergeStudent::getId)
                        .select(BaseClassMergeStudent.class, x -> VoToColumnUtil.fieldsToColumns(BaseClassMergeStudent.class).contains(x.getProperty()))
                        .innerJoin(BaseClass.class, BaseClass::getId, BaseClassMergeStudent::getClassId)
                        .eq(BaseClassMergeStudent::getDeleteMark, DeleteMark.NODELETE.getCode())
                        .like(BaseClass::getName, className)
        );
        if(!classList.isEmpty()){
            Set<Long> collect = classList.stream().map(BaseClassMergeStudent::getBaseClassMergeId).collect(Collectors.toSet());
            return new ArrayList<>(collect);
        }
        return null;
    }
}