基于javaweb+mysql的springboot教室图书馆预约管理系统(java+springboot+jpa+vue+maven+mysql)

基于javaweb+mysql的springboot教室图书馆预约管理系统(java+springboot+jpa+vue+maven+mysql)

运行环境

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

开发工具

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

前端：WebStorm/VSCode/HBuilderX等均可

适用

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

功能说明

基于javaweb+mysql的SpringBoot教室图书馆预约管理系统(java+springboot+jpa+vue+maven+mysql)

项目简介：

这是一个前后端分离的教室预约和查看系统项目，能够实现以教室为单位活动的预约和取消，能够以视图形式显示，附带图书馆和公告管理器功能。

主要采用Vue.js+SpringBoot 技术栈开发

使用技术点

• 前端：Vue、ElementUI、axios、Echart、jQurey * 后端：SpringBoot、Spring Data + JPA、hibernate、MySQL、Shiro

使用说明：

1. 在mysql数据库中创建数据库testmeeting行项目，将自动注入数据。如需关闭此功能，请将 application.properties 中的 spring.datasource.initialization-mode=always 代码注释。同样，可以通过使用项目sql目录下testmeeting直接导入数 据库数据结构与内容，可根据需要自行使用。2. 数据库配置在后端项目的 src\main\resources 目录下的application.properties 文件中，mysql 版本为 8.0以上版本 。 3. 在IntelliJ IDEA中运行后端项目，为了保证项目成功运行，可以右键点击 pom.xml 选择 maven -> reimport ，并重启项目。 至此，服务端就启动成功了，同时，运行前端项目，访问 http://localhost:8080 ，即可进入登录页面，默认账号是 admin，密码是 123 4. 项目使用了虹软公司的人脸识别SDK与百度的人体分析SDk： * 虹软的SDK请自行前往官网获取，获取后建议将SDK导入到src/main/resources/lib-sdk目录下,然后在src/main/java/utils目录下新建SdkParameter.java文件，填入appId和key以及引擎和算法等文件位置。 * 百度人体分析SDk已在maven中引用，但是app_id等请前往百度云AI开发者平台自行获取，该项目中表示位置为SdkParameter.java文件。 * 以上内容不必要，可以删除并注释对应接口与服务即可。 ----

二次开发请注意：

• 进入前端项目根目录中，在命令行依次输入如下命令： text # 安装依赖 npm install # 在 localhost:8080 启动项目 npm run dev * 由于在前端项目中已经配置了端口转发，将数据转发到SpringBoot上，因此项目启动之后，在浏览器中输入 http://localhost:8080 就可以访问我们的前端项目了，所有的请求通过端口转发将数据传到 SpringBoot 中（注意此时不要关闭 SpringBoot 项目）。 * 最后可以用 IDEA / WebStorm 等工具打开前端项目，继续开发，开发完成后，当项目要上线时，依然进入到 wj-vue 目录，然后执行如下命令： text npm run build * 该命令执行成功之后，前端项目目录下生成一个 dist 文件夹，可以将该文件夹中的两个文件static和 index.html 拷贝到前端项目中 resources/static/ 目录下，然后直接运行前端项目，访问 http://localhost:8443 ，

实际上是把前端打包后作为静态文件，但不推荐使用这种方式。

@RestController
@RequestMapping("/api")
public class ClassRoomController {
    @Resource
    private ClassRoomService classRoomService;

    /**
     * 保存新的或者修改教室
     * @param classRoom 教室
     * @return 保存的新房间
     */
    @CrossOrigin
    @RequestMapping("/rooms/save")
    public ClassRoom save(@RequestBody ClassRoom classRoom){
        classRoomService.save(classRoom);
        return classRoom;
    }

    /**
     * 删除教室
     * @param classRoom 教室
     * @return 删除的教室
     */
    @CrossOrigin
    @RequestMapping("/rooms/delete")
    public ClassRoom delete(@RequestBody ClassRoom classRoom){
        System.out.println(classRoom.getRoomId());
        classRoomService.delete(classRoom.getRoomId());
        return classRoom;
    }

    /**
     * 获得所有的房间列表
     * @return 封装获得所有房间
     */
    @CrossOrigin
    @RequestMapping("/rooms")
    public Result getAll(){
        return ResultFactory.buildSuccessResult(classRoomService.getAll());
    }

