基于javaweb+mysql的springboot基于遗传算法学校排课系统(java+springboot+maven+mybatis+vue+mysql)

基于javaweb+mysql的springboot基于遗传算法学校排课系统(java+springboot+maven+mybatis+vue+mysql)

运行环境

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

开发工具

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

前端：WebStorm/VSCode/HBuilderX等均可

适用

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

功能说明

基于javaweb+mysql的SpringBoot基于遗传算法学校排课系统(java+springboot+maven+mybatis+vue+mysql)

一、项目简述本系统功能包括： 排课管理，课程管理，讲师管理，班级管理，学生管理，教学资料，学习文档，在线测试，教材列表，教学设计，帮助中心等等功能。

二、项目运行 环境配置：

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

项目技术：

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

        System.out.println("gradeNo = " + gradeNo);
        Map<String, Object> map = new HashMap();
        List<ClassInfoVO> classInfoVOS = null;
        if (gradeNo.equals("")) {
            classInfoVOS = classInfoDao.queryClassInfos((page - 1) * limit, limit);
            int total = classInfoDao.count2();
            map.put("records", classInfoVOS);
            map.put("total", total);
        } else {
            classInfoVOS = classInfoDao.queryClassInfo((page - 1) * limit, limit, gradeNo);
            int total = classInfoDao.count1(gradeNo);
            map.put("records", classInfoVOS);
            map.put("total", total);
        }
        return ServerResponse.ofSuccess(map);
    }

    // TODO 编辑班级

    // TODO 删除班级

    /**
     * 添加班级
     * @param classAddVO
     * @return
     */
    @PostMapping("/addclassinfo")
    public ServerResponse addClass(@RequestBody ClassAddVO classAddVO) {
        System.out.println(classAddVO);
        ClassInfo c = new ClassInfo();
        c.setRemark(classAddVO.getGradeNo());
        c.setClassNo(classAddVO.getClassNo());
        c.setClassName(classAddVO.getClassName());
        c.setTeacher(classAddVO.getId());
        c.setNum(classAddVO.getNum());
        boolean b = classInfoService.save(c);
        if (b) {
            return ServerResponse.ofSuccess("添加班级成功");
        }
        return ServerResponse.ofError("添加班级失败");
    }

    /**
     * 上传讲师证件
     * @param id
     * @param file
     * @return
     */
    @PostMapping("/upload/{id}")
    public ServerResponse uploadLicense(@PathVariable("id") Integer id, MultipartFile file) {
        Map<String, Object> map = AliyunUtil.upload(file, "license");
        String license = (String) map.get("url");
        Teacher t = teacherService.getById(id);
        t.setLicense(license);
        boolean b = teacherService.updateById(t);
        if (b) {
            return ServerResponse.ofSuccess("上传证件成功");
        }
        return ServerResponse.ofError("上传证件失败");
    }

    /**
     * 讲师登录
     * @param userLoginRequest
     * @return
     */
    @PostMapping("/login")
    public ServerResponse teacherLogin(@RequestBody UserLoginRequest userLoginRequest) {
        Map<String, Object> map = new HashMap<>();
        QueryWrapper<Teacher> wrapper = new QueryWrapper<>();
        wrapper.eq("teacher_no", userLoginRequest.getUsername());
        // 先查询是否有该账号
        Teacher teacher2 = teacherService.getOne(wrapper);
        if (teacher2 == null) {
            return ServerResponse.ofError("账号不存在");
        } else if (teacher2.getStatus() != 0) {
            return ServerResponse.ofError("账号状态异常，请联系管理员");
        }
        // 登录,使用编号登录
        Teacher teacher = teacherService.teacherLogin(userLoginRequest.getUsername(), userLoginRequest.getPassword());

     * @return
     */
    @DeleteMapping("/delete/{id}")
    public ServerResponse deleteClassroomById(@PathVariable("id") Integer id) {
        boolean b = classroomService.removeById(id);
        if (b) {
            return ServerResponse.ofSuccess("删除成功");
        }
        return ServerResponse.ofError("删除失败");
    }

    /**
     * 根据id查询教室
     * @param id
     * @return
     */
    @GetMapping("/query/{id}")
    public ServerResponse queryClassroomByID(@PathVariable("id") Integer id) {

        return ServerResponse.ofSuccess(classroomService.getById(id));
    }

    /**
     * 更新教室
     * @param classroom
     * @return
     */
    @PostMapping("/modify")
    public ServerResponse modifyClassroom(@RequestBody Classroom classroom) {

        return classroomService.updateById(classroom) ? ServerResponse.ofSuccess("更新成功") : ServerResponse.ofError("更新失败");
    }

}

