教师、学生添加、导入功能完善

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

         Integer classid = tClassStudent.getClassid();
         N_Utils.validation(new Object[]{classid,"班级id",1});
         try {
-            classStudentService.save(tClassStudent);
-            return new ResultVo(0, "保存成功");
+            Integer delStuId = classStudentService.save(tClassStudent);
+            return new ResultVo(0, "保存成功", delStuId);
         } catch (Exception e) {
             return new ResultVo(1,e.getMessage());
         }

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

         userService.batchUpdateTime(usertime, userids);
         return new ResultVo(0, "批量修有效期成功");
     }
+
+    @PostMapping("/activate")
+    public ResultVo activate(@RequestBody TUser user) {
+        Integer userid = user.getUserid();
+        N_Utils.validation(new Object[]{userid, "用户id", 1});
+        userService.updateState(userid, 1);
+        return new ResultVo(0, "激活成功");
+    }
+
+    @PostMapping("/batch_activate")
+    public ResultVo batchActivate(@RequestBody Map map) {
+        List<Integer> userids = (List<Integer>) map.get("userids");
+        if (N_Utils.isListEmpty(userids)) return new ResultVo(1, "用户id集合不能为空");
+        userService.batchActivate(userids);
+        return new ResultVo(0, "批量激活成功");
+    }
 }

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

      * @Author ywx
      * @Date 2020/6/2 10:44
      **/
