基于 SpringBoot 的高校宿舍管理系统设计与开发

1.引言

宿舍是大学生学习与生活的主要场所之一,宿舍管理是高校学工管理事务中 尤为重要的一项。随着我国高校招生规模的进一步扩大,学生总体人数的不断增加, 宿舍管理工作变得愈加沉重和琐碎,学生宿舍信息的采集、汇总、统计与分析等各 项工作都面临诸多困难,传统的管理模式早已无法满足当前我国高校的管理需求了。 因此,迫切需要研究设计和开发一个新型的高校宿舍管理系统,以便更好地满足高 校宿舍管理工作的实际需求,方便宿管人员开展管理工作,提升管理水平,提高工 作效率,节约人力、物力,为广大学生群体提供更优质、高效的服务。 基于上述背景,本文设计并开发了一个高校宿舍管理系统。系统采用 B/S 架构, 后端基于 Java 语言和 SpringBoot 框架的方式进行了开发,前端则是使用 Layui 框 架,结合 HTML、JQuery、Ajax 等技术进行开发,并使用 MySQL 数据库对所有相关的 信息进行了存储。系统主要包括基本信息管理、离返校管理、宿舍分配管理、宿舍 日常管理、综合查询管理等五大功能模块,并根据学生、辅导员、宿舍管理员的使 用需求对这些功能进行了细化和实现。通过本系统能够方便、快捷地采集、查看、 统计相关的信息,并以图形化界面的方式展示出来,较好地满足了目标用户的需求, 提高了宿舍管理的水平,有利于我国推进高校学工管理真正实现信息化、科学化、 规范化的历史性进程。

2.开发技术

2.1SpringBoot框架 

Spring Boot是一个用于快速构建可配置的、独立的、生产级的Spring应用程序的开源框架。它是基于Spring框架的,并借助于约定优于配置的原则,旨在简化Spring应用程序的开发和部署。

以下是Spring Boot框架的一些关键特点和描述:

(1)简化的配置:Spring Boot通过约定优于配置的方式来配置应用程序,使开发人员能够更快速地启动和开发项目。它自动配置许多常用的功能和第三方库,如数据库连接、Web开发、安全性等,默认情况下遵循最佳实践。

(2)内嵌的Servlet容器:Spring Boot集成了内嵌的Servlet容器(如Tomcat、Jetty),使得开发人员可以将Web应用程序打包为独立可执行的JAR文件,无需外部服务器的部署和配置。

(3)自动化依赖管理:Spring Boot简化了项目的依赖管理。它提供了一种称为“Starter”的概念,即一组预定义的依赖项,用于快速引入相关的库和功能。开发人员只需添加适当的Starter依赖,并且Spring Boot会自动解析和配置所需的依赖项。

(4)监控和管理:Spring Boot提供了丰富的监控和管理功能,使得开发人员能够更好地了解应用程序的运行状况和性能指标。它集成了多个可插拔的监控工具,如健康检查、度量指标、日志记录等,用于故障排查和性能优化。

(5)生态系统支持:Spring Boot作为Spring框架的衍生版本,能够充分利用Spring生态系统的各个方面。开发人员可以轻松地集成Spring框架的其他模块和扩展,如Spring Data、Spring Security等,为应用程序提供更丰富和完整的功能。

总之,Spring Boot是一个简化Spring应用程序开发的框架。它通过约定优于配置、自动化依赖管理和内嵌的Servlet容器等特性,提供了一种快速和高效的方式来构建Java应用程序。Spring Boot框架在开发效率、可维护性和可扩展性方面具有很大优势,被广泛应用于各种类型的项目和应用程序。

2.2MyBatis框架

MyBatis是一个开源的持久层框架,用于简化数据库访问的开发工作。它与Java应用程序紧密集成,并使开发人员能够通过简单的配置和灵活的SQL映射,实现对关系型数据库的访问和操作。

以下是MyBatis框架的一些关键特点和描述:

(1)SQL映射:MyBatis使用XML或注解来定义SQL映射,将Java对象与数据库表进行映射。开发人员可以根据需要编写SQL语句,并将其与Java方法进行绑定。这样可以实现灵活的数据访问和操作。

(2)简化的数据访问:MyBatis提供了简单且直观的API,使开发人员可以轻松执行各种数据库操作,如插入、更新、删除和查询等。它封装了底层的数据库连接和结果集处理细节,为开发人员提供了方便的数据操作接口。

(3)动态SQL:MyBatis支持动态SQL,使得在SQL语句中可以根据不同条件进行灵活的组合和拼接。开发人员可以根据运行时的条件改变SQL语句的逻辑,从而实现更高级别的数据访问和处理。

(4)缓存机制:MyBatis具有内置的缓存机制,可在多次查询相同数据时提供性能优化。开发人员可以配置不同级别的缓存,如会话级缓存、查询级缓存等,以提高数据访问的效率。

(5)可扩展性:MyBatis是一个可扩展的框架。开发人员可以使用插件机制扩展和定制MyBatis的功能。插件可以通过添加额外的拦截器来拦截和修改MyBatis的核心行为,以满足特定的需求。

(6)生态系统支持:MyBatis拥有广泛的生态系统和活跃的社区支持。开发人员可以通过官方文档、示例代码和社区论坛等资源来学习和解决问题。此外,MyBatis与Spring框架等其他技术和工具也有良好的集成。

总而言之,MyBatis是一个简化数据库访问的持久层框架。通过灵活的SQL映射、简单的数据访问API和动态SQL支持,MyBatis使开发人员能够轻松地进行数据库操作。其缓存机制和可扩展性也为性能优化和定制化提供了便利。MyBatis在许多Java应用程序中被广泛使用,特别是在需要灵活SQL操作和定制化数据访问的场景中。

2.3Mysql数据库

MySQL是一种开源的关系型数据库管理系统(RDBMS)。它是最受欢迎和广泛使用的数据库之一,被许多应用程序和网站用于存储和管理数据。

以下是MySQL数据库的一些关键特点和描述:

(1)关系型数据库:MySQL是一种关系型数据库管理系统,基于表和关系的概念来组织和存储数据。数据以结构化的方式存储,可以通过SQL(Structured Query Language)进行查询和管理。

(2)可靠和稳定:MySQL以其可靠性和稳定性而闻名,被广泛用于处理重要的数据。它具有高度的可用性、容错性和数据完整性,适用于各种规模的应用程序。

(3)跨平台性:MySQL可以在多个操作系统上运行,包括Windows、Linux、Mac和UNIX等。开发人员可以在不同的平台上使用相同的MySQL数据库,无需更改代码和数据模型。

(4)高性能:MySQL在处理大量数据时表现出色,并具有高效的读写速度。它通过索引、查询优化和缓存机制等技术来提高查询性能,以满足各种负载条件下的需求。

(5)可扩展性:MySQL具有良好的可扩展性,可以处理大量的数据和高并发访问。它支持垂直扩展和水平扩展,可以通过增加更多的服务器、分片和复制等方式来提高性能和容量。

(6)安全性:MySQL提供了多种安全功能来保护数据的安全性。它支持用户身份验证、访问控制、加密传输和数据审计等功能,以防止未经授权的访问和恶意攻击。

(7)丰富的功能:MySQL提供了丰富的功能和特性,如存储过程、触发器、视图、备份和恢复等。它还提供了多种存储引擎,如InnoDB、MyISAM等,可根据需求选择合适的引擎。

总结起来,MySQL是一个强大、可靠和高性能的关系型数据库管理系统。它具有跨平台性、可扩展性和丰富的功能,被广泛应用于各种类型的应用程序和网站。MySQL拥有广泛的用户社区和丰富的资源,提供了大量的文档、示例和支持,使开发人员能够更好地管理和操作数据库。

3.功能设计

通过对宿舍管理工作中相关业务流程的调研和分析,确定了系统的功能主要有:
(1)基本信息管理 基本信息分为学生信息和宿舍信息两部分,其功能是负责维护这些信息,对 它们进行增删查改等操作。
(2)宿舍分配管理 根据给定的宿舍信息与学生信息,按照一定的规则自动地给还未分配宿舍的 学生分配宿舍,学生可在该宿舍内自选床位,最终的宿舍分配信息可以以文件形 式(如 Excel 表格)导出。
(3)宿舍日常管理 主要包括卫生管理、报修管理、留言管理等。 卫生管理:记录并维护卫生检查信息。 报修管理:添加、查看、修改报修单信息。 留言管理:包括发布公告、失物招领、普通留言以及对这些信息的维护。
(4)离返校管理 对节假日学生的去向、寒暑假学生的留校以及返校登记信息进行统计及管 理,并以图表形式呈现统计信息。
(5)综合查询管理 包括查找学生信息、各楼栋/专业的学生宿舍分配情况、卫生检查情况、学 生离返校及留校信息、指定类型的留言、查看宿舍成员等
本系统所面向的客户群主要分为学生、辅导员和宿舍管理员三种类型的用户,不 同类型的用户对系统的功能具有不同的需求。
(1)学生 可以选择床位、查看自己所在的宿舍以及同宿舍人员的信息;填写、查看和 修改自己宿舍的报修单;查看每周的卫生检查情况;节假日时填写离校登记信息、寒暑假提交留校申请以及填写返校登记信息;查看留言板上的公告、失物招领信 息,发布留言等;修改自己的基本信息和账号的密码。
基于 SpringBoot 的高校宿舍管理系统设计与开发_第1张图片