package com.lyk.coursearrange.controller;

/**
 * 网课名称，每一个网课下面有1到多个视频

    }

    /**
     * 根据姓名关键字搜索讲师
     * @return
     */
    @GetMapping("/search/{page}/{keyword}")
    public ServerResponse searchTeacher(@PathVariable("keyword") String keyword, @PathVariable("page") Integer page,
                                        @RequestParam(defaultValue = "10") Integer limit) {
        QueryWrapper<Teacher> wrapper = new QueryWrapper<>();
        wrapper.orderByDesc("update_time");
        wrapper.like(!StringUtils.isEmpty(keyword), "realname", keyword);
        Page<Teacher> pages = new Page<>(page, limit);
        IPage<Teacher> iPage = teacherService.page(pages, wrapper);
        if (page != null) {
            return ServerResponse.ofSuccess(iPage);
        }
        return ServerResponse.ofError("查询失败!");
    }

    /**
     * 管理员根据ID删除讲师
     * @return
     */
    @DeleteMapping("/delete/{id}")
    public ServerResponse deleteTeacher(@PathVariable Integer id) {
        boolean b = teacherService.removeById(id);
        if(b) {
            return ServerResponse.ofSuccess("删除成功！");
        }
        return ServerResponse.ofError("删除失败！");
    }

    /**
     * 用于给讲师生成讲师编号,返回一个讲师编号
     * @return
     */
    @GetMapping("/no")
    public ServerResponse getTeacherNo() {

        List<Teacher> teacherList = teacherService.list(new QueryWrapper<Teacher>().select().orderByDesc("teacher_no"));

        // 返回最大编号的讲师编号再+1给新添加的讲师
        return ServerResponse.ofSuccess(teacherList.get(0).getTeacherNo());
    }

    /**
     * 管理员添加讲师,默认密码是123456
     * @param t
     * @return
     */
    @PostMapping("/add")
    public ServerResponse addTeacher(@RequestBody TeacherAddRequest t) {

}
package com.lyk.coursearrange.controller;

/**
 */
@RestController
public class ClassTaskController {

    Logger log = LoggerFactory.getLogger(ClassTaskController.class);

    @Autowired
    private ClassTaskService classTaskService;

    /**
     * 查询开课任务
     */
    @GetMapping("/classtask/{page}/{semester}")
    public ServerResponse queryClassTask(@PathVariable("page") Integer page,
                                         @PathVariable("semester") String semester,
                                         @RequestParam(defaultValue = "10") Integer limit) {
        Page<ClassTask> pages = new Page<>(page, limit);
        QueryWrapper<ClassTask> wrapper = new QueryWrapper<ClassTask>().eq("semester", semester);
        IPage<ClassTask> ipage = classTaskService.page(pages, wrapper);

        if (ipage != null) {
            return ServerResponse.ofSuccess(ipage);
        }
        return ServerResponse.ofError("查询开课任务失败！");
    }

    @Autowired
    private StudentService studentService;

    @Autowired
    private TokenService tokenService;

    /**
     *  学生加入班级，只有加入班级后才可以看到本班的课表，文档
     * @param id 学生id
     * @param classNo 班级编号
     * @return
     */
    @PostMapping("/join/{id}/{classNo}")
    public ServerResponse joinClass(@PathVariable("id") Integer id, @PathVariable("classNo") String classNo) {
        // TODO 学生加入年级，学生查看本班的文档(文档控制器中),查看自己所在的班级课表
        Student student = studentService.getById(id);
        student.setClassNo(classNo);
        boolean b = studentService.saveOrUpdate(student);
        if (b) {
            return ServerResponse.ofSuccess("加入班级成功");
        }
        return ServerResponse.ofError("加入班级失败");
    }

