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

import cn.dev33.satoken.secure.BCrypt;
import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
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.*;
import com.xjrsoft.common.exception.MyException;
import com.xjrsoft.common.utils.RedisUtil;
import com.xjrsoft.common.utils.VoToColumnUtil;
import com.xjrsoft.config.CommonPropertiesConfig;
import com.xjrsoft.module.base.entity.BaseCourseSubject;
import com.xjrsoft.module.base.entity.CourseSubjectDetail;
import com.xjrsoft.module.hikvision.util.DataUtil;
import com.xjrsoft.module.organization.entity.*;
import com.xjrsoft.module.organization.mapper.UserDeptRelationMapper;
import com.xjrsoft.module.organization.mapper.UserRoleRelationMapper;
import com.xjrsoft.module.organization.service.*;
import com.xjrsoft.module.personnel.entity.CarMessageApply;
import com.xjrsoft.module.personnel.mapper.CarMessageApplyMapper;
import com.xjrsoft.module.personnel.service.ITeacherFaceProcessService;
import com.xjrsoft.module.system.entity.DictionaryDetail;
import com.xjrsoft.module.system.entity.DictionaryItem;
import com.xjrsoft.module.system.service.IDictionarydetailService;
import com.xjrsoft.module.teacher.dto.AddXjrUserDto;
import com.xjrsoft.module.teacher.dto.BaseTeacherPageDto;
import com.xjrsoft.module.teacher.dto.UpdateXjrUserDto;
import com.xjrsoft.module.teacher.entity.*;
import com.xjrsoft.module.teacher.mapper.*;
import com.xjrsoft.module.teacher.service.ITeacherbaseManagerService;
import com.xjrsoft.module.teacher.vo.ProfessionalTitleImportVo;
import com.xjrsoft.module.teacher.vo.XjrUserPageVo;
import com.xjrsoft.module.veb.util.ImportExcelUtil;
import com.xjrsoft.module.veb.vo.BaseCourseSubjectImportVo;
import com.xjrsoft.module.workflow.entity.WorkflowFormRelation;
import com.xjrsoft.module.workflow.mapper.WorkflowFormRelationMapper;
import lombok.AllArgsConstructor;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.camunda.bpm.engine.history.HistoricProcessInstance;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

import static com.xjrsoft.module.veb.util.ImportExcelUtil.isRequiredFieldsFilled;
import static com.xjrsoft.module.veb.util.ImportExcelUtil.validateAndSetDictionaryField;

/**
 * @title: service
 * @Author 管理员
 * @Date: 2023-08-08
 * @Version 1.0
 */