    /**
     * 获取所有的房间数量
     * @return 封装的房间数
     */
    @CrossOrigin
    @RequestMapping("/rooms/count")
    public Result getAllCount(){
            return ResultFactory.buildSuccessResult(classRoomService.CountByAllClassRoom());

        if (e instanceof MethodArgumentNotValidException) {
            message = ((MethodArgumentNotValidException) e).getBindingResult().getFieldError().getDefaultMessage();
        }

        if (e instanceof UnauthorizedException) {
            message = "权限认证失败";
        }

        return ResultFactory.buildFailResult(message);
    }
}
package com.shencangblue.design.icrs.controller;

@RestController
public class MenuController {
    @Autowired
    AdminMenuService adminMenuService;

    /**
     * 根据用户获取菜单
     * @return 封装好的菜单列表
     */
    @GetMapping("/api/menu")
    public Result menu() {
        return ResultFactory.buildSuccessResult(adminMenuService.getMenusByCurrentUser());
    }

    /**
     * 返回角色菜单
     * @return 封装好的菜单列表
     */
    @GetMapping("/api/admin/role/menu")
    public Result listAllMenus() {
        return ResultFactory.buildSuccessResult(adminMenuService.getMenusByRoleId(1));
    }
}

                return ResultFactory.buildFailResult("用户已存在");
        }
        return ResultFactory.buildFailResult("未知错误");
    }

    /**
     * 退出登录
     * @return 成功登出的封装消息
     */
    @GetMapping("/api/logout")
    public Result logout() {
        Subject subject = SecurityUtils.getSubject();
        subject.logout();
        return ResultFactory.buildSuccessResult("成功登出");
    }

    /**
     * 身份认证
     * @return 成功认证的消息字符串
     */
    @GetMapping("/api/authentication")
    public String authentication() {
        return "身份认证成功";
    }

    /**
     * 通过登录用户名查找用户账号
     * @param requestUser 用户身份凭据
     * @return 封装的用户名
     */
    @CrossOrigin
    @RequestMapping("/api/info/username")
    public Result loggedUserUsername(@RequestBody User requestUser) {
        String username = HtmlUtils.htmlEscape(requestUser.getUsername());
        return ResultFactory.buildSuccessResult(userService.findByUsername(username).getUsername());

    }

    /**
     * 通过登录用户查找用户姓名
     * @param requestUser 用户身份凭据
     * @return 封装的用户姓名
     */
    @CrossOrigin
    @RequestMapping("/api/info/name")
    public Result loggedUserName(@RequestBody User requestUser) {
        String username = HtmlUtils.htmlEscape(requestUser.getUsername());

     */
    @RequestMapping("/meeting/cancel")
    public Result cancelMeeting(@RequestBody Meeting meeting) {
        Meeting meeting_s = meetingService.getById(meeting.getMeetingId());
        meeting_s.setStatus(0);
        meeting_s.setCanceledTime(meeting.getCanceledTime());
        meeting_s.setCanceledReason(meeting.getCanceledReason());
        meetingService.save(meeting_s);
        return ResultFactory.buildSuccessResult("取消成功");
    }

    /**
     * 查询用户取消的活动
     *
     * @param requestUser 要查询的用户
     * @return 封装好的活动列表
     */
    @RequestMapping("/meeting/get/user_cancel")
    public Result getAllMeetingByUsernameCanceled(@RequestBody User requestUser) {
        return ResultFactory.buildSuccessResult(meetingService.findAllByStuIdCancel(requestUser.getUsername()));
    }

    /**
     * 查询用户超时活动
     *
     * @param requestUser 要查询的用户
     * @return 封装好的查询结果
     */
    @RequestMapping("/meeting/get/user_timeout")
    public Result getAllMeetingByUsernameTimeout(@RequestBody User requestUser) {
        return ResultFactory.buildSuccessResult(meetingService.findAllByStuIdTimeout(requestUser.getUsername()));
    }

    /**
     * 查询所有可用的活动数量
     *
     * @return 封装好的可用活动数量
     */
    @RequestMapping("/meeting/get/count/classify/usable")
    public Result getAllMeetingCountClassifyUsable() {
        return ResultFactory.buildSuccessResult(meetingService.CountByAllMeetingUsable());
    }

    /**
     * 查询所有取消和超时的活动
     *

     */
    @GetMapping("/api/article/{id}")
    public Result getOneArticle(@PathVariable("id") int id) {
        return ResultFactory.buildSuccessResult(jotterArticleService.findById(id));
    }

    /**
     * 删除文章或者公告
     * @param id 要删除的ID
     * @return 封装好的删除结果
     */
    @DeleteMapping("/api/admin/content/article/{id}")
    public Result deleteArticle(@PathVariable("id") int id) {
        jotterArticleService.delete(id);
        return ResultFactory.buildSuccessResult("删除成功");
    }
}
//package com.shencangblue.design.icrs.config;
//
//
//
//@Configuration
//public class WebConfiguration {
//    @Bean
//    public RemoteIpFilter remoteIpFilter() {
//        return new RemoteIpFilter();
//    }
//
//    @Bean
//    public FilterRegistrationBean testFilterRegistration() {
//
//        FilterRegistrationBean registration = new FilterRegistrationBean();
//        registration.setFilter(new MyFilter());
//        registration.addUrlPatterns("/*");
//        registration.addInitParameter("paramName", "paramValue");
//        registration.setName("MyFilter");
//        registration.setOrder(1);
//        return registration;
//    }
//
//    public static class MyFilter implements Filter {
//        @Override

    }

    /**
     * 分页功能
     * @param size 数量
     * @param page 页码数
     * @return 封装页面数据
     */
    @GetMapping("/api/article/{size}/{page}")
    public Result listArticles(@PathVariable("size") int size, @PathVariable("page") int page) {
        return ResultFactory.buildSuccessResult(jotterArticleService.list(page - 1, size));
    }

    /**
     * 查看指定ID的文章
     * @param id 文章、公告的iD
     * @return 封装的文章或者公告
     */
    @GetMapping("/api/article/{id}")
    public Result getOneArticle(@PathVariable("id") int id) {
        return ResultFactory.buildSuccessResult(jotterArticleService.findById(id));
    }

    /**
     * 删除文章或者公告
     * @param id 要删除的ID
     * @return 封装好的删除结果
     */
    @DeleteMapping("/api/admin/content/article/{id}")
    public Result deleteArticle(@PathVariable("id") int id) {
        jotterArticleService.delete(id);
        return ResultFactory.buildSuccessResult("删除成功");
    }
}
//package com.shencangblue.design.icrs.config;
//
//
//
//@Configuration
//public class WebConfiguration {
//    @Bean
//    public RemoteIpFilter remoteIpFilter() {
//        return new RemoteIpFilter();
//    }
//
//    @Bean
//    public FilterRegistrationBean testFilterRegistration() {

 * 会在之后的版本中删除
 */
