api/src/main/java/com/xjrsoft/module/teacher/service/impl/TeacherbaseManagerServiceImpl.java

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.StrUtil;
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.DeleteMark;
import com.xjrsoft.common.enums.EnabledMark;
import com.xjrsoft.common.enums.GenderDictionaryEnum;
import com.xjrsoft.common.enums.JobStateEnum;
import com.xjrsoft.common.enums.RoleEnum;
import com.xjrsoft.common.enums.TeaChangeTypeEnum;
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.hikvision.util.DataUtil;
import com.xjrsoft.module.organization.entity.Department;
import com.xjrsoft.module.organization.entity.Post;
import com.xjrsoft.module.organization.entity.User;
import com.xjrsoft.module.organization.entity.UserDeptRelation;
import com.xjrsoft.module.organization.entity.UserPostRelation;
import com.xjrsoft.module.organization.entity.UserRoleRelation;
import com.xjrsoft.module.organization.mapper.UserDeptRelationMapper;
import com.xjrsoft.module.organization.mapper.UserRoleRelationMapper;
import com.xjrsoft.module.organization.service.IDepartmentService;
import com.xjrsoft.module.organization.service.IPostService;
import com.xjrsoft.module.organization.service.IUserDeptRelationService;
import com.xjrsoft.module.organization.service.IUserPostRelationService;
import com.xjrsoft.module.organization.service.IUserService;
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.UpdateXjrUserDto;
import com.xjrsoft.module.teacher.entity.BaseTeacher;
import com.xjrsoft.module.teacher.entity.BaseTeacherChangeRecord;
import com.xjrsoft.module.teacher.entity.BaseTeacherContact;
import com.xjrsoft.module.teacher.entity.BaseTeacherEducation;
import com.xjrsoft.module.teacher.entity.BaseTeacherEmploy;
import com.xjrsoft.module.teacher.entity.BaseTeacherFamily;
import com.xjrsoft.module.teacher.entity.BaseTeacherFamilyMember;
import com.xjrsoft.module.teacher.entity.BaseTeacherRegular;
import com.xjrsoft.module.teacher.entity.WfTeacherDepart;
import com.xjrsoft.module.teacher.entity.XjrUser;
import com.xjrsoft.module.teacher.mapper.BaseTeacherChangeRecordMapper;
import com.xjrsoft.module.teacher.mapper.BaseTeacherContactMapper;
import com.xjrsoft.module.teacher.mapper.BaseTeacherEducationMapper;
import com.xjrsoft.module.teacher.mapper.BaseTeacherEmployMapper;
import com.xjrsoft.module.teacher.mapper.BaseTeacherFamilyMapper;
import com.xjrsoft.module.teacher.mapper.BaseTeacherFamilyMemberMapper;
import com.xjrsoft.module.teacher.mapper.BaseTeacherMapper;
import com.xjrsoft.module.teacher.mapper.BaseTeacherRegularMapper;
import com.xjrsoft.module.teacher.mapper.WfTeacherDepartMapper;
import com.xjrsoft.module.teacher.mapper.XjrUserMapper;
import com.xjrsoft.module.teacher.service.ITeacherbaseManagerService;
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.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.camunda.bpm.engine.history.HistoricProcessInstance;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * @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 teacherbaseManagerBaseTeacherMapper;
    private final BaseTeacherContactMapper teacherbaseManagerBaseTeacherContactMapper;
    private final BaseTeacherEducationMapper teacherbaseManagerBaseTeacherEducationMapper;
    private final BaseTeacherEmployMapper teacherbaseManagerBaseTeacherEmployMapper;
    private final BaseTeacherFamilyMapper teacherbaseManagerBaseTeacherFamilyMapper;
    private final BaseTeacherFamilyMemberMapper teacherbaseManagerBaseTeacherFamilyMemberMapper;
    private final BaseTeacherRegularMapper teacherbaseManagerBaseTeacherRegularMapper;

    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 BaseTeacherMapper baseTeacherMapper;
    private IDictionarydetailService dictionarydetailService;

    private WfTeacherDepartMapper wfTeacherDepartMapper;

    private BaseTeacherChangeRecordMapper baseTeacherChangeRecordMapper;

    private WorkflowFormRelationMapper workflowFormRelationMapper;

    private final ITeacherFaceProcessService teacherFaceProcessService;
    private final CarMessageApplyMapper carMessageApplyMapper;


    @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);
                    }
                }
            }

            teacherbaseManagerBaseTeacherMapper.insert(baseTeacher);
        }
        for (BaseTeacherContact baseTeacherContact : xjrUser.getBaseTeacherContactList()) {
            baseTeacherContact.setUserId(xjrUser.getId());
            teacherbaseManagerBaseTeacherContactMapper.insert(baseTeacherContact);
        }
        for (BaseTeacherEducation baseTeacherEducation : xjrUser.getBaseTeacherEducationList()) {
            baseTeacherEducation.setUserId(xjrUser.getId());
            teacherbaseManagerBaseTeacherEducationMapper.insert(baseTeacherEducation);
        }
        for (BaseTeacherEmploy baseTeacherEmploy : xjrUser.getBaseTeacherEmployList()) {
            baseTeacherEmploy.setUserId(xjrUser.getId());
            teacherbaseManagerBaseTeacherEmployMapper.insert(baseTeacherEmploy);
        }
        for (BaseTeacherFamily baseTeacherFamily : xjrUser.getBaseTeacherFamilyList()) {
            baseTeacherFamily.setUserId(xjrUser.getId());
            teacherbaseManagerBaseTeacherFamilyMapper.insert(baseTeacherFamily);
        }
        for (BaseTeacherFamilyMember baseTeacherFamilyMember : xjrUser.getBaseTeacherFamilyMemberList()) {
            baseTeacherFamilyMember.setUserId(xjrUser.getId());
            teacherbaseManagerBaseTeacherFamilyMemberMapper.insert(baseTeacherFamilyMember);
        }
        for (BaseTeacherRegular baseTeacherRegular : xjrUser.getBaseTeacherRegularList()) {
            baseTeacherRegular.setUserId(xjrUser.getId());
            teacherbaseManagerBaseTeacherRegularMapper.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 = teacherbaseManagerBaseTeacherMapper.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) {
                    teacherbaseManagerBaseTeacherMapper.updateById(baseTeacher);
                }
                //如果等于空 则新增
                else {
                    //已经不存在的id 删除
                    baseTeacher.setUserId(xjrUser.getId());
                    teacherbaseManagerBaseTeacherMapper.insert(baseTeacher);
                }
            }
            //已经不存在的id 删除
            if (baseTeacherRemoveIds.size() > 0) {
                teacherbaseManagerBaseTeacherMapper.deleteBatchIds(baseTeacherRemoveIds);
            }
        }
        //********************************* BaseTeacher  增删改  结束 *******************************************/

        //********************************* BaseTeacherContact  增删改  开始 *******************************************/
        {
            // 查出所有子级的id
            List<BaseTeacherContact> baseTeacherContactList = teacherbaseManagerBaseTeacherContactMapper.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) {
                    teacherbaseManagerBaseTeacherContactMapper.updateById(baseTeacherContact);
                }
                //如果等于空 则新增
                else {
                    //已经不存在的id 删除
                    baseTeacherContact.setUserId(xjrUser.getId());
                    teacherbaseManagerBaseTeacherContactMapper.insert(baseTeacherContact);
                }
            }
            //已经不存在的id 删除
            if (baseTeacherContactRemoveIds.size() > 0) {
                teacherbaseManagerBaseTeacherContactMapper.deleteBatchIds(baseTeacherContactRemoveIds);
            }
        }
        //********************************* BaseTeacherContact  增删改  结束 *******************************************/

        //********************************* BaseTeacherEducation  增删改  开始 *******************************************/
        {
            // 查出所有子级的id
            List<BaseTeacherEducation> baseTeacherEducationList = teacherbaseManagerBaseTeacherEducationMapper.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) {
                    teacherbaseManagerBaseTeacherEducationMapper.updateById(baseTeacherEducation);
                }
                //如果等于空 则新增
                else {
                    //已经不存在的id 删除
                    baseTeacherEducation.setUserId(xjrUser.getId());
                    teacherbaseManagerBaseTeacherEducationMapper.insert(baseTeacherEducation);
                }
            }
            //已经不存在的id 删除
            if (baseTeacherEducationRemoveIds.size() > 0) {
                teacherbaseManagerBaseTeacherEducationMapper.deleteBatchIds(baseTeacherEducationRemoveIds);
            }
        }
        //********************************* BaseTeacherEducation  增删改  结束 *******************************************/

        //********************************* BaseTeacherEmploy  增删改  开始 *******************************************/
        {
            // 查出所有子级的id
            List<BaseTeacherEmploy> baseTeacherEmployList = teacherbaseManagerBaseTeacherEmployMapper.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) {
                    teacherbaseManagerBaseTeacherEmployMapper.updateById(baseTeacherEmploy);
                }
                //如果等于空 则新增
                else {
                    //已经不存在的id 删除
                    baseTeacherEmploy.setUserId(xjrUser.getId());
                    teacherbaseManagerBaseTeacherEmployMapper.insert(baseTeacherEmploy);
                }
            }
            //已经不存在的id 删除
            if (baseTeacherEmployRemoveIds.size() > 0) {
                teacherbaseManagerBaseTeacherEmployMapper.deleteBatchIds(baseTeacherEmployRemoveIds);
            }
        }
        //********************************* BaseTeacherEmploy  增删改  结束 *******************************************/

        //********************************* BaseTeacherFamily  增删改  开始 *******************************************/
        {
            // 查出所有子级的id
            List<BaseTeacherFamily> baseTeacherFamilyList = teacherbaseManagerBaseTeacherFamilyMapper.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) {
                    teacherbaseManagerBaseTeacherFamilyMapper.updateById(baseTeacherFamily);
                }
                //如果等于空 则新增
                else {
                    //已经不存在的id 删除
                    baseTeacherFamily.setUserId(xjrUser.getId());
                    teacherbaseManagerBaseTeacherFamilyMapper.insert(baseTeacherFamily);
                }
            }
            //已经不存在的id 删除
            if (baseTeacherFamilyRemoveIds.size() > 0) {
                teacherbaseManagerBaseTeacherFamilyMapper.deleteBatchIds(baseTeacherFamilyRemoveIds);
            }
        }
        //********************************* BaseTeacherFamily  增删改  结束 *******************************************/

        //********************************* BaseTeacherFamilyMember  增删改  开始 *******************************************/
        {
            // 查出所有子级的id
            List<BaseTeacherFamilyMember> baseTeacherFamilyMemberList = teacherbaseManagerBaseTeacherFamilyMemberMapper.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) {
                    teacherbaseManagerBaseTeacherFamilyMemberMapper.updateById(baseTeacherFamilyMember);
                }
                //如果等于空 则新增
                else {
                    //已经不存在的id 删除
                    baseTeacherFamilyMember.setUserId(xjrUser.getId());
                    teacherbaseManagerBaseTeacherFamilyMemberMapper.insert(baseTeacherFamilyMember);
                }
            }
            //已经不存在的id 删除
            if (baseTeacherFamilyMemberRemoveIds.size() > 0) {
                teacherbaseManagerBaseTeacherFamilyMemberMapper.deleteBatchIds(baseTeacherFamilyMemberRemoveIds);
            }
        }
        //********************************* BaseTeacherFamilyMember  增删改  结束 *******************************************/

        //********************************* BaseTeacherRegular  增删改  开始 *******************************************/
        {
            // 查出所有子级的id
            List<BaseTeacherRegular> baseTeacherRegularList = teacherbaseManagerBaseTeacherRegularMapper.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) {
                    teacherbaseManagerBaseTeacherRegularMapper.updateById(baseTeacherRegular);
                }
                //如果等于空 则新增
                else {
                    //已经不存在的id 删除
                    baseTeacherRegular.setUserId(xjrUser.getId());
                    teacherbaseManagerBaseTeacherRegularMapper.insert(baseTeacherRegular);
                }
            }
            //已经不存在的id 删除
            if (baseTeacherRegularRemoveIds.size() > 0) {
                teacherbaseManagerBaseTeacherRegularMapper.deleteBatchIds(baseTeacherRegularRemoveIds);
            }
        }
        //********************************* BaseTeacherRegular  增删改  结束 *******************************************/

        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean delete(List<Long> ids) {
        teacherbaseManagerXjrUserMapper.deleteBatchIds(ids);
        teacherbaseManagerBaseTeacherMapper.delete(Wrappers.lambdaQuery(BaseTeacher.class).in(BaseTeacher::getUserId, ids));
        teacherbaseManagerBaseTeacherContactMapper.delete(Wrappers.lambdaQuery(BaseTeacherContact.class).in(BaseTeacherContact::getUserId, ids));
        teacherbaseManagerBaseTeacherEducationMapper.delete(Wrappers.lambdaQuery(BaseTeacherEducation.class).in(BaseTeacherEducation::getUserId, ids));
        teacherbaseManagerBaseTeacherEmployMapper.delete(Wrappers.lambdaQuery(BaseTeacherEmploy.class).in(BaseTeacherEmploy::getUserId, ids));
        teacherbaseManagerBaseTeacherFamilyMapper.delete(Wrappers.lambdaQuery(BaseTeacherFamily.class).in(BaseTeacherFamily::getUserId, ids));
        teacherbaseManagerBaseTeacherFamilyMemberMapper.delete(Wrappers.lambdaQuery(BaseTeacherFamilyMember.class).in(BaseTeacherFamilyMember::getUserId, ids));
        teacherbaseManagerBaseTeacherRegularMapper.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) {
        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::getUserName, x -> x));

        List<BaseTeacher> teacherList = teacherbaseManagerBaseTeacherMapper.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);

        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 = postRelations.stream()
                .collect(Collectors.groupingBy(UserPostRelation::getUserId, Collectors.mapping(UserPostRelation::getPostId, Collectors.toList())));

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

        for (Map<Integer, Object> rowData : excelDataList) {
            String jobCode = rowData.get(0).toString();
            if (userMap.containsKey(jobCode)) {
                User user = userMap.get(jobCode);
                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()));
                updateTeacherList.add(teacher);

                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());
            teacherbaseManagerBaseTeacherMapper.insert(teacher);

            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) {
                teacherbaseManagerBaseTeacherMapper.updateById(teacher);
            }
        }

        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 = teacherbaseManagerBaseTeacherMapper.selectList(Wrappers.lambdaQuery(BaseTeacher.class)
                .eq(BaseTeacher::getJobState, jobState));
        for (BaseTeacher baseTeacher : baseTeacherList) {
            baseTeacher.setIsNormal(isNormal);
            teacherbaseManagerBaseTeacherMapper.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");
                baseTeacherMapper.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);
    }
}