(2)辅导员

负责维护学生的基本信息;查看学生宿舍分配信息;查看学生节假日的去向 信息和返校信息;查看和审批学生的寒暑假留校的申请;查看学生的卫生检查情况。 

基于 SpringBoot 的高校宿舍管理系统设计与开发_第2张图片

(3)宿舍管理员

负责维护宿舍信息;为新生分配宿舍;处理学生的报修申请;发布公告、失 物招领等信息到留言板上;查看学生寒暑假留校信息;每周进行卫生检查并将检 查情况记录到系统中。

基于 SpringBoot 的高校宿舍管理系统设计与开发_第3张图片4.实现效果展示

(1)登录

为了保证系统的安全性,用户在进入系统前必须先登录,通过账号的合法性检验 后才能进入系统。 登录的界面如图 4.1 所示,用户输入账号信息,点击“登录”的按钮,将表单数 据提交到后端。如果存在相应的用户信息,则系统跳转到对应权限的页面;不然验 证失败,系统给予错误提示。

基于 SpringBoot 的高校宿舍管理系统设计与开发_第4张图片

(2) 学生端

学生端主页面如图 4.2 所示,其功能主要包括了我的宿舍、离返校登记、留言板、 基本资料管理等。

基于 SpringBoot 的高校宿舍管理系统设计与开发_第5张图片

 我的宿舍

学生可以查看本人所在的宿舍和室友的信息。如果是初次进入本系统,系统 将提示学生选择床位,床位选择界面如图 4.3 所示,学生可以根据系统提供的宿 舍布局为参考,从未被选择的床位中选取自己想要的床位。
基于 SpringBoot 的高校宿舍管理系统设计与开发_第6张图片
我的报修

 学生可以查看本宿舍的报修信息(包括自己提交的和他人提交的),填写和 修改报修单信息,但只能修改本人提交的报修单,且只能修改未处理的,正在处 理和已处理的报修信息则不能被更改。

基于 SpringBoot 的高校宿舍管理系统设计与开发_第7张图片

卫生检查记录

学生可以查看自己宿舍的卫生检查情况,系统优先显示近期的记录,对于不 合格(低于 60 分)的记录,系统将高亮显示,提醒学生。

基于 SpringBoot 的高校宿舍管理系统设计与开发_第8张图片  离校登记

 系统将显示学生所有的离校登记信息,学生也可以在该页面下提交和编辑登 记信息。填写时,学生需选择去向类型,如果是回家或者外出,必须填写目的地、 回校时间、紧急联系人,如果是留校,以上三项信息则无需填写。

基于 SpringBoot 的高校宿舍管理系统设计与开发_第9张图片

留校申请

 寒暑假期间有留校需求的学生需要向学院提交留校申请。申请填写页面如图 4.8 所示,学生需要说明留校的原因,留校的截止时间,并提供家长手写的同意 留校及安全保证承诺的图片。

基于 SpringBoot 的高校宿舍管理系统设计与开发_第10张图片

返校登记

 临近开学时学生要填写返校信息,主要内容有是否要延迟返校、返校时间、 延迟的原因、交通方式以及车次的信息。

基于 SpringBoot 的高校宿舍管理系统设计与开发_第11张图片

(3)留言板

 在这里,学生可以查看所在楼栋的相关留言信息,包括公告、失物招领以及 普通留言;也可以发布留言与他人进行沟通,编辑和查看自己的留言等。 留言信息以便签的形式呈现出来,不同类型的留言使用不同的底色以示区分。

基于 SpringBoot 的高校宿舍管理系统设计与开发_第12张图片

(4)辅导员端 

辅导员端的主页面如图 4.11 所示,主要实现了对学生事务的管理及宿舍相关事 务的查看,包含了学生管理、离返校管理、卫生管理三个模块。
​​​ 基于 SpringBoot 的高校宿舍管理系统设计与开发_第13张图片

  学生管理

主要完成对学生信息的增、删、查、改等操作。 添加分为单条信息添加和批量添加。单条信息添加页面如图 4.12 所示,辅 导员需录入学生的学院、专业、班级、姓名及学号信息。批量添加则是通过导入Excel 表格来实现的,辅导员在给定的 Excel 模板中填写学生的信息,点击“导 入”按钮将文件上传,后端把表格的每一行解析成一条学生信息,批量插入到数 据库中。
基于 SpringBoot 的高校宿舍管理系统设计与开发_第14张图片

基于 SpringBoot 的高校宿舍管理系统设计与开发_第15张图片 

 宿舍管理

 辅导员可按专业、班级来查看学生的宿舍分配信息,还可以将分配信息导出 成 Excel 文件。

基于 SpringBoot 的高校宿舍管理系统设计与开发_第16张图片

 离校管理- 节假日去向管理

 用于查看学生节假日的去向信息,可以按去向类型(留校、回家、外出)来 查看,系统还统计了每种类型的学生人数及比例,并以饼状图的形式展现出来。

基于 SpringBoot 的高校宿舍管理系统设计与开发_第17张图片

  离校管理-假期留校管理

主要用来查看和审批学生假期的留校申请信息,系统同样也支持将这些信息 导出,并且也统计了留校学生在每个宿舍区的人数,以饼状图展现出来。
基于 SpringBoot 的高校宿舍管理系统设计与开发_第18张图片

   离校管理-返校管理

用于查看和导出各学生的返校情况,同样也实现了对按时返校与延迟返校的 信息统计。

基于 SpringBoot 的高校宿舍管理系统设计与开发_第19张图片

(5)宿舍管理员端

宿舍管理员端界面如下图 4.19 所示,主要包括了宿舍管理、留校管理、住宿管 理及日常管理四个功能,用于对宿舍事务进行管理。

 基于 SpringBoot 的高校宿舍管理系统设计与开发_第20张图片

 宿舍管理

实现了对宿舍信息的维护。系统支持单个宿舍信息的添加和批量的添加,批 量添加是通过 Excel 的导入来实现的。查找宿舍信息可以通过指定宿舍区、楼栋、 寝室以及宿舍的入住状态(已住满/未住满)来查询。
基于 SpringBoot 的高校宿舍管理系统设计与开发_第21张图片

  住宿管理-预分配管理

系统为还未分配宿舍的学生分配宿舍,主要用于大一的新生。系统从数据中 查出未分配宿舍的学生列表和有空余床位的宿舍列表,按照优先同性别、同学院、 同专业、同班级的原则,按学号从小到大的顺序将学生安排进空余宿舍中。每分配好一个学生,宿舍的空余数就减 1,当该宿舍的空余数为 0 时,将后续学生安 排进下一个宿舍,直至所有学生分配完毕。

基于 SpringBoot 的高校宿舍管理系统设计与开发_第22张图片

5.核心代码

@Controller
@RequestMapping("/dm")
public class DorMController {

    @Resource
    private DorMService dormService;

    /**
     * 卫生检查列表
     *
     * @return
     */
    @RequestMapping(value = "/cleanList")
    public String cleanList() {
        return "/dm/clean-list";
    }

    /**
     * 查看卫生检查情况
     *
     * @param ciVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/clean/list")
    public DataGridViewResult findCleanInfoList(CleanInfoVo ciVo, HttpServletRequest request) {
        // 获取宿管员管理的宿舍区和楼栋号,拼接成brcode
        String brarea = (String) request.getSession().getAttribute("brarea");
        String brbid = (String) request.getSession().getAttribute("brbid");
        String brcode = MyStringUtil.getBrcode(brarea, brbid, "");
        if (StringUtils.isNotBlank(brcode)) {
            ciVo.setBrcode(brcode);
        }
        System.out.println(ciVo);

        // 设置分页信息
        PageHelper.startPage(ciVo.getPage(), ciVo.getLimit());
        // 查询
        List list = dormService.findCleanInfoListByPage(ciVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 更改卫生检查信息
     *
     * @param ci
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/clean/update")
    public String updateCleanInfo(CleanInfo ci) {
        System.out.println(ci);
        HashMap map = new HashMap<>();
        int result = dormService.updateCleanInfo(ci);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "更改成功!");
        } else {
            map.put("success", false);
            map.put("msg", "更改失败!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 删除卫生检查记录
     *
     * @param id
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/clean/delete")
    public String deleteCleanInfo(String id) {
        System.out.println(id);
        HashMap map = new HashMap<>();
        int result = dormService.deleteCleanInfo(id);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "删除成功!");
        } else {
            map.put("success", false);
            map.put("msg", "删除失败!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 返回添加卫生检查记录页面
     *
     * @return
     */
    @RequestMapping(value = "/clean/add.html")
    public String addCleanInfo() {
        return "/dm/clean-add";
    }