@RestController
public class StudentController {
    @Resource
    StudentService studentService;

    @CrossOrigin
    @PostMapping("api/login-stu")
    @ResponseBody
    public Result login(@RequestBody Student requestStudent) {
        System.out.println("------------------------------");
        System.out.println(requestStudent.getStudentIdName());
        System.out.println(requestStudent.getPassword());
        // 对 html 标签进行转义，防止 XSS 攻击
        String studentIdName = requestStudent.getStudentIdName();
        studentIdName =HtmlUtils.htmlEscape(studentIdName);

        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(studentIdName,requestStudent.getPassword());
        usernamePasswordToken.setRememberMe(true);
        try{
            Student student = studentService.getByStudentIdName(studentIdName);
            if (!student.isEnabled()){
                System.out.println("fail-user");
                return ResultFactory.buildFailResult("该用户已被禁用");
            }
            subject.login(usernamePasswordToken);
            return ResultFactory.buildSuccessResult(usernamePasswordToken);
        }catch (IncorrectCredentialsException e){
            System.out.println("password-error");
            return ResultFactory.buildFailResult("密码错误");
        } catch (UnknownAccountException e) {
            System.out.println("user-error");
            return ResultFactory.buildFailResult("账号不存在");
        }
    }
    @CrossOrigin
    @ResponseBody
    @GetMapping(value = "api/logout-stu")
    public Result logout(){
        Subject subject = SecurityUtils.getSubject();
        subject.logout();
        String message= "成功登出账号";
        return ResultFactory.buildSuccessResult(message);

     * @param book 要删除的书籍
     * @return 封装好的删除成功的消息
     */
    @PostMapping("/api/admin/content/books/delete")
    public Result deleteBook(@RequestBody @Valid Book book) {
        bookService.deleteById(book.getId());
        return ResultFactory.buildSuccessResult("删除成功");
    }

    /**
     * 数据查找关键词
     * @param keywords 关键词
     * @return 封装的查询的结果
     */
    @GetMapping("/api/search")
    public Result searchResult(@RequestParam("keywords") String keywords) {
        if ("".equals(keywords)) {
            return ResultFactory.buildSuccessResult(bookService.list());
        } else {
            return ResultFactory.buildSuccessResult(bookService.Search(keywords));
        }
    }

    /**
     * 获取某个分类的书籍
     * @param cid 分类ID
     * @return 封装的书籍
     */
    @GetMapping("/api/categories/{cid}/books")
    public Result listByCategory(@PathVariable("cid") int cid) {
        if (0 != cid) {
            return ResultFactory.buildSuccessResult(bookService.listByCategory(cid));
        } else {
            return ResultFactory.buildSuccessResult(bookService.list());
        }
    }

    /**
     * 上传书籍封面
     * @param file 数据封面
     * @return 书籍的链接
     */

    /**
     * 查询用户权限
     * @return 用户所有权限
     */
    @GetMapping("/api/admin/role/perm")
    public Result listPerms() {
        return ResultFactory.buildSuccessResult(adminPermissionService.list());
    }

    /**
     * 更新角色菜单
     * @param rid 角色ID
     * @param menusIds 菜单ID
     * @return 封装好的成功消息
     */
    @PutMapping("/api/admin/role/menu")
    public Result updateRoleMenu(@RequestParam int rid, @RequestBody Map<String, List<Integer>> menusIds) {
        adminRoleMenuService.updateRoleMenu(rid, menusIds);
        return ResultFactory.buildSuccessResult("更新成功");
    }
}
package com.shencangblue.design.icrs.controller;

@RestController
public class LibraryController {
    @Autowired
    BookService bookService;

