批量解绑、修改密码、修改有效期、移除、转班

scommons/src/main/java/com/xhkjedu/utils/N_Utils.java

         int a=nums[0];int b=nums[1];int i=0;
         int temp;
         if(a<b){
-            temp=a;
-            a=b;
-            b=temp;
-            temp=a%b;
-            while(temp!=0){
-                a=b;
-                b=temp;
-                temp=a%b;
+            temp = a;
+            a = b;
+            b = temp;
+            temp = a % b;
+            while (temp != 0) {
+                a = b;
+                b = temp;
+                temp = a % b;
             }
-            nums[i+1]=b;
+            nums[i + 1] = b;
         }
-        return nums[nums.length-1];
+        return nums[nums.length - 1];
+    }
+
+    /**
+     * 密码加密
+     *
+     * @param [pwd]
+     * @return java.lang.String
+     * @author ywx
+     * @date 2022/5/20 10:18
+     */
+    public static String getMD5Pwd(String pwd) {
+        if (isEmpty(pwd)) return null;
+        MD5 md5 = new MD5();
+        return md5.getMD5ofStr(md5.getMD5ofStr(md5.getMD5ofStr(pwd)));
     }
 
 }

suser/src/main/java/com/xhkjedu/suser/controller/gradeclass/ClassStudentController.java

         classStudentService.delTgStu(loginname);
         return new ResultVo(0, "删除学生所有提高班和所在提高班直播课成功");
     }
+
+    @PostMapping("/batch_remove_bind")
+    public ResultVo batchMoveBind(@RequestBody List<Integer> studentids) {
+        if (N_Utils.isListEmpty(studentids)) return new ResultVo(1, "学生不能为空");
+        classStudentService.batchRemoveBind(studentids);
+        return new ResultVo(0, "批量解除mac绑定成功");
+    }
+
+    @PostMapping("/batch_delete")
+    public ResultVo batchDelete(@RequestBody List<TClassStudent> students) {
+        if (N_Utils.isListEmpty(students)) return new ResultVo(1, "学生不能为空");
+        classStudentService.batchDelete(students);
+        return new ResultVo(0, "批量移除成功");
+    }
+
+    @PostMapping("/batch_move_class")
+    public ResultVo batchMoveClass(@RequestBody List<TClassStudent> students) {
+        if (N_Utils.isListEmpty(students)) return new ResultVo(1, "学生不能为空");
+        classStudentService.batchMoveClass(students);
+        return new ResultVo(0, "批量转班成功");
+    }
 }

suser/src/main/java/com/xhkjedu/suser/controller/system/UserController.java

         userService.unLock(userid);
         return new ResultVo(0, "解锁成功");
     }
+
+    /**
+     * 批量修改密码
+     *
+     * @param [map]
+     * @return com.xhkjedu.vo.ResultVo
+     * @author ywx
+     * @date 2022/5/20 11:18
+     */
+    @PostMapping("/batch_update_pwd2")
+    public ResultVo batchUpdatePwd2(@RequestBody Map map) {
+        String loginpwd = map.get("loginpwd").toString();
+        N_Utils.validation(new Object[]{loginpwd, "密码", 2});
+        List<Integer> userids = (List<Integer>) map.get("userids");
+        if (N_Utils.isListEmpty(userids)) return new ResultVo(1, "用户id集合不能为空");
+        userService.batchUpdatePwd2(loginpwd, userids);
+        return new ResultVo(0, "批量修改密码成功");
+    }
+
+    /**
+     * 批量修有效期
+     *
+     * @param [map]
+     * @return com.xhkjedu.vo.ResultVo
+     * @author ywx
+     * @date 2022/5/20 11:23
+     */
+    @PostMapping("/batch_update_time")
+    public ResultVo batchUpdateTime(@RequestBody Map map) {
+        String usertime = map.get("usertime").toString();
+        N_Utils.validation(new Object[]{usertime, "有效期", 2});
+        List<Integer> userids = (List<Integer>) map.get("userids");
+        if (N_Utils.isListEmpty(userids)) return new ResultVo(1, "用户id集合不能为空");
+        userService.batchUpdateTime(usertime, userids);
+        return new ResultVo(0, "批量修有效期成功");
+    }
 }

suser/src/main/java/com/xhkjedu/suser/mapper/gradeclass/ClassMapper.java

 
     //班级下教师，以及教师科目
     List<Map> listTeacherSubject(Integer classid);