    /**
     * 批量添加卫生检查记录
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/clean/add")
    public String batchAddCleanInfo(HttpServletRequest request) {
        HashMap map = new HashMap<>();
        String params = request.getParameter("params");
        String checker = (String) request.getSession().getAttribute("uname");
        try {
            boolean result = dormService.batchInsertCleanInfo(params, checker);
            if (result) {
                map.put("success", true);
                map.put("msg", "添加成功!");
            } else {
                map.put("success", false);
                map.put("msg", "添加失败!");
            }
        } catch (Exception e) {
            e.printStackTrace();
            map.put("success", false);
            map.put("msg", "添加失败!");
        }
        return JSON.toJSONString(map);
    }


    /**
     * 学生报修列表
     *
     * @return
     */
    @RequestMapping(value = "/repairList")
    public String viewRepairList() {
        return "/dm/repair-list";
    }

    /**
     * 查找该宿管员负责的楼栋下的报修信息
     *
     * @param riVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/repair/list")
    public DataGridViewResult findRepairInfoList(RepairInfoVo riVo, HttpServletRequest request) {
        // 拼接brcode
        String brarea = (String) request.getSession().getAttribute("brarea");
        String brbid = (String) request.getSession().getAttribute("brbid");
        if (StringUtils.isBlank(brarea)) {
            brarea = riVo.getBrarea();
        }
        if (StringUtils.isBlank(brbid)) {
            brbid = riVo.getBrbid();
        }
        String brcode = MyStringUtil.getBrcode(brarea, brbid, "");
        if (StringUtils.isNotBlank(brcode)) {
            riVo.setBrcode(brcode);
        }
        System.out.println(riVo);

        // 设置分页信息
        PageHelper.startPage(riVo.getPage(), riVo.getLimit());
        // 查询
        List list = dormService.findRepairInfoListByPage(riVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 查看报修详情
     *
     * @return
     */
    @RequestMapping(value = "/repair/detail.html")
    public String repairDetail() {
        return "/dm/repair-detail";
    }


    /**
     * 导出报修数据
     *
     * @param request
     * @param response
     */
    @ResponseBody
    @RequestMapping(value = "/repair/export.action")
    public void exportToExcel(HttpServletRequest request, HttpServletResponse response) {
        HashMap map = new HashMap<>();
        response.reset();// 清除缓存

        // 获取宿管员管理的宿舍区和楼栋号,拼接成brcode
        String brarea = (String) request.getSession().getAttribute("brarea");
        String brbid = (String) request.getSession().getAttribute("brbid");
        String brcode = MyStringUtil.getBrcode(brarea, brbid, "");
        String status = request.getParameter("status");

        System.out.println("status" + status);
        System.out.println("brcode" + brcode);
        // 根据条件查找报修列表
        List list = dormService.exportRepairInfo(brcode, status);

        // 拼接excel表名
        StringBuffer filenamebuffer = new StringBuffer();
        if (StringUtils.isNotBlank(brcode)) {
            filenamebuffer.append(brcode);
            filenamebuffer.append("-");
        }
        filenamebuffer.append("报修表");
        String filename = filenamebuffer.toString();
        try {
            ExcelUtils.writeExcel(filename, response, list, RepairInfo.class);
            map.put("success", true);
            map.put("msg", "导出成功!");
            System.out.println(JSON.toJSONString(map));
        } catch (Exception e) {
            e.printStackTrace();
            map.put("success", false);
            map.put("msg", "导出失败!");
        }
//        return JSON.toJSONString(map);
    }

    /**
     * 批量更改报修状态
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/repair/edit")
    public String editRepairStatus(HttpServletRequest request) {
        HashMap map = new HashMap<>();
        String params = request.getParameter("params");
        if (StringUtils.isNotBlank(params)) {
            boolean result = dormService.batchEditRepairStatus(params);
            if (result) {
                map.put("success", true);
                map.put("msg", "更改成功!");
                return JSON.toJSONString(map);
            } else {
                map.put("success", false);
                map.put("msg", "更改失败!");
                return JSON.toJSONString(map);
            }
        }
        map.put("success", false);
        map.put("msg", "更改失败!请选择要更改的行。");
        return JSON.toJSONString(map);
    }

    /**
     * 学生报修列表
     *
     * @return
     */
    @RequestMapping(value = "/buildroomList")
    public String viewBuildRoomList() {
        return "/dm/buildroom-list";
    }

    /**
     * 查看宿舍信息
     *
     * @param biVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/buildroom/list")
    public DataGridViewResult findBuildRoomInfo(BuildRoomInfoVo biVo, HttpServletRequest request) {
        // 拼接brcode
        String brarea = (String) request.getSession().getAttribute("brarea");
        if (StringUtils.isBlank(brarea)) {
            brarea = biVo.getBrarea();
        }
        /*
         * 如果管理员负责具体的一栋楼,则只能查询本栋楼有关的宿舍信息;
         * 如果是负责一个区,则可以查询这个区下所有楼的宿舍信息
         * session中没有brbid说明是负责一个区的,此时按照用户输入的楼栋数来进行查询
         */
        String brbid = (String) request.getSession().getAttribute("brbid");
        if (StringUtils.isBlank(brbid)) {
            brbid = biVo.getBrbid();
        }
        String brrid = biVo.getBrrid();
        String brcode = MyStringUtil.getBrcode(brarea, brbid, brrid);
        if (StringUtils.isNotBlank(brcode)) {
            biVo.setBrcode(brcode);
        }
        System.out.println(biVo);