    /**
     * 查询所有书籍
     * @return 封装好的书籍
     */
    @GetMapping("/api/books")
    public Result listBooks() {

//    @PostMapping("/api/admin/user")
//    public Result editUser(@RequestBody Student requestStudent) {
//        if(studentService.editUser(requestStudent)) {
//            return ResultFactory.buildSuccessResult("修改用户信息成功");
//        } else {
//            return ResultFactory.buildFailResult("参数错误，修改失败");
//        }
//    }
}

package com.shencangblue.design.icrs.controller;

@RestController
public class LoginController {

    @Autowired
    UserService userService;

    /**
     * 登录方法
     * @param requestUser 登录用户凭据
     * @return 封装的是否登录成功
     */
    @PostMapping("/api/login")
    public Result login(@RequestBody User requestUser) {
        String username = requestUser.getUsername();
        username = HtmlUtils.htmlEscape(username);

        Subject subject = SecurityUtils.getSubject();
//        subject.getSession().setTimeout(10000);
        UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(username, requestUser.getPassword());
        usernamePasswordToken.setRememberMe(true);
        try {
            subject.login(usernamePasswordToken);
            User user = userService.findByUsername(username);

            return ResultFactory.buildSuccessResult("添加成功");
        }
        return ResultFactory.buildFailResult("添加失败");
    }
}
package com.shencangblue.design.icrs.config;

@ControllerAdvice
public class GlobalDefaultExceptionHandler {
    public void defaultErrorHandler(HttpServletRequest req, Exception e)  {

//      // If the exception is annotated with @ResponseStatus rethrow it and let
//      // the framework handle it - like the OrderNotFoundException example
//      // at the start of this post.
//      // AnnotationUtils is a Spring Framework utility class.
//      if (AnnotationUtils.findAnnotation(e.getClass(), ResponseStatus.class) != null)
//          throw e;
//
//      // Otherwise setup and send the user to a default error-view.
//      ModelAndView mav = new ModelAndView();
//      mav.addObject("exception", e);
//      mav.addObject("url", req.getRequestURL());
//      mav.setViewName(DEFAULT_ERROR_VIEW);
//      return mav;

        //打印异常信息：
        e.printStackTrace();
        System.out.println("GlobalDefaultExceptionHandler.defaultErrorHandler()");
        /*

         * 返回json数据或者String数据：
         * 那么需要在方法上加上注解：@ResponseBody
         * 添加return即可。
         */
        /*
         * 返回视图：
         * 定义一个ModelAndView即可，
         * 然后return;
         * 定义视图文件(比如：error.html,error.ftl,error.jsp);
         *
         */

    }
}
package com.shencangblue.design.icrs.exception;

//    public RemoteIpFilter remoteIpFilter() {
//        return new RemoteIpFilter();
//    }
//
//    @Bean
//    public FilterRegistrationBean testFilterRegistration() {
//
//        FilterRegistrationBean registration = new FilterRegistrationBean();
//        registration.setFilter(new MyFilter());
//        registration.addUrlPatterns("/*");
//        registration.addInitParameter("paramName", "paramValue");
//        registration.setName("MyFilter");
//        registration.setOrder(1);
//        return registration;
//    }
//
//    public static class MyFilter implements Filter {
//        @Override
//        public void destroy() {
//            // TODO Auto-generated method stub
//        }
//
//        @Override
//        public void doFilter(ServletRequest srequest, ServletResponse sresponse, FilterChain filterChain)
//                throws IOException, ServletException {
//            // TODO Auto-generated method stub
//            HttpServletRequest request = (HttpServletRequest) srequest;
//            System.out.println("this is MyFilter,url :"+request.getRequestURI());
//            filterChain.doFilter(srequest, sresponse);
//        }
//
//        @Override
//        public void init(FilterConfig arg0) throws ServletException {
//            // TODO Auto-generated method stub
//        }
//    }
//}
package com.shencangblue.design.icrs.controller;

@RestController
@RequestMapping("/api")

    }