@Service
@AllArgsConstructor
public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMapper, XjrUser> implements ITeacherbaseManagerService {
    private final XjrUserMapper teacherbaseManagerXjrUserMapper;

    private final BaseTeacherMapper teacherMapper;
    private final BaseTeacherContactMapper teacherContactMapper;
    private final BaseTeacherEducationMapper teacherEducationMapper;
    private final BaseTeacherEmployMapper teacherEmployMapper;
    private final BaseTeacherFamilyMapper baseTeacherFamilyMapper;
    private final BaseTeacherFamilyMemberMapper familyMemberMapper;
    private final BaseTeacherRegularMapper teacherRegularMapper;

    private final UserRoleRelationMapper userRoleRelationMapper;
    private final IUserDeptRelationService userDeptRelationService;
    private final RedisUtil redisUtil;
    private final UserDeptRelationMapper userDeptRelationMapper;
    private final IUserService userService;
    private final CommonPropertiesConfig propertiesConfig;
    private final IUserPostRelationService userPostRelationService;
    private final IDictionarydetailService dictionaryService;
    private final IDepartmentService departmentService;
    private final IPostService postService;
    private final ITeacherFaceProcessService teacherFaceProcessService;
    private final CarMessageApplyMapper carMessageApplyMapper;
    private IDictionarydetailService dictionarydetailService;
    private WfTeacherDepartMapper wfTeacherDepartMapper;
    private BaseTeacherChangeRecordMapper baseTeacherChangeRecordMapper;
    private WorkflowFormRelationMapper workflowFormRelationMapper;

    private ProfessionalTitleMapper professionalTitleMapper;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean add(AddXjrUserDto dto) {

        XjrUser xjrUser = BeanUtil.toBean(dto, XjrUser.class);
        xjrUser.setCode(dto.getUserName());

        // 使用系统配置的默认密码
        xjrUser.setPassword(BCrypt.hashpw(propertiesConfig.getDefaultPassword(), BCrypt.gensalt()));
        teacherbaseManagerXjrUserMapper.insert(xjrUser);
        for (BaseTeacher baseTeacher : xjrUser.getBaseTeacherList()) {

            baseTeacher.setUserId(xjrUser.getId());

            if (!StrUtil.isNotBlank(baseTeacher.getJobState())) {
                baseTeacher.setIsNormal(1);
            } else {
                DictionaryDetail dictionaryDetail = dictionarydetailService.getOne(Wrappers.<DictionaryDetail>query()
                        .lambda()
                        .eq(DictionaryDetail::getCode, baseTeacher.getJobState())
                        .inSql(DictionaryDetail::getItemId, "SELECT id from xjr_dictionary_item where code='job_state'")
                );
                if (dictionaryDetail != null) {
                    if ("0".equals(dictionaryDetail.getExtendField1())) {
                        baseTeacher.setIsNormal(0);
                    } else {
                        baseTeacher.setIsNormal(1);
                    }
                }
            }

            teacherMapper.insert(baseTeacher);
        }
        for (BaseTeacherContact baseTeacherContact : xjrUser.getBaseTeacherContactList()) {
            baseTeacherContact.setUserId(xjrUser.getId());
            teacherContactMapper.insert(baseTeacherContact);
        }
        for (BaseTeacherEducation baseTeacherEducation : xjrUser.getBaseTeacherEducationList()) {
            baseTeacherEducation.setUserId(xjrUser.getId());
            teacherEducationMapper.insert(baseTeacherEducation);
        }
        for (BaseTeacherEmploy baseTeacherEmploy : xjrUser.getBaseTeacherEmployList()) {
            baseTeacherEmploy.setUserId(xjrUser.getId());
            teacherEmployMapper.insert(baseTeacherEmploy);
        }
        for (BaseTeacherFamily baseTeacherFamily : xjrUser.getBaseTeacherFamilyList()) {
            baseTeacherFamily.setUserId(xjrUser.getId());
            baseTeacherFamilyMapper.insert(baseTeacherFamily);
        }
        for (BaseTeacherFamilyMember baseTeacherFamilyMember : xjrUser.getBaseTeacherFamilyMemberList()) {
            baseTeacherFamilyMember.setUserId(xjrUser.getId());
            familyMemberMapper.insert(baseTeacherFamilyMember);
        }
        for (BaseTeacherRegular baseTeacherRegular : xjrUser.getBaseTeacherRegularList()) {
            baseTeacherRegular.setUserId(xjrUser.getId());
            teacherRegularMapper.insert(baseTeacherRegular);
        }

        List<UserDeptRelation> userDeptRelationList = new ArrayList<>();
        if (StrUtil.isNotBlank(dto.getDepartmentIds())) {
            String allDeptIdStr = StrUtil.join(StringPool.COMMA, dto.getDepartmentIds());
            List<Long> departmentIds = Arrays.stream(allDeptIdStr.split(StringPool.COMMA)).map(Convert::toLong).collect(Collectors.toList());
            if (CollectionUtil.isNotEmpty(departmentIds)) {
                for (Long deptId : departmentIds) {
                    //将用户所选部门保存到关联表中
                    UserDeptRelation userDeptRelation = new UserDeptRelation();
                    userDeptRelation.setUserId(xjrUser.getId());
                    userDeptRelation.setDeptId(deptId);
                    userDeptRelationList.add(userDeptRelation);
                }
            }
            userDeptRelationService.saveBatch(userDeptRelationList);
        }

        List<UserPostRelation> userPostRelationList = new ArrayList<>();
        if (StrUtil.isNotBlank(dto.getPostIds())) {
            String allPostIdStr = StrUtil.join(StringPool.COMMA, dto.getPostIds());
            List<Long> postIds = Arrays.stream(allPostIdStr.split(StringPool.COMMA)).map(Convert::toLong).collect(Collectors.toList());
            if (CollectionUtil.isNotEmpty(postIds)) {
                for (Long postId : postIds) {
                    //将用户所选岗位保存到关联表中
                    UserPostRelation userPostRelation = new UserPostRelation();
                    userPostRelation.setUserId(xjrUser.getId());
                    userPostRelation.setPostId(postId);
                    userPostRelationList.add(userPostRelation);
                }
            }
            userPostRelationService.saveBatch(userPostRelationList);
        }

        // 添加角色
        UserRoleRelation userRoleRelation = new UserRoleRelation();
        userRoleRelation.setUserId(xjrUser.getId());
        userRoleRelation.setRoleId(RoleEnum.TEACHER.getCode());
        userRoleRelationMapper.insert(userRoleRelation);

        List<User> list = userService.list();
        list.add(BeanUtil.toBean(xjrUser, User.class));
        redisUtil.set(GlobalConstant.USER_CACHE_KEY, list);


        List<UserDeptRelation> deptRelationList = userDeptRelationMapper.selectList(Wrappers.lambdaQuery(UserDeptRelation.class));
        redisUtil.set(GlobalConstant.USER_DEPT_RELATION_CACHE_KEY, deptRelationList);

        List<UserRoleRelation> userRoleRelationList = userRoleRelationMapper.selectList(Wrappers.lambdaQuery(UserRoleRelation.class));
        redisUtil.set(GlobalConstant.USER_ROLE_RELATION_CACHE_KEY, userRoleRelationList);

        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean update(UpdateXjrUserDto dto) {
        XjrUser old = this.getByIdDeep(dto.getId());
        if (ObjectUtils.isEmpty(old)) {
            throw new MyException("教职工信息不存在");
        }

        // 处理在职状态
        // 获取字典值
        List<DictionaryDetail> detailList = dictionarydetailService.list(
                new MPJLambdaWrapper<DictionaryDetail>()
                        .select(DictionaryDetail::getId)
                        .select(DictionaryDetail.class, x -> VoToColumnUtil.fieldsToColumns(DictionaryDetail.class).contains(x.getProperty()))
                        .leftJoin(DictionaryItem.class, DictionaryItem::getId, DictionaryDetail::getItemId)
                        .eq(DictionaryItem::getCode, "job_state")
        );

        Map<String, String> dictionaryDetailMap = detailList.stream()
                .collect(Collectors.toMap(DictionaryDetail::getCode, DictionaryDetail::getName));

        // 定义常量
        final String NO_JOB_STATE = "无在职状态";

        // 获取新旧在职状态
        String oldJobState = null;
        String newJobState = null;

        if (CollectionUtils.isNotEmpty(old.getBaseTeacherList()) && StringUtils.isNotEmpty(old.getBaseTeacherList().get(0).getJobState())) {
            oldJobState = old.getBaseTeacherList().get(0).getJobState();
        }

        if (CollectionUtils.isNotEmpty(dto.getBaseTeacherList()) && StringUtils.isNotEmpty(dto.getBaseTeacherList().get(0).getJobState())) {
            newJobState = dto.getBaseTeacherList().get(0).getJobState();
        }

        // 只有在职状态被修改时，才触发 insert
        if (!Objects.equals(oldJobState, newJobState)) {
            BaseTeacherChangeRecord insetBaseTeacherChangeRecord = new BaseTeacherChangeRecord();
            insetBaseTeacherChangeRecord.setCreateUserId(StpUtil.getLoginIdAsLong());
            insetBaseTeacherChangeRecord.setCreateDate(new Date());
            insetBaseTeacherChangeRecord.setUserId(dto.getId());
            insetBaseTeacherChangeRecord.setChangeType(TeaChangeTypeEnum.TCT0001.getCode());

            // 设置旧状态
            if (StringUtils.isNotEmpty(oldJobState)) {
                insetBaseTeacherChangeRecord.setOldJobState(dictionaryDetailMap.getOrDefault(oldJobState, oldJobState));
            } else {
                insetBaseTeacherChangeRecord.setOldJobState(NO_JOB_STATE);
            }

            // 设置新状态
            if (StringUtils.isNotEmpty(newJobState)) {
                insetBaseTeacherChangeRecord.setNewJobState(dictionaryDetailMap.getOrDefault(newJobState, newJobState));
            } else {
                insetBaseTeacherChangeRecord.setNewJobState(NO_JOB_STATE);
            }

            // 插入变更记录
            baseTeacherChangeRecordMapper.insert(insetBaseTeacherChangeRecord);

            //如果在职状态改为了非在职，禁用账号，并清空海康相关信息
            if (!JobStateEnum.isBeOnTheJobByCode(oldJobState)) {
                disabledUser(dto.getId());
            }
        }

        XjrUser xjrUser = BeanUtil.toBean(dto, XjrUser.class);

        teacherbaseManagerXjrUserMapper.updateById(xjrUser);

        //先删除再新增
        userDeptRelationService.remove(Wrappers.<UserDeptRelation>query().lambda().eq(UserDeptRelation::getUserId, xjrUser.getId()));
        List<UserDeptRelation> userDeptRelationList = new ArrayList<>();
        if (StrUtil.isNotBlank(dto.getDepartmentIds())) {
            String allDeptIdStr = StrUtil.join(StringPool.COMMA, dto.getDepartmentIds());
            List<Long> departmentIds = Arrays.stream(allDeptIdStr.split(StringPool.COMMA)).map(Convert::toLong).collect(Collectors.toList());
            if (CollectionUtil.isNotEmpty(departmentIds)) {
                for (Long deptId : departmentIds) {
                    //将用户所选部门保存到关联表中
                    UserDeptRelation userDeptRelation = new UserDeptRelation();
                    userDeptRelation.setUserId(xjrUser.getId());
                    userDeptRelation.setDeptId(deptId);
                    userDeptRelationList.add(userDeptRelation);
                }
            }
            userDeptRelationService.saveBatch(userDeptRelationList);
        }

        userPostRelationService.remove(Wrappers.<UserPostRelation>query().lambda().eq(UserPostRelation::getUserId, xjrUser.getId()));
        List<UserPostRelation> userPostRelationList = new ArrayList<>();
        if (StrUtil.isNotBlank(dto.getPostIds())) {
            String allPostIdStr = StrUtil.join(StringPool.COMMA, dto.getPostIds());
            List<Long> postIds = Arrays.stream(allPostIdStr.split(StringPool.COMMA)).map(Convert::toLong).collect(Collectors.toList());
            if (CollectionUtil.isNotEmpty(postIds)) {
                for (Long postId : postIds) {
                    //将用户所选岗位保存到关联表中
                    UserPostRelation userPostRelation = new UserPostRelation();
                    userPostRelation.setUserId(xjrUser.getId());
                    userPostRelation.setPostId(postId);
                    userPostRelationList.add(userPostRelation);
                }
            }
            userPostRelationService.saveBatch(userPostRelationList);
        }

        //********************************* BaseTeacher  增删改  开始 *******************************************/
        {
            // 查出所有子级的id
            List<BaseTeacher> baseTeacherList = teacherMapper.selectList(Wrappers.lambdaQuery(BaseTeacher.class).eq(BaseTeacher::getUserId, xjrUser.getId()).select(BaseTeacher::getId));
            List<Long> baseTeacherIds = baseTeacherList.stream().map(BaseTeacher::getId).collect(Collectors.toList());
            //原有子表单 没有被删除的主键
            List<Long> baseTeacherOldIds = xjrUser.getBaseTeacherList().stream().map(BaseTeacher::getId).filter(Objects::nonNull).collect(Collectors.toList());
            //找到需要删除的id
            List<Long> baseTeacherRemoveIds = baseTeacherIds.stream().filter(item -> !baseTeacherOldIds.contains(item)).collect(Collectors.toList());

            for (BaseTeacher baseTeacher : xjrUser.getBaseTeacherList()) {

                if (!StrUtil.isNotBlank(baseTeacher.getJobState())) {
                    baseTeacher.setIsNormal(1);
                } else {
                    DictionaryDetail dictionaryDetail = dictionarydetailService.getOne(Wrappers.<DictionaryDetail>query()
                            .lambda()
                            .eq(DictionaryDetail::getCode, baseTeacher.getJobState())
                            .inSql(DictionaryDetail::getItemId, "SELECT id from xjr_dictionary_item where code='job_state'")
                    );
                    if (dictionaryDetail != null) {
                        if ("0".equals(dictionaryDetail.getExtendField1())) {
                            baseTeacher.setIsNormal(0);
                        } else {
                            baseTeacher.setIsNormal(1);
                        }
                    }
                }

                //如果不等于空则修改
                if (baseTeacher.getId() != null) {
                    teacherMapper.updateById(baseTeacher);
                }
                //如果等于空 则新增
                else {
                    //已经不存在的id 删除
                    baseTeacher.setUserId(xjrUser.getId());
                    teacherMapper.insert(baseTeacher);
                }
            }
            //已经不存在的id 删除
            if (baseTeacherRemoveIds.size() > 0) {
                teacherMapper.deleteBatchIds(baseTeacherRemoveIds);
            }
        }
        //********************************* BaseTeacher  增删改  结束 *******************************************/

        //********************************* BaseTeacherContact  增删改  开始 *******************************************/
        {
            // 查出所有子级的id
            List<BaseTeacherContact> baseTeacherContactList = teacherContactMapper.selectList(Wrappers.lambdaQuery(BaseTeacherContact.class).eq(BaseTeacherContact::getUserId, xjrUser.getId()).select(BaseTeacherContact::getId));
            List<Long> baseTeacherContactIds = baseTeacherContactList.stream().map(BaseTeacherContact::getId).collect(Collectors.toList());
            //原有子表单 没有被删除的主键
            List<Long> baseTeacherContactOldIds = xjrUser.getBaseTeacherContactList().stream().map(BaseTeacherContact::getId).filter(Objects::nonNull).collect(Collectors.toList());
            //找到需要删除的id
            List<Long> baseTeacherContactRemoveIds = baseTeacherContactIds.stream().filter(item -> !baseTeacherContactOldIds.contains(item)).collect(Collectors.toList());

            for (BaseTeacherContact baseTeacherContact : xjrUser.getBaseTeacherContactList()) {
                //如果不等于空则修改
                if (baseTeacherContact.getId() != null) {
                    teacherContactMapper.updateById(baseTeacherContact);
                }
                //如果等于空 则新增
                else {
                    //已经不存在的id 删除
                    baseTeacherContact.setUserId(xjrUser.getId());
                    teacherContactMapper.insert(baseTeacherContact);
                }
            }
            //已经不存在的id 删除
            if (baseTeacherContactRemoveIds.size() > 0) {
                teacherContactMapper.deleteBatchIds(baseTeacherContactRemoveIds);
            }
        }
        //********************************* BaseTeacherContact  增删改  结束 *******************************************/

        //********************************* BaseTeacherEducation  增删改  开始 *******************************************/
        {
            // 查出所有子级的id
            List<BaseTeacherEducation> baseTeacherEducationList = teacherEducationMapper.selectList(Wrappers.lambdaQuery(BaseTeacherEducation.class).eq(BaseTeacherEducation::getUserId, xjrUser.getId()).select(BaseTeacherEducation::getId));
            List<Long> baseTeacherEducationIds = baseTeacherEducationList.stream().map(BaseTeacherEducation::getId).collect(Collectors.toList());
            //原有子表单 没有被删除的主键
            List<Long> baseTeacherEducationOldIds = xjrUser.getBaseTeacherEducationList().stream().map(BaseTeacherEducation::getId).filter(Objects::nonNull).collect(Collectors.toList());
            //找到需要删除的id
            List<Long> baseTeacherEducationRemoveIds = baseTeacherEducationIds.stream().filter(item -> !baseTeacherEducationOldIds.contains(item)).collect(Collectors.toList());

            for (BaseTeacherEducation baseTeacherEducation : xjrUser.getBaseTeacherEducationList()) {
                //如果不等于空则修改
                if (baseTeacherEducation.getId() != null) {
                    teacherEducationMapper.updateById(baseTeacherEducation);
                }
                //如果等于空 则新增
                else {
                    //已经不存在的id 删除
                    baseTeacherEducation.setUserId(xjrUser.getId());
                    teacherEducationMapper.insert(baseTeacherEducation);
                }
            }
            //已经不存在的id 删除
            if (baseTeacherEducationRemoveIds.size() > 0) {
                teacherEducationMapper.deleteBatchIds(baseTeacherEducationRemoveIds);
            }
        }
        //********************************* BaseTeacherEducation  增删改  结束 *******************************************/

        //********************************* BaseTeacherEmploy  增删改  开始 *******************************************/
        {
            // 查出所有子级的id
            List<BaseTeacherEmploy> baseTeacherEmployList = teacherEmployMapper.selectList(Wrappers.lambdaQuery(BaseTeacherEmploy.class).eq(BaseTeacherEmploy::getUserId, xjrUser.getId()).select(BaseTeacherEmploy::getId));
            List<Long> baseTeacherEmployIds = baseTeacherEmployList.stream().map(BaseTeacherEmploy::getId).collect(Collectors.toList());
            //原有子表单 没有被删除的主键
            List<Long> baseTeacherEmployOldIds = xjrUser.getBaseTeacherEmployList().stream().map(BaseTeacherEmploy::getId).filter(Objects::nonNull).collect(Collectors.toList());
            //找到需要删除的id
            List<Long> baseTeacherEmployRemoveIds = baseTeacherEmployIds.stream().filter(item -> !baseTeacherEmployOldIds.contains(item)).collect(Collectors.toList());

            for (BaseTeacherEmploy baseTeacherEmploy : xjrUser.getBaseTeacherEmployList()) {
                //如果不等于空则修改
                if (baseTeacherEmploy.getId() != null) {
                    teacherEmployMapper.updateById(baseTeacherEmploy);
                }
                //如果等于空 则新增
                else {
                    //已经不存在的id 删除
                    baseTeacherEmploy.setUserId(xjrUser.getId());
                    teacherEmployMapper.insert(baseTeacherEmploy);
                }
            }
            //已经不存在的id 删除
            if (baseTeacherEmployRemoveIds.size() > 0) {
                teacherEmployMapper.deleteBatchIds(baseTeacherEmployRemoveIds);
            }
        }
        //********************************* BaseTeacherEmploy  增删改  结束 *******************************************/

        //********************************* BaseTeacherFamily  增删改  开始 *******************************************/
        {
            // 查出所有子级的id
            List<BaseTeacherFamily> baseTeacherFamilyList = baseTeacherFamilyMapper.selectList(Wrappers.lambdaQuery(BaseTeacherFamily.class).eq(BaseTeacherFamily::getUserId, xjrUser.getId()).select(BaseTeacherFamily::getId));
            List<Long> baseTeacherFamilyIds = baseTeacherFamilyList.stream().map(BaseTeacherFamily::getId).collect(Collectors.toList());
            //原有子表单 没有被删除的主键
            List<Long> baseTeacherFamilyOldIds = xjrUser.getBaseTeacherFamilyList().stream().map(BaseTeacherFamily::getId).filter(Objects::nonNull).collect(Collectors.toList());
            //找到需要删除的id
            List<Long> baseTeacherFamilyRemoveIds = baseTeacherFamilyIds.stream().filter(item -> !baseTeacherFamilyOldIds.contains(item)).collect(Collectors.toList());

            for (BaseTeacherFamily baseTeacherFamily : xjrUser.getBaseTeacherFamilyList()) {
                //如果不等于空则修改
                if (baseTeacherFamily.getId() != null) {
                    baseTeacherFamilyMapper.updateById(baseTeacherFamily);
                }
                //如果等于空 则新增
                else {
                    //已经不存在的id 删除
                    baseTeacherFamily.setUserId(xjrUser.getId());
                    baseTeacherFamilyMapper.insert(baseTeacherFamily);
                }
            }
            //已经不存在的id 删除
            if (baseTeacherFamilyRemoveIds.size() > 0) {
                baseTeacherFamilyMapper.deleteBatchIds(baseTeacherFamilyRemoveIds);
            }
        }
        //********************************* BaseTeacherFamily  增删改  结束 *******************************************/

        //********************************* BaseTeacherFamilyMember  增删改  开始 *******************************************/
        {
            // 查出所有子级的id
            List<BaseTeacherFamilyMember> baseTeacherFamilyMemberList = familyMemberMapper.selectList(Wrappers.lambdaQuery(BaseTeacherFamilyMember.class).eq(BaseTeacherFamilyMember::getUserId, xjrUser.getId()).select(BaseTeacherFamilyMember::getId));
            List<Long> baseTeacherFamilyMemberIds = baseTeacherFamilyMemberList.stream().map(BaseTeacherFamilyMember::getId).collect(Collectors.toList());
            //原有子表单 没有被删除的主键
            List<Long> baseTeacherFamilyMemberOldIds = xjrUser.getBaseTeacherFamilyMemberList().stream().map(BaseTeacherFamilyMember::getId).filter(Objects::nonNull).collect(Collectors.toList());
            //找到需要删除的id
            List<Long> baseTeacherFamilyMemberRemoveIds = baseTeacherFamilyMemberIds.stream().filter(item -> !baseTeacherFamilyMemberOldIds.contains(item)).collect(Collectors.toList());

            for (BaseTeacherFamilyMember baseTeacherFamilyMember : xjrUser.getBaseTeacherFamilyMemberList()) {
                //如果不等于空则修改
                if (baseTeacherFamilyMember.getId() != null) {
                    familyMemberMapper.updateById(baseTeacherFamilyMember);
                }
                //如果等于空 则新增
                else {
                    //已经不存在的id 删除
                    baseTeacherFamilyMember.setUserId(xjrUser.getId());
                    familyMemberMapper.insert(baseTeacherFamilyMember);
                }
            }
            //已经不存在的id 删除
            if (baseTeacherFamilyMemberRemoveIds.size() > 0) {
                familyMemberMapper.deleteBatchIds(baseTeacherFamilyMemberRemoveIds);
            }
        }
        //********************************* BaseTeacherFamilyMember  增删改  结束 *******************************************/

        //********************************* BaseTeacherRegular  增删改  开始 *******************************************/
        {
            // 查出所有子级的id
            List<BaseTeacherRegular> baseTeacherRegularList = teacherRegularMapper.selectList(Wrappers.lambdaQuery(BaseTeacherRegular.class).eq(BaseTeacherRegular::getUserId, xjrUser.getId()).select(BaseTeacherRegular::getId));
            List<Long> baseTeacherRegularIds = baseTeacherRegularList.stream().map(BaseTeacherRegular::getId).collect(Collectors.toList());
            //原有子表单 没有被删除的主键
            List<Long> baseTeacherRegularOldIds = xjrUser.getBaseTeacherRegularList().stream().map(BaseTeacherRegular::getId).filter(Objects::nonNull).collect(Collectors.toList());
            //找到需要删除的id
            List<Long> baseTeacherRegularRemoveIds = baseTeacherRegularIds.stream().filter(item -> !baseTeacherRegularOldIds.contains(item)).collect(Collectors.toList());

            for (BaseTeacherRegular baseTeacherRegular : xjrUser.getBaseTeacherRegularList()) {
                //如果不等于空则修改
                if (baseTeacherRegular.getId() != null) {
                    teacherRegularMapper.updateById(baseTeacherRegular);
                }
                //如果等于空 则新增
                else {
                    //已经不存在的id 删除
                    baseTeacherRegular.setUserId(xjrUser.getId());
                    teacherRegularMapper.insert(baseTeacherRegular);
                }
            }
            //已经不存在的id 删除
            if (baseTeacherRegularRemoveIds.size() > 0) {
                teacherRegularMapper.deleteBatchIds(baseTeacherRegularRemoveIds);
            }
        }
        //********************************* BaseTeacherRegular  增删改  结束 *******************************************/

        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean delete(List<Long> ids) {
        teacherbaseManagerXjrUserMapper.deleteBatchIds(ids);
        teacherMapper.delete(Wrappers.lambdaQuery(BaseTeacher.class).in(BaseTeacher::getUserId, ids));
        teacherContactMapper.delete(Wrappers.lambdaQuery(BaseTeacherContact.class).in(BaseTeacherContact::getUserId, ids));
        teacherEducationMapper.delete(Wrappers.lambdaQuery(BaseTeacherEducation.class).in(BaseTeacherEducation::getUserId, ids));
        teacherEmployMapper.delete(Wrappers.lambdaQuery(BaseTeacherEmploy.class).in(BaseTeacherEmploy::getUserId, ids));
        baseTeacherFamilyMapper.delete(Wrappers.lambdaQuery(BaseTeacherFamily.class).in(BaseTeacherFamily::getUserId, ids));
        familyMemberMapper.delete(Wrappers.lambdaQuery(BaseTeacherFamilyMember.class).in(BaseTeacherFamilyMember::getUserId, ids));
        teacherRegularMapper.delete(Wrappers.lambdaQuery(BaseTeacherRegular.class).in(BaseTeacherRegular::getUserId, ids));

        return true;
    }

    /**
     * 导入，根据第一个工号查询是否有相关信息
     * 1、批量新增或者修改xjr_user、base_teacher、xjr_user_dept_relation、xjr_user_post_relation
     * 2、更新redis里面的缓存
     *
     * @param excelDataList 导入的数据
     * @return 成功
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean importData(List<Map<Integer, Object>> excelDataList) throws ParseException {
        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, User> userMap = userList.stream().collect(Collectors.toMap(User::getCredentialNumber, x -> x));

        List<BaseTeacher> teacherList = teacherMapper.selectJoinList(BaseTeacher.class,
                new MPJLambdaWrapper<BaseTeacher>()
                        .select(BaseTeacher::getId)
                        .select(BaseTeacher.class, x -> VoToColumnUtil.fieldsToColumns(BaseTeacher.class).contains(x.getProperty()))
                        .innerJoin(User.class, User::getId, BaseTeacher::getUserId)
        );
        Map<Long, BaseTeacher> teacherMap = teacherList.stream().collect(Collectors.toMap(BaseTeacher::getUserId, x -> x));

        List<Long> itemList = new ArrayList<>();
        itemList.add(2023000000000000016L);
        itemList.add(2023000000000000006L);
        itemList.add(2023000000000000005L);
        itemList.add(2023000000000000020L);

        List<DictionaryDetail> dictionaryList = dictionaryService.list(
                new QueryWrapper<DictionaryDetail>().lambda()
                        .in(DictionaryDetail::getItemId, itemList)
                        .eq(DictionaryDetail::getDeleteMark, DeleteMark.NODELETE.getCode())
        );
        Map<String, String> dictionaryMap = dictionaryList.stream().collect(Collectors.toMap(DictionaryDetail::getName, DictionaryDetail::getCode));

        List<Department> departmentList = departmentService.list(
                new QueryWrapper<Department>().lambda()
                        .eq(Department::getDeleteMark, DeleteMark.NODELETE.getCode())
        );
        Map<String, Long> departmentMap = departmentList.stream().collect(Collectors.toMap(Department::getName, Department::getId));

        List<Post> postList = postService.list(
                new QueryWrapper<Post>().lambda()
                        .eq(Post::getDeleteMark, DeleteMark.NODELETE.getCode())
        );
        Map<String, Long> postMap = postList.stream().collect(Collectors.toMap(Post::getName, Post::getId));

        List<UserPostRelation> postRelations = userPostRelationService.list(
                new MPJLambdaWrapper<UserPostRelation>()
                        .select(UserPostRelation::getId)
                        .select(UserPostRelation.class, x -> VoToColumnUtil.fieldsToColumns(UserPostRelation.class).contains(x.getProperty()))
                        .innerJoin(User.class, User::getId, UserPostRelation::getUserId)
                        .innerJoin(BaseTeacher.class, BaseTeacher::getUserId, User::getId)
        );
        Map<Long, List<Long>> userPostMap = postRelations.stream()
                .collect(Collectors.groupingBy(UserPostRelation::getUserId, Collectors.mapping(UserPostRelation::getPostId, Collectors.toList())));

        List<UserDeptRelation> deptRelations = userDeptRelationMapper.selectList(
                new MPJLambdaWrapper<UserDeptRelation>()
                        .select(UserDeptRelation::getId)
                        .select(UserDeptRelation.class, x -> VoToColumnUtil.fieldsToColumns(UserDeptRelation.class).contains(x.getProperty()))
                        .innerJoin(User.class, User::getId, UserDeptRelation::getUserId)
                        .innerJoin(BaseTeacher.class, BaseTeacher::getUserId, User::getId)
        );
        Map<Long, List<Long>> userDeptMap = deptRelations.stream()
                .collect(Collectors.groupingBy(UserDeptRelation::getUserId, Collectors.mapping(UserDeptRelation::getDeptId, Collectors.toList())));

        List<BaseTeacherRegular> regularList = teacherRegularMapper.selectList(
                new MPJLambdaWrapper<BaseTeacherRegular>()
                        .select(BaseTeacherRegular::getId)
                        .select(BaseTeacherRegular.class, x -> VoToColumnUtil.fieldsToColumns(BaseTeacherRegular.class).contains(x.getProperty()))
                        .innerJoin(User.class, User::getId, BaseTeacherRegular::getUserId)
        );
        Map<Long, BaseTeacherRegular> regularMap = regularList.stream()
                .collect(Collectors.toMap(BaseTeacherRegular::getUserId, x -> x));

        List<User> updateUserList = new ArrayList<>();
        List<BaseTeacher> updateTeacherList = new ArrayList<>();
        List<UserDeptRelation> updateDeptList = new ArrayList<>();
        List<UserPostRelation> updatePostList = new ArrayList<>();
        List<BaseTeacherRegular> updateBaseTeacherRegularList = new ArrayList<>();

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");

        for (Map<Integer, Object> rowData : excelDataList) {
            String credentialNumber = rowData.get(4).toString();
            if (userMap.containsKey(credentialNumber)) {
                User user = userMap.get(credentialNumber);
                user.setName(rowData.get(1).toString());
                user.setGender(GenderDictionaryEnum.getCode(rowData.get(2).toString()));
                user.setCredentialType(dictionaryMap.get(rowData.get(3).toString()));
                user.setCredentialNumber(rowData.get(4).toString());
                user.setMobile(rowData.get(5).toString());
                updateUserList.add(user);

                BaseTeacher teacher = teacherMap.get(user.getId());
                teacher.setEmployType(dictionaryMap.get(rowData.get(6).toString()));
                if(rowData.get(9) != null && StrUtil.isNotEmpty(rowData.get(9).toString())){
                    teacher.setJobState(dictionaryMap.get(rowData.get(9).toString()));
                }
                if(rowData.get(10) != null && StrUtil.isNotEmpty(rowData.get(10).toString())){
                    teacher.setJoinTime(sdf.parse(rowData.get(10).toString()));
                }

                updateTeacherList.add(teacher);

                if(rowData.get(11) != null && StrUtil.isNotEmpty(rowData.get(11).toString())){
                    BaseTeacherRegular teacherRegular = regularMap.get(user.getId());
                    JSONArray teachingStatus = teacherRegular.getTeachingStatus();
                    teachingStatus.add(dictionaryMap.get(rowData.get(11).toString()));
                    teacherRegular.setTeachingStatus(teachingStatus);
                    updateBaseTeacherRegularList.add(teacherRegular);
                }


                List<Long> deptIds = userDeptMap.get(user.getId());
                if (deptIds == null || !deptIds.contains(departmentMap.get(rowData.get(7).toString()))) {
                    UserDeptRelation userDeptRelation = new UserDeptRelation();
                    userDeptRelation.setDeptId(departmentMap.get(rowData.get(7).toString()));
                    userDeptRelation.setUserId(user.getId());
                    updateDeptList.add(userDeptRelation);
                }

                List<Long> postIds = userPostMap.get(user.getId());
                if (postIds == null || !postIds.contains(postMap.get(rowData.get(8).toString()))) {
                    UserPostRelation postRelation = new UserPostRelation();
                    postRelation.setPostId(postMap.get(rowData.get(8).toString()));
                    postRelation.setUserId(user.getId());
                    updatePostList.add(postRelation);
                }

                continue;
            }
            User user = new User();
            user.setUserName(rowData.get(0).toString());
            user.setPassword(BCrypt.hashpw(propertiesConfig.getDefaultPassword(), BCrypt.gensalt()));
            user.setIsChangePassword(1);
            user.setName(rowData.get(1).toString());
            user.setGender(GenderDictionaryEnum.getCode(rowData.get(2).toString()));
            user.setCredentialType(dictionaryMap.get(rowData.get(3).toString()));
            user.setCredentialNumber(rowData.get(4).toString());
            user.setMobile(rowData.get(5).toString());
            user.setCreateDate(LocalDateTime.now());
            userService.save(user);

            BaseTeacher teacher = new BaseTeacher();
            teacher.setEmployType(dictionaryMap.get(rowData.get(6).toString()));
            teacher.setUserId(user.getId());
            teacher.setCreateDate(LocalDateTime.now());
            if(rowData.get(9) != null && StrUtil.isNotEmpty(rowData.get(9).toString())){
                teacher.setJobState(dictionaryMap.get(rowData.get(9).toString()));
            }

            if(rowData.get(10) != null && StrUtil.isNotEmpty(rowData.get(10).toString())){
                teacher.setJoinTime(sdf.parse(rowData.get(10).toString()));
            }

            teacherMapper.insert(teacher);

            if(rowData.get(11) != null && StrUtil.isNotEmpty(rowData.get(11).toString())){
                BaseTeacherRegular teacherRegular = new BaseTeacherRegular();
                JSONArray teachingStatus = new JSONArray();
                teachingStatus.add(dictionaryMap.get(rowData.get(11).toString()));
                teacherRegular.setTeachingStatus(teachingStatus);
                teacherRegular.setCreateDate(LocalDateTime.now());
                teacherRegular.setCreateUserId(StpUtil.getLoginIdAsLong());
                teacherRegular.setUserId(user.getId());
                teacherRegular.setDeleteMark(DeleteMark.NODELETE.getCode());
                teacherRegular.setEnabledMark(EnabledMark.ENABLED.getCode());
                teacherRegularMapper.insert(teacherRegular);
            }

            UserDeptRelation userDeptRelation = new UserDeptRelation();
            userDeptRelation.setDeptId(departmentMap.get(rowData.get(7).toString()));
            userDeptRelation.setUserId(user.getId());
            userDeptRelationMapper.insert(userDeptRelation);

            UserPostRelation postRelation = new UserPostRelation();
            postRelation.setPostId(postMap.get(rowData.get(8).toString()));
            postRelation.setUserId(user.getId());
            userPostRelationService.save(postRelation);

            UserRoleRelation roleRelation = new UserRoleRelation();
            roleRelation.setUserId(user.getId());
            roleRelation.setRoleId(RoleEnum.TEACHER.getCode());
            userRoleRelationMapper.insert(roleRelation);
        }

        if (!updateUserList.isEmpty()) {
            userService.updateBatchById(updateUserList);
        }
        if (!updateDeptList.isEmpty()) {
            for (UserDeptRelation relation : updateDeptList) {
                userDeptRelationMapper.insert(relation);
            }
        }
        if (!updatePostList.isEmpty()) {
            userPostRelationService.saveBatch(updatePostList);
        }
        if (!updateTeacherList.isEmpty()) {
            for (BaseTeacher teacher : updateTeacherList) {
                teacherMapper.updateById(teacher);
            }
        }

        if (!updateBaseTeacherRegularList.isEmpty()) {
            for (BaseTeacherRegular teacherRegular : updateBaseTeacherRegularList) {
                teacherRegularMapper.updateById(teacherRegular);
            }
        }

        List<User> list = userService.list();
        redisUtil.set(GlobalConstant.USER_CACHE_KEY, list);

        List<UserDeptRelation> deptRelationList = userDeptRelationMapper.selectList(Wrappers.lambdaQuery(UserDeptRelation.class));
        redisUtil.set(GlobalConstant.USER_DEPT_RELATION_CACHE_KEY, deptRelationList);

        List<UserRoleRelation> userRoleRelationList = userRoleRelationMapper.selectList(Wrappers.lambdaQuery(UserRoleRelation.class));
        redisUtil.set(GlobalConstant.USER_ROLE_RELATION_CACHE_KEY, userRoleRelationList);

        List<UserPostRelation> postRelationList = userPostRelationService.list(Wrappers.lambdaQuery(UserPostRelation.class));
        redisUtil.set(GlobalConstant.USER_POST_RELATION_CACHE_KEY, postRelationList);

        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void changeIsNormal(String jobState, Integer isNormal) {
        List<BaseTeacher> baseTeacherList = teacherMapper.selectList(Wrappers.lambdaQuery(BaseTeacher.class)
                .eq(BaseTeacher::getJobState, jobState));
        for (BaseTeacher baseTeacher : baseTeacherList) {
            baseTeacher.setIsNormal(isNormal);
            teacherMapper.updateById(baseTeacher);
        }

    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void teacherDepartDataHandle(Long formId) {
        WfTeacherDepart wfTextbookRecede = wfTeacherDepartMapper.selectById(formId);

        Date nowDate = new Date();

        // 根据数据id找到所在流程得状态
        WorkflowFormRelation workflowFormRelation = workflowFormRelationMapper.selectOne(
                Wrappers.lambdaQuery(WorkflowFormRelation.class)
                        .eq(WorkflowFormRelation::getFormKeyValue, formId)
        );

        if (ObjectUtils.isNotEmpty(wfTextbookRecede)
                && ObjectUtils.isNotEmpty(workflowFormRelation)
                && HistoricProcessInstance.STATE_COMPLETED.equals(workflowFormRelation.getCurrentState())
        ) {
            XjrUser old = this.getByIdDeep(wfTextbookRecede.getApplicantUserId());
            if (ObjectUtils.isEmpty(old)) {
                throw new MyException("教职工信息不存在");
            }

            // 处理在职状态
            // 更新教职工在职状态
            List<BaseTeacher> baseTeacherList = old.getBaseTeacherList();
            BaseTeacher updateBaseTeacher;
            for (BaseTeacher baseTeacher : baseTeacherList) {
                updateBaseTeacher = new BaseTeacher();
                updateBaseTeacher.setId(baseTeacher.getId());
                updateBaseTeacher.setJobState("JOB_LZ");
                teacherMapper.updateById(updateBaseTeacher);
            }

            // 处理变更记录
            // 获取字典值
            List<DictionaryDetail> detailList = dictionarydetailService.list(
                    new MPJLambdaWrapper<DictionaryDetail>()
                            .select(DictionaryDetail::getId)
                            .select(DictionaryDetail.class, x -> VoToColumnUtil.fieldsToColumns(DictionaryDetail.class).contains(x.getProperty()))
                            .leftJoin(DictionaryItem.class, DictionaryItem::getId, DictionaryDetail::getItemId)
                            .eq(DictionaryItem::getCode, "job_state")
            );

            Map<String, String> dictionaryDetailMap = detailList.stream()
                    .collect(Collectors.toMap(DictionaryDetail::getCode, DictionaryDetail::getName));

            // 定义常量
            final String NO_JOB_STATE = "无在职状态";

            // 获取新旧在职状态
            String oldJobState = null;
            String newJobState = null;

            if (CollectionUtils.isNotEmpty(old.getBaseTeacherList()) && StringUtils.isNotEmpty(old.getBaseTeacherList().get(0).getJobState())) {
                oldJobState = old.getBaseTeacherList().get(0).getJobState();
            }

            newJobState = "JOB_LZ";

            // 只有在职状态被修改时，才触发 insert
            if (!Objects.equals(oldJobState, newJobState)) {
                BaseTeacherChangeRecord insetBaseTeacherChangeRecord = new BaseTeacherChangeRecord();
                insetBaseTeacherChangeRecord.setCreateUserId(wfTextbookRecede.getApplicantUserId());
                insetBaseTeacherChangeRecord.setCreateDate(nowDate);
                insetBaseTeacherChangeRecord.setUserId(wfTextbookRecede.getApplicantUserId());
                insetBaseTeacherChangeRecord.setChangeType(TeaChangeTypeEnum.TCT0001.getCode());

                // 设置旧状态
                if (StringUtils.isNotEmpty(oldJobState)) {
                    insetBaseTeacherChangeRecord.setOldJobState(dictionaryDetailMap.getOrDefault(oldJobState, oldJobState));
                } else {
                    insetBaseTeacherChangeRecord.setOldJobState(NO_JOB_STATE);
                }

                // 设置新状态
                if (StringUtils.isNotEmpty(newJobState)) {
                    insetBaseTeacherChangeRecord.setNewJobState(dictionaryDetailMap.getOrDefault(newJobState, newJobState));
                } else {
                    insetBaseTeacherChangeRecord.setNewJobState(NO_JOB_STATE);
                }

                // 插入变更记录
                baseTeacherChangeRecordMapper.insert(insetBaseTeacherChangeRecord);
            }
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void disabledUser(Long userId) {
        XjrUser xjrUser = this.getById(userId);
        xjrUser.setDeleteMark(DeleteMark.DELETED.getCode());
        xjrUser.setEnabledMark(EnabledMark.DISABLED.getCode());
        this.updateById(xjrUser);

        //清除海康人脸
        teacherFaceProcessService.removeByUserId(userId);

        DataUtil dataUtil = new DataUtil();

        List<Long> userIds = new ArrayList<>();
        userIds.add(userId);
        dataUtil.deletePerson(userIds);

        List<CarMessageApply> carList = carMessageApplyMapper.selectList(
                new QueryWrapper<CarMessageApply>().lambda()
                        .eq(CarMessageApply::getDeleteMark, DeleteMark.NODELETE.getCode())
                        .eq(CarMessageApply::getUserId, userId)
        );
        dataUtil.deleteCar(carList);
    }

    @Override
    public List<XjrUserPageVo> getList(BaseTeacherPageDto dto) {
        return teacherMapper.getList(dto);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String professionalTitle(MultipartFile file) throws IOException, IllegalAccessException {
        List<ProfessionalTitleImportVo> excelDataList = EasyExcel.read(file.getInputStream()).headRowNumber(1).head(ProfessionalTitleImportVo.class).sheet().doReadSync();
        StringBuilder sb = new StringBuilder();

        // 获取所有的教职工
        MPJLambdaWrapper<XjrUser> xjrUserMPJLambdaWrapper = new MPJLambdaWrapper<>();
        xjrUserMPJLambdaWrapper
                .select(XjrUser::getId)
                .select(XjrUser::getUserName, XjrUser::getUserName)
                .select(XjrUser::getName, XjrUser::getName)
                .select(" (SELECT GROUP_CONCAT(a.id) FROM xjr_department a" +
                        " INNER JOIN xjr_user_dept_relation b ON a.id = b.dept_id" +
                        " WHERE a.delete_mark = 0 AND b.user_id = t.id) as code")
                .innerJoin(UserRoleRelation.class, UserRoleRelation::getUserId, XjrUser::getId)
                .eq(UserRoleRelation::getRoleId, 2)
        ;

        List<XjrUser> xjrUsers = this.selectJoinList(XjrUser.class, xjrUserMPJLambdaWrapper);
        // 根据姓名和工号映射
        Map<String, XjrUser> mapByUsernameAndName = xjrUsers.stream()
                .collect(Collectors.toMap(u -> u.getUserName() + "-" + u.getName(), u -> u, (u1, u2) -> u1));

        if (MapUtils.isEmpty(mapByUsernameAndName)) {
            sb.append("系统教职工数据有误，请联系管理员");
            return sb.toString();
        }

        List<ProfessionalTitle> oldProfessionalTitles = professionalTitleMapper.selectList(Wrappers.lambdaQuery(ProfessionalTitle.class)
                .eq(ProfessionalTitle::getDeleteMark, DeleteMark.NODELETE.getCode())
        );

        // 先根据用户分组，再根据
        Map<Long, Map<String, ProfessionalTitle>> mapByUserIdThenNo = oldProfessionalTitles.stream()
                        .collect(Collectors.groupingBy(
                                ProfessionalTitle::getUserId, // 第一级分组：按 userId 分组
                                Collectors.toMap(
                                        ProfessionalTitle::getProfessionalTitleNo, // 第二级分组的键：professionalTitleNo
                                        pt -> pt // 第二级分组的值：整个 ProfessionalTitle 对象
                                )
                        ));

        List<ProfessionalTitle> professionalTitles = new ArrayList<>();
        ProfessionalTitle insert;
        for (int i = 0; i < excelDataList.size(); i++) {
            ProfessionalTitleImportVo vo = excelDataList.get(i);
            if (isRequiredFieldsFilled(vo,
                    sb,
                    i + 1)) {
                return sb.toString();
            }

            XjrUser user = mapByUsernameAndName.get(vo.getUserName() + "-" + vo.getName());
            if (ObjectUtils.isEmpty(user)) {
                sb
                        .append("第")
                        .append(i + 1)
                        .append("行工号和姓名对应的教职工不存在，请核实");
                return sb.toString();
            }

            insert = new ProfessionalTitle();
            BeanUtils.copyProperties(vo, insert);
            insert.setUserId(user.getId());
            insert.setDeptId(user.getCode());


            professionalTitles.add(insert);
        }

//        //批量新增
//        if (!professionalTitles.isEmpty()) {
//            for (BaseCourseSubject baseCourseSubject : baseCourseSubjects) {
//                baseCourseSubjectMapper.insert(baseCourseSubject);
//            }
//        }
//        if (!courseSubjectDetails.isEmpty()) {
//            for (CourseSubjectDetail courseSubjectDetail : courseSubjectDetails) {
//                courseSubjectDetailMapper.insert(courseSubjectDetail);
//            }
//        }
        return sb.toString();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String teacherCertification(MultipartFile file) throws IOException, IllegalAccessException {
        return "";
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String evaluatorInformation(MultipartFile file) throws IOException, IllegalAccessException {
        return "";
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String languageCompetence(MultipartFile file) throws IOException, IllegalAccessException {
        return "";
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String facultyContract(MultipartFile file) throws IOException, IllegalAccessException {
        return "";
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String outsideAssociations(MultipartFile file) throws IOException, IllegalAccessException {
        return "";
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String coreTeacher(MultipartFile file) throws IOException, IllegalAccessException {
        return "";
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String scientificResearch(MultipartFile file) throws IOException, IllegalAccessException {
        return "";
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String jobInformation(MultipartFile file) throws IOException, IllegalAccessException {
        return "";
    }

//    public String jobInformation(MultipartFile file) {
//        return "";
//    }
}