教师导入增加必填字段

src/main/java/com/xjrsoft/module/teacher/service/ITeacherbaseManagerService.java

@@ -5,6 +5,7 @@ import com.xjrsoft.module.teacher.dto.AddXjrUserDto;
 import com.xjrsoft.module.teacher.dto.UpdateXjrUserDto;
 import com.xjrsoft.module.teacher.entity.XjrUser;
 
+import java.text.ParseException;
 import java.util.List;
 import java.util.Map;
 
@@ -40,7 +41,7 @@ public interface ITeacherbaseManagerService extends MPJBaseService<XjrUser> {
      */
     Boolean delete(List<Long> ids);
 
-    Boolean importData(List<Map<Integer, Object>> excelDataList);
+    Boolean importData(List<Map<Integer, Object>> excelDataList) throws ParseException;
 
     void changeIsNormal(String jobState, Integer isNormal);
 

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

@@ -6,6 +6,7 @@ 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.alibaba.fastjson.JSONArray;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.StringPool;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
@@ -75,6 +76,8 @@ import org.camunda.bpm.engine.history.HistoricProcessInstance;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -95,13 +98,13 @@ import java.util.stream.Collectors;
 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 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;
@@ -157,31 +160,31 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
                 }
             }
 
-            teacherbaseManagerBaseTeacherMapper.insert(baseTeacher);
+            teacherMapper.insert(baseTeacher);
         }
         for (BaseTeacherContact baseTeacherContact : xjrUser.getBaseTeacherContactList()) {
             baseTeacherContact.setUserId(xjrUser.getId());
-            teacherbaseManagerBaseTeacherContactMapper.insert(baseTeacherContact);
+            teacherContactMapper.insert(baseTeacherContact);
         }
         for (BaseTeacherEducation baseTeacherEducation : xjrUser.getBaseTeacherEducationList()) {
             baseTeacherEducation.setUserId(xjrUser.getId());
-            teacherbaseManagerBaseTeacherEducationMapper.insert(baseTeacherEducation);
+            teacherEducationMapper.insert(baseTeacherEducation);
         }
         for (BaseTeacherEmploy baseTeacherEmploy : xjrUser.getBaseTeacherEmployList()) {
             baseTeacherEmploy.setUserId(xjrUser.getId());
-            teacherbaseManagerBaseTeacherEmployMapper.insert(baseTeacherEmploy);
+            teacherEmployMapper.insert(baseTeacherEmploy);
         }
         for (BaseTeacherFamily baseTeacherFamily : xjrUser.getBaseTeacherFamilyList()) {
             baseTeacherFamily.setUserId(xjrUser.getId());
-            teacherbaseManagerBaseTeacherFamilyMapper.insert(baseTeacherFamily);
+            baseTeacherFamilyMapper.insert(baseTeacherFamily);
         }
         for (BaseTeacherFamilyMember baseTeacherFamilyMember : xjrUser.getBaseTeacherFamilyMemberList()) {
             baseTeacherFamilyMember.setUserId(xjrUser.getId());
-            teacherbaseManagerBaseTeacherFamilyMemberMapper.insert(baseTeacherFamilyMember);
+            familyMemberMapper.insert(baseTeacherFamilyMember);
         }
         for (BaseTeacherRegular baseTeacherRegular : xjrUser.getBaseTeacherRegularList()) {
             baseTeacherRegular.setUserId(xjrUser.getId());
-            teacherbaseManagerBaseTeacherRegularMapper.insert(baseTeacherRegular);
+            teacherRegularMapper.insert(baseTeacherRegular);
         }
 
         List<UserDeptRelation> userDeptRelationList = new ArrayList<>();
@@ -345,7 +348,7 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
         //********************************* BaseTeacher  增删改  开始 *******************************************/
         {
             // 查出所有子级的id
-            List<BaseTeacher> baseTeacherList = teacherbaseManagerBaseTeacherMapper.selectList(Wrappers.lambdaQuery(BaseTeacher.class).eq(BaseTeacher::getUserId, xjrUser.getId()).select(BaseTeacher::getId));
+            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());
@@ -373,18 +376,18 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
 
                 //如果不等于空则修改
                 if (baseTeacher.getId() != null) {
-                    teacherbaseManagerBaseTeacherMapper.updateById(baseTeacher);
+                    teacherMapper.updateById(baseTeacher);
                 }
                 //如果等于空 则新增
                 else {
                     //已经不存在的id 删除
                     baseTeacher.setUserId(xjrUser.getId());
-                    teacherbaseManagerBaseTeacherMapper.insert(baseTeacher);
+                    teacherMapper.insert(baseTeacher);
                 }
             }
             //已经不存在的id 删除
             if (baseTeacherRemoveIds.size() > 0) {
-                teacherbaseManagerBaseTeacherMapper.deleteBatchIds(baseTeacherRemoveIds);
+                teacherMapper.deleteBatchIds(baseTeacherRemoveIds);
             }
         }
         //********************************* BaseTeacher  增删改  结束 *******************************************/