    /**
     * 通过登录用户查找用户姓名
     * @param requestUser 用户身份凭据
     * @return 封装的用户姓名
     */
    @CrossOrigin
    @RequestMapping("/api/info/name")
    public Result loggedUserName(@RequestBody User requestUser) {
        String username = HtmlUtils.htmlEscape(requestUser.getUsername());
        return ResultFactory.buildSuccessResult(userService.findByUsername(username).getName());

    }
}
package com.shencangblue.design.icrs.controller;

@RestController
public class RoleController {
    @Autowired
    AdminRoleService adminRoleService;
    @Autowired
    AdminPermissionService adminPermissionService;
    @Autowired
    AdminRolePermissionService adminRolePermissionService;
    @Autowired
    AdminRoleMenuService adminRoleMenuService;

    /**
     * h获取角色列表
     * @return 返回角色列表
     */
    @GetMapping("/api/admin/role")
    public Result listRoles() {

    @Resource
    MeetingService meetingService;
    @Resource
    UserService userService;
    Timestamp nowTime;
    Timestamp tomTime;

    /**
     * 保存或者修改会议活动
     *
     * @param meeting 活动与会议
     * @return 封装的提示消息
     */
    @RequestMapping("/meeting/save")
    public Result save(@RequestBody Meeting meeting) {
        meetingService.save(meeting);
        if (meetingService.getById(meeting.getMeetingId()) != null) {
            return ResultFactory.buildSuccessResult("添加成功");
        }
        return ResultFactory.buildFailResult("添加失败");
    }

    /**
     * 删除指定活动
     *
     * @param meeting 要删除指定活动
     * @return 封装的封装消息
     */
    @RequestMapping("/meeting/delete")
    public Result delete(@RequestBody Meeting meeting) {
        System.out.println(meeting.getMeetingId());
        meetingService.delete(meeting.getMeetingId());
        return ResultFactory.buildSuccessResult("success");
    }

    /**
     * 查找所有会议
     *
     * @return 封装好的所有会议信息
     */

    @Autowired
    AdminPermissionService adminPermissionService;
    @Autowired
    AdminRolePermissionService adminRolePermissionService;
    @Autowired
    AdminRoleMenuService adminRoleMenuService;

    /**
     * h获取角色列表
     * @return 返回角色列表
     */
    @GetMapping("/api/admin/role")
    public Result listRoles() {
        return ResultFactory.buildSuccessResult(adminRoleService.listWithPermsAndMenus());
    }

    /**
     * 获取角色状态
     * @param requestRole 要查询的角色
     * @return 封装好的消息
     */
    @PutMapping("/api/admin/role/status")
    public Result updateRoleStatus(@RequestBody AdminRole requestRole) {
        AdminRole adminRole = adminRoleService.updateRoleStatus(requestRole);
        String message = "用户" + adminRole.getNameZh() + "状态更新成功";
        return ResultFactory.buildSuccessResult(message);
    }

    /**
     * 修改角色信息
     * @param requestRole 要修改的角色信息
     * @return 封装好的消息
     */
    @PutMapping("/api/admin/role")
    public Result editRole(@RequestBody AdminRole requestRole) {
        adminRoleService.addOrUpdate(requestRole);
        adminRolePermissionService.savePermChanges(requestRole.getId(), requestRole.getPerms());
        String message = "修改角色信息成功";
        return ResultFactory.buildSuccessResult(message);
    }

    /**
     * 修改用户用户角色

        bookService.addOrUpdate(book);
        return ResultFactory.buildSuccessResult("修改成功");
    }

    /**
     * 删除书籍
     * @param book 要删除的书籍
     * @return 封装好的删除成功的消息
     */
    @PostMapping("/api/admin/content/books/delete")
    public Result deleteBook(@RequestBody @Valid Book book) {
        bookService.deleteById(book.getId());
        return ResultFactory.buildSuccessResult("删除成功");
    }

    /**
     * 数据查找关键词
     * @param keywords 关键词
     * @return 封装的查询的结果
     */
    @GetMapping("/api/search")
    public Result searchResult(@RequestParam("keywords") String keywords) {
        if ("".equals(keywords)) {
            return ResultFactory.buildSuccessResult(bookService.list());
        } else {
            return ResultFactory.buildSuccessResult(bookService.Search(keywords));
        }
    }

    /**
     * 获取某个分类的书籍
     * @param cid 分类ID
     * @return 封装的书籍
     */
    @GetMapping("/api/categories/{cid}/books")
    public Result listByCategory(@PathVariable("cid") int cid) {
        if (0 != cid) {
            return ResultFactory.buildSuccessResult(bookService.listByCategory(cid));
        } else {
            return ResultFactory.buildSuccessResult(bookService.list());
        }
    }

    /**
     * 上传书籍封面
     * @param file 数据封面
     * @return 书籍的链接
     */
    @PostMapping("/api/admin/content/books/covers")

            return ResultFactory.buildFailResult("账号不存在");
        }
    }
    @CrossOrigin
    @ResponseBody
    @GetMapping(value = "api/logout-stu")
    public Result logout(){
        Subject subject = SecurityUtils.getSubject();
        subject.logout();
        String message= "成功登出账号";
        return ResultFactory.buildSuccessResult(message);
    }

    @CrossOrigin
    @PostMapping(value = "api/register-stu")
    @ResponseBody
    public Result register(@RequestBody Student student) {
        int status = studentService.register(student);
        switch (status){
            case 0:
                return ResultFactory.buildFailResult("用户名和密码不能为空");
            case 1:
                return ResultFactory.buildSuccessResult("注册成功");
            case 2:
                return ResultFactory.buildFailResult("用户已存在");
        }
        return ResultFactory.buildFailResult("未知错误");
    }

