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）学生 可以选择床位、查看自己所在的宿舍以及同宿舍人员的信息；填写、查看和 修改自己宿舍的报修单；查看每周的卫生检查情况；节假日时填写离校登记信息、寒暑假提交留校申请以及填写返校登记信息；查看留言板上的公告、失物招领信 息，发布留言等；修改自己的基本信息和账号的密码。
（2）辅导员
负责维护学生的基本信息；查看学生宿舍分配信息；查看学生节假日的去向 信息和返校信息；查看和审批学生的寒暑假留校的申请；查看学生的卫生检查情况。
（3）宿舍管理员
负责维护宿舍信息；为新生分配宿舍；处理学生的报修申请；发布公告、失 物招领等信息到留言板上；查看学生寒暑假留校信息；每周进行卫生检查并将检 查情况记录到系统中。
4.实现效果展示
（1）登录
为了保证系统的安全性，用户在进入系统前必须先登录，通过账号的合法性检验 后才能进入系统。 登录的界面如图 4.1 所示，用户输入账号信息，点击“登录”的按钮，将表单数 据提交到后端。如果存在相应的用户信息，则系统跳转到对应权限的页面；不然验 证失败，系统给予错误提示。
（2） 学生端
学生端主页面如图 4.2 所示，其功能主要包括了我的宿舍、离返校登记、留言板、 基本资料管理等。
我的宿舍
学生可以查看本人所在的宿舍和室友的信息。如果是初次进入本系统，系统 将提示学生选择床位，床位选择界面如图 4.3 所示，学生可以根据系统提供的宿 舍布局为参考，从未被选择的床位中选取自己想要的床位。
我的报修
学生可以查看本宿舍的报修信息（包括自己提交的和他人提交的），填写和 修改报修单信息，但只能修改本人提交的报修单，且只能修改未处理的，正在处 理和已处理的报修信息则不能被更改。
卫生检查记录
学生可以查看自己宿舍的卫生检查情况，系统优先显示近期的记录，对于不 合格（低于 60 分）的记录，系统将高亮显示，提醒学生。
系统将显示学生所有的离校登记信息，学生也可以在该页面下提交和编辑登 记信息。填写时，学生需选择去向类型，如果是回家或者外出，必须填写目的地、 回校时间、紧急联系人，如果是留校，以上三项信息则无需填写。
留校申请
寒暑假期间有留校需求的学生需要向学院提交留校申请。申请填写页面如图 4.8 所示，学生需要说明留校的原因，留校的截止时间，并提供家长手写的同意 留校及安全保证承诺的图片。
返校登记
临近开学时学生要填写返校信息，主要内容有是否要延迟返校、返校时间、 延迟的原因、交通方式以及车次的信息。
（3）留言板
在这里，学生可以查看所在楼栋的相关留言信息，包括公告、失物招领以及 普通留言；也可以发布留言与他人进行沟通，编辑和查看自己的留言等。 留言信息以便签的形式呈现出来，不同类型的留言使用不同的底色以示区分。
（4）辅导员端
辅导员端的主页面如图 4.11 所示，主要实现了对学生事务的管理及宿舍相关事 务的查看，包含了学生管理、离返校管理、卫生管理三个模块。
学生管理
主要完成对学生信息的增、删、查、改等操作。 添加分为单条信息添加和批量添加。单条信息添加页面如图 4.12 所示，辅 导员需录入学生的学院、专业、班级、姓名及学号信息。批量添加则是通过导入Excel 表格来实现的，辅导员在给定的 Excel 模板中填写学生的信息，点击“导 入”按钮将文件上传，后端把表格的每一行解析成一条学生信息，批量插入到数 据库中。
宿舍管理
辅导员可按专业、班级来查看学生的宿舍分配信息，还可以将分配信息导出 成 Excel 文件。
离校管理-
节假日去向管理
用于查看学生节假日的去向信息，可以按去向类型（留校、回家、外出）来 查看，系统还统计了每种类型的学生人数及比例，并以饼状图的形式展现出来。
离校管理-假期留校管理
主要用来查看和审批学生假期的留校申请信息，系统同样也支持将这些信息 导出，并且也统计了留校学生在每个宿舍区的人数，以饼状图展现出来。
离校管理-返校管理
用于查看和导出各学生的返校情况，同样也实现了对按时返校与延迟返校的 信息统计。
（5）宿舍管理员端
宿舍管理员端界面如下图 4.19 所示，主要包括了宿舍管理、留校管理、住宿管 理及日常管理四个功能，用于对宿舍事务进行管理。
宿舍管理
实现了对宿舍信息的维护。系统支持单个宿舍信息的添加和批量的添加，批 量添加是通过 Excel 的导入来实现的。查找宿舍信息可以通过指定宿舍区、楼栋、 寝室以及宿舍的入住状态（已住满/未住满）来查询。
住宿管理-预分配管理
系统为还未分配宿舍的学生分配宿舍，主要用于大一的新生。系统从数据中 查出未分配宿舍的学生列表和有空余床位的宿舍列表，按照优先同性别、同学院、 同专业、同班级的原则，按学号从小到大的顺序将学生安排进空余宿舍中。每分配好一个学生，宿舍的空余数就减 1，当该宿舍的空余数为 0 时，将后续学生安 排进下一个宿舍，直至所有学生分配完毕。
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<CleanInfo> list = dormService.findCleanInfoListByPage(ciVo);
// 创建分页对象
PageInfo<CleanInfo> pageInfo = new PageInfo<CleanInfo>(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<String, Object> 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<String, Object> 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<String, Object> 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<RepairInfo> list = dormService.findRepairInfoListByPage(riVo);
// 创建分页对象
PageInfo<RepairInfo> pageInfo = new PageInfo<RepairInfo>(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<String, Object> 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<RepairInfo> 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<String, Object> 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<RepairInfo> list = dormService.findBuildRoomInfoListByPage(biVo);
// 创建分页对象
PageInfo<RepairInfo> pageInfo = new PageInfo<RepairInfo>(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<String, Object> 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<BuildRoomInfo> 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<String, Object> map = new HashMap<>();
try {
List<BuildRoomInfo> 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<String, Object> 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<String, Object> 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<MessageBoard> list = dormService.findMessageListByPage(mbVo);
// 创建分页对象
PageInfo<MessageBoard> pageInfo = new PageInfo<MessageBoard>(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<String, Object> 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<String, Object> 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<String, Object> map = new HashMap<>();
String params = request.getParameter("params");
System.out.println(params);
try {
if (StringUtils.isNotBlank(params)) {
// 获取id数组
JSONArray jsonArray = JSONArray.parseArray(params);
List<Integer> 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<StayInfo> list = dormService.findStayInfoListByPage(stVo);
// 创建分页对象
PageInfo<StayInfo> pageInfo = new PageInfo<StayInfo>(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<StayInfo> 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<BuildRoomInfo> list = dormService.findFreeRoomListByPage(biVo);
// 创建分页对象
PageInfo<BuildRoomInfo> pageInfo = new PageInfo<BuildRoomInfo>(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<StudentInfo> list = dormService.findNotAllocateStudentListByPage(siVo);
// 创建分页对象
PageInfo<StudentInfo> pageInfo = new PageInfo<StudentInfo>(list);
// 按接口要求返回数据
DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
return data;
}
@ResponseBody
@RequestMapping(value = "/allocation/doAllocate")
public String doAllocate(HttpServletRequest request) {
HashMap<String, Object> 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<String, Object> 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<String, Object> 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<AllocationInfo> list = dormService.viewAllocateResult(aiVo);
// 创建分页对象
PageInfo<AllocationInfo> pageInfo = new PageInfo<AllocationInfo>(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<AllocationInfo> list = dormService.findAllocationInfoListByPage(aiVo);
// 创建分页对象
PageInfo<AllocationInfo> pageInfo = new PageInfo<AllocationInfo>(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<AllocationInfo> 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<String, String> 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<String, Object> 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<String, Object> 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<CleanInfo> list = studentService.findMyCleanInfoListByPage(ciVo);
// 创建分页对象
PageInfo<CleanInfo> pageInfo = new PageInfo<CleanInfo>(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<RepairInfo> list = studentService.findMyRepairInfoListByPage(riVo);
// 创建分页对象
PageInfo<RepairInfo> pageInfo = new PageInfo<RepairInfo>(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<String, Object> 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<String, Object> 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<String, Object> 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<MessageBoard> 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<MessageBoard> list = studentService.findMyMessage(mbVo);
// 创建分页对象
PageInfo<MessageBoard> pageInfo = new PageInfo<MessageBoard>(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<String, Object> 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<String, Object> map = new HashMap<>();
String params = request.getParameter("params");
System.out.println(params);
try {
if (StringUtils.isNotBlank(params)) {
// 获取id数组
JSONArray jsonArray = JSONArray.parseArray(params);
List<Integer> 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<String, Object> 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<String, Object> 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<LeaveInfo> list = studentService.findMyLeaveInfoByPage(liVo);
// 创建分页对象
PageInfo<LeaveInfo> pageInfo = new PageInfo<LeaveInfo>(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<String, Object> 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<String, Object> 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<StayInfo> list = studentService.findMyStayInfoListByPage(siVo);
// 创建分页对象
PageInfo<StayInfo> pageInfo = new PageInfo<StayInfo>(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<String, Object> map = new HashMap<>();
HashMap<String, Object> 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<String, Object> 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<String, Object> 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<BackToScInfo> list = studentService.findMyBackInfoByPage(bsVo);
// 创建分页对象
PageInfo<BackToScInfo> pageInfo = new PageInfo<BackToScInfo>(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<String, Object> 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<String, Object> 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<AllocationInfo> list = studentService.findMyDormitoryInfoListByPage(aiVo);
// 创建分页对象
PageInfo<AllocationInfo> pageInfo = new PageInfo<AllocationInfo>(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<String, Object> 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<String, Object> 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<String, Object> map = new HashMap<>();
String stuid = (String) request.getSession().getAttribute("uid");
List<Integer> 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<AllocationInfo> list = teacherService.findAllocationInfoListByPage(aiVo);
// 创建分页对象
PageInfo<AllocationInfo> pageInfo = new PageInfo<AllocationInfo>(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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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<AllocationInfo> 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<StudentInfo> list = teacherService.findStudentInfoListByPage(si);
// 创建分页对象
PageInfo<StudentInfo> pageInfo = new PageInfo<StudentInfo>(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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> map = new HashMap<>();
try {
List<StudentInfo> 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<CleanInfoVo> list = teacherService.findCleanInfoListByPage(ciVo);
// 创建分页对象
PageInfo<CleanInfoVo> pageInfo = new PageInfo<CleanInfoVo>(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<LeaveInfo> list = teacherService.findLeaveInfoListByPage(liVo);
// 创建分页对象
PageInfo<LeaveInfo> pageInfo = new PageInfo<LeaveInfo>(list);
// 按接口要求返回数据
DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
return data;
}
@ResponseBody
@RequestMapping(value = "/leave/delete")
public String batchDeleteLeaveInfo(HttpServletRequest request) {
HashMap<String, Object> 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<LeaveInfo> 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<String, Object> 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<StayInfo> list = teacherService.findStayInfoListByPage(siVo);
// 创建分页对象
PageInfo<StayInfo> pageInfo = new PageInfo<StayInfo>(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<String, Object> 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<StayInfo> 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<BackToScInfo> list = teacherService.findBackToScInfoListByPage(bsVo);
// 创建分页对象
PageInfo<BackToScInfo> pageInfo = new PageInfo<BackToScInfo>(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<BackToScInfo> 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);
}
}