@@ -392,7 +395,7 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
         //********************************* BaseTeacherContact  增删改  开始 *******************************************/
         {
             // 查出所有子级的id
-            List<BaseTeacherContact> baseTeacherContactList = teacherbaseManagerBaseTeacherContactMapper.selectList(Wrappers.lambdaQuery(BaseTeacherContact.class).eq(BaseTeacherContact::getUserId, xjrUser.getId()).select(BaseTeacherContact::getId));
+            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());
@@ -402,18 +405,18 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
             for (BaseTeacherContact baseTeacherContact : xjrUser.getBaseTeacherContactList()) {
                 //如果不等于空则修改
                 if (baseTeacherContact.getId() != null) {
-                    teacherbaseManagerBaseTeacherContactMapper.updateById(baseTeacherContact);
+                    teacherContactMapper.updateById(baseTeacherContact);
                 }
                 //如果等于空 则新增
                 else {
                     //已经不存在的id 删除
                     baseTeacherContact.setUserId(xjrUser.getId());
-                    teacherbaseManagerBaseTeacherContactMapper.insert(baseTeacherContact);
+                    teacherContactMapper.insert(baseTeacherContact);
                 }
             }
             //已经不存在的id 删除
             if (baseTeacherContactRemoveIds.size() > 0) {
-                teacherbaseManagerBaseTeacherContactMapper.deleteBatchIds(baseTeacherContactRemoveIds);
+                teacherContactMapper.deleteBatchIds(baseTeacherContactRemoveIds);
             }
         }
         //********************************* BaseTeacherContact  增删改  结束 *******************************************/
@@ -421,7 +424,7 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
         //********************************* BaseTeacherEducation  增删改  开始 *******************************************/
         {
             // 查出所有子级的id
-            List<BaseTeacherEducation> baseTeacherEducationList = teacherbaseManagerBaseTeacherEducationMapper.selectList(Wrappers.lambdaQuery(BaseTeacherEducation.class).eq(BaseTeacherEducation::getUserId, xjrUser.getId()).select(BaseTeacherEducation::getId));
+            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());
@@ -431,18 +434,18 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
             for (BaseTeacherEducation baseTeacherEducation : xjrUser.getBaseTeacherEducationList()) {
                 //如果不等于空则修改
                 if (baseTeacherEducation.getId() != null) {
-                    teacherbaseManagerBaseTeacherEducationMapper.updateById(baseTeacherEducation);
+                    teacherEducationMapper.updateById(baseTeacherEducation);
                 }
                 //如果等于空 则新增
                 else {
                     //已经不存在的id 删除
                     baseTeacherEducation.setUserId(xjrUser.getId());
-                    teacherbaseManagerBaseTeacherEducationMapper.insert(baseTeacherEducation);
+                    teacherEducationMapper.insert(baseTeacherEducation);
                 }
             }
             //已经不存在的id 删除
             if (baseTeacherEducationRemoveIds.size() > 0) {
-                teacherbaseManagerBaseTeacherEducationMapper.deleteBatchIds(baseTeacherEducationRemoveIds);
+                teacherEducationMapper.deleteBatchIds(baseTeacherEducationRemoveIds);
             }
         }
         //********************************* BaseTeacherEducation  增删改  结束 *******************************************/
@@ -450,7 +453,7 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
         //********************************* BaseTeacherEmploy  增删改  开始 *******************************************/
         {
             // 查出所有子级的id
-            List<BaseTeacherEmploy> baseTeacherEmployList = teacherbaseManagerBaseTeacherEmployMapper.selectList(Wrappers.lambdaQuery(BaseTeacherEmploy.class).eq(BaseTeacherEmploy::getUserId, xjrUser.getId()).select(BaseTeacherEmploy::getId));
+            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());
@@ -460,18 +463,18 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
             for (BaseTeacherEmploy baseTeacherEmploy : xjrUser.getBaseTeacherEmployList()) {
                 //如果不等于空则修改
                 if (baseTeacherEmploy.getId() != null) {
-                    teacherbaseManagerBaseTeacherEmployMapper.updateById(baseTeacherEmploy);
+                    teacherEmployMapper.updateById(baseTeacherEmploy);
                 }
                 //如果等于空 则新增
                 else {
                     //已经不存在的id 删除
                     baseTeacherEmploy.setUserId(xjrUser.getId());
-                    teacherbaseManagerBaseTeacherEmployMapper.insert(baseTeacherEmploy);
+                    teacherEmployMapper.insert(baseTeacherEmploy);
                 }
             }
             //已经不存在的id 删除
             if (baseTeacherEmployRemoveIds.size() > 0) {
-                teacherbaseManagerBaseTeacherEmployMapper.deleteBatchIds(baseTeacherEmployRemoveIds);
+                teacherEmployMapper.deleteBatchIds(baseTeacherEmployRemoveIds);
             }
         }
         //********************************* BaseTeacherEmploy  增删改  结束 *******************************************/