//    @CrossOrigin
//    @ResponseBody
//    @GetMapping(value = "api/authentication")
//    public String authentication(){
//        return "身份认证成功";
//    }
//
//    @CrossOrigin
//    @ResponseBody
//    @GetMapping("/api/admin/user")
//    public Iterable<Student> listUsers() {
//        return studentService.list();
//    }
//
//    @CrossOrigin
//    @ResponseBody
//    @PostMapping("/api/admin/user/status")
//    public Result updateUserStatus(@RequestBody Student requestStudent) {
//        if (studentService.updateStudentStatus(requestStudent)) {
//            return ResultFactory.buildSuccessResult("用户状态更新成功");
//        } else {
//            return ResultFactory.buildFailResult("参数错误，更新失败");

//            return ResultFactory.buildFailResult("参数错误，修改失败");
//        }
//    }
}

package com.shencangblue.design.icrs.controller;

@RestController
public class LoginController {

    @Autowired
    UserService userService;

    /**
     * 登录方法
     * @param requestUser 登录用户凭据
     * @return 封装的是否登录成功
     */
    @PostMapping("/api/login")
    public Result login(@RequestBody User requestUser) {
        String username = requestUser.getUsername();
        username = HtmlUtils.htmlEscape(username);

        Subject subject = SecurityUtils.getSubject();
//        subject.getSession().setTimeout(10000);
        UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(username, requestUser.getPassword());
        usernamePasswordToken.setRememberMe(true);

     * @param requestRole 要修改的角色
     * @return 封装好的修改成功消息
     */
    @PostMapping("/api/admin/role")
    public Result addRole(@RequestBody AdminRole requestRole) {
        adminRoleService.editRole(requestRole);
        return ResultFactory.buildSuccessResult("修改用户成功");
    }

    /**
     * 查询用户权限
     * @return 用户所有权限
     */
    @GetMapping("/api/admin/role/perm")
    public Result listPerms() {
        return ResultFactory.buildSuccessResult(adminPermissionService.list());
    }

    /**
     * 更新角色菜单
     * @param rid 角色ID
     * @param menusIds 菜单ID
     * @return 封装好的成功消息
     */
    @PutMapping("/api/admin/role/menu")
    public Result updateRoleMenu(@RequestParam int rid, @RequestBody Map<String, List<Integer>> menusIds) {
        adminRoleMenuService.updateRoleMenu(rid, menusIds);
        return ResultFactory.buildSuccessResult("更新成功");
    }
}
package com.shencangblue.design.icrs.controller;

@RestController
public class LibraryController {
    @Autowired
    BookService bookService;

