基于javaweb+mysql的springboot在线学生选课系统(java+springboot+vue+maven+mysql)

最新推荐文章于 2024-10-05 12:07:50 发布

java毕业

最新推荐文章于 2024-10-05 12:07:50 发布

阅读量388

点赞数 11

文章标签： java mysql spring boot

本文链接：https://blog.csdn.net/m0_70122726/article/details/134656777

版权

基于javaweb+mysql的springboot在线学生选课系统(java+springboot+vue+maven+mysql)

私信源码获取及调试交流

运行环境

Java≥8、MySQL≥5.7、Node.js≥10

开发工具

后端：eclipse/idea/myeclipse/sts等均可配置运行

前端：WebStorm/VSCode/HBuilderX等均可

适用

课程设计，大作业，毕业设计，项目练习，学习演示等

功能说明

基于javaweb+mysql的SpringBoot在线学生选课系统(java+springboot+vue+maven+mysql)


管理员：

10001	123456

学生：

1803010028	123456

1803010039	123456

1803010045	123456

1803010046	123456

老师：

180014	123456

180019	123456

一、项目运行环境配置：

Jdk1.8 + Mysql + HBuilderX（Webstorm也行）+ Eclispe（IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持）。

项目技术：

Spring + SpringBoot+ mybatis + Maven + Vue 等等组成，B/S模式 + Maven管理等等。

        }
        // 情况二： 模糊查询
        if (!StringUtils.isEmpty(like) && StringUtils.isEmpty(kechengleixing) && StringUtils.isEmpty(xuefen)) {
            return studentUserDAO.SelectionLike(xuehao, like);
        }
        // 情况三： 学分
        if (!StringUtils.isEmpty(xuefen) && StringUtils.isEmpty(kechengleixing) && StringUtils.isEmpty(like)) {
            return studentUserDAO.SelectionXuefen(xuehao, Integer.valueOf(xuefen));
        }
        // 情况四： 课程类别
        if (!StringUtils.isEmpty(kechengleixing) && StringUtils.isEmpty(like) && StringUtils.isEmpty(xuefen)) {
            return studentUserDAO.SelectionLeixing(xuehao, kechengleixing);
        }
        // 情况五： 学分和模糊查询
        if (!StringUtils.isEmpty(xuefen) && !StringUtils.isEmpty(like) && StringUtils.isEmpty(kechengleixing)) {
            return studentUserDAO.SelectionXandLike(xuehao, Integer.valueOf(xuefen), like);
        }
        // 情况六：学分和课程类型
        if (!StringUtils.isEmpty(xuefen) && !StringUtils.isEmpty(kechengleixing) && StringUtils.isEmpty(like)) {
            return studentUserDAO.SelectionXandLeibie(xuehao, Integer.valueOf(xuefen), kechengleixing);
        }
        // 情况七： like 和 课程类型
        if (!StringUtils.isEmpty(like) && !StringUtils.isEmpty(kechengleixing) && StringUtils.isEmpty(xuefen)) {
            return studentUserDAO.SelectionLandLiebie(xuehao, like, kechengleixing);
        }
        // 情况八： like 学分 课程类型
        if (!StringUtils.isEmpty(like) && !StringUtils.isEmpty(xuefen) && !StringUtils.isEmpty(kechengleixing)) {
            return studentUserDAO.SelectionAll(xuehao, like, Integer.valueOf(xuefen), kechengleixing);
        }
        return null;
    }

    /**
     * 根据课程ID进行查询
     **/
    @Autowired
    CurriDAO curriDAO;

    @CrossOrigin

            jsobj.put("code", "200");
            jsobj.put("token", token);
            jsobj.put("teachername", teacherUser.getName());
            return jsobj.toString();
         }else {
            ResultCode result = new ResultCode(256);
            // 将获取的json数据封装一层，然后在给返回
            JSONObject jsobj = new JSONObject();
            jsobj.put("msg", "密码错误！");
            jsobj.put("code", "256");
            return jsobj.toString();
         }
      }
   }

   /**
    * 学生账户登录接口
    * ***/
   @Autowired
   StudentUserDAO studentUserDAO;
   @CrossOrigin
   @PostMapping(value = "/api/login_student")
   @ResponseBody
   // 学生用户的登录 api
   public Object login_student(@RequestBody StudentUser requestUser) throws Exception {
      Integer username = requestUser.getXuehao();
      StudentUser studentUser = studentUserDAO.findByXuehao(username);
      if (studentUser == null) {
         ResultCode result = new ResultCode(255);
         // 将获取的json数据封装一层，然后在给返回
         JSONObject jsobj = new JSONObject();
         jsobj.put("msg", "用户不存在！");
         jsobj.put("code", "255");
         return jsobj.toString();
      } else {
         if(MD5.verify(requestUser.getPassword(),studentUser.getPassword())) {
            String token = tokenService.getStudentToken(requestUser);
            ResultCode result = new ResultCode(200);
            // 将获取的json数据封装一层，然后在给返回
            JSONObject jsobj = new JSONObject();
            jsobj.put("msg", "登录成功！");


    /**
     * 学生自主选课，将选课信息添加到 选课信息表
     * **/
    /**
     * 添加学生用户信息
     **/
    @CrossOrigin
    @ResponseBody
    @PostMapping("/api/student/addsutclass")
    public SelectionModel addSelection(@RequestBody Map<String, Object> json) {
        String xuehao = String.valueOf(json.get("xuehao"));
        String kechengid = String.valueOf(json.get("kechengid"));
        SelectionModel selectionModel = new SelectionModel();
        selectionModel.setXuehao(Integer.valueOf(xuehao));
        selectionModel.setKechengid(Integer.valueOf(kechengid));
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        selectionModel.setCtime(df.format(new Date()));
        return selectionDAO.save(selectionModel);
    }

    /**
     * 根据当前登录的学生账号，获取该学生当前选择的学分情况，分为选修和必修
     ***/
    // 查找必修
    @CrossOrigin
    @PostMapping("/api/student/getxuefenbi/{zhanghao}")
    List<Map<String, Object>> getXueFenBi(@PathVariable("zhanghao") Integer zhanghao) {
        return selectionDAO.getXueFenBixiu(zhanghao);
    }

    // 查找必修
    @CrossOrigin
    @PostMapping("/api/student/getxuefenxuan/{zhanghao}")
    List<Map<String, Object>> getXueFenXuan(@PathVariable("zhanghao") Integer zhanghao) {
        return selectionDAO.getXueFenXuanxiu(zhanghao);
    }

        adminUser.setPassword(MD5.md5(adminUser.getPassword()));
        return adminUserDAO.saveAndFlush(adminUser);
    }

    /**
     * 添加教师用户信息
     **/
    @Autowired
    TeacherUserDAO teacherUserDAO;
    @Autowired
    CollegeDAO collegeDAO;

    @CrossOrigin
    @PostMapping("/api/admin/addtea")
    public TeacherUser saveTea(@RequestBody TeacherUser teacherUser) throws Exception {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        teacherUser.setCtime(df.format(new Date()));
        teacherUser.setPassword(MD5.md5(teacherUser.getPassword()));
        return teacherUserDAO.save(teacherUser);
    }

    /**
     * 对所有教师信息进行动态分页查询
     **/
    @Autowired
    UserService userService;

    @CrossOrigin
    @ResponseBody
    @PostMapping("/api/admin/tealist")
    public Page<TeacherUser> pageQuery(@RequestBody Map<String, Object> json) {
        Integer pageNum = Integer.valueOf((Integer) json.get("pageNum"));
        Integer pageSize = Integer.valueOf((Integer) json.get("pageSize"));
        String college = String.valueOf((String) json.get("college"));
        String major = String.valueOf(json.get("major"));
        String like = String.valueOf(json.get("query"));
        String sex = String.valueOf(json.get("sex"));
        Pageable pageable = PageRequest.of(pageNum - 1, pageSize);
        return userService.getTeaList(like, college, major, sex, pageable);
    }

    /**
     * 根据学号进行删除
     **/
    @Autowired
    StudentUserDAO studentUserDAO;

    @CrossOrigin
    @DeleteMapping("/api/admin/deletestu/{xuehao}")
    public Integer deleteStu(@PathVariable("xuehao") Integer xuehao) {

    @CrossOrigin
    @ResponseBody
    @PostMapping("/api/admin/getcollegeinfo/{collegeid}")
    public CollegeModel findCollegeByCid(@PathVariable("collegeid") Integer collegeid) {
        return collegeDAO.findByCollegeid(collegeid);
    }

    /**
     * 根据 collegeid 更新当前学院信息
     **/
    @CrossOrigin
    @PutMapping("/api/admin/updatecollege/{collegeid}")
    public CollegeModel updateCollegeUser(@PathVariable("collegeid") Integer collegeid, @RequestBody Map<String, Object> json) {
        String content = String.valueOf(json.get("content"));
        String collegename = String.valueOf(json.get("collegename"));
        CollegeModel collegeModel = new CollegeModel();
        collegeModel.setCollegeid(collegeid);
        collegeModel.setCollegename(collegename);
        collegeModel.setContent(content);
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        collegeModel.setCtime(df.format(new Date()));
        return collegeDAO.saveAndFlush(collegeModel);
    }

    /**
     * 添加学院信息
     **/
    @CrossOrigin
    @PostMapping("/api/admin/addcollege")
    public CollegeModel addCollegeUser(@RequestBody Map<String, Object> json) {
        String collegename = String.valueOf(json.get("collegename"));
        String content = String.valueOf(json.get("content"));
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        CollegeModel collegeModel = new CollegeModel();
        collegeModel.setContent(content);
        collegeModel.setCollegename(collegename);
        collegeModel.setCtime(df.format(new Date()));
        return collegeDAO.save(collegeModel);
    }

    /**
     * 根据学院 ID删除学院 信息
     **/
    @CrossOrigin

    @CrossOrigin
    @PutMapping("/api/student/updateselfpwd/{xuehao}")
    public StudentUser updateStuPwd(@PathVariable("xuehao") Integer xuehao, @RequestBody StudentUser studentUser) throws Exception {
        studentUser.setXuehao(xuehao);
        studentUser.setPassword(MD5.md5(studentUser.getPassword()));
        return studentUserDAO.saveAndFlush(studentUser);
    }

    /**
     * 获取当前学生账户所在班级的可选课程
     **/
    @CrossOrigin
    @ResponseBody
    @PostMapping("/api/sutdent/getselectionall")
    public List<Map<String, Object>> SelectionALLQuery(@RequestBody Map<String, Object> json) {
        String kechengleixing = String.valueOf(json.get("kechengleibie"));
        String like = String.valueOf(json.get("like"));
        Integer xuehao = Integer.valueOf((String) json.get("xuehao"));
        String xuefen = String.valueOf(json.get("xuefen"));

        // 情况一： 没有任何筛选条件
        if (StringUtils.isEmpty(kechengleixing) && StringUtils.isEmpty(like) && StringUtils.isEmpty(xuefen)) {
            return curriDAO.findCurriNo(xuehao);
        }
        // 情况二： 模糊查询
        if (!StringUtils.isEmpty(like) && StringUtils.isEmpty(kechengleixing) && StringUtils.isEmpty(xuefen)) {
            return curriDAO.findCurriLike(xuehao, like);
        }
        // 情况三： 学分
        if (!StringUtils.isEmpty(xuefen) && StringUtils.isEmpty(kechengleixing) && StringUtils.isEmpty(like)) {
            return curriDAO.findCurriXuefen(xuehao, Integer.valueOf(xuefen));
        }
        // 情况四： 课程类别
        if (!StringUtils.isEmpty(kechengleixing) && StringUtils.isEmpty(like) && StringUtils.isEmpty(xuefen)) {
            return curriDAO.findCurriLeixing(xuehao, kechengleixing);
        }
        // 情况五： 学分和模糊查询
        if (!StringUtils.isEmpty(xuefen) && !StringUtils.isEmpty(like) && StringUtils.isEmpty(kechengleixing)) {
            return curriDAO.findCurriXandLike(xuehao, like, Integer.valueOf(xuefen));
        }
        // 情况六：学分和课程类型
        if (!StringUtils.isEmpty(xuefen) && !StringUtils.isEmpty(kechengleixing) && StringUtils.isEmpty(like)) {
            return curriDAO.findCurriXandLeixing(xuehao, Integer.valueOf(xuefen), kechengleixing);
        }
        // 情况七： like 和 课程类型
        if (!StringUtils.isEmpty(like) && !StringUtils.isEmpty(kechengleixing) && StringUtils.isEmpty(xuefen)) {
            return curriDAO.findCurriLandLeibie(xuehao, like, kechengleixing);

            return jsonObject.toString();
        } else {
            if (resetPwdModel.getState_code() == 1) {
                JSONObject jsonObject = new JSONObject();
                // 验证码在有效期之内
                jsonObject.put("msg", "url验证通过！");
                jsonObject.put("code", "200");
                return jsonObject.toString();
            } else {
                // 验证码已经失效
                JSONObject jsonObject = new JSONObject();
                jsonObject.put("msg", "该链接已失效！请重新获取链接！");
                jsonObject.put("code", "256");
                return jsonObject.toString();
            }
        }
    }

//    @CrossOrigin
//    @PostMapping(value = "/api/resetpwd/checkstatus")
//    @ResponseBody
//    public Object checkStatus(@RequestBody Map<String, Object> json) {
//        Integer zhanghu = Integer.valueOf(String.valueOf(json.get("zhanghu")));
//        ResetPwdModel resetPwdModel = resetPwdDAO.findByZhanghu(zhanghu);
//        int state_code = resetPwdModel.getState_code();
//        String code = resetPwdModel.getCode();
//        if (state_code == 0) {
//            ResultCode result = new ResultCode(233);
//            // 将获取的json数据封装一层，然后在给返回
//            JSONObject jsobj = new JSONObject();
//            jsobj.put("msg", "当前链接已过期！");
//            jsobj.put("code", "233");
//            return jsobj.toString();
//        } else if (!String.valueOf(json.get("code")).equals(code)) {
//            ResultCode result = new ResultCode(233);
//            // 将获取的json数据封装一层，然后在给返回
//            JSONObject jsobj = new JSONObject();
//            jsobj.put("msg", "当前链接已过期或链接不正确！");
//            jsobj.put("code", "233");
//            return jsobj.toString();
//        } else {
//            ResultCode result = new ResultCode(200);
//            // 将获取的json数据封装一层，然后在给返回
//            JSONObject jsobj = new JSONObject();
//            jsobj.put("msg", "验证通过！");
//            jsobj.put("code", "200");
//            return jsobj.toString();
//        }
//    }

     * 获取选课信息 （有对课程名称进行模糊查询和对课程类型进行筛选条件）
     ***/
    @Autowired
    SelectionDAO selectionDAO;

    @CrossOrigin
    @ResponseBody
    @PostMapping("/api/teacher/getselection")
    public List<Map<String, Object>> SelectionQuery(@RequestBody Map<String, Object> json) {
        String kechengteacher = String.valueOf(json.get("kechengteacher"));
        String kechengname = String.valueOf(json.get("kechengname"));
        String kechengleibie = String.valueOf(json.get("kechengleibie"));

        // 情况一：没有筛选条件的情况
        if (StringUtils.isEmpty(kechengname) && StringUtils.isEmpty(kechengleibie)) {
            return selectionDAO.SelectionClass(kechengteacher);
        }
        // 情况二：筛选课程类型为必修，模糊查询没有
        if (StringUtils.isEmpty(kechengname) && kechengleibie.equals("必修")) {
            return selectionDAO.SelectionClassBixiu(kechengteacher);
        }
        // 情况三：筛选课程类型为选修，模糊查询没有
        if (StringUtils.isEmpty(kechengname) && kechengleibie.equals("选修")) {
            return selectionDAO.SelectionClassXuanxiu(kechengteacher);
        }
        // 情况四：有模糊查询条件，无课程类别筛选
        if (!StringUtils.isEmpty(kechengname) && StringUtils.isEmpty(kechengleibie)) {
            return selectionDAO.SelectionClassLike(kechengteacher, kechengname);
        }
        // 情况五：有模糊查询条件，课程类别筛选为 必修
        if (!StringUtils.isEmpty(kechengname) && kechengleibie.equals("必修")) {
            return selectionDAO.SelectionClassLikeBiXiu(kechengteacher, kechengname);
        }
        // 情况五：有模糊查询条件，课程类别筛选为 选修
        if (!StringUtils.isEmpty(kechengname) && kechengleibie.equals("选修")) {
            return selectionDAO.SelectionClassLikeXuanXiu(kechengteacher, kechengname);
        }
        return null;
    }

    /***
     *获取当前课程的所有选课学生
     * **/
    @CrossOrigin
    @GetMapping("/api/teacher/getallselection/{kechengid}")
    public List<Map<String, Object>> getAllSelection(@PathVariable("kechengid") Integer kechengid) {
        return studentUserDAO.getAllSelection(kechengid);
    }

    /**
     * 根据教师账户获取该教师所有信息

   UserService userService;
   @Autowired
   TokenService tokenService;
   @Autowired
   AdminUserDAO adminUserDAO;
   @CrossOrigin
   @PostMapping(value = "/api/login_admin")
   @ResponseBody
   public Object login_admin(@RequestBody AdminUser requestUser) throws Exception {
      Integer username = requestUser.getZhanghao();
      AdminUser adminUser = adminUserDAO.findByZhanghao(username);
      if (adminUser == null) {
         ResultCode result = new ResultCode(255);
         JSONObject jsonObject = new JSONObject();
         jsonObject.put("msg","用户不存在!");
         jsonObject.put("code","255");
         return jsonObject.toString();
      }else {
         if(MD5.verify(requestUser.getPassword(),adminUser.getPassword())) {
            String token = tokenService.getAdminToken(requestUser);
            ResultCode result = new ResultCode(200);
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("msg","登录成功！");
            jsonObject.put("code","200");
            jsonObject.put("token",token);
            jsonObject.put("adminname",adminUser.getName());
            return jsonObject.toString();
         }else {
            ResultCode result = new ResultCode(256);
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("msg","密码错误！");
            jsonObject.put("code","256");
            return jsonObject.toString();
         }
      }
   }

   /**
    * 教师账户登录接口
    * ***/
   @Autowired
   TeacherUserDAO teacherUserDAO;
   @CrossOrigin
   @PostMapping(value = "/api/login_teacher")
   @ResponseBody
   // 教师账户的登录 api
   public Object login_teacher(@RequestBody TeacherUser requestUser) throws Exception {
      Integer username = requestUser.getZhanghu();
      TeacherUser teacherUser = teacherUserDAO.findByZhanghu(username);
      if (teacherUser == null) {
         ResultCode result = new ResultCode(255);
         // 将获取的json数据封装一层，然后在给返回
         JSONObject jsobj = new JSONObject();
         jsobj.put("msg", "用户不存在！");

        AdminUser adminUser = adminUserDAO.findByZhanghaoAndEmail(Integer.valueOf(zhanghu), email);
        if (adminUser == null) {
            ResultCode result = new ResultCode(255);
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("msg", "账户和邮箱数据有误 !");
            jsonObject.put("code", "255");
            return jsonObject.toString();
        } else {
            adminUser.setPassword(MD5.md5(password));
            AdminUser adminUser1 = adminUserDAO.saveAndFlush(adminUser);
            if (adminUser1 == null) {
                ResultCode result = new ResultCode(255);
                JSONObject jsonObject = new JSONObject();
                jsonObject.put("msg", "重置密码失败!");
                jsonObject.put("code", "255");
                return jsonObject.toString();
            } else {
                ResultCode result = new ResultCode(255);
                JSONObject jsonObject = new JSONObject();
                jsonObject.put("msg", "重置密码成功!");
                jsonObject.put("code", "200");
                return jsonObject.toString();
            }
        }
    }

}

        banjiModel.setContent(content);
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        banjiModel.setCtime(df.format(new Date()));
        return banjiDAO.saveAndFlush(banjiModel);
    }

    /**
     * 添加班级信息
     **/
    @CrossOrigin
    @PostMapping("/api/admin/addbanji")
    public BanjiModel addBanjiUser(@RequestBody Map<String, Object> json) {
        String banjiname = (String) json.get("banjiname");
        String majorname = (String) json.get("majorname");
        String content = (String) json.get("content");
        // 获取 已知majorname 的 majorid
        MajorModel majorModel = majorDAO.findByMajorname(majorname);
        BanjiModel banjiModel = new BanjiModel();
        banjiModel.setBanjiname(banjiname);
        banjiModel.setMajorid(majorModel.getMajorid());
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        banjiModel.setCtime(df.format(new Date()));
        banjiModel.setContent(content);
        return banjiDAO.save(banjiModel);
    }

    /**
     * 添加专业信息
     **/
    @CrossOrigin
    @PostMapping("/api/admin/addmajor")
    public MajorModel addMajorUser(@RequestBody Map<String, Object> json) {
        String majorname = String.valueOf(json.get("majorname"));
        String collegename = String.valueOf(json.get("college"));
        String content = String.valueOf(json.get("content"));
        // 获取已知 collegename 的 collegeid
        CollegeModel collegeModel = collegeDAO.findByCollegename(collegename);
        MajorModel majorModel = new MajorModel();
        majorModel.setCollegeid(collegeModel.getCollegeid());
        majorModel.setMajorname(majorname);
        majorModel.setContent(content);
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        majorModel.setCtime(df.format(new Date()));
        return majorDAO.save(majorModel);
    }

    /**
     * 获取所有学院信息
     **/
    @CrossOrigin
    @ResponseBody

    /**
     * 根据课程ID进行查询
     **/
    @CrossOrigin
    @GetMapping("/api/teacher/getcurri/{kechengid}")
    public CurriModel getCurriInfo(@PathVariable("kechengid") Integer kechengid) {
        Optional<CurriModel> optional = Optional.ofNullable(curriDAO.findByKechengid(kechengid));
        return optional.orElseGet(CurriModel::new);
    }

    /**
     * 获取所有上课教室信息
     **/
    @Autowired
    ClassDAO classDAO;

    @CrossOrigin
    @GetMapping("/api/teacher/getclassroomall")
    public List<Object> getClassroomAll() {
        return classDAO.getByClassroom();
    }

    /***
     * 根据课程ID (kechengid) 进行更新
     * **/
    @CrossOrigin
    @PutMapping("/api/teacher/updatecurri/{kechengid}")
    public CurriModel updateCurri(@PathVariable("kechengid") Integer kechengid, @RequestBody CurriModel curriModel) {
        curriModel.setKechengid(kechengid);
        // 修改当前课程类型为必修，添加对应班级的选择该课程
        String leixing = curriModel.getKechengleibie();
        if (leixing.equals("必修")) {
            String[] list = curriModel.getOptionalclass().split(" ");
            String sqltext = "";
            for (int i = 0; i < list.length; i++) {
                Integer[] list1 = studentUserDAO.findByXhinBJ(list[i]);
                for (int j = 0; j < list1.length; j++) {
                    SelectionModel selectionModel = new SelectionModel();
                    selectionModel.setKechengid(kechengid);
                    selectionModel.setXuehao(list1[j]);
                    SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    selectionModel.setCtime(df.format(new Date()));
                    selectionDAO.save(selectionModel);
                }
            }

    }

    /**
     * 获取教师信息管理页面专业信息
     **/
    @CrossOrigin
    @GetMapping("/api/admin/getmajorgroup")
    public List<Object> findByMajorGroup() {
        return teacherUserDAO.getByMajorgroupjs();
    }

    /***
     * 根据 banjiid 获取当前班级的详细信息
     * **/
    @CrossOrigin
    @GetMapping("/api/admin/getbjbybjid/{banjiid}")
    public Map<String, Object> findByBJByBJid(@PathVariable("banjiid") Integer banjiid) {
        return banjiDAO.findByBanjiidA(banjiid);
    }

    /**
     * 根据 banjiid 更新当前班级信息
     **/
    @CrossOrigin
    @PutMapping("/api/admin/updatebanji/{banjiid}")
    public BanjiModel updateBanjiUser(@PathVariable("banjiid") Integer banjiid, @RequestBody Map<String, Object> json) {
        String banjiname = (String) json.get("banjiname");
        String majorname = (String) json.get("majorname");
        String content = (String) json.get("content");
        // 获取 已知majorname 的 majorid
        MajorModel majorModel = majorDAO.findByMajorname(majorname);
        Integer majorid = majorModel.getMajorid();
        BanjiModel banjiModel = new BanjiModel();
        banjiModel.setBanjiid(banjiid);
        banjiModel.setBanjiname(banjiname);
        banjiModel.setMajorid(majorid);
        banjiModel.setContent(content);
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        banjiModel.setCtime(df.format(new Date()));
        return banjiDAO.saveAndFlush(banjiModel);

        String content = (String) json.get("content");
        // 获取 已知majorname 的 majorid
        MajorModel majorModel = majorDAO.findByMajorname(majorname);
        Integer majorid = majorModel.getMajorid();
        BanjiModel banjiModel = new BanjiModel();
        banjiModel.setBanjiid(banjiid);
        banjiModel.setBanjiname(banjiname);
        banjiModel.setMajorid(majorid);
        banjiModel.setContent(content);
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        banjiModel.setCtime(df.format(new Date()));
        return banjiDAO.saveAndFlush(banjiModel);
    }

    /**
     * 添加班级信息
     **/
    @CrossOrigin
    @PostMapping("/api/admin/addbanji")
    public BanjiModel addBanjiUser(@RequestBody Map<String, Object> json) {
        String banjiname = (String) json.get("banjiname");
        String majorname = (String) json.get("majorname");
        String content = (String) json.get("content");
        // 获取 已知majorname 的 majorid
        MajorModel majorModel = majorDAO.findByMajorname(majorname);
        BanjiModel banjiModel = new BanjiModel();
        banjiModel.setBanjiname(banjiname);
        banjiModel.setMajorid(majorModel.getMajorid());
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        banjiModel.setCtime(df.format(new Date()));
        banjiModel.setContent(content);
        return banjiDAO.save(banjiModel);
    }

    /**
     * 添加专业信息
     **/
    @CrossOrigin


    /**
     * 根据选课表的ID进行删除指定ID的记录
     **/
    @Autowired
    SelectionDAO selectionDAO;

    @CrossOrigin
    @DeleteMapping("/api/student/deleteselection/{id}")
    public Integer deleteSelection(@PathVariable("id") Integer id) {
        return selectionDAO.deleteById1(id);
    }

    /**
     * 根据学号获取该生的选课信息，用于生成课程表
     **/
    @CrossOrigin
    @GetMapping("/api/student/getkechengbiao/{xuehao}")
    public List<Map<String, Object>> getKeChengBiaoInfo(@PathVariable("xuehao") Integer xuehao) {
        return selectionDAO.getkechengbiao(xuehao);
    }

    /***
     * 获取当前账户的学生个人信息
     * **/
    @CrossOrigin
    @GetMapping("/api/student/getself/{xuehao}")
    public StudentUser getStuSelf(@PathVariable("xuehao") Integer xuehao) {
        Optional<StudentUser> optional = Optional.ofNullable(studentUserDAO.findByXuehao(xuehao));
        return optional.orElseGet(StudentUser::new);
    }

    /**
     * 根据账户信息进行基本信息更新
     **/
    @CrossOrigin
    @PutMapping("/api/student/updateself/{xuehao}")
    public StudentUser updateStuSelf(@PathVariable("xuehao") Integer xuehao, @RequestBody StudentUser studentUser) {
        studentUser.setXuehao(Integer.valueOf(xuehao));
        return studentUserDAO.saveAndFlush(studentUser);
    }

    /**

        // 是数字
        if (k == 1) {
            // 获取当前collegeid 的 collegename
            collegeModel = collegeDAO.findByCollegeid(Integer.valueOf(collegeid));
        } else {
            // 不是数字
            collegeModel = collegeDAO.findByCollegename(collegeid);
        }
        majorModel.setCollegeid(collegeModel.getCollegeid());
        majorModel.setCtime(df.format(new Date()));
        return majorDAO.saveAndFlush(majorModel);
    }

    /**
     * 获取所有教室信息，，仅一个 like
     **/
    @Autowired
    ClassDAO classDAO;

    @CrossOrigin
    @ResponseBody
    @PostMapping({"/api/admin/getallrooms", "/api/admin/getallcr"})
    public List<Classroom> findAllRooms(@RequestBody Map<String, Object> json) {
        String like1 = String.valueOf(json.getOrDefault("like",""));
        String like2 = String.valueOf(json.getOrDefault("query",""));
        return classDAO.findAllRooms(like1+like2);
    }

    /**
     * 获取每个学院的学生和教师人数数量
     **/
    @CrossOrigin
    @ResponseBody
    @GetMapping("/api/admin/getnums")
    public List<Map<String, Object>> getAllNums() {
        return collegeDAO.getAllNums();
    }

    @PostMapping("/api/teacher/addcurri")
    public CurriModel saveCurri(@RequestBody CurriModel curriModel) {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        curriModel.setCtime(df.format(new Date()));
        CurriModel curriModel1 = curriDAO.save(curriModel);
        Integer kechengid = curriModel1.getKechengid();
        // 修改当前课程类型为必修，添加对应班级的选择该课程
        String leixing = curriModel.getKechengleibie();
        if (leixing.equals("必修")) {
            String[] list = curriModel.getOptionalclass().split(" ");
            String sqltext = "";
            for (int i = 0; i < list.length; i++) {
                Integer[] list1 = studentUserDAO.findByXhinBJ(list[i]);
                for (int j = 0; j < list1.length; j++) {
                    SelectionModel selectionModel = new SelectionModel();
                    selectionModel.setKechengid(kechengid);
                    selectionModel.setXuehao(list1[j]);
                    selectionModel.setCtime(df.format(new Date()));
                    selectionDAO.save(selectionModel);
                }
            }
        }
        return curriModel1;
    }

    /**
     * 获取选课信息 （有对课程名称进行模糊查询和对课程类型进行筛选条件）
     ***/
    @Autowired
    SelectionDAO selectionDAO;

    @CrossOrigin
    @ResponseBody
    @PostMapping("/api/teacher/getselection")
    public List<Map<String, Object>> SelectionQuery(@RequestBody Map<String, Object> json) {
        String kechengteacher = String.valueOf(json.get("kechengteacher"));
        String kechengname = String.valueOf(json.get("kechengname"));
        String kechengleibie = String.valueOf(json.get("kechengleibie"));

        // 情况一：没有筛选条件的情况
        if (StringUtils.isEmpty(kechengname) && StringUtils.isEmpty(kechengleibie)) {
            return selectionDAO.SelectionClass(kechengteacher);
        }
        // 情况二：筛选课程类型为必修，模糊查询没有
        if (StringUtils.isEmpty(kechengname) && kechengleibie.equals("必修")) {
            return selectionDAO.SelectionClassBixiu(kechengteacher);
        }
        // 情况三：筛选课程类型为选修，模糊查询没有
        if (StringUtils.isEmpty(kechengname) && kechengleibie.equals("选修")) {
            return selectionDAO.SelectionClassXuanxiu(kechengteacher);
        }
        // 情况四：有模糊查询条件，无课程类别筛选