+
+    //获取班级信息
+    List<ClassVo> listByIds(@Param("classids") List<Integer> classids);
 }

suser/src/main/java/com/xhkjedu/suser/mapper/gradeclass/ClassStudentMapper.java

 import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
+import java.util.Map;
 
 public interface ClassStudentMapper extends TkMapper<TClassStudent> {
     //班级学生列表
 
     //获取学生除某个班外的行政班和提高班ids
     String getClassIdsByCidAndSid(@Param("classid") Integer classid, @Param("studentid") Integer studentid);
+
+    //获取学生除某个班外的行政班和提高班ids
+    List<Map> listClassIdsByCidAndSid(@Param("students") List<TClassStudent> students);
+
+    //批量删除班级、分组对应学生
+    void deleteBatchStudent2(@Param("students") List<TClassStudent> students);
 }

suser/src/main/java/com/xhkjedu/suser/mapper/liveplay/CourseMapper.java

 
     //含某些班的直播课
     List<Map> listCourse(@Param("classids") String classids);
+
+    //指定班级的直播课
+    List<Map> listXzCourse2(@Param("classids") List<Integer> classids);
 }

suser/src/main/java/com/xhkjedu/suser/mapper/system/UserMapper.java

 
     //绑定手机号用户列表
     List<Map> listBindPhoneUser();
+
+    //批量解绑
+    void batchRemoveBind(@Param("userids") List<Integer> userids);
+
+    //批量修改密码
+    void batchUpdatePwd2(@Param("loginpwd") String loginpwd, @Param("userids") List<Integer> userids);
+
+    //批量修有效期
+    void batchUpdateTime(@Param("usertime") String usertime, @Param("userids") List<Integer> userids);
 }

suser/src/main/java/com/xhkjedu/suser/service/gradeclass/ClassStudentService.java

 import com.xhkjedu.suser.mapper.gradeclass.GroupStudentMapper;
 import com.xhkjedu.suser.mapper.gradeclass.SchoolMapper;
 import com.xhkjedu.suser.mapper.liveplay.CourseMapper;
+import com.xhkjedu.suser.mapper.system.UserMapper;
 import com.xhkjedu.suser.model.gradeclass.TClassStudent;
 import com.xhkjedu.suser.model.gradeclass.TGroupStudent;
 import com.xhkjedu.suser.model.system.TUser;
-import com.xhkjedu.suser.service.system.UserService;
 import com.xhkjedu.suser.utils.PoiUtils;
 import com.xhkjedu.suser.vo.gradeclass.ClassStudentVo;
 import com.xhkjedu.suser.vo.gradeclass.ClassVo;
     @Resource
     private ClassStudentMapper classStudentMapper;
     @Resource