    /**
     * 查询所有书籍
     * @return 封装好的书籍

        Iterable<Meeting> meetings = meetingService.findAllByStartTimeAfterAndEndTimeBefore(nowTime, nowTime);
        nowTime = new Timestamp(new Date().getTime());
        for (Meeting meeting : meetings) {
            meeting.setStatus(2);
        }
        meetingService.saveAll(meetings);
        return ResultFactory.buildSuccessResult("更新状态成功");
    }

    /**
     * 查询活动是否过期
     * @return 返回更新状态
     */
    @RequestMapping("/checkMeetTimeout")
    public Result checkMeetTimeout() {
        nowTime = new Timestamp(new Date().getTime());
        Iterable<Meeting> meetings = meetingService.findAllByEndTimeBefore(nowTime);
        for (Meeting meeting : meetings) {
            meeting.setStatus(-1);
            System.out.println(meeting.getMeetingId() + " " + meeting.getStatus());
        }
        meetingService.saveAll(meetings);
        return ResultFactory.buildSuccessResult("更新状态成功");
    }

    /**
     * 查询七天内所有用户会议所有教室预约情况
     *
     * @return 预约情况
     */
    @RequestMapping("/querySevenDayMeetOfUser")
    public Result querySevenDayMeetOfUser(@RequestBody User requestUser) {
        return ResultFactory.buildSuccessResult(meetingService.querySevenDayMeetOfUser(requestUser.getUsername()));
    }

    /**
     * 依照会议时间是否冲突-重新封装模式
     *
     * @return 是否冲突
     */
    @RequestMapping("/checkTimeConflict")
    public Result checkTimeConflict(@RequestBody Meeting meeting) {
        return ResultFactory.buildSuccessResult(meetingService.checkTimeConflict(meeting));
    }

}

package com.shencangblue.design.icrs.controller;