        // 设置分页信息
        PageHelper.startPage(biVo.getPage(), biVo.getLimit());
        // 查询
        List list = dormService.findBuildRoomInfoListByPage(biVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 单个添加宿舍信息
     *
     * @param bi
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/buildroom/add")
    public String addBuildRoomInfo(BuildRoomInfo bi) {
        HashMap map = new HashMap<>();
        // 拼接brcode,如果brcode是空,说明宿舍信息错误了
        String brarea = bi.getBrarea();
        String brbid = bi.getBrbid();
        String brrid = bi.getBrrid();
        String brcode = MyStringUtil.getBrcode(brarea, brbid, brrid);
        if (StringUtils.isBlank(brcode)) {
            map.put("success", false);
            map.put("msg", "添加失败!宿舍信息错误!");
            return JSON.toJSONString(map);
        }

        // 计算空余数
        Integer free = bi.getVolume() - bi.getPeople();
        if (free < 0) {
            map.put("success", false);
            map.put("msg", "添加失败!入住数不能大于床位数!");
            return JSON.toJSONString(map);
        }

        bi.setBrcode(brcode);
        bi.setFree(free);
        System.out.println(bi);
        List list = new ArrayList<>();
        list.add(bi);

        boolean result = dormService.addBuildRoomInfo(list);
        if (result) {
            map.put("success", true);
            map.put("msg", "添加成功!");
        } else {
            map.put("success", false);
            map.put("msg", "添加失败!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 导入宿舍信息
     *
     * @param file excel表格
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/buildroom/import.action")
    public String importExcel(@RequestParam("file") MultipartFile file) {
        HashMap map = new HashMap<>();
        try {
            List list = ExcelUtils.readExcel("", BuildRoomInfo.class, file);
            // 拼接brcode和计算空余数
            for (int i = 0; i < list.size(); i++) {
                String brarea = list.get(i).getBrarea();
                String brbid = list.get(i).getBrbid();
                String brrid = list.get(i).getBrrid();
                String brcode = MyStringUtil.getBrcode(brarea, brbid, brrid);
                Integer free = list.get(i).getVolume() - list.get(i).getPeople();
                list.get(i).setBrcode(brcode);
                list.get(i).setFree(free);
            }
            boolean result = dormService.addBuildRoomInfo(list);
            if (result) {
                map.put("code", 200);
                map.put("msg", "导入成功!");
                map.put("data", null);
            } else {
                map.put("code", 500);
                map.put("msg", "导入失败!");
                map.put("data", null);
            }
        } catch (Exception e) {
            e.printStackTrace();
            map.put("code", 500);
            map.put("msg", "导入失败!");
            map.put("data", null);
        }
        return JSON.toJSONString(map);
    }

    /**
     * 更改宿舍信息
     *
     * @param bi
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/buildroom/update")
    public String updateBuildRoomInfo(BuildRoomInfo bi) {
        HashMap map = new HashMap<>();
        try {
            // 如果入住数小于等于床位数,则执行更新操作,否则返回提示
            Integer free = bi.getVolume() - bi.getPeople();
            if (free >= 0) {
                bi.setFree(free);
                System.out.println(bi);
                int result = dormService.updateBuildRoomInfo(bi);
                // 返回值大于0表示成功执行了更改操作,小于0表示发生了异常
                if (result > 0) {
                    map.put("success", true);
                    map.put("msg", "更改成功!");
                    return JSON.toJSONString(map);
                } else {
                    map.put("success", false);
                    map.put("msg", "更改失败!");
                    return JSON.toJSONString(map);
                }
            } else {
                map.put("success", false);
                map.put("msg", "更改失败!入住数不能大于床位数!");
                return JSON.toJSONString(map);
            }
        } catch (Exception e) {
            e.printStackTrace();
            map.put("success", false);
            map.put("msg", "更改失败!");
            return JSON.toJSONString(map);
        }
    }

    /**
     * 删除宿舍信息
     *
     * @param brcode
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/buildroom/delete")
    public String deleteBuildRoomInfo(String brcode) {
        System.out.println(brcode);
        HashMap map = new HashMap<>();
        int result = dormService.deleteBuildRoomInfo(brcode);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "删除成功!");
        } else {
            map.put("success", false);
            map.put("msg", "删除失败!");
        }
        return JSON.toJSONString(map);
    }

    @RequestMapping(value = "/messageList")
    public String viewMessageBoard() {
        return "/dm/message-list";
    }


    /**
     * 公告管理、失物招领
     *
     * @param mbVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/message/list")
    public DataGridViewResult findMessageList(MessageBoardVo mbVo, HttpServletRequest request) {
        // 获取当前管理员的管理区域
        // 如果管理员负责众多楼栋,则按查询条件的宿舍区和楼栋来查,否则只能查他所负责的楼栋的公告信息
        String brarea = (String) request.getSession().getAttribute("brarea");
        String brbid = (String) request.getSession().getAttribute("brbid");
        if (StringUtils.isBlank(brarea)) {
            brarea = mbVo.getBrarea();
        }
        if (StringUtils.isBlank(brbid)) {
            brbid = mbVo.getBrbid();
        }
        String brcode = MyStringUtil.getBrcode(brarea, brbid, "");
        mbVo.setBrcode(brcode);
        System.out.println(mbVo);

        // 设置分页信息
        PageHelper.startPage(mbVo.getPage(), mbVo.getLimit());
        // 查询
        List list = dormService.findMessageListByPage(mbVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 添加公告/失物招领信息
     *
     * @param mb
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/message/add")
    public String addMessage(MessageBoard mb, HttpServletRequest request) {
        // announcer是管理员的uname
        String uname = (String) request.getSession().getAttribute("uname");
        mb.setAnnouncer(uname);

        HashMap map = new HashMap<>();
        int result = dormService.addMessage(mb);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "添加成功!");
        } else {
            map.put("success", false);
            map.put("msg", "添加失败!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 更新公告/失物招领
     *
     * @param mb
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/message/update")
    public String updateMessage(MessageBoard mb) {
        // 拼接brcode
        String brcode = MyStringUtil.getBrcode(mb.getBrarea(), mb.getBrbid(), "");
        mb.setBrcode(brcode);

        System.out.println(mb);

        HashMap map = new HashMap<>();
        int result = dormService.updateMessage(mb);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "更改成功!");
        } else {
            map.put("success", false);
            map.put("msg", "更改失败!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 批量删除公告/失物招领信息
     *
     * @param request 获取前端传来的id数组
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/message/delete")
    public String deleteMessage(HttpServletRequest request) {
        HashMap map = new HashMap<>();
        String params = request.getParameter("params");
        System.out.println(params);
        try {
            if (StringUtils.isNotBlank(params)) {
                // 获取id数组
                JSONArray jsonArray = JSONArray.parseArray(params);
                List list = new ArrayList<>();
                for (int i = 0; i < jsonArray.size(); i++) {
                    JSONObject obj = jsonArray.getJSONObject(i);
                    Integer id = (Integer) obj.get("id");
                    System.out.println(id);
                    list.add(id);
                }
                boolean result = dormService.deleteMessage(list);
                if (result) {
                    map.put("success", true);
                    map.put("msg", "删除成功!");
                } else {
                    map.put("success", false);
                    map.put("msg", "删除失败!");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            map.put("success", false);
            map.put("msg", "删除失败!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 留校信息列表
     *
     * @return
     */
    @RequestMapping(value = "/stayinList")
    public String viewStayInfoList() {
        return "/dm/stayin-list";
    }

    /**
     * 查找留校信息列表
     *
     * @param stVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/stayin/list")
    public DataGridViewResult findStayInfoListByPage(StayInfoVo stVo, HttpServletRequest request) {
        String brarea = (String) request.getSession().getAttribute("brarea");
        String brbid = (String) request.getSession().getAttribute("brbid");
        if (StringUtils.isNotBlank(brarea)) {
            stVo.setBrarea(brarea);
        }
        if (StringUtils.isNotBlank(brbid)) {
            stVo.setBrbid(brbid);
        }
        System.out.println(stVo);
        // 设置分页信息
        PageHelper.startPage(stVo.getPage(), stVo.getLimit());
        // 查询
        List list = dormService.findStayInfoListByPage(stVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 导出学生留校信息
     *
     * @param request
     * @param response
     */
    @ResponseBody
    @RequestMapping(value = "/stayin/export.action")
    public void exportStayInfoToExcel(HttpServletRequest request, HttpServletResponse response) {
        response.reset();// 清除缓存
        String brarea = (String) request.getSession().getAttribute("brarea");
        String brbid = (String) request.getSession().getAttribute("brbid");
        // 查找学生登记信息
        List list = dormService.exportStayInfo(brarea, brbid);

        // 拼接excel表名
        StringBuffer filenamebuffer = new StringBuffer();
        if (StringUtils.isNotBlank(brarea)) {
            filenamebuffer.append(brarea);
            filenamebuffer.append("-");
        }
        if (StringUtils.isNotBlank(brbid)) {
            filenamebuffer.append(brbid);
            filenamebuffer.append("栋-");
        }
        filenamebuffer.append("学生留校信息");
        String filename = filenamebuffer.toString();
        try {
            ExcelUtils.writeExcel(filename, response, list, StayInfo.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取留校申请中的统计数据
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/stayin/echartsData")
    public String getStayInfoEchartsData(HttpServletRequest request) {
        String brarea = (String) request.getSession().getAttribute("brarea");
        String brbid = (String) request.getSession().getAttribute("brbid");
        JSONObject data = dormService.getStayInfoEchartsData(brarea, brbid);
        System.out.println(JSON.toJSONString(data));
        return JSON.toJSONString(data);
    }

    /**
     * 预分配宿舍界面
     *
     * @return
     */
    @RequestMapping(value = "/allocation/pre")
    public String preAllocateDorm() {
        return "/dm/pre-allocate";
    }

    /**
     * 查找空余寝室
     *
     * @param biVo
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/room/list")
    public DataGridViewResult getFreeRoomList(BuildRoomInfoVo biVo) {
        System.out.println(biVo);
        // 设置分页信息
        PageHelper.startPage(biVo.getPage(), biVo.getLimit());
        // 查询
        List list = dormService.findFreeRoomListByPage(biVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 查找未分配寝室的学生
     *
     * @param siVo
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/student/list")
    public DataGridViewResult getNotAllocateStudentList(StudentInfoVo siVo) {
        System.out.println(siVo);
        // 设置分页信息
        PageHelper.startPage(siVo.getPage(), siVo.getLimit());
        // 查询
        List list = dormService.findNotAllocateStudentListByPage(siVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    @ResponseBody
    @RequestMapping(value = "/allocation/doAllocate")
    public String doAllocate(HttpServletRequest request) {
        HashMap map = new HashMap<>();
        String room = request.getParameter("room");
        String student = request.getParameter("student");
        System.out.println(room);
        System.out.println(student);
        map.put("msg", "接受到数据");
        return JSON.toJSONString(map);
    }

    /**
     * 判断床位数够不够
     *
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/allocation/isEnough")
    public String judgeIsEnough() {
        HashMap map = new HashMap<>();
        boolean enough = dormService.judgeIsEnough();
        if (enough) {
            map.put("success", true);
        } else {
            map.put("success", false);
            map.put("msg", "床位数不够,请先添加空余宿舍信息!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 全部分配
     *
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/allocation/assignAll")
    public String assignAll() {
        HashMap map = new HashMap<>();
        boolean success = dormService.doAssignAll();
        if (success) {
            map.put("success", true);
            map.put("msg", "分配完毕,分配结果显示在当前页面下方。");
        } else {
            map.put("success", false);
            map.put("msg", "分配失败!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 显示分配结果
     *
     * @param aiVo
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/allocation/result")
    public DataGridViewResult viewAllocateResult(AllocationInfoVo aiVo) {
        // 设置分页信息
        PageHelper.startPage(aiVo.getPage(), aiVo.getLimit());
        // 查询
        List list = dormService.viewAllocateResult(aiVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }


    /**
     * 宿舍分配列表
     *
     * @return
     */
    @RequestMapping(value = "/allocation/list")
    public String allocationList() {
        return "/dm/allocation-list";
    }


    /**
     * 查询宿舍分配信息
     * 查询条件:专业/年级
     *
     * @param aiVo
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/allocation/info")
    public DataGridViewResult findAllocationInfoList(AllocationInfoVo aiVo, HttpServletRequest request) {
        String brarea = (String) request.getSession().getAttribute("brarea");
        String brbid = (String) request.getSession().getAttribute("brbid");
        if (StringUtils.isNotBlank(brarea)) {
            aiVo.setBrarea(brarea);
        }
        if (StringUtils.isNotBlank(brbid)) {
            aiVo.setBrbid(brbid);
        }
        System.out.println(aiVo);
        // 设置分页信息
        PageHelper.startPage(aiVo.getPage(), aiVo.getLimit());
        // 查询
        List list = dormService.findAllocationInfoListByPage(aiVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }


    /**
     * 导出学生宿舍分配信息
     *
     * @param request
     * @param response
     */
    @ResponseBody
    @RequestMapping(value = "/allocation/export.action")
    public void exportAllocationInfoToExcel(HttpServletRequest request, HttpServletResponse response) {
        response.reset();// 清除缓存
        String brarea = (String) request.getSession().getAttribute("brarea");
        String brbid = (String) request.getSession().getAttribute("brbid");
        // 查找宿舍分配信息
        List list = dormService.exportAllocationInfo(brarea, brbid);

        // 拼接excel表名
        StringBuffer filenamebuffer = new StringBuffer();
        if (StringUtils.isNotBlank(brarea)) {
            filenamebuffer.append(brarea);
            filenamebuffer.append("-");
        }
        if (StringUtils.isNotBlank(brbid)) {
            filenamebuffer.append(brbid);
            filenamebuffer.append("栋-");
        }
        filenamebuffer.append("学生宿舍分配名单");
        String filename = filenamebuffer.toString();
        try {
            ExcelUtils.writeExcel(filename, response, list, AllocationInfo.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
@Controller
@RequestMapping("/")
public class IndexController {
    @Resource
    private IndexService indexService;
    @Resource
    private MenuService menuService;

    public String index() {
        return "index";
    }

    @RequestMapping(value = "/login.html")
    public String toLogin() {
        return "/login";
    }

    @RequestMapping(value = "/home.html")
    public String home() {
        return "/home";
    }


    /**
     * 验证登录
     *
     * @param re      前端返回的参数
     * @param session 将用户信息添加到session中
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/login.action")
    public String loginAction(@RequestBody Map re, HttpSession session) {
        String uid = re.get("username");
        String upwd = re.get("password");
        Integer utype = Integer.parseInt(re.get("type"));
        System.out.println(utype);
        Users user = indexService.findUserByuId(uid, upwd, utype);
        Map map = new HashMap<>();
        if (user != null) {
            session.setAttribute("uid", uid);
            session.setAttribute("uname", user.getUname());
            session.setAttribute("utype", utype);
            // 如果是教师或宿管员,还要把他们负责的部门(专业年级/宿舍楼)记下
            if (utype == 1) {
                session.setAttribute("dept", user.getDept());
                session.setAttribute("grade", user.getGrade());
            } else if (utype == 2) {
                session.setAttribute("brarea", user.getBrarea());
                session.setAttribute("brbid", user.getBrbid());
            }
            map.put("type", "success");
        } else {
            map.put("type", "error");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 退出登录
     *
     * @param session
     * @return 返回到登录界面
     */
    @RequestMapping(value = "/logout.action")
    public String logout(HttpSession session) {
        // 清空session中的属性
        session.removeAttribute("uid");
        session.removeAttribute("uname");
        session.removeAttribute("utype");
        //让session无效
        session.invalidate();
        return "redirect:/login";
    }

    @ResponseBody
    @RequestMapping(value = "/api/loadMenuList")
    public String loadMenuList(HttpSession session) {
        Integer utype = (Integer) session.getAttribute("utype");
        String initJson = menuService.loadMenuList(utype);
        System.out.println(initJson);
        return initJson;
    }

    /**
     * 基本资料
     *
     * @param session
     * @return
     */
    @RequestMapping(value = "/basic-info.html")
    public String setBasicInfo(HttpSession session) {
        Integer utype = (Integer) session.getAttribute("utype");
        // 是学生则返回学生的界面
        if (utype == 0) {
            return "/student/basic-info";
        } else {
            return "/basic-info";
        }
    }


    /**
     * 修改密码
     *
     * @return
     */
    @RequestMapping(value = "/password-setting.html")
    public String setPassword() {
        return "/password-setting";
    }

    @ResponseBody
    @RequestMapping(value = "/updatePassword.action")
    public String updatePassword(HttpServletRequest request) {
        HashMap map = new HashMap<>();

        String uid = (String) request.getSession().getAttribute("uid");
        Integer utype = (Integer) request.getSession().getAttribute("utype");
        String param = request.getParameter("param");
        System.out.println(param);
        try {
            if (StringUtils.isNotBlank(param)) {
                JSONObject obj = JSONObject.parseObject(param);
                String old_password = (String) obj.get("old_password");
                String new_password = (String) obj.get("new_password");
                int result = indexService.updatePassword(uid, utype, old_password, new_password);
                switch (result) {
                    case -1:
                        map.put("success", false);
                        map.put("msg", "系统出错,修改失败!");
                        break;
                    case 0:
                        map.put("success", false);
                        map.put("msg", "旧密码不正确!");
                        break;
                    case 1:
                        map.put("success", true);
                        map.put("msg", "修改成功!");
                }
                return JSON.toJSONString(map);
            }
        } catch (Exception e) {
            e.printStackTrace();
            map.put("success", false);
            map.put("msg", "系统出错,修改失败!");
        }
        return JSON.toJSONString(map);
    }
}
@Controller
@RequestMapping
public class MenuController {

    @Resource
    private MenuService menuService;


}
@Controller
@RequestMapping("/student")
public class StudentController {
    @Resource
    private StudentService studentService;

    /**
     * 我的卫生检查记录界面
     *
     * @return
     */
    @RequestMapping(value = "/viewMyCleanInfo")
    public String viewMyCleanInfo() {
        return "/student/clean-list";
    }

    /**
     * 查询我的宿舍卫生检查记录
     *
     * @param ciVo    分页信息
     * @param request 用于获取session中的uid
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/clean/list")
    public DataGridViewResult findMyCleanInfoListByPage(CleanInfoVo ciVo, HttpServletRequest request) {
        // 获取学号
        String uid = (String) request.getSession().getAttribute("uid");
        ciVo.setStuid(uid);
        // 设置分页信息
        PageHelper.startPage(ciVo.getPage(), ciVo.getLimit());
        // 查询
        List list = studentService.findMyCleanInfoListByPage(ciVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 我的报修界面
     *
     * @return
     */
    @RequestMapping(value = "/viewMyRepairInfo")
    public String viewMyRepairInfo() {
        return "/student/repair-list";
    }

    /**
     * 查询我的宿舍的报修记录
     *
     * @param riVo    分页信息
     * @param request 用于获取session中的uid
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/repair/list")
    public DataGridViewResult findMyRepairInfoListByPage(RepairInfoVo riVo, HttpServletRequest request) {
        // 获取学号
        String uid = (String) request.getSession().getAttribute("uid");
        riVo.setStuid(uid);
        // 设置分页信息
        PageHelper.startPage(riVo.getPage(), riVo.getLimit());
        // 查询
        List list = studentService.findMyRepairInfoListByPage(riVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 提交报修单
     *
     * @param ri
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/repair/add")
    public String addRepairInfo(RepairInfo ri, HttpServletRequest request) {
        HashMap map = new HashMap<>();
        String stuid = (String) request.getSession().getAttribute("uid");
        ri.setStuid(stuid);
        // 报修提交时间
        Date date = new Date();
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        ri.setSubtime(format.format(date));
        System.out.println(ri);

        // 去执行添加操作
        int result = studentService.addRepairInfo(ri);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "添加成功");
        } else {
            map.put("success", false);
            map.put("msg", "添加失败");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 修改报修单
     *
     * @param ri
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/repair/update")
    public String updateRepairInfo(RepairInfo ri, HttpServletRequest request) {
        HashMap map = new HashMap<>();
        System.out.println(ri);

        // 判断这是不是自己的提交的报修单
        String stuid = (String) request.getSession().getAttribute("uid");
        if (!stuid.equals(ri.getStuid())) {
            map.put("success", false);
            map.put("msg", "只能修改自己提交的报修单!");
            return JSON.toJSONString(map);
        }

        int result = studentService.updateRepairInfo(ri);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "修改成功!");
        } else {
            map.put("success", false);
            map.put("msg", "修改失败!");
        }
        return JSON.toJSONString(map);
    }


    /**
     * 我的宿舍界面
     *
     * @return
     */
    @RequestMapping(value = "/viewMyDormInfo")
    public String viewMyDormInfo() {
        return "/student/myDorm";
    }


    /**
     * 查看留言板
     *
     * @return
     */
    @RequestMapping(value = "/viewMessageBoard")
    public String viewMessageBoard() {
        return "/student/messageboard";
    }

    @ResponseBody
    @RequestMapping(value = "/message/list")
    public String findMessageListByPage(HttpServletRequest request) {
        HashMap map = new HashMap<>();
        try {
            // 获取id,用来查找所在宿舍区
            String uid = (String) request.getSession().getAttribute("uid");
            // 获取当前页
            Integer curr = Integer.parseInt(request.getParameter("curr"));
            // 获取页面size
            Integer limit = Integer.parseInt(request.getParameter("limit"));
            // 获取信息类型
            Integer type = Integer.parseInt(request.getParameter("type"));
            // 起始行数
            Integer start = (curr - 1) * limit;
            List list = studentService.findMessageListByPage(uid, start, limit, type);
            // 总行数
            Integer count = studentService.findMessageCount(type);
            // 总页数
            Integer total = (count - 1) / limit + 1;
            map.put("success", true);
            map.put("count", count);
            map.put("total", total);
            map.put("curr", curr);
            map.put("limit", limit);
            map.put("data", list);
            System.out.println(JSON.toJSONString(map));
            return JSON.toJSONString(map);
        } catch (Exception e) {
            e.printStackTrace();
            map.put("success", false);
            map.put("msg", "系统错误!");
            return JSON.toJSONString(map);
        }
    }

    /**
     * 查看我的留言
     *
     * @return
     */
    @RequestMapping(value = "viewMyMessage")
    public String viewMyMessage() {
        return "/student/my-message";
    }


    /**
     * 查看我的留言
     *
     * @param mbVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/message/my")
    public DataGridViewResult myMessage(MessageBoardVo mbVo, HttpServletRequest request) {
        String uname = (String) request.getSession().getAttribute("uname");
        mbVo.setAnnouncer(uname);

        // 设置分页信息
        PageHelper.startPage(mbVo.getPage(), mbVo.getLimit());
        // 查询
        List list = studentService.findMyMessage(mbVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 发布留言
     *
     * @param mb
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/message/add")
    public String addMessage(MessageBoard mb, HttpServletRequest request) {
        String uname = (String) request.getSession().getAttribute("uname");
        mb.setAnnouncer(uname);

        HashMap map = new HashMap<>();
        int result = studentService.addMessage(mb);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "添加成功!");
        } else {
            map.put("success", false);
            map.put("msg", "添加失败!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 批量删除留言
     *
     * @param request 获取前端传来的id数组
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/message/delete")
    public String deleteMessage(HttpServletRequest request) {
        HashMap map = new HashMap<>();
        String params = request.getParameter("params");
        System.out.println(params);
        try {
            if (StringUtils.isNotBlank(params)) {
                // 获取id数组
                JSONArray jsonArray = JSONArray.parseArray(params);
                List list = new ArrayList<>();
                for (int i = 0; i < jsonArray.size(); i++) {
                    JSONObject obj = jsonArray.getJSONObject(i);
                    Integer id = (Integer) obj.get("id");
                    list.add(id);
                }
                boolean result = studentService.deleteMessage(list);
                if (result) {
                    map.put("success", true);
                    map.put("msg", "删除成功!");
                } else {
                    map.put("success", false);
                    map.put("msg", "删除失败!");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            map.put("success", false);
            map.put("msg", "删除失败!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 查看学生基本信息
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/basic/info")
    public String viewStudentInfo(HttpServletRequest request) {
        HashMap map = new HashMap<>();

        String stuid = (String) request.getSession().getAttribute("uid");
        if (StringUtils.isNotBlank(stuid)) {
            StudentInfo si = studentService.findStudentInfoByStuid(stuid);
            if (si != null) {
                map.put("success", true);
                map.put("data", si);
            } else {
                map.put("success", false);
                map.put("msg", "系统错误:不存在该用户!");
            }
        }
        return JSON.toJSONString(map);
    }

    /**
     * 更改基本信息
     *
     * @param si
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/basic/update")
    public String updateStudentInfo(StudentInfo si) {
        HashMap map = new HashMap<>();
        System.out.println(si);
        int result = studentService.updateStudentInfo(si);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "保存成功!");
        } else {
            map.put("success", false);
            map.put("msg", "保存失败!");
        }
        return JSON.toJSONString(map);
    }

    @RequestMapping(value = "/leave/register")
    public String myLeaveInfo() {
        return "/student/leave-info";
    }

    /**
     * 查找我的离校登记记录
     *
     * @param liVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/leave/list")
    public DataGridViewResult findMyLeaveInfoByPage(LeaveInfoVo liVo, HttpServletRequest request) {
        String stuid = (String) request.getSession().getAttribute("uid");
        liVo.setStuid(stuid);
        System.out.println(liVo);

        // 设置分页信息
        PageHelper.startPage(liVo.getPage(), liVo.getLimit());
        // 查询
        List list = studentService.findMyLeaveInfoByPage(liVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }


    /**
     * 添加离校登记记录
     *
     * @param li
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/leave/add")
    public String addMyLeaveInfo(LeaveInfo li, HttpServletRequest request) {
        HashMap map = new HashMap<>();

        String stuid = (String) request.getSession().getAttribute("uid");
        li.setStuid(stuid);
        System.out.println(li);

        int result = studentService.addMyLeaveInfo(li);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "登记成功!");
        } else {
            map.put("success", false);
            map.put("msg", "登记失败,请稍后再试!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 修改离校登记记录
     *
     * @param li
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/leave/update")
    public String updateMyLeaveInfo(LeaveInfo li) {
        HashMap map = new HashMap<>();

        System.out.println(li);

        int result = studentService.updateMyLeaveInfo(li);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "更改成功!");
        } else {
            map.put("success", false);
            map.put("msg", "更改失败,请稍后再试!");
        }
        return JSON.toJSONString(map);
    }


    /**
     * 留校申请
     *
     * @return
     */
    @RequestMapping(value = "/stayin/apply")
    public String myStayInfo() {
        return "/student/stayin-apply";
    }

    /**
     * 查看自己的留校申请
     *
     * @param siVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/stayin/list")
    public DataGridViewResult findMyStayInfoListByPage(StayInfoVo siVo, HttpServletRequest request) {
        String stuid = (String) request.getSession().getAttribute("uid");
        siVo.setStuid(stuid);
        System.out.println(siVo);

        // 设置分页信息
        PageHelper.startPage(siVo.getPage(), siVo.getLimit());
        // 查询
        List list = studentService.findMyStayInfoListByPage(siVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 上传图片
     *
     * @param file
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/stayin/uploadImage")
    public String uploadOpinionImage(MultipartFile file, HttpServletRequest request) {
        HashMap map = new HashMap<>();
        HashMap data = new HashMap<>();
        try {
            if (file != null) {
                String stuid = (String) request.getSession().getAttribute("uid");
                String originalFilename = file.getOriginalFilename();
                Date date = new Date();
                String fileName = date.getTime() + "-" + originalFilename;
                // 类路径
//                String path = ResourceUtils.getURL("classpath:").getPath();
                String classPath = "F:/IDEA/workspace/高校宿舍管理系统/doms/target/classes/static";
                // 父路径
                String src = "/upload/stayin/" + stuid + "/";
                File directory = new File(classPath, src);
                if (!directory.exists()) {
                    directory.mkdir();
                }
                // 文件名
                String imagePath = directory.getPath() + "\\" + fileName;
                System.out.println(imagePath);
                file.transferTo(new File(imagePath));
                data.put("src", src + fileName);
                map.put("code", 0);
                map.put("msg", "上传成功!");
                map.put("data", data);
                return JSON.toJSONString(map);
            } else {
                map.put("code", -1);
                map.put("msg", "请选择图片!");
                return JSON.toJSONString(map);
            }
        } catch (Exception e) {
            e.printStackTrace();
            map.put("code", -1);
            map.put("msg", "上传失败,请稍后重试!");
            return JSON.toJSONString(map);
        }
    }


    /**
     * 提交留校申请
     *
     * @param si
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/stayin/add")
    public String addStayInfo(StayInfo si, HttpServletRequest request) {
        HashMap map = new HashMap<>();
        String stuid = (String) request.getSession().getAttribute("uid");
        si.setStuid(stuid);

        System.out.println(si);
        int result = studentService.addMyStayInfo(si);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "提交申请成功");
        } else {
            map.put("success", false);
            map.put("msg", "提交申请失败,请稍后重试!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 修改留校申请信息
     *
     * @param si
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/stayin/update")
    public String updateMyStayInfo(StayInfo si) {
        HashMap map = new HashMap<>();

        System.out.println(si);

        int result = studentService.updateMyStayInfo(si);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "修改成功!");
        } else {
            map.put("success", false);
            map.put("msg", "修改失败,请稍后再试!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 查看我的返校信息
     *
     * @return
     */
    @RequestMapping(value = "/viewMyBackInfo")
    public String viewMyBackToScInfo() {
        return "/student/back-info";
    }

    /**
     * 查找我的返校登记记录
     *
     * @param bsVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/back/list")
    public DataGridViewResult findMyBackInfoByPage(BackToScInfoVo bsVo, HttpServletRequest request) {
        String stuid = (String) request.getSession().getAttribute("uid");
        bsVo.setStuid(stuid);
        System.out.println(bsVo);

        // 设置分页信息
        PageHelper.startPage(bsVo.getPage(), bsVo.getLimit());
        // 查询
        List list = studentService.findMyBackInfoByPage(bsVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }


    /**
     * 添加返校登记记录
     *
     * @param bs
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/back/add")
    public String addMyBackInfo(BackToScInfo bs, HttpServletRequest request) {
        HashMap map = new HashMap<>();

        String stuid = (String) request.getSession().getAttribute("uid");
        bs.setStuid(stuid);
        System.out.println(bs);

        int result = studentService.addMyBackInfo(bs);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "提交成功!");
        } else {
            map.put("success", false);
            map.put("msg", "提交失败,请稍后再试!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 修改返校登记记录
     *
     * @param bs
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/back/update")
    public String updateMyBackInfo(BackToScInfo bs) {
        HashMap map = new HashMap<>();

        System.out.println(bs);

        int result = studentService.updateMyBackInfo(bs);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "更改成功!");
        } else {
            map.put("success", false);
            map.put("msg", "更改失败,请稍后再试!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 密码设置
     *
     * @return
     */
    @RequestMapping(value = "/setting")
    public String passwordSetting() {
        return "password-setting";
    }

    @RequestMapping(value = "/myDormitoryInfo")
    public String viewMyDormitoryInfo() {
        return "/student/my-dormitory";
    }

    /**
     * 查看自己宿舍信息
     *
     * @param aiVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/mydorm/list")
    public DataGridViewResult findMyDormitoryInfoListByPage(AllocationInfoVo aiVo, HttpServletRequest request) {
        String stuid = (String) request.getSession().getAttribute("uid");
        aiVo.setStuid(stuid);
        System.out.println(aiVo);

        // 设置分页信息
        PageHelper.startPage(aiVo.getPage(), aiVo.getLimit());
        // 查询
        List list = studentService.findMyDormitoryInfoListByPage(aiVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 判断是否已经选择床位了
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/mydorm/isChoosed")
    public String isChooseBed(HttpServletRequest request) {
        HashMap map = new HashMap<>();
        String stuid = (String) request.getSession().getAttribute("uid");
        boolean status = studentService.isChooseBed(stuid);
        map.put("status", status);
        return JSON.toJSONString(map);
    }

    /**
     * 提交选择的床位号
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/mydorm/chooseBed")
    public String chooseBed(HttpServletRequest request) {
        HashMap map = new HashMap<>();
        String stuid = (String) request.getSession().getAttribute("uid");
        String bed = request.getParameter("bed");
        if (StringUtils.isNotBlank(bed)) {
            int bedNum = Integer.parseInt(bed);
            // 提交床位号
            int result = studentService.chooseBed(stuid, bedNum);
            if (result > 0) {
                map.put("success", true);
                map.put("msg", "选择成功!");
            } else {
                map.put("success", false);
                map.put("msg", "选择失败!");
            }
            return JSON.toJSONString(map);
        } else {
            map.put("success", false);
            map.put("msg", "床位号不能为空!");
            return JSON.toJSONString(map);
        }
    }

    /**
     * 查找已经选择了的床位
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/mydorm/alreadyBeds")
    public String findAlreadyChooseBeds(HttpServletRequest request) {
        HashMap map = new HashMap<>();
        String stuid = (String) request.getSession().getAttribute("uid");
        List list = studentService.findAlreadyChooseBeds(stuid);
        map.put("beds", list);
        return JSON.toJSONString(map);
    }
}
/**
 * 教师对应的控制器
 */
@Controller
@RequestMapping("/teacher")
public class TeacherController {
    @Resource
    private TeacherService teacherService;

    @RequestMapping(value = "/viewAllocationInfo")
    public String allocationList() {
        return "/teacher/allocation-list";
    }

    /**
     * 查询宿舍分配信息
     * 查询条件:专业/年级
     *
     * @param aiVo
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/allocation/list")
    public DataGridViewResult findAllocationInfoList(AllocationInfoVo aiVo, HttpServletRequest request) {
        // 获取session中的专业和年级
        String dept = (String) request.getSession().getAttribute("dept");
        String grade = (String) request.getSession().getAttribute("grade");
        if (StringUtils.isNotBlank(dept)) {
            aiVo.setStudept(dept);
        }
        if (StringUtils.isNotBlank(grade)) {
            aiVo.setStugrade(grade);
        }
        System.out.println(aiVo);
        // 设置分页信息
        PageHelper.startPage(aiVo.getPage(), aiVo.getLimit());
        // 查询
        List list = teacherService.findAllocationInfoListByPage(aiVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 添加宿舍分配信息
     *
     * @param ai
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/allocation/add")
    public String addAllocationInfo(AllocationInfo ai) {
        HashMap map = new HashMap<>();
        int result = teacherService.addAllocationInfo(ai);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "添加成功!");
        } else {
            map.put("success", false);
            map.put("msg", "添加失败!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 更改宿舍分配信息
     *
     * @param ai
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/allocation/update")
    public String updateAllocationInfo(AllocationInfo ai) {
        HashMap map = new HashMap<>();
        int result = teacherService.updateAllocationInfo(ai);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "更改成功!");
        } else {
            map.put("success", false);
            map.put("msg", "更改失败!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 删除宿舍分配信息
     *
     * @param stuid
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/allocation/delete")
    public String deleteAllocationInfo(String stuid) {
        HashMap map = new HashMap<>();
        int result = teacherService.deleteAllocationInfo(stuid);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "删除成功!");
        } else {
            map.put("success", false);
            map.put("msg", "删除失败!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 导出宿舍分配信息列表(excel格式)
     *
     * @param request  用来获取缓存中的attribute
     * @param response 输出文件流
     */
    @ResponseBody
    @RequestMapping(value = "/allocation/export.action")
    public void exportAllocationInfoToExcel(HttpServletRequest request, HttpServletResponse response) {
        HashMap map = new HashMap<>();
        response.reset();// 清除缓存
        String studept = (String) request.getSession().getAttribute("dept");
        String grade = (String) request.getSession().getAttribute("grade");
        System.out.println("studept" + studept);
        System.out.println("grade" + grade);
        // 查找宿舍分配信息列表
        List list = teacherService.exportByDept(studept, grade);

        // 拼接excel表名
        StringBuffer filenamebuffer = new StringBuffer();
        if (StringUtils.isNotBlank(studept)) {
            filenamebuffer.append(studept);
            filenamebuffer.append("-");
        }
        if (StringUtils.isNotBlank(grade)) {
            filenamebuffer.append(grade);
            filenamebuffer.append("-");
        }
        filenamebuffer.append("宿舍分配表");
        String filename = filenamebuffer.toString();
        try {
            ExcelUtils.writeExcel(filename, response, list, AllocationInfo.class);
            map.put("success", true);
            map.put("mag", "导出成功!");
        } catch (Exception e) {
            e.printStackTrace();
            map.put("success", false);
            map.put("mag", "导出失败!");
        }
//        return JSON.toJSONString(map);
    }


    @RequestMapping(value = "/viewStudentInfo")
    public String studentList() {
        return "/teacher/student-list";
    }

    /**
     * 获取学生信息列表
     *
     * @param si
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/student/list")
    public DataGridViewResult findStudentInfoList(StudentInfoVo si, HttpServletRequest request) {
        // 获取教师所负责的专业和年级,年级对应学号
        String studept = (String) request.getSession().getAttribute("dept");
        String grade = (String) request.getSession().getAttribute("grade");
        if (StringUtils.isNotBlank(studept)) {
            si.setStudept(studept);
        }
        // 如果学号为空,则教师负责的年级作为学号的前缀条件
        if (StringUtils.isBlank(si.getStuid())) {
            if (StringUtils.isNotBlank(grade)) {
                si.setStuid(grade);
            }
        }
        System.out.println(si);

        // 设置分页信息
        PageHelper.startPage(si.getPage(), si.getLimit());
        // 查询
        List list = teacherService.findStudentInfoListByPage(si);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }


    /**
     * 添加学生信息
     *
     * @param si
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/student/add")
    public String addStudentInfo(StudentInfo si) {
        HashMap map = new HashMap<>();
        String grade = si.getStuid().substring(0, 4);
        si.setStugrade(grade);
        System.out.println(grade);
        int result = teacherService.addStudentInfo(si);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "添加成功!");
        } else {
            map.put("success", false);
            map.put("msg", "添加失败!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 更改学生信息
     *
     * @param si
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/student/update")
    public String updateStudentInfo(StudentInfo si) {
        HashMap map = new HashMap<>();
        int result = teacherService.updateStudentInfo(si);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "更改成功!");
        } else {
            map.put("success", false);
            map.put("msg", "更改失败!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 删除学生信息
     *
     * @param stuid
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/student/delete")
    public String deleteaddStudentInfo(String stuid) {
        HashMap map = new HashMap<>();
        int result = teacherService.deleteStudentInfo(stuid);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "删除成功!");
        } else {
            map.put("success", false);
            map.put("msg", "删除失败!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 导入学生信息
     *
     * @param file excel表格
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/student/import.action")
    public String importExcel(@RequestParam("file") MultipartFile file) {
        HashMap map = new HashMap<>();

        try {
            List list = ExcelUtils.readExcel("", StudentInfo.class, file);
            for (int i = 0; i < list.size(); i++) {
                String grade = list.get(i).getStuid().substring(0, 4);
                list.get(i).setStugrade(grade);
                System.out.println(grade);
            }
            boolean result = teacherService.batchInsert(list);
            if (result) {
                map.put("code", 200);
                map.put("msg", "导入成功!");
                map.put("data", null);
            } else {
                map.put("code", 500);
                map.put("msg", "导入失败!");
                map.put("data", null);
            }
        } catch (Exception e) {
            e.printStackTrace();
            map.put("code", 500);
            map.put("msg", "导入失败,请检查文件内容是否正确。");
            map.put("data", null);
        }
        return JSON.toJSONString(map);
    }

    /**
     * 查看卫生检查情况
     *
     * @return
     */
    @RequestMapping(value = "/viewCleanInfo")
    public String viewCleanInfo() {
        return "/teacher/clean-list";
    }

    /**
     * 专业班级卫生检查信息
     *
     * @param ciVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/clean/list")
    public DataGridViewResult findCleanInfoListByPage(CleanInfoVo ciVo, HttpServletRequest request) {
        // 获取session中的专业和年级
        String dept = (String) request.getSession().getAttribute("dept");
        String grade = (String) request.getSession().getAttribute("grade");
        if (StringUtils.isNotBlank(dept)) {
            ciVo.setStudept(dept);
        }
        if (StringUtils.isNotBlank(grade)) {
            ciVo.setStuid(grade);
        }
        System.out.println(ciVo);
        // 设置分页信息
        PageHelper.startPage(ciVo.getPage(), ciVo.getLimit());
        // 查询
        List list = teacherService.findCleanInfoListByPage(ciVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    @RequestMapping(value = "/viewLeaveInfo")
    public String viewLeaveInfo() {
        return "/teacher/leave-info";
    }

    @ResponseBody
    @RequestMapping(value = "/leave/list")
    public DataGridViewResult findLeaveInfoByPage(LeaveInfoVo liVo, HttpServletRequest request) {
        // 专业和年级
        String dept = (String) request.getSession().getAttribute("dept");
        String grade = (String) request.getSession().getAttribute("grade");
        if (StringUtils.isNotBlank(dept)) {
            liVo.setStudept(dept);
        }
        if (StringUtils.isNotBlank(grade)) {
            liVo.setStugrade(grade);
        }
        System.out.println(liVo);
        // 设置分页信息
        PageHelper.startPage(liVo.getPage(), liVo.getLimit());
        // 查询
        List list = teacherService.findLeaveInfoListByPage(liVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    @ResponseBody
    @RequestMapping(value = "/leave/delete")
    public String batchDeleteLeaveInfo(HttpServletRequest request) {
        HashMap map = new HashMap<>();
        String params = request.getParameter("params");
        try {
            if (StringUtils.isBlank(params)) {
                map.put("success", false);
                map.put("msg", "请选择要删除的行!");
                return JSON.toJSONString(map);
            }
            boolean result = teacherService.batchDeleteLeaveInfo(params);
            if (result) {
                map.put("success", true);
                map.put("msg", "删除成功!");
            } else {
                map.put("success", false);
                map.put("msg", "系统错误,请稍后再试!");
            }
        } catch (Exception e) {
            e.printStackTrace();
            map.put("success", false);
            map.put("msg", "系统错误,请稍后再试!");
        }
        return JSON.toJSONString(map);
    }


    /**
     * 将学生去向信息导出到Excel中
     *
     * @param request
     * @param response
     */
    @ResponseBody
    @RequestMapping(value = "/leave/export.action")
    public void exportLeaveInfoToExcel(HttpServletRequest request, HttpServletResponse response) {
        response.reset();// 清除缓存
        String studept = (String) request.getSession().getAttribute("dept");
        String stugrade = (String) request.getSession().getAttribute("grade");
        // 查找学生登记信息
        List list = teacherService.exportLeaveInfo(studept, stugrade);

        // 拼接excel表名
        StringBuffer filenamebuffer = new StringBuffer();
        if (StringUtils.isNotBlank(studept)) {
            filenamebuffer.append(studept);
            filenamebuffer.append("-");
        }
        if (StringUtils.isNotBlank(stugrade)) {
            filenamebuffer.append(stugrade);
            filenamebuffer.append("级-");
        }
        filenamebuffer.append("节假日去向表");
        String filename = filenamebuffer.toString();
        try {
            ExcelUtils.writeExcel(filename, response, list, LeaveInfo.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取饼状图的数据
     *
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/leave/echartsData")
    public String getLeaveInfoEchartsData(HttpServletRequest request) {
        String studept = (String) request.getSession().getAttribute("dept");
        String stugrade = (String) request.getSession().getAttribute("grade");
        HashMap map = teacherService.getLeaveInfoEchartsData(studept, stugrade);
        String result = JSON.toJSONString(map);
        System.out.println(result);
        return result;
    }


    /**
     * 留校管理
     *
     * @return
     */
    @RequestMapping(value = "/stayinManage")
    public String stayinManege() {
        return "/teacher/stayin-manage";
    }

    /**
     * 留校申请列表
     *
     * @param siVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/stayin/list")
    public DataGridViewResult findStayInfoListByPage(StayInfoVo siVo, HttpServletRequest request) {
        String studept = (String) request.getSession().getAttribute("dept");
        String stugrade = (String) request.getSession().getAttribute("grade");
        if (StringUtils.isNotBlank(studept)) {
            siVo.setStudept(studept);
        }
        if (StringUtils.isNotBlank(stugrade)) {
            siVo.setStugrade(stugrade);
        }
        System.out.println(siVo);

        // 设置分页信息
        PageHelper.startPage(siVo.getPage(), siVo.getLimit());
        // 查询
        List list = teacherService.findStayInfoListByPage(siVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 审批学生留校申请
     *
     * @param si
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/stayin/approve")
    public String approveStayInfo(StayInfo si) {
        HashMap map = new HashMap<>();
        System.out.println(si);
        int result = teacherService.approveStayInfo(si);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "审批成功");
        } else {
            map.put("success", false);
            map.put("msg", "审批失败,请稍后再试!");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 导出学生留校申请信息
     *
     * @param request
     * @param response
     */
    @ResponseBody
    @RequestMapping(value = "/stayin/export.action")
    public void exportStayInfoToExcel(HttpServletRequest request, HttpServletResponse response) {
        response.reset();// 清除缓存
        String studept = (String) request.getSession().getAttribute("dept");
        String stugrade = (String) request.getSession().getAttribute("grade");
        // 查找学生登记信息
        List list = teacherService.exportStayInfo(studept, stugrade);

        // 拼接excel表名
        StringBuffer filenamebuffer = new StringBuffer();
        if (StringUtils.isNotBlank(studept)) {
            filenamebuffer.append(studept);
            filenamebuffer.append("-");
        }
        if (StringUtils.isNotBlank(stugrade)) {
            filenamebuffer.append(stugrade);
            filenamebuffer.append("级-");
        }
        filenamebuffer.append("留校申请表");
        String filename = filenamebuffer.toString();
        try {
            ExcelUtils.writeExcel(filename, response, list, StayInfo.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取留校申请中的统计数据
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/stayin/echartsData")
    public String getStayInfoEchartsData(HttpServletRequest request) {
        String studept = (String) request.getSession().getAttribute("dept");
        String stugrade = (String) request.getSession().getAttribute("grade");
        JSONObject data = teacherService.getStayInfoEchartsData(studept, stugrade);
        System.out.println(JSON.toJSONString(data));
        return JSON.toJSONString(data);
    }

    @RequestMapping(value = "/backManage")
    public String backManage() {
        return "/teacher/back-manage";
    }

    /**
     * 查找学生返校信息
     *
     * @param bsVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/back/list")
    public DataGridViewResult findBackToScInfoListByPage(BackToScInfoVo bsVo, HttpServletRequest request) {
        String studept = (String) request.getSession().getAttribute("dept");
        String stugrade = (String) request.getSession().getAttribute("grade");
        if (StringUtils.isNotBlank(studept)) {
            bsVo.setStudept(studept);
        }
        if (StringUtils.isNotBlank(stugrade)) {
            bsVo.setStugrade(stugrade);
        }
        System.out.println(bsVo);

        // 设置分页信息
        PageHelper.startPage(bsVo.getPage(), bsVo.getLimit());
        // 查询
        List list = teacherService.findBackToScInfoListByPage(bsVo);
        // 创建分页对象
        PageInfo pageInfo = new PageInfo(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 导出学生返校登记信息
     *
     * @param request
     * @param response
     */
    @ResponseBody
    @RequestMapping(value = "/back/export.action")
    public void exportBackToScInfoToExcel(HttpServletRequest request, HttpServletResponse response) {
        response.reset();// 清除缓存
        String studept = (String) request.getSession().getAttribute("dept");
        String stugrade = (String) request.getSession().getAttribute("grade");
        // 查找学生登记信息
        List list = teacherService.exportBackToScInfo(studept, stugrade);

        // 拼接excel表名
        StringBuffer filenamebuffer = new StringBuffer();
        if (StringUtils.isNotBlank(studept)) {
            filenamebuffer.append(studept);
            filenamebuffer.append("-");
        }
        if (StringUtils.isNotBlank(stugrade)) {
            filenamebuffer.append(stugrade);
            filenamebuffer.append("级-");
        }
        filenamebuffer.append("返校登记表");
        String filename = filenamebuffer.toString();
        try {
            ExcelUtils.writeExcel(filename, response, list, BackToScInfo.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取返校登记的统计数据
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/back/echartsData")
    public String getBackToScInfoEchartsData(HttpServletRequest request) {
        String studept = (String) request.getSession().getAttribute("dept");
        String stugrade = (String) request.getSession().getAttribute("grade");
        JSONObject data = teacherService.getBackToScInfoEchartsData(studept, stugrade);
        System.out.println(JSON.toJSONString(data));
        return JSON.toJSONString(data);
    }
}

你可能感兴趣的:(课程设计,spring,boot,后端,java)