学年升级添加记录

sapi/src/main/java/com/xhkjedu/sapi/controller/system/SchoolController.java

         Integer pageSize = tSchool.getPageSize();
         N_Utils.validation(new Object[]{page,"显示页码",1,pageSize,"显示条数",1});
         PageHelper.startPage(page, pageSize);
-        List<Map> list = schoolService.findAll();
+        List<Map<String,Object>> list = schoolService.findAll();
         PageResult pageResult = PageUtil.getPageResult(new PageInfo(list));
         return new ResultVo(0,"获取列表成功",pageResult);
     }
         N_Utils.validation(new Object[]{schoolid,"学校id",1});
 
         try {
-            Map rtnmap = schoolService.checkSchoolUpgrade(schoolid);
+            Map<String,Object> rtnmap = schoolService.checkSchoolUpgrade(schoolid);
             return new ResultVo(0,"成功检测学年升级",rtnmap);
         } catch (Exception e) {
             log.error("检测学年升级失败：" + e.getMessage());
     @PostMapping("/upgrade")
     public ResultVo upgrade(@RequestBody TSchool tSchool) {
         Integer schoolid = tSchool.getSchoolid();
-        N_Utils.validation(new Object[]{schoolid,"学校id",1});
+        Integer createid = tSchool.getCreateid();
+        N_Utils.validation(new Object[]{schoolid, "学校id", 1, createid, "用户id", 1});
         Integer year = schoolService.getYearById(schoolid);
         Integer nowYear = N_Utils.getNodeDateTime("year");//当前年份
         if (year >= nowYear) return new ResultVo(1,"当前学年不用升级");
         try {
-            schoolService.upgrade(schoolid, year);
+            schoolService.upgrade(schoolid, year, createid);
             return new ResultVo(0,"学年升级成功");
         } catch (Exception e) {
             log.error("学年升级失败：" + e.getMessage());
     @PostMapping("/downgrade")
     public ResultVo downgrade(@RequestBody TSchool tSchool) {
         Integer schoolid = tSchool.getSchoolid();
+        Integer createid = tSchool.getCreateid();
+        N_Utils.validation(new Object[]{schoolid, "学校id", 1, createid, "用户id", 1});
         Integer year = schoolService.getYearById(schoolid);
-        N_Utils.validation(new Object[]{schoolid,"学校id",1});
-        schoolService.downgrade(schoolid, year);
-        return new ResultVo(0,"学年降级成功");
+        try {
+            schoolService.downgrade(schoolid, year, createid);
+            return new ResultVo(0,"学年降级成功");
+        } catch (Exception e) {
+            log.error("学年降级失败：" + e.getMessage());
+            return new ResultVo(1,"学年降级失败");
+        }
+    }
+
+    /**
+     * @Description 学校升级记录
+     * @Param [tSchool]
+     * @Author ywx
+     * @Date 2023/6/30 9:24
+     * @return com.xhkjedu.vo.ResultVo
+     **/
+    @PostMapping("/list_up")
+    public ResultVo listUpgrade(@RequestBody TSchool tSchool) {
+        Integer schoolid = tSchool.getSchoolid();
+        N_Utils.validation(new Object[]{schoolid, "学校id", 1});
+        List<Map<String,Object>> list = schoolService.listUpgrade(schoolid);
+        return new ResultVo(0, "获取学校升级记录成功", list);
     }
 
     @PostMapping("/detail")
     public ResultVo detail(@RequestBody TSchool tSchool) {
         Integer schoolid = tSchool.getSchoolid();
         N_Utils.validation(new Object[]{schoolid, "学校id", 1});
-        Map school = schoolService.findById(schoolid);
+        Map<String,Object> school = schoolService.findById(schoolid);
         return new ResultVo(0, "获取学校详情成功", school);
     }
 
     @PostMapping("/list_sel")
     public ResultVo listForSel(@RequestBody TSchool tSchool) {
-        List<Map> list = schoolService.listForSel(tSchool.getSchoolname());
+        List<Map<String,Object>> list = schoolService.listForSel(tSchool.getSchoolname());
         return new ResultVo(0, "获取学校选择列表成功", list);
     }
 
     public ResultVo getFschoolids(@RequestBody SchoolParams params) {
         Integer schoolid = params.getSchoolid();
         N_Utils.validation(new Object[]{schoolid, "学校id", 1});
-        List<Map> list = schoolService.listFSchoolidsBySchoolid(schoolid);
+        List<Map<String,Object>> list = schoolService.listFSchoolidsBySchoolid(schoolid);
         return new ResultVo(0, "获取成功",list);
     }
 
     public ResultVo listSchoolClass(@RequestBody SchoolParams params) {
         Integer schoolid = params.getSchoolid();
         N_Utils.validation(new Object[]{schoolid, "学校id", 1});
-        List<Map> list = schoolService.listSchoolAndFriendSchools(schoolid);
+        List<Map<String,Object>> list = schoolService.listSchoolAndFriendSchools(schoolid);
         return new ResultVo(0, "获取成功",list);
     }
 
     @PostMapping("/list_fsel")
     public ResultVo listFriendForSel(@RequestBody TSchool school) {
         N_Utils.validation(new Object[]{school.getSchoolid(), "学校id", 1});
-        List<Map> list = schoolService.listFriendForSel(school);
+        List<Map<String,Object>> list = schoolService.listFriendForSel(school);
         return new ResultVo(0, "获取伙伴学校选择列表成功", list);
     }
 }

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

     Integer getClassIdByName(String classname, Integer schoolid, Integer gradeid, Integer year);
 
     //修改班级状态
-    void updateClassState(@Param("classstate") Integer classstate, @Param("classids") String classids);
+    int updateClassState(@Param("classstate") Integer classstate, @Param("classids") String classids);
 
 
     //要升级的班级列表
     //升级时要毕业的班级列表
     List<TClass> listClassBiyeBySchoolId(@Param("schoolid") Integer schoolid,@Param("year") Integer year,@Param("classstate") Integer classstate);
 
-    //要升级的班级id字符串
-    String listClassIdBySchoolId(@Param("schoolid") Integer schoolid,@Param("year") Integer year);
-
     //获取要升级的学生列表
     List<TClassStudent> listStudentByClassIds(@Param("classIds") String classIds);
     //要升级的教师列表
     //获取要升级的学生列表
     List<TGroupStudent> listStudentByGroupIds(@Param("groupIds") String groupIds);
 
+    //班级学生id列表
+    List<Integer> listStudentIdByClassIds(@Param("classIds") String classIds);
 }

sapi/src/main/java/com/xhkjedu/sapi/mapper/system/SchoolFriendMapper.java

 public interface SchoolFriendMapper extends TkMapper<TSchoolFriend> {
 
     //获取关联学校id
-    List<Map> listFSchoolidsBySchoolid(@Param("schoolid")Integer schoolid);
+    List<Map<String,Object>> listFSchoolidsBySchoolid(@Param("schoolid")Integer schoolid);
 
     //删除学校附属学校
     void deleteBySchoolid(@Param("schoolid")Integer schoolid);
 
     //获取学校关联的所有行政班
-    List<Map> listSchoolClass(@Param("schoolid")Integer schoolid);
+    List<Map<String,Object>> listSchoolClass(@Param("schoolid")Integer schoolid);
 
     //获取附属学校关联的所有行政班
-    List<Map> listFriendSchoolClass(@Param("schoolid")Integer schoolid);
+    List<Map<String,Object>> listFriendSchoolClass(@Param("schoolid")Integer schoolid);
 }

sapi/src/main/java/com/xhkjedu/sapi/mapper/system/SchoolMapper.java

     Integer deleteById(@Param("schoolid") Integer schoolid);
 
     //列表
-    List<Map> findAll();
+    List<Map<String,Object>> findAll();
 
     /**
      * 学年升级
     Integer downgrade(@Param("schoolid") Integer schoolid, @Param("year") Integer year);
 
     //学校选择列表
-    List<Map> listForSel(@Param("schoolname")String schoolname);
+    List<Map<String,Object>> listForSel(@Param("schoolname")String schoolname);
 
     TSchool getSchoolDetailById(@Param("schoolid") Integer schoolid);//获取区域码
 
     List<Integer> listCloudYear();
 
     //详情
-    Map findById(@Param("schoolid") Integer schoolid);
+    Map<String,Object> findById(@Param("schoolid") Integer schoolid);
 
     //伙伴学校列表
-    List<Map> listSchool(@Param("schoolid") Integer schoolid);
+    List<Map<String,Object>> listSchool(@Param("schoolid") Integer schoolid);
 
     //加入学校列表
-    List<Map> listJoinSchool(@Param("schoolid") Integer schoolid);
+    List<Map<String,Object>> listJoinSchool(@Param("schoolid") Integer schoolid);
 
     //伙伴学校选择列表
-    List<Map> listFriendForSel(@Param("school") TSchool school);
+    List<Map<String,Object>> listFriendForSel(@Param("school") TSchool school);
+
+    //学校升级记录
+    List<Map<String,Object>> listUpgrade(Integer schoolid);
 }

sapi/src/main/java/com/xhkjedu/sapi/mapper/system/SchoolUpgradeHistoryMapper.java

+package com.xhkjedu.sapi.mapper.system;
+
+import com.xhkjedu.base.TkMapper;
+import com.xhkjedu.sapi.model.system.TSchoolUpgradeHistory;
+import org.springframework.stereotype.Repository;
+
+/**
+ * @Description 学校学年升级年级记录表
+ * @Author ywx
+ * Date 2023/6/30 12:24
+ **/
+@Repository
+public interface SchoolUpgradeHistoryMapper extends TkMapper<TSchoolUpgradeHistory> {
+}

sapi/src/main/java/com/xhkjedu/sapi/mapper/system/SchoolUpgradeMapper.java

+package com.xhkjedu.sapi.mapper.system;
+
+import com.xhkjedu.base.TkMapper;
+import com.xhkjedu.sapi.model.system.TSchoolUpgrade;
+import org.springframework.stereotype.Repository;
+
+/**
+ * @Description 学校升级记录
+ * @Author ywx
+ * Date 2023/6/29 15:44
+ **/
+@Repository
+public interface SchoolUpgradeMapper extends TkMapper<TSchoolUpgrade> {
+}

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

     UserVo getSchoolAdminBySchoolid(@Param("schoolid")Integer schoolid);
 
     //批量修改学生状态
-    void batchUpdateState(@Param("users")List<TClassStudent> users, @Param("userstate")Integer userstate);
+    int batchUpdateState(@Param("users")List<Integer> users, @Param("userstate")Integer userstate);
 
     //根据用户id获取学校id
     Integer getSchoolIdByUserId(Integer userid);

sapi/src/main/java/com/xhkjedu/sapi/model/system/TSchoolUpgrade.java

+package com.xhkjedu.sapi.model.system;
+
+import com.xhkjedu.model.BaseBean;
+import lombok.Data;
+
+import javax.persistence.Id;
+import javax.persistence.Table;
+
+/**
+ * @Description 学校升级记录表
+ * @Author ywx
+ * Date 2023/6/29 15:08
+ **/
+@Table(name = "t_school_upgrade")
+@Data
+public class TSchoolUpgrade extends BaseBean {
+    @Id
+    private Integer suid;//学校升级记录表
+    private Integer schoolid;//学校id
+    private Integer uptype;//类型：1升级2降级
+    private Integer oldyear;//旧年份
+    private Integer newyear;//新年份
+    private Integer uptime;//升级时间
+    private Integer upuserid;//升级人
+    private Integer upresult;//升级结果1成功2失败
+}

sapi/src/main/java/com/xhkjedu/sapi/model/system/TSchoolUpgradeHistory.java

+package com.xhkjedu.sapi.model.system;
+
+import com.xhkjedu.model.BaseBean;
+import lombok.Data;
+
+import javax.persistence.Id;
+import javax.persistence.Table;
+
+/**
+ * @Description 学校学年升级年级记录表
+ * @Author ywx
+ * Date 2023/6/29 15:08
+ **/
+@Table(name = "t_school_upgrade_history")
+@Data
+public class TSchoolUpgradeHistory extends BaseBean {
+    @Id
+    private Integer suhid;//学校学年升级年级记录表
+    private Integer schoolid;//学校id
+    private Integer suid;//学年升级id
+    private Integer gradeid;//学年升级id
+    private Integer classyxznum;//应升级行政班数量
+    private Integer classsxznum;//实际升级行政班数量
+    private Integer classyxnnum;//应升级虚拟班数量
+    private Integer classsxnnum;//实际升级虚拟班数量
+    private Integer stuyupnum;//应升级学生数量
+    private Integer stusupnum;//实际升级学生数量
+}

sapi/src/main/java/com/xhkjedu/sapi/service/system/SchoolService.java

 import com.xhkjedu.utils.MD5;
 import com.xhkjedu.utils.N_Utils;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.dao.DuplicateKeyException;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
     private GroupStudentMapper groupStudentMapper;
     @Resource
     private UserMapper userMapper;
-    @Autowired
+    @Resource
     private RoleMapper roleMapper;
-    @Autowired
+    @Resource
     private RoleModuleMapper roleModuleMapper;
-    @Autowired
+    @Resource
     private UserRoleMapper userRoleMapper;
     @Resource
     private SchoolFriendMapper schoolFriendMapper;
     @Resource
     private CloudMapper cloudMapper;
+    @Resource
+    private SchoolUpgradeMapper schoolUpgradeMapper;
+    @Resource
+    private SchoolUpgradeHistoryMapper schoolUpgradeHistoryMapper;
 
     //添加
     @Transactional(rollbackFor = Exception.class)
         //添加学校信息
         model.setSchoolstate(1);
         model.setCreatetime(N_Utils.getSecondTimestamp());
-        Integer schoolid = null;
+        Integer schoolid;
         try {
             schoolMapper.insertUseGeneratedKeys(model);
             schoolid = model.getId();
      * @Param [userid, roleid]
      * @Author ywx
      * @Date 2020/7/2 11:52
-     * @return java.lang.Integer
      **/
-    private Integer saveUserRole(Integer userid, Integer roleid) {
+    private void saveUserRole(Integer userid, Integer roleid) {
         TUserRole userRole = new TUserRole();
         userRole.setUserid(userid);
         userRole.setRoleid(roleid);
         userRole.setCreateid(userid);
         userRole.setCreatetime(N_Utils.getSecondTimestamp());
         userRoleMapper.insertUseGeneratedKeys(userRole);
-        return userRole.getId();
     }
 
     /**
     /**
      * 保存子模块信息并设置角色模块信息
      *
-     * @return void
      * @Param [schoolid, userid, roleid, roleModules, module]
      * @Author ywx
      * @Date 2020/7/2 11:47
     /**
      * 保存子模块信息
      *
-     * @return void
      * @Param [schoolid, userid, module, roleModules, roleid]
      * @Author ywx
      * @Date 2020/7/2 11:46
     }
 
     //获取列表
-    public List <Map> findAll() {
+    public List <Map<String,Object>> findAll() {
         return schoolMapper.findAll();
     }
 
-    public Map checkSchoolUpgrade(Integer schoolid) throws Exception{
-        Map rtnMap = new HashMap();
+    public Map<String,Object> checkSchoolUpgrade(Integer schoolid) throws Exception{
+        HashMap<String,Object> rtnMap = new HashMap<>();
         TCloud cloud = cloudMapper.getCloudUpTime();
-        boolean isup = false;
-        if(ApiUtil.compareCurrDateTime(cloud.getStarttime(),cloud.getStoptime())){
-            isup = true;
-        }
+        boolean isup = ApiUtil.compareCurrDateTime(cloud.getStarttime(), cloud.getStoptime());
 
         //获取当前学校的学年
         int year = schoolMapper.getYearById(schoolid);
 
-        //前端进行年份判断
-        /*Integer nowYear = N_Utils.getNodeDateTime("year");//当前年份
-        //如果学校年份大于等于当前年份无需升级
-        if(year >= nowYear){
-            isup = false;
-        }*/
-
         rtnMap.put("isup",isup);
         rtnMap.put("year",year);
         rtnMap.put("starttime",cloud.getStarttime());
      * @Param [schoolid, year]
      * @Author ywx
      * @Date 2020/6/12 13:50
-     * @return void
      **/
     @Transactional(rollbackFor = Exception.class)
-    public void upgrade(Integer schoolid, Integer year) throws Exception {
-        //获取区域限制学年升级时间
-        TCloud cloud = cloudMapper.getCloudUpTime();
-        if(!ApiUtil.compareCurrDateTime(cloud.getStarttime(),cloud.getStoptime())){
-           throw new Exception("不在学年升级时间范围，禁止升级");
-        }
-
+    public void upgrade(Integer schoolid, Integer year, Integer createid) throws Exception {
+        checkUpTime();
+
+        int timestamp = N_Utils.getSecondTimestamp();
+        TSchoolUpgrade su = new TSchoolUpgrade();
+        su.setSchoolid(schoolid);
+        su.setUptype(1);
+        su.setOldyear(year);
+        su.setNewyear(year + 1);
+        su.setUptime(timestamp);
+        su.setUpuserid(createid);
+        int classyxznum;//应升级行政班数量
+        int classsxznum;//实际升级行政班数量
+        int classyxnnum;//应升级虚拟班数量
+        int classsxnnum;//实际升级虚拟班数量
+        int stuyupnum;//应升级学生数量
+        int stusupnum;//实际升级学生数量
+        int gradeid;//学年升级id
+        List<TSchoolUpgradeHistory> histories = new ArrayList<>();
         try {
+            //不需要升级，需要标识毕业的班级，学生
+            List<TClass> biyeclass = classMapper.listClassBiyeBySchoolId(schoolid, year, 1);
+            List<String> xzList = biyeclass.stream().filter(c -> c.getClasstype().equals(1))
+                                           .map(c -> c.getClassid().toString()).collect(Collectors.toList());
+            String xzClassIds = String.join(",", xzList);
+            List<Integer> bystudents = new ArrayList<>();
+            if (N_Utils.isNotEmpty(xzClassIds)) {
+                bystudents = classMapper.listStudentIdByClassIds(xzClassIds);//要毕业的学生列表
+            }
+
             List<TClass> classes = classMapper.listClassBySchoolId(schoolid, year);//要升级的班级列表
             if (N_Utils.isListNotEmpty(classes)) {
-                String classIds = classMapper.listClassIdBySchoolId(schoolid, year);
+                List<String> classids = classes.stream().filter(c -> c.getClasstype().equals(1)).map(c -> c.getClassid().toString()).collect(Collectors.toList());
+                String classIds = String.join(",", classids);
                 List<TClassStudent> cStudents = classMapper.listStudentByClassIds(classIds);//要升级的学生列表
                 List<TClassTeacher> cTeachers = classMapper.listTeacherByClassIds(classIds);//要升级的教师列表
-
                 List<TGroup> groups = classMapper.listGroupByClassIds(classIds);//要升级的全体分组列表
-                StringBuilder sb = new StringBuilder();
-                groups.forEach(g -> {
-                    sb.append(g.getGroupid()).append(",");
-                });
-                String groupIds = sb.toString().substring(0, sb.toString().length() - 1);
+                String groupIds = groups.stream().map(g -> g.getGroupid().toString()).collect(Collectors.joining(","));
                 List<TGroupStudent> gStudents = classMapper.listStudentByGroupIds(groupIds);//要升级的学生列表
-
-                List<TClassStudent> classStudents = new ArrayList<>();//升级后的班级学生
-                List<TClassTeacher> classTeachers = new ArrayList<>();//升级后的班级教师
-                List<TGroupStudent> groupStudents = new ArrayList<>();//升级后的分组学生
-                for (TClass c : classes) {
-                    //复制班级信息
-                    c.setYear(c.getYear() + 1);
-                    c.setGradeid(c.getGradeid() + 1);
-                    c.setClassstate(1);
-                    c.setCreatetime(N_Utils.getSecondTimestamp());
-                }
-                classMapper.insertList(classes);//保存升级后的班级信息
-                for (TClass c : classes) {
-                    //复制班级信息
-                    Integer oldClassId = c.getClassid();
-                    Integer classid = c.getId();
-
-                    //复制班级学生信息
-                    boolean rtn = false;
-                    for (TClassStudent s : cStudents) {
-                        if (oldClassId.equals(s.getClassid())) {
-                            s.setClassid(classid);
-                            s.setCreatetime(N_Utils.getSecondTimestamp());
-                            classStudents.add(s);
-                            rtn = true;
-                        } else if (!oldClassId.equals(s.getClassid()) && rtn) {
-                            break;
-                        }
-                    }
-
-                    //复制班级教师信息
-                    rtn = false;
-                    for (TClassTeacher t : cTeachers) {
-                        if (oldClassId.equals(t.getClassid())){
-                            t.setClassid(classid);
-                            t.setCreatetime(N_Utils.getSecondTimestamp());
-                            classTeachers.add(t);
-                            rtn = true;
-                        } else if (!oldClassId.equals(t.getClassid()) && rtn){
-                            break;
-                        }
-                    }
-
-                    for (TGroup g : groups) {
-                        if (oldClassId.equals(g.getClassid())) {
-                            //复制班级分组信息
-                            g.setClassid(classid);
-                            g.setCreatetime(N_Utils.getSecondTimestamp());
-                            break;
-                        }
+                Map<Integer, List<TClass>> gcollect = classes.stream().collect(Collectors.groupingBy(c -> c.getGradeid()));
+                for (Map.Entry<Integer, List<TClass>> entry : gcollect.entrySet()) {
+                    gradeid = entry.getKey();
+                    List<TClass> classList = entry.getValue();
+                    List<TClass> xzbList = classList.stream().filter(c -> c.getClasstype().equals(1)).collect(Collectors.toList());
+                    List<TClass> xnbList = classList.stream().filter(c -> c.getClasstype().equals(2)).collect(Collectors.toList());
+                    if (N_Utils.isListNotEmpty(xzbList)) {
+                        String cIds = xzbList.stream().map(c -> c.getClassid().toString()).collect(Collectors.joining(","));
+                        List<TClassStudent> studentList = cStudents.stream().filter(cs -> cIds.contains(String.valueOf(cs.getClassid()))).collect(Collectors.toList());
+                        List<TClassTeacher> teacherList = cTeachers.stream().filter(cs -> cIds.contains(String.valueOf(cs.getClassid()))).collect(Collectors.toList());
+                        List<TGroup> gList = groups.stream().filter(cs -> cIds.contains(String.valueOf(cs.getClassid()))).collect(Collectors.toList());
+                        List<TGroupStudent> gsList = gStudents.stream().filter(cs -> cIds.contains(String.valueOf(cs.getClassid()))).collect(Collectors.toList());
+                        List<Integer> list = saveClass(timestamp, xzbList, studentList, teacherList, gList, gsList);
+                        classyxznum = xzbList.size();
+                        classsxznum = list.get(0);
+                        stuyupnum = studentList.size();
+                        stusupnum = list.get(1);
+                    } else {
+                        classyxznum = 0;
+                        classsxznum = 0;
+                        stuyupnum = 0;
+                        stusupnum = 0;
                     }
-                }
-                groupMapper.insertList(groups);//保存升级后的班级分组信息
-                for (TGroup g : groups) {
-                    Integer classid = g.getClassid();
-                    Integer oldGroupId = g.getGroupid();
-                    Integer groupid = g.getId();
-                    //复制分组学生信息
-                    boolean rtn = false;
-                    for (TGroupStudent s : gStudents) {
-                        if (oldGroupId.equals(s.getGroupid())) {
-                            s.setClassid(classid);
-                            s.setGroupid(groupid);
-                            s.setCreatetime(N_Utils.getSecondTimestamp());
-                            groupStudents.add(s);
-                            rtn = true;
-                        } else if (!oldGroupId.equals(s.getGroupid()) && rtn) {
-                            break;
+                    if (N_Utils.isListNotEmpty(xnbList)) {
+                        String cIds = xnbList.stream().map(c -> c.getClassid().toString()).collect(Collectors.joining(","));
+                        List<TClassStudent> studentList = new ArrayList<>();
+                        for (TClassStudent cs : cStudents) {
+                            if (cIds.contains(cs.getClassid().toString()) && !bystudents.contains(cs.getStudentid())) {
+                                studentList.add(cs);
+                            }
                         }
+                        List<TClassTeacher> teacherList = cTeachers.stream().filter(cs -> cIds.contains(String.valueOf(cs.getClassid()))).collect(Collectors.toList());
+                        List<TGroup> gList = groups.stream().filter(cs -> cIds.contains(String.valueOf(cs.getClassid()))).collect(Collectors.toList());
+                        List<TGroupStudent> gsList = gStudents.stream().filter(cs -> cIds.contains(String.valueOf(cs.getClassid()))).collect(Collectors.toList());
+                        List<Integer> list = saveClass(timestamp, xzbList, studentList, teacherList, gList, gsList);
+                        classyxnnum = xnbList.size();
+                        classsxnnum = list.get(0);
+                    } else {
+                        classyxnnum = 0;
+                        classsxnnum = 0;
                     }
+                    TSchoolUpgradeHistory suh = new TSchoolUpgradeHistory();
+                    suh.setGradeid(gradeid);
+                    suh.setClassyxznum(classyxznum);
+                    suh.setClasssxznum(classsxznum);
+                    suh.setClassyxnnum(classyxnnum);
+                    suh.setClasssxnnum(classsxnnum);
+                    suh.setStuyupnum(stuyupnum);
+                    suh.setStusupnum(stusupnum);
+                    histories.add(suh);
                 }
-                classStudentMapper.insertList(classStudents);//保存升级后的班级学生信息
-                classTeacherMapper.insertList(classTeachers);//保存升级后的班级教师信息
-                groupStudentMapper.insertList(groupStudents);//保存升级后的分组学生信息
             }
 
-            //不需要升级，需要标识毕业的班级，学生
-            List<TClass> biyeclass = classMapper.listClassBiyeBySchoolId(schoolid,year,1);
-
 
-            if(N_Utils.isListNotEmpty(biyeclass)){
-                String byclassIds = "";
-                for(int i=0;i<biyeclass.size();i++){
-                    TClass c = biyeclass.get(i);
-                    if(i>0){
-                        byclassIds = byclassIds + "," + c.getClassid();
-                    }else{
-                        byclassIds = c.getClassid().toString();
-                    }
+            if (N_Utils.isListNotEmpty(biyeclass)) {
+                gradeid = biyeclass.get(0).getGradeid();
+                List<String> xnList = biyeclass.stream().filter(c -> c.getClasstype().equals(2))
+                                               .map(c -> c.getClassid().toString()).collect(Collectors.toList());
+                String xnClassIds = String.join(",", xnList);
+                if (N_Utils.isNotEmpty(xzClassIds)) {
+                    classyxznum = xzList.size();
+                    classsxznum = classMapper.updateClassState(3, xzClassIds);//修改班级状态
+                } else {
+                    classyxznum = 0;
+                    classsxznum = 0;
                 }
-
-                List<TClassStudent> bystudents = classMapper.listStudentByClassIds(byclassIds);//要毕业的学生列表
-
-                if (N_Utils.isNotEmpty(byclassIds)) {
-                    classMapper.updateClassState(3, byclassIds);//修改班级状态
+                if (N_Utils.isNotEmpty(xnClassIds)) {
+                    classyxnnum = xnList.size();
+                    classsxnnum = classMapper.updateClassState(3, xnClassIds);//修改班级状态
+                } else {
+                    classyxnnum = 0;
+                    classsxnnum = 0;
                 }
                 if (N_Utils.isListNotEmpty(bystudents)) {
-                    userMapper.batchUpdateState(bystudents, 3);   //修改学生状态为已毕业状态
+                    stuyupnum = bystudents.size();
+                    stusupnum = userMapper.batchUpdateState(bystudents, 3);//修改学生状态为已毕业状态
+                } else {
+                    stuyupnum = 0;
+                    stusupnum = 0;
                 }
+                TSchoolUpgradeHistory suh = new TSchoolUpgradeHistory();
+                suh.setGradeid(gradeid);
+                suh.setClassyxznum(classyxznum);
+                suh.setClasssxznum(classsxznum);
+                suh.setClassyxnnum(classyxnnum);
+                suh.setClasssxnnum(classsxnnum);
+                suh.setStuyupnum(stuyupnum);
+                suh.setStusupnum(stusupnum);
+                histories.add(suh);
             }
 
             schoolMapper.upgrade(schoolid);//学校年份升级
-        }catch (Exception e){
+            su.setUpresult(1);
+        } catch (Exception e) {
             log.error("学年升级失败：" + e.getMessage());
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            su.setUpresult(2);
             throw new RuntimeException("学年升级失败");
+        } finally {
+            schoolUpgradeMapper.insertUseGeneratedKeys(su);
+            if (N_Utils.isListNotEmpty(histories)) {
+                Integer suId = su.getId();
+                histories.forEach(h -> {
+                    h.setSchoolid(schoolid);
+                    h.setSuid(suId);
+                });
+                schoolUpgradeHistoryMapper.insertList(histories);
+            }
+        }
+    }
+
+    //保存班级信息
+    private List<Integer> saveClass(int timestamp, List<TClass> classes, List<TClassStudent> cStudents
+            , List<TClassTeacher> cTeachers, List<TGroup> groups, List<TGroupStudent> gStudents) {
+        List<TClassStudent> classStudents = new ArrayList<>();//升级后的班级学生
+        List<TClassTeacher> classTeachers = new ArrayList<>();//升级后的班级教师
+        List<TGroupStudent> groupStudents = new ArrayList<>();//升级后的分组学生
+        for (TClass c : classes) {
+            //复制班级信息
+            c.setYear(c.getYear() + 1);
+            c.setGradeid(c.getGradeid() + 1);
+            c.setClassstate(1);
+            c.setCreatetime(timestamp);
+        }
+        int classnum = classMapper.insertList(classes);//保存升级后的班级信息
+        for (TClass c : classes) {
+            //复制班级信息
+            Integer oldClassId = c.getClassid();
+            Integer classid = c.getId();
+
+            //复制班级学生信息
+            boolean rtn = false;
+            for (TClassStudent s : cStudents) {
+                if (oldClassId.equals(s.getClassid())) {
+                    s.setClassid(classid);
+                    s.setCreatetime(timestamp);
+                    classStudents.add(s);
+                    rtn = true;
+                } else if (!oldClassId.equals(s.getClassid()) && rtn) {
+                    break;
+                }
+            }
+
+            //复制班级教师信息
+            rtn = false;
+            for (TClassTeacher t : cTeachers) {
+                if (oldClassId.equals(t.getClassid())) {
+                    t.setClassid(classid);
+                    t.setCreatetime(timestamp);
+                    classTeachers.add(t);
+                    rtn = true;
+                } else if (!oldClassId.equals(t.getClassid()) && rtn) {
+                    break;
+                }
+            }
+
+            for (TGroup g : groups) {
+                if (oldClassId.equals(g.getClassid())) {
+                    //复制班级分组信息
+                    g.setClassid(classid);
+                    g.setCreatetime(timestamp);
+                    break;
+                }
+            }
+        }
+        if (N_Utils.isListNotEmpty(groups)) groupMapper.insertList(groups);//保存升级后的班级分组信息
+        for (TGroup g : groups) {
+            Integer classid = g.getClassid();
+            Integer oldGroupId = g.getGroupid();
+            Integer groupid = g.getId();
+            //复制分组学生信息
+            boolean rtn = false;
+            for (TGroupStudent s : gStudents) {
+                if (oldGroupId.equals(s.getGroupid())) {
+                    s.setClassid(classid);
+                    s.setGroupid(groupid);
+                    s.setCreatetime(timestamp);
+                    groupStudents.add(s);
+                    rtn = true;
+                } else if (!oldGroupId.equals(s.getGroupid()) && rtn) {
+                    break;
+                }
+            }
+        }
+        int stunum = 0;
+        if (N_Utils.isListNotEmpty(classStudents)) {
+            stunum = classStudentMapper.insertList(classStudents);//保存升级后的班级学生信息
         }
+        if (N_Utils.isListNotEmpty(classTeachers)) classTeacherMapper.insertList(classTeachers);//保存升级后的班级教师信息
+        if (N_Utils.isListNotEmpty(groupStudents)) groupStudentMapper.insertList(groupStudents);//保存升级后的分组学生信息
+        List<Integer> list = new ArrayList<>();
+        list.add(classnum);
+        list.add(stunum);
+        return list;
     }
 
     /**
      * @Param [schoolid, year]
      * @Author ywx
      * @Date 2020/6/16 13:51
-     * @return void
      **/
-    public void downgrade(Integer schoolid, Integer year) {
-
-        schoolMapper.downgrade(schoolid, year);
-        //之前已毕业的班级进行恢复
-        List<TClass> biyeclass = classMapper.listClassBiyeBySchoolId(schoolid,year,3);
-
-        if(N_Utils.isListNotEmpty(biyeclass)){
-            String byclassIds = "";
-            for(int i=0;i<biyeclass.size();i++){
-                TClass c = biyeclass.get(i);
-                if(i>0){
-                    byclassIds = "," + c.getClassid();
-                }else{
-                    byclassIds = c.getClassid().toString();
+    @Transactional(rollbackFor = Exception.class)
+    public void downgrade(Integer schoolid, Integer year, Integer createid) throws Exception {
+        checkUpTime();
+
+        int timestamp = N_Utils.getSecondTimestamp();
+        TSchoolUpgrade su = new TSchoolUpgrade();
+        su.setSchoolid(schoolid);
+        su.setUptype(2);
+        su.setOldyear(year);
+        su.setNewyear(year - 1);
+        su.setUptime(timestamp);
+        su.setUpuserid(createid);
+        int classyxznum = 0;//应升级行政班数量
+        int classsxznum = 0;//实际升级行政班数量
+        int classyxnnum = 0;//应升级虚拟班数量
+        int classsxnnum = 0;//实际升级虚拟班数量
+        int stuyupnum = 0;//应升级学生数量
+        int stusupnum = 0;//实际升级学生数量
+        int gradeid = 0;//学年升级id
+        try {
+            //之前已毕业的班级进行恢复
+            List<TClass> biyeclass = classMapper.listClassBiyeBySchoolId(schoolid, year - 1, 3);
+
+            if (N_Utils.isListNotEmpty(biyeclass)) {
+                gradeid = biyeclass.get(0).getGradeid();
+                List<String> xzList = biyeclass.stream().filter(c -> c.getClasstype().equals(1))
+                                               .map(c -> c.getClassid().toString()).collect(Collectors.toList());
+                classyxznum = xzList.size();
+                List<String> xnList = biyeclass.stream().filter(c -> c.getClasstype().equals(2))
+                                               .map(c -> c.getClassid().toString()).collect(Collectors.toList());
+                classyxnnum = xnList.size();
+                String xzClassIds = String.join(",", xzList);
+                String xnClassIds = String.join(",", xnList);
+                List<Integer> bystudents = null;
+                if (N_Utils.isNotEmpty(xzClassIds)) {
+                    bystudents = classMapper.listStudentIdByClassIds(xzClassIds);//要毕业的学生列表
+                    stuyupnum = bystudents.size();
                 }
-            }
 
-            List<TClassStudent> bystudents = classMapper.listStudentByClassIds(byclassIds);//要毕业的学生列表
+                classsxznum = classMapper.updateClassState(1, xzClassIds);//修改班级状态
+                classsxnnum = classMapper.updateClassState(1, xnClassIds);//修改班级状态
+                if (N_Utils.isListNotEmpty(bystudents)) {
+                    stusupnum = userMapper.batchUpdateState(bystudents, 1);//修改学生状态
+                }
+            }
+            schoolMapper.downgrade(schoolid, year);
+            su.setUpresult(1);
+        } catch (Exception e) {
+            log.error("学年降级失败：" + e.getMessage());
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            su.setUpresult(2);
+            throw new RuntimeException("学年降级失败");
+        } finally {
+            schoolUpgradeMapper.insertUseGeneratedKeys(su);
+            TSchoolUpgradeHistory suh = new TSchoolUpgradeHistory();
+            suh.setSchoolid(schoolid);
+            suh.setSuid(su.getId());
+            suh.setGradeid(gradeid);
+            suh.setClassyxznum(classyxznum);
+            suh.setClasssxznum(classsxznum);
+            suh.setClassyxnnum(classyxnnum);
+            suh.setClasssxnnum(classsxnnum);
+            suh.setStuyupnum(stuyupnum);
+            suh.setStusupnum(stusupnum);
+            schoolUpgradeHistoryMapper.insertSelective(suh);
+        }
+    }
 
-            classMapper.updateClassState(1,byclassIds);//修改班级状态
-            userMapper.batchUpdateState(bystudents,1);   //修改学生状态
+    private void checkUpTime() throws Exception {
+        //获取区域限制学年升级时间
+        TCloud cloud = cloudMapper.getCloudUpTime();
+        if (!ApiUtil.compareCurrDateTime(cloud.getStarttime(), cloud.getStoptime())) {
+            throw new Exception("不在学年升级时间范围，禁止升级");
         }
     }
 
     }
 
     //学校选择列表
-    public List<Map> listForSel(String schoolname) {
+    public List<Map<String,Object>> listForSel(String schoolname) {
         return schoolMapper.listForSel(schoolname);
     }
 
     }
 
     //获取学校附属学校
-    public List<Map> listFSchoolidsBySchoolid(Integer schoolid){
+    public List<Map<String,Object>> listFSchoolidsBySchoolid(Integer schoolid){
         return schoolFriendMapper.listFSchoolidsBySchoolid(schoolid);
     }
 
     //获取学校及附属学校班级
-    public List<Map> listSchoolAndFriendSchools(Integer schoolid){
-        List<Map> rtnlist = new ArrayList<>();
-        List<Map> schools = schoolFriendMapper.listSchoolClass(schoolid);
+    public List<Map<String,Object>> listSchoolAndFriendSchools(Integer schoolid){
+        List<Map<String,Object>> rtnlist = new ArrayList<>();
+        List<Map<String,Object>> schools = schoolFriendMapper.listSchoolClass(schoolid);
         setSchoolGradeSclass(rtnlist,schools);
-        List<Map> fschools = schoolFriendMapper.listFriendSchoolClass(schoolid);
+        List<Map<String,Object>> fschools = schoolFriendMapper.listFriendSchoolClass(schoolid);
         setFriendSchoolGradeSclass(rtnlist,fschools);
         return rtnlist;
     }
 
-    private void setSchoolGradeSclass(List<Map> rtnlist,List<Map> schools){
+    private void setSchoolGradeSclass(List<Map<String,Object>> rtnlist,List<Map<String,Object>> schools){
         //处理学校
-        Map schoolsmap = schools.get(0);
-        Map schoolm = new LinkedHashMap();
+        Map<String,Object> schoolsmap = schools.get(0);
+        LinkedHashMap<String,Object> schoolm = new LinkedHashMap<>();
         schoolm.put("schoolid",Integer.parseInt(schoolsmap.get("schoolid").toString()));
         schoolm.put("schoolname",schoolsmap.get("schoolname").toString());
 
-        List<Map> gradelist = new ArrayList<>();
+        List<Map<String,Object>> gradelist = new ArrayList<>();
         //根据年级进行分组
-        Map<String,List<Map>> grademap =  schools.stream().collect(Collectors.groupingBy(s -> s.get("gradeid").toString(), Collectors.toList()));
-        for(Map.Entry<String, List<Map>> entry : grademap.entrySet()){
-            Map gmap = new LinkedHashMap();
+        Map<String,List<Map<String,Object>>> grademap =  schools.stream().collect(Collectors.groupingBy(s -> s.get("gradeid").toString(), Collectors.toList()));
+        for(Map.Entry<String, List<Map<String,Object>>> entry : grademap.entrySet()){
+            LinkedHashMap<String,Object> gmap = new LinkedHashMap<>();
             gmap.put("gradeid",Integer.parseInt(entry.getKey()));
-            List<Map> classlist = entry.getValue();
-            for(Map cmap : classlist){
+            List<Map<String,Object>> classlist = entry.getValue();
+            for(Map<String,Object> cmap : classlist){
                 cmap.remove("schoolid");
                 cmap.remove("schoolname");
                 cmap.remove("gradeid");
         rtnlist.add(schoolm);
     }
 
-    private void setFriendSchoolGradeSclass(List<Map> rtnlist,List<Map> schools){
-        Map<String,List<Map>> schoolmap =  schools.stream().collect(Collectors.groupingBy(s -> s.get("schoolid").toString(), Collectors.toList()));
-        for(Map.Entry<String, List<Map>> entry : schoolmap.entrySet()){
-            Map schoolm = new LinkedHashMap();
+    private void setFriendSchoolGradeSclass(List<Map<String,Object>> rtnlist,List<Map<String,Object>> schools){
+        Map<String,List<Map<String,Object>>> schoolmap =  schools.stream().collect(Collectors.groupingBy(s -> s.get("schoolid").toString(), Collectors.toList()));
+        for(Map.Entry<String, List<Map<String,Object>>> entry : schoolmap.entrySet()){
+            Map<String,Object> schoolm = new LinkedHashMap<>();
             schoolm.put("schoolid",Integer.parseInt(entry.getKey()));
-            Map schoolm2 = entry.getValue().get(0);
+            Map<String,Object> schoolm2 = entry.getValue().get(0);
             schoolm.put("schoolname",schoolm2.get("schoolname").toString());
-            List<Map> gradelist = entry.getValue();
-            List<Map> savegradelist = new ArrayList<>();
+            List<Map<String,Object>> gradelist = entry.getValue();
+            List<Map<String,Object>> savegradelist = new ArrayList<>();
             //根据年级进行分组
-            Map<String,List<Map>> grademap =  gradelist.stream().collect(Collectors.groupingBy(s -> s.get("gradeid").toString(), Collectors.toList()));
-            for(Map.Entry<String, List<Map>> entryg : grademap.entrySet()){
-                Map gmap = new LinkedHashMap();
+            Map<String,List<Map<String,Object>>> grademap =  gradelist.stream().collect(Collectors.groupingBy(s -> s.get("gradeid").toString(), Collectors.toList()));
+            for(Map.Entry<String, List<Map<String,Object>>> entryg : grademap.entrySet()){
+                Map<String,Object> gmap = new LinkedHashMap<>();
                 gmap.put("gradeid",Integer.parseInt(entryg.getKey()));
-                List<Map> classlist = entryg.getValue();
-                for(Map cmap : classlist){
+                List<Map<String,Object>> classlist = entryg.getValue();
+                for(Map<String,Object> cmap : classlist){
                     cmap.remove("schoolid");
                     cmap.remove("schoolname");
                     cmap.remove("gradeid");
     }
 
     //详情
-    public Map findById(Integer schoolid) {
-        Map map = schoolMapper.findById(schoolid);
-        List<Map> friendSchools=schoolMapper.listSchool(schoolid);
+    public Map<String,Object> findById(Integer schoolid) {
+        Map<String,Object> map = schoolMapper.findById(schoolid);
+        List<Map<String,Object>> friendSchools=schoolMapper.listSchool(schoolid);
         map.put("friendSchools",friendSchools);//伙伴学校列表
-        List<Map> joinSchools=schoolMapper.listJoinSchool(schoolid);
+        List<Map<String,Object>> joinSchools=schoolMapper.listJoinSchool(schoolid);
         map.put("joinSchools",joinSchools);//加入学校列表
         return map;
     }
 
     //伙伴学校选择列表
-    public List<Map> listFriendForSel(TSchool school) {
+    public List<Map<String,Object>> listFriendForSel(TSchool school) {
         return schoolMapper.listFriendForSel(school);
     }
+
+    //学校升级记录
+    public List<Map<String,Object>> listUpgrade(Integer schoolid) {
+        return schoolMapper.listUpgrade(schoolid);
+    }
 }

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

     </select>
     <!--升级时要毕业的班级列表-->
     <select id="listClassBiyeBySchoolId" resultType="com.xhkjedu.sapi.model.gradeclass.TClass">
-        select * from t_class where schoolid=#{schoolid} and year=#{year} and classtype in(1,2) and classstate=#{classstate} and gradeid in(6,9,12)
-    </select>
-    <!--要升级的班级id字符串-->
-    <select id="listClassIdBySchoolId" resultType="java.lang.String">
-        select group_concat(classid) from t_class where schoolid=#{schoolid} and year=#{year} and classtype in(1,2) and classstate=1 and gradeid in(1,2,3,4,5,7,8,10,11)
+        select classid,classtype,gradeid from t_class where schoolid=#{schoolid} and year=#{year} and classtype in(1,2) and classstate=#{classstate} and gradeid in(6,9,12)
     </select>
 
     <!--获取要升级的学生列表-->
     <select id="listStudentByGroupIds" resultType="com.xhkjedu.sapi.model.gradeclass.TGroupStudent">
         select * from t_group_student where groupid in(${groupIds}) order by groupid;
     </select>
-
+    <!--班级学生id列表-->
+    <select id="listStudentIdByClassIds" resultType="java.lang.Integer">
+        select distinct studentid from t_class_student where classid in(${classIds})
+    </select>
 </mapper>

sapi/src/main/resources/mapper/system/SchoolMapper.xml

     </update>
 
     <select id="listSchool" resultType="java.util.Map">
-        select f.fschoolid schoolid,s2.schoolname
+        select f.fschoolid as schoolid,s2.schoolname
         from t_school_friend f left join t_school s2 on f.fschoolid=s2.schoolid
         where f.schoolid=#{schoolid}
     </select>
     <select id="findAll" resultType="java.util.Map">
         select s.schoolid,s.schoolname,s.shortname,s.schoollevel,s.errorrate,s.`year`
         ,(select u.loginname from t_user u where u.schoolid=s.schoolid and u.usertype=0 and u.userstate=1
-        ORDER BY u.userid ASC LIMIT 1)loginname
+        ORDER BY u.userid LIMIT 1)loginname
         ,(select count(sf.schoolid) from t_school_friend sf where sf.fschoolid=s.schoolid)joinnum
         ,(select count(sf.fschoolid) from t_school_friend sf where sf.schoolid=s.schoolid)friendnum
         from t_school s
     <select id="findById" resultType="java.util.Map">
         select s.*,tu.username createname
         ,(select u.loginname from t_user u where u.schoolid=s.schoolid and u.usertype=0 and u.userstate=1
-        order by u.userid asc limit 1)loginname
+        order by u.userid limit 1) as loginname
         from t_school s left join t_user tu on s.createid = tu.userid
         where s.schoolid=#{schoolid}
     </select>
         </if>
         order by s2.createtime desc
     </select>
+    <!--学校升级记录-->
+    <select id="listUpgrade" resultType="java.util.Map">
+        select su.suid,uptype,oldyear,newyear,uptime,upresult
+        ,classxznum,classxnnum,stuupnum,stubynum,u.username
+        from t_school_upgrade su left join t_user u on su.upuserid=u.userid
+        where su.schoolid=#{schoolid} order by su.suid desc
+    </select>
 </mapper>

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

     <!--批量修改用户状态-->
     <update id="batchUpdateState">
         update t_user set userstate=#{userstate} where
-        <foreach collection="users" item="user" index="index" separator="or">
-            userid=${user.studentid}
+        <foreach collection="users" item="userid" index="index" separator="or">
+            userid=${userid}
         </foreach>
     </update>