        tomTime.setNanos(0);
        tomTime.setDate(tomTime.getDate() + 1);
        int count = 0;
        for (Meeting meeting : meetingService.findAllByStartTimeBetweenAndStatusGreaterThan(nowTime, tomTime, 0)) {

            list.add(new int[]{count, meeting.getStartTime().getHours(), meeting.getNumberOfParticipants()});
            count++;

        }
        return ResultFactory.buildSuccessResult(list);
    }

    /**
     * 查询活动预约的状态
     *
     * @return
     */
    @RequestMapping("/queryReservationOfCurrentDateRoom")
    public Result QueryReservationOfCurrentDateRoom() {
        List<String> list = new ArrayList<>();
        nowTime = new Timestamp(new Date().getTime());
        tomTime = new Timestamp(new Date().getTime());
        nowTime.setHours(0);
        nowTime.setSeconds(0);
        nowTime.setMinutes(0);
        nowTime.setNanos(0);
        tomTime.setHours(0);
        tomTime.setSeconds(0);
        tomTime.setMinutes(0);
        tomTime.setNanos(0);
        tomTime.setDate(tomTime.getDate() + 1);
        for (Meeting meeting : meetingService.findAllByStartTimeBetweenAndStatusGreaterThan(nowTime, tomTime, 0)) {

            list.add(meeting.getRoomName());
            ;
        }
        return ResultFactory.buildSuccessResult(list);
    }

    /**
     * 查询活动是否结束
     * @return 封装好的活动状态提升
     */
    @RequestMapping("/checkMeetBegin")
    public Result checkMeetBegin() {
        Iterable<Meeting> meetings = meetingService.findAllByStartTimeAfterAndEndTimeBefore(nowTime, nowTime);
        nowTime = new Timestamp(new Date().getTime());
        for (Meeting meeting : meetings) {
            meeting.setStatus(2);
        }
        meetingService.saveAll(meetings);
        return ResultFactory.buildSuccessResult("更新状态成功");
    }

    /**
     * 用于统计房间人数的方法-活体检测-前端返回类型
     * @param file 教室的图像
     * @return 封装的人数
     */
    @PostMapping("/classroomInfo/info")
    public String coversUpload(MultipartFile file) {
        AipBodyAnalysis client =BDAipBodyAnalysis.getClient();
        String folder = "D:/workspace/img";
        File imageFolder = new File(folder);
        File f = new File(imageFolder, StringUtils.getRandomString(6) + file.getOriginalFilename()
                .substring(file.getOriginalFilename().length() - 4));
        if (!f.getParentFile().exists())
            f.getParentFile().mkdirs();
        try {
            file.transferTo(f);
//            String imgURL = "http://localhost:8443/api/file/" + f.getName();
//            return imgURL;
            return classRoomService.analysisPeople(client ,f);
        } catch (IOException e) {
            e.printStackTrace();
            return "-1";
        }
    }

}
package com.shencangblue.design.icrs.controller;

     * @return 封装的房间
     */
    @CrossOrigin
    @RequestMapping("/rooms/usable-rooms")
    public Result getUsableRooms(){
        return ResultFactory.buildSuccessResult(classRoomService.findAllUsableRooms(0));
    }

    /**
     * 修改指定的房间数据
     * @return 修改结果
     */
    @CrossOrigin
    @RequestMapping("/rooms/update")
    public String update(){
        return classRoomService.update(3L,classRoomService.getById(3L))!=null?"sec":"fal";
    }

    /**
     * 获取不同的分类的房间
     * @param capacity 分类的依据：房间容纳人数
     * @return 教室列表
     */
    @CrossOrigin
    @RequestMapping("/rooms/capacity/{capacity}/rooms")
    public Iterable<ClassRoom> findAllByCapacity(@PathVariable("capacity") int capacity){
        System.out.println(capacity);
        if (0==capacity){
            return classRoomService.getAll();
        }else {
            return classRoomService.findAllByCapacity(capacity);
        }
    }

    /**
     * 查询功能
     * @param keywords 要查询的关键字
     * @return 查询到的教室
     */
    @CrossOrigin
    @RequestMapping("/search")
    public Iterable<ClassRoom> searchResult(@RequestParam("keywords") String keywords){
        if ("".equals(keywords)){
            return classRoomService.getAll();
        }
        else {
            return classRoomService.search(keywords);
        }

@RestController
public class LibraryController {
    @Autowired
    BookService bookService;

    /**
     * 查询所有书籍
     * @return 封装好的书籍
     */
    @GetMapping("/api/books")
    public Result listBooks() {
        return ResultFactory.buildSuccessResult(bookService.list());
    }

    /**
     * 新增或者修改书籍
     * @param book 要修改或者新增的书籍
     * @return 封装好的修改成功提示
     */
    @PostMapping("/api/admin/content/books")
    public Result addOrUpdateBooks(@RequestBody @Valid Book book) {
        bookService.addOrUpdate(book);
        return ResultFactory.buildSuccessResult("修改成功");
    }

    /**
     * 删除书籍
     * @param book 要删除的书籍
     * @return 封装好的删除成功的消息
     */
    @PostMapping("/api/admin/content/books/delete")
    public Result deleteBook(@RequestBody @Valid Book book) {
        bookService.deleteById(book.getId());
        return ResultFactory.buildSuccessResult("删除成功");
    }

    /**
     * 数据查找关键词
     * @param keywords 关键词
     * @return 封装的查询的结果
     */
    @GetMapping("/api/search")

    public Result delete(@RequestBody Meeting meeting) {
        System.out.println(meeting.getMeetingId());
        meetingService.delete(meeting.getMeetingId());
        return ResultFactory.buildSuccessResult("success");
    }

    /**
     * 查找所有会议
     *
     * @return 封装好的所有会议信息
     */
    @RequestMapping("/meeting")
    public Result getAll() {
        return ResultFactory.buildSuccessResult(meetingService.getAll());
    }

    /**
     * 获取活动数量
     *
     * @return 封装好的活动数量
     */
    @RequestMapping("/meeting/count")
    public Result getAllCount() {
        return ResultFactory.buildSuccessResult(meetingService.CountByAllMeeting());
    }

    /**
     * 获取指定用户的活动
     *
     * @param requestUser 要查找的用户
     * @return 封装好活动信息列表
     */
    @RequestMapping("/meeting/get/user")
    public Result getAllMeetingByUsername(@RequestBody User requestUser) {
        return ResultFactory.buildSuccessResult(meetingService.findAllByStuId(requestUser.getUsername()));
    }

    /**
     * 获取管理员的活动
     *
     * @return 封装好的管理员活动
     */
    @RequestMapping("/meeting/get/admin")
    public Result getAllMeetingByAdmin() {
        return ResultFactory.buildSuccessResult(meetingService.findAllByStuId("admin"));
    }

    /**
     * 查询用户可用的活动