    /**
     * 学生登录
     * @param studentLoginRequest
     * @return
     */
    @PostMapping("/login")
    public ServerResponse studentLogin(@RequestBody StudentLoginRequest studentLoginRequest) {
        Map<String, Object> map = new HashMap<>();
        // 先判断是否有该学号，该学生
        QueryWrapper<Student> wrapper = new QueryWrapper<Student>().eq("student_no", studentLoginRequest.getUsername());
        // 查询是否有该学生
        Student student2 = studentService.getOne(wrapper);

        if (student2 == null) {
            return ServerResponse.ofError("学生账号不存在!");

            OutputStream os = response.getOutputStream();
            int i = bis.read(buffer);
            while (i != -1) {
                os.write(buffer, 0, i);
                i = bis.read(buffer);
            }
            log.info("文件下载成功");
        }
        catch (Exception e) {
            e.printStackTrace();
            log.info("文件下载失败: " + e.getMessage());
        } finally {
            if (bis != null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 如果没有模板文件就创建模板文件
     */
    private void createTemplate() {
        ExportParams params = new ExportParams();
        params.setTitle("课程任务导入模板(请严格对照数据库信息填写)");
        params.setSheetName("课程任务模板");
        List<ClassTask> list = new ArrayList();
        Workbook workbook = ExcelExportUtil.exportExcel(params, ClassTask.class, list);
        try {
            // 输出模板到本地
            FileOutputStream fos = new FileOutputStream("D:/arrange/excel/课程任务导入模板.xls");
            workbook.write(fos);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

/**
 * description: 教材信息
 */
@RestController
@RequestMapping("/courseinfo")
public class CourseInfoController {

    @Autowired
    private CourseInfoService cis;

    /**
     * 分页查询所有的教材信息
     * @param page
     * @param limit
     * @return
     */
    @GetMapping("/{page}")
    public ServerResponse queryCourseInfo(@PathVariable("page") Integer page,
                                          @RequestParam(defaultValue = "10") Integer limit) {

        Page<CourseInfo> pages = new Page<>(page, limit);
        QueryWrapper<CourseInfo> wrapper = new QueryWrapper<CourseInfo>().orderByAsc("course_no");
        IPage<CourseInfo> ipage = cis.page(pages, wrapper);
        return ServerResponse.ofSuccess(ipage);
    }

    /**
     * 添加教材信息
     * @param cinfo
     * @return
     */
    @PostMapping("/add")
    public ServerResponse addCourseInfo(@RequestBody CourseInfo cinfo) {
        boolean b = cis.saveOrUpdate(cinfo);
        if (b) {
            return ServerResponse.ofSuccess("添加成功");
        }
        return ServerResponse.ofError("添加失败");
    }

    }

}
package com.lyk.coursearrange.controller;

/**
 */
@RestController
@RequestMapping("/admin")
public class AdminController {

    @Autowired
    private AdminService adminService;
    @Autowired
    private TeacherService teacherService;
    @Autowired
    private TokenService tokenService;

    /**
     * 管理员登录

    }

    /**
     * 分页查询讲师
     * @param page
     * @param limit
     * @return
     */
    @GetMapping("/query/{page}")
    public ServerResponse queryTeacher(@PathVariable(value = "page") Integer page,
                                       @RequestParam(defaultValue = "10") Integer limit) {
        Page<Teacher> pages = new Page<>(page, limit);
        QueryWrapper<Teacher> wrapper = new QueryWrapper<Teacher>().orderByDesc("teacher_no");
        IPage<Teacher> iPage = teacherService.page(pages, wrapper);
        return ServerResponse.ofSuccess(iPage);
    }

    /**
     * 根据姓名关键字搜索讲师
     * @return
     */
    @GetMapping("/search/{page}/{keyword}")
    public ServerResponse searchTeacher(@PathVariable("keyword") String keyword, @PathVariable("page") Integer page,
                                        @RequestParam(defaultValue = "10") Integer limit) {
        QueryWrapper<Teacher> wrapper = new QueryWrapper<>();
        wrapper.orderByDesc("update_time");
        wrapper.like(!StringUtils.isEmpty(keyword), "realname", keyword);
        Page<Teacher> pages = new Page<>(page, limit);
        IPage<Teacher> iPage = teacherService.page(pages, wrapper);
        if (page != null) {
            return ServerResponse.ofSuccess(iPage);
        }
        return ServerResponse.ofError("查询失败!");
    }

    /**
     * 管理员根据ID删除讲师
     * @return
     */
    @DeleteMapping("/delete/{id}")
    public ServerResponse deleteTeacher(@PathVariable Integer id) {
        boolean b = teacherService.removeById(id);
        if(b) {
            return ServerResponse.ofSuccess("删除成功！");
        }
        return ServerResponse.ofError("删除失败！");
    }

                                        @RequestParam(defaultValue = "10") Integer limit) {
        QueryWrapper<Teacher> wrapper = new QueryWrapper<>();
        wrapper.orderByDesc("update_time");
        wrapper.like(!StringUtils.isEmpty(keyword), "realname", keyword);
        Page<Teacher> pages = new Page<>(page, limit);
        IPage<Teacher> iPage = teacherService.page(pages, wrapper);
        if (page != null) {
            return ServerResponse.ofSuccess(iPage);
        }
        return ServerResponse.ofError("查询失败!");
    }

    /**
     * 管理员根据ID删除讲师
     * @return
     */
    @DeleteMapping("/delete/{id}")
    public ServerResponse deleteTeacher(@PathVariable Integer id) {
        boolean b = teacherService.removeById(id);
        if(b) {
            return ServerResponse.ofSuccess("删除成功！");
        }
        return ServerResponse.ofError("删除失败！");
    }

    /**
     * 用于给讲师生成讲师编号,返回一个讲师编号
     * @return
     */
    @GetMapping("/no")
    public ServerResponse getTeacherNo() {

        List<Teacher> teacherList = teacherService.list(new QueryWrapper<Teacher>().select().orderByDesc("teacher_no"));

        // 返回最大编号的讲师编号再+1给新添加的讲师
        return ServerResponse.ofSuccess(teacherList.get(0).getTeacherNo());
    }

    /**
     * 管理员添加讲师,默认密码是123456
     * @param t

        c.setCapacity(car.getCapacity());
        c.setClassroomNo(car.getClassroomNo());
        c.setTeachbuildNo(car.getTeachbuildNo());
        c.setClassroomName(car.getClassroomName());
        c.setRemark(car.getRemark());
        boolean b = classroomService.save(c);
        if (b) {
            return ServerResponse.ofSuccess("添加成功");
        }
        return ServerResponse.ofError("添加失败");
    }

    /**
     * 删除教室
     * @param id
     * @return
     */
    @DeleteMapping("/delete/{id}")
    public ServerResponse deleteClassroomById(@PathVariable("id") Integer id) {
        boolean b = classroomService.removeById(id);
        if (b) {
            return ServerResponse.ofSuccess("删除成功");
        }
        return ServerResponse.ofError("删除失败");
    }

    /**
     * 根据id查询教室
     * @param id
     * @return
     */
    @GetMapping("/query/{id}")
    public ServerResponse queryClassroomByID(@PathVariable("id") Integer id) {

        return ServerResponse.ofSuccess(classroomService.getById(id));
    }

    /**
     * 更新教室
     * @param classroom
     * @return
     */
    @PostMapping("/modify")
    public ServerResponse modifyClassroom(@RequestBody Classroom classroom) {

        return classroomService.updateById(classroom) ? ServerResponse.ofSuccess("更新成功") : ServerResponse.ofError("更新失败");
    }

}

        // 得到已经使用了的教室编号
        Set<String> usedClaassroom = new HashSet<>();
        for (int i = 0; i < coursePlanList.size(); i++) {
            // 截取占用的教室所属编号前两位，即教学楼编号
            if (teachbuildNo.equals(coursePlanList.get(i).getClassroomNo().substring(0, 2))) {
                usedClaassroom.add(coursePlanList.get(i).getClassroomNo());
            }
        }

        QueryWrapper<Classroom> wrapper2 = new QueryWrapper();
        wrapper2.in("classroom_no", usedClaassroom);
        wrapper2.orderByAsc("classroom_no");

        List<Classroom> used = classroomService.list(wrapper2);
        // 取差
        Set<Classroom> newList = getSub(allClassroom, used);

        return ServerResponse.ofSuccess(newList);
    }

    /**
     * 集合取差
     * @param list1
     * @param list2
     * @return
     */
    private Set<Classroom> getSub(List<Classroom> list1, List<Classroom> list2) {
        Set<Classroom> newList = new HashSet<>();
        for (int i = 0; i <list1.size(); i++) {
            //遍历集合2，判断集合1中是否包含集合2中元素，若包含，则把这个共同元素加入新集合中
            for (int j = 0; j <list2.size(); j++) {
                if (!(list1.get(i).equals(list2.get(j)) || list1.get(i) == list2.get(j))) {
                    newList.add(list1.get(i));
                }
            }
        }
        return newList;
    }

    /**
     * 带分页显示教室列表
     * @return
     */
    @GetMapping("/{page}")
    public ServerResponse queryClassroom(@PathVariable("page")Integer page,
                                         @RequestParam(defaultValue = "10")Integer limit) {
        Page<Classroom> pages = new Page<>(page, limit);
        QueryWrapper<Classroom> wrapper = new QueryWrapper<Classroom>().orderByAsc("classroom_no");

        IPage<Classroom> ipage = classroomService.page(pages, wrapper);

    @GetMapping("/get/{id}")
    public ServerResponse getAllVideo(@PathVariable("id") Integer id) {
        return ServerResponse.ofSuccess(ovs.list( new QueryWrapper<OnlineVideo>().eq("online_course_id", id)));
    }

    /**
     * 上传视频并返回url和文件名到前端
     * @return
     */
    @PostMapping("/upload")
    public ServerResponse upload(MultipartFile file) {
        Map<String, Object> map = AliyunUtil.upload(file, null);
        if (map != null) {
            return ServerResponse.ofSuccess(map);
        }
        return ServerResponse.ofError("视频上传失败");
    }

    /**
     * 上传新视频
     * @param
     * @return
     */
    @PostMapping("/add")
    public ServerResponse addVideo(MultipartFile file, @RequestBody UserInfoVO u) {
        Map<String, Object> map = new HashMap();
//        map = AliyunUtil.upload(file, null);
        OnlineVideo onlineVideo = new OnlineVideo();
        // 所属课程的id
        onlineVideo.setOnlineCourseId(u.getCourseId());
        onlineVideo.setVideoName(u.getVideoName());
        onlineVideo.setVideoUrl(u.getVideoUrl());
        onlineVideo.setCover(u.getCover());

//        onlineVideo.setVideoUrl(map.get("url").toString());
//        onlineVideo.setVideoName(map.get("name").toString());
        onlineVideo.setVideoNo(u.getVideoNo()); // 视频编号
        onlineVideo.setFromUserType(u.getUserType());
        onlineVideo.setFromUserId(u.getId());
        onlineVideo.setFromUserName(u.getRealname());

        boolean b = ovs.save(onlineVideo);
        if (b) {
            return ServerResponse.ofSuccess("添加视频成功");
        }
        return ServerResponse.ofError("添加视频失败");
    }

    /**
     * 根据id删除视频
     * @param id
     * @return
     */

     */
    @PostMapping("/password")
    public ServerResponse updatePass(@RequestBody PasswordVO passwordVO) {
        QueryWrapper<Teacher> wrapper = new QueryWrapper();
        wrapper.eq("id", passwordVO.getId());
        wrapper.eq("password", passwordVO.getOldPass());
        Teacher teacher = teacherService.getOne(wrapper);
        if (teacher == null) {
            return ServerResponse.ofError("旧密码错误");
        }
        // 否则进入修改密码流程
        teacher.setPassword(passwordVO.getNewPass());
        boolean b = teacherService.updateById(teacher);
        if (b) {
            return ServerResponse.ofSuccess("密码修改成功");
        }
        return ServerResponse.ofError("密码更新失败");
    }

    /**
     * 查询所有讲师
     * @return
     */
    @GetMapping("/all")
    public ServerResponse getAllTeacher() {

        return ServerResponse.ofSuccess(teacherService.list());
    }

}

package com.lyk.coursearrange.controller;

    public ServerResponse getTeacherNo() {

        List<Teacher> teacherList = teacherService.list(new QueryWrapper<Teacher>().select().orderByDesc("teacher_no"));

        // 返回最大编号的讲师编号再+1给新添加的讲师
        return ServerResponse.ofSuccess(teacherList.get(0).getTeacherNo());
    }

    /**
     * 管理员添加讲师,默认密码是123456
     * @param t
     * @return
     */
    @PostMapping("/add")
    public ServerResponse addTeacher(@RequestBody TeacherAddRequest t) {
        Teacher teacher = new Teacher();
        teacher.setTeacherNo(t.getTeacherNo());
        teacher.setUsername(t.getUsername());
        teacher.setEmail(t.getEmail());
        // 每一个新增的讲师密码默认是123456
        teacher.setPassword("123456");
        teacher.setRealname(t.getRealname());
        teacher.setJobtitle(t.getJobtitle());
        teacher.setTeach(t.getTeach());
        teacher.setTelephone(t.getTelephone());
        teacher.setAddress(t.getAddress());
        teacher.setAge(t.getAge());
        boolean b = teacherService.save(teacher);
        if (b) {
            return ServerResponse.ofSuccess("添加讲师成功！");
        }
        return ServerResponse.ofError("添加讲师失败！");
    }

    /**
     * 根据ID封禁、解封讲师账号，状态为0时正常，1时封禁
     * @param id
     * @return
     */
    @GetMapping("/lock/{id}")
    public ServerResponse lockTeacher(@PathVariable("id") Integer id) {

        // 先查出来再修改，
        Teacher teacher = teacherService.getById(id);
        // 修改
        if (teacher.getStatus() == 0) {

        QueryWrapper wrapper = new QueryWrapper();
        // 查询父id为0的类别，即一级分类
        wrapper.eq("parent_id", 0);
        List<OnlineCategory> list = ocs.list(wrapper);
        return ServerResponse.ofSuccess(list);
    }

    /**
     * 查询每个类别下面的二级类别
     * @param id 一级分类id
     * @return
     */
    @GetMapping("/two/{id}")
    public ServerResponse queryTwo(@PathVariable("id") Integer id) {
        QueryWrapper wrapper = new QueryWrapper();
        // 该id下面的二级分类
        wrapper.eq("parent_id", id);
        List<OnlineCategory> list = ocs.list(wrapper);
        return ServerResponse.ofSuccess(list);
    }

    /**
     * 点击添加类别的时候请求这个接口给前端返回一个编号
     * @return
     */
    @GetMapping("/get-no")
    public ServerResponse getNo() {
        QueryWrapper<OnlineCategory> wrapper = new QueryWrapper<OnlineCategory>().select("category_no").orderByDesc();
        List<OnlineCategory> list = ocs.list(wrapper);
        String no = String.valueOf(Integer.parseInt(list.get(0).getCategoryNo()) + 1);
        System.out.println("no = " + no);
        // 返回自动生成的编号，从res.data.message中获取
        return ServerResponse.ofSuccess(no);
    }

}

package com.lyk.coursearrange.controller;

        boolean b = teachBuildInfoService.removeById(id);
        if (b) {
            return ServerResponse.ofSuccess("删除成功");
        }
        return ServerResponse.ofError("删除失败");
    }

    /**
     * 添加教学楼
     * @param t
     * @return
     */
    @PostMapping("/add")
    public ServerResponse addTeachbuilding(@RequestBody TeachbuildAddRequest t) {
        System.out.println(t);
        TeachbuildInfo t1 = new TeachbuildInfo();
        t1.setTeachBuildNo(t.getTeachBuildNo());
        t1.setTeachBuildName(t.getTeachBuildName());
        t1.setTeachBuildLocation(t.getTeachBuildLocation());
        boolean b = teachBuildInfoService.save(t1);
        if (b) {
            return ServerResponse.ofSuccess("添加成功");
        }
        return ServerResponse.ofError("添加失败");
    }

    /**
     * 根据id查询
     * @param id
     * @return
     */
    @GetMapping("/select/{id}")
    public ServerResponse queryTeachBuildingById(@PathVariable("id") Integer id) {

        return ServerResponse.ofSuccess(teachBuildInfoService.getById(id));
    }

    /**
     * 更新教学楼
     * @param t
     * @return
     */
    @PostMapping("/modify/{id}")

/**
 * @Descripe: 拦截器
 */
public class AuthenticationInterceptor implements HandlerInterceptor {

    @Autowired
    private AdminService adminService;

    @Autowired
    private StudentService studentService;

    @Autowired
    private TeacherService teacherService;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 从 http 请求头中取出 token
        String token = request.getHeader("token");

        // 如果不是映射到方法直接通过
        if(!(handler instanceof HandlerMethod)){
            return true;
        }
        HandlerMethod handlerMethod = (HandlerMethod)handler;
        Method method = handlerMethod.getMethod();
        //检查是否有passtoken注释，有则跳过认证
        if (method.isAnnotationPresent(PassToken.class)) {
            PassToken passToken = method.getAnnotation(PassToken.class);
            if (passToken.required()) {
                return true;
            }
        }

        //检查有没有需要用户权限的注解

/**
 */
@RestController
@RequestMapping("/onlinevideo")
public class OnlineVideoController {

    @Autowired
    private OnlineVideoService ovs;

    /**
     * 根据课程id获取课程包含的视频
     * @param id
     * @return
     */
    @GetMapping("/get/{id}")
    public ServerResponse getAllVideo(@PathVariable("id") Integer id) {
        return ServerResponse.ofSuccess(ovs.list( new QueryWrapper<OnlineVideo>().eq("online_course_id", id)));
    }

    /**
     * 上传视频并返回url和文件名到前端
     * @return
     */
    @PostMapping("/upload")
    public ServerResponse upload(MultipartFile file) {
        Map<String, Object> map = AliyunUtil.upload(file, null);
        if (map != null) {
            return ServerResponse.ofSuccess(map);
        }
        return ServerResponse.ofError("视频上传失败");
    }

    /**

            int total = classInfoDao.count1(gradeNo);
            map.put("records", classInfoVOS);
            map.put("total", total);
        }
        return ServerResponse.ofSuccess(map);
    }

    // TODO 编辑班级

    // TODO 删除班级

    /**
     * 添加班级
     * @param classAddVO
     * @return
     */
    @PostMapping("/addclassinfo")
    public ServerResponse addClass(@RequestBody ClassAddVO classAddVO) {
        System.out.println(classAddVO);
        ClassInfo c = new ClassInfo();
        c.setRemark(classAddVO.getGradeNo());
        c.setClassNo(classAddVO.getClassNo());
        c.setClassName(classAddVO.getClassName());
        c.setTeacher(classAddVO.getId());
        c.setNum(classAddVO.getNum());
        boolean b = classInfoService.save(c);
        if (b) {
            return ServerResponse.ofSuccess("添加班级成功");
        }
        return ServerResponse.ofError("添加班级失败");
    }

    /**
     * 查询每个班级的学生人数000000000000000000000000000000000000000000000000000000000000000000000000000000出大问题
     * @return
     */
//    @GetMapping("/studentnums")
//    public ServerResponse queryStudentNumByClass() {
//        // 先获得所有的班级编号
//        QueryWrapper<ClassInfo> wrapper = new QueryWrapper();
//        QueryWrapper wrapper2 = new QueryWrapper();
//
//        int nums = 0;
//        List<ClassInfo> classList = classInfoService.list();
//        // 循环查每个班级的人数
//        for (ClassInfo classInfo : classList) {
//            wrapper2.eq("class_no", classInfo.getClassNo());
//            // 得到该班学生人数
//            nums = studentService.count(wrapper2);
//            classInfo.setNum(nums);
//            // 更新回去
//            classInfoService.update(classInfo, null);
//        }

        Page<Student> pages = new Page<>(page, limit);
        IPage<Student> iPage = studentService.page(pages, wrapper);
        return ServerResponse.ofSuccess(iPage);
    }

    /**
     * 查询班级信息带详细信息
     * @return
     */
    @GetMapping("/queryclassinfo/{page}")
    public ServerResponse queryClassInfos(@PathVariable("page") Integer page, @RequestParam(defaultValue = "10") Integer limit, @RequestParam(defaultValue = "") String gradeNo) {
        System.out.println("gradeNo = " + gradeNo);
        Map<String, Object> map = new HashMap();
        List<ClassInfoVO> classInfoVOS = null;
        if (gradeNo.equals("")) {
            classInfoVOS = classInfoDao.queryClassInfos((page - 1) * limit, limit);
            int total = classInfoDao.count2();
            map.put("records", classInfoVOS);
            map.put("total", total);
        } else {
            classInfoVOS = classInfoDao.queryClassInfo((page - 1) * limit, limit, gradeNo);
            int total = classInfoDao.count1(gradeNo);
            map.put("records", classInfoVOS);
            map.put("total", total);
        }
        return ServerResponse.ofSuccess(map);
    }

    // TODO 编辑班级

    // TODO 删除班级

    /**
     * 添加班级
     * @param classAddVO
     * @return
     */
    @PostMapping("/addclassinfo")
    public ServerResponse addClass(@RequestBody ClassAddVO classAddVO) {
        System.out.println(classAddVO);
        ClassInfo c = new ClassInfo();
        c.setRemark(classAddVO.getGradeNo());
        c.setClassNo(classAddVO.getClassNo());
        c.setClassName(classAddVO.getClassName());
        c.setTeacher(classAddVO.getId());
        c.setNum(classAddVO.getNum());
        boolean b = classInfoService.save(c);
        if (b) {
            return ServerResponse.ofSuccess("添加班级成功");
        }
        return ServerResponse.ofError("添加班级失败");
    }

    /**

        onlineVideo.setVideoUrl(u.getVideoUrl());
        onlineVideo.setCover(u.getCover());

//        onlineVideo.setVideoUrl(map.get("url").toString());
//        onlineVideo.setVideoName(map.get("name").toString());
        onlineVideo.setVideoNo(u.getVideoNo()); // 视频编号
        onlineVideo.setFromUserType(u.getUserType());
        onlineVideo.setFromUserId(u.getId());
        onlineVideo.setFromUserName(u.getRealname());

        boolean b = ovs.save(onlineVideo);
        if (b) {
            return ServerResponse.ofSuccess("添加视频成功");
        }
        return ServerResponse.ofError("添加视频失败");
    }

    /**
     * 根据id删除视频
     * @param id
     * @return
     */
    @DeleteMapping("/delete/{id}")
    public ServerResponse deleteVideo(@PathVariable("id") Integer id) {

        boolean b = ovs.removeById(id);

        if (b) {
            return ServerResponse.ofSuccess("删除视频成功");
        }
        return ServerResponse.ofError("删除视频失败");
    }

}

package com.lyk.coursearrange.controller;

/**
 */

     * @return
     */
    @PostMapping("/uploaddocs")
    public ServerResponse uploadDocs(MultipartFile file) {
        return docService.uploadDocs(file);
    }

    /**
     * 添加文档的相关描述信息
     * @param docsVO
     * @return
     */
    @PostMapping("/adddocs")
    public ServerResponse addDocs(@RequestBody DocsVO docsVO) {
        return docService.addDcos(docsVO);
    }

    /**
     * 下载文档
     * @param id
     * @return
     */
    @GetMapping(value = "/downloaddocs", consumes = MediaType.ALL_VALUE)
    public ServerResponse downloadDocs(Integer id) {
        return docService.downloadDocs(id);
    }

    /**
     * 分页查询所有的文档
     * @param page
     * @param limit
     * @return
     */
    @GetMapping("/docs/{page}")
    public ServerResponse allDocs(@PathVariable("page") Integer page, @RequestParam(defaultValue = "10") Integer limit) {
        Page<Doc> pages = new Page<>(page, limit);
        QueryWrapper<Doc> wrapper = new QueryWrapper<Doc>().orderByDesc("create_time");
        IPage<Doc> iPage = docService.page(pages, wrapper);
        return ServerResponse.ofSuccess(iPage);
    }

    /**
     * 根据班级查询文档，用于学生端
     * @param page
     * @param toClassNo
     * @param limit
     * @return
     */
    @GetMapping("/docs-class/{page}/{toClassNo}")

    /**
     * 管理员登录
     * @param adminLoginRequest
     * @return
     */
    @PostMapping("/login")
    public ServerResponse adminLogin(@RequestBody UserLoginRequest adminLoginRequest) {
        Map<String, Object> map = new HashMap();
        Admin admin = adminService.adminLogin(adminLoginRequest.getUsername(), adminLoginRequest.getPassword());
        if (admin != null){
            String token = tokenService.getToken(admin);
            map.put("admin", admin);
            map.put("token", token);
            return ServerResponse.ofSuccess(map);
        }
        return ServerResponse.ofError("用户名或密码错误!");
    }

    /**
     * 管理员更新个人资料
     * @return
     */
    @PostMapping("/modify")
    public ServerResponse modifyAdmin(@RequestBody Admin admin) {

        return adminService.updateById(admin) ? ServerResponse.ofSuccess("更新成功！") : ServerResponse.ofError("更新失败！");
    }

    /**
     * 根据ID查询管理员信息
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    public ServerResponse queryAdmin(@PathVariable("id") Integer id) {
        return ServerResponse.ofSuccess(adminService.getById(id));
    }

        Page<Student> pages = new Page<>(page, limit);
        QueryWrapper<Student> wrapper = new QueryWrapper<Student>().orderByDesc("student_no");
        IPage<Student> iPage = studentService.page(pages, wrapper);

        return ServerResponse.ofSuccess(iPage);

    }

    /**
     * 根据姓名关键字搜学生
     * @return
     */
    @GetMapping("/search/{keyword}")
    public ServerResponse searchTeacher(@PathVariable("keyword") String keyword, @RequestParam(defaultValue = "1") Integer page,
                                        @RequestParam(defaultValue = "10") Integer limit) {
        QueryWrapper<Student> wrapper = new QueryWrapper<>();
        wrapper.orderByDesc("update_time");
        wrapper.like(!StringUtils.isEmpty(keyword), "realname", keyword);
        Page<Student> pages = new Page<>(page, limit);
        IPage<Student> iPage = studentService.page(pages, wrapper);
        if (page != null) {
            return ServerResponse.ofSuccess(iPage);
        }
        return ServerResponse.ofError("查询不到数据!");
    }

    /**
     * 管理员根据ID删除学生
     * @return
     */
    @DeleteMapping("/delete/{id}")
    public ServerResponse deleteTeacher(@PathVariable Integer id) {
        boolean b = studentService.removeById(id);
        if(b) {
            return ServerResponse.ofSuccess("删除成功！");
        }
        return ServerResponse.ofError("删除失败！");
    }

    /**
     * 学生修改密码
     * @param passwordVO
     * @return
     */
    @PostMapping("/password")