-    Integer checkLoginName(@Param("loginname") String loginname);
+    Map checkLoginName(@Param("loginname") String loginname);
 
     /**
      * 根据登录账号获取用户详情
 
     //根据手机号获取用户基本信息
     UserVo getUserByUserPhone(String userphone);
+
+    //批量更新用户状态
+    void batchUpdateUserState(@Param("userstate") Integer userstate, @Param("userids") List<Integer> userids);
 }

suser/src/main/java/com/xhkjedu/suser/model/gradeclass/TClassTeacher.java

     @Transient
     //是否锁定0未锁定1已锁定
     private Integer userlock;
+
+    @Transient
+    //用户状态1正常2删除
+    private Integer userstate;
 }

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

                 //全体分组
                 ImportStudentVo stu = getNumById(classid, studentid, year);
                 if (classVo.getClasstype() == 1 && stu.getXznum() != 0) {
-                    throw new Exception("该学生已在行政班");
+                    throw new Exception("此学生已在行政班");
                 }
                 Integer num = stu.getClassnum();//班级学生数量
                 if (num == 0) {//学生不在该班级
 
     //添加
     @Transactional(rollbackFor = Exception.class)
-    public void save(TClassStudent model) throws Exception {
+    public Integer save(TClassStudent model) throws Exception {
+        Integer delStuId = 0;//已删除学生id
         try {
             model.setCreatetime(N_Utils.getSecondTimestamp());
             Integer schoolid = model.getSchoolid();
                             stu.setHeadtime(N_Utils.getSecondTimestamp());
                         }
                     }
-                    if (1 != user.getUserstate()) {//已删除用户改为正常用户
-                        stu.setUserstate(1);
+                    if (1 != user.getUserstate()) {//已删除用户
+                        delStuId = userid;
                     }
                     userMapper.updateByPrimaryKeySelective(stu);
                 }
             ClassVo classVo = classMapper.getById(model.getClassid());
             ImportStudentVo student = getNumById(model.getClassid(), model.getStudentid(), classVo.getYear());
             if (classVo.getClasstype() == 1 && student.getXznum() != 0) {
-                throw new Exception("该学生已在行政班");
+                throw new Exception("此学生已在行政班");
             }
             Integer num = student.getClassnum();//班级学生数量
             if (num == 0) {//学生不在该班级
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
             throw new MissingParametersException(e.getMessage());
         }
+        return delStuId;
     }
 
     /**
     public ResultVo update(TClassStudent model) {
         TUser u = userMapper.getObjByLoginName(model.getStudentno());
         if (u != null && !model.getStudentid().equals(u.getUserid())) {
-            return new ResultVo(1, "该账号已被【" + u.getUsername() + "】占用");
+            return new ResultVo(1, "此账号已被【" + u.getUsername() + "】占用");
         }
         //修改学生信息
         TUser user = new TUser();
             List<Integer> changeCourseidList = new ArrayList<>();//用户更新直播课中学生数量
             Map<Integer, List<Map>> courseMap = new HashMap<>();//要添加班级直播
             Map<String, List<Map>> delCourseMap = new HashMap<>();//要删除班级直播
-            // 以下学生信息已存在
-            List<TUser> usersExisted = new ArrayList<>();
+            List<TUser> teachersExisted = new ArrayList<>();//已存在教师列表
+            List<TUser> studentsExisted = new ArrayList<>();//已存在学生列表
+            List<TUser> usersExisted = new ArrayList<>();//已存在非本校账号列表
+            List<TUser> delUsers = new ArrayList<>();//已删除学生列表
             for (TUser user : students) {
                 TUser u = userMapper.getObjByLoginName(user.getLoginname());
                 if (null == u) {
                     user.setUserlock(0);
                     users.add(user);
                 } else {
-                    Integer studentid = u.getUserid();
-                    Integer oldclassid = classStudentMapper.getClassIdByStuId(studentid);//获取学生行政班id
-                    if (2 != u.getUsertype() || schoolid != u.getSchoolid()) {//非本校学生信息
+                    if (schoolid != u.getSchoolid()) {
                         usersExisted.add(u);
+                        continue;//非本校账号处理下一条数据
+                    } else if (2 != u.getUsertype()) {
+                        teachersExisted.add(u);
+                        continue;//非本校学生处理下一条数据
                     } else {
+                        Integer studentid = u.getUserid();
+                        Integer oldclassid = classStudentMapper.getClassIdByStuId(studentid);//获取学生行政班id
                         Integer classid = user.getClassid();
                         if (!classid.equals(oldclassid) && 2 == u.getUsertype() && schoolid == u.getSchoolid()) {
                             if (1 != u.getUserstate()) {
-                                userMapper.updateState(u.getUserid(), 1);
+                                delUsers.add(u);
                             }
                             //要添加的班级
                             setStudents(classid, schoolid, createid, user.getGroupid(), classStudents, groupStudents, studentid);//处理班级加入学生
                                 handleDelClassCourse2(delStudentList, changeCourseidList, courses2, studentid);//处理关联的直播课以及需要删除学生的直播班id
                             }
                         } else {//本班学生信息
-                            usersExisted.add(u);
+                            studentsExisted.add(u);
                         }
                     }
                 }
                 String numcourseids = changeCourseidList.stream().distinct().map(String::valueOf).collect(Collectors.joining(","));
                 courseMapper.updateStuNumBatch(numcourseids);//批量修改课程学生数量
             }
+            map.put("teachersExisted", teachersExisted);
+            map.put("studentsExisted", studentsExisted);
             map.put("usersExisted", usersExisted);
-            if (N_Utils.isListNotEmpty(usersExisted)) {
+            map.put("delUsers", delUsers);
+            if (N_Utils.isListNotEmpty(teachersExisted) || N_Utils.isListNotEmpty(studentsExisted)
+                    || N_Utils.isListNotEmpty(usersExisted) || N_Utils.isListNotEmpty(delUsers)) {
                 map.put("code", 1);
             } else {
                 map.put("code", 0);
             Map<Integer, List<Map>> courseMap = new HashMap<>();
             // 以下学生信息不存在
             List<TUser> usersNotExisted = new ArrayList<>();
+            List<TUser> delUsers = new ArrayList<>();//已删除学生列表
             for (TUser user : students) {
                 TUser u = userMapper.getObjByLoginName(user.getLoginname());
                 if (null == u) {
                         usersNotExisted.add(u);
                     } else if (0 == classnum && 2 == u.getUsertype() && schoolid == u.getSchoolid()) {
                         if (1 != u.getUserstate()) {
-                            userMapper.updateState(u.getUserid(), 1);
+                            delUsers.add(u);
                         }
                         setStudents(classid, schoolid, createid, user.getGroupid(), classStudents, groupStudents, studentid);//处理班级加入学生
                         List<Map> courses = listCourseByClassId(courseMap, classid);
                 courseMapper.updateStuNumBatch(numcourseids);//批量修改课程学生数量
             }
             map.put("usersNotExisted", usersNotExisted);
-            if (N_Utils.isListNotEmpty(usersNotExisted)) {
+            map.put("delUsers", delUsers);
+            if (N_Utils.isListNotEmpty(usersNotExisted) || N_Utils.isListNotEmpty(delUsers)) {
                 map.put("code", 1);
             } else {
                 map.put("code", 0);

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

             resultVo = this.checkLoginUser(user,userVo,1);
 
         } else {
-            resultVo = new ResultVo(1, "该账号不存在");
+            resultVo = new ResultVo(1, "此账号不存在");
         }
 
         return getLogResultVo(user, resultVo, loginpwd, request);
             //帐号密码登录
             return new ResultVo(1, "密码错误");
         } else {
-
-            if(userVo.getUsertype() == 999){
+            Integer usertype = userVo.getUsertype();
+            if (usertype == 999) {
                 return new ResultVo(0, "登录成功", userVo);
             }
             //判断学校状态
-            if(userVo.getSchoolstate() != 1){
-                return new ResultVo(1, "该学校已锁定，禁止登录");
+            if (userVo.getSchoolstate() != 1) {
+                return new ResultVo(1, "此学校已锁定，禁止登录");
             }
             //判断用户状态
             if (userVo.getUserstate() != 1) {
-                return new ResultVo(1, "该账户无权访问，请联系老师");
+                if (usertype == 2) {//学生
+                    return new ResultVo(1, "此账号无权访问，请联系老师");
+                } else {
+                    return new ResultVo(1, "此账号无权访问，请联系管理员");
+                }
             }
 
             if(userVo.getUserlock() == 1){
-                return new ResultVo(1, "该账户已被锁定，禁止登录");
+                return new ResultVo(1, "此账号已锁定，禁止登录");
             }
 
             //进行角色判断
-            if (userVo.getUsertype() == 2) {
+            if (usertype == 2) {
                 Integer stuweb = userVo.getStuweb();
                 if (stuweb != null && stuweb != 1) return new ResultVo(1, "学生账号无法登录");
 
                 }
                 //验证用户是否有行政班
                 if (binduser.getXznum() == 0) {
-                    return new ResultVo(1, "该账号未分配班级");
+                    return new ResultVo(1, "此账号未分配班级");
                 }
 
                 //更新学生硬件绑定信息
                 if (userVo.getUsertype() != 1) {
                     resultVo = new ResultVo(1, "禁止非教师账号登录");
                 } else if (userVo.getSchoolstate() != 1) {
-                    resultVo = new ResultVo(1, "用户所在学校暂无权限");
+                    resultVo = new ResultVo(1, "此学校已锁定，禁止登录");
                 } else {
                     if (userVo.getUserstate() != 1) {
-                        resultVo = new ResultVo(1, "该账户无权访问，请联系老师");
+                        resultVo = new ResultVo(1, "此账号无权访问，请联系管理员");
                     } else {
                         resultVo = new ResultVo(0, "登录成功", userVo);
                     }
                 }
             }
         } else {
-            resultVo = new ResultVo(1, "该账号不存在");
+            resultVo = new ResultVo(1, "此账号不存在");
         }
 
         return getLogResultVo(user, resultVo, loginpwd, request);
             //验证学生登录系列问题
             resultVo = checkLoginStudent(user,userVo);
         } else {
-            resultVo = new ResultVo(1, "该账号不存在");
+            resultVo = new ResultVo(1, "此账号不存在");
         }
 
         return getLogResultVo(user, resultVo, loginpwd, request);
             if (userVo.getUsertype() != 2) {
                 return new ResultVo(1, "登录失败，仅允许学生登录");
             } else if (userVo.getXznum() == 0) {
-                return new ResultVo(1, "该账号未分配班级");
+                return new ResultVo(1, "此账号未分配班级");
             } else if (sbindmac == 1 && N_Utils.isNotEmpty(mac)) {
                 if (N_Utils.isNotEmpty(userVo.getMac()) && !mac.equals(userVo.getMac())) {
                     return new ResultVo(1, "登录失败，该账号已与其他设备关联");
 
             resultVo = checkLoginUser(user,userVo,2);
         } else {
-            resultVo = new ResultVo(1, "该账号不存在");
+            resultVo = new ResultVo(1, "此账号不存在");
         }
 
         return getLogResultVo(user, resultVo, user.getMsgcode() + "", request);
             UserVo userVo = (UserVo) result.getObj();
             if (userVo.getUserlock() == 1) {
                 result.setCode(1);
-                result.setMsg("该账户已被锁定，禁止登录");
+                result.setMsg("此账号已锁定，禁止登录");
                 return result;
             }
             String usertime = userVo.getUsertime();
                 String dayBegin = DatesUtil.getDayBegin();
                 if (usertime.compareTo(dayBegin) < 0) {
                     result.setCode(1);
-                    result.setMsg("账号已过有效期，请联系管理员");
+                    if (usertype == 2) {//学生
+                        result.setMsg("账号已过有效期，请联系老师");
+                    } else {
+                        result.setMsg("账号已过有效期，请联系管理员");
+                    }
                     return result;
                 }
             }
             TUser user1 = getObjByLoginName(loginname);
             //登录账号改变并且和别的账号冲突
             if (user1 != null && !user1.getUserid().equals(user.getUserid())) {
-                return new ResultVo(1, "此用户已存在，请更换！");
+                return new ResultVo(1, "此账号已存在，请更换！");
             }
         }
         Integer bindphoned = 0;
      * @Date 2020/6/2 10:44
      **/
     public ResultVo checkLoginName(String loginname) {
-        Integer num = userMapper.checkLoginName(loginname);
-        if (num != 0) {
-            return new ResultVo(1, "此用户已存在，请更换！");
+        Map num = userMapper.checkLoginName(loginname);
+        if (num != null) {
+            return new ResultVo(1, "此账号已存在，请更换", num);
         } else {
             return new ResultVo(0, "检查登录账号是否存在成功");
         }
             map.remove("users");//导入成功的教师信息不返回给前端
             Integer year = schoolMapper.getYearById(schoolid);
 
-            // 以下教师信息已存在·
-            List<TUser> usersExisted = new ArrayList<>();
+            List<TUser> teachersExisted = new ArrayList<>();//已存在教师列表
+            List<TUser> studentsExisted = new ArrayList<>();//已存在学生列表
+            List<TUser> usersExisted = new ArrayList<>();//已存在非本校账号列表
+            List<TUser> delUsers = new ArrayList<>();//已删除教师列表
             List<TClassTeacher> ctlst = new ArrayList<>();//班级教师集合
             List<Integer> teacherIds = new ArrayList<>();//要导入的教师id集合
             List<TUser> teacherList = new ArrayList<>();//要导入的新教师集合
                     user.setUserlock(0);
                     teacherList.add(user);
                 } else {
-                    if (1 != u.getUsertype() || schoolid != u.getSchoolid()) {
+                    if (schoolid != u.getSchoolid()) {
                         usersExisted.add(u);
+                        continue;//非本校账号处理下一条数据
+                    } else if (1 != u.getUsertype()) {
+                        studentsExisted.add(u);
                         continue;//非本校老师处理下一条数据
                     } else {
-                        usersExisted.add(u);
+                        if (u.getUserstate() != 1) {//本校已删除教师
+                            delUsers.add(u);
+                        } else {//本校已存在教师
+                            teachersExisted.add(u);
+                        }
                         userid = u.getUserid();
                         teacherIds.add(userid);
                         //处理用户班级
             }
             if (N_Utils.isListNotEmpty(teacherList)) {
                 batchSave(teacherList);//批量添加教师
-                System.out.println("新教师：" + JSON.toJSONString(teacherList));
                 for (TUser user : teacherList) {
                     Integer userid = user.getId();
                     teacherIds.add(userid);//把新添加的教师id添加到要导入的教师id集合
                 }
             }
 
-            if (N_Utils.isListNotEmpty(ctlst)) {
+            if (N_Utils.isListNotEmpty(teacherIds)) {
                 String teacherids = teacherIds.stream().distinct().map(String::valueOf).collect(Collectors.joining(","));
                 classTeacherMapper.deleteByUserid2(teacherids, year);//删除教师任教班级
+            }
+
+            if (N_Utils.isListNotEmpty(ctlst)) {
                 classTeacherMapper.insertList(ctlst);//添加教师任教班级
             }
 
+            map.put("teachersExisted", teachersExisted);
+            map.put("studentsExisted", studentsExisted);
             map.put("usersExisted", usersExisted);
-            if (N_Utils.isListNotEmpty(usersExisted)) {
+            map.put("delUsers", delUsers);
+            if (N_Utils.isListNotEmpty(teachersExisted) || N_Utils.isListNotEmpty(studentsExisted)
+                    || N_Utils.isListNotEmpty(usersExisted) || N_Utils.isListNotEmpty(delUsers)) {
                 map.put("code", 1);
             } else {
                 map.put("code", 0);
         if ("yhzc".equals(templateCode)) {//用户注册验证码
             msgtxt += "验证码" + messageCode + "，您正在注册成为新用户，感谢您的支持！";
         } else if ("xgmm".equals(templateCode)) {//修改密码验证码
-            msgtxt += "验证码" + messageCode + "，您正在尝试修改登录密码，请妥善保管账户信息。";
+            msgtxt += "验证码" + messageCode + "，您正在尝试修改登录密码，请妥善保管账号信息。";
         } else if ("dlqr".equals(templateCode)) {//登录确认验证码
             msgtxt += "验证码" + messageCode + "，您正在登录，若非本人操作，请勿泄露。";
         } else if ("bdsj".equals(templateCode)) {//绑定手机验证码
         UserVo userVo = userMapper.getUserByUserPhone(userphone);
         if (userVo == null || userVo.getBindphoned() == 0) return new ResultVo(1, "手机号码未绑定");
         //判断学校状态
-        if (userVo.getUsertype() != 999 && userVo.getSchoolstate() != 1) {
-            return new ResultVo(1, "该学校已锁定，禁止登录");
+        Integer usertype = userVo.getUsertype();
+        if (usertype != 999 && userVo.getSchoolstate() != 1) {
+            return new ResultVo(1, "此学校已锁定，禁止登录");
+        }
+        String roleName;
+        if (usertype == 2) {
+            roleName = "老师";
+        } else {
+            roleName = "管理员";
         }
         //判断用户状态
         if (userVo.getUserstate() != 1) {
-            return new ResultVo(1, "该账户无权访问，请联系老师");
+            return new ResultVo(1, "此账号无权访问，请联系" + roleName);
         }
         //判断用户是否锁定
         if (userVo.getUserlock() == 1) {
-            return new ResultVo(1, "该账户已被锁定，禁止登录");
+            return new ResultVo(1, "此账号已锁定，禁止登录");
         }
         //判断用户是否过期
         String usertime = userVo.getUsertime();
         String dayBegin = DatesUtil.getDayBegin();
         if (N_Utils.isNotEmpty(usertime) && usertime.compareTo(dayBegin) < 0) {
-            return new ResultVo(1, "账号已过有效期，请联系管理员");
+            return new ResultVo(1, "账号已过有效期，请联系" + roleName);
         }
 
         //进行角色判断
-        if (userVo.getUsertype() == 2) {
+        if (usertype == 2) {
             Integer stuweb = userVo.getStuweb();
             if (stuweb != null && stuweb != 1) return new ResultVo(1, "学生账号无法登录");
         }
         UserVo user = userMapper.getUserSchoolByUserid(userid);
         String usertime = user.getUsertime();
         String dayBegin = DatesUtil.getDayBegin();
-        String msg = "用户信息正常";
+        String msg = "账号信息正常";
         if (!loginpwd.equals(user.getLoginpwd())) {
             needLogin = true;
             msg = "密码已修改，请重新登录";
         }
         //判断学校状态
-        if (!needLogin && user.getUsertype() != 999 && user.getSchoolstate() != 1) {
+        Integer usertype = user.getUsertype();
+        String roleName;
+        if (usertype == 2) {//学生
+            roleName = "老师";
+        } else {
+            roleName = "管理员";
+        }
+        if (!needLogin && usertype != 999 && user.getSchoolstate() != 1) {
             needLogin = true;
-            msg = "该学校已锁定，请联系管理员";
+            msg = "此学校已锁定，请联系" + roleName;
         }
         //判断用户状态
         if (!needLogin && user.getUserstate() != 1) {
             needLogin = true;
-            msg = "该账户无权访问，请联系老师";
+            msg = "此账号无权访问，请联系" + roleName;
         }
         if (!needLogin && N_Utils.isNotEmpty(usertime) && usertime.compareTo(dayBegin) < 0) {
             needLogin = true;
-            msg = "账号已过有效期，请联系管理员";
+            msg = "账号已过有效期，请联系" + roleName;
         }
         if (!needLogin && user.getUserlock() == 1) {
             needLogin = true;
-            msg = "该用户已被锁定，请联系管理员";
+            msg = "此账号已锁定，请联系" + roleName;
         }
-        if (user.getUsertype() == 2) {
+        if (usertype == 2) {
             needPhone = userMapper.checkUserPhone(userid);
             if (!needLogin && needPhone) msg = "未绑定手机号";
 
-            if(device != null && "pad".equals(device)){
+            if (device != null && "pad".equals(device)) {
                 //当是设备不为空并且是pad时，进行验证
-                if(user.getSbindmac() == 1 && user.getBindmac() != 1){
+                if (user.getSbindmac() == 1 && user.getBindmac() != 1) {
                     needLogin = true;
                     msg = "未绑定设备";
                 }
             } else if (userVo.getUsertype() == 2) {
                 resultVo = new ResultVo(1, "禁止学生登录");
             } else if (userVo.getSchoolstate() != 1) {
-                resultVo = new ResultVo(1, "用户所在学校暂无权限");
+                resultVo = new ResultVo(1, "账号所在学校暂无权限");
             } else {
                 if (userVo.getUserstate() != 1) {
-                    resultVo = new ResultVo(1, "该账户无权访问，请联系老师");
+                    resultVo = new ResultVo(1, "此账号无权访问，请联系管理员");
                 } else {
                     resultVo = new ResultVo(0, "登录成功", userVo);
                 }
             }
         } else {
-            resultVo = new ResultVo(1, "该账号不存在");
+            resultVo = new ResultVo(1, "此账号不存在");
         }
 
         return getLogResultVo(user, resultVo, "", request);
     public ResultVo checkUser(String loginname, String username) {
         Map map = userMapper.getBindByName(loginname);
         if (N_Utils.isEmpty(map)) {
-            return new ResultVo(1, "该账号不存在");
+            return new ResultVo(1, "此账号不存在");
         }
         String username1 = map.get("username").toString();
         if (!username.equals(username1)) {
-            return new ResultVo(1, "该账号和姓名不匹配");
+            return new ResultVo(1, "此账号和姓名不匹配");
         }
         return new ResultVo(0, "验证身份成功", map);
     }
     public void batchUpdateTime(String usertime, List<Integer> userids) {
         userMapper.batchUpdateTime(usertime, userids);
     }
+
+    /**
+     * 批量激活
+     *
+     * @return void
+     * @Param [userids]
+     * @Author ywx
+     * @Date 2022/6/8 17:10
+     **/
+    public void batchActivate(List<Integer> userids) {
+        userMapper.batchUpdateUserState(1, userids);
+    }
 }

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

             left join t_teacher_powersb tp on tp.teacherid=u.userid
             left join t_subject_book sb on sb.lsbid=tp.lsbid
         </if>
-        where u.schoolid=#{teacher.schoolid} and u.usertype in(0,1) and u.userstate=1
+        where u.schoolid=#{teacher.schoolid} and u.usertype in(0,1)
+        <if test="teacher.userstate!=null and teacher.userstate!=0">
+            and u.userstate=#{teacher.userstate}
+        </if>
         <if test="teacher.userlock!=null and teacher.userlock!=0">
             and u.userlock=#{teacher.userlock}
         </if>

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

         update t_user set headpic=#{user.headpic},headtime=UNIX_TIMESTAMP() where userid=#{user.userid}
     </update>
     <!--检查登录账号是否存在-->
-    <select id="checkLoginName" resultType="java.lang.Integer">
-        select count(*) from t_user u where binary u.loginname=#{loginname}
+    <select id="checkLoginName" resultType="java.util.Map">
+        select u.userid,u.userstate,u.usertype,u.schoolid from t_user u where binary u.loginname=#{loginname}
     </select>
     <!--根据登录账号获取用户详情-->
     <select id="getObjByLoginName" resultType="com.xhkjedu.suser.model.system.TUser">
     </select>
     <!--修改用户状态-->
     <update id="updateState">
-        update t_user set userstate=#{userstate} where userid=#{userid}
+        update t_user set userstate=#{userstate},createtime=UNIX_TIMESTAMP() where userid=#{userid}
     </update>
 
     <!-- 用户设置操作密码 -->
             ${userid}
         </foreach>
     </update>
+    <!--批量更新用户状态-->
+    <update id="batchUpdateUserState">
+        update t_user set userstate=#{userstate},createtime=UNIX_TIMESTAMP() where userid in
+        <foreach collection="userids" item="userid" index="index" open="(" separator="," close=")">
+            ${userid}
+        </foreach>
+    </update>
 
     <!--根据用户id获取用户详细信息，学校基本信息-->
     <select id="getUserSchoolByUserid" resultType="com.xhkjedu.suser.vo.system.UserVo">