-    private UserService userService;
+    private UserMapper userMapper;
     @Resource
     private ClassMapper classMapper;
     @Resource
             List<Integer> changeCourseidList = new ArrayList<>();//用户更新直播课中学生数量
             List<Map> courses = courseMapper.listXzCourse(classid);
             for (TClassStudent student : students) {
-                //save(student);
                 Integer studentid = student.getStudentid();
                 //全体分组
                 ImportStudentVo stu = getNumById(classid, studentid, year);
             Integer schoolid = classVo.getSchoolid();
             Integer createid = classVo.getCreateid();
             Integer groupid = classVo.getGroupid();
-            Integer year = classVo.getYear();
             List<Integer> studentIds = classStudentMapper.listStudentIdByClassId(classid);//班级原有学生
             for (Integer studentid : newStuIds) {
                 if (!N_Utils.numInList(studentid, studentIds)) {//新添加的学生
             Map<String, List<Map>> courseMap = new HashMap();//班级直播课
             for (Integer studentId : studentIds) {
                 if (!N_Utils.numInList(studentId, newStuIds)) {//删除的学生
-                    //deleteById(classid, studentId);
                     //把这个学生从此行政班、提高班关联的所有直播班移除
                     delStudentIdList.add(studentId);
                     String classids = classStudentMapper.getClassIdsByCidAndSid(classid, studentId);//获取学生除某个班外的行政班和提高班ids
     public void save(TClassStudent model) throws Exception {
         try {
             model.setCreatetime(N_Utils.getSecondTimestamp());
+            Integer schoolid = model.getSchoolid();
             if (!N_Utils.isEmpty(model.getStudentno())) {
                 String headpic = model.getHeadpic();
-                TUser user = userService.getObjByLoginName(model.getStudentno());
+                TUser user = userMapper.getObjByLoginName(model.getStudentno());
                 if (user == null) {//学生信息在用户表不存在，添加学生信息
-                    user = new TUser();
-                    user.setUsertype(2);
-                    user.setUsername(model.getStudentname());
-                    user.setLoginname(model.getStudentno());
-                    user.setLoginpwd("123456");
-                    user.setUsersex(model.getUsersex());
-                    user.setStudentno(model.getStudentno());
-                    user.setCreateid(model.getCreateid());
-                    user.setSchoolid(model.getSchoolid());
-                    user.setUsertime(model.getUsertime());
-                    user.setHeadpic(headpic);
-                    user.setUserphone(model.getUserphone());
-                    ResultVo vo = userService.save(user);
-                    if (vo.getCode() != 0) throw new Exception(vo.getMsg());
-                    user.setUserid((Integer) vo.getObj());
+                    user = saveUser(model);//保存用户信息
                 } else if (user.getUsertype() != 2) {
                     throw new Exception("禁止添加非学生账号");
-                } else if (!model.getSchoolid().equals(user.getSchoolid())) {
+                } else if (!schoolid.equals(user.getSchoolid())) {
                     throw new Exception("禁止添加非本校学生账号");
                 } else if (N_Utils.isNotEmpty(headpic) || 1 != user.getUserstate()) {
                     TUser stu = new TUser();
                     Integer userid = user.getUserid();
                     stu.setUserid(userid);
                     if (N_Utils.isNotEmpty(headpic)) {
-                        TUser u = userService.getUserTypeAndHeadTime(userid);//获取用户类型和修改头像时间
+                        TUser u = userMapper.getUserTypeAndHeadTime(userid);//获取用户类型和修改头像时间
                         if (u.getHeadtime() == 0) {
                             throw new Exception("6个月内只能修改一次");
                         } else {
                     if (1 != user.getUserstate()) {//已删除用户改为正常用户
                         stu.setUserstate(1);
                     }
-                    userService.updateByPrimaryKeySelective(stu);
+                    userMapper.updateByPrimaryKeySelective(stu);
                 }
 
                 model.setStudentid(user.getUserid());
                     groupStudent.setGroupid(model.getGroupid());
                     groupStudent.setStudentid(model.getStudentid());
                     groupStudent.setCreateid(model.getCreateid());
-                    groupStudent.setSchoolid(model.getSchoolid());
+                    groupStudent.setSchoolid(schoolid);
                     addGroupStudentList.add(groupStudent);
                 }
                 List<Integer> changeCourseidList = new ArrayList<>();//用户更新直播课中学生数量
         }
     }
 
+    /**
+     * 保存用户信息
+     *
+     * @param [model]
+     * @return com.xhkjedu.suser.model.system.TUser
+     * @author ywx
+     * @date 2022/5/20 10:22
+     */
+    private TUser saveUser(TClassStudent model) throws Exception {
+        Integer schoolid = model.getSchoolid();
+        TUser user = new TUser();
+        user.setUsertype(2);
+        user.setUsername(model.getStudentname());
+        user.setLoginname(model.getStudentno());
+        user.setLoginpwd(N_Utils.getMD5Pwd("123456"));
+        user.setUsersex(model.getUsersex());
+        user.setStudentno(model.getStudentno());
+        user.setCreateid(model.getCreateid());
+        user.setSchoolid(schoolid);
+        user.setUsertime(model.getUsertime());
+        user.setHeadpic(model.getHeadpic());
+        user.setUserphone(model.getUserphone());
+        Integer usernum = schoolMapper.getUserNumById(schoolid);
+        if (usernum != null) {
+            Integer usernum2 = userMapper.getUserNumBySchoolId(schoolid);
+            usernum2 = usernum2 + 1;//学校账号数量+本次添加的人
+            if (usernum.compareTo(usernum2) == -1) {
+                throw new Exception("账号数量已超限，请联系管理员");
+            }
+        }
+        user.setUserstate(1);
+        user.setCreatetime(N_Utils.getSecondTimestamp());
+        Integer bindphoned = 0;
+        String userphone = user.getUserphone();
+        if (N_Utils.isNotEmpty(userphone)) {
+            //获取手机号绑定的其他用户数量
+            Integer num = userMapper.getNumByUserPhone(0, userphone);
+            if (num != 0) {//手机号被其他账号绑定，不保存返回提示信息
+                throw new Exception("手机号【" + userphone + "】已被绑定");
+            } else {//手机号未被其他账号绑定，设置已绑定手机号
+                bindphoned = 1;
+            }
+        }
+        user.setBindphoned(bindphoned);
+        if ("NaN-aN-aN".equals(user.getUsertime())) {//有效期异常值置空
+            user.setUsertime(null);
+        }
+        user.setBindsecret(0);
+        user.setUserlock(0);
+        userMapper.insertUseGeneratedKeys(user);
+        user.setUserid(user.getId());
+        return user;
+    }
+
     //删除
     @Transactional(rollbackFor = Exception.class)
     public void deleteById(Integer classid, Integer studentid) {
 
     //修改
     public ResultVo update(TClassStudent model) {
-        TUser u = userService.getObjByLoginName(model.getStudentno());
+        TUser u = userMapper.getObjByLoginName(model.getStudentno());
         if (u != null && !model.getStudentid().equals(u.getUserid())) {
             return new ResultVo(1, "该账号已被【" + u.getUsername() + "】占用");
         }
         user.setUserphone(model.getUserphone());
         user.setUsertime(model.getUsertime());
         user.setHeadpic(model.getHeadpic());
-        ResultVo vo = userService.update(user);
-        if (vo.getCode() != 0) return vo;
+        Integer bindphoned = 0;
+        String userphone = user.getUserphone();
+        if (N_Utils.isEmpty(userphone) || userphone.contains("****")) {//手机号为空或带星号不修改手机号和是否绑定手机号
+            bindphoned = null;
+            user.setUserphone(null);
+        } else if (N_Utils.isNotEmpty(userphone)) {
+            //获取手机号绑定的其他用户数量
+            Integer num = userMapper.getNumByUserPhone(user.getUserid(), userphone);
+            if (num != 0) return new ResultVo(1, "此手机号已被绑定");
+            bindphoned = 1;
+        }
+        user.setBindphoned(bindphoned);
+        if ("NaN-aN-aN".equals(user.getUsertime())) {//有效期异常值置空
+            user.setUsertime(null);
+        }
+        user.setCreatetime(N_Utils.getSecondTimestamp());
+        userMapper.updateByPrimaryKeySelective(user);
         return new ResultVo(0, "修改成功");
     }
 
             }
             Integer usernum = schoolMapper.getUserNumById(schoolid);
             if (usernum != null) {
-                Integer usernum2 = userService.getUserNumBySchoolId(schoolid);
+                Integer usernum2 = userMapper.getUserNumBySchoolId(schoolid);
                 usernum2 = usernum2 + stunum;//学校账号数量+本次添加的人
                 if (usernum.compareTo(usernum2) == -1) {
                     return new ResultVo(1, "账号数量已超限，请联系管理员");
                 }
             }
             map.remove("users");//导入成功的学生信息不返回给前端
-            /*if (!CollectionUtils.isEmpty((List<TUser>)map.get("excelExisted"))) {
-                map.put("code",1);
-                return new ResultVo(0, "导入失败", map);
-            }*/
 
             List<TUser> users = new ArrayList<>();
             List<TClassStudent> classStudents = new ArrayList<>();
             List<TGroupStudent> groupStudents = new ArrayList<>();
-            //List<Integer> delClassidList = new ArrayList<>();//需要删除的班级学生信息
             List<TClassStudent> delStudentList = new ArrayList<>();//要删除的班级学生集合
             List<Integer> changeCourseidList = new ArrayList<>();//用户更新直播课中学生数量
             Map<Integer, List<Map>> courseMap = new HashMap<>();//要添加班级直播
             // 以下学生信息已存在
             List<TUser> usersExisted = new ArrayList<>();
             for (TUser user : students) {
-                TUser u = userService.getObjByLoginName(user.getLoginname());
+                TUser u = userMapper.getObjByLoginName(user.getLoginname());
                 if (null == u) {
                     user.setSchoolid(schoolid);
                     user.setCreateid(createid);
                         Integer classid = user.getClassid();
                         if (!classid.equals(oldclassid) && 2 == u.getUsertype() && schoolid == u.getSchoolid()) {
                             if (1 != u.getUserstate()) {
-                                userService.updateState(u.getUserid(), 1);
+                                userMapper.updateState(u.getUserid(), 1);
                             }
                             //要添加的班级
                             setStudents(classid, schoolid, createid, user.getGroupid(), classStudents, groupStudents, studentid);//处理班级加入学生
 
             //保存用户信息
             if (!CollectionUtils.isEmpty(users)) {
-                userService.batchSave(users);
+                userMapper.insertList(users);
                 for (TUser user : users) {
                     Integer studentid = user.getId();
                     Integer classid = user.getClassid();
 
             List<Integer> classidlist = new ArrayList<>();
             if (N_Utils.isListNotEmpty(delStudentList)) {//要删除的班级学生集合
-                Map<Integer, List<TClassStudent>> slist = delStudentList.stream().collect(Collectors.groupingBy(m -> m.getStudentid()));
-                for (Map.Entry<Integer, List<TClassStudent>> entry : slist.entrySet()) {
-                    List<Integer> delClassidList = delStudentList.stream().map(TClassStudent::getClassid).collect(Collectors.toList());
-                    classStudentMapper.deleteBatchStudent(delClassidList, entry.getKey().toString());//批量移除班级学生
-                    classidlist.addAll(delClassidList);
-                }
+                List<Integer> delClassidList = delStudentList.stream().map(TClassStudent::getClassid).collect(Collectors.toList());
+                classStudentMapper.deleteBatchStudent2(delStudentList);//批量删除班级、分组对应学生
+                classidlist.addAll(delClassidList);
             }
 
             //保存学生关联信息
             // 以下学生信息不存在
             List<TUser> usersNotExisted = new ArrayList<>();
             for (TUser user : students) {
-                TUser u = userService.getObjByLoginName(user.getLoginname());
+                TUser u = userMapper.getObjByLoginName(user.getLoginname());
                 if (null == u) {
                     user.setSchoolid(schoolid);
                     user.setCreateid(createid);
                         usersNotExisted.add(u);
                     } else if (0 == classnum && 2 == u.getUsertype() && schoolid == u.getSchoolid()) {
                         if (1 != u.getUserstate()) {
-                            userService.updateState(u.getUserid(), 1);
+                            userMapper.updateState(u.getUserid(), 1);
                         }
                         setStudents(classid, schoolid, createid, user.getGroupid(), classStudents, groupStudents, studentid);//处理班级加入学生
                         List<Map> courses = listCourseByClassId(courseMap, classid);
      * @Date 2020/9/18 11:56
      **/
     public void removeBind(Integer studentid) {
-        userService.removeBind(studentid);
+        List<Integer> studentids = new ArrayList<>();
+        studentids.add(studentid);
+        userMapper.batchRemoveBind(studentids);//批量解绑
+    }
+
+    /**
+     * 批量解绑
+     *
+     * @param [studentids]
+     * @return void
+     * @author ywx
+     * @date 2022/5/20 13:48
+     */
+    public void batchRemoveBind(List<Integer> studentids) {
+        userMapper.batchRemoveBind(studentids);//批量解绑
     }
 
     /**
         }
         return new ResultVo(0, "取消选课成功");
     }
+
+    /**
+     * 批量移除学生
+     *
+     * @param [students]
+     * @return void
+     * @author ywx
+     * @date 2022/5/20 14:52
+     */
+    @Transactional(rollbackFor = Exception.class)
+    public void batchDelete(List<TClassStudent> students) {
+        try {
+            List<TClassStudent> delStudentList = new ArrayList<>();//要删除的班级学生集合
+            delStudentList.addAll(students);
+            List<Integer> delids = students.stream().map(TClassStudent::getClassid).distinct().collect(Collectors.toList());
+
+            List<Map> classMap = classStudentMapper.listClassIdsByCidAndSid(students);//获取学生除某个班外的行政班和提高班ids
+            Map<Integer, String> studentClassMap = new HashMap<>();//学生除某个班外的行政班和提高班ids集合
+            for (Map map : classMap) {
+                studentClassMap.put((Integer) map.get("studentid"), map.get("classids").toString());
+            }
+            List<Map> courseAll = courseMapper.listXzCourse2(delids);//指定班级的直播课
+            Map<Integer, List<Map>> delCourseMap = courseAll.stream().collect(Collectors.groupingBy(m -> (Integer) m.get("oldclassid")));
+
+            List<Integer> changeCourseidList = new ArrayList<>();//用户更新直播课中学生数量
+            for (TClassStudent student : students) {
+                Integer classid = student.getClassid();
+                Integer studentid = student.getStudentid();
+                //把这个学生从此行政班、提高班关联的所有直播班移除
+                String classids = studentClassMap.get(studentid);//获取学生除某个班外的行政班和提高班ids
+                List<Map> courses = delCourseMap.get(classid);//指定班级的直播课
+                if (courses == null) courses = new ArrayList<>();//null时执行hs1.removeAll(hs2)报错
+                if (N_Utils.isNotEmpty(classids)) {
+                    List<Map> courses2 = courseMapper.listCourse(classids);//某些班的直播课
+                    if (N_Utils.isListNotEmpty(courses2)) {//要排除班级的直播不为空
+                        HashSet hs1 = new HashSet(courses);
+                        HashSet hs2 = new HashSet(courses2);
+                        hs1.removeAll(hs2);//指定班级排除某些班级的直播
+                        courses = new ArrayList<>();
+                        courses.addAll(hs1);
+                    }
+                }
+                handleDelClassCourse2(delStudentList, changeCourseidList, courses, studentid);//处理关联的直播课以及需要删除学生的直播班id
+            }
+
+            List<Integer> delClassidList = delStudentList.stream().map(TClassStudent::getClassid).distinct().collect(Collectors.toList());
+            classStudentMapper.deleteBatchStudent2(delStudentList);//批量删除班级、分组对应学生
+            String numclassids = delClassidList.stream().distinct().map(String::valueOf).collect(Collectors.joining(","));
+            classMapper.updateClassGroupNumByType(numclassids);//批量修改班级、班级分组数量
+            if (N_Utils.isListNotEmpty(changeCourseidList)) {
+                String numcourseids = changeCourseidList.stream().distinct().map(String::valueOf).collect(Collectors.joining(","));
+                courseMapper.updateStuNumBatch(numcourseids);//批量修改课程学生数量
+            }
+        } catch (Exception e) {
+            log.error("批量移除学生出错：" + e.getMessage());
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            throw new MissingParametersException(e.getMessage());
+        }
+    }
+
+    /**
+     * 批量转班
+     *
+     * @param [students]
+     * @return void
+     * @author ywx
+     * @date 2022/5/20 17:07
+     */
+    @Transactional(rollbackFor = Exception.class)
+    public void batchMoveClass(List<TClassStudent> students) {
+        try {
+            List<TClassStudent> delStudentList = new ArrayList<>();//要删除的班级学生集合
+            List<TClassStudent> addClassStudentList = new ArrayList<>();//新增的班级学生集合
+            List<TGroupStudent> addGroupStudentList = new ArrayList<>();//新增的班级分组集合
+            List<Integer> changeCourseidList = new ArrayList<>();//用户更新直播课中学生数量
+
+            List<Integer> classIds = students.stream().map(TClassStudent::getClassid).distinct().collect(Collectors.toList());
+            List<ClassVo> classes = classMapper.listByIds(classIds);//获取新班级信息
+            List<Map> addCourseAll = courseMapper.listXzCourse2(classIds);//指定班级的直播课
+            Map<Integer, List<Map>> addCourseMap = addCourseAll.stream().collect(Collectors.groupingBy(m -> (Integer) m.get("oldclassid")));
+
+            List<TClassStudent> oldStudents = new ArrayList<>();//要转班的班级学生集合
+            for (TClassStudent student : students) {
+                TClassStudent oldStu = new TClassStudent();
+                oldStu.setClassid(student.getOldclassid());
+                oldStu.setStudentid(student.getStudentid());
+                oldStudents.add(oldStu);
+            }
+            List<Map> classMap = classStudentMapper.listClassIdsByCidAndSid(oldStudents);//获取学生除某个班外的行政班和提高班ids
+            Map<Integer, String> studentClassMap = new HashMap<>();//学生除某个班外的行政班和提高班ids集合
+            for (Map map : classMap) {
+                studentClassMap.put((Integer) map.get("studentid"), map.get("classids").toString());
+            }
+            List<Integer> delids = students.stream().map(TClassStudent::getOldclassid).distinct().collect(Collectors.toList());
+            List<Map> courseAll = courseMapper.listXzCourse2(delids);//指定班级的直播课
+            Map<Integer, List<Map>> courseMap = courseAll.stream().collect(Collectors.groupingBy(m -> (Integer) m.get("oldclassid")));
+            Map<String, List<Map>> delCourseMap = new HashMap();//要删除班级直播课
+            for (TClassStudent student : students) {
+                Integer studentid = student.getStudentid();
+                Integer classid = student.getClassid();
+                //把这个学生从此行政班、提高班关联的所有直播班移除
+                String classids = studentClassMap.get(studentid);//获取学生除某个班外的行政班和提高班ids
+                List<Map> courses = courseMap.get(student.getOldclassid());//指定班级的直播课
+                if (courses == null) courses = new ArrayList<>();//null时执行hs1.removeAll(hs2)报错
+                List<Map> courses2;
+                if (N_Utils.isNotEmpty(classids)) {
+                    courses2 = delCourseMap.get(classids);
+                    if (N_Utils.isListEmpty(courses2)) {
+                        courses2 = courseMapper.listCourse(classids);//某些班的直播课
+                        delCourseMap.put(classids, courses2);
+                    }
+                    if (courses2 == null) {//要排除班级的直播为空
+                        courses2 = courses;
+                    } else {//要排除班级的直播不为空
+                        HashSet hs1 = new HashSet(courses);
+                        HashSet hs2 = new HashSet(courses2);
+                        hs1.removeAll(hs2);//指定班级排除某些班级的直播
+                        courses2 = new ArrayList<>();
+                        courses2.addAll(hs1);
+                    }
+                } else {
+                    courses2 = courses;//指定班级的直播课
+                }
+                handleDelClassCourse2(delStudentList, changeCourseidList, courses2, studentid);//处理关联的直播课以及需要删除学生的直播班id
+
+                //学生新添加班级的信息
+                ClassVo classVo = classes.stream().filter(c -> c.getClassid().equals(classid)).findFirst().orElse(null);//获取新班级信息
+                //学生要加入新的班级信息处理
+                moveClassHandleAddGroupStudent(addClassStudentList, addGroupStudentList, classVo, studentid);
+
+                //获取新班级关联直播课关联的班级，并把学生加入
+                courses = addCourseMap.get(classid);
+                handleAddClassCourse(addClassStudentList, addGroupStudentList, changeCourseidList, courses, studentid);
+            }
+
+            List<Integer> delClassidList = delStudentList.stream().map(TClassStudent::getClassid).distinct().collect(Collectors.toList());
+            classStudentMapper.deleteBatchStudent2(delStudentList);//批量删除班级、分组对应学生
+            classStudentMapper.saveBatchClassStudent(addClassStudentList);//批量新增班级学生
+            groupStudentMapper.saveBatchGroupStudent(addGroupStudentList);//批量新增班级分组学生
+
+            //新增学生的班级id集合
+            List<Integer> saveclassids = addClassStudentList.stream().map(TClassStudent::getClassid).distinct().collect(Collectors.toList());
+            delClassidList.addAll(saveclassids);
+
+            String numclassids = delClassidList.stream().distinct().map(String::valueOf).collect(Collectors.joining(","));
+            classMapper.updateClassGroupNumByType(numclassids);//批量修改班级、班级分组数量
+            if (N_Utils.isListNotEmpty(changeCourseidList)) {
+                String numcourseids = changeCourseidList.stream().distinct().map(String::valueOf).collect(Collectors.joining(","));
+                courseMapper.updateStuNumBatch(numcourseids);//批量修改课程学生数量
+            }
+        } catch (Exception e) {
+            log.error("批量转班出错：" + e.getMessage());
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            throw new MissingParametersException(e.getMessage());
+        }
+    }
 }

suser/src/main/java/com/xhkjedu/suser/service/system/UserService.java

     public void updateByPrimaryKeySelective(TUser user) {
         userMapper.updateByPrimaryKeySelective(user);
     }
+
+    /**
+     * 批量修改密码
+     *
+     * @param [loginpwd, userids]
+     * @return void
+     * @author ywx
+     * @date 2022/5/20 11:18
+     */
+    public void batchUpdatePwd2(String loginpwd, List<Integer> userids) {
+        loginpwd = N_Utils.getMD5Pwd(loginpwd);
+        userMapper.batchUpdatePwd2(loginpwd, userids);
+    }
+
+    /**
+     * 批量修改有效期
+     *
+     * @param [usertime, userids]
+     * @return void
+     * @author ywx
+     * @date 2022/5/20 11:22
+     */
+    public void batchUpdateTime(String usertime, List<Integer> userids) {
+        userMapper.batchUpdateTime(usertime, userids);
+    }
 }

suser/src/main/resources/mapper/gradeclass/ClassMapper.xml

         left join t_subject_book sb on tp.lsbid=sb.lsbid
         where ct.classid=#{classid} group by ct.teacherid order by ct.teacherid
     </select>
+    <!--获取班级信息-->
+    <select id="listByIds" resultType="com.xhkjedu.suser.vo.gradeclass.ClassVo">
+        select c.classid,c.classname,c.gradeid,c.classnum,tg.groupid,c.classtype,c.createid,c.schoolid,c.year
+        from t_class c left join t_group tg on c.classid = tg.classid
+        where tg.grouptype=1 and c.classid in
+        <foreach collection="classids" item="classid" index="index" open="(" separator="," close=")">
+            ${classid}
+        </foreach>
+        group by c.classid
+    </select>
 </mapper>

suser/src/main/resources/mapper/gradeclass/ClassStudentMapper.xml

         left join t_class_student cs on c.classid=cs.classid
         where tc.classid=#{classid} and c.classid!=#{classid} and c.classtype in(1,2) and cs.studentid=#{studentid}
     </select>
+    <!--获取学生除某个班外的行政班和提高班id-->
+    <select id="listClassIdsByCidAndSid" resultType="java.util.Map">
+        select group_concat(c.classid)classids,cs.studentid
+        from t_class tc left join t_class c on c.schoolid=tc.schoolid and c.`year`=tc.`year`
+        left join t_class_student cs on c.classid=cs.classid
+        where c.classtype in(1,2) and
+        <foreach collection="students" item="student" index="index" open="(" separator="or" close=")">
+            (tc.classid=${student.classid} and c.classid!=${student.classid} and cs.studentid=${student.studentid})
+        </foreach>
+        group by cs.studentid
+    </select>
+    <!--批量删除班级、分组对应学生-->
+    <delete id="deleteBatchStudent2">
+        delete cs.*,gs.*
+        from t_class_student cs left join t_group g on g.classid=cs.classid
+        left join t_group_student gs on g.groupid = gs.groupid AND gs.studentid=cs.studentid
+        where
+        <foreach collection="students" item="student" separator="or">
+            (cs.classid=${student.classid} and cs.studentid=${student.studentid})
+        </foreach>
+    </delete>
 </mapper>

suser/src/main/resources/mapper/liveplay/CourseMapper.xml

         where c.coursetype=1 and cc.classid=#{classid}
         group by c.courseid
     </select>
+    <!--指定班级的直播课-->
+    <select id="listXzCourse2" resultType="java.util.Map">
+        select c.courseid,c.classid,c.createid,c.schoolid,g.groupid,cc.classid oldclassid
+        from l_course c left join l_course_class cc on cc.courseid=c.courseid
+        left join t_group g on c.classid=g.classid and g.grouptype=1
+        where c.coursetype=1 and cc.classid in
+        <foreach collection="classids" item="classid" index="index" open="(" separator="," close=")">
+            ${classid}
+        </foreach>
+        group by c.courseid,cc.classid
+    </select>
 
     <!--批量更改课程学生数量-->
     <update id="updateStuNumBatch">

suser/src/main/resources/mapper/system/UserMapper.xml

     <select id="listBindPhoneUser" resultType="java.util.Map">
         select loginname,userphone from t_user where userphone!=''
     </select>
+    <!--批量解绑-->
+    <update id="batchRemoveBind">
+        update t_user set bindmac=0,mac=NULL where userid in
+        <foreach collection="userids" item="userid" index="index" open="(" separator="," close=")">
+            ${userid}
+        </foreach>
+    </update>
+    <!--批量修改密码-->
+    <update id="batchUpdatePwd2">
+        update t_user set loginpwd=#{loginpwd} where userid in
+        <foreach collection="userids" item="userid" index="index" open="(" separator="," close=")">
+            ${userid}
+        </foreach>
+    </update>
+    <!--批量修有效期-->
+    <update id="batchUpdateTime">
+        update t_user set usertime=#{usertime} where userid in
+        <foreach collection="userids" item="userid" index="index" open="(" separator="," close=")">
+            ${userid}
+        </foreach>
+    </update>
 </mapper>