From b39e6d60040354797914d5ab80bb73098ed04d3a Mon Sep 17 00:00:00 2001 From: ZSQ <3528263214@qq.com> Date: Sun, 27 Apr 2025 22:20:57 +0800 Subject: [PATCH] 'zsq' --- main/Absence.java | 101 ++++++++++ main/AbsenceController.java | 85 +++++++++ main/AbsenceMapper.java | 23 +++ main/AbsenceService缺勤管理.java | 59 ++++++ main/Bed.java | 46 +++++ main/BedController.java | 65 +++++++ main/BedMapper.java | 25 +++ main/BedService在线选宿舍.java | 59 ++++++ main/Building.java | 97 ++++++++++ main/BuildingController.java | 73 +++++++ main/BuildingMapper.java | 23 +++ main/BuildingService楼层设置.java | 71 +++++++ main/Constant.java | 16 ++ main/Dormitory.java | 89 +++++++++ main/DormitoryApplication.java | 15 ++ main/DormitoryController.java | 66 +++++++ main/DormitoryMapper.java | 26 +++ main/DormitoryService宿舍编号设置.java | 112 +++++++++++ main/DormitorySet.java | 101 ++++++++++ main/DormitorySetController.java | 60 ++++++ main/DormitorySetMapper.java | 23 +++ ...vice宿舍设置增删查改数据库.java | 59 ++++++ main/DormitoryStudent.java | 77 ++++++++ main/DormitoryStudentController.java | 72 +++++++ main/DormitoryStudentMapper.java | 30 +++ ...itoryStudentService宿舍预选设置.java | 97 ++++++++++ main/Entity.java | 28 +++ main/GlobalControllerAdvice.java | 27 +++ main/Grade.java | 31 +++ main/GradeController.java | 60 ++++++ main/GradeMapper.java | 24 +++ main/GradeService年级管理.java | 59 ++++++ main/JWTUtil.java | 156 +++++++++++++++ main/LoginController.java | 52 +++++ main/MainController.java | 76 ++++++++ main/Menu.java | 82 ++++++++ main/MenuController.java | 97 ++++++++++ main/MenuMapper.java | 23 +++ main/MenuService菜单.java | 31 +++ main/MyException.java | 11 ++ main/MyWebMvcConfigurer.java | 42 ++++ main/Notice.java | 94 +++++++++ main/NoticeController.java | 70 +++++++ main/NoticeMapper.java | 26 +++ main/NoticeReceive.java | 42 ++++ main/NoticeReceiveController.java | 60 ++++++ main/NoticeReceiveMapper.java | 25 +++ main/NoticeReceiveService公告查看.java | 59 ++++++ main/NoticeService公告管理.java | 100 ++++++++++ main/Org.java | 89 +++++++++ main/OrgController.java | 111 +++++++++++ main/OrgMapper.java | 25 +++ main/OrgService机构管理.java | 65 +++++++ main/Record.java | 59 ++++++ main/RecordController.java | 60 ++++++ main/RecordMapper.java | 24 +++ ...rvice用户id的增删查改数据库.java | 59 ++++++ main/Repair.java | 108 +++++++++++ main/RepairController.java | 85 +++++++++ main/RepairMapper.java | 24 +++ main/RepairService报修管理.java | 123 ++++++++++++ main/Result.java | 105 ++++++++++ main/Selection.java | 96 ++++++++++ main/SelectionController.java | 71 +++++++ main/SelectionDormitory.java | 46 +++++ main/SelectionDormitoryController.java | 63 ++++++ main/SelectionDormitoryMapper.java | 25 +++ ...SelectionDormitoryService宿舍管理.java | 77 ++++++++ main/SelectionJoiner.java | 40 ++++ main/SelectionJoinerController.java | 60 ++++++ main/SelectionJoinerMapper.java | 25 +++ ...ce用户id筛选增删查改数据库.java | 59 ++++++ main/SelectionMapper.java | 26 +++ main/SelectionService学生查询管理.java | 110 +++++++++++ main/Storey.java | 59 ++++++ main/StoreyController.java | 60 ++++++ main/StoreyMapper.java | 23 +++ main/StoreyService楼宇管理.java | 59 ++++++ main/StuController.java | 179 ++++++++++++++++++ main/Student.java | 128 +++++++++++++ main/StudentController.java | 77 ++++++++ main/StudentMapper.java | 26 +++ main/StudentService学生管理.java | 67 +++++++ main/TokenInterceptor.java | 53 ++++++ main/User.java | 89 +++++++++ main/UserController.java | 107 +++++++++++ main/UserMapper.java | 26 +++ main/UserService用户管理.java | 96 ++++++++++ main/Visit.java | 128 +++++++++++++ main/VisitController.java | 68 +++++++ main/VisitMapper.java | 24 +++ main/VisitService来访管理.java | 59 ++++++ 92 files changed, 5808 insertions(+) create mode 100644 main/Absence.java create mode 100644 main/AbsenceController.java create mode 100644 main/AbsenceMapper.java create mode 100644 main/AbsenceService缺勤管理.java create mode 100644 main/Bed.java create mode 100644 main/BedController.java create mode 100644 main/BedMapper.java create mode 100644 main/BedService在线选宿舍.java create mode 100644 main/Building.java create mode 100644 main/BuildingController.java create mode 100644 main/BuildingMapper.java create mode 100644 main/BuildingService楼层设置.java create mode 100644 main/Constant.java create mode 100644 main/Dormitory.java create mode 100644 main/DormitoryApplication.java create mode 100644 main/DormitoryController.java create mode 100644 main/DormitoryMapper.java create mode 100644 main/DormitoryService宿舍编号设置.java create mode 100644 main/DormitorySet.java create mode 100644 main/DormitorySetController.java create mode 100644 main/DormitorySetMapper.java create mode 100644 main/DormitorySetService宿舍设置增删查改数据库.java create mode 100644 main/DormitoryStudent.java create mode 100644 main/DormitoryStudentController.java create mode 100644 main/DormitoryStudentMapper.java create mode 100644 main/DormitoryStudentService宿舍预选设置.java create mode 100644 main/Entity.java create mode 100644 main/GlobalControllerAdvice.java create mode 100644 main/Grade.java create mode 100644 main/GradeController.java create mode 100644 main/GradeMapper.java create mode 100644 main/GradeService年级管理.java create mode 100644 main/JWTUtil.java create mode 100644 main/LoginController.java create mode 100644 main/MainController.java create mode 100644 main/Menu.java create mode 100644 main/MenuController.java create mode 100644 main/MenuMapper.java create mode 100644 main/MenuService菜单.java create mode 100644 main/MyException.java create mode 100644 main/MyWebMvcConfigurer.java create mode 100644 main/Notice.java create mode 100644 main/NoticeController.java create mode 100644 main/NoticeMapper.java create mode 100644 main/NoticeReceive.java create mode 100644 main/NoticeReceiveController.java create mode 100644 main/NoticeReceiveMapper.java create mode 100644 main/NoticeReceiveService公告查看.java create mode 100644 main/NoticeService公告管理.java create mode 100644 main/Org.java create mode 100644 main/OrgController.java create mode 100644 main/OrgMapper.java create mode 100644 main/OrgService机构管理.java create mode 100644 main/Record.java create mode 100644 main/RecordController.java create mode 100644 main/RecordMapper.java create mode 100644 main/RecordService用户id的增删查改数据库.java create mode 100644 main/Repair.java create mode 100644 main/RepairController.java create mode 100644 main/RepairMapper.java create mode 100644 main/RepairService报修管理.java create mode 100644 main/Result.java create mode 100644 main/Selection.java create mode 100644 main/SelectionController.java create mode 100644 main/SelectionDormitory.java create mode 100644 main/SelectionDormitoryController.java create mode 100644 main/SelectionDormitoryMapper.java create mode 100644 main/SelectionDormitoryService宿舍管理.java create mode 100644 main/SelectionJoiner.java create mode 100644 main/SelectionJoinerController.java create mode 100644 main/SelectionJoinerMapper.java create mode 100644 main/SelectionJoinerService用户id筛选增删查改数据库.java create mode 100644 main/SelectionMapper.java create mode 100644 main/SelectionService学生查询管理.java create mode 100644 main/Storey.java create mode 100644 main/StoreyController.java create mode 100644 main/StoreyMapper.java create mode 100644 main/StoreyService楼宇管理.java create mode 100644 main/StuController.java create mode 100644 main/Student.java create mode 100644 main/StudentController.java create mode 100644 main/StudentMapper.java create mode 100644 main/StudentService学生管理.java create mode 100644 main/TokenInterceptor.java create mode 100644 main/User.java create mode 100644 main/UserController.java create mode 100644 main/UserMapper.java create mode 100644 main/UserService用户管理.java create mode 100644 main/Visit.java create mode 100644 main/VisitController.java create mode 100644 main/VisitMapper.java create mode 100644 main/VisitService来访管理.java diff --git a/main/Absence.java b/main/Absence.java new file mode 100644 index 0000000..da4e017 --- /dev/null +++ b/main/Absence.java @@ -0,0 +1,101 @@ +package com.yanzhen.entity; + +import org.hibernate.validator.constraints.Length; +import com.yanzhen.utils.Entity; +import java.util.Date; + + + +public class Absence extends Entity{// 定义一个名为Absence缺勤的类，继承自Entity类 + + private Integer id;// 定义私有变量id，用于存储缺勤记录的唯一标识符 + + private Integer studentId;// 定义私有变量studentId，用于存储学生的唯一标识符 + + private Integer dormitoryId;// 定义私有变量dormitoryId，用于存储宿舍的唯一标识符 + + private Date startTime;// 定义私有变量startTime，用于存储缺勤开始时间 + + private Date endTime;// 定义私有变量endTime，用于存储缺勤结束时间 + + @Length(max = 200)// 定义私有变量remark，用于存储备注信息，并限制其最大长度为200个字符 + private String remark; + + private Student student;// 定义私有变量student，用于存储与缺勤记录关联的学生对象 + + private Dormitory dormitory;// 定义私有变量dormitory，用于存储与缺勤记录关联的宿舍对象 + + private String name;// 定义私有变量name，用于存储缺勤记录的名称或描述 + + public Integer getId() {// 获取id的值 + return id; + } + + public void setId(Integer id) {// 设置id的值 + this.id = id; + } + + public Integer getStudentId() {// 获取studentId的值 + return studentId; + } + + public void setStudentId(Integer studentId) {// 设置studentId的值 + this.studentId = studentId; + } + + public Integer getDormitoryId() {// 获取dormitoryId的值 + return dormitoryId; + } + + public void setDormitoryId(Integer dormitoryId) {// 设置dormitoryId的值 + this.dormitoryId = dormitoryId; + } + + public Date getStartTime() {// 获取startTime的值 + return startTime; + } + + public void setStartTime(Date startTime) {// 设置startTime的值 + this.startTime = startTime; + } + + public Date getEndTime() {// 获取endTime的值 + return endTime; + } + + public void setEndTime(Date endTime) {// 设置endTime的值 + this.endTime = endTime; + } + + public String getRemark() {// 获取remark的值 + return remark; + } + + public void setRemark(String remark) {// 设置remark的值 + this.remark = remark; + } + + public Student getStudent() {// 获取student的值 + return student; + } + + public void setStudent(Student student) {// 设置student的值 + this.student = student; + } + + public Dormitory getDormitory() {// 获取dormitory的值 + return dormitory; + } + + public void setDormitory(Dormitory dormitory) { // 设置dormitory的值 + this.dormitory = dormitory; + } + + public String getName() {// 获取name的值 + return name; + } + + public void setName(String name) {// 设置name的值 + this.name = name; + } +} diff --git a/main/AbsenceController.java b/main/AbsenceController.java new file mode 100644 index 0000000..3ced4ff --- /dev/null +++ b/main/AbsenceController.java @@ -0,0 +1,85 @@ +package com.yanzhen.controller; // 定义包名 + +import com.github.pagehelper.PageInfo; // 导入分页插件 +import com.yanzhen.entity.Absence; // 导入Absence实体类 +import com.yanzhen.entity.Dormitory; // 导入Dormitory实体类 +import com.yanzhen.entity.Student; // 导入Student实体类 +import com.yanzhen.service.AbsenceService缺勤管理; // 导入AbsenceService服务接口 +import com.yanzhen.service.DormitoryService宿舍编号设置; // 导入DormitoryService服务接口 +import com.yanzhen.service.StudentService学生管理; // 导入StudentService服务接口 +import com.yanzhen.utils.Result; // 导入Result工具类 +import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解 +import org.springframework.web.bind.annotation.*; // 导入Spring MVC的注解 + +import java.util.Map; // 导入Map集合 + +@RestController // 声明这是一个控制器，并且返回的数据直接写入HTTP响应体中 +@RequestMapping("/absence") // 设置请求路径前缀为/absence +public class AbsenceController { // 定义AbsenceController类 + + @Autowired // 自动注入AbsenceService实例 + private AbsenceService缺勤管理 absenceService; + @Autowired // 自动注入StudentService实例 + private StudentService学生管理 studentService; + @Autowired // 自动注入DormitoryService实例 + private DormitoryService宿舍编号设置 dormitoryService; + + @PostMapping("create") // 映射HTTP POST请求到create方法 + public Result create(@RequestBody Absence absence){ // 接收请求体中的Absence对象 + int flag = absenceService.create(absence); // 调用服务层创建记录 + if(flag>0){ // 如果创建成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果创建失败 + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("delete") // 映射HTTP GET请求到delete方法 + public Result delete(String ids){ // 接收请求参数ids + int flag = absenceService.delete(ids); // 调用服务层删除记录 + if(flag>0){ // 如果删除成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果删除失败 + return Result.fail(); // 返回失败结果 + } + } + + @PostMapping("update") // 映射HTTP POST请求到update方法 + public Result update(@RequestBody Absence absence){ // 接收请求体中的Absence对象 + int flag = absenceService.updateSelective(absence); // 调用服务层更新记录 + if(flag>0){ // 如果更新成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果更新失败 + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("detail") // 映射HTTP GET请求到detail方法 + public Absence detail(Integer id){ // 接收请求参数id + return absenceService.detail(id); // 调用服务层获取详情并返回 + } + + @PostMapping("query") // 映射HTTP POST请求到query方法 + public Map query(@RequestBody Absence absence){ // 接收请求体中的Absence对象 + PageInfo pageInfo = new PageInfo(); // 创建分页信息对象 + if(absence.getName() != null){ // 如果请求体中的name属性不为空 + Student detailId = studentService.detailByName(absence.getName()); // 根据name查询学生ID + if(detailId != null){ // 如果找到对应的学生ID + absence.setStudentId(detailId.getId()); // 设置学生ID到absence对象中 + }else{ // 如果未找到对应的学生ID + pageInfo.setList(null); // 设置分页列表为空 + pageInfo.setSize(0); // 设置分页大小为0 + return Result.ok(pageInfo); // 返回空的分页结果 + } + } + pageInfo = absenceService.query(absence); // 调用服务层查询记录 + pageInfo.getList().forEach(entity->{ // 遍历查询结果列表 + Student detail = studentService.detail(entity.getStudentId()); // 根据学生ID查询学生详情 + entity.setStudent(detail); // 设置学生详情到absence对象中 + Dormitory dormitory = dormitoryService.detail(entity.getDormitoryId()); // 根据宿舍ID查询宿舍详情 + entity.setDormitory(dormitory); // 设置宿舍详情到absence对象中 + }); + return Result.ok(pageInfo); // 返回查询结果 + } + +} \ No newline at end of file diff --git a/main/AbsenceMapper.java b/main/AbsenceMapper.java new file mode 100644 index 0000000..61ca701 --- /dev/null +++ b/main/AbsenceMapper.java @@ -0,0 +1,23 @@ +package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包 + +import java.util.List; // 导入Java的List类，用于处理列表数据结构 + +import com.yanzhen.entity.Absence; // 导入Absence缺勤实体类，用于操作缺勤信息 + +public interface AbsenceMapper { // 定义AbsenceMapper接口，提供对Absence缺勤实体进行数据库操作的方法 + + public int create(Absence absence); // 创建一个新的Absence缺勤记录，返回影响的行数 + + public int delete(Integer id); // 根据id删除一个Absence缺勤记录，返回影响的行数 + + public int update(Absence absence); // 更新一个Absence缺勤记录，返回影响的行数 + + public int updateSelective(Absence absence); // 选择性地更新一个Absence缺勤记录，返回影响的行数 + + public List query(Absence absence); // 根据条件查询Absence缺勤记录，返回符合条件的Absence缺勤列表 + + public Absence detail(Integer id); // 根据id查询一个Absence缺勤记录的详细信息，返回Absence缺勤对象 + + public int count(Absence absence); // 根据条件统计Absence缺勤记录的数量，返回记录数量 + +} \ No newline at end of file diff --git a/main/AbsenceService缺勤管理.java b/main/AbsenceService缺勤管理.java new file mode 100644 index 0000000..73dfdef --- /dev/null +++ b/main/AbsenceService缺勤管理.java @@ -0,0 +1,59 @@ +package com.yanzhen.service; // 定义包名 + +import com.yanzhen.mapper.AbsenceMapper; // 导入AbsenceMapper接口 +import com.yanzhen.entity.Absence; // 导入Absence实体类 +import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类 +import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类 +import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解 +import org.springframework.stereotype.Service; // 导入Spring的服务层注解 +import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作 + +@Service // 标注这是一个服务层的组件 +public class AbsenceService缺勤管理 { // 定义AbsenceService类 “缺勤服务类----管理员/宿管” + + @Autowired // 自动装配AbsenceMapper对象 + private AbsenceMapper absenceMapper; + + public int create(Absence absence) { // 创建一个新的Absence记录 + return absenceMapper.create(absence); // 调用Mapper的create方法并返回结果 + } + + public int delete(String ids) { // 根据多个ID删除Absence记录 + String[] arr = ids.split(","); // 将传入的ID字符串按逗号分割成数组 + int row = 0; // 初始化删除计数器 + for (String s : arr) { // 遍历ID数组 + if(!StringUtils.isEmpty(s)){ // 如果当前ID不为空 + absenceMapper.delete(Integer.parseInt(s)); // 调用Mapper的delete方法删除对应记录 + row++; // 删除计数器加1 + } + } + return row; // 返回删除的记录数 + } + + public int delete(Integer id) { // 根据单个ID删除Absence记录 + return absenceMapper.delete(id); // 调用Mapper的delete方法并返回结果 + } + + public int update(Absence absence) { // 更新一个Absence记录 + return absenceMapper.update(absence); // 调用Mapper的update方法并返回结果 + } + + public int updateSelective(Absence absence) { // 选择性更新一个Absence记录 + return absenceMapper.updateSelective(absence); // 调用Mapper的updateSelective方法并返回结果 + } + + public PageInfo query(Absence absence) { // 查询Absence记录列表并进行分页处理 + if(absence != null && absence.getPage() != null){ // 如果Absence对象和分页参数不为空 + PageHelper.startPage(absence.getPage(),absence.getLimit()); // 设置分页参数 + } + return new PageInfo(absenceMapper.query(absence)); // 调用Mapper的query方法进行查询并返回分页信息 + } + + public Absence detail(Integer id) { // 根据ID获取Absence详情 + return absenceMapper.detail(id); // 调用Mapper的detail方法并返回结果 + } + + public int count(Absence absence) { // 统计Absence记录数量 + return absenceMapper.count(absence); // 调用Mapper的count方法并返回结果 + } +} \ No newline at end of file diff --git a/main/Bed.java b/main/Bed.java new file mode 100644 index 0000000..adde104 --- /dev/null +++ b/main/Bed.java @@ -0,0 +1,46 @@ +package com.yanzhen.entity; // 定义包名 + +import org.hibernate.validator.constraints.Length; // 导入Length注解，用于验证字符串长度 +import com.yanzhen.utils.Entity; // 导入自定义的Entity类 + +import java.util.Map; // 导入Map接口 + +public class Bed extends Entity{ // 定义Bed类，继承自Entity类 + + private Integer id; // 定义id属性，类型为Integer + + @Length(max = 50) // 使用Length注解限制bno的最大长度为50 + private String bno; // 定义bno属性，类型为String + + private Integer dormitoryId; // 定义dormitoryId属性，类型为Integer + + private Map student; // 定义student属性，类型为Map，键为String，值为Object + + // 以下为getter和setter方法 + public Integer getId() { // 获取id的值 + return id; + } + public void setId(Integer id) { // 设置id的值 + this.id = id; + } + public String getBno() { // 获取bno的值 + return bno; + } + public void setBno(String bno) { // 设置bno的值 + this.bno = bno; + } + public Integer getDormitoryId() { // 获取dormitoryId的值 + return dormitoryId; + } + public void setDormitoryId(Integer dormitoryId) { // 设置dormitoryId的值 + this.dormitoryId = dormitoryId; + } + + public Map getStudent() { // 获取student的值 + return student; + } + + public void setStudent(Map student) { // 设置student的值 + this.student = student; + } +} \ No newline at end of file diff --git a/main/BedController.java b/main/BedController.java new file mode 100644 index 0000000..9aa07db --- /dev/null +++ b/main/BedController.java @@ -0,0 +1,65 @@ +package com.yanzhen.controller; + +import com.github.pagehelper.PageInfo; +import com.yanzhen.entity.Bed; +import com.yanzhen.service.BedService在线选宿舍; +import com.yanzhen.service.DormitoryStudentService宿舍预选设置; +import com.yanzhen.utils.Result; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +import java.util.Map; + +@RestController// 声明这是一个控制器，并且返回的数据直接写入HTTP响应体中 +@RequestMapping("/bed")// 设置请求路径前缀为/bed，所有的映射都在这个路径之下 +public class BedController { + + @Autowired// 自动注入BedService实例 + private BedService在线选宿舍 bedService; + @Autowired// 自动注入DormitoryStudentService实例，处理与学生宿舍相关的业务逻辑 + private DormitoryStudentService宿舍预选设置 dormitoryStudentService; + + @PostMapping("create")// 映射HTTP POST请求到create方法 + public Result create(@RequestBody Bed bed){// 从请求体中获取Bed对象 + int flag = bedService.create(bed);// 调用bedService的create方法创建床位记录 + if(flag>0){// 如果创建成功 + return Result.ok();// 返回成功结果 + }else{// 如果创建失败 + return Result.fail();// 返回失败结果 + } + } + + @GetMapping("delete")// 映射HTTP GET请求到delete方法，删除床位记录 + public Result delete(String ids){// 从请求参数中获取要删除的床位ID字符串 + int flag = bedService.delete(ids);// 调用bedService的delete方法删除床位记录，传入要删除的床位ID字符串 + if(flag>0){// 如果删除成功 + return Result.ok();// 返回成功结果 + }else{// 如果删除失败 + return Result.fail();// 返回失败结果 + } + } + + @PostMapping("update")// 映射HTTP POST请求到update方法，更新床位信息 + public Result update(@RequestBody Bed bed){// 从请求体中获取更新后的Bed对象 + int flag = bedService.update(bed);// 调用bedService的update方法更新床位记录 + if(flag>0){// 如果更新成功 + return Result.ok();// 返回成功结果 + }else{// 如果更新失败 + return Result.fail();// 返回失败结果 + } + } + + @GetMapping("detail")// 映射HTTP GET请求到detail方法，获取床位详情 + public Bed detail(Integer id){ // 从请求参数中获取床位ID + return bedService.detail(id); // 调用bedService的detail方法获取床位详情并返回 + } + + @PostMapping("query")// 映射HTTP POST请求到query方法，查询床位列表 + public Map query(@RequestBody Bed bed){ // 从请求体中获取查询条件Bed对象 + PageInfo pageInfo = bedService.query(bed);// 调用bedService的query方法进行分页查询 + pageInfo.getList().forEach(entity->{// 遍历查询结果列表 + entity.setStudent(dormitoryStudentService.queryStudentByBedId(entity.getId()));// 为每个床位设置对应的学生信息 + }); + return Result.ok(pageInfo);// 返回包含分页信息的查询结果 + } +} diff --git a/main/BedMapper.java b/main/BedMapper.java new file mode 100644 index 0000000..6b682b1 --- /dev/null +++ b/main/BedMapper.java @@ -0,0 +1,25 @@ +package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包 + +import java.util.List; // 导入Java的List类，用于处理列表数据结构 + +import com.yanzhen.entity.Bed; // 导入Bed床实体类，用于操作床位信息 + +public interface BedMapper { // 定义BedMapper接口，提供对Bed床实体进行数据库操作的方法 + + public int create(Bed bed); // 创建一个新的Bed床记录，返回影响的行数 + + public int delete(Integer id); // 根据id删除一个Bed床记录，返回影响的行数 + + public int deleteByDormitoryId(Integer dormitoryId); // 根据宿舍ID删除所有相关的Bed床记录，返回影响的行数 + + public int update(Bed bed); // 更新一个Bed床记录，返回影响的行数 + + public int updateSelective(Bed bed); // 选择性地更新一个Bed床记录，返回影响的行数 + + public List query(Bed bed); // 根据条件查询Bed床记录，返回符合条件的Bed床列表 + + public Bed detail(Integer id); // 根据id查询一个Bed床记录的详细信息，返回Bed床对象 + + public int count(Bed bed); // 根据条件统计Bed床记录的数量，返回记录数量 + +} \ No newline at end of file diff --git a/main/BedService在线选宿舍.java b/main/BedService在线选宿舍.java new file mode 100644 index 0000000..6ce9e14 --- /dev/null +++ b/main/BedService在线选宿舍.java @@ -0,0 +1,59 @@ +package com.yanzhen.service; // 定义包名 + +import com.yanzhen.mapper.BedMapper; // 导入BedMapper接口 +import com.yanzhen.entity.Bed; // 导入Bed实体类 +import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类 +import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类 +import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解 +import org.springframework.stereotype.Service; // 导入Spring的服务层注解 +import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作 + +@Service // 标注该类为服务层组件 +public class BedService在线选宿舍 { // 定义BedService类 “在线选宿舍----学生” + + @Autowired // 自动装配BedMapper对象 + private BedMapper bedMapper; + + public int create(Bed bed) { // 创建床位记录的方法 + return bedMapper.create(bed); // 调用Mapper层的create方法并返回结果 + } + + public int delete(String ids) { // 根据多个ID删除床位记录的方法 + String[] arr = ids.split(","); // 将传入的ID字符串按逗号分割成数组 + int row = 0; // 初始化删除记录数为0 + for (String s : arr) { // 遍历ID数组 + if(!StringUtils.isEmpty(s)){ // 如果当前ID不为空 + bedMapper.delete(Integer.parseInt(s)); // 调用Mapper层的delete方法删除对应ID的记录 + row++; // 删除记录数加1 + } + } + return row; // 返回删除的记录数 + } + + public int delete(Integer id) { // 根据单个ID删除床位记录的方法 + return bedMapper.delete(id); // 调用Mapper层的delete方法并返回结果 + } + + public int update(Bed bed) { // 更新床位记录的方法 + return bedMapper.update(bed); // 调用Mapper层的update方法并返回结果 + } + + public int updateSelective(Bed bed) { // 选择性更新床位记录的方法 + return bedMapper.updateSelective(bed); // 调用Mapper层的updateSelective方法并返回结果 + } + + public PageInfo query(Bed bed) { // 查询床位记录的方法，支持分页 + if(bed != null && bed.getPage() != null){ // 如果床位对象和分页参数不为空 + PageHelper.startPage(bed.getPage(),bed.getLimit()); // 设置分页参数 + } + return new PageInfo(bedMapper.query(bed)); // 调用Mapper层的query方法并封装成PageInfo对象返回 + } + + public Bed detail(Integer id) { // 根据ID获取床位详情的方法 + return bedMapper.detail(id); // 调用Mapper层的detail方法并返回结果 + } + + public int count(Bed bed) { // 统计床位记录数量的方法 + return bedMapper.count(bed); // 调用Mapper层的count方法并返回结果 + } +} \ No newline at end of file diff --git a/main/Building.java b/main/Building.java new file mode 100644 index 0000000..94f505a --- /dev/null +++ b/main/Building.java @@ -0,0 +1,97 @@ +package com.yanzhen.entity; + +import org.hibernate.validator.constraints.Length; +import com.yanzhen.utils.Entity; + + +public class Building extends Entity{ + + private Integer id;// 定义一个私有的Integer类型的id变量，用于存储建筑的唯一标识符 + + + @Length(max = 100)// 使用@Length注解限制name字段的最大长度为100个字符 + private String name; + + private Integer type;// 定义一个私有的Integer类型的type变量，用于表示宿舍类型（例如4人间、6人间、8人间） + + + private Integer storeyNum;// 定义一个私有的Integer类型的storeyNum变量，用于存储宿舍的层数 + + + private Integer sex;// 定义一个私有的Integer类型的sex变量，可能用于表示性别或性别比例（例如男多于女或反之） + + + @Length(max = 200) // 使用@Length注解限制remark字段的最大长度为200个字符 + private String remark; + + + private Integer userId; // 定义一个私有的Integer类型的userId变量，用于关联用户表的主键ID + + + private User user;// 定义一个User类型的user变量，用于存储与该建筑相关的用户信息 + + + public Integer getId() { + return id;// 获取id的值 + } + + public void setId(Integer id) { + this.id = id;// 设置id的值 + } + + public String getName() { + return name;// 获取name的值 + } + + public void setName(String name) { + this.name = name;// 设置name的值 + } + + public Integer getType() { + return type; // 获取type的值 + } + + public void setType(Integer type) { + this.type = type;// 设置type的值 + } + + public Integer getStoreyNum() { + return storeyNum;// 获取storeyNum的值 + } + + public void setStoreyNum(Integer storeyNum) { + this.storeyNum = storeyNum;// 设置storeyNum的值 + } + + public Integer getSex() { + return sex;// 获取sex的值 + } + + public void setSex(Integer sex) { + this.sex = sex;// 设置sex的值 + } + + public String getRemark() { + return remark;// 获取remark的值 + } + + public void setRemark(String remark) { + this.remark = remark;// 设置remark的值 + } + + public Integer getUserId() { + return userId;// 获取userId的值 + } + + public void setUserId(Integer userId) { + this.userId = userId;// 设置userId的值 + } + + public User getUser() {// 获取user的值 + return user; + } + + public void setUser(User user) {// 设置user的值 + this.user = user; + } +} \ No newline at end of file diff --git a/main/BuildingController.java b/main/BuildingController.java new file mode 100644 index 0000000..7f38eca --- /dev/null +++ b/main/BuildingController.java @@ -0,0 +1,73 @@ +package com.yanzhen.controller; + +import com.github.pagehelper.PageInfo; +import com.yanzhen.entity.Building; +import com.yanzhen.entity.User; +import com.yanzhen.service.BuildingService楼层设置; +import com.yanzhen.service.UserService用户管理; +import com.yanzhen.utils.Result; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +import javax.servlet.http.HttpServletRequest; +import java.util.Map; + +@RestController // 标记为RESTful控制器 +@RequestMapping("/building") // 映射URL路径到该控制器 +public class BuildingController { + + @Autowired // 自动注入BuildingService + private BuildingService楼层设置 buildingService; + @Autowired // 自动注入UserService + private UserService用户管理 userService; + + @PostMapping("create") // 映射POST请求到create方法 + public Result create(@RequestBody Building building){ // 接收JSON格式的楼宇对象 + int flag = buildingService.create(building); // 调用服务层创建楼宇 + if(flag>0){ // 如果创建成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果创建失败 + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("delete") // 映射GET请求到delete方法 + public Result delete(String ids){ // 接收楼宇ID字符串 + int flag = buildingService.delete(ids); // 调用服务层删除楼宇 + if(flag>0){ // 如果删除成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果删除失败 + return Result.fail(); // 返回失败结果 + } + } + + @PostMapping("update") // 映射POST请求到update方法 + public Result update(@RequestBody Building building){ // 接收JSON格式的楼宇对象 + int flag = buildingService.update(building); // 调用服务层更新楼宇信息 + if(flag>0){ // 如果更新成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果更新失败 + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("detail") // 映射GET请求到detail方法 + public Building detail(Integer id){ // 接收楼宇ID + return buildingService.detail(id); // 调用服务层获取楼宇详情并返回 + } + + @PostMapping("query") // 映射POST请求到query方法 + public Map query(@RequestBody Building building, HttpServletRequest request){ // 接收JSON格式的楼宇对象和HTTP请求 + User param = (User)request.getAttribute("user"); // 从请求中获取用户信息 + User loginUser = userService.detail(param.getId()); // 调用服务层获取用户详情 + if(loginUser.getType() == 1){ // 如果用户是宿管员 + building.setUserId(loginUser.getId()); // 设置楼宇的用户ID为当前登录用户的ID + } + PageInfo pageInfo = buildingService.query(building); // 调用服务层查询楼宇列表 + pageInfo.getList().forEach(entity->{ // 遍历查询结果中的每个楼宇 + User user = userService.detail(entity.getUserId()); // 调用服务层获取每个楼宇的用户信息 + entity.setUser(user); // 将用户信息设置到楼宇对象中 + }); + return Result.ok(pageInfo); // 返回查询结果 + } +} \ No newline at end of file diff --git a/main/BuildingMapper.java b/main/BuildingMapper.java new file mode 100644 index 0000000..b2103d3 --- /dev/null +++ b/main/BuildingMapper.java @@ -0,0 +1,23 @@ +package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包 + +import java.util.List; // 导入Java的List类，用于处理列表数据结构 + +import com.yanzhen.entity.Building; // 导入Building楼宇实体类，用于操作楼宇信息 + +public interface BuildingMapper { // 定义BuildingMapper接口，提供对Building楼宇实体进行数据库操作的方法 + + public int create(Building building); // 创建一个新的Building楼宇记录，返回影响的行数 + + public int delete(Integer id); // 根据id删除一个Building楼宇记录，返回影响的行数 + + public int update(Building building); // 更新一个Building楼宇记录，返回影响的行数 + + public int updateSelective(Building building); // 选择性地更新一个Building楼宇记录，返回影响的行数 + + public List query(Building building); // 根据条件查询Building楼宇记录，返回符合条件的Building楼宇列表 + + public Building detail(Integer id); // 根据id查询一个Building楼宇记录的详细信息，返回Building楼宇对象 + + public int count(Building building); // 根据条件统计Building楼宇记录的数量，返回记录数量 + +} \ No newline at end of file diff --git a/main/BuildingService楼层设置.java b/main/BuildingService楼层设置.java new file mode 100644 index 0000000..df64bd7 --- /dev/null +++ b/main/BuildingService楼层设置.java @@ -0,0 +1,71 @@ +package com.yanzhen.service; // 定义包名 + +import com.yanzhen.entity.Storey; // 导入Storey实体类 +import com.yanzhen.mapper.BuildingMapper; // 导入BuildingMapper接口 +import com.yanzhen.entity.Building; // 导入Building实体类 +import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类 +import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类 +import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解 +import org.springframework.stereotype.Service; // 导入Spring的服务层注解 +import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作 + +@Service // 标记为服务层组件 +public class BuildingService楼层设置 { // 定义BuildingService类 “楼宇管理----管理员” + + @Autowired // 自动注入BuildingMapper依赖 + private BuildingMapper buildingMapper; + @Autowired // 自动注入StoreyService依赖 + private StoreyService楼宇管理 storeyService; + + public int create(Building building) { // 创建Building记录的方法； 目的 ：插入一条Building记录并为其创建楼层信息 + int row = 0; // 初始化受影响行数为0 + row = buildingMapper.create(building); // 调用Mapper方法插入Building记录 + Integer storeyNum = building.getStoreyNum(); // 获取建筑的楼层数量 + for(int i=1;i<=storeyNum;i++){ // 循环创建每一层 + Storey storey = new Storey(); // 实例化Storey对象 + storey.setBuildingId(building.getId()); // 设置Storey所属的建筑ID + storey.setName(i+"层"); // 设置Storey的名称为“X层” + storeyService.create(storey); // 调用StoreyService方法插入Storey记录 + } + return row; // 返回受影响行数 + } + + public int delete(String ids) { // 根据多个ID删除Building记录的方法 + String[] arr = ids.split(","); // 将传入的ID字符串按逗号分割成数组 + int row = 0; // 初始化受影响行数为0 + for (String s : arr) { // 遍历ID数组 + if(!StringUtils.isEmpty(s)){ // 如果ID不为空 + buildingMapper.delete(Integer.parseInt(s)); // 调用Mapper方法删除对应ID的Building记录 + row++; // 受影响行数加1 + } + } + return row; // 返回受影响行数 + } + + public int delete(Integer id) { // 根据单个ID删除Building记录的方法 + return buildingMapper.delete(id); // 调用Mapper方法删除对应ID的Building记录并返回受影响行数 + } + + public int update(Building building) { // 更新Building记录的方法 + return buildingMapper.update(building); // 调用Mapper方法更新Building记录并返回受影响行数 + } + + public int updateSelective(Building building) { // 选择性更新Building记录的方法 + return buildingMapper.updateSelective(building); // 调用Mapper方法选择性更新Building记录并返回受影响行数 + } + + public PageInfo query(Building building) { // 查询Building记录的方法，支持分页 + if(building != null && building.getPage() != null){ // 如果Building对象和分页参数不为空 + PageHelper.startPage(building.getPage(),building.getLimit()); // 启动分页，设置当前页和每页显示条数 + } + return new PageInfo(buildingMapper.query(building)); // 调用Mapper方法查询Building记录，并封装成PageInfo对象返回 + } + + public Building detail(Integer id) { // 根据ID查询Building详情的方法 + return buildingMapper.detail(id); // 调用Mapper方法查询对应ID的Building记录并返回 + } + + public int count(Building building) { // 统计Building记录数量的方法 + return buildingMapper.count(building); // 调用Mapper方法统计Building记录数量并返回 + } +} \ No newline at end of file diff --git a/main/Constant.java b/main/Constant.java new file mode 100644 index 0000000..41014a8 --- /dev/null +++ b/main/Constant.java @@ -0,0 +1,16 @@ +package com.yanzhen.utils; // 定义包名 + +import java.util.HashMap; // 导入HashMap类 +import java.util.Map; // 导入Map接口 + +public class Constant { // 定义公共类Constant + + //用户类型 + public static Map typeString = new HashMap<>(); // 定义一个静态的Map，用于存储用户类型和对应的字符串描述 + + static { // 静态初始化块 + typeString.put(0,"管理员"); // 将用户类型0映射为"管理员" + typeString.put(1,"宿管员"); // 将用户类型1映射为"宿管员" + } + +} \ No newline at end of file diff --git a/main/Dormitory.java b/main/Dormitory.java new file mode 100644 index 0000000..e523a17 --- /dev/null +++ b/main/Dormitory.java @@ -0,0 +1,89 @@ +package com.yanzhen.entity; + +import org.hibernate.validator.constraints.Length; +import com.yanzhen.utils.Entity; + + + + +public class Dormitory extends Entity{// 定义一个名为Dormitory宿舍的类，继承自Entity类 + + private Integer id;// 定义一个私有的Integer类型的id变量 + + + @Length(max = 50)// 使用@Length注解限制no字段的最大长度为50 + + private String no;// 定义一个私有的String类型的no变量 + + + private Integer sex; // 定义一个私有的Integer类型的sex变量 + + + private Integer type;// 定义一个私有的Integer类型的type变量 + + + private Integer capacity;// 定义一个私有的Integer类型的capacity变量 + + + private Integer storeyId;// 定义一个私有的Integer类型的storeyId变量 + + + private Integer buildingId;// 定义一个私有的Integer类型的buildingId变量 + + + public Integer getId() { + return id;// 获取id的值 + } + + public void setId(Integer id) { + this.id = id;// 设置id的值 + } + + public String getNo() { + return no;// 获取no的值 + } + + public void setNo(String no) { + this.no = no; // 设置no的值 + } + + public Integer getSex() { + return sex;// 获取sex的值 + } + + public void setSex(Integer sex) { + this.sex = sex;// 设置sex的值 + } + + public Integer getType() { + return type;// 获取type的值 + } + + public void setType(Integer type) { + this.type = type;// 设置type的值 + } + + public Integer getCapacity() { + return capacity;// 获取capacity的值 + } + + public void setCapacity(Integer capacity) { + this.capacity = capacity;// 设置capacity的值 + } + + public Integer getStoreyId() { + return storeyId;// 获取storeyId的值 + } + + public void setStoreyId(Integer storeyId) { + this.storeyId = storeyId;// 设置storeyId的值 + } + + public Integer getBuildingId() { + return buildingId;// 获取buildingId的值 + } + + public void setBuildingId(Integer buildingId) { + this.buildingId = buildingId;// 设置buildingId的值 + } +} \ No newline at end of file diff --git a/main/DormitoryApplication.java b/main/DormitoryApplication.java new file mode 100644 index 0000000..0b85af6 --- /dev/null +++ b/main/DormitoryApplication.java @@ -0,0 +1,15 @@ +package com.yanzhen; // 定义包名 + +import org.mybatis.spring.annotation.MapperScan; // 导入MyBatis的MapperScan注解 +import org.springframework.boot.SpringApplication; // 导入Spring Boot的SpringApplication类 +import org.springframework.boot.autoconfigure.SpringBootApplication; // 导入Spring Boot的SpringBootApplication注解 + +@SpringBootApplication // 标注这是一个Spring Boot应用 +@MapperScan({"com.yanzhen.mapper"}) // 扫描指定包下的Mapper接口，自动生成实现类 +public class DormitoryApplication { // 定义主应用类 + + public static void main(String[] args) { // 主方法，程序入口 + SpringApplication.run(DormitoryApplication.class, args); // 启动Spring Boot应用 + } + +} \ No newline at end of file diff --git a/main/DormitoryController.java b/main/DormitoryController.java new file mode 100644 index 0000000..8be48fb --- /dev/null +++ b/main/DormitoryController.java @@ -0,0 +1,66 @@ +package com.yanzhen.controller; + +import com.github.pagehelper.PageInfo; +import com.yanzhen.entity.Dormitory; +import com.yanzhen.service.DormitoryService宿舍编号设置; +import com.yanzhen.utils.Result; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +import java.util.Map; + +@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中，而不是解析为跳转路径。 +@RequestMapping("/dormitory") // 设置请求的根路径为 /dormitory，所有方法的请求路径都会以 /dormitory 开头。 +public class DormitoryController { // 定义一个名为 DormitoryController 的类，用于处理宿舍相关的 HTTP 请求。 + + @Autowired // 自动注入 DormitoryService 对象，用于调用业务逻辑层的方法。 + private DormitoryService宿舍编号设置 dormitoryService; + + @PostMapping("create") // 映射 HTTP POST 请求到 create 方法，路径为 /dormitory/create。 + public Result create(@RequestBody Dormitory dormitory){ // 从请求体中获取 Dormitory 对象，并调用服务层的 create 方法。 + int flag = dormitoryService.create(dormitory); // 调用服务层的 create 方法，传入 Dormitory 对象，返回操作结果标志。 + if(flag>0){ // 如果操作成功（flag > 0）。 + return Result.ok(); // 返回成功的 Result 对象。 + }else{ // 如果操作失败（flag <= 0）。 + return Result.fail(); // 返回失败的 Result 对象。 + } + } + + @GetMapping("delete") // 映射 HTTP GET 请求到 delete 方法，路径为 /dormitory/delete。 + public Result delete(String ids){ // 从请求参数中获取要删除的记录的 ID，并调用服务层的 delete 方法。 + int flag = dormitoryService.delete(ids); // 调用服务层的 delete 方法，传入 ID，返回操作结果标志。 + if(flag>0){ // 如果操作成功（flag > 0）。 + return Result.ok(); // 返回成功的 Result 对象。 + }else{ // 如果操作失败（flag <= 0）。 + return Result.fail(); // 返回失败的 Result 对象。 + } + } + + @PostMapping("update") // 映射 HTTP POST 请求到 update 方法，路径为 /dormitory/update。 + public Result update(@RequestBody Dormitory dormitory){ // 从请求体中获取 Dormitory 对象，并调用服务层的 update 方法。 + int flag = dormitoryService.update(dormitory); // 调用服务层的 update 方法，传入 Dormitory 对象，返回操作结果标志。 + if(flag>0){ // 如果操作成功（flag > 0）。 + return Result.ok(); // 返回成功的 Result 对象。 + }else{ // 如果操作失败（flag <= 0）。 + return Result.fail(); // 返回失败的 Result 对象。 + } + } + + @GetMapping("detail") // 映射 HTTP GET 请求到 detail 方法，路径为 /dormitory/detail。 + public Dormitory detail(Integer id){ // 从请求参数中获取记录的 ID，并调用服务层的 detail 方法。 + return dormitoryService.detail(id); // 调用服务层的 detail 方法，传入 ID，返回对应的 Dormitory 对象。 + } + + @PostMapping("query") // 映射 HTTP POST 请求到 query 方法，路径为 /dormitory/query。 + public Map query(@RequestBody Dormitory dormitory){ // 从请求体中获取 Dormitory 对象，并调用服务层的 query 方法。 + PageInfo pageInfo = dormitoryService.query(dormitory); // 调用服务层的 query 方法，传入 Dormitory 对象，返回分页信息。 + return Result.ok(pageInfo); // 将分页信息封装在成功的 Result 对象中并返回。 + } + + @PostMapping("init") // 映射 HTTP POST 请求到 init 方法，路径为 /dormitory/init。 + public Result init(@RequestBody Dormitory dormitory){ // 从请求体中获取 Dormitory 对象，并调用服务层的 init 方法。 + dormitoryService.init(dormitory); // 调用服务层的 init 方法，传入 Dormitory 对象。 + return Result.ok(); // 返回成功的 Result 对象。 + } + +} diff --git a/main/DormitoryMapper.java b/main/DormitoryMapper.java new file mode 100644 index 0000000..8753788 --- /dev/null +++ b/main/DormitoryMapper.java @@ -0,0 +1,26 @@ +package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包 + +import java.util.List; // 导入Java的List类，用于处理列表数据结构 + +import com.yanzhen.entity.Dormitory; // 导入Dormitory宿舍实体类，用于操作宿舍信息 +import org.apache.ibatis.annotations.Param; // 导入MyBatis的Param注解，用于传递参数到SQL语句中 + +public interface DormitoryMapper { // 定义DormitoryMapper接口，提供对Dormitory宿舍进行数据库操作的方法 + + public int create(Dormitory dormitory); // 创建一个新的Dormitory宿舍记录，返回影响的行数 + + public int delete(Integer id); // 根据id删除一个Dormitory宿舍记录，返回影响的行数 + + public int update(Dormitory dormitory); // 更新一个Dormitory宿舍记录，返回影响的行数 + + public int updateSelective(Dormitory dormitory); // 选择性地更新一个Dormitory宿舍记录，返回影响的行数 + + public List query(Dormitory dormitory); // 根据条件查询Dormitory宿舍记录，返回符合条件的Dormitory宿舍列表 + + public Dormitory detail(Integer id); // 根据id查询一个Dormitory宿舍记录的详细信息，返回Dormitory宿舍对象 + + public int count(Dormitory dormitory); // 根据条件统计Dormitory宿舍记录的数量，返回记录数量 + + public int deleteByBuildingIdAndStoryId(@Param("buildingId") Integer buildingId, @Param("storeyId")Integer storeyId); // 根据建筑ID和楼层ID删除Dormitory宿舍记录，返回影响的行数 + +} \ No newline at end of file diff --git a/main/DormitoryService宿舍编号设置.java b/main/DormitoryService宿舍编号设置.java new file mode 100644 index 0000000..2f535e3 --- /dev/null +++ b/main/DormitoryService宿舍编号设置.java @@ -0,0 +1,112 @@ +package com.yanzhen.service; // 定义包名 + +import com.yanzhen.entity.Bed; // 导入Bed实体类 +import com.yanzhen.entity.Building; // 导入Building实体类 +import com.yanzhen.entity.DormitorySet; // 导入DormitorySet实体类 +import com.yanzhen.mapper.BedMapper; // 导入BedMapper接口 +import com.yanzhen.mapper.BuildingMapper; // 导入BuildingMapper接口 +import com.yanzhen.mapper.DormitoryMapper; // 导入DormitoryMapper接口 +import com.yanzhen.entity.Dormitory; // 导入Dormitory实体类 +import com.github.pagehelper.PageHelper; // 导入PageHelper分页插件 +import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类 +import com.yanzhen.mapper.DormitorySetMapper; // 导入DormitorySetMapper接口 +import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的@Autowired注解 +import org.springframework.stereotype.Service; // 导入Spring的@Service注解 +import org.springframework.transaction.annotation.Transactional; // 导入Spring的@Transactional注解 +import org.springframework.util.StringUtils; // 导入Spring的StringUtils工具类 + +import java.util.List; // 导入Java的List集合类 + +@Service // 标注这是一个服务层的Bean +public class DormitoryService宿舍编号设置 {// “宿舍编号设置----管理员” + + @Autowired // 自动注入DormitoryMapper依赖 + private DormitoryMapper dormitoryMapper; + @Autowired // 自动注入DormitorySetMapper依赖 + private DormitorySetMapper dormitorySetMapper; + @Autowired // 自动注入BuildingMapper依赖 + private BuildingMapper buildingMapper; + @Autowired // 自动注入BedMapper依赖 + private BedMapper bedMapper; + + public int create(Dormitory dormitory) { // 创建宿舍记录 + return dormitoryMapper.create(dormitory); // 调用DormitoryMapper的create方法 + } + + public int delete(String ids) { // 根据ID字符串批量删除宿舍记录 + String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组 + int row = 0; // 初始化删除计数器 + for (String s : arr) { // 遍历ID数组 + if(!StringUtils.isEmpty(s)){ // 如果ID不为空 + dormitoryMapper.delete(Integer.parseInt(s)); // 调用DormitoryMapper的delete方法删除记录 + row++; // 删除计数器加1 + } + } + return row; // 返回删除的记录数 + } + + public int delete(Integer id) { // 根据ID删除单个宿舍记录 + return dormitoryMapper.delete(id); // 调用DormitoryMapper的delete方法 + } + + public int update(Dormitory dormitory) { // 更新宿舍记录 + return dormitoryMapper.update(dormitory); // 调用DormitoryMapper的update方法 + } + + public int updateSelective(Dormitory dormitory) { // 选择性更新宿舍记录 + return dormitoryMapper.updateSelective(dormitory); // 调用DormitoryMapper的updateSelective方法 + } + + public PageInfo query(Dormitory dormitory) { // 查询宿舍记录并分页 + if(dormitory != null && dormitory.getPage() != null){ // 如果宿舍对象和分页信息不为空 + PageHelper.startPage(dormitory.getPage(),dormitory.getLimit()); // 设置分页参数 + } + return new PageInfo(dormitoryMapper.query(dormitory)); // 返回分页后的宿舍记录列表 + } + + public Dormitory detail(Integer id) { // 根据ID查询单个宿舍详情 + return dormitoryMapper.detail(id); // 调用DormitoryMapper的detail方法 + } + + public int count(Dormitory dormitory) { // 统计符合条件的宿舍记录数 + return dormitoryMapper.count(dormitory); // 调用DormitoryMapper的count方法 + } + + @Transactional // 声明该方法需要事务管理 + public void init(Dormitory dormitory){ // 初始化宿舍数据 + DormitorySet param = new DormitorySet(); // 创建DormitorySet对象 + param.setBuildingId(dormitory.getBuildingId()); // 设置建筑ID + param.setStoreyId(dormitory.getStoreyId()); // 设置楼层ID + List dormitorySets = dormitorySetMapper.query(param); // 查询宿舍设置信息 + Building building = buildingMapper.detail(dormitory.getBuildingId()); // 查询建筑详细信息 + + //删除已有床位（先查询出来，然后批量删除） + List dormitoryList = dormitoryMapper.query(dormitory); // 查询现有的宿舍记录 + dormitoryList.forEach(item->{ // 遍历宿舍记录列表 + bedMapper.deleteByDormitoryId(item.getId()); // 删除每个宿舍对应的床位记录 + }); + //删除以有的数据(删除已有宿舍) + dormitoryMapper.deleteByBuildingIdAndStoryId(dormitory.getBuildingId(),dormitory.getStoreyId()); // 删除指定建筑和楼层的所有宿舍记录 + + dormitorySets.forEach(dormitorySet -> { // 遍历宿舍设置信息列表 + + for(int i=dormitorySet.getStart();i<=dormitorySet.getEnd();i++){ // 根据起始和结束编号生成宿舍编号 + Dormitory entity = new Dormitory(); // 创建新的宿舍对象 + entity.setNo(dormitorySet.getPrefix()+i); // 设置宿舍编号 + entity.setBuildingId(dormitory.getBuildingId()); // 设置建筑ID + entity.setStoreyId(dormitory.getStoreyId()); // 设置楼层ID + entity.setCapacity(dormitorySet.getCapacity()); // 设置宿舍容量 + entity.setSex(building.getSex()); // 设置宿舍性别限制 + entity.setType(building.getType()); // 设置宿舍类型 + dormitoryMapper.create(entity); // 创建新的宿舍记录 + for(int j=1;j<=entity.getCapacity();j++){ // 根据宿舍容量生成床位记录 + Bed bed = new Bed(); // 创建新的床位对象 + bed.setBno(entity.getNo()+"-"+j); // 设置床位编号 + bed.setDormitoryId(entity.getId()); // 设置所属宿舍ID + bedMapper.create(bed); // 创建新的床位记录 + } + } + }); + } + +} \ No newline at end of file diff --git a/main/DormitorySet.java b/main/DormitorySet.java new file mode 100644 index 0000000..9990715 --- /dev/null +++ b/main/DormitorySet.java @@ -0,0 +1,101 @@ +package com.yanzhen.entity; + +import org.hibernate.validator.constraints.Length; +import com.yanzhen.utils.Entity; + + + +public class DormitorySet extends Entity{// 定义一个名为DormitorySet的类，继承自Entity类 + + + private Integer id;// 定义一个私有的Integer类型的id变量 + + + @Length(max = 50)// 定义一个私有的String类型的prefix变量，并使用@Length注解限制其最大长度为50 + private String prefix; + + + private Integer start;// 定义一个私有的Integer类型的start变量 + + + private Integer end;// 定义一个私有的Integer类型的end变量 + + + private Integer buildingId;// 定义一个私有的Integer类型的buildingId变量 + + + private Integer storeyId;// 定义一个私有的Integer类型的storeyId变量 + + + private Integer capacity;// 定义一个私有的Integer类型的capacity变量 + + + public Integer getId() { + return id;// 获取id的值 + } + + + public void setId(Integer id) { + this.id = id;// 设置id的值 + } + + + public String getPrefix() { + return prefix;// 获取prefix的值 + } + + + public void setPrefix(String prefix) { + this.prefix = prefix;// 设置prefix的值 + } + + + public Integer getStart() { + return start;// 获取start的值 + } + + + public void setStart(Integer start) { + this.start = start;// 设置start的值 + } + + + public Integer getEnd() { + return end;// 获取end的值 + } + + + public void setEnd(Integer end) { + this.end = end;// 设置end的值 + } + + + public Integer getBuildingId() { + return buildingId;// 获取buildingId的值 + } + + + public void setBuildingId(Integer buildingId) { + this.buildingId = buildingId;// 设置buildingId的值 + } + + + public Integer getStoreyId() { + return storeyId;// 获取storeyId的值 + } + + + public void setStoreyId(Integer storeyId) { + this.storeyId = storeyId;// 设置storeyId的值 + } + + + public Integer getCapacity() { + return capacity;// 获取capacity的值 + } + + + public void setCapacity(Integer capacity) { + this.capacity = capacity;// 设置capacity的值 + } +} \ No newline at end of file diff --git a/main/DormitorySetController.java b/main/DormitorySetController.java new file mode 100644 index 0000000..481f372 --- /dev/null +++ b/main/DormitorySetController.java @@ -0,0 +1,60 @@ +package com.yanzhen.controller; + +import com.github.pagehelper.PageInfo; +import com.yanzhen.entity.DormitorySet; +import com.yanzhen.service.DormitorySetService宿舍设置增删查改数据库; +import com.yanzhen.utils.Result; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +import java.util.Map; + +@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中，而不是解析为跳转路径。 +@RequestMapping("/dormitorySet") // 设置请求的根路径为 /dormitorySet +public class DormitorySetController { // 定义一个名为 DormitorySetController 的类 + + @Autowired // 自动注入 DormitorySetService 对象 + private DormitorySetService宿舍设置增删查改数据库 dormitorySetService; + + @PostMapping("create") // 映射 HTTP POST 请求到 create 方法 + public Result create(@RequestBody DormitorySet dormitorySet){ // 从请求体中获取 DormitorySet 对象 + int flag = dormitorySetService.create(dormitorySet); // 调用服务层的 create 方法创建记录 + if(flag>0){ // 如果创建成功 + return Result.ok(); // 返回成功的 Result 对象 + }else{ // 如果创建失败 + return Result.fail(); // 返回失败的 Result 对象 + } + } + + @GetMapping("delete") // 映射 HTTP GET 请求到 delete 方法 + public Result delete(String ids){ // 从请求参数中获取要删除的记录 ID + int flag = dormitorySetService.delete(ids); // 调用服务层的 delete 方法删除记录 + if(flag>0){ // 如果删除成功 + return Result.ok(); // 返回成功的 Result 对象 + }else{ // 如果删除失败 + return Result.fail(); // 返回失败的 Result 对象 + } + } + + @PostMapping("update") // 映射 HTTP POST 请求到 update 方法 + public Result update(@RequestBody DormitorySet dormitorySet){ // 从请求体中获取 DormitorySet 对象 + int flag = dormitorySetService.update(dormitorySet); // 调用服务层的 update 方法更新记录 + if(flag>0){ // 如果更新成功 + return Result.ok(); // 返回成功的 Result 对象 + }else{ // 如果更新失败 + return Result.fail(); // 返回失败的 Result 对象 + } + } + + @GetMapping("detail") // 映射 HTTP GET 请求到 detail 方法 + public DormitorySet detail(Integer id){ // 从请求参数中获取记录 ID + return dormitorySetService.detail(id); // 调用服务层的 detail 方法获取记录详情并返回 + } + + @PostMapping("query") // 映射 HTTP POST 请求到 query 方法 + public Map query(@RequestBody DormitorySet dormitorySet){ // 从请求体中获取 DormitorySet 对象作为查询条件 + PageInfo pageInfo = dormitorySetService.query(dormitorySet); // 调用服务层的 query 方法进行分页查询 + return Result.ok(pageInfo); // 返回包含查询结果的成功的 Result 对象 + } + +} diff --git a/main/DormitorySetMapper.java b/main/DormitorySetMapper.java new file mode 100644 index 0000000..a670181 --- /dev/null +++ b/main/DormitorySetMapper.java @@ -0,0 +1,23 @@ +package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包 + +import java.util.List; // 导入Java的List类，用于处理列表数据结构 + +import com.yanzhen.entity.DormitorySet; // 导入DormitorySet宿舍设置实体类，用于操作宿舍设置信息 + +public interface DormitorySetMapper { // 定义DormitorySetMapper接口，提供对DormitorySet宿舍设置实体进行数据库操作的方法 + + public int create(DormitorySet dormitorySet); // 创建一个新的DormitorySet宿舍设置记录，返回影响的行数 + + public int delete(Integer id); // 根据id删除一个DormitorySet宿舍设置记录，返回影响的行数 + + public int update(DormitorySet dormitorySet); // 更新一个DormitorySet宿舍设置记录，返回影响的行数 + + public int updateSelective(DormitorySet dormitorySet); // 选择性地更新一个DormitorySet宿舍设置记录，返回影响的行数 + + public List query(DormitorySet dormitorySet); // 根据条件查询DormitorySet宿舍设置记录，返回符合条件的DormitorySet宿舍设置列表 + + public DormitorySet detail(Integer id); // 根据id查询一个DormitorySet宿舍设置记录的详细信息，返回DormitorySet宿舍设置对象 + + public int count(DormitorySet dormitorySet); // 根据条件统计DormitorySet宿舍设置记录的数量，返回记录数量 + +} \ No newline at end of file diff --git a/main/DormitorySetService宿舍设置增删查改数据库.java b/main/DormitorySetService宿舍设置增删查改数据库.java new file mode 100644 index 0000000..b589442 --- /dev/null +++ b/main/DormitorySetService宿舍设置增删查改数据库.java @@ -0,0 +1,59 @@ +package com.yanzhen.service; // 定义包名 + +import com.yanzhen.mapper.DormitorySetMapper; // 导入DormitorySetMapper接口 +import com.yanzhen.entity.DormitorySet; // 导入DormitorySet实体类 +import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类 +import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类 +import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解 +import org.springframework.stereotype.Service; // 导入Spring的服务层注解 +import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作 + +@Service // 标记为服务层组件 +public class DormitorySetService宿舍设置增删查改数据库 { // 定义DormitorySetService类 “宿舍管理----管理员/宿管” + + @Autowired // 自动装配DormitorySetMapper依赖 + private DormitorySetMapper dormitorySetMapper; + + public int create(DormitorySet dormitorySet) { // 创建宿舍设置记录的方法 + return dormitorySetMapper.create(dormitorySet); // 调用Mapper层的create方法 + } + + public int delete(String ids) { // 根据ID字符串批量删除DormitorySet记录的方法 + String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组 + int row = 0; // 初始化受影响行数为0 + for (String s : arr) { // 遍历ID数组 + if(!StringUtils.isEmpty(s)){ // 如果ID不为空 + dormitorySetMapper.delete(Integer.parseInt(s)); // 调用Mapper层的delete方法删除记录 + row++; // 受影响行数加1 + } + } + return row; // 返回受影响行数 + } + + public int delete(Integer id) { // 根据ID删除DormitorySet记录的方法 + return dormitorySetMapper.delete(id); // 调用Mapper层的delete方法 + } + + public int update(DormitorySet dormitorySet) { // 更新DormitorySet记录的方法 + return dormitorySetMapper.update(dormitorySet); // 调用Mapper层的update方法 + } + + public int updateSelective(DormitorySet dormitorySet) { // 选择性更新DormitorySet记录的方法 + return dormitorySetMapper.updateSelective(dormitorySet); // 调用Mapper层的updateSelective方法 + } + + public PageInfo query(DormitorySet dormitorySet) { // 查询DormitorySet记录列表的方法 + if(dormitorySet != null && dormitorySet.getPage() != null){ // 如果DormitorySet对象和分页参数不为空 + PageHelper.startPage(dormitorySet.getPage(),dormitorySet.getLimit()); // 启动分页并设置分页参数 + } + return new PageInfo(dormitorySetMapper.query(dormitorySet)); // 返回分页后的查询结果 + } + + public DormitorySet detail(Integer id) { // 根据ID获取DormitorySet详情的方法 + return dormitorySetMapper.detail(id); // 调用Mapper层的detail方法 + } + + public int count(DormitorySet dormitorySet) { // 统计DormitorySet记录数量的方法 + return dormitorySetMapper.count(dormitorySet); // 调用Mapper层的count方法 + } +} \ No newline at end of file diff --git a/main/DormitoryStudent.java b/main/DormitoryStudent.java new file mode 100644 index 0000000..3f74a1b --- /dev/null +++ b/main/DormitoryStudent.java @@ -0,0 +1,77 @@ +package com.yanzhen.entity; + +import com.yanzhen.utils.Entity; +import java.util.Date; + + +public class DormitoryStudent extends Entity{ // 定义一个名为DormitoryStudent的类，继承自Entity类 + + private Integer id; // 定义一个私有变量id，用于存储学生的宿舍分配ID + + private Integer dormitoryId; // 定义一个私有变量dormitoryId，用于存储宿舍ID + + private Integer bedId; // 定义一个私有变量bedId，用于存储床位ID + + private Integer studentId; // 定义一个私有变量studentId，用于存储学生ID + + private Date checkin; // 定义一个私有变量checkin，用于存储入住日期 + + private Integer status; // 定义一个私有变量status，用于表示入住状态（0为待入住，1为已入住） + + private Student student; // 定义一个私有变量student，用于关联Student对象 + + private Dormitory dormitory; // 定义一个私有变量dormitory，用于关联Dormitory对象 + + public Integer getId() { // 定义一个公共方法getId，用于获取id的值 + return id; + } + public void setId(Integer id) { // 定义一个公共方法setId，用于设置id的值 + this.id = id; + } + public Integer getDormitoryId() { // 定义一个公共方法getDormitoryId，用于获取dormitoryId的值 + return dormitoryId; + } + public void setDormitoryId(Integer dormitoryId) { // 定义一个公共方法setDormitoryId，用于设置dormitoryId的值 + this.dormitoryId = dormitoryId; + } + public Integer getBedId() { // 定义一个公共方法getBedId，用于获取bedId的值 + return bedId; + } + public void setBedId(Integer bedId) { // 定义一个公共方法setBedId，用于设置bedId的值 + this.bedId = bedId; + } + public Integer getStudentId() { // 定义一个公共方法getStudentId，用于获取studentId的值 + return studentId; + } + public void setStudentId(Integer studentId) { // 定义一个公共方法setStudentId，用于设置studentId的值 + this.studentId = studentId; + } + public Date getCheckin() { // 定义一个公共方法getCheckin，用于获取checkin的值 + return checkin; + } + public void setCheckin(Date checkin) { // 定义一个公共方法setCheckin，用于设置checkin的值 + this.checkin = checkin; + } + public Integer getStatus() { // 定义一个公共方法getStatus，用于获取status的值 + return status; + } + public void setStatus(Integer status) { // 定义一个公共方法setStatus，用于设置status的值 + this.status = status; + } + + public Student getStudent() { // 定义一个公共方法getStudent，用于获取student对象的值 + return student; + } + + public void setStudent(Student student) { // 定义一个公共方法setStudent，用于设置student对象的值 + this.student = student; + } + + public Dormitory getDormitory() { // 定义一个公共方法getDormitory，用于获取dormitory对象的值 + return dormitory; + } + + public void setDormitory(Dormitory dormitory) { // 定义一个公共方法setDormitory，用于设置dormitory对象的值 + this.dormitory = dormitory; + } +} \ No newline at end of file diff --git a/main/DormitoryStudentController.java b/main/DormitoryStudentController.java new file mode 100644 index 0000000..36c75b7 --- /dev/null +++ b/main/DormitoryStudentController.java @@ -0,0 +1,72 @@ +package com.yanzhen.controller; + +import com.github.pagehelper.PageInfo; +import com.yanzhen.entity.DormitoryStudent; +import com.yanzhen.entity.Student; +import com.yanzhen.service.DormitoryService宿舍编号设置; +import com.yanzhen.service.DormitoryStudentService宿舍预选设置; +import com.yanzhen.service.StudentService学生管理; +import com.yanzhen.utils.Result; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +import java.util.Map; + +@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中，而不是解析为跳转路径。 +@RequestMapping("/dormitoryStudent") // 设置请求的根路径为 /dormitoryStudent +public class DormitoryStudentController { + + @Autowired // 自动注入DormitoryStudentService实例 + private DormitoryStudentService宿舍预选设置 dormitoryStudentService; + + @Autowired // 自动注入StudentService实例 + private StudentService学生管理 studentService; + + @Autowired // 自动注入DormitoryService实例 + private DormitoryService宿舍编号设置 dormitoryService; + + @PostMapping("create") // 映射HTTP POST请求到 create 方法 + public Result create(@RequestBody DormitoryStudent dormitoryStudent){ // 从请求体中获取 DormitoryStudent 对象 + int flag = dormitoryStudentService.create(dormitoryStudent); // 调用服务层创建学生宿舍记录 + if(flag>0){ // 如果创建成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果创建失败 + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("delete") // 映射HTTP GET请求到 delete 方法 + public Result delete(String ids){ // 接收要删除的学生宿舍记录的ID字符串 + int flag = dormitoryStudentService.delete(ids); // 调用服务层删除指定ID的学生宿舍记录 + if(flag>0){ // 如果删除成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果删除失败 + return Result.fail(); // 返回失败结果 + } + } + + @PostMapping("update") // 映射HTTP POST请求到 update 方法 + public Result update(@RequestBody DormitoryStudent dormitoryStudent){ // 从请求体中获取 DormitoryStudent 对象 + int flag = dormitoryStudentService.update(dormitoryStudent); // 调用服务层更新学生宿舍记录 + if(flag>0){ // 如果更新成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果更新失败 + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("detail") // 映射HTTP GET请求到 detail 方法 + public DormitoryStudent detail(Integer id){ // 接收学生宿舍记录的ID + return dormitoryStudentService.detail(id); // 调用服务层获取指定ID的学生宿舍记录详情并返回 + } + + @PostMapping("query") // 映射HTTP POST请求到 query 方法 + public Map query(@RequestBody DormitoryStudent dormitoryStudent){ // 从请求体中获取 DormitoryStudent 对象用于查询条件 + PageInfo pageInfo = dormitoryStudentService.query(dormitoryStudent); // 调用服务层进行分页查询 + pageInfo.getList().forEach(entity->{ // 遍历查询结果列表 + Student detail = studentService.detail(entity.getStudentId()); // 获取每个学生宿舍记录对应的学生详细信息 + entity.setStudent(detail); // 将学生信息设置到学生宿舍记录中 + }); + return Result.ok(pageInfo); // 返回包含分页信息和查询结果的成功结果 + } +} diff --git a/main/DormitoryStudentMapper.java b/main/DormitoryStudentMapper.java new file mode 100644 index 0000000..b99918b --- /dev/null +++ b/main/DormitoryStudentMapper.java @@ -0,0 +1,30 @@ +package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包 + +import java.util.List; // 导入Java的List类，用于处理列表数据结构 +import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构 + +import com.yanzhen.entity.DormitoryStudent; // 导入DormitoryStudent实体类，用于操作学生宿舍信息 +import org.apache.ibatis.annotations.Param; // 导入MyBatis的Param注解，用于传递参数到SQL语句中 + +public interface DormitoryStudentMapper { // 定义DormitoryStudentMapper接口，提供对DormitoryStudent实体进行数据库操作的方法 + + public int create(DormitoryStudent dormitoryStudent); // 创建一个新的DormitoryStudent记录，返回影响的行数 + + public int delete(Integer id); // 根据id删除一个DormitoryStudent记录，返回影响的行数 + + public int deleteByCond(@Param("studentId") Integer studentId, @Param("dormitoryId")Integer dormitoryId); // 根据条件删除DormitoryStudent记录，返回影响的行数 + + public int update(DormitoryStudent dormitoryStudent); // 更新一个DormitoryStudent记录，返回影响的行数 + + public int updateSelective(DormitoryStudent dormitoryStudent); // 选择性地更新一个DormitoryStudent记录，返回影响的行数 + + public List query(DormitoryStudent dormitoryStudent); // 根据条件查询DormitoryStudent记录，返回符合条件的DormitoryStudent列表 + + public DormitoryStudent detail(Integer id); // 根据id查询一个DormitoryStudent记录的详细信息，返回DormitoryStudent对象 + + public int count(DormitoryStudent dormitoryStudent); // 根据条件统计DormitoryStudent记录的数量，返回记录数量 + + public int countByBuildingId(Integer buildingId); // 根据buildingId统计DormitoryStudent记录的数量，返回记录数量 + + public Map queryStudentByBedId(Integer bedId); // 根据bedId查询学生信息，返回包含学生信息的Map对象 +} \ No newline at end of file diff --git a/main/DormitoryStudentService宿舍预选设置.java b/main/DormitoryStudentService宿舍预选设置.java new file mode 100644 index 0000000..1b93516 --- /dev/null +++ b/main/DormitoryStudentService宿舍预选设置.java @@ -0,0 +1,97 @@ +package com.yanzhen.service; // 定义包名 + +import com.yanzhen.entity.Dormitory; // 导入Dormitory实体类 +import com.yanzhen.mapper.DormitoryMapper; // 导入DormitoryMapper接口 +import com.yanzhen.mapper.DormitoryStudentMapper; // 导入DormitoryStudentMapper接口 +import com.yanzhen.entity.DormitoryStudent; // 导入DormitoryStudent实体类 +import com.github.pagehelper.PageHelper; // 导入PageHelper分页插件 +import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类 +import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的@Autowired注解 +import org.springframework.stereotype.Service; // 导入Spring的@Service注解 +import org.springframework.util.StringUtils; // 导入Spring的StringUtils工具类 + +import java.util.Date; // 导入Date类 +import java.util.List; // 导入List接口 +import java.util.Map; // 导入Map接口 + +@Service // 标记为服务层组件 +public class DormitoryStudentService宿舍预选设置 {// “宿舍预选设置--------管理员” + + @Autowired // 自动注入DormitoryStudentMapper实例 + private DormitoryStudentMapper dormitoryStudentMapper; + @Autowired // 自动注入DormitoryMapper实例 + private DormitoryMapper dormitoryMapper; + + public int create(DormitoryStudent dormitoryStudent) { // 创建宿舍学生记录 + return dormitoryStudentMapper.create(dormitoryStudent); // 调用Mapper的create方法 + } + + public int delete(String ids) { // 根据ID字符串批量删除宿舍学生记录 + String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组 + int row = 0; // 初始化删除计数器 + for (String s : arr) { // 遍历ID数组 + if(!StringUtils.isEmpty(s)){ // 如果ID不为空 + dormitoryStudentMapper.delete(Integer.parseInt(s)); // 调用Mapper的delete方法删除记录 + row++; // 删除计数器加1 + } + } + return row; // 返回删除的记录数 + } + + public int delete(Integer id) { // 根据ID删除宿舍学生记录 + return dormitoryStudentMapper.delete(id); // 调用Mapper的delete方法 + } + + public int update(DormitoryStudent dormitoryStudent) { // 更新宿舍学生记录 + return dormitoryStudentMapper.update(dormitoryStudent); // 调用Mapper的update方法 + } + + public int updateSelective(DormitoryStudent dormitoryStudent) { // 选择性更新宿舍学生记录 + return dormitoryStudentMapper.updateSelective(dormitoryStudent); // 调用Mapper的updateSelective方法 + } + + public PageInfo query(DormitoryStudent dormitoryStudent) { // 查询宿舍学生记录并分页 + if(dormitoryStudent != null && dormitoryStudent.getPage() != null){ // 如果查询条件和分页信息不为空 + PageHelper.startPage(dormitoryStudent.getPage(),dormitoryStudent.getLimit()); // 设置分页参数 + } + return new PageInfo(dormitoryStudentMapper.query(dormitoryStudent)); // 返回分页结果 + } + + public DormitoryStudent detail(Integer id) { // 根据ID查询宿舍学生详情 + return dormitoryStudentMapper.detail(id); // 调用Mapper的detail方法 + } + + public int count(DormitoryStudent dormitoryStudent) { // 统计宿舍学生记录数 + return dormitoryStudentMapper.count(dormitoryStudent); // 调用Mapper的count方法 + } + + public synchronized int select_dormitory_submit(Integer studentId,Integer dormitoryId,Integer bedId){ // 提交选择宿舍操作 + Dormitory detail = dormitoryMapper.detail(dormitoryId); // 获取宿舍详情 + int capacity = detail.getCapacity(); // 获取宿舍容量 + DormitoryStudent ds = new DormitoryStudent(); // 创建新的DormitoryStudent对象 + ds.setDormitoryId(dormitoryId); // 设置宿舍ID + List list = dormitoryStudentMapper.query(ds); // 查询该宿舍的学生列表 + if(list.size() == capacity){ // 如果宿舍已满 + return 0; // 返回0表示失败 + }else{ // 如果宿舍未满 + dormitoryStudentMapper.deleteByCond(studentId,dormitoryId); // 删除该学生在宿舍中的现有记录 + DormitoryStudent entity = new DormitoryStudent(); // 创建新的DormitoryStudent对象 + entity.setDormitoryId(dormitoryId); // 设置宿舍ID + entity.setBedId(bedId); // 设置床位ID + entity.setStudentId(studentId); // 设置学生ID + entity.setCheckin(new Date()); // 设置入住日期为当前日期 + entity.setStatus(1); // 设置状态为1（入住） + dormitoryStudentMapper.create(entity); // 创建新的宿舍学生记录 + } + return 1; // 返回1表示成功 + } + + public int countByBuildingId(Integer buildingId){ // 根据建筑ID统计宿舍学生记录数 + return dormitoryStudentMapper.countByBuildingId(buildingId); // 调用Mapper的countByBuildingId方法 + } + + public Map queryStudentByBedId(Integer bedId){ // 根据床位ID查询学生信息 + return dormitoryStudentMapper.queryStudentByBedId(bedId); // 调用Mapper的queryStudentByBedId方法 + } + +} \ No newline at end of file diff --git a/main/Entity.java b/main/Entity.java new file mode 100644 index 0000000..35999c0 --- /dev/null +++ b/main/Entity.java @@ -0,0 +1,28 @@ +package com.yanzhen.utils; // 定义包名 + +import com.fasterxml.jackson.annotation.JsonIgnore; // 导入JsonIgnore注解 +import com.fasterxml.jackson.annotation.JsonProperty; // 导入JsonProperty注解 + +public class Entity { // 定义Entity类 + + private Integer page = 1; // 页码数，默认为1 + + private Integer limit = 10; // 页面大小，默认的10 + + public Integer getPage() { // 获取页码数的方法 + return page; // 返回页码数 + } + + public void setPage(Integer page) { // 设置页码数的方法 + this.page = page; // 设置页码数 + } + + public Integer getLimit() { // 获取页面大小的方法 + return limit; // 返回页面大小 + } + + public void setLimit(Integer limit) { // 设置页面大小的方法 + this.limit = limit; // 设置页面大小 + } + +} \ No newline at end of file diff --git a/main/GlobalControllerAdvice.java b/main/GlobalControllerAdvice.java new file mode 100644 index 0000000..f86b3d3 --- /dev/null +++ b/main/GlobalControllerAdvice.java @@ -0,0 +1,27 @@ +package com.yanzhen.framework.mvc; // 定义包名 + +import com.yanzhen.framework.exception.MyException; // 导入自定义异常类 +import com.yanzhen.utils.Result; // 导入结果处理工具类 +import org.springframework.web.bind.annotation.ControllerAdvice; // 导入Spring MVC的ControllerAdvice注解 +import org.springframework.web.bind.annotation.ExceptionHandler; // 导入Spring MVC的ExceptionHandler注解 +import org.springframework.web.bind.annotation.RequestBody; // 导入Spring MVC的RequestBody注解 +import org.springframework.web.bind.annotation.ResponseBody; // 导入Spring MVC的ResponseBody注解 + +@ControllerAdvice // 标记该类为全局异常处理类 +public class GlobalControllerAdvice { + + @ExceptionHandler(RuntimeException.class) // 处理所有RuntimeException类型的异常 + @ResponseBody // 将返回值作为HTTP响应体 + public Result handle(RuntimeException exception){ // 定义处理方法，参数为捕获到的异常 + exception.printStackTrace(); // 打印异常堆栈信息 + return Result.fail(exception.getMessage()); // 返回失败的结果对象，包含异常信息 + } + + @ExceptionHandler(MyException.class) // 处理所有MyException类型的异常 + @ResponseBody // 将返回值作为HTTP响应体 + public Result handle(MyException exception){ // 定义处理方法，参数为捕获到的异常 + exception.printStackTrace(); // 打印异常堆栈信息 + return Result.fail(Result.TOKEN_ERROR,exception.getMessage()); // 返回失败的结果对象，包含错误码和异常信息 + } + +} \ No newline at end of file diff --git a/main/Grade.java b/main/Grade.java new file mode 100644 index 0000000..6c40148 --- /dev/null +++ b/main/Grade.java @@ -0,0 +1,31 @@ +package com.yanzhen.entity; + +import javax.validation.constraints.NotNull; +import org.hibernate.validator.constraints.Length; +import com.yanzhen.utils.Entity; +import java.util.Date; + + +public class Grade extends Entity{// 定义一个名为Grade的类，继承自Entity类 + + private Integer id;// 定义一个私有的Integer类型的变量id + + @Length(max = 100)// 使用@Length注解限制name字段的最大长度为100个字符 + private String name; + + public Integer getId() { + return id;// 定义一个公共方法getId，用于获取id的值 + } + + public void setId(Integer id) { + this.id = id;// 定义一个公共方法setId，用于设置id的值 + } + + public String getName() { + return name;// 定义一个公共方法getName，用于获取name的值 + } + + public void setName(String name) { + this.name = name;// 定义一个公共方法setName，用于设置name的值 + } +} \ No newline at end of file diff --git a/main/GradeController.java b/main/GradeController.java new file mode 100644 index 0000000..d5b79f3 --- /dev/null +++ b/main/GradeController.java @@ -0,0 +1,60 @@ +package com.yanzhen.controller; + +import com.github.pagehelper.PageInfo; +import com.yanzhen.entity.Grade; +import com.yanzhen.service.GradeService年级管理; +import com.yanzhen.utils.Result; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +import java.util.Map; + +@RestController // 声明这是一个RESTful控制器，返回的数据直接写入HTTP响应体中 +@RequestMapping("/grade") // 设置请求路径的映射前缀为"/grade" +public class GradeController { + + @Autowired // 自动注入GradeService对象 + private GradeService年级管理 gradeService; + + @PostMapping("create") // 映射HTTP POST请求到create方法 + public Result create(@RequestBody Grade grade){ // 从请求体中获取Grade对象 + int flag = gradeService.create(grade); // 调用服务层的create方法创建记录 + if(flag>0){ // 如果创建成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果创建失败 + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("delete") // 映射HTTP GET请求到delete方法 + public Result delete(String ids){ // 从请求参数中获取要删除的记录ID + int flag = gradeService.delete(ids); // 调用服务层的delete方法删除记录 + if(flag>0){ // 如果删除成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果删除失败 + return Result.fail(); // 返回失败结果 + } + } + + @PostMapping("update") // 映射HTTP POST请求到update方法 + public Result update(@RequestBody Grade grade){ // 从请求体中获取Grade对象 + int flag = gradeService.update(grade); // 调用服务层的update方法更新记录 + if(flag>0){ // 如果更新成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果更新失败 + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("detail") // 映射HTTP GET请求到detail方法 + public Grade detail(Integer id){ // 从请求参数中获取记录ID + return gradeService.detail(id); // 调用服务层的detail方法获取记录详情 + } + + @PostMapping("query") // 映射HTTP POST请求到query方法 + public Map query(@RequestBody Grade grade){ // 从请求体中获取Grade对象作为查询条件 + PageInfo pageInfo = gradeService.query(grade); // 调用服务层的query方法进行分页查询 + return Result.ok(pageInfo); // 返回包含查询结果的成功结果 + } + +} diff --git a/main/GradeMapper.java b/main/GradeMapper.java new file mode 100644 index 0000000..0f55d68 --- /dev/null +++ b/main/GradeMapper.java @@ -0,0 +1,24 @@ +package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包 + +import java.util.List; // 导入Java的List类，用于处理列表数据结构 +import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构 + +import com.yanzhen.entity.Grade; // 导入Grade实体类，用于操作年级信息 + +public interface GradeMapper { // 定义GradeMapper接口，提供对Grade实体进行数据库操作的方法 + + public int create(Grade grade); // 创建一个新的Grade记录，返回影响的行数 + + public int delete(Integer id); // 根据id删除一个Grade记录，返回影响的行数 + + public int update(Grade grade); // 更新一个Grade记录，返回影响的行数 + + public int updateSelective(Grade grade); // 选择性地更新一个Grade记录，返回影响的行数 + + public List query(Grade grade); // 根据条件查询Grade记录，返回符合条件的Grade列表 + + public Grade detail(Integer id); // 根据id查询一个Grade记录的详细信息，返回Grade对象 + + public int count(Grade grade); // 根据条件统计Grade记录的数量，返回记录数量 + +} \ No newline at end of file diff --git a/main/GradeService年级管理.java b/main/GradeService年级管理.java new file mode 100644 index 0000000..af59346 --- /dev/null +++ b/main/GradeService年级管理.java @@ -0,0 +1,59 @@ +package com.yanzhen.service; // 定义包名 + +import com.yanzhen.mapper.GradeMapper; // 导入GradeMapper接口 +import com.yanzhen.entity.Grade; // 导入Grade实体类 +import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类 +import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类 +import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解 +import org.springframework.stereotype.Service; // 导入Spring的服务层注解 +import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作 + +@Service // 标注该类为服务层组件 +public class GradeService年级管理 { // 定义GradeService类 “年级管理----管理员” + + @Autowired // 自动装配GradeMapper对象 + private GradeMapper gradeMapper; + + public int create(Grade grade) { // 创建Grade记录的方法 + return gradeMapper.create(grade); // 调用GradeMapper的create方法并返回结果 + } + + public int delete(String ids) { // 根据ID字符串批量删除Grade记录的方法 + String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组 + int row = 0; // 初始化受影响行数为0 + for (String s : arr) { // 遍历ID数组 + if(!StringUtils.isEmpty(s)){ // 如果ID不为空 + gradeMapper.delete(Integer.parseInt(s)); // 调用GradeMapper的delete方法删除记录 + row++; // 受影响行数加1 + } + } + return row; // 返回受影响行数 + } + + public int delete(Integer id) { // 根据ID删除单个Grade记录的方法 + return gradeMapper.delete(id); // 调用GradeMapper的delete方法并返回结果 + } + + public int update(Grade grade) { // 更新Grade记录的方法 + return gradeMapper.update(grade); // 调用GradeMapper的update方法并返回结果 + } + + public int updateSelective(Grade grade) { // 选择性更新Grade记录的方法 + return gradeMapper.updateSelective(grade); // 调用GradeMapper的updateSelective方法并返回结果 + } + + public PageInfo query(Grade grade) { // 查询Grade记录列表的方法 + if(grade != null && grade.getPage() != null){ // 如果Grade对象和分页参数不为空 + PageHelper.startPage(grade.getPage(),grade.getLimit()); // 启动分页并设置分页参数 + } + return new PageInfo(gradeMapper.query(grade)); // 调用GradeMapper的query方法并返回分页信息 + } + + public Grade detail(Integer id) { // 根据ID获取Grade详情的方法 + return gradeMapper.detail(id); // 调用GradeMapper的detail方法并返回结果 + } + + public int count(Grade grade) { // 统计Grade记录数量的方法 + return gradeMapper.count(grade); // 调用GradeMapper的count方法并返回结果 + } +} \ No newline at end of file diff --git a/main/JWTUtil.java b/main/JWTUtil.java new file mode 100644 index 0000000..8d0bb03 --- /dev/null +++ b/main/JWTUtil.java @@ -0,0 +1,156 @@ +package com.yanzhen.framework.jwt; // 定义包名 + +import com.yanzhen.entity.Student; // 导入Student类 +import com.yanzhen.entity.User; // 导入User类 +import com.yanzhen.framework.exception.MyException; // 导入自定义异常类MyException +import io.jsonwebtoken.*; // 导入JWT相关类 +import org.springframework.util.StringUtils; // 导入Spring框架的StringUtils工具类 + +import java.util.Date; // 导入Date类 +import java.util.HashMap; // 导入HashMap类 +import java.util.Map; // 导入Map接口 +import java.util.UUID; // 导入UUID类 + + +public class JWTUtil {//jwt的工具类 + + public static String token = "token"; // 定义静态变量token，用于存储token字符串 + //秘钥 + public static String jwt_secret="yanzhen@cms@cc596183363."; // 定义静态变量jwt_secret，用于存储JWT签名的密钥 + //过期时长 + public static long jwt_expr = 3600*24*1000; // 定义静态变量jwt_expr，用于设置JWT的过期时间（单位：毫秒） + + //1、生成token + public static String sign(User user){ // 定义静态方法sign，用于生成用户类型的JWT + + //1、指定签名的时候使用的签名算法 + SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256; // 使用HS256算法进行签名 + //2、生成签发时间 + long nowMillis = System.currentTimeMillis(); // 获取当前时间的毫秒数 + Date date = new Date(nowMillis); // 将毫秒数转换为Date对象 + + //3、创建playLoad的私有声明 + Map claims = new HashMap<>(); // 创建一个Map对象，用于存储JWT的负载信息 + claims.put("id",user.getId()); // 将用户的ID添加到负载中 + claims.put("userName",user.getUserName()); // 将用户名添加到负载中 + claims.put("type","USER"); // 添加类型信息到负载中 + //4、生成签发人 + String subject = user.getUserName(); // 将用户名作为JWT的签发人 + + JwtBuilder builder = Jwts.builder() // 创建JwtBuilder对象，用于构建JWT + .setClaims(claims) // 设置JWT的负载信息 + .setId(UUID.randomUUID().toString()) // 设置JWT的唯一标识符 + .setIssuedAt(date) // 设置JWT的签发时间 + .setSubject(subject) // 设置JWT的签发人 + .signWith(signatureAlgorithm,jwt_secret); // 使用指定的签名算法和密钥对JWT进行签名 + //设置过期时间 + Date exprDate = new Date(nowMillis + jwt_expr); // 计算JWT的过期时间 + builder.setExpiration(exprDate); // 设置JWT的过期时间 + return builder.compact(); // 生成并返回JWT字符串 + } + + + //1、生成token + public static String signForStudent(Student student){ // 定义静态方法signForStudent，用于生成学生类型的JWT + + //1、指定签名的时候使用的签名算法 + SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256; // 使用HS256算法进行签名 + //2、生成签发时间 + long nowMillis = System.currentTimeMillis(); // 获取当前时间的毫秒数 + Date date = new Date(nowMillis); // 将毫秒数转换为Date对象 + + //3、创建playLoad的私有声明 + Map claims = new HashMap<>(); // 创建一个Map对象，用于存储JWT的负载信息 + claims.put("id",student.getId()); // 将学生的ID添加到负载中 + claims.put("stuNo",student.getStuNo()); // 将学号添加到负载中 + claims.put("type","STUDENT"); // 添加类型信息到负载中 + //4、生成签发人 + String subject = student.getStuNo(); // 将学号作为JWT的签发人 + JwtBuilder builder = Jwts.builder() // 创建JwtBuilder对象，用于构建JWT + .setClaims(claims) // 设置JWT的负载信息 + .setId(UUID.randomUUID().toString()) // 设置JWT的唯一标识符 + .setIssuedAt(date) // 设置JWT的签发时间 + .setSubject(subject) // 设置JWT的签发人 + .signWith(signatureAlgorithm,jwt_secret); // 使用指定的签名算法和密钥对JWT进行签名 + //设置过期时间 + Date exprDate = new Date(nowMillis + jwt_expr); // 计算JWT的过期时间 + builder.setExpiration(exprDate); // 设置JWT的过期时间 + return builder.compact(); // 生成并返回JWT字符串 + } + + //2、验证token + public static boolean verify(String token){ // 定义静态方法verify，用于验证JWT是否合法 + try { + if(StringUtils.isEmpty(token)){ // 如果token为空，则返回false + return false; + } + Jwts.parser().setSigningKey(jwt_secret).parseClaimsJws(token).getBody(); // 解析JWT并验证签名 + return true; // 如果解析成功且签名合法，则返回true + } catch (Exception e) { // 如果解析或验证过程中发生异常，则捕获异常 + e.printStackTrace(); // 打印异常堆栈信息 + return false; // 返回false表示验证失败 + } + } + + public static String getType(String token){ // 定义静态方法getType，用于获取JWT的类型信息 + try { + if(StringUtils.isEmpty(token)){ // 如果token为空，则抛出自定义异常 + throw new MyException("token不能为空"); + } + if(verify(token)){ // 如果token验证通过，则解析JWT并获取类型信息 + Claims claims = Jwts.parser().setSigningKey(jwt_secret).parseClaimsJws(token).getBody(); // 解析JWT并获取负载信息 + return claims.get("type")+""; // 返回类型信息 + }else{ + throw new MyException("超时或不合法token"); // 如果token验证失败，则抛出自定义异常 + } + } catch (Exception e) { // 如果解析或验证过程中发生异常，则捕获异常 + throw new MyException("超时或不合法token"); // 抛出自定义异常 + } + } + + //3、获取用户信息 + public static User getUser(String token){ // 定义静态方法getUser，用于从JWT中提取用户信息 + try { + if(StringUtils.isEmpty(token)){ // 如果token为空，则抛出自定义异常 + throw new MyException("token不能为空"); + } + if(verify(token)){ // 如果token验证通过，则解析JWT并获取用户信息 + Claims claims = Jwts.parser().setSigningKey(jwt_secret).parseClaimsJws(token).getBody(); // 解析JWT并获取负载信息 + User user = new User(); // 创建User对象 + user.setId(Integer.parseInt(claims.get("id")+"")); // 从负载中提取用户ID并设置到User对象中 + user.setUserName(claims.get("userName")+""); // 从负载中提取用户名并设置到User对象中 + return user; // 返回User对象 + }else{ + throw new MyException("超时或不合法token"); // 如果token验证失败，则抛出自定义异常 + } + } catch (Exception e) { // 如果解析或验证过程中发生异常，则捕获异常 + throw new MyException("超时或不合法token"); // 抛出自定义异常 + } + } + + public static Student getStudent(String token){ // 定义静态方法getStudent，用于从JWT中提取学生信息 + try { + if(StringUtils.isEmpty(token)){ // 如果token为空，则抛出自定义异常 + throw new MyException("token不能为空"); + } + if(verify(token)){ // 如果token验证通过，则解析JWT并获取学生信息 + Claims claims = Jwts.parser().setSigningKey(jwt_secret).parseClaimsJws(token).getBody(); // 解析JWT并获取负载信息 + Student student = new Student(); // 创建Student对象 + student.setId(Integer.parseInt(claims.get("id")+"")); // 从负载中提取学生ID并设置到Student对象中 + student.setStuNo(claims.get("stuNo")+""); // 从负载中提取学号并设置到Student对象中 + return student; // 返回Student对象 + }else{ + throw new MyException("超时或不合法token"); // 如果token验证失败，则抛出自定义异常 + } + } catch (Exception e) { // 如果解析或验证过程中发生异常，则捕获异常 + throw new MyException("超时或不合法token"); // 抛出自定义异常 + } + } + + public static void main(String[] args) { // 主方法，程序入口点 + User user = new User(); // 创建User对象 + user.setId(1); // 设置用户ID + user.setUserName("admin"); // 设置用户名 + System.out.println(sign(user)); // 生成用户类型的JWT并打印输出 + } +} \ No newline at end of file diff --git a/main/LoginController.java b/main/LoginController.java new file mode 100644 index 0000000..7edcb87 --- /dev/null +++ b/main/LoginController.java @@ -0,0 +1,52 @@ +package com.yanzhen.controller; + +import com.yanzhen.entity.Student; +import com.yanzhen.entity.User; +import com.yanzhen.framework.jwt.JWTUtil; +import com.yanzhen.service.StudentService学生管理; +import com.yanzhen.service.UserService用户管理; +import com.yanzhen.utils.Result; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RestController; + +import java.util.HashMap; +import java.util.Map; + +@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中，而不是解析为跳转路径。 +public class LoginController { // 定义一个名为 LoginController 的类，用于处理登录相关的请求。 + + @Autowired // 自动注入 UserService 实例，用于处理用户相关的业务逻辑。 + private UserService用户管理 userService; + + @Autowired // 自动注入 StudentService 实例，用于处理学生相关的业务逻辑。 + private StudentService学生管理 studentService; + + @PostMapping("/login") // 映射 HTTP POST 请求到 /login 路径上，用于处理登录请求。 + public Result login(@RequestBody User user){ // 定义一个方法 login，接收一个 User 对象作为请求体。 + if(user.getType() == 2){ // 如果用户类型是学生（假设类型为2表示学生）。 + Student entity = studentService.login(user.getUserName(),user.getPassword()); // 调用 studentService 的 login 方法验证学生身份。 + if(entity != null){ // 如果学生信息存在，即登录成功。 + String token = JWTUtil.signForStudent(entity); // 生成针对学生的 JWT 令牌。 + Map map = new HashMap(); // 创建一个 Map 对象存储返回数据。 + map.put(JWTUtil.token,token); // 将 JWT 令牌放入 Map。 + map.put("student",entity); // 将学生实体信息放入 Map。 + return Result.ok("登陆成功",map); // 返回包含成功消息和数据的 Result 对象。 + }else{ // 如果学生信息不存在，即登录失败。 + return Result.fail("用户名或密码错误"); // 返回包含错误信息的 Result 对象。 + } + }else{ // 如果用户类型不是学生（管理员或宿管员）。 + User entity = userService.login(user.getUserName(),user.getPassword()); // 调用 userService 的 login 方法验证用户身份。 + if(entity != null){ // 如果用户信息存在，即登录成功。 + String token = JWTUtil.sign(entity); // 生成通用的 JWT 令牌。 + Map map = new HashMap(); // 创建一个 Map 对象存储返回数据。 + map.put(JWTUtil.token,token); // 将 JWT 令牌放入 Map。 + map.put("user",entity); // 将用户实体信息放入 Map。 + return Result.ok("登陆成功",map); // 返回包含成功消息和数据的 Result 对象。 + }else{ // 如果用户信息不存在，即登录失败。 + return Result.fail("用户名或密码错误"); // 返回包含错误信息的 Result 对象。 + } + } + } +} \ No newline at end of file diff --git a/main/MainController.java b/main/MainController.java new file mode 100644 index 0000000..a776fac --- /dev/null +++ b/main/MainController.java @@ -0,0 +1,76 @@ +package com.yanzhen.controller; + +import com.github.pagehelper.PageInfo; +import com.yanzhen.entity.Building; +import com.yanzhen.entity.Dormitory; +import com.yanzhen.entity.Notice; +import com.yanzhen.service.BuildingService楼层设置; +import com.yanzhen.service.DormitoryService宿舍编号设置; +import com.yanzhen.service.DormitoryStudentService宿舍预选设置; +import com.yanzhen.service.NoticeService公告管理; +import com.yanzhen.utils.Result; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.text.DecimalFormat; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中，而不是解析为跳转路径。 +@RequestMapping("/main") // 设置请求的根路径为 /main，所有该控制器下的请求都会以 /main 开头。 +public class MainController { + + @Autowired // 自动注入 BuildingService 实例，用于处理楼宇相关的业务逻辑。 + private BuildingService楼层设置 buildingService; + + @Autowired // 自动注入 DormitoryService 实例，用于处理宿舍相关的业务逻辑。 + private DormitoryService宿舍编号设置 dormitoryService; + @Autowired // 自动注入 DormitoryStudentService 实例，用于处理学生宿舍分配的业务逻辑。 + private DormitoryStudentService宿舍预选设置 dormitoryStudentService; + @Autowired // 自动注入 NoticeService 实例，用于处理公告通知的业务逻辑。 + private NoticeService公告管理 noticeService; + + @GetMapping("/building") // 映射 HTTP GET 请求到 /main/building 路径。 + public Result building(){ + Building building = new Building(); // 创建一个新的楼宇对象。 + building.setLimit(1000); // 设置查询限制为1000条记录。 + PageInfo pageInfo = buildingService.query(building); // 调用服务层方法查询楼宇信息。 + List> list = new ArrayList<>(); // 创建一个列表来存储每个楼宇的信息。 + DecimalFormat df = new DecimalFormat("######0.00"); // 定义一个格式化工具，用于格式化百分比。 + pageInfo.getList().forEach(entity->{ // 遍历查询到的楼宇列表。 + Map map = new HashMap<>(); // 创建一个 Map 来存储单个楼宇的信息。 + Dormitory param = new Dormitory(); // 创建一个新的宿舍对象。 + param.setBuildingId(entity.getId()); // 设置宿舍对象的楼宇ID。 + param.setLimit(1000000); // 设置查询限制为1000000条记录。 + + PageInfo dormitoryPageInfo = dormitoryService.query(param); // 调用服务层方法查询宿舍信息。 + int all = dormitoryPageInfo.getList().size(); // 获取该楼宇下的总宿舍数。 + map.put("name",entity.getName()); // 将楼宇名称存入 Map。 + map.put("all",all); // 将总宿舍数存入 Map。 + int used = dormitoryStudentService.countByBuildingId(entity.getId()); // 计算已分配宿舍的学生数量。 + map.put("used",used); // 将已分配宿舍的学生数量存入 Map。 + int unused = all-used; // 计算未分配宿舍的数量。 + map.put("unused",unused); // 将未分配宿舍的数量存入 Map。 + if(all == 0){ // 如果总宿舍数为0，则百分比为0。 + map.put("percent",0); + }else{ // 否则，计算并格式化已使用宿舍的百分比。 + map.put("percent",df.format((float)used/all)); + } + + list.add(map); // 将当前楼宇的信息添加到列表中。 + }); + return Result.ok(list); // 返回包含所有楼宇信息的列表。 + } + + @GetMapping("/notice") // 映射 HTTP GET 请求到 /main/notice 路径。 + public Result notice(){ + Notice notice = new Notice(); // 创建一个新的公告对象。 + notice.setLimit(5); // 设置查询限制为5条记录。 + PageInfo pageInfo = noticeService.query(notice); // 调用服务层方法查询公告信息。 + return Result.ok(pageInfo.getList()); // 返回包含公告信息的列表。 + } +} diff --git a/main/Menu.java b/main/Menu.java new file mode 100644 index 0000000..3622680 --- /dev/null +++ b/main/Menu.java @@ -0,0 +1,82 @@ +package com.yanzhen.entity; + +import java.util.List; + +public class Menu { // 定义一个名为Menu的公共类 + + private Integer id; // 私有成员变量，用于存储菜单项的唯一标识符 + private String title; // 私有成员变量，用于存储菜单项的标题 + private String icon; // 私有成员变量，用于存储菜单项的图标 + private String href; // 私有成员变量，用于存储菜单项的链接地址 + private String target; // 私有成员变量，用于指定链接打开的目标窗口 + private Integer parentId; // 私有成员变量，用于存储父菜单项的ID + private Integer type; // 私有成员变量，用于存储菜单项的类型 + + private List child; // 私有成员变量，用于存储子菜单项的列表 + + // 以下为该类的成员变量的getter和setter方法 + + public Integer getId() { // 获取菜单项的ID + return id; + } + + public void setId(Integer id) { // 设置菜单项的ID + this.id = id; + } + + public String getTitle() { // 获取菜单项的标题 + return title; + } + + public void setTitle(String title) { // 设置菜单项的标题 + this.title = title; + } + + public String getIcon() { // 获取菜单项的图标 + return icon; + } + + public void setIcon(String icon) { // 设置菜单项的图标 + this.icon = icon; + } + + public String getHref() { // 获取菜单项的链接地址 + return href; + } + + public void setHref(String href) { // 设置菜单项的链接地址 + this.href = href; + } + + public String getTarget() { // 获取链接打开的目标窗口 + return target; + } + + public void setTarget(String target) { // 设置链接打开的目标窗口 + this.target = target; + } + + public Integer getParentId() { // 获取父菜单项的ID + return parentId; + } + + public void setParentId(Integer parentId) { // 设置父菜单项的ID + this.parentId = parentId; + } + + public Integer getType() { // 获取菜单项的类型 + return type; + } + + public void setType(Integer type) { // 设置菜单项的类型 + this.type = type; + } + + public List getChild() { // 获取子菜单项的列表 + return child; + } + + public void setChild(List child) { // 设置子菜单项的列表 + this.child = child; + } +} diff --git a/main/MenuController.java b/main/MenuController.java new file mode 100644 index 0000000..1bf6179 --- /dev/null +++ b/main/MenuController.java @@ -0,0 +1,97 @@ +package com.yanzhen.controller; + +import com.yanzhen.entity.Menu; +import com.yanzhen.entity.User; +import com.yanzhen.service.MenuService菜单; +import com.yanzhen.utils.Result; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import javax.servlet.http.HttpServletRequest; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中，而不是解析为跳转路径。 +@RequestMapping("/menu") // 设置请求的根路径为 "/menu" +public class MenuController { + + @Autowired // 自动注入 MenuService 对象 + private MenuService菜单 menuService; + + @GetMapping("/query") // 处理对 "/menu/query" 的 GET 请求 + public Result query(HttpServletRequest request){ + List menus = new ArrayList<>(); // 创建一个空的菜单列表 + if(request.getAttribute("user") != null){ // 如果请求中有 "user" 属性 + User user = (User) request.getAttribute("user"); // 获取用户信息 + menus = menuService.query(user.getId()); // 根据用户ID查询菜单 + }else if(request.getAttribute("student") != null){ // 如果请求中有 "student" 属性 + menus = menuService.queryByType(); // 查询所有学生类型的菜单 + } + + List menuList1 = new ArrayList<>(); // 创建一级菜单列表 + //找出一级菜单 + for (Menu menu : menus) { // 遍历所有菜单项 + if(menu.getParentId() == 0){ // 如果父ID为0，则为一级菜单 + menuList1.add(menu); // 添加到一级菜单列表中 + } + } + + //嵌套循环找出关联设置child属性 + for (Menu parent : menuList1) { // 遍历一级菜单 + List child = new ArrayList<>(); // 创建子菜单列表 + for (Menu entity : menus) { // 遍历所有菜单项 + if(parent.getId() == entity.getParentId()){ // 如果当前菜单是某个一级菜单的子菜单 + child.add(entity); // 添加到子菜单列表中 + } + } + parent.setChild(child); // 设置一级菜单的子菜单列表 + } + + return Result.ok(menuList1); // 返回包含一级菜单及其子菜单的结果 + } + + @GetMapping("/tree") // 处理对 "/menu/tree" 的 GET 请求 + public Result tree(Integer checked,HttpServletRequest request){ + //check查询的时候是否选中状态 + List checkedMenuId = new ArrayList<>(); // 创建已选中菜单ID列表 + if(checked != null){ // 如果请求参数中包含 "checked" + User user = (User) request.getAttribute("user"); // 获取用户信息 + //查询出来自己已经设置过得menuId + checkedMenuId = menuService.queryCheckMenuId(user.getId()); // 查询用户已设置的菜单ID + } + List list = menuService.list(); // 获取所有菜单列表 + List> menus = new ArrayList<>(); // 创建用于存储树形结构的菜单列表 + for (Menu menu : list) { // 遍历所有菜单项 + if(menu.getParentId()==0){ // 如果父ID为0，则为一级菜单 + Map map = new HashMap<>(); // 创建存储一级菜单信息的映射 + map.put("id",menu.getId()); // 添加菜单ID + map.put("name",menu.getTitle()); // 添加菜单名称 + map.put("isParent",true); // 标记为父节点 + map.put("open",true); // 默认展开 + if(checked != null){ // 如果存在已选中的菜单ID + map.put("checked",checkedMenuId.contains(menu.getId())); // 设置是否选中 + } + List> child = new ArrayList<>(); // 创建子菜单列表 + for (Menu menu1 : list) { // 遍历所有菜单项 + if(menu1.getParentId()!=0 && menu.getId() == menu1.getParentId()){ // 如果当前菜单是某个一级菜单的子菜单 + Map map2 = new HashMap<>(); // 创建存储子菜单信息的映射 + map2.put("id",menu1.getId()); // 添加子菜单ID + map2.put("name",menu1.getTitle()); // 添加子菜单名称 + map2.put("isParent",false); // 标记为子节点 + if(checked != null){ // 如果存在已选中的菜单ID + map2.put("checked",checkedMenuId.contains(menu1.getId())); // 设置是否选中 + } + child.add(map2); // 添加到子菜单列表中 + } + } + map.put("children",child); // 将子菜单列表添加到一级菜单的映射中 + menus.add(map); // 将一级菜单的映射添加到结果列表中 + } + } + return Result.ok(menus); // 返回包含树形结构菜单的结果 + } + +} diff --git a/main/MenuMapper.java b/main/MenuMapper.java new file mode 100644 index 0000000..104d11d --- /dev/null +++ b/main/MenuMapper.java @@ -0,0 +1,23 @@ +package com.yanzhen.mapper; // 定义包名 + +import com.yanzhen.entity.Menu; // 导入Menu实体类 +import com.yanzhen.entity.User; // 导入User实体类 +import org.apache.ibatis.annotations.Param; // 导入MyBatis的@Param注解 + +import java.util.List; // 导入List集合 + +public interface MenuMapper { // 定义MenuMapper接口 + + public List query(Integer userId); // 根据用户ID查询菜单列表 + + public List queryByType(); // 查询所有类型的菜单 + + public List list(); // 列出所有菜单 + + public int createUserMenu(@Param("userId") Integer userId, @Param("menuId") Integer menuId); // 为用户创建菜单，关联用户ID和菜单ID + + public int deleteUserMenu(@Param("userId") Integer userId); // 删除用户的菜单，根据用户ID + + public List queryCheckMenuId(Integer userId); // 查询用户已选择的菜单ID列表 + +} \ No newline at end of file diff --git a/main/MenuService菜单.java b/main/MenuService菜单.java new file mode 100644 index 0000000..a9ad6b3 --- /dev/null +++ b/main/MenuService菜单.java @@ -0,0 +1,31 @@ +package com.yanzhen.service; // 定义包名 + +import com.yanzhen.mapper.MenuMapper; // 导入MenuMapper接口 +import com.yanzhen.entity.Menu; // 导入Menu实体类 +import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解 +import org.springframework.stereotype.Service; // 导入Spring的服务层注解 + +import java.util.List; // 导入List集合类 + +@Service // 标记为服务层组件 +public class MenuService菜单 { // 定义MenuService类 + + @Autowired // 自动注入MenuMapper依赖 + private MenuMapper menuMapper; + + public List query(Integer userId){ // 根据用户ID查询对应菜单列表 + return menuMapper.query(userId); // 调用menuMapper的query方法并返回结果 + } + public List list(){ // 查询所有菜单的方法 + return menuMapper.list(); // 调用menuMapper的list方法并返回结果 + } + + public List queryCheckMenuId(Integer userId){ // 根据用户ID查询选中的菜单ID的方法 + return menuMapper.queryCheckMenuId(userId); // 调用menuMapper的queryCheckMenuId方法并返回结果 + } + + public List queryByType(){ // 按类型查询菜单的方法 + return menuMapper.queryByType(); // 调用menuMapper的queryByType方法并返回结果 + } + +} \ No newline at end of file diff --git a/main/MyException.java b/main/MyException.java new file mode 100644 index 0000000..ce2b5f1 --- /dev/null +++ b/main/MyException.java @@ -0,0 +1,11 @@ +package com.yanzhen.framework.exception; + +public class MyException extends RuntimeException { // 定义一个名为MyException的类，继承自RuntimeException + + public MyException() { // 无参构造函数 + } + + public MyException(String message) { // 带一个字符串参数的构造函数 + super(message); // 调用父类的构造函数，并传递消息参数 + } +} diff --git a/main/MyWebMvcConfigurer.java b/main/MyWebMvcConfigurer.java new file mode 100644 index 0000000..e65c2ac --- /dev/null +++ b/main/MyWebMvcConfigurer.java @@ -0,0 +1,42 @@ +package com.yanzhen.framework.mvc; // 定义包名 + +import org.springframework.context.annotation.Bean; // 导入@Bean注解 +import org.springframework.context.annotation.Configuration; // 导入@Configuration注解 +import org.springframework.web.cors.CorsConfiguration; // 导入CorsConfiguration类 +import org.springframework.web.cors.CorsConfigurationSource; // 导入CorsConfigurationSource接口 +import org.springframework.web.cors.UrlBasedCorsConfigurationSource; // 导入UrlBasedCorsConfigurationSource类 +import org.springframework.web.filter.CorsFilter; // 导入CorsFilter类 +import org.springframework.web.servlet.config.annotation.InterceptorRegistry; // 导入InterceptorRegistry类 +import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; // 导入WebMvcConfigurer接口 + +@Configuration // 标记该类为配置类 +public class MyWebMvcConfigurer implements WebMvcConfigurer { // 实现WebMvcConfigurer接口 + + @Bean // 将方法返回的对象注册为Spring容器中的Bean + public TokenInterceptor tokenInterceptor(){ // 定义tokenInterceptor方法，返回TokenInterceptor对象 + return new TokenInterceptor(); // 创建并返回TokenInterceptor实例 + } + + @Override // 重写父类的方法 + public void addInterceptors(InterceptorRegistry registry) { // 定义addInterceptors方法，参数为InterceptorRegistry对象 + registry.addInterceptor(tokenInterceptor()) // 添加自定义拦截器 + .addPathPatterns("/**") // 设置拦截所有路径 + .excludePathPatterns("/login"); // 排除登录路径不拦截 + } + + //使用CorsFilter解决跨域的问题 + @Bean // 将方法返回的对象注册为Spring容器中的Bean + public CorsFilter corsFilter(){ // 定义corsFilter方法，返回CorsFilter对象 + CorsConfiguration corsConfiguration = new CorsConfiguration(); // 创建CorsConfiguration实例 + //允许跨域请求的域名 + corsConfiguration.addAllowedOrigin("*"); // 允许所有域名进行跨域请求 + corsConfiguration.addAllowedMethod("*"); // 允许所有HTTP方法进行跨域请求 + //允许任何头部 + corsConfiguration.addAllowedHeader("*"); // 允许所有头部信息进行跨域请求 + UrlBasedCorsConfigurationSource urlBasedCorsConfigurationSource = new UrlBasedCorsConfigurationSource(); // 创建UrlBasedCorsConfigurationSource实例 + urlBasedCorsConfigurationSource.registerCorsConfiguration("/**",corsConfiguration); // 注册跨域配置到URL模式 + CorsFilter corsFilter = new CorsFilter(urlBasedCorsConfigurationSource); // 创建CorsFilter实例 + return corsFilter; // 返回CorsFilter实例 + } + +} \ No newline at end of file diff --git a/main/Notice.java b/main/Notice.java new file mode 100644 index 0000000..12cff04 --- /dev/null +++ b/main/Notice.java @@ -0,0 +1,94 @@ +package com.yanzhen.entity; + +import javax.validation.constraints.NotNull; +import org.hibernate.validator.constraints.Length; +import com.yanzhen.utils.Entity; +import java.util.Date; +import java.util.List; + + +public class Notice extends Entity{ // 定义一个继承自Entity的Notice类 + + private Integer id; // 定义一个私有的Integer类型的id变量，用于存储公告的唯一标识符 + + @Length(max = 200) // 使用@Length注解限制title字段的最大长度为200个字符 + private String title; // 定义一个私有的String类型的title变量，用于存储公告的标题 + + @Length(max = 0) // 使用@Length注解限制content字段的最大长度为0个字符（这似乎是一个错误，通常应设置为非零值） + private String content; // 定义一个私有的String类型的content变量，用于存储公告的内容 + + private Date createTime; // 定义一个私有的Date类型的createTime变量，用于存储公告的创建时间 + + private Integer userId; // 定义一个私有的Integer类型的userId变量，用于存储发布公告的用户ID + + @Length(max = 200) // 使用@Length注解限制filepath字段的最大长度为200个字符 + private String filepath; // 定义一个私有的String类型的filepath变量，用于存储与公告相关的文件路径 + + private User user; // 定义一个私有的User类型的user变量，用于存储发布公告的用户信息 + + private List buildingIds; // 定义一个私有的List类型的buildingIds变量，用于存储与公告相关的建筑ID列表 + + private Integer buildingId; // 定义一个私有的Integer类型的buildingId变量，用于存储单个建筑ID + + // Getter和Setter方法 + public Integer getId() { // 获取公告的ID + return id; + } + public void setId(Integer id) { // 设置公告的ID + this.id = id; + } + public String getTitle() { // 获取公告的标题 + return title; + } + public void setTitle(String title) { // 设置公告的标题 + this.title = title; + } + public String getContent() { // 获取公告的内容 + return content; + } + public void setContent(String content) { // 设置公告的内容 + this.content = content; + } + public Date getCreateTime() { // 获取公告的创建时间 + return createTime; + } + public void setCreateTime(Date createTime) { // 设置公告的创建时间 + this.createTime = createTime; + } + public Integer getUserId() { // 获取发布公告的用户ID + return userId; + } + public void setUserId(Integer userId) { // 设置发布公告的用户ID + this.userId = userId; + } + public String getFilepath() { // 获取与公告相关的文件路径 + return filepath; + } + public void setFilepath(String filepath) { // 设置与公告相关的文件路径 + this.filepath = filepath; + } + + public User getUser() { // 获取发布公告的用户信息 + return user; + } + + public void setUser(User user) { // 设置发布公告的用户信息 + this.user = user; + } + + public List getBuildingIds() { // 获取与公告相关的建筑ID列表 + return buildingIds; + } + + public void setBuildingIds(List buildingIds) { // 设置与公告相关的建筑ID列表 + this.buildingIds = buildingIds; + } + + public Integer getBuildingId() { // 获取单个建筑ID + return buildingId; + } + + public void setBuildingId(Integer buildingId) { // 设置单个建筑ID + this.buildingId = buildingId; + } +} \ No newline at end of file diff --git a/main/NoticeController.java b/main/NoticeController.java new file mode 100644 index 0000000..e0b1ac4 --- /dev/null +++ b/main/NoticeController.java @@ -0,0 +1,70 @@ +package com.yanzhen.controller; // 定义包名 + +import com.github.pagehelper.PageInfo; // 导入分页插件 +import com.yanzhen.entity.Notice; // 导入公告实体类 +import com.yanzhen.entity.User; // 导入用户实体类 +import com.yanzhen.service.NoticeService公告管理; // 导入公告服务接口 +import com.yanzhen.service.UserService用户管理; // 导入用户服务接口 +import com.yanzhen.utils.Result; // 导入结果工具类 +import org.springframework.beans.factory.annotation.Autowired; // 导入自动装配注解 +import org.springframework.web.bind.annotation.*; // 导入Spring MVC相关注解 + +import javax.servlet.http.HttpServletRequest; // 导入HttpServletRequest类 +import java.util.Map; // 导入Map接口 + +@RestController // 声明这是一个控制器，并且返回的数据直接写入HTTP响应体中 +@RequestMapping("/notice") // 设置请求路径前缀为/notice +public class NoticeController { // 定义控制器类 + + @Autowired // 自动注入NoticeService实例 + private NoticeService公告管理 noticeService; + @Autowired // 自动注入UserService实例 + private UserService用户管理 userService; + + @PostMapping("create") // 映射POST请求到create方法 + public Result create(@RequestBody Notice notice, HttpServletRequest request){ // 接收JSON格式的公告数据和请求对象 + User user = (User) request.getAttribute("user"); // 从请求中获取当前登录的用户信息 + notice.setUserId(user.getId()); // 设置公告的用户ID为当前用户的ID + int flag = noticeService.create(notice); // 调用服务层创建公告 + if(flag>0){ // 如果创建成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果创建失败 + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("delete") // 映射GET请求到delete方法 + public Result delete(String ids){ // 接收要删除的公告ID字符串 + int flag = noticeService.delete(ids); // 调用服务层删除公告 + if(flag>0){ // 如果删除成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果删除失败 + return Result.fail(); // 返回失败结果 + } + } + + @PostMapping("update") // 映射POST请求到update方法 + public Result update(@RequestBody Notice notice){ // 接收JSON格式的公告数据 + int flag = noticeService.updateSelective(notice); // 调用服务层更新公告 + if(flag>0){ // 如果更新成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果更新失败 + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("detail") // 映射GET请求到detail方法 + public Notice detail(Integer id){ // 接收公告ID + return noticeService.detail(id); // 调用服务层获取公告详情并返回 + } + + @PostMapping("query") // 映射POST请求到query方法 + public Map query(@RequestBody Notice notice){ // 接收JSON格式的查询条件 + PageInfo pageInfo = noticeService.query(notice); // 调用服务层进行分页查询 + pageInfo.getList().forEach(entity->{ // 遍历查询结果列表 + entity.setUser(userService.detail(entity.getUserId())); // 为每个公告设置对应的用户信息 + }); + return Result.ok(pageInfo); // 返回包含分页信息的查询结果 + } + +} \ No newline at end of file diff --git a/main/NoticeMapper.java b/main/NoticeMapper.java new file mode 100644 index 0000000..01bdf5a --- /dev/null +++ b/main/NoticeMapper.java @@ -0,0 +1,26 @@ +package com.yanzhen.mapper; // 定义包名 + +import java.util.List; // 导入List集合类 +import java.util.Map; // 导入Map集合类 + +import com.yanzhen.entity.Notice; // 导入Notice实体类 + +public interface NoticeMapper { // 定义NoticeMapper接口 + + public int create(Notice notice); // 创建Notice记录，返回受影响的行数 + + public int delete(Integer id); // 根据ID删除Notice记录，返回受影响的行数 + + public int update(Notice notice); // 更新Notice记录，返回受影响的行数 + + public int updateSelective(Notice notice); // 选择性更新Notice记录，返回受影响的行数 + + public List query(Notice notice); // 根据条件查询Notice列表 + + public List queryByBuildingId(Notice notice); // 根据建筑ID查询Notice列表 + + public Notice detail(Integer id); // 根据ID查询Notice详情 + + public int count(Notice notice); // 统计符合条件的Notice数量 + +} \ No newline at end of file diff --git a/main/NoticeReceive.java b/main/NoticeReceive.java new file mode 100644 index 0000000..81fb4eb --- /dev/null +++ b/main/NoticeReceive.java @@ -0,0 +1,42 @@ +package com.yanzhen.entity; + +import javax.validation.constraints.NotNull; +import org.hibernate.validator.constraints.Length; +import com.yanzhen.utils.Entity; +import java.util.Date; + + +public class NoticeReceive extends Entity{// 定义一个名为NoticeReceive的类，继承自Entity类 + + private Integer id; // 定义一个私有的Integer类型的变量id + + private Integer noticeId;// 定义一个私有的Integer类型的变量noticeId + + private Integer buildingId;// 定义一个私有的Integer类型的变量buildingId + + public Integer getId() { + return id;// 定义一个公共方法getId，用于获取id的值 + } + + public void setId(Integer id) { + this.id = id;// 定义一个公共方法setId，用于设置id的值 + } + + public Integer getNoticeId() { + return noticeId;// 定义一个公共方法getNoticeId，用于获取noticeId的值 + } + + public void setNoticeId(Integer noticeId) { + this.noticeId = noticeId;// 定义一个公共方法setNoticeId，用于设置noticeId的值 + } + + + public Integer getBuildingId() { + return buildingId;// 定义一个公共方法getBuildingId，用于获取buildingId的值 + } + + + public void setBuildingId(Integer buildingId) { + this.buildingId = buildingId;// 定义一个公共方法setBuildingId，用于设置buildingId的值 + } +} \ No newline at end of file diff --git a/main/NoticeReceiveController.java b/main/NoticeReceiveController.java new file mode 100644 index 0000000..1786e27 --- /dev/null +++ b/main/NoticeReceiveController.java @@ -0,0 +1,60 @@ +package com.yanzhen.controller; // 定义包名 + +import com.github.pagehelper.PageInfo; // 导入分页插件 +import com.yanzhen.entity.NoticeReceive; // 导入公告接收实体类 +import com.yanzhen.service.NoticeReceiveService公告查看; // 导入公告接收服务接口 +import com.yanzhen.utils.Result; // 导入结果工具类 +import org.springframework.beans.factory.annotation.Autowired; // 导入自动装配注解 +import org.springframework.web.bind.annotation.*; // 导入Spring MVC相关注解 + +import java.util.Map; // 导入Map接口 + +@RestController // 声明这是一个控制器，并且返回的数据直接写入HTTP响应体中 +@RequestMapping("/noticeReceive") // 设置请求路径前缀为/noticeReceive +public class NoticeReceiveController { // 定义控制器类 + + @Autowired // 自动注入NoticeReceiveService实例 + private NoticeReceiveService公告查看 noticeReceiveService; + + @PostMapping("create") // 映射POST请求到create方法 + public Result create(@RequestBody NoticeReceive noticeReceive){ // 接收JSON格式的公告接收数据 + int flag = noticeReceiveService.create(noticeReceive); // 调用服务层创建公告接收 + if(flag>0){ // 如果创建成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果创建失败 + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("delete") // 映射GET请求到delete方法 + public Result delete(String ids){ // 接收要删除的公告接收ID字符串 + int flag = noticeReceiveService.delete(ids); // 调用服务层删除公告接收 + if(flag>0){ // 如果删除成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果删除失败 + return Result.fail(); // 返回失败结果 + } + } + + @PostMapping("update") // 映射POST请求到update方法 + public Result update(@RequestBody NoticeReceive noticeReceive){ // 接收JSON格式的公告接收数据 + int flag = noticeReceiveService.update(noticeReceive); // 调用服务层更新公告接收 + if(flag>0){ // 如果更新成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果更新失败 + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("detail") // 映射GET请求到detail方法 + public NoticeReceive detail(Integer id){ // 接收公告接收ID + return noticeReceiveService.detail(id); // 调用服务层获取公告接收详情并返回 + } + + @PostMapping("query") // 映射POST请求到query方法 + public Map query(@RequestBody NoticeReceive noticeReceive){ // 接收JSON格式的查询条件 + PageInfo pageInfo = noticeReceiveService.query(noticeReceive); // 调用服务层进行分页查询 + return Result.ok(pageInfo); // 返回包含分页信息的查询结果 + } + +} \ No newline at end of file diff --git a/main/NoticeReceiveMapper.java b/main/NoticeReceiveMapper.java new file mode 100644 index 0000000..4313a82 --- /dev/null +++ b/main/NoticeReceiveMapper.java @@ -0,0 +1,25 @@ +package com.yanzhen.mapper; // 定义包名 + +import java.util.List; // 导入List集合类 +import java.util.Map; // 导入Map集合类 + +import com.yanzhen.entity.NoticeReceive; // 导入NoticeReceive实体类 + +public interface NoticeReceiveMapper { // 定义NoticeReceiveMapper接口 + + public int create(NoticeReceive noticeReceive); // 创建NoticeReceive记录的方法 + + public int delete(Integer id); // 根据ID删除NoticeReceive记录的方法 + + public int deleteByNoticeId(Integer noticeId); // 根据通知ID删除NoticeReceive记录的方法 + + public int update(NoticeReceive noticeReceive); // 更新NoticeReceive记录的方法 + + public int updateSelective(NoticeReceive noticeReceive); // 选择性更新NoticeReceive记录的方法 + + public List query(NoticeReceive noticeReceive); // 查询NoticeReceive记录列表的方法 + + public NoticeReceive detail(Integer id); // 根据ID获取NoticeReceive详情的方法 + + public int count(NoticeReceive noticeReceive); // 统计NoticeReceive记录数量的方法 +} \ No newline at end of file diff --git a/main/NoticeReceiveService公告查看.java b/main/NoticeReceiveService公告查看.java new file mode 100644 index 0000000..88552ec --- /dev/null +++ b/main/NoticeReceiveService公告查看.java @@ -0,0 +1,59 @@ +package com.yanzhen.service; // 定义包名 + +import com.yanzhen.mapper.NoticeReceiveMapper; // 导入NoticeReceiveMapper接口 +import com.yanzhen.entity.NoticeReceive; // 导入NoticeReceive实体类 +import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类 +import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类 +import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解 +import org.springframework.stereotype.Service; // 导入Spring的服务层注解 +import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作 + +@Service // 标注该类为服务层组件 +public class NoticeReceiveService公告查看 { // 定义NoticeReceiveService类 “公告查看----学生” + + @Autowired // 自动装配NoticeReceiveMapper对象 + private NoticeReceiveMapper noticeReceiveMapper; + + public int create(NoticeReceive noticeReceive) { // 创建NoticeReceive记录的方法 + return noticeReceiveMapper.create(noticeReceive); // 调用Mapper层的create方法 + } + + public int delete(String ids) { // 根据ID字符串批量删除NoticeReceive记录的方法 + String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组 + int row = 0; // 初始化受影响行数为0 + for (String s : arr) { // 遍历ID数组 + if(!StringUtils.isEmpty(s)){ // 如果ID不为空 + noticeReceiveMapper.delete(Integer.parseInt(s)); // 调用Mapper层的delete方法删除记录 + row++; // 受影响行数加1 + } + } + return row; // 返回受影响行数 + } + + public int delete(Integer id) { // 根据ID删除NoticeReceive记录的方法 + return noticeReceiveMapper.delete(id); // 调用Mapper层的delete方法 + } + + public int update(NoticeReceive noticeReceive) { // 更新NoticeReceive记录的方法 + return noticeReceiveMapper.update(noticeReceive); // 调用Mapper层的update方法 + } + + public int updateSelective(NoticeReceive noticeReceive) { // 选择性更新NoticeReceive记录的方法 + return noticeReceiveMapper.updateSelective(noticeReceive); // 调用Mapper层的updateSelective方法 + } + + public PageInfo query(NoticeReceive noticeReceive) { // 查询NoticeReceive记录列表的方法 + if(noticeReceive != null && noticeReceive.getPage() != null){ // 如果查询条件和分页信息不为空 + PageHelper.startPage(noticeReceive.getPage(),noticeReceive.getLimit()); // 启动分页并设置分页参数 + } + return new PageInfo(noticeReceiveMapper.query(noticeReceive)); // 调用Mapper层的query方法并封装成PageInfo对象返回 + } + + public NoticeReceive detail(Integer id) { // 根据ID获取NoticeReceive详情的方法 + return noticeReceiveMapper.detail(id); // 调用Mapper层的detail方法 + } + + public int count(NoticeReceive noticeReceive) { // 统计NoticeReceive记录数量的方法 + return noticeReceiveMapper.count(noticeReceive); // 调用Mapper层的count方法 + } +} \ No newline at end of file diff --git a/main/NoticeService公告管理.java b/main/NoticeService公告管理.java new file mode 100644 index 0000000..9fb8cbc --- /dev/null +++ b/main/NoticeService公告管理.java @@ -0,0 +1,100 @@ +package com.yanzhen.service; + +import com.yanzhen.entity.NoticeReceive; +import com.yanzhen.mapper.NoticeMapper; +import com.yanzhen.entity.Notice; +import com.github.pagehelper.PageHelper; +import com.github.pagehelper.PageInfo; +import com.yanzhen.mapper.NoticeReceiveMapper; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.util.StringUtils; + +import java.util.List; + +@Service // 标记为Spring的服务组件 +public class NoticeService公告管理 { // “公告管理----管理员/宿管” + + @Autowired // 自动注入NoticeMapper依赖 + private NoticeMapper noticeMapper; + @Autowired // 自动注入NoticeReceiveMapper依赖 + private NoticeReceiveMapper noticeReceiveMapper; + + // 创建通知，并关联到多个建筑 + public int create(Notice notice) { + noticeMapper.create(notice); // 在数据库中创建通知记录 + List buildingIds = notice.getBuildingIds(); // 获取通知关联的建筑ID列表 + for (Integer buildingId : buildingIds) { // 遍历每个建筑ID + NoticeReceive noticeReceive = new NoticeReceive(); // 创建新的NoticeReceive对象 + noticeReceive.setBuildingId(buildingId); // 设置建筑ID + noticeReceive.setNoticeId(notice.getId()); // 设置通知ID + noticeReceiveMapper.create(noticeReceive); // 在数据库中创建通知接收记录 + } + return 1; // 返回成功标志 + } + + // 根据逗号分隔的ID字符串批量删除通知 + public int delete(String ids) { + String[] arr = ids.split(","); // 将ID字符串分割成数组 + int row = 0; // 初始化受影响行数计数器 + for (String s : arr) { // 遍历每个ID + if(!StringUtils.isEmpty(s)){ // 如果ID不为空 + noticeReceiveMapper.deleteByNoticeId(Integer.parseInt(s)); // 删除相关的通知接收记录 + noticeMapper.delete(Integer.parseInt(s)); // 删除通知记录 + row++; // 增加受影响行数计数器 + } + } + return row; // 返回受影响行数 + } + + // 根据单个ID删除通知 + public int delete(Integer id) { + noticeReceiveMapper.deleteByNoticeId(id); // 删除相关的通知接收记录 + return noticeMapper.delete(id); // 删除通知记录并返回结果 + } + + // 更新通知信息 + public int update(Notice notice) { + return noticeMapper.update(notice); // 更新通知记录并返回结果 + } + + // 选择性更新通知信息，同时重新关联建筑 + public int updateSelective(Notice notice) { + noticeMapper.updateSelective(notice); // 选择性更新通知记录 + noticeReceiveMapper.deleteByNoticeId(notice.getId()); // 删除旧的通知接收记录 + List buildingIds = notice.getBuildingIds(); // 获取新的通知关联的建筑ID列表 + for (Integer buildingId : buildingIds) { // 遍历每个建筑ID + NoticeReceive noticeReceive = new NoticeReceive(); // 创建新的NoticeReceive对象 + noticeReceive.setBuildingId(buildingId); // 设置建筑ID + noticeReceive.setNoticeId(notice.getId()); // 设置通知ID + noticeReceiveMapper.create(noticeReceive); // 在数据库中创建新的通知接收记录 + } + return 1; // 返回成功标志 + } + + // 分页查询通知 + public PageInfo query(Notice notice) { + if(notice != null && notice.getPage() != null){ // 如果通知对象和分页信息不为空 + PageHelper.startPage(notice.getPage(), notice.getLimit()); // 启动分页 + } + return new PageInfo(noticeMapper.query(notice)); // 执行查询并返回分页结果 + } + + // 根据建筑ID分页查询通知 + public PageInfo queryByBuildingId(Notice notice){ + if(notice != null && notice.getPage() != null){ // 如果通知对象和分页信息不为空 + PageHelper.startPage(notice.getPage(), notice.getLimit()); // 启动分页 + } + return new PageInfo(noticeMapper.queryByBuildingId(notice)); // 执行查询并返回分页结果 + } + + // 根据ID获取通知详情 + public Notice detail(Integer id) { + return noticeMapper.detail(id); // 查询并返回通知详情 + } + + // 统计符合条件的通知数量 + public int count(Notice notice) { + return noticeMapper.count(notice); // 查询并返回符合条件的通知数量 + } +} \ No newline at end of file diff --git a/main/Org.java b/main/Org.java new file mode 100644 index 0000000..da0e98d --- /dev/null +++ b/main/Org.java @@ -0,0 +1,89 @@ +package com.yanzhen.entity; + +import javax.validation.constraints.NotNull; +import org.hibernate.validator.constraints.Length; +import com.yanzhen.utils.Entity; +import java.util.Date; + + + +public class Org extends Entity{ + // 定义一个私有的Integer类型的变量id，用于存储组织的唯一标识符 + private Integer id; + + // 使用@Length注解限制name字段的最大长度为100个字符 + @Length(max = 100) + private String name; + + private Integer type;//定义一个私有的Integer类型的变量type，用于表示组织的类型。--类型说明：1 - 学院; 2 - 系;3 - 专业;4 - 班级 + + // 定义一个私有的Integer类型的变量gradeId，用于存储年级ID + private Integer gradeId; + + // 定义一个私有的Integer类型的变量parentId，用于存储父级组织的ID + private Integer parentId; + + // 使用@Length注解限制remark字段的最大长度为200个字符 + @Length(max = 200) + private String remark; + + // 获取id的值 + public Integer getId() { + return id; + } + + // 设置id的值 + public void setId(Integer id) { + this.id = id; + } + + // 获取name的值 + public String getName() { + return name; + } + + // 设置name的值 + public void setName(String name) { + this.name = name; + } + + // 获取type的值 + public Integer getType() { + return type; + } + + // 设置type的值 + public void setType(Integer type) { + this.type = type; + } + + // 获取gradeId的值 + public Integer getGradeId() { + return gradeId; + } + + // 设置gradeId的值 + public void setGradeId(Integer gradeId) { + this.gradeId = gradeId; + } + + // 获取parentId的值 + public Integer getParentId() { + return parentId; + } + + // 设置parentId的值 + public void setParentId(Integer parentId) { + this.parentId = parentId; + } + + // 获取remark的值 + public String getRemark() { + return remark; + } + + // 设置remark的值 + public void setRemark(String remark) { + this.remark = remark; + } +} diff --git a/main/OrgController.java b/main/OrgController.java new file mode 100644 index 0000000..67af0c1 --- /dev/null +++ b/main/OrgController.java @@ -0,0 +1,111 @@ +package com.yanzhen.controller; // 定义包名 + +import com.github.pagehelper.PageInfo; // 导入分页插件 +import com.yanzhen.entity.Org; // 导入组织实体类 +import com.yanzhen.service.OrgService机构管理; // 导入组织服务接口 +import com.yanzhen.utils.Result; // 导入结果工具类 +import org.springframework.beans.factory.annotation.Autowired; // 导入自动装配注解 +import org.springframework.web.bind.annotation.*; // 导入Spring MVC相关注解 + +import java.util.ArrayList; // 导入ArrayList类 +import java.util.HashMap; // 导入HashMap类 +import java.util.List; // 导入List接口 +import java.util.Map; // 导入Map接口 + +@RestController // 声明这是一个控制器，并且返回的数据直接写入HTTP响应体中 +@RequestMapping("/org") // 设置请求路径前缀为/org +public class OrgController { // 定义控制器类 + + @Autowired // 自动注入OrgService实例 + private OrgService机构管理 orgService; + + @GetMapping("tree") // 映射GET请求到/org/tree路径 + public Result tree(){ // 定义获取树形结构的方法 + PageInfo pageInfo = orgService.query(null); // 查询所有组织数据 + //所有的树形数据 + List list = pageInfo.getList(); // 获取查询结果列表 + //要构建的树形结构 + List> trees = new ArrayList<>(); // 初始化树形结构的列表 + for (Org entity : list) { // 遍历所有组织数据 + if(entity.getParentId() == 0){ // 如果父ID为0，表示是顶级节点 + Map map = new HashMap<>(); // 创建一个新的Map对象 + map.put("id",entity.getId()); // 将组织ID放入Map + map.put("name",entity.getName()); // 将组织名称放入Map + if(entity.getType()<4){ // 如果类型小于4，表示有子节点 + map.put("isParent",true); // 标记为父节点 + map.put("open",true); // 默认展开 + map.put("children",getChild(entity,list)); // 递归获取子节点并放入Map + }else{ + map.put("isParent",false); // 标记为叶子节点 + } + trees.add(map); // 将Map添加到树形结构列表中 + } + } + return Result.ok(trees); // 返回包含树形结构的响应结果 + } + + //自己调自己、有出口 + public List> getChild(Org parent,List list){ // 定义递归方法获取子节点 + List> child = new ArrayList<>(); // 初始化子节点列表 + for (Org org : list) { // 遍历所有组织数据 + if(parent.getId() == org.getParentId()){ // 如果当前组织的父ID等于传入的父节点ID + Map map = new HashMap<>(); // 创建一个新的Map对象 + map.put("id",org.getId()); // 将组织ID放入Map + map.put("name",org.getName()); // 将组织名称放入Map + if(org.getType()<4){ // 如果类型小于4，表示有子节点 + map.put("isParent",true); // 标记为父节点 + map.put("children",getChild(org,list)); // 递归获取子节点并放入Map + }else{ + map.put("isParent",false); // 标记为叶子节点 + } + child.add(map); // 将Map添加到子节点列表中 + } + } + return child; // 返回子节点列表 + } + + @PostMapping("create") // 映射POST请求到/org/create路径 + public Result create(@RequestBody Org org){ // 定义创建组织的方法 + //未设置则为一级栏目 + if(org.getParentId() == null){ // 如果父ID为空，设置为0（顶级节点） + org.setParentId(0); + } + int flag = orgService.create(org); // 调用服务层方法创建组织 + if(flag>0){ // 如果创建成功 + return Result.ok(); // 返回成功结果 + }else{ + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("delete") // 映射GET请求到/org/delete路径 + public Result delete(String id){ // 定义删除组织的方法 + int flag = orgService.delete(id); // 调用服务层方法删除组织 + if(flag>0){ // 如果删除成功 + return Result.ok(); // 返回成功结果 + }else{ + return Result.fail(); // 返回失败结果 + } + } + + @PostMapping("update") // 映射POST请求到/org/update路径 + public Result update(@RequestBody Org org){ // 定义更新组织的方法 + int flag = orgService.update(org); // 调用服务层方法更新组织信息 + if(flag>0){ // 如果更新成功 + return Result.ok(); // 返回成功结果 + }else{ + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("detail") // 映射GET请求到/org/detail路径 + public Org detail(Integer id){ // 定义获取组织详情的方法 + return orgService.detail(id); // 调用服务层方法获取组织详情并返回 + } + + @PostMapping("query") // 映射POST请求到/org/query路径 + public Map query(@RequestBody Org org){ // 定义查询组织的方法 + PageInfo pageInfo = orgService.query(org); // 调用服务层方法查询组织数据 + return Result.ok(pageInfo); // 返回包含查询结果的响应结果 + } +} \ No newline at end of file diff --git a/main/OrgMapper.java b/main/OrgMapper.java new file mode 100644 index 0000000..fad09a8 --- /dev/null +++ b/main/OrgMapper.java @@ -0,0 +1,25 @@ +package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包 + +import java.util.List; // 导入Java的List类，用于处理列表数据结构 +import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构 + +import com.yanzhen.entity.Org; // 导入Org实体类，用于操作组织信息 + +public interface OrgMapper { // 定义OrgMapper接口，提供对Org实体进行数据库操作的方法 + + public int create(Org org); // 创建一个新的Org记录，返回影响的行数 + + public int delete(Integer id); // 根据id删除一个Org记录，返回影响的行数 + + public int update(Org org); // 更新一个Org记录，返回影响的行数 + + public int updateSelective(Org org); // 选择性地更新一个Org记录，返回影响的行数 + + public List query(Org org); // 根据条件查询Org记录，返回符合条件的Org列表 + + public Org detail(Integer id); // 根据id查询一个Org记录的详细信息，返回Org对象 + + public int count(Org org); // 根据条件统计Org记录的数量，返回记录数量 + + public List queryOrgBySelectionId(Integer selectionId); // 根据selectionId查询相关的Org记录，返回符合条件的Org列表 +} \ No newline at end of file diff --git a/main/OrgService机构管理.java b/main/OrgService机构管理.java new file mode 100644 index 0000000..71c7516 --- /dev/null +++ b/main/OrgService机构管理.java @@ -0,0 +1,65 @@ +package com.yanzhen.service; // 定义包名 + +import com.yanzhen.mapper.OrgMapper; // 导入OrgMapper接口 +import com.yanzhen.entity.Org; // 导入Org实体类 +import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类 +import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类 +import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解 +import org.springframework.stereotype.Service; // 导入Spring的服务层注解 +import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作 + +import java.util.List; // 导入Java的List接口 + +@Service // 标注该类为服务层组件 +public class OrgService机构管理 { // 定义OrgService类 “机构管理----管理员” + + @Autowired // 自动装配OrgMapper对象 + private OrgMapper orgMapper; + + public int create(Org org) { // 创建Org记录的方法 + return orgMapper.create(org); // 调用Mapper层的create方法 + } + + public int delete(String ids) { // 根据ID字符串批量删除Org记录的方法 + String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组 + int row = 0; // 初始化受影响行数为0 + for (String s : arr) { // 遍历ID数组 + if(!StringUtils.isEmpty(s)){ // 如果ID不为空 + orgMapper.delete(Integer.parseInt(s)); // 调用Mapper层的delete方法删除记录 + row++; // 受影响行数加1 + } + } + return row; // 返回受影响行数 + } + + public int delete(Integer id) { // 根据ID删除Org记录的方法 + return orgMapper.delete(id); // 调用Mapper层的delete方法 + } + + public int update(Org org) { // 更新Org记录的方法 + return orgMapper.update(org); // 调用Mapper层的update方法 + } + + public int updateSelective(Org org) { // 选择性更新Org记录的方法 + return orgMapper.updateSelective(org); // 调用Mapper层的updateSelective方法 + } + + public PageInfo query(Org org) { // 查询Org记录列表的方法 + if(org != null && org.getPage() != null){ // 如果查询条件和分页信息不为空 + PageHelper.startPage(org.getPage(),org.getLimit()); // 启动分页并设置分页参数 + } + return new PageInfo(orgMapper.query(org)); // 调用Mapper层的query方法并封装成PageInfo对象返回 + } + + public Org detail(Integer id) { // 根据ID获取Org详情的方法 + return orgMapper.detail(id); // 调用Mapper层的detail方法 + } + + public int count(Org org) { // 统计Org记录数量的方法 + return orgMapper.count(org); // 调用Mapper层的count方法 + } + + public List queryOrgBySelectionId(Integer selectionId){ // 根据selectionId查询Org列表的方法 + return orgMapper.queryOrgBySelectionId(selectionId); // 调用Mapper层的queryOrgBySelectionId方法 + } +} \ No newline at end of file diff --git a/main/Record.java b/main/Record.java new file mode 100644 index 0000000..bef4133 --- /dev/null +++ b/main/Record.java @@ -0,0 +1,59 @@ +package com.yanzhen.entity; + +import javax.validation.constraints.NotNull; +import org.hibernate.validator.constraints.Length; +import com.yanzhen.utils.Entity; +import java.util.Date; + + +public class Record extends Entity{ // 定义一个名为Record的类，继承自Entity类 + + private Integer id; // 定义一个私有的Integer类型的变量id + + private Integer studentId; // 定义一个私有的Integer类型的变量studentId + + private Integer dormitoryId; // 定义一个私有的Integer类型的变量dormitoryId + + private Integer bedId; // 定义一个私有的Integer类型的变量bedId + + private Integer status; // 定义一个私有的Integer类型的变量status，用于表示入住或退宿状态（ 1入住/2退宿） + + private Date createDate; // 定义一个私有的Date类型的变量createDate，用于记录创建日期 + + public Integer getId() { // 定义一个公共方法getId，用于获取id的值 + return id; + } + public void setId(Integer id) { // 定义一个公共方法setId，用于设置id的值 + this.id = id; + } + public Integer getStudentId() { // 定义一个公共方法getStudentId，用于获取studentId的值 + return studentId; + } + public void setStudentId(Integer studentId) { // 定义一个公共方法setStudentId，用于设置studentId的值 + this.studentId = studentId; + } + public Integer getDormitoryId() { // 定义一个公共方法getDormitoryId，用于获取dormitoryId的值 + return dormitoryId; + } + public void setDormitoryId(Integer dormitoryId) { // 定义一个公共方法setDormitoryId，用于设置dormitoryId的值 + this.dormitoryId = dormitoryId; + } + public Integer getBedId() { // 定义一个公共方法getBedId，用于获取bedId的值 + return bedId; + } + public void setBedId(Integer bedId) { // 定义一个公共方法setBedId，用于设置bedId的值 + this.bedId = bedId; + } + public Integer getStatus() { // 定义一个公共方法getStatus，用于获取status的值 + return status; + } + public void setStatus(Integer status) { // 定义一个公共方法setStatus，用于设置status的值 + this.status = status; + } + public Date getCreateDate() { // 定义一个公共方法getCreateDate，用于获取createDate的值 + return createDate; + } + public void setCreateDate(Date createDate) { // 定义一个公共方法setCreateDate，用于设置createDate的值 + this.createDate = createDate; + } +} \ No newline at end of file diff --git a/main/RecordController.java b/main/RecordController.java new file mode 100644 index 0000000..e79053c --- /dev/null +++ b/main/RecordController.java @@ -0,0 +1,60 @@ +package com.yanzhen.controller; // 定义包名 + +import com.github.pagehelper.PageInfo; // 导入分页插件 +import com.yanzhen.entity.Record; // 导入记录实体类 +import com.yanzhen.service.RecordService用户id的增删查改数据库; // 导入记录服务接口 +import com.yanzhen.utils.Result; // 导入结果工具类 +import org.springframework.beans.factory.annotation.Autowired; // 导入自动装配注解 +import org.springframework.web.bind.annotation.*; // 导入Spring MVC相关注解 + +import java.util.Map; // 导入Map接口 + +@RestController // 声明这是一个控制器，并且返回的数据直接写入HTTP响应体中 +@RequestMapping("/record") // 设置请求路径前缀为/record +public class RecordController { // 定义控制器类 + + @Autowired // 自动注入RecordService实例 + private RecordService用户id的增删查改数据库 recordService; + + @PostMapping("create") // 映射POST请求到create方法 + public Result create(@RequestBody Record record){ // 接收JSON格式的记录数据 + int flag = recordService.create(record); // 调用服务层创建记录 + if(flag>0){ // 如果创建成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果创建失败 + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("delete") // 映射GET请求到delete方法 + public Result delete(String ids){ // 接收要删除的记录ID字符串 + int flag = recordService.delete(ids); // 调用服务层删除记录 + if(flag>0){ // 如果删除成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果删除失败 + return Result.fail(); // 返回失败结果 + } + } + + @PostMapping("update") // 映射POST请求到update方法 + public Result update(@RequestBody Record record){ // 接收JSON格式的记录数据 + int flag = recordService.update(record); // 调用服务层更新记录 + if(flag>0){ // 如果更新成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果更新失败 + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("detail") // 映射GET请求到detail方法 + public Record detail(Integer id){ // 接收记录ID + return recordService.detail(id); // 调用服务层获取记录详情并返回 + } + + @PostMapping("query") // 映射POST请求到query方法 + public Map query(@RequestBody Record record){ // 接收JSON格式的查询条件 + PageInfo pageInfo = recordService.query(record); // 调用服务层进行分页查询 + return Result.ok(pageInfo); // 返回包含分页信息的查询结果 + } + +} \ No newline at end of file diff --git a/main/RecordMapper.java b/main/RecordMapper.java new file mode 100644 index 0000000..30975ac --- /dev/null +++ b/main/RecordMapper.java @@ -0,0 +1,24 @@ +package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包 + +import java.util.List; // 导入Java的List类，用于处理列表数据结构 +import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构 + +import com.yanzhen.entity.Record; // 导入Record实体类，用于操作记录信息 + +public interface RecordMapper { // 定义RecordMapper接口，提供对Record实体进行数据库操作的方法 + + public int create(Record record); // 创建一个新的Record记录，返回影响的行数 + + public int delete(Integer id); // 根据id删除一个Record记录，返回影响的行数 + + public int update(Record record); // 更新一个Record记录，返回影响的行数 + + public int updateSelective(Record record); // 选择性地更新一个Record记录，返回影响的行数 + + public List query(Record record); // 根据条件查询Record记录，返回符合条件的Record列表 + + public Record detail(Integer id); // 根据id查询一个Record记录的详细信息，返回Record对象 + + public int count(Record record); // 根据条件统计Record记录的数量，返回记录数量 + +} \ No newline at end of file diff --git a/main/RecordService用户id的增删查改数据库.java b/main/RecordService用户id的增删查改数据库.java new file mode 100644 index 0000000..a3b66c1 --- /dev/null +++ b/main/RecordService用户id的增删查改数据库.java @@ -0,0 +1,59 @@ +package com.yanzhen.service; // 定义包名 + +import com.yanzhen.mapper.RecordMapper; // 导入RecordMapper接口 +import com.yanzhen.entity.Record; // 导入Record实体类 +import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类 +import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类 +import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解 +import org.springframework.stereotype.Service; // 导入Spring的服务层注解 +import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作 + +@Service // 标注该类为服务层组件 +public class RecordService用户id的增删查改数据库 { // 定义RecordService类 “----管理员/宿管” + + @Autowired // 自动装配RecordMapper对象 + private RecordMapper recordMapper; + + public int create(Record record) { // 创建记录的方法 + return recordMapper.create(record); // 调用Mapper层的create方法 + } + + public int delete(String ids) { // 根据ID字符串批量删除记录的方法 + String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组 + int row = 0; // 初始化受影响行数为0 + for (String s : arr) { // 遍历ID数组 + if(!StringUtils.isEmpty(s)){ // 如果ID不为空 + recordMapper.delete(Integer.parseInt(s)); // 调用Mapper层的delete方法删除记录 + row++; // 受影响行数加1 + } + } + return row; // 返回受影响行数 + } + + public int delete(Integer id) { // 根据ID删除记录的方法 + return recordMapper.delete(id); // 调用Mapper层的delete方法 + } + + public int update(Record record) { // 更新记录的方法 + return recordMapper.update(record); // 调用Mapper层的update方法 + } + + public int updateSelective(Record record) { // 选择性更新记录的方法 + return recordMapper.updateSelective(record); // 调用Mapper层的updateSelective方法 + } + + public PageInfo query(Record record) { // 查询记录列表的方法 + if(record != null && record.getPage() != null){ // 如果查询条件和分页信息不为空 + PageHelper.startPage(record.getPage(),record.getLimit()); // 启动分页并设置分页参数 + } + return new PageInfo(recordMapper.query(record)); // 调用Mapper层的query方法并封装成PageInfo对象返回 + } + + public Record detail(Integer id) { // 根据ID获取详情的方法 + return recordMapper.detail(id); // 调用Mapper层的detail方法 + } + + public int count(Record record) { // 统计记录数量的方法 + return recordMapper.count(record); // 调用Mapper层的count方法 + } +} \ No newline at end of file diff --git a/main/Repair.java b/main/Repair.java new file mode 100644 index 0000000..9e03c08 --- /dev/null +++ b/main/Repair.java @@ -0,0 +1,108 @@ +package com.yanzhen.entity; + +import org.hibernate.validator.constraints.Length; +import com.yanzhen.utils.Entity; +import java.util.Date; + + + +public class Repair extends Entity{ // 定义一个名为Repair的类，继承自Entity类 + + private Integer id; // 定义一个私有的Integer类型的变量id + + private Integer studentId; // 定义一个私有的Integer类型的变量studentId + + private Integer dormitoryId; // 定义一个私有的Integer类型的变量dormitoryId + + private Integer buildingId; // 定义一个私有的Integer类型的变量buildingId + + @Length(max = 500) // 限制description字段的最大长度为500 + private String description; // 定义一个私有的String类型的变量description + + private Date createDate; // 定义一个私有的Date类型的变量createDate + + private Integer status; // 定义一个私有的Integer类型的变量status，用于表示维修状态（0待解决/1已解决） + + private Student student; // 定义一个私有的Student类型的变量student + + private Dormitory dormitory; // 定义一个私有的Dormitory类型的变量dormitory，并命名为“宿舍” + + private Building building; // 定义一个私有的Building类型的变量building，并命名为“楼宇” + + private String name; // 定义一个私有的String类型的变量name + + public Integer getId() { // 定义一个公共方法getId，用于获取id的值 + return id; + } + public void setId(Integer id) { // 定义一个公共方法setId，用于设置id的值 + this.id = id; + } + public Integer getStudentId() { // 定义一个公共方法getStudentId，用于获取studentId的值 + return studentId; + } + public void setStudentId(Integer studentId) { // 定义一个公共方法setStudentId，用于设置studentId的值 + this.studentId = studentId; + } + public Integer getDormitoryId() { // 定义一个公共方法getDormitoryId，用于获取dormitoryId的值 + return dormitoryId; + } + public void setDormitoryId(Integer dormitoryId) { // 定义一个公共方法setDormitoryId，用于设置dormitoryId的值 + this.dormitoryId = dormitoryId; + } + public Integer getBuildingId() { // 定义一个公共方法getBuildingId，用于获取buildingId的值 + return buildingId; + } + public void setBuildingId(Integer buildingId) { // 定义一个公共方法setBuildingId，用于设置buildingId的值 + this.buildingId = buildingId; + } + public String getDescription() { // 定义一个公共方法getDescription，用于获取description的值 + return description; + } + public void setDescription(String description) { // 定义一个公共方法setDescription，用于设置description的值 + this.description = description; + } + public Date getCreateDate() { // 定义一个公共方法getCreateDate，用于获取createDate的值 + return createDate; + } + public void setCreateDate(Date createDate) { // 定义一个公共方法setCreateDate，用于设置createDate的值 + this.createDate = createDate; + } + public Integer getStatus() { // 定义一个公共方法getStatus，用于获取status的值 + return status; + } + public void setStatus(Integer status) { // 定义一个公共方法setStatus，用于设置status的值 + this.status = status; + } + + public Student getStudent() { // 定义一个公共方法getStudent，用于获取student的值 + return student; + } + + public void setStudent(Student student) { // 定义一个公共方法setStudent，用于设置student的值 + this.student = student; + } + + public Dormitory getDormitory() { // 定义一个公共方法getDormitory，用于获取dormitory的值 + return dormitory; + } + + public void setDormitory(Dormitory dormitory) { // 定义一个公共方法setDormitory，用于设置dormitory的值 + this.dormitory = dormitory; + } + + public Building getBuilding() { // 定义一个公共方法getBuilding，用于获取building的值 + return building; + } + + public void setBuilding(Building building) { // 定义一个公共方法setBuilding，用于设置building的值 + this.building = building; + } + + public String getName() { // 定义一个公共方法getName，用于获取name的值 + return name; + } + + public void setName(String name) { // 定义一个公共方法setName，用于设置name的值 + this.name = name; + } +} \ No newline at end of file diff --git a/main/RepairController.java b/main/RepairController.java new file mode 100644 index 0000000..07cfcf7 --- /dev/null +++ b/main/RepairController.java @@ -0,0 +1,85 @@ +package com.yanzhen.controller; + +import com.github.pagehelper.PageInfo; +import com.yanzhen.entity.Repair; +import com.yanzhen.entity.Student; +import com.yanzhen.service.BuildingService楼层设置; +import com.yanzhen.service.DormitoryService宿舍编号设置; +import com.yanzhen.service.RepairService报修管理; +import com.yanzhen.service.StudentService学生管理; +import com.yanzhen.utils.Result; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +import java.util.Map; + +@RestController // 声明这是一个RESTful控制器 +@RequestMapping("/repair") // 设置请求路径前缀为/repair +public class RepairController { + + @Autowired // 自动注入RepairService实例 + private RepairService报修管理 repairService; + @Autowired // 自动注入StudentService实例 + private StudentService学生管理 studentService; + @Autowired // 自动注入DormitoryService实例 + private DormitoryService宿舍编号设置 dormitoryService; + @Autowired // 自动注入BuildingService实例 + private BuildingService楼层设置 buildingService; + + @PostMapping("create") // 映射HTTP POST请求到create方法 + public Result create(@RequestBody Repair repair){ // 接收一个Repair对象作为请求体 + int flag = repairService.create(repair); // 调用服务层创建维修记录 + if(flag>0){ // 如果创建成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果创建失败 + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("delete") // 映射HTTP GET请求到delete方法 + public Result delete(String ids){ // 接收要删除的记录ID字符串 + int flag = repairService.delete(ids); // 调用服务层删除指定ID的维修记录 + if(flag>0){ // 如果删除成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果删除失败 + return Result.fail(); // 返回失败结果 + } + } + + @PostMapping("update") // 映射HTTP POST请求到update方法 + public Result update(@RequestBody Repair repair){ // 接收一个Repair对象作为请求体 + int flag = repairService.updateSelective(repair); // 调用服务层更新维修记录，只更新非空字段 + if(flag>0){ // 如果更新成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果更新失败 + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("detail") // 映射HTTP GET请求到detail方法 + public Repair detail(Integer id){ // 接收维修记录的ID + return repairService.detail(id); // 调用服务层获取指定ID的维修记录详情并返回 + } + + @PostMapping("query") // 映射HTTP POST请求到query方法 + public Map query(@RequestBody Repair repair){ // 接收一个Repair对象作为查询条件 + PageInfo pageInfo = new PageInfo<>(); // 创建一个分页信息对象 + if(repair.getName() != null){ // 如果查询条件中包含学生姓名 + Student detailId = studentService.detailByName(repair.getName()); // 根据姓名查找学生ID + if(detailId != null){ // 如果找到对应的学生ID + repair.setStudentId(detailId.getId()); // 设置查询条件的studentId属性 + }else{ // 如果没有找到对应的学生ID + pageInfo.setList(null); // 设置分页列表为空 + pageInfo.setSize(0); // 设置分页大小为0 + return Result.ok(pageInfo); // 返回空的查询结果 + } + } + pageInfo = repairService.query(repair); // 调用服务层进行查询操作 + pageInfo.getList().forEach(entity->{ // 遍历查询结果列表 + entity.setBuilding(buildingService.detail(entity.getBuildingId())); // 设置每个维修记录的楼宇信息 + entity.setStudent(studentService.detail(entity.getStudentId())); // 设置每个维修记录的学生信息 + entity.setDormitory(dormitoryService.detail(entity.getDormitoryId())); // 设置每个维修记录的宿舍信息 + }); + return Result.ok(pageInfo); // 返回查询结果 + } +} \ No newline at end of file diff --git a/main/RepairMapper.java b/main/RepairMapper.java new file mode 100644 index 0000000..599c4ec --- /dev/null +++ b/main/RepairMapper.java @@ -0,0 +1,24 @@ +package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包 + +import java.util.List; // 导入Java的List类，用于处理列表数据结构 +import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构 + +import com.yanzhen.entity.Repair; // 导入Repair实体类，用于操作维修记录信息 + +public interface RepairMapper { // 定义RepairMapper接口，提供对Repair实体进行数据库操作的方法 + + public int create(Repair repair); // 创建一个新的Repair记录，返回影响的行数 + + public int delete(Integer id); // 根据id删除一个Repair记录，返回影响的行数 + + public int update(Repair repair); // 更新一个Repair记录，返回影响的行数 + + public int updateSelective(Repair repair); // 选择性地更新一个Repair记录，返回影响的行数 + + public List query(Repair repair); // 根据条件查询Repair记录，返回符合条件的Repair列表 + + public Repair detail(Integer id); // 根据id查询一个Repair记录的详细信息，返回Repair对象 + + public int count(Repair repair); // 根据条件统计Repair记录的数量，返回记录数量 + +} \ No newline at end of file diff --git a/main/RepairService报修管理.java b/main/RepairService报修管理.java new file mode 100644 index 0000000..9b9898a --- /dev/null +++ b/main/RepairService报修管理.java @@ -0,0 +1,123 @@ +package com.yanzhen.service; + +import com.yanzhen.mapper.RepairMapper; +import com.yanzhen.entity.Repair; +import com.github.pagehelper.PageHelper; +import com.github.pagehelper.PageInfo; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.util.StringUtils; + +@Service +public class RepairService报修管理 {// 自动注入RepairMapper接口，用于数据库操作 “报修管理----管理员/宿舍管理员” + + @Autowired + private RepairMapper repairMapper; + + /** + * 创建一个新的维修记录 + * @param repair 包含维修信息的Repair对象 + * @return 返回插入操作的结果，通常是受影响的行数 + */ + public int create(Repair repair) {//创建一个新的维修记录,@param repair 包含维修信息的Repair对象, @return 返回插入操作的结果，通常是受影响的行数 + // 调用repairMapper的create方法将repair对象插入数据库 + return repairMapper.create(repair); + } + + /** + * 删除指定ID的记录 + * @param ids 以逗号分隔的字符串，包含要删除的记录ID + * @return 成功删除的记录数 + */ + public int delete(String ids) {//删除指定ID的记录,@param ids 以逗号分隔的字符串，包含要删除的记录ID, @return 成功删除的记录数 + + // 将传入的ID字符串按逗号分割成数组 + String[] arr = ids.split(","); + // 初始化删除计数器 + int row = 0; + // 遍历ID数组 + for (String s : arr) { + // 如果当前ID不为空 + if(!StringUtils.isEmpty(s)){ + // 调用repairMapper的delete方法删除对应ID的记录 + repairMapper.delete(Integer.parseInt(s)); + // 删除计数器加1 + row++; + } + } + // 返回成功删除的记录数 + return row; + } + + /** + * 删除指定ID的记录 + * @param id 要删除的记录的ID + * @return 返回删除操作的结果，通常是受影响的行数 + */ + public int delete(Integer id) {//删除指定ID的记录,@param id 要删除的记录的ID, @return 返回删除操作的结果，通常是受影响的行数 + + // 调用repairMapper对象的delete方法，传入要删除的记录ID + return repairMapper.delete(id); + } + + /** + * 更新维修记录 + * + * @param repair 需要更新的维修记录对象 + * @return 更新操作影响的行数 + */ + public int update(Repair repair) {//更新维修记录,@param repair 需要更新的维修记录对象, @return 更新操作影响的行数 + + // 调用repairMapper的update方法，将传入的repair对象进行更新操作 + return repairMapper.update(repair); + } + + /** + * 更新维修记录，只更新非空字段 + * @param repair 包含需要更新的维修记录信息的对象 + * @return 返回更新操作影响的行数 + */ + public int updateSelective(Repair repair) {//更新维修记录，只更新非空字段,@param repair 包含需要更新的维修记录信息的对象, @return 返回更新操作影响的行数 + + // 调用repairMapper的updateSelective方法，传入repair对象进行更新操作 + return repairMapper.updateSelective(repair); + } + + /** + * 查询维修记录的方法 + * @param repair 包含查询条件的Repair对象 + * @return 包含查询结果的PageInfo对象 + */ + public PageInfo query(Repair repair) {//查询维修记录的方法,@param repair 包含查询条件的Repair对象, @return 包含查询结果的PageInfo对象 + + // 如果repair对象和其分页信息不为空 + if(repair != null && repair.getPage() != null){ + // 使用PageHelper设置分页参数，开始分页 + PageHelper.startPage(repair.getPage(), repair.getLimit()); + } + // 返回包含查询结果的PageInfo对象 + return new PageInfo(repairMapper.query(repair)); + } + + /** + * 获取指定ID的维修详情 + * @param id 维修记录的唯一标识符 + * @return 返回对应ID的维修详情对象 + */ + public Repair detail(Integer id) {//获取指定ID的维修详情,@param id 维修记录的唯一标识符, @return 返回对应ID的维修详情对象 + + // 调用repairMapper对象的detail方法，根据传入的id获取对应的维修详情 + return repairMapper.detail(id); + } + + /** + * 计算维修记录的数量 + * @param repair 包含查询条件的Repair对象 + * @return 返回符合条件的维修记录数量 + */ + public int count(Repair repair) {//计算维修记录的数量,@param repair 包含查询条件的Repair对象, @return 返回符合条件的维修记录数量 + + // 调用repairMapper的count方法，传入repair对象，返回符合条件的维修记录数量 + return repairMapper.count(repair); + } +} diff --git a/main/Result.java b/main/Result.java new file mode 100644 index 0000000..22c4b7d --- /dev/null +++ b/main/Result.java @@ -0,0 +1,105 @@ +package com.yanzhen.utils; // 定义包名 + +import com.github.pagehelper.PageInfo; // 导入分页信息类 + +import java.util.HashMap; // 导入HashMap类 +import java.util.Map; // 导入Map接口 + +public class Result { // 定义Result类 + + public static final Integer SUCCESS_CODE = 200; // 成功状态码 + public static final Integer TOKEN_ERROR = 400; // 令牌错误状态码 + public static final Integer ERROR_CODE = 500; // 错误状态码 + + private Integer code; // 响应码 + private String msg; // 响应消息 + private Object data = null; // 响应数据，默认为null + + // 根据分页信息创建成功的响应结果 + public static Map ok(PageInfo pageInfo){ + Map map = new HashMap<>(); // 创建HashMap存储响应结果 + map.put("code",SUCCESS_CODE); // 设置响应码为成功 + map.put("msg","查询成功"); // 设置响应消息 + map.put("count",pageInfo.getTotal()); // 设置总记录数 + map.put("data",pageInfo.getList()); // 设置数据列表 + return map; // 返回响应结果 + } + + // 创建自定义状态码、消息和数据的响应结果 + public static Result ok(Integer status,String msg,Object data){ + return new Result(status,msg,data); // 返回新的Result对象 + } + + // 创建自定义消息和数据的响应结果，状态码为成功 + public static Result ok(String msg,Object data){ + return new Result(SUCCESS_CODE,msg,data); // 返回新的Result对象 + } + + // 创建仅包含数据的响应结果，状态码为成功，消息为"操作成功" + public static Result ok(Object data){ + return new Result(SUCCESS_CODE,"操作成功",data); // 返回新的Result对象 + } + + // 创建无数据的成功响应结果，状态码为成功，消息为"操作成功" + public static Result ok(){ + return new Result(SUCCESS_CODE,"操作成功",null); // 返回新的Result对象 + } + + // 创建自定义状态码和消息的失败响应结果 + public static Result fail(Integer status,String msg){ + return new Result(status,msg); // 返回新的Result对象 + } + + // 创建自定义消息的失败响应结果，状态码为错误 + public static Result fail(String msg){ + return new Result(ERROR_CODE,msg); // 返回新的Result对象 + } + + // 创建无消息的失败响应结果，状态码为错误，消息为"操作失败" + public static Result fail(){ + return new Result(ERROR_CODE,"操作失败"); // 返回新的Result对象 + } + + // 构造函数，初始化响应码和消息 + public Result(Integer code, String msg) { + this.code = code; // 设置响应码 + this.msg = msg; // 设置响应消息 + } + + // 构造函数，初始化响应码、消息和数据 + public Result(Integer code, String msg, Object data) { + this.code = code; // 设置响应码 + this.msg = msg; // 设置响应消息 + this.data = data; // 设置响应数据 + } + + // 获取响应码 + public Integer getCode() { + return code; // 返回响应码 + } + + // 设置响应码 + public void setCode(Integer code) { + this.code = code; // 设置响应码 + } + + // 获取响应消息 + public String getMsg() { + return msg; // 返回响应消息 + } + + // 设置响应消息 + public void setMsg(String msg) { + this.msg = msg; // 设置响应消息 + } + + // 获取响应数据 + public Object getData() { + return data; // 返回响应数据 + } + + // 设置响应数据 + public void setData(Object data) { + this.data = data; // 设置响应数据 + } +} \ No newline at end of file diff --git a/main/Selection.java b/main/Selection.java new file mode 100644 index 0000000..da09166 --- /dev/null +++ b/main/Selection.java @@ -0,0 +1,96 @@ +package com.yanzhen.entity; + +import javax.validation.constraints.NotNull; +import org.hibernate.validator.constraints.Length; +import com.yanzhen.utils.Entity; +import java.util.Date; +import java.util.List; + + + +public class Selection extends Entity{// 定义一个名为Selection的类，继承自Entity类 + + + private Integer id; // 定义一个私有的Integer类型的变量id + + + @Length(max = 100) // 定义一个私有的String类型的变量name，并设置其最大长度为100 + private String name; + + + private Date startTime;// 定义一个私有的Date类型的变量startTime + + + private Date endTime;// 定义一个私有的Date类型的变量endTime + + + @Length(max = 100)// 定义一个私有的String类型的变量remark，并设置其最大长度为100 + private String remark; + + + private List clazzIds; // 定义一个私有的List类型的变量clazzIds + + + private List clazzes;// 定义一个私有的List类型的变量clazzes + + + public Integer getId() {// 定义一个公共方法getId，用于获取id的值 + return id; + } + + public void setId(Integer id) { // 定义一个公共方法setId，用于设置id的值 + this.id = id; + } + + public String getName() { // 定义一个公共方法getName，用于获取name的值 + return name; + } + + public void setName(String name) { // 定义一个公共方法setName，用于设置name的值 + this.name = name; + } + + public Date getStartTime() { // 定义一个公共方法getStartTime，用于获取startTime的值 + return startTime; + } + + public void setStartTime(Date startTime) {// 定义一个公共方法setStartTime，用于设置startTime的值 + this.startTime = startTime; + } + + public Date getEndTime() {// 定义一个公共方法getEndTime，用于获取endTime的值 + return endTime; + } + + public void setEndTime(Date endTime) {// 定义一个公共方法setEndTime，用于设置endTime的值 + this.endTime = endTime; + } + + public String getRemark() {// 定义一个公共方法getRemark，用于获取remark的值 + return remark; + } + + public void setRemark(String remark) {// 定义一个公共方法setRemark，用于设置remark的值 + this.remark = remark; + } + + + public List getClazzIds() { // 定义一个公共方法getClazzIds，用于获取clazzIds的值 + return clazzIds; + } + + + public void setClazzIds(List clazzIds) {// 定义一个公共方法setClazzIds，用于设置clazzIds的值 + this.clazzIds = clazzIds; + } + + + public List getClazzes() { // 定义一个公共方法getClazzes，用于获取clazzes的值 + return clazzes; + } + + + public void setClazzes(List clazzes) {// 定义一个公共方法setClazzes，用于设置clazzes的值 + this.clazzes = clazzes; + } +} \ No newline at end of file diff --git a/main/SelectionController.java b/main/SelectionController.java new file mode 100644 index 0000000..11fbfde --- /dev/null +++ b/main/SelectionController.java @@ -0,0 +1,71 @@ +package com.yanzhen.controller; + +import com.github.pagehelper.PageInfo; +import com.yanzhen.entity.Org; +import com.yanzhen.entity.Selection; +import com.yanzhen.service.OrgService机构管理; +import com.yanzhen.service.SelectionJoinerService用户id筛选增删查改数据库; +import com.yanzhen.service.SelectionService学生查询管理; +import com.yanzhen.utils.Result; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +import java.util.List; +import java.util.Map; + +@RestController // 声明这是一个RESTful控制器，返回的数据直接写入HTTP响应体中 +@RequestMapping("/selection") // 设置请求路径的映射前缀为/selection +public class SelectionController { // 定义一个名为SelectionController的类 + + @Autowired // 自动注入SelectionService实例 + private SelectionService学生查询管理 selectionService; + @Autowired // 自动注入SelectionJoinerService实例 + private SelectionJoinerService用户id筛选增删查改数据库 selectionJoinerService; + @Autowired // 自动注入OrgService实例 + private OrgService机构管理 orgService; + + @PostMapping("create") // 映射HTTP POST请求到create方法 + public Result create(@RequestBody Selection selection){ // 接收JSON格式的Selection对象作为请求体 + int flag = selectionService.create(selection); // 调用selectionService的create方法创建记录 + if(flag>0){ // 如果创建成功 + return Result.ok(); // 返回操作成功的Result对象 + }else{ // 如果创建失败 + return Result.fail(); // 返回操作失败的Result对象 + } + } + + @GetMapping("delete") // 映射HTTP GET请求到delete方法 + public Result delete(String ids){ // 接收要删除的记录ID字符串 + int flag = selectionService.delete(ids); // 调用selectionService的delete方法删除记录 + if(flag>0){ // 如果删除成功 + return Result.ok(); // 返回操作成功的Result对象 + }else{ // 如果删除失败 + return Result.fail(); // 返回操作失败的Result对象 + } + } + + @PostMapping("update") // 映射HTTP POST请求到update方法 + public Result update(@RequestBody Selection selection){ // 接收JSON格式的Selection对象作为请求体 + int flag = selectionService.update(selection); // 调用selectionService的update方法更新记录 + if(flag>0){ // 如果更新成功 + return Result.ok(); // 返回操作成功的Result对象 + }else{ // 如果更新失败 + return Result.fail(); // 返回操作失败的Result对象 + } + } + + @GetMapping("detail") // 映射HTTP GET请求到detail方法 + public Selection detail(Integer id){ // 接收记录的ID作为参数 + return selectionService.detail(id); // 调用selectionService的detail方法获取详细信息并返回 + } + + @PostMapping("query") // 映射HTTP POST请求到query方法 + public Map query(@RequestBody Selection selection){ // 接收JSON格式的Selection对象作为请求体 + PageInfo pageInfo = selectionService.query(selection); // 调用selectionService的query方法查询记录 + pageInfo.getList().forEach(item->{ // 遍历查询结果列表 + List clazzes = orgService.queryOrgBySelectionId(item.getId()); // 根据选择ID查询关联的组织信息 + item.setClazzes(clazzes); // 将组织信息设置到选择项中 + }); + return Result.ok(pageInfo); // 返回包含分页信息的Result对象 + } +} \ No newline at end of file diff --git a/main/SelectionDormitory.java b/main/SelectionDormitory.java new file mode 100644 index 0000000..f59f5bd --- /dev/null +++ b/main/SelectionDormitory.java @@ -0,0 +1,46 @@ +package com.yanzhen.entity; // 定义包名，表示该类属于com.yanzhen.entity包 + +import javax.validation.constraints.NotNull; // 导入NotNull注解，用于字段验证 +import org.hibernate.validator.constraints.Length; // 导入Length注解，用于字符串长度验证 +import com.yanzhen.utils.Entity; // 导入Entity类，SelectionDormitory类继承自Entity类 +import java.util.Date; // 导入Date类，用于日期处理 + + + + +public class SelectionDormitory extends Entity{// 定义一个名为SelectionDormitory的类，继承自Entity类 + + + private Integer id;// 定义一个私有的Integer类型的变量id + + + private Integer dormitoryId;// 定义一个私有的Integer类型的变量dormitoryId + + + private Integer clazzId;// 定义一个私有的Integer类型的变量clazzId + + + public Integer getId() {// 定义一个公共方法getId，用于获取id的值 + return id; + } + + public void setId(Integer id) {// 定义一个公共方法setId，用于设置id的值 + this.id = id; + } + + public Integer getDormitoryId() {// 定义一个公共方法getDormitoryId，用于获取dormitoryId的值 + return dormitoryId; + } + + public void setDormitoryId(Integer dormitoryId) {// 定义一个公共方法setDormitoryId，用于设置dormitoryId的值 + this.dormitoryId = dormitoryId; + } + + public Integer getClazzId() {// 定义一个公共方法getClazzId，用于获取clazzId的值 + return clazzId; + } + + public void setClazzId(Integer clazzId) {// 定义一个公共方法setClazzId，用于设置clazzId的值 + this.clazzId = clazzId; + } +} \ No newline at end of file diff --git a/main/SelectionDormitoryController.java b/main/SelectionDormitoryController.java new file mode 100644 index 0000000..7690b1e --- /dev/null +++ b/main/SelectionDormitoryController.java @@ -0,0 +1,63 @@ +package com.yanzhen.controller; + +import com.github.pagehelper.PageInfo; +import com.yanzhen.entity.SelectionDormitory; +import com.yanzhen.service.SelectionDormitoryService宿舍管理; +import com.yanzhen.utils.Result; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +import java.util.Map; + +@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中，而不是解析为跳转路径。 +@RequestMapping("/selectionDormitory") // 设置请求的根路径为 "/selectionDormitory" +public class SelectionDormitoryController { + + @Autowired // 自动注入 SelectionDormitoryService 对象 + private SelectionDormitoryService宿舍管理 selectionDormitoryService; + + @PostMapping("create") // 映射 HTTP POST 请求到 create 方法 + public Result create(@RequestBody Map map){ // 从请求体中获取 JSON 数据并转换为 Map + //clazzId,dormitoryIds + String clazzId = map.get("clazzId"); // 从 Map 中获取班级ID + String dormitoryIds = map.get("dormitoryIds"); // 从 Map 中获取宿舍ID列表 + int flag = selectionDormitoryService.create(clazzId,dormitoryIds); // 调用服务层的创建方法 + if(flag>0){ // 如果创建成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果创建失败 + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("delete") // 映射 HTTP GET 请求到 delete 方法 + public Result delete(String ids){ // 从请求参数中获取要删除的记录ID + int flag = selectionDormitoryService.delete(ids); // 调用服务层的删除方法 + if(flag>0){ // 如果删除成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果删除失败 + return Result.fail(); // 返回失败结果 + } + } + + @PostMapping("update") // 映射 HTTP POST 请求到 update 方法 + public Result update(@RequestBody SelectionDormitory selectionDormitory){ // 从请求体中获取 JSON 数据并转换为 SelectionDormitory 对象 + int flag = selectionDormitoryService.update(selectionDormitory); // 调用服务层的更新方法 + if(flag>0){ // 如果更新成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果更新失败 + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("detail") // 映射 HTTP GET 请求到 detail 方法 + public SelectionDormitory detail(Integer id){ // 从请求参数中获取记录ID + return selectionDormitoryService.detail(id); // 调用服务层的详情查询方法并返回结果 + } + + @PostMapping("query") // 映射 HTTP POST 请求到 query 方法 + public Map query(@RequestBody SelectionDormitory selectionDormitory){ // 从请求体中获取 JSON 数据并转换为 SelectionDormitory 对象 + PageInfo pageInfo = selectionDormitoryService.query(selectionDormitory); // 调用服务层的查询方法并获取分页信息 + return Result.ok(pageInfo); // 返回包含分页信息的查询结果 + } + +} \ No newline at end of file diff --git a/main/SelectionDormitoryMapper.java b/main/SelectionDormitoryMapper.java new file mode 100644 index 0000000..a251436 --- /dev/null +++ b/main/SelectionDormitoryMapper.java @@ -0,0 +1,25 @@ +package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包 + +import java.util.List; // 导入Java的List类，用于处理列表数据结构 +import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构 + +import com.yanzhen.entity.SelectionDormitory; // 导入SelectionDormitory实体类，用于操作宿舍选择信息 + +public interface SelectionDormitoryMapper { // 定义SelectionDormitoryMapper接口，提供对SelectionDormitory实体进行数据库操作的方法 + + public int create(SelectionDormitory selectionDormitory); // 创建一个新的SelectionDormitory记录，返回影响的行数 + + public int delete(Integer id); // 根据id删除一个SelectionDormitory记录，返回影响的行数 + + public int deleteByClazzId(Integer clazzId); // 根据clazzId删除SelectionDormitory记录，返回影响的行数 + + public int update(SelectionDormitory selectionDormitory); // 更新一个SelectionDormitory记录，返回影响的行数 + + public int updateSelective(SelectionDormitory selectionDormitory); // 选择性地更新一个SelectionDormitory记录，返回影响的行数 + + public List query(SelectionDormitory selectionDormitory); // 根据条件查询SelectionDormitory记录，返回符合条件的SelectionDormitory列表 + + public SelectionDormitory detail(Integer id); // 根据id查询一个SelectionDormitory记录的详细信息，返回SelectionDormitory对象 + + public int count(SelectionDormitory selectionDormitory); // 根据条件统计SelectionDormitory记录的数量，返回记录数量 +} \ No newline at end of file diff --git a/main/SelectionDormitoryService宿舍管理.java b/main/SelectionDormitoryService宿舍管理.java new file mode 100644 index 0000000..4e870da --- /dev/null +++ b/main/SelectionDormitoryService宿舍管理.java @@ -0,0 +1,77 @@ +package com.yanzhen.service; // 定义包名 + +import com.yanzhen.mapper.SelectionDormitoryMapper; // 导入SelectionDormitoryMapper类 +import com.yanzhen.entity.SelectionDormitory; // 导入SelectionDormitory实体类 +import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类 +import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类 +import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的@Autowired注解 +import org.springframework.stereotype.Service; // 导入Spring的@Service注解 +import org.springframework.util.StringUtils; // 导入Spring的StringUtils工具类 + +@Service // 标记该类为Spring的服务层组件 +public class SelectionDormitoryService宿舍管理 {// “宿舍管理----管理员/宿管员” + + @Autowired // 自动注入SelectionDormitoryMapper依赖 + private SelectionDormitoryMapper selectionDormitoryMapper; + + // 创建选择宿舍记录的方法 + public int create(String clazzId, String dormitoryIds) { + String[] arr = dormitoryIds.split(","); // 将宿舍ID字符串按逗号分割成数组 + selectionDormitoryMapper.deleteByClazzId(Integer.parseInt(clazzId)); // 根据班级ID删除已有的选择记录 + for (String s : arr) { // 遍历宿舍ID数组 + if (!StringUtils.isEmpty(s)) { // 如果宿舍ID不为空 + SelectionDormitory selectionDormitory = new SelectionDormitory(); // 创建新的选择宿舍对象 + selectionDormitory.setClazzId(Integer.parseInt(clazzId)); // 设置班级ID + selectionDormitory.setDormitoryId(Integer.parseInt(s)); // 设置宿舍ID + selectionDormitoryMapper.create(selectionDormitory); // 插入新的选择宿舍记录 + } + } + return 1; // 返回操作成功标志 + } + + // 批量删除选择宿舍记录的方法 + public int delete(String ids) { + String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组 + int row = 0; // 初始化受影响行数计数器 + for (String s : arr) { // 遍历ID数组 + if (!StringUtils.isEmpty(s)) { // 如果ID不为空 + selectionDormitoryMapper.delete(Integer.parseInt(s)); // 删除对应的选择宿舍记录 + row++; // 增加受影响行数计数器 + } + } + return row; // 返回受影响行数 + } + + // 根据ID删除选择宿舍记录的方法 + public int delete(Integer id) { + return selectionDormitoryMapper.delete(id); // 调用Mapper方法删除记录并返回结果 + } + + // 更新选择宿舍记录的方法 + public int update(SelectionDormitory selectionDormitory) { + return selectionDormitoryMapper.update(selectionDormitory); // 调用Mapper方法更新记录并返回结果 + } + + // 选择性更新选择宿舍记录的方法 + public int updateSelective(SelectionDormitory selectionDormitory) { + return selectionDormitoryMapper.updateSelective(selectionDormitory); // 调用Mapper方法选择性更新记录并返回结果 + } + + // 查询选择宿舍记录的方法，支持分页 + public PageInfo query(SelectionDormitory selectionDormitory) { + if (selectionDormitory != null && selectionDormitory.getPage() != null) { // 如果查询条件和分页信息不为空 + PageHelper.startPage(selectionDormitory.getPage(), selectionDormitory.getLimit()); // 启动分页 + } + return new PageInfo(selectionDormitoryMapper.query(selectionDormitory)); // 执行查询并返回分页信息 + } + + // 根据ID查询选择宿舍详情的方法 + public SelectionDormitory detail(Integer id) { + return selectionDormitoryMapper.detail(id); // 调用Mapper方法查询详情并返回结果 + } + + // 统计选择宿舍记录数量的方法 + public int count(SelectionDormitory selectionDormitory) { + return selectionDormitoryMapper.count(selectionDormitory); // 调用Mapper方法统计记录数量并返回结果 + } +} \ No newline at end of file diff --git a/main/SelectionJoiner.java b/main/SelectionJoiner.java new file mode 100644 index 0000000..c1471ad --- /dev/null +++ b/main/SelectionJoiner.java @@ -0,0 +1,40 @@ +package com.yanzhen.entity; + +import javax.validation.constraints.NotNull; +import org.hibernate.validator.constraints.Length; +import com.yanzhen.utils.Entity; +import java.util.Date; + + +public class SelectionJoiner extends Entity{// 定义一个名为SelectionJoiner的类，继承自Entity类 + + private Integer id;// 定义一个私有的Integer类型的变量id + + private Integer selectionId;// 定义一个私有的Integer类型的变量selectionId + + private Integer clazzId;// 定义一个私有的Integer类型的变量clazzId + + public Integer getId() {// 定义一个公共方法getId，用于获取id的值 + return id; + } + + public void setId(Integer id) {// 定义一个公共方法setId，用于设置id的值 + this.id = id; + } + + public Integer getSelectionId() {// 定义一个公共方法getSelectionId，用于获取selectionId的值 + return selectionId; + } + + public void setSelectionId(Integer selectionId) {// 定义一个公共方法setSelectionId，用于设置selectionId的值 + this.selectionId = selectionId; + } + + public Integer getClazzId() {// 定义一个公共方法getClazzId，用于获取clazzId的值 + return clazzId; + } + + public void setClazzId(Integer clazzId) {// 定义一个公共方法setClazzId，用于设置clazzId的值 + this.clazzId = clazzId; + } +} \ No newline at end of file diff --git a/main/SelectionJoinerController.java b/main/SelectionJoinerController.java new file mode 100644 index 0000000..6db91b7 --- /dev/null +++ b/main/SelectionJoinerController.java @@ -0,0 +1,60 @@ +package com.yanzhen.controller; + +import com.github.pagehelper.PageInfo; +import com.yanzhen.entity.SelectionJoiner; +import com.yanzhen.service.SelectionJoinerService用户id筛选增删查改数据库; +import com.yanzhen.utils.Result; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +import java.util.Map; + +@RestController // 声明这是一个RESTful控制器，返回的数据直接写入HTTP响应体中 +@RequestMapping("/selectionJoiner") // 设置请求路径的映射前缀为/selectionJoiner +public class SelectionJoinerController { + + @Autowired // 自动注入SelectionJoinerService实例 + private SelectionJoinerService用户id筛选增删查改数据库 selectionJoinerService; + + @PostMapping("create") // 映射HTTP POST请求到create方法 + public Result create(@RequestBody SelectionJoiner selectionJoiner){ // 从请求体中获取SelectionJoiner对象 + int flag = selectionJoinerService.create(selectionJoiner); // 调用服务层的create方法创建记录 + if(flag>0){ // 如果创建成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果创建失败 + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("delete") // 映射HTTP GET请求到delete方法 + public Result delete(String ids){ // 从请求参数中获取要删除的记录ID + int flag = selectionJoinerService.delete(ids); // 调用服务层的delete方法删除记录 + if(flag>0){ // 如果删除成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果删除失败 + return Result.fail(); // 返回失败结果 + } + } + + @PostMapping("update") // 映射HTTP POST请求到update方法 + public Result update(@RequestBody SelectionJoiner selectionJoiner){ // 从请求体中获取SelectionJoiner对象 + int flag = selectionJoinerService.update(selectionJoiner); // 调用服务层的update方法更新记录 + if(flag>0){ // 如果更新成功 + return Result.ok(); // 返回成功结果 + }else{ // 如果更新失败 + return Result.fail(); // 返回失败结果 + } + } + + @GetMapping("detail") // 映射HTTP GET请求到detail方法 + public SelectionJoiner detail(Integer id){ // 从请求参数中获取记录ID + return selectionJoinerService.detail(id); // 调用服务层的detail方法获取记录详情并返回 + } + + @PostMapping("query") // 映射HTTP POST请求到query方法 + public Map query(@RequestBody SelectionJoiner selectionJoiner){ // 从请求体中获取SelectionJoiner对象作为查询条件 + PageInfo pageInfo = selectionJoinerService.query(selectionJoiner); // 调用服务层的query方法进行分页查询 + return Result.ok(pageInfo); // 返回包含查询结果的成功结果 + } + +} diff --git a/main/SelectionJoinerMapper.java b/main/SelectionJoinerMapper.java new file mode 100644 index 0000000..980a502 --- /dev/null +++ b/main/SelectionJoinerMapper.java @@ -0,0 +1,25 @@ +package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包 + +import java.util.List; // 导入Java的List类，用于处理列表数据结构 +import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构 + +import com.yanzhen.entity.SelectionJoiner; // 导入SelectionJoiner实体类，用于操作宿舍层信息 + +public interface SelectionJoinerMapper { // 定义SelectionJoinerMapper接口，提供对SelectionJoiner实体进行数据库操作的方法 + + public int create(SelectionJoiner selectionJoiner); // 创建一个新的SelectionJoiner记录，返回影响的行数 + + public int delete(Integer id); // 根据id删除一个SelectionJoiner记录，返回影响的行数 + + public int deleteBySelectionId(Integer selectionId); // 根据selectionId删除SelectionJoiner记录，返回影响的行数 + + public int update(SelectionJoiner selectionJoiner); // 更新一个SelectionJoiner记录，返回影响的行数 + + public int updateSelective(SelectionJoiner selectionJoiner); // 选择性地更新一个SelectionJoiner记录，返回影响的行数 + + public List query(SelectionJoiner selectionJoiner); // 根据条件查询SelectionJoiner记录，返回符合条件的SelectionJoiner列表 + + public SelectionJoiner detail(Integer id); // 根据id查询一个SelectionJoiner记录的详细信息，返回SelectionJoiner对象 + + public int count(SelectionJoiner selectionJoiner); // 根据条件统计SelectionJoiner记录的数量，返回记录数量 +} \ No newline at end of file diff --git a/main/SelectionJoinerService用户id筛选增删查改数据库.java b/main/SelectionJoinerService用户id筛选增删查改数据库.java new file mode 100644 index 0000000..c558600 --- /dev/null +++ b/main/SelectionJoinerService用户id筛选增删查改数据库.java @@ -0,0 +1,59 @@ +package com.yanzhen.service; // 定义包名 + +import com.yanzhen.mapper.SelectionJoinerMapper; // 导入SelectionJoinerMapper接口 +import com.yanzhen.entity.SelectionJoiner; // 导入SelectionJoiner实体类 +import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类 +import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类 +import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解 +import org.springframework.stereotype.Service; // 导入Spring的服务层注解 +import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作 + +@Service // 标注该类为服务层组件 +public class SelectionJoinerService用户id筛选增删查改数据库 { // 定义SelectionJoinerService类 “筛选用户id----管理员” + + @Autowired // 自动装配SelectionJoinerMapper对象 + private SelectionJoinerMapper selectionJoinerMapper; + + public int create(SelectionJoiner selectionJoiner) { // 创建SelectionJoiner记录的方法 + return selectionJoinerMapper.create(selectionJoiner); // 调用Mapper层的create方法 + } + + public int delete(String ids) { // 根据ID字符串批量删除SelectionJoiner记录的方法 + String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组 + int row = 0; // 初始化受影响行数为0 + for (String s : arr) { // 遍历ID数组 + if(!StringUtils.isEmpty(s)){ // 如果ID不为空 + selectionJoinerMapper.delete(Integer.parseInt(s)); // 调用Mapper层的delete方法删除记录 + row++; // 受影响行数加1 + } + } + return row; // 返回受影响行数 + } + + public int delete(Integer id) { // 根据ID删除SelectionJoiner记录的方法 + return selectionJoinerMapper.delete(id); // 调用Mapper层的delete方法 + } + + public int update(SelectionJoiner selectionJoiner) { // 更新SelectionJoiner记录的方法 + return selectionJoinerMapper.update(selectionJoiner); // 调用Mapper层的update方法 + } + + public int updateSelective(SelectionJoiner selectionJoiner) { // 选择性更新SelectionJoiner记录的方法 + return selectionJoinerMapper.updateSelective(selectionJoiner); // 调用Mapper层的updateSelective方法 + } + + public PageInfo query(SelectionJoiner selectionJoiner) { // 查询SelectionJoiner记录列表的方法 + if(selectionJoiner != null && selectionJoiner.getPage() != null){ // 如果查询条件和分页信息不为空 + PageHelper.startPage(selectionJoiner.getPage(),selectionJoiner.getLimit()); // 启动分页并设置分页参数 + } + return new PageInfo(selectionJoinerMapper.query(selectionJoiner)); // 调用Mapper层的query方法并封装成PageInfo对象返回 + } + + public SelectionJoiner detail(Integer id) { // 根据ID获取SelectionJoiner详情的方法 + return selectionJoinerMapper.detail(id); // 调用Mapper层的detail方法 + } + + public int count(SelectionJoiner selectionJoiner) { // 统计SelectionJoiner记录数量的方法 + return selectionJoinerMapper.count(selectionJoiner); // 调用Mapper层的count方法 + } +} \ No newline at end of file diff --git a/main/SelectionMapper.java b/main/SelectionMapper.java new file mode 100644 index 0000000..849b839 --- /dev/null +++ b/main/SelectionMapper.java @@ -0,0 +1,26 @@ +package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包 + +import java.util.List; // 导入Java的List类，用于处理列表数据结构 +import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构 + +import com.yanzhen.entity.Selection; // 导入Selection实体类，用于操作选择信息 + +public interface SelectionMapper { // 定义SelectionMapper接口，提供对Selection实体进行数据库操作的方法 + + public int create(Selection selection); // 创建一个新的Selection记录，返回影响的行数 + + public int delete(Integer id); // 根据id删除一个Selection记录，返回影响的行数 + + public int update(Selection selection); // 更新一个Selection记录，返回影响的行数 + + public int updateSelective(Selection selection); // 选择性地更新一个Selection记录，返回影响的行数 + + public List query(Selection selection); // 根据条件查询Selection记录，返回符合条件的Selection列表 + + public List queryByClazzId(Integer clazzId); // 根据clazzId查询Selection记录，返回符合条件的Selection列表 + + public Selection detail(Integer id); // 根据id查询一个Selection记录的详细信息，返回Selection对象 + + public int count(Selection selection); // 根据条件统计Selection记录的数量，返回记录数量 + +} \ No newline at end of file diff --git a/main/SelectionService学生查询管理.java b/main/SelectionService学生查询管理.java new file mode 100644 index 0000000..c7c15cc --- /dev/null +++ b/main/SelectionService学生查询管理.java @@ -0,0 +1,110 @@ +package com.yanzhen.service; + +import com.yanzhen.entity.Org; +import com.yanzhen.entity.SelectionJoiner; +import com.yanzhen.mapper.SelectionJoinerMapper; +import com.yanzhen.mapper.SelectionMapper; +import com.yanzhen.entity.Selection; +import com.github.pagehelper.PageHelper; +import com.github.pagehelper.PageInfo; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; +import org.springframework.util.StringUtils; + +import java.util.ArrayList; +import java.util.List; + +@Service // 标记该类为Spring的服务组件 +public class SelectionService学生查询管理 {// “学生管理----管理员” + + @Autowired // 自动注入SelectionMapper依赖 + private SelectionMapper selectionMapper; + @Autowired // 自动注入OrgService依赖 + private OrgService机构管理 orgService; + + @Autowired // 自动注入SelectionJoinerMapper依赖 + private SelectionJoinerMapper selectionJoinerMapper; + + @Transactional // 声明该方法需要事务管理 + public int create(Selection selection) { + selectionMapper.create(selection); // 创建新的Selection记录 + List clazzIds = selection.getClazzIds(); // 获取班级ID列表 + //筛选出对应的班级 + List selectIds = new ArrayList(); // 初始化选择的班级ID列表 + clazzIds.forEach(item->{ // 遍历班级ID列表 + Org detail = orgService.detail(item); // 获取班级详细信息 + if(detail.getType() == 4){ // 如果班级类型为4 + selectIds.add(detail.getId()); // 将班级ID添加到选择的班级ID列表中 + } + }); + selectIds.forEach(item->{ // 遍历选择的班级ID列表 + SelectionJoiner joiner = new SelectionJoiner(); // 创建新的SelectionJoiner对象 + joiner.setClazzId(item); // 设置班级ID + joiner.setSelectionId(selection.getId()); // 设置Selection ID + selectionJoinerMapper.create(joiner); // 创建新的SelectionJoiner记录 + }); + return 1; // 返回操作成功标志 + } + + public int delete(String ids) { + String[] arr = ids.split(","); // 将传入的ID字符串按逗号分割成数组 + int row = 0; // 初始化删除计数器 + for (String s : arr) { // 遍历ID数组 + if(!StringUtils.isEmpty(s)){ // 如果ID不为空 + selectionMapper.delete(Integer.parseInt(s)); // 根据ID删除Selection记录 + row++; // 删除计数器加一 + } + } + return row; // 返回删除的记录数 + } + + public int delete(Integer id) { + return selectionMapper.delete(id); // 根据ID删除Selection记录并返回操作结果 + } + + public int update(Selection selection) { + selectionMapper.update(selection); // 更新Selection记录 + //先删除已设置的信息 + selectionJoinerMapper.deleteBySelectionId(selection.getId()); // 根据Selection ID删除所有相关的SelectionJoiner记录 + List clazzIds = selection.getClazzIds(); // 获取班级ID列表 + //筛选出对应的班级 + List selectIds = new ArrayList(); // 初始化选择的班级ID列表 + clazzIds.forEach(item->{ // 遍历班级ID列表 + Org detail = orgService.detail(item); // 获取班级详细信息 + if(detail.getType() == 4){ // 如果班级类型为4 + selectIds.add(detail.getId()); // 将班级ID添加到选择的班级ID列表中 + } + }); + selectIds.forEach(item->{ // 遍历选择的班级ID列表 + SelectionJoiner joiner = new SelectionJoiner(); // 创建新的SelectionJoiner对象 + joiner.setClazzId(item); // 设置班级ID + joiner.setSelectionId(selection.getId()); // 设置Selection ID + selectionJoinerMapper.create(joiner); // 创建新的SelectionJoiner记录 + }); + return 1; // 返回操作成功标志 + } + + public int updateSelective(Selection selection) { + return selectionMapper.updateSelective(selection); // 选择性更新Selection记录并返回操作结果 + } + + public PageInfo query(Selection selection) { + if(selection != null && selection.getPage() != null){ // 如果Selection对象和分页信息不为空 + PageHelper.startPage(selection.getPage(),selection.getLimit()); // 启动分页查询 + } + return new PageInfo(selectionMapper.query(selection)); // 执行查询并返回分页结果 + } + + public List queryByClazzId(Integer clazzId){ + return selectionMapper.queryByClazzId(clazzId); // 根据班级ID查询Selection记录并返回结果列表 + } + + public Selection detail(Integer id) { + return selectionMapper.detail(id); // 根据ID查询Selection详情并返回结果 + } + + public int count(Selection selection) { + return selectionMapper.count(selection); // 统计符合条件的Selection记录数并返回结果 + } +} \ No newline at end of file diff --git a/main/Storey.java b/main/Storey.java new file mode 100644 index 0000000..39e1b2d --- /dev/null +++ b/main/Storey.java @@ -0,0 +1,59 @@ +package com.yanzhen.entity; + +import javax.validation.constraints.NotNull; +import org.hibernate.validator.constraints.Length; +import com.yanzhen.utils.Entity; +import java.util.Date; + + +public class Storey extends Entity{// 定义一个名为Storey的类，继承自Entity类 + + + private Integer id;// 定义一个私有的Integer类型的变量id，用于存储楼层的唯一标识符 + + + @Length(max = 100)// 使用@Length注解限制name字段的最大长度为100个字符 + + private String name;// 定义一个私有的String类型的变量name，用于存储楼层的名称 + + + private Integer buildingId;// 定义一个私有的Integer类型的变量buildingId，用于存储所属建筑的ID + + + @Length(max = 200)// 使用@Length注解限制remark字段的最大长度为200个字符 + + private String remark;// 定义一个私有的String类型的变量remark，用于存储楼层的备注信息 + + + public Integer getId() {// 定义一个公共方法getId，用于获取楼层的唯一标识符 + return id; + } + + public void setId(Integer id) {// 定义一个公共方法setId，用于设置楼层的唯一标识符 + this.id = id; + } + + public String getName() {// 定义一个公共方法getName，用于获取楼层的名称 + return name; + } + + public void setName(String name) {// 定义一个公共方法setName，用于设置楼层的名称 + this.name = name; + } + + public Integer getBuildingId() {// 定义一个公共方法getBuildingId，用于获取所属建筑的ID + return buildingId; + } + + public void setBuildingId(Integer buildingId) {// 定义一个公共方法setBuildingId，用于设置所属建筑的ID + this.buildingId = buildingId; + } + + public String getRemark() {// 定义一个公共方法getRemark，用于获取楼层的备注信息 + return remark; + } + + public void setRemark(String remark) {// 定义一个公共方法setRemark，用于设置楼层的备注信息 + this.remark = remark; + } +} \ No newline at end of file diff --git a/main/StoreyController.java b/main/StoreyController.java new file mode 100644 index 0000000..629527b --- /dev/null +++ b/main/StoreyController.java @@ -0,0 +1,60 @@ +package com.yanzhen.controller; + +import com.github.pagehelper.PageInfo; +import com.yanzhen.entity.Storey; +import com.yanzhen.service.StoreyService楼宇管理; +import com.yanzhen.utils.Result; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +import java.util.Map; + +@RestController // 声明这是一个RESTful控制器，返回的数据直接写入HTTP响应体中 +@RequestMapping("/storey") // 设置请求路径前缀为/storey +public class StoreyController { + + @Autowired // 自动注入StoreyService对象 + private StoreyService楼宇管理 storeyService; + + @PostMapping("create") // 映射HTTP POST请求到create方法 + public Result create(@RequestBody Storey storey){ // @RequestBody注解用于将请求体中的JSON转换为Storey对象 + int flag = storeyService.create(storey); // 调用storeyService的create方法创建记录 + if(flag>0){ // 如果创建成功，返回成功的Result对象 + return Result.ok(); + }else{ // 如果创建失败，返回失败的Result对象 + return Result.fail(); + } + } + + @GetMapping("delete") // 映射HTTP GET请求到delete方法 + public Result delete(String ids){ // 接收要删除的记录ID字符串 + int flag = storeyService.delete(ids); // 调用storeyService的delete方法删除记录 + if(flag>0){ // 如果删除成功，返回成功的Result对象 + return Result.ok(); + }else{ // 如果删除失败，返回失败的Result对象 + return Result.fail(); + } + } + + @PostMapping("update") // 映射HTTP POST请求到update方法 + public Result update(@RequestBody Storey storey){ // @RequestBody注解用于将请求体中的JSON转换为Storey对象 + int flag = storeyService.update(storey); // 调用storeyService的update方法更新记录 + if(flag>0){ // 如果更新成功，返回成功的Result对象 + return Result.ok(); + }else{ // 如果更新失败，返回失败的Result对象 + return Result.fail(); + } + } + + @GetMapping("detail") // 映射HTTP GET请求到detail方法 + public Storey detail(Integer id){ // 接收要查询的记录ID + return storeyService.detail(id); // 调用storeyService的detail方法获取记录详情并返回 + } + + @PostMapping("query") // 映射HTTP POST请求到query方法 + public Map query(@RequestBody Storey storey){ // @RequestBody注解用于将请求体中的JSON转换为Storey对象 + PageInfo pageInfo = storeyService.query(storey); // 调用storeyService的query方法查询记录，返回分页信息 + return Result.ok(pageInfo); // 返回包含分页信息的成功的Result对象 + } + +} \ No newline at end of file diff --git a/main/StoreyMapper.java b/main/StoreyMapper.java new file mode 100644 index 0000000..c6e0a19 --- /dev/null +++ b/main/StoreyMapper.java @@ -0,0 +1,23 @@ +package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包 + +import java.util.List; // 导入Java的List类，用于处理列表数据结构 +import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构 + +import com.yanzhen.entity.Storey; // 导入Storey实体类，用于操作宿舍层信息 + +public interface StoreyMapper { // 定义StoreyMapper接口，提供对Storey实体进行数据库操作的方法 + + public int create(Storey storey); // 创建一个新的Storey记录，返回影响的行数 + + public int delete(Integer id); // 根据id删除一个Storey记录，返回影响的行数 + + public int update(Storey storey); // 更新一个Storey记录，返回影响的行数 + + public int updateSelective(Storey storey); // 选择性地更新一个Storey记录，返回影响的行数 + + public List query(Storey storey); // 根据条件查询Storey记录，返回符合条件的Storey列表 + + public Storey detail(Integer id); // 根据id查询一个Storey记录的详细信息，返回Storey对象 + + public int count(Storey storey); // 根据条件统计Storey记录的数量，返回记录数量 +} \ No newline at end of file diff --git a/main/StoreyService楼宇管理.java b/main/StoreyService楼宇管理.java new file mode 100644 index 0000000..fa6dfac --- /dev/null +++ b/main/StoreyService楼宇管理.java @@ -0,0 +1,59 @@ +package com.yanzhen.service; // 定义包名 + +import com.yanzhen.mapper.StoreyMapper; // 导入StoreyMapper接口 +import com.yanzhen.entity.Storey; // 导入Storey实体类 +import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类 +import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类 +import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解 +import org.springframework.stereotype.Service; // 导入Spring的服务层注解 +import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作 + +@Service // 标注该类为服务层组件 +public class StoreyService楼宇管理 { // 定义StoreyService类 “楼宇管理----管理员” + + @Autowired // 自动装配StoreyMapper对象 + private StoreyMapper storeyMapper; + + public int create(Storey storey) { // 创建Storey记录的方法，要创建的楼层记录对象 + return storeyMapper.create(storey); // 调用Mapper层的create方法 + } + + public int delete(String ids) { // 根据ID字符串批量删除Storey记录的方法； 统计成功删除的楼宇记录 + String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组 + int row = 0; // 初始化受影响行数为0 + for (String s : arr) { // 遍历ID数组 + if(!StringUtils.isEmpty(s)){ // 如果ID不为空 + storeyMapper.delete(Integer.parseInt(s)); // 调用Mapper层的delete方法删除记录 + row++; // 受影响行数加1 + } + } + return row; // 返回受影响行数 + } + + public int delete(Integer id) { // 根据ID删除Storey记录的方法 + return storeyMapper.delete(id); // 调用Mapper层的delete方法 + } + + public int update(Storey storey) { // 更新Storey记录的方法 + return storeyMapper.update(storey); // 调用Mapper层的update方法 + } + + public int updateSelective(Storey storey) { // 选择性更新Storey记录的方法 + return storeyMapper.updateSelective(storey); // 调用Mapper层的updateSelective方法 + } + + public PageInfo query(Storey storey) { // 查询Storey记录列表的方法 + if(storey != null && storey.getPage() != null){ // 如果查询条件和分页信息不为空 + PageHelper.startPage(storey.getPage(),storey.getLimit()); // 启动分页并设置分页参数 + } + return new PageInfo(storeyMapper.query(storey)); // 调用Mapper层的query方法并封装成PageInfo对象返回 + } + + public Storey detail(Integer id) { // 根据ID获取Storey详情的方法 + return storeyMapper.detail(id); // 调用Mapper层的detail方法 + } + + public int count(Storey storey) { // 统计Storey记录数量的方法 + return storeyMapper.count(storey); // 调用Mapper层的count方法 + } +} \ No newline at end of file diff --git a/main/StuController.java b/main/StuController.java new file mode 100644 index 0000000..d50f8bd --- /dev/null +++ b/main/StuController.java @@ -0,0 +1,179 @@ +package com.yanzhen.controller; // 定义包名 + +import com.github.pagehelper.PageInfo; // 导入分页插件 +import com.yanzhen.entity.*; // 导入实体类 +import com.yanzhen.service.*; // 导入服务接口 +import com.yanzhen.utils.Result; // 导入结果封装类 +import org.springframework.beans.factory.annotation.Autowired; // 导入自动装配注解 +import org.springframework.web.bind.annotation.*; // 导入Spring MVC相关注解 + +import javax.servlet.http.HttpServletRequest; // 导入HttpServletRequest类 +import java.util.ArrayList; // 导入ArrayList类 +import java.util.Date; // 导入Date类 +import java.util.HashMap; // 导入HashMap类 +import java.util.List; // 导入List接口 +import java.util.Map; // 导入Map接口 + +@RestController // 声明这是一个控制器，并且返回的数据直接写入HTTP响应体中 +@RequestMapping("/stu") // 设置请求路径前缀 +public class StuController { + + @Autowired // 自动注入StudentService实例 + private StudentService学生管理 studentService; + + @Autowired // 自动注入OrgService实例 + private OrgService机构管理 orgService; + + @Autowired // 自动注入GradeService实例 + private GradeService年级管理 gradeService; + + @Autowired // 自动注入SelectionDormitoryService实例 + private SelectionDormitoryService宿舍管理 selectionDormitoryService; + + @Autowired // 自动注入DormitoryService实例 + private DormitoryService宿舍编号设置 dormitoryService; + + @Autowired // 自动注入DormitoryStudentService实例 + private DormitoryStudentService宿舍预选设置 dormitoryStudentService; + + @Autowired // 自动注入AbsenceService实例 + private AbsenceService缺勤管理 absenceService; + + @Autowired // 自动注入RepairService实例 + private RepairService报修管理 repairService; + + @Autowired // 自动注入NoticeService实例 + private NoticeService公告管理 noticeService; + + @Autowired // 自动注入UserService实例 + private UserService用户管理 userService; + + @Autowired // 自动注入BuildingService实例 + private BuildingService楼层设置 buildingService; + + @Autowired // 自动注入SelectionService实例 + private SelectionService学生查询管理 selectionService; + + @GetMapping("/info") // 映射GET请求到/info路径 + public Result info(HttpServletRequest request) { // 定义info方法，参数为HttpServletRequest对象 + Student param = (Student)request.getAttribute("student"); // 从请求属性中获取学生信息 + Student student = studentService.detail(param.getId()); // 根据学生ID获取学生详细信息 + student.setOrg(orgService.detail(student.getClazzId())); // 设置学生所属组织信息 + student.setGrade(gradeService.detail(student.getGradeId())); // 设置学生所在年级信息 + return Result.ok(student); // 返回包含学生信息的Result对象 + } + + @GetMapping("/select_dormitory") // 映射GET请求到/select_dormitory路径 + public Result select_dormitory(HttpServletRequest request) { // 定义select_dormitory方法，参数为HttpServletRequest对象 + Student param = (Student)request.getAttribute("student"); // 从请求属性中获取学生信息 + Student student = studentService.detail(param.getId()); // 根据学生ID获取学生详细信息 + + SelectionDormitory selectionDormitory = new SelectionDormitory(); // 创建SelectionDormitory对象 + selectionDormitory.setClazzId(student.getClazzId()); // 设置班级ID + selectionDormitory.setLimit(1000); // 设置查询限制条数 + PageInfo pageInfo = selectionDormitoryService.query(selectionDormitory); // 查询可选宿舍列表 + + List> list = new ArrayList<>(); // 创建用于存储宿舍信息的列表 + List selectionDormitorys = pageInfo.getList(); // 获取查询结果列表 + for (SelectionDormitory sd : selectionDormitorys) { // 遍历查询结果列表 + Map map = new HashMap<>(); // 创建用于存储单个宿舍信息的Map对象 + //查询宿舍的基本信息 + Dormitory dormitory = dormitoryService.detail(sd.getDormitoryId()); // 根据宿舍ID获取宿舍详细信息 + map.put("capacity",dormitory.getCapacity()); // 设置宿舍容量 + map.put("id",dormitory.getId()); // 设置宿舍ID + map.put("no",dormitory.getNo()); // 设置宿舍编号 + map.put("sex",dormitory.getSex()); // 设置宿舍性别要求 + map.put("buildingName",buildingService.detail(dormitory.getBuildingId()).getName()); // 设置宿舍所在建筑名称 + //查询已选择的所有学生 + DormitoryStudent ds = new DormitoryStudent(); // 创建DormitoryStudent对象 + ds.setDormitoryId(sd.getDormitoryId()); // 设置宿舍ID + ds.setLimit(1000); // 设置查询限制条数 + PageInfo pageInfo1 = dormitoryStudentService.query(ds); // 查询已选择的学生列表 + map.put("selected",pageInfo1.getTotal()); // 设置已选择的学生数量 + //构造已经选择的同学信息 + List> studentList = new ArrayList<>(); // 创建用于存储已选择学生信息的列表 + List list1 = pageInfo1.getList(); // 获取已选择学生列表 + for(DormitoryStudent ds1 : list1){ // 遍历已选择学生列表 + Map studentMap = new HashMap<>(); // 创建用于存储单个学生信息的Map对象 + Student detail = studentService.detail(ds1.getStudentId()); // 根据学生ID获取学生详细信息 + studentMap.put("stuNo",detail.getStuNo()); // 设置学生学号 + studentMap.put("name",detail.getName()); // 设置学生姓名 + studentMap.put("bedId",ds1.getBedId()); // 设置学生床位ID + studentList.add(studentMap); // 将学生信息添加到列表中 + } + map.put("studentList",studentList); // 将已选择学生信息列表添加到宿舍信息Map中 + list.add(map); // 将宿舍信息添加到最终列表中 + } + return Result.ok(list); // 返回包含宿舍信息的Result对象 + } + + @PostMapping("select_dormitory_submit") // 映射POST请求到/select_dormitory_submit路径 + public Result select_dormitory(@RequestBody Map map, HttpServletRequest request){ // 定义select_dormitory方法，参数为请求体中的Map和HttpServletRequest对象 + Student param = (Student)request.getAttribute("student"); // 从请求属性中获取学生信息 + Student student = studentService.detail(param.getId()); // 根据学生ID获取学生详细信息 + + List selections = selectionService.queryByClazzId(student.getClazzId()); // 根据班级ID查询可选时间段列表 + if(selections != null && selections.size()==0){ // 如果未设置或没有可选时间段 + return Result.fail("操作失败，未设置！请联系管理员"); // 返回失败结果 + } + Selection selection = selections.get(0); // 获取第一个可选时间段 + if(selection.getStartTime().getTime() > System.currentTimeMillis() || System.currentTimeMillis() > selection.getEndTime().getTime()){ // 如果当前时间不在可选时间段内 + return Result.fail("操作失败，不在时间段内选择"); // 返回失败结果 + } + String bedId = map.get("bedId"); // 从请求体中获取床位ID + String dormitoryId = map.get("dormitoryId"); // 从请求体中获取宿舍ID + int row = dormitoryStudentService.select_dormitory_submit(student.getId(),Integer.parseInt(dormitoryId),Integer.parseInt(bedId)); // 根据学生ID、宿舍ID和床位ID提交选择宿舍请求 + if(row > 0){ // 如果提交成功 + return Result.ok(); // 返回成功结果 + }else{ + return Result.fail(); // 如果提交失败，返回失败结果 + } + } + + @PostMapping("repair_create") // 映射POST请求到/repair_create路径 + public Result repair_create(@RequestBody Repair repair,HttpServletRequest request){ // 定义repair_create方法，参数为请求体中的Repair对象和HttpServletRequest对象 + Student param = (Student)request.getAttribute("student"); // 从请求属性中获取学生信息 + DormitoryStudent ds = new DormitoryStudent(); // 创建DormitoryStudent对象 + ds.setStudentId(param.getId()); // 设置学生ID + PageInfo pageInfo = dormitoryStudentService.query(ds); // 查询学生关联的宿舍信息 + PageInfo noticePageInfo = null; // 初始化通知信息分页对象 + if(pageInfo.getList() != null && pageInfo.getList().size() > 0){ // 如果存在关联的宿舍信息 + DormitoryStudent dormitoryStudent = pageInfo.getList().get(0); // 获取第一个关联的宿舍信息 + Dormitory detail = dormitoryService.detail(dormitoryStudent.getDormitoryId()); // 根据宿舍ID获取宿舍详细信息 + repair.setBuildingId(detail.getBuildingId()); // 设置维修记录的建筑ID + repair.setDormitoryId(dormitoryStudent.getDormitoryId()); // 设置维修记录的宿舍ID + repair.setStudentId(param.getId()); // 设置维修记录的学生ID + repair.setCreateDate(new Date()); // 设置维修记录的创建日期 + repair.setStatus(0); // 设置维修记录的状态为0（未完成） + int flag = repairService.create(repair); // 提交维修记录并获取操作结果标志 + if(flag > 0){ // 如果提交成功 + return Result.ok(); // 返回成功结果 + }else{ + return Result.fail(); // 如果提交失败，返回失败结果 + } + }else{ + return Result.fail("操作失败，没有关联的宿舍"); // 如果不存在关联的宿舍信息，返回失败结果 + } + } + + @PostMapping("notice_query") // 映射POST请求到/notice_query路径 + public Map notice_query(@RequestBody Notice notice,HttpServletRequest request){ // 定义notice_query方法，参数为请求体中的Notice对象和HttpServletRequest对象 + Student param = (Student)request.getAttribute("student"); // 从请求属性中获取学生信息 + DormitoryStudent ds = new DormitoryStudent(); // 创建DormitoryStudent对象 + ds.setStudentId(param.getId()); // 设置学生ID + PageInfo pageInfo = dormitoryStudentService.query(ds); // 查询学生关联的宿舍信息 + PageInfo noticePageInfo = null; // 初始化通知信息分页对象 + if(pageInfo.getList() != null && pageInfo.getList().size() > 0){ // 如果存在关联的宿舍信息 + DormitoryStudent dormitoryStudent = pageInfo.getList().get(0); // 获取第一个关联的宿舍信息 + Dormitory detail = dormitoryService.detail(dormitoryStudent.getDormitoryId()); // 根据宿舍ID获取宿舍详细信息 + notice.setBuildingId(detail.getBuildingId()); // 设置通知的建筑ID + noticePageInfo = noticeService.queryByBuildingId(notice); // 根据建筑ID查询通知列表 + noticePageInfo.getList().forEach(entity->{ // 遍历通知列表 + entity.setUser(userService.detail(entity.getUserId())); // 根据用户ID获取用户详细信息并设置到通知对象中 + }); + }else{ + noticePageInfo = new PageInfo<>(null); // 如果不存在关联的宿舍信息，初始化空的通知分页对象 + } + return Result.ok(noticePageInfo); // 返回包含通知信息的Result对象 + } +} \ No newline at end of file diff --git a/main/Student.java b/main/Student.java new file mode 100644 index 0000000..93ad934 --- /dev/null +++ b/main/Student.java @@ -0,0 +1,128 @@ +package com.yanzhen.entity; + +import javax.validation.constraints.NotNull; +import org.hibernate.validator.constraints.Length; +import com.yanzhen.utils.Entity; +import java.util.Date; + + + +public class Student extends Entity{ + + private Integer id; // 学生ID + + @Length(max = 50) // 学号，最大长度50 + private String stuNo; + + @Length(max = 50) // 姓名，最大长度50 + private String name; + + @Length(max = 50)// 身份证号，最大长度50 + private String idcard; + + private Integer gradeId;// 年级ID + + private Integer sex;// 性别（1为男，2为女） + + @Length(max = 50)// 电话号码，最大长度50 + private String phone; + + @Length(max = 50)// 密码，最大长度50 + private String password; + + private Integer clazzId;// 班级ID + + + private Org org;// 所属组织 + + private Grade grade;// 所属年级 + + + public Integer getId() { + return id;// 获取学生ID + } + + public void setId(Integer id) {// 设置学生ID + this.id = id; + } + + public String getStuNo() {// 获取学号 + return stuNo; + } + + public void setStuNo(String stuNo) {// 设置学号 + this.stuNo = stuNo; + } + + public String getName() {// 获取姓名 + return name; + } + + public void setName(String name) {// 设置姓名 + this.name = name; + } + + public String getIdcard() {// 获取身份证号 + return idcard; + } + + public void setIdcard(String idcard) {// 设置身份证号 + this.idcard = idcard; + } + + public Integer getGradeId() {// 获取年级ID + return gradeId; + } + + public void setGradeId(Integer gradeId) {// 设置年级ID + this.gradeId = gradeId; + } + + public Integer getSex() {// 获取性别 + return sex; + } + + public void setSex(Integer sex) {// 设置性别 + this.sex = sex; + } + + public String getPhone() {// 获取电话号码 + return phone; + } + + public void setPhone(String phone) {// 设置电话号码 + this.phone = phone; + } + + public String getPassword() { // 获取密码 + return password; + } + + public void setPassword(String password) {// 设置密码 + this.password = password; + } + + public Integer getClazzId() {// 获取班级ID + return clazzId; + } + + public void setClazzId(Integer clazzId) {// 设置班级ID + this.clazzId = clazzId; + } + + public Org getOrg() {// 获取所属组织 + return org; + } + + public void setOrg(Org org) {// 设置所属组织 + this.org = org; + } + + public Grade getGrade() {// 获取所属年级 + return grade; + } + + public void setGrade(Grade grade) {// 设置所属年级 + this.grade = grade; + } +} \ No newline at end of file diff --git a/main/StudentController.java b/main/StudentController.java new file mode 100644 index 0000000..9caaa97 --- /dev/null +++ b/main/StudentController.java @@ -0,0 +1,77 @@ +package com.yanzhen.controller; + +import com.github.pagehelper.PageInfo; +import com.yanzhen.entity.Grade; +import com.yanzhen.entity.Org; +import com.yanzhen.entity.Student; +import com.yanzhen.service.GradeService年级管理; +import com.yanzhen.service.OrgService机构管理; +import com.yanzhen.service.StudentService学生管理; +import com.yanzhen.utils.Result; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +import java.util.Map; + +@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中，而不是解析为跳转路径。 +@RequestMapping("/student") // 设置请求的根路径为 "/student"，所有方法的请求路径都会以这个为基础。 +public class StudentController { // 定义一个名为 StudentController 的类，用于处理学生相关的请求。 + + @Autowired // 自动注入 StudentService 对象，用于处理学生数据的业务逻辑。 + private StudentService学生管理 studentService; + + @Autowired // 自动注入 GradeService 对象，用于处理年级数据的业务逻辑。 + private GradeService年级管理 gradeService; + + @Autowired // 自动注入 OrgService 对象，用于处理班级数据的业务逻辑。 + private OrgService机构管理 orgService; + + @PostMapping("create") // 映射 HTTP POST 请求到 create 方法，用于创建新的学生记录。 + public Result create(@RequestBody Student student){ // 接收一个 JSON 格式的学生对象作为请求体。 + int flag = studentService.create(student); // 调用 studentService 的 create 方法保存学生信息，并返回操作结果标志。 + if(flag>0){ // 如果操作成功（flag > 0）。 + return Result.ok(); // 返回成功的 Result 对象。 + }else{ // 如果操作失败（flag <= 0）。 + return Result.fail(); // 返回失败的 Result 对象。 + } + } + + @GetMapping("delete") // 映射 HTTP GET 请求到 delete 方法，用于删除学生记录。 + public Result delete(String ids){ // 接收要删除的学生 ID 列表作为请求参数。 + int flag = studentService.delete(ids); // 调用 studentService 的 delete 方法删除指定的学生记录，并返回操作结果标志。 + if(flag>0){ // 如果操作成功（flag > 0）。 + return Result.ok(); // 返回成功的 Result 对象。 + }else{ // 如果操作失败（flag <= 0）。 + return Result.fail(); // 返回失败的 Result 对象。 + } + } + + @PostMapping("update") // 映射 HTTP POST 请求到 update 方法，用于更新学生记录。 + public Result update(@RequestBody Student student){ // 接收一个 JSON 格式的学生对象作为请求体。 + int flag = studentService.updateSelective(student); // 调用 studentService 的 updateSelective 方法更新学生信息，并返回操作结果标志。 + if(flag>0){ // 如果操作成功（flag > 0）。 + return Result.ok(); // 返回成功的 Result 对象。 + }else{ // 如果操作失败（flag <= 0）。 + return Result.fail(); // 返回失败的 Result 对象。 + } + } + + @GetMapping("detail") // 映射 HTTP GET 请求到 detail 方法，用于获取单个学生的详细信息。 + public Student detail(Integer id){ // 接收学生 ID 作为请求参数。 + return studentService.detail(id); // 调用 studentService 的 detail 方法获取指定 ID 的学生信息，并返回该学生对象。 + } + + @PostMapping("query") // 映射 HTTP POST 请求到 query 方法，用于查询学生列表。 + public Map query(@RequestBody Student student){ // 接收一个 JSON 格式的学生对象作为请求体，用于查询条件。 + PageInfo pageInfo = studentService.query(student); // 调用 studentService 的 query 方法查询符合条件的学生列表，并返回分页信息。 + + pageInfo.getList().forEach(entity->{ // 遍历查询结果中的每个学生对象。 + Grade grade = gradeService.detail(entity.getGradeId()); // 根据学生对象的年级 ID 获取对应的年级信息。 + entity.setGrade(grade); // 将年级信息设置到学生对象中。 + Org org = orgService.detail(entity.getClazzId()); // 根据学生对象的班级 ID 获取对应的班级信息。 + entity.setOrg(org); // 将班级信息设置到学生对象中。 + }); + return Result.ok(pageInfo); // 返回包含分页信息的成功的 Result 对象。 + } + +} \ No newline at end of file diff --git a/main/StudentMapper.java b/main/StudentMapper.java new file mode 100644 index 0000000..51e0385 --- /dev/null +++ b/main/StudentMapper.java @@ -0,0 +1,26 @@ +package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包 + +import java.util.List; // 导入Java的List类，用于处理列表数据结构 +import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构 + +import com.yanzhen.entity.Student; // 导入Student实体类，用于操作学生信息 + +public interface StudentMapper { // 定义一个名为StudentMapper的公共接口 + + public int create(Student student); // 定义一个创建学生记录的方法，返回值为int类型，参数为Student对象 + + public int delete(Integer id); // 定义一个删除学生记录的方法，返回值为int类型，参数为学生的ID + + public int update(Student student); // 定义一个更新学生记录的方法，返回值为int类型，参数为Student对象 + + public int updateSelective(Student student); // 定义一个选择性更新学生记录的方法，返回值为int类型，参数为Student对象 + + public List query(Student student); // 定义一个查询学生记录的方法，返回值为List类型，参数为Student对象 + + public Student detail(Integer id); // 定义一个获取学生详细信息的方法，返回值为Student对象，参数为学生的ID + public Student detailByName(String name); // 定义一个通过名字获取学生详细信息的方法，返回值为Student对象，参数为学生的名字 + + public int count(Student student); // 定义一个统计学生数量的方法，返回值为int类型，参数为Student对象 + + public Student login(String userName,String password); // 定义一个登录方法，返回值为Student对象，参数为用户名称和密码 +} \ No newline at end of file diff --git a/main/StudentService学生管理.java b/main/StudentService学生管理.java new file mode 100644 index 0000000..00c2fc8 --- /dev/null +++ b/main/StudentService学生管理.java @@ -0,0 +1,67 @@ +package com.yanzhen.service; // 定义包名 + +import com.yanzhen.mapper.StudentMapper; // 导入StudentMapper接口 +import com.yanzhen.entity.Student; // 导入Student实体类 +import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类 +import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类 +import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解 +import org.springframework.stereotype.Service; // 导入Spring的服务层注解 +import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作 + +@Service // 标注该类为服务层组件 +public class StudentService学生管理 { // 定义StudentService类 “学生管理----管理员” + + @Autowired // 自动装配StudentMapper对象 + private StudentMapper studentMapper; + + public int create(Student student) { // 创建学生记录的方法 + return studentMapper.create(student); // 调用Mapper层的create方法 + } + + public int delete(String ids) { // 根据ID字符串批量删除学生记录的方法 + String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组 + int row = 0; // 初始化受影响行数为0 + for (String s : arr) { // 遍历ID数组 + if(!StringUtils.isEmpty(s)){ // 如果ID不为空 + studentMapper.delete(Integer.parseInt(s)); // 调用Mapper层的delete方法删除记录 + row++; // 受影响行数加1 + } + } + return row; // 返回受影响行数 + } + + public int delete(Integer id) { // 根据ID删除学生记录的方法 + return studentMapper.delete(id); // 调用Mapper层的delete方法 + } + + public int update(Student student) { // 更新学生记录的方法 + return studentMapper.update(student); // 调用Mapper层的update方法 + } + + public int updateSelective(Student student) { // 选择性更新学生记录的方法 + return studentMapper.updateSelective(student); // 调用Mapper层的updateSelective方法 + } + + public PageInfo query(Student student) { // 查询学生记录列表的方法 + if(student != null && student.getPage() != null){ // 如果查询条件和分页信息不为空 + PageHelper.startPage(student.getPage(),student.getLimit()); // 启动分页并设置分页参数 + } + return new PageInfo(studentMapper.query(student)); // 调用Mapper层的query方法并封装成PageInfo对象返回 + } + + public Student detail(Integer id) { // 根据ID获取学生详情的方法 + return studentMapper.detail(id); // 调用Mapper层的detail方法 + } + + public Student detailByName(String name) { // 根据姓名获取学生详情的方法 + return studentMapper.detailByName(name); // 调用Mapper层的detailByName方法 + } + + public int count(Student student) { // 统计学生记录数量的方法 + return studentMapper.count(student); // 调用Mapper层的count方法 + } + + public Student login(String userName,String password){ // 登录验证的方法 + return studentMapper.login(userName,password); // 调用Mapper层的login方法进行登录验证 + } +} \ No newline at end of file diff --git a/main/TokenInterceptor.java b/main/TokenInterceptor.java new file mode 100644 index 0000000..9ccc70f --- /dev/null +++ b/main/TokenInterceptor.java @@ -0,0 +1,53 @@ +package com.yanzhen.framework.mvc; // 定义包名 + +import com.yanzhen.entity.Student; // 导入Student类 +import com.yanzhen.entity.User; // 导入User类 +import com.yanzhen.framework.exception.MyException; // 导入自定义异常类MyException +import com.yanzhen.framework.jwt.JWTUtil; // 导入JWT工具类JWTUtil +import org.springframework.web.servlet.HandlerInterceptor; // 导入Spring MVC的HandlerInterceptor接口 +import org.springframework.web.servlet.ModelAndView; // 导入Spring MVC的ModelAndView类 + +import javax.servlet.http.HttpServletRequest; // 导入HttpServletRequest类 +import javax.servlet.http.HttpServletResponse; // 导入HttpServletResponse类 + +public class TokenInterceptor implements HandlerInterceptor { // 定义TokenInterceptor类并实现HandlerInterceptor接口 + + @Override // 重写preHandle方法，在请求处理之前进行调用 + public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { + String token = request.getHeader(JWTUtil.token); // 从请求头中获取token + + String type = JWTUtil.getType(token); // 根据token获取类型 + if("USER".equals(type)){ // 如果类型是USER + //根据token获取user对象 + User user = JWTUtil.getUser(token); // 通过JWT工具类获取User对象 + if(user == null){ // 如果User对象为空 + throw new MyException("超时或不合法的token"); // 抛出自定义异常 + } + String newToken = JWTUtil.sign(user); // 重新生成新的token + response.setHeader(JWTUtil.token,newToken); // 将新token设置到响应头中 + response.setHeader("Access-Control-Expose-Headers", JWTUtil.token); // 设置允许暴露的响应头 + request.setAttribute("user",user); // 将User对象设置到请求属性中 + }else if("STUDENT".equals(type)){ // 如果类型是STUDENT + //根据token获取user对象 + Student student = JWTUtil.getStudent(token); // 通过JWT工具类获取Student对象 + if(student == null){ // 如果Student对象为空 + throw new MyException("超时或不合法的token"); // 抛出自定义异常 + } + String newToken = JWTUtil.signForStudent(student); // 重新生成新的token + response.setHeader(JWTUtil.token,newToken); // 将新token设置到响应头中 + response.setHeader("Access-Control-Expose-Headers", JWTUtil.token); // 设置允许暴露的响应头 + request.setAttribute("student",student); // 将Student对象设置到请求属性中 + } + return true; // 返回true表示继续执行后续的拦截器和处理器 + } + + @Override // 重写postHandle方法，在请求处理之后但在视图渲染之前进行调用 + public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { + + } + + @Override // 重写afterCompletion方法，在整个请求结束之后进行调用 + public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { + + } +} \ No newline at end of file diff --git a/main/User.java b/main/User.java new file mode 100644 index 0000000..db8c8b8 --- /dev/null +++ b/main/User.java @@ -0,0 +1,89 @@ +package com.yanzhen.entity; + +import javax.validation.constraints.NotNull; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonProperty; +import org.hibernate.validator.constraints.Length; +import com.yanzhen.utils.Entity; +import java.util.Date; +import java.util.List; + + + +public class User extends Entity{ // 定义一个User类，继承自Entity类 + + private Integer id; // 用户的唯一标识符 + + @Length(max = 100) // 用户名的最大长度限制为100个字符 + private String userName; // 用户的用户名 + + @Length(max = 100) // 密码的最大长度限制为100个字符 + private String password; // 用户的密码 + + @Length(max = 100) // 姓名的最大长度限制为100个字符 + private String name; // 用户的姓名 + + @Length(max = 100) // 电话号码的最大长度限制为100个字符 + private String phone; // 用户的电话号码 + + private Integer type; // 用户的类型，0表示管理员，1表示宿管员 + + @Length(max = 200) // 备注信息的最大长度限制为200个字符 + private String remark; // 用户的备注信息 + + private List ids; // 存储多个ID的列表 + + public Integer getId() { // 获取用户ID的方法 + return id; + } + public void setId(Integer id) { // 设置用户ID的方法 + this.id = id; + } + public String getUserName() { // 获取用户名的方法 + return userName; + } + public void setUserName(String userName) { // 设置用户名的方法 + this.userName = userName; + } + @JsonIgnore // 在序列化时忽略此属性 + public String getPassword() { // 获取用户密码的方法 + return password; + } + @JsonProperty // 在序列化时包含此属性 + public void setPassword(String password) { // 设置用户密码的方法 + this.password = password; + } + public String getName() { // 获取用户姓名的方法 + return name; + } + public void setName(String name) { // 设置用户姓名的方法 + this.name = name; + } + public String getPhone() { // 获取用户电话号码的方法 + return phone; + } + public void setPhone(String phone) { // 设置用户电话号码的方法 + this.phone = phone; + } + public Integer getType() { // 获取用户类型的方法 + return type; + } + public void setType(Integer type) { // 设置用户类型的方法 + this.type = type; + } + public String getRemark() { // 获取用户备注信息的方法 + return remark; + } + public void setRemark(String remark) { // 设置用户备注信息的方法 + this.remark = remark; + } + + public List getIds() { // 获取ID列表的方法 + return ids; + } + + public void setIds(List ids) { // 设置ID列表的方法 + this.ids = ids; + } +} \ No newline at end of file diff --git a/main/UserController.java b/main/UserController.java new file mode 100644 index 0000000..04f9cd9 --- /dev/null +++ b/main/UserController.java @@ -0,0 +1,107 @@ +package com.yanzhen.controller; + +import com.github.pagehelper.PageInfo; +import com.yanzhen.entity.Student; +import com.yanzhen.entity.User; +import com.yanzhen.service.StudentService学生管理; +import com.yanzhen.service.UserService用户管理; +import com.yanzhen.utils.Result; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +import javax.servlet.http.HttpServletRequest; +import java.util.Map; + + +@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中，而不是解析为跳转路径。 +@RequestMapping("/user") // 设置请求的基础路径为 "/user"，所有方法的请求路径都会以 "/user" 开头。 +public class UserController { + + @Autowired // 自动注入 UserService 对象，用于处理用户相关的业务逻辑。 + private UserService用户管理 userService; + @Autowired // 自动注入 StudentService 对象，用于处理学生相关的业务逻辑。 + private StudentService学生管理 studentService; + + @PostMapping("create") // 映射 HTTP POST 请求到 "create" 方法，用于创建新用户。 + public Result create(@RequestBody User user){ // 从请求体中获取 User 对象。 + int flag = userService.create(user); // 调用 userService 的 create 方法创建用户，并返回操作结果标志。 + if(flag>0){ // 如果创建成功（flag > 0）。 + return Result.ok(); // 返回成功的 Result 对象。 + }else{ // 如果创建失败（flag <= 0）。 + return Result.fail(); // 返回失败的 Result 对象。 + } + } + + @GetMapping("delete") // 映射 HTTP GET 请求到 "delete" 方法，用于删除用户。 + public Result delete(String ids){ // 从请求参数中获取要删除的用户 ID 字符串。 + int flag = userService.delete(ids); // 调用 userService 的 delete 方法删除用户，并返回操作结果标志。 + if(flag>0){ // 如果删除成功（flag > 0）。 + return Result.ok(); // 返回成功的 Result 对象。 + }else{ // 如果删除失败（flag <= 0）。 + return Result.fail(); // 返回失败的 Result 对象。 + } + } + + @PostMapping("update") // 映射 HTTP POST 请求到 "update" 方法，用于更新用户信息。 + public Result update(@RequestBody User user){ // 从请求体中获取 User 对象。 + int flag = userService.updateSelective(user); // 调用 userService 的 updateSelective 方法更新用户信息，并返回操作结果标志。 + if(flag>0){ // 如果更新成功（flag > 0）。 + return Result.ok(); // 返回成功的 Result 对象。 + }else{ // 如果更新失败（flag <= 0）。 + return Result.fail(); // 返回失败的 Result 对象。 + } + } + + @GetMapping("detail") // 映射 HTTP GET 请求到 "detail" 方法，用于获取用户详细信息。 + public User detail(Integer id){ // 从请求参数中获取用户 ID。 + return userService.detail(id); // 调用 userService 的 detail 方法获取用户详细信息，并返回该用户对象。 + } + + @GetMapping("info") // 映射 HTTP GET 请求到 "info" 方法，用于获取当前登录用户的详细信息。 + public Result info(HttpServletRequest request){ // 从请求中获取当前用户信息。 + User user = (User)request.getAttribute("user"); // 从请求属性中获取当前用户对象。 + return Result.ok(userService.detail(user.getId())); // 调用 userService 的 detail 方法获取用户详细信息，并返回成功的 Result 对象。 + } + + @PostMapping("pwd") // 映射 HTTP POST 请求到 "pwd" 方法，用于修改用户密码。 + public Result pwd(@RequestBody Map map,HttpServletRequest request){ // 从请求体中获取包含原密码和新密码的 Map，并从请求中获取当前用户或学生信息。 + String spassword = map.get("spassword"); // 获取原密码。 + String npassword = map.get("npassword"); // 获取新密码。 + //用户修改 + if(request.getAttribute("user") != null){ // 如果当前用户是普通用户。 + User user = (User)request.getAttribute("user"); // 从请求属性中获取当前用户对象。 + User entity = userService.detail(user.getId()); // 调用 userService 的 detail 方法获取用户详细信息。 + if(entity.getPassword().equals(spassword)){ // 如果原密码正确。 + User param = new User(); // 创建新的 User 对象用于更新密码。 + param.setId(entity.getId()); // 设置用户 ID。 + param.setPassword(npassword); // 设置新密码。 + userService.updatePwd(param); // 调用 userService 的 updatePwd 方法更新密码。 + return Result.ok("修改密码成功"); // 返回成功的 Result 对象。 + }else{ // 如果原密码错误。 + return Result.fail("原密码错误"); // 返回失败的 Result 对象。 + } + } + //学生修改 + if(request.getAttribute("student") != null){ // 如果当前用户是学生。 + Student student = (Student)request.getAttribute("student"); // 从请求属性中获取当前学生对象。 + Student entity = studentService.detail(student.getId()); // 调用 studentService 的 detail 方法获取学生详细信息。 + if(entity.getPassword().equals(spassword)){ // 如果原密码正确。 + Student param = new Student(); // 创建新的 Student 对象用于更新密码。 + param.setId(entity.getId()); // 设置学生 ID。 + param.setPassword(npassword); // 设置新密码。 + studentService.updateSelective(param); // 调用 studentService 的 updateSelective 方法更新密码。 + return Result.ok("修改密码成功"); // 返回成功的 Result 对象。 + }else{ // 如果原密码错误。 + return Result.fail("原密码错误"); // 返回失败的 Result 对象。 + } + } + return Result.ok(); // 如果既不是普通用户也不是学生，返回成功的 Result 对象。 + } + + @PostMapping("query") // 映射 HTTP POST 请求到 "query" 方法，用于查询用户列表。 + public Map query(@RequestBody User user){ // 从请求体中获取 User 对象作为查询条件。 + PageInfo pageInfo = userService.query(user); // 调用 userService 的 query 方法进行分页查询，并返回分页信息。 + return Result.ok(pageInfo); // 返回包含分页信息的成功的 Result 对象。 + } + +} diff --git a/main/UserMapper.java b/main/UserMapper.java new file mode 100644 index 0000000..aabff78 --- /dev/null +++ b/main/UserMapper.java @@ -0,0 +1,26 @@ +package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包 + +import java.util.List; // 导入Java的List类，用于处理列表数据结构 +import java.util.Map; // 导入Java的Map类，用于处理键值对数据结构 + +import com.yanzhen.entity.User; // 导入User实体类，用于操作用户数据 +import org.apache.ibatis.annotations.Param; // 导入MyBatis的Param注解，用于传递参数到SQL语句中 + +public interface UserMapper { // 定义UserMapper接口，作为MyBatis的Mapper接口 + + public int create(User user); // 定义create方法，用于创建新用户，返回影响的行数 + + public int delete(Integer id); // 定义delete方法，根据用户ID删除用户，返回影响的行数 + + public int update(User user); // 定义update方法，更新用户信息，返回影响的行数 + + public int updateSelective(User user); // 定义updateSelective方法，选择性更新用户信息，返回影响的行数 + + public List query(User user); // 定义query方法，根据条件查询用户列表，返回用户列表 + + public User detail(Integer id); // 定义detail方法，根据用户ID查询用户详情，返回用户对象 + + public User login(@Param("userName") String userName, @Param("password") String password); // 定义login方法，根据用户名和密码查询用户，返回用户对象 + + public int count(User user); // 定义count方法，统计符合条件的用户数量，返回用户数量 +} \ No newline at end of file diff --git a/main/UserService用户管理.java b/main/UserService用户管理.java new file mode 100644 index 0000000..727a556 --- /dev/null +++ b/main/UserService用户管理.java @@ -0,0 +1,96 @@ +package com.yanzhen.service; + +import com.yanzhen.mapper.MenuMapper; +import com.yanzhen.mapper.UserMapper; +import com.yanzhen.entity.User; +import com.github.pagehelper.PageHelper; +import com.github.pagehelper.PageInfo; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.util.StringUtils; + +@Service +public class UserService用户管理 { //“用户管理----管理员” + + @Autowired // 自动注入UserMapper + private UserMapper userMapper; + @Autowired // 自动注入MenuMapper + private MenuMapper menuMapper; + + public int create(User user) {//目的：在数据库中创建一个新的用户记录，并关联菜单权限 + int row = 0; // 初始化受影响的行数为0 + userMapper.create(user); // 调用userMapper的create方法将用户信息保存在数据库中 + for (Integer menuId : user.getIds()) { // 遍历用户关联的菜单ID列表 + menuMapper.createUserMenu(user.getId(),menuId); // 将用户和菜单的关系保存到中间表 + } + row = 1; // 设置受影响的行数为1，表示成功创建一条记录 + return row; // 返回受影响的行数 + } + + public int delete(String ids) {// 目的：根据多个ID删除对应的用户记录，并清除中间表中的关联关系 + String[] arr = ids.split(","); // 将传入的字符串按逗号分割成数组 + int row = 0; // 初始化受影响的行数为0 + for (String s : arr) { // 遍历数组中的每个元素 + if(!StringUtils.isEmpty(s)){ // 如果元素不为空 + menuMapper.deleteUserMenu(Integer.parseInt(s)); // 删除中间表中对应的记录 + userMapper.delete(Integer.parseInt(s)); // 删除用户表中对应的记录 + row++; // 增加受影响的行数 + } + } + return row; // 返回受影响的行数 + } + + public int delete(Integer id) {// 目的：该函数通过两步操作来删除用户及其相关的菜单记录：首先删除中间表中的记录，然后删除用户表中的记录。 + menuMapper.deleteUserMenu(id); // 删除中间表中对应的记录 + return userMapper.delete(id); // 删除用户表中对应的记录并返回受影响的行数 + } + + public int update(User user) {// 目的：更新用户信息，并更新中间表中的菜单关系, + int row = 0; // 初始化受影响的行数为0 + userMapper.update(user); // 更新用户信息 + menuMapper.deleteUserMenu(user.getId()); // 删除旧的用户-菜单关系 + for (Integer menuId : user.getIds()) { // 遍历新的用户-菜单关系 + menuMapper.createUserMenu(user.getId(),menuId); // 保存新的用户-菜单关系 + } + row = 1; // 设置受影响的行数为1，表示成功更新一条记录 + return row; // 返回受影响的行数 + } + + public int updatePwd(User user) {// 目的：该函数 updatePwd 的主要作用是通过调用 userMapper 对象的 updateSelective 方法来更新用户密码。 + + return userMapper.updateSelective(user); // 更新用户密码并返回受影响的行数 + } + + public int updateSelective(User user) {// 目的：该函数通过调用多个数据访问对象（DAO）的方法，实现了对用户信息的选择性更新以及用户-菜单关系的更新。 + + int row = 0; // 初始化受影响的行数为0 + userMapper.updateSelective(user); // 选择性更新用户信息 + menuMapper.deleteUserMenu(user.getId()); // 删除旧的用户-菜单关系 + for (Integer menuId : user.getIds()) { // 遍历新的用户-菜单关系 + menuMapper.createUserMenu(user.getId(),menuId); // 保存新的用户-菜单关系 + } + row = 1; // 设置受影响的行数为1，表示成功更新一条记录 + return row; // 返回受影响的行数 + } + + public PageInfo query(User user) {//该函数的主要作用是根据传入的用户对象进行分页查询，并返回包含用户信息的分页结果。 + if(user != null && user.getPage() != null){ // 如果用户对象不为空且分页参数不为空 + PageHelper.startPage(user.getPage(),user.getLimit()); // 设置分页参数 + } + return new PageInfo(userMapper.query(user)); // 查询用户列表并返回分页信息 + } + + public User login(String userName,String password){//实现了一个简单的用户登录功能，通过调用数据访问层的 login 方法，根据用户名和密码查询用户信息并返回。 + return userMapper.login(userName,password); // 根据用户名和密码查询用户信息并返回 + } + + public User detail(Integer id) {// 目的：该函数的主要作用是通过调用 userMapper 对象的 detail 方法，根据用户ID查询用户的详细信息。 + + return userMapper.detail(id); // 根据用户ID查询用户详情并返回 + } + + public int count(User user) {// 目的：定义了一个名为 count 的方法，用于统计符合特定条件的用户数量。 + + return userMapper.count(user); // 统计符合条件的用户数量并返回 + } +} \ No newline at end of file diff --git a/main/Visit.java b/main/Visit.java new file mode 100644 index 0000000..ef3bfcb --- /dev/null +++ b/main/Visit.java @@ -0,0 +1,128 @@ +package com.yanzhen.entity; + +import javax.validation.constraints.NotNull; +import org.hibernate.validator.constraints.Length; +import com.yanzhen.utils.Entity; +import java.util.Date; + + + + +public class Visit extends Entity{// 定义一个名为Visit的类，继承自Entity类 + + + private Integer id;// 定义一个私有的Integer类型的变量id + + + @Length(max = 100)// 定义一个私有的String类型的变量visitor，并设置其最大长度为100 + private String visitor; + + + @Length(max = 100)// 定义一个私有的String类型的变量phone，并设置其最大长度为100 + private String phone; + + + private Integer sex; // 定义一个私有的Integer类型的变量sex + + + @Length(max = 100) // 定义一个私有的String类型的变量idcard，并设置其最大长度为100 + private String idcard; + + private Integer studentId; // 定义一个私有的Integer类型的变量studentId + + + private Date visitTime; // 定义一个私有的Date类型的变量visitTime + + + private Date leaveTime;// 定义一个私有的Date类型的变量leaveTime + + + @Length(max = 200) // 定义一个私有的String类型的变量remark，并设置其最大长度为200 + private String remark; + + + private Student student;// 定义一个私有的Student类型的变量student + + + public Integer getId() {// 定义一个公共方法getId，用于获取id的值 + return id; + } + + public void setId(Integer id) {// 定义一个公共方法setId，用于设置id的值 + this.id = id; + } + + public String getVisitor() {// 定义一个公共方法getVisitor，用于获取visitor的值 + return visitor; + } + + public void setVisitor(String visitor) {// 定义一个公共方法setVisitor，用于设置visitor的值 + this.visitor = visitor; + } + + public String getPhone() {// 定义一个公共方法getPhone，用于获取phone的值 + return phone; + } + + public void setPhone(String phone) {// 定义一个公共方法setPhone，用于设置phone的值 + this.phone = phone; + } + + public Integer getSex() {// 定义一个公共方法getSex，用于获取sex的值 + return sex; + } + + public void setSex(Integer sex) {// 定义一个公共方法setSex，用于设置sex的值 + this.sex = sex; + } + + public String getIdcard() {// 定义一个公共方法getIdcard，用于获取idcard的值 + return idcard; + } + + public void setIdcard(String idcard) {// 定义一个公共方法setIdcard，用于设置idcard的值 + this.idcard = idcard; + } + + public Integer getStudentId() {// 定义一个公共方法getStudentId，用于获取studentId的值 + return studentId; + } + + public void setStudentId(Integer studentId) {// 定义一个公共方法setStudentId，用于设置studentId的值 + this.studentId = studentId; + } + + public Date getVisitTime() {// 定义一个公共方法getVisitTime，用于获取visitTime的值 + return visitTime; + } + + public void setVisitTime(Date visitTime) {// 定义一个公共方法setVisitTime，用于设置visitTime的值 + this.visitTime = visitTime; + } + + public Date getLeaveTime() {// 定义一个公共方法getLeaveTime，用于获取leaveTime的值 + return leaveTime; + } + + public void setLeaveTime(Date leaveTime) {// 定义一个公共方法setLeaveTime，用于设置leaveTime的值 + this.leaveTime = leaveTime; + } + + public String getRemark() {// 定义一个公共方法getRemark，用于获取remark的值 + return remark; + } + + public void setRemark(String remark) {// 定义一个公共方法setRemark，用于设置remark的值 + this.remark = remark; + } + + + public Student getStudent() {// 定义一个公共方法getStudent，用于获取student的值 + return student; + } + + + public void setStudent(Student student) {// 定义一个公共方法setStudent，用于设置student的值 + this.student = student; + } +} \ No newline at end of file diff --git a/main/VisitController.java b/main/VisitController.java new file mode 100644 index 0000000..fb99958 --- /dev/null +++ b/main/VisitController.java @@ -0,0 +1,68 @@ +package com.yanzhen.controller; + +import com.github.pagehelper.PageInfo; +import com.yanzhen.entity.Student; +import com.yanzhen.entity.Visit; +import com.yanzhen.service.StudentService学生管理; +import com.yanzhen.service.VisitService来访管理; +import com.yanzhen.utils.Result; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +import java.util.Map; + +@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中，而不是解析为跳转路径。 +@RequestMapping("/visit") // 设置请求的根路径为 "/visit"，所有方法的请求路径都会以 "/visit" 开头。 +public class VisitController { // 定义一个名为 VisitController 的类，用于处理与访问相关的请求。 + + @Autowired // 自动注入 VisitService 对象，用于处理访问数据的业务逻辑。 + private VisitService来访管理 visitService; + @Autowired // 自动注入 StudentService 对象，用于处理学生数据的业务逻辑。 + private StudentService学生管理 studentService; + + @PostMapping("create") // 映射 HTTP POST 请求到 create 方法，用于创建新的访问记录。 + public Result create(@RequestBody Visit visit){ // 从请求体中获取 Visit 对象。 + int flag = visitService.create(visit); // 调用 VisitService 的 create 方法保存访问记录，并返回操作结果标志。 + if(flag>0){ // 如果操作成功（flag > 0）。 + return Result.ok(); // 返回成功的 Result 对象。 + }else{ // 如果操作失败（flag <= 0）。 + return Result.fail(); // 返回失败的 Result 对象。 + } + } + + @GetMapping("delete") // 映射 HTTP GET 请求到 delete 方法，用于删除访问记录。 + public Result delete(String ids){ // 从请求参数中获取要删除的记录的 ID 字符串。 + int flag = visitService.delete(ids); // 调用 VisitService 的 delete 方法删除指定 ID 的记录，并返回操作结果标志。 + if(flag>0){ // 如果操作成功（flag > 0）。 + return Result.ok(); // 返回成功的 Result 对象。 + }else{ // 如果操作失败（flag <= 0）。 + return Result.fail(); // 返回失败的 Result 对象。 + } + } + + @PostMapping("update") // 映射 HTTP POST 请求到 update 方法，用于更新访问记录。 + public Result update(@RequestBody Visit visit){ // 从请求体中获取 Visit 对象。 + int flag = visitService.updateSelective(visit); // 调用 VisitService 的 updateSelective 方法更新访问记录，并返回操作结果标志。 + if(flag>0){ // 如果操作成功（flag > 0）。 + return Result.ok(); // 返回成功的 Result 对象。 + }else{ // 如果操作失败（flag <= 0）。 + return Result.fail(); // 返回失败的 Result 对象。 + } + } + + @GetMapping("detail") // 映射 HTTP GET 请求到 detail 方法，用于获取访问记录的详细信息。 + public Visit detail(Integer id){ // 从请求参数中获取访问记录的 ID。 + return visitService.detail(id); // 调用 VisitService 的 detail 方法获取指定 ID 的访问记录，并返回该记录。 + } + + @PostMapping("query") // 映射 HTTP POST 请求到 query 方法，用于查询访问记录。 + public Map query(@RequestBody Visit visit){ // 从请求体中获取 Visit 对象作为查询条件。 + PageInfo pageInfo = visitService.query(visit); // 调用 VisitService 的 query 方法查询符合条件的访问记录，并返回分页信息。 + pageInfo.getList().forEach(entity->{ // 遍历查询结果中的每条记录。 + Student detail = studentService.detail(entity.getStudentId()); // 根据学生 ID 获取学生的详细信息。 + entity.setStudent(detail); // 将学生详细信息设置到访问记录中。 + }); + return Result.ok(pageInfo); // 返回包含分页信息的成功的 Result 对象。 + } + +} \ No newline at end of file diff --git a/main/VisitMapper.java b/main/VisitMapper.java new file mode 100644 index 0000000..25ebc85 --- /dev/null +++ b/main/VisitMapper.java @@ -0,0 +1,24 @@ +package com.yanzhen.mapper; // 定义包名，表示该接口属于com.yanzhen.mapper包 + +import java.util.List; // 导入Java标准库中的List类 +import java.util.Map; // 导入Java标准库中的Map类 + +import com.yanzhen.entity.Visit; // 导入自定义的Visit实体类 + +public interface VisitMapper { // 定义一个名为VisitMapper的公共接口 + + public int create(Visit visit); // 定义一个创建访问记录的方法，返回值为int类型 + + public int delete(Integer id); // 定义一个删除访问记录的方法，参数为访问记录的ID，返回值为int类型 + + public int update(Visit visit); // 定义一个更新访问记录的方法，参数为Visit对象，返回值为int类型 + + public int updateSelective(Visit visit); // 定义一个选择性更新访问记录的方法，参数为Visit对象，返回值为int类型 + + public List query(Visit visit); // 定义一个查询访问记录的方法，参数为Visit对象，返回值为Visit对象的列表 + + public Visit detail(Integer id); // 定义一个获取访问记录详情的方法，参数为访问记录的ID，返回值为Visit对象 + + public int count(Visit visit); // 定义一个统计访问记录数量的方法，参数为Visit对象，返回值为int类型 + +} \ No newline at end of file diff --git a/main/VisitService来访管理.java b/main/VisitService来访管理.java new file mode 100644 index 0000000..0bac891 --- /dev/null +++ b/main/VisitService来访管理.java @@ -0,0 +1,59 @@ +package com.yanzhen.service; // 定义包名 + +import com.yanzhen.mapper.VisitMapper; // 导入VisitMapper接口 +import com.yanzhen.entity.Visit; // 导入Visit实体类 +import com.github.pagehelper.PageHelper; // 导入PageHelper分页工具类 +import com.github.pagehelper.PageInfo; // 导入PageInfo分页信息类 +import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的自动装配注解 +import org.springframework.stereotype.Service; // 导入Spring的服务层注解 +import org.springframework.util.StringUtils; // 导入Spring的工具类，用于字符串操作 + +@Service // 标注该类为服务层组件 +public class VisitService来访管理 { // 定义VisitService类 “来访管理----管理员/宿管员” + + @Autowired // 自动装配VisitMapper对象 + private VisitMapper visitMapper; + + public int create(Visit visit) { // 创建Visit记录的方法 + return visitMapper.create(visit); // 调用Mapper层的create方法 + } + + public int delete(String ids) { // 根据ID字符串批量删除Visit记录的方法 + String[] arr = ids.split(","); // 将ID字符串按逗号分割成数组 + int row = 0; // 初始化受影响行数为0 + for (String s : arr) { // 遍历ID数组 + if(!StringUtils.isEmpty(s)){ // 如果ID不为空 + visitMapper.delete(Integer.parseInt(s)); // 调用Mapper层的delete方法删除记录 + row++; // 受影响行数加1 + } + } + return row; // 返回受影响行数 + } + + public int delete(Integer id) { // 根据ID删除Visit记录的方法 + return visitMapper.delete(id); // 调用Mapper层的delete方法 + } + + public int update(Visit visit) { // 更新Visit记录的方法 + return visitMapper.update(visit); // 调用Mapper层的update方法 + } + + public int updateSelective(Visit visit) { // 选择性更新Visit记录的方法 + return visitMapper.updateSelective(visit); // 调用Mapper层的updateSelective方法 + } + + public PageInfo query(Visit visit) { // 查询Visit记录列表的方法 + if(visit != null && visit.getPage() != null){ // 如果查询条件和分页信息不为空 + PageHelper.startPage(visit.getPage(),visit.getLimit()); // 启动分页并设置分页参数 + } + return new PageInfo(visitMapper.query(visit)); // 调用Mapper层的query方法并封装成PageInfo对象返回 + } + + public Visit detail(Integer id) { // 根据ID获取Visit详情的方法 + return visitMapper.detail(id); // 调用Mapper层的detail方法 + } + + public int count(Visit visit) { // 统计Visit记录数量的方法 + return visitMapper.count(visit); // 调用Mapper层的count方法 + } +} \ No newline at end of file