@@ -479,7 +482,7 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
         //********************************* BaseTeacherFamily  增删改  开始 *******************************************/
         {
             // 查出所有子级的id
-            List<BaseTeacherFamily> baseTeacherFamilyList = teacherbaseManagerBaseTeacherFamilyMapper.selectList(Wrappers.lambdaQuery(BaseTeacherFamily.class).eq(BaseTeacherFamily::getUserId, xjrUser.getId()).select(BaseTeacherFamily::getId));
+            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());
@@ -489,18 +492,18 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
             for (BaseTeacherFamily baseTeacherFamily : xjrUser.getBaseTeacherFamilyList()) {
                 //如果不等于空则修改
                 if (baseTeacherFamily.getId() != null) {
-                    teacherbaseManagerBaseTeacherFamilyMapper.updateById(baseTeacherFamily);
+                    baseTeacherFamilyMapper.updateById(baseTeacherFamily);
                 }
                 //如果等于空 则新增
                 else {
                     //已经不存在的id 删除
                     baseTeacherFamily.setUserId(xjrUser.getId());
-                    teacherbaseManagerBaseTeacherFamilyMapper.insert(baseTeacherFamily);
+                    baseTeacherFamilyMapper.insert(baseTeacherFamily);
                 }
             }
             //已经不存在的id 删除
             if (baseTeacherFamilyRemoveIds.size() > 0) {
-                teacherbaseManagerBaseTeacherFamilyMapper.deleteBatchIds(baseTeacherFamilyRemoveIds);
+                baseTeacherFamilyMapper.deleteBatchIds(baseTeacherFamilyRemoveIds);
             }
         }
         //********************************* BaseTeacherFamily  增删改  结束 *******************************************/
@@ -508,7 +511,7 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
         //********************************* BaseTeacherFamilyMember  增删改  开始 *******************************************/
         {
             // 查出所有子级的id
-            List<BaseTeacherFamilyMember> baseTeacherFamilyMemberList = teacherbaseManagerBaseTeacherFamilyMemberMapper.selectList(Wrappers.lambdaQuery(BaseTeacherFamilyMember.class).eq(BaseTeacherFamilyMember::getUserId, xjrUser.getId()).select(BaseTeacherFamilyMember::getId));
+            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());
@@ -518,18 +521,18 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
             for (BaseTeacherFamilyMember baseTeacherFamilyMember : xjrUser.getBaseTeacherFamilyMemberList()) {
                 //如果不等于空则修改
                 if (baseTeacherFamilyMember.getId() != null) {
-                    teacherbaseManagerBaseTeacherFamilyMemberMapper.updateById(baseTeacherFamilyMember);
+                    familyMemberMapper.updateById(baseTeacherFamilyMember);
                 }
                 //如果等于空 则新增
                 else {
                     //已经不存在的id 删除
                     baseTeacherFamilyMember.setUserId(xjrUser.getId());
-                    teacherbaseManagerBaseTeacherFamilyMemberMapper.insert(baseTeacherFamilyMember);
+                    familyMemberMapper.insert(baseTeacherFamilyMember);
                 }
             }
             //已经不存在的id 删除
             if (baseTeacherFamilyMemberRemoveIds.size() > 0) {
-                teacherbaseManagerBaseTeacherFamilyMemberMapper.deleteBatchIds(baseTeacherFamilyMemberRemoveIds);
+                familyMemberMapper.deleteBatchIds(baseTeacherFamilyMemberRemoveIds);
             }
         }
         //********************************* BaseTeacherFamilyMember  增删改  结束 *******************************************/
@@ -537,7 +540,7 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
         //********************************* BaseTeacherRegular  增删改  开始 *******************************************/
         {
             // 查出所有子级的id
-            List<BaseTeacherRegular> baseTeacherRegularList = teacherbaseManagerBaseTeacherRegularMapper.selectList(Wrappers.lambdaQuery(BaseTeacherRegular.class).eq(BaseTeacherRegular::getUserId, xjrUser.getId()).select(BaseTeacherRegular::getId));
+            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());
@@ -547,18 +550,18 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
             for (BaseTeacherRegular baseTeacherRegular : xjrUser.getBaseTeacherRegularList()) {
                 //如果不等于空则修改
                 if (baseTeacherRegular.getId() != null) {
-                    teacherbaseManagerBaseTeacherRegularMapper.updateById(baseTeacherRegular);
+                    teacherRegularMapper.updateById(baseTeacherRegular);
                 }
                 //如果等于空 则新增
                 else {
                     //已经不存在的id 删除
                     baseTeacherRegular.setUserId(xjrUser.getId());
-                    teacherbaseManagerBaseTeacherRegularMapper.insert(baseTeacherRegular);
+                    teacherRegularMapper.insert(baseTeacherRegular);
                 }
             }
             //已经不存在的id 删除
             if (baseTeacherRegularRemoveIds.size() > 0) {
-                teacherbaseManagerBaseTeacherRegularMapper.deleteBatchIds(baseTeacherRegularRemoveIds);
+                teacherRegularMapper.deleteBatchIds(baseTeacherRegularRemoveIds);
             }
         }
         //********************************* BaseTeacherRegular  增删改  结束 *******************************************/
@@ -570,13 +573,13 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
     @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));
+        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;
     }
@@ -591,16 +594,16 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
      */
     @Override
     @Transactional(rollbackFor = Exception.class)
-    public Boolean importData(List<Map<Integer, Object>> excelDataList) {
+    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::getUserName, x -> x));
+        Map<String, User> userMap = userList.stream().collect(Collectors.toMap(User::getCredentialNumber, x -> x));
 
-        List<BaseTeacher> teacherList = teacherbaseManagerBaseTeacherMapper.selectJoinList(BaseTeacher.class,
+        List<BaseTeacher> teacherList = teacherMapper.selectJoinList(BaseTeacher.class,
                 new MPJLambdaWrapper<BaseTeacher>()
                         .select(BaseTeacher::getId)
                         .select(BaseTeacher.class, x -> VoToColumnUtil.fieldsToColumns(BaseTeacher.class).contains(x.getProperty()))
@@ -611,6 +614,8 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
         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()
@@ -648,18 +653,30 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
                         .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())));
+        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 jobCode = rowData.get(0).toString();
-            if (userMap.containsKey(jobCode)) {
-                User user = userMap.get(jobCode);
+            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()));
@@ -669,8 +686,16 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
 
                 BaseTeacher teacher = teacherMap.get(user.getId());
                 teacher.setEmployType(dictionaryMap.get(rowData.get(6).toString()));
+                teacher.setJobState(dictionaryMap.get(rowData.get(9).toString()));
+                teacher.setJoinTime(sdf.parse(rowData.get(10).toString()));
                 updateTeacherList.add(teacher);
 
+                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();
@@ -705,7 +730,20 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
             teacher.setEmployType(dictionaryMap.get(rowData.get(6).toString()));
             teacher.setUserId(user.getId());
             teacher.setCreateDate(LocalDateTime.now());
-            teacherbaseManagerBaseTeacherMapper.insert(teacher);
+            teacher.setJobState(dictionaryMap.get(rowData.get(9).toString()));
+            teacher.setJoinTime(sdf.parse(rowData.get(10).toString()));
+            teacherMapper.insert(teacher);
+
+            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()));
@@ -736,7 +774,13 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
         }
         if (!updateTeacherList.isEmpty()) {
             for (BaseTeacher teacher : updateTeacherList) {
-                teacherbaseManagerBaseTeacherMapper.updateById(teacher);
+                teacherMapper.updateById(teacher);
+            }
+        }
+
+        if(!updateBaseTeacherRegularList.isEmpty()){
+            for (BaseTeacherRegular teacherRegular : updateBaseTeacherRegularList) {
+                teacherRegularMapper.updateById(teacherRegular);
             }
         }
 
@@ -758,11 +802,11 @@ public class TeacherbaseManagerServiceImpl extends MPJBaseServiceImpl<XjrUserMap
     @Override
     @Transactional(rollbackFor = Exception.class)
     public void changeIsNormal(String jobState, Integer isNormal) {
-        List<BaseTeacher> baseTeacherList = teacherbaseManagerBaseTeacherMapper.selectList(Wrappers.lambdaQuery(BaseTeacher.class)
+        List<BaseTeacher> baseTeacherList = teacherMapper.selectList(Wrappers.lambdaQuery(BaseTeacher.class)
                 .eq(BaseTeacher::getJobState, jobState));
         for (BaseTeacher baseTeacher : baseTeacherList) {
             baseTeacher.setIsNormal(isNormal);
-            teacherbaseManagerBaseTeacherMapper.updateById(baseTeacher);
+            teacherMapper.updateById(baseTeacher);
         }
 
     }