p76jblgzq
/
test
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

上传

Browse Source
main
R 3 months ago
parent f0b960b318
commit cfba176670
55 changed files with 3553 additions and 4876 deletions
Show Stats Download Patch File Download Diff File

68
README.md
Unescape View File

@ -1,2 +1,68 @@
# test
系统角色分为：经理（管理员）和员工（普通用户）两种用户， 其中经理（管理员）具有查看所有预定、删除客房、查看员工、添加员工等功能权限 员工（普通用户）具有查看空房、客户预订、修改预订、删除预订、注册新客户等功能权限（任务自拟）
## 用户角色
| 用户 | 权限 |
| ------- | :----------------------------------------------- |
| 经理 | 增删改查客房，增删查员工信息，查看自己工资 |
| 员工2 | 查看空房，预定房间，删除预定，结账，查看自己工资 |
| 保洁员3 | 接受退房后客户的信息进行卫生打扫，查看自己工资 |
| | |
| 管理员 | 查看所有客房信息及收益信息，增删改查经理信息。 |
# 主要流程
1.经理设置客房状态并且设置每晚价格。
2.客户可以通过员工预定房间，或者自己预定房间，并且可以选择预定时间（包含钟点房）
3.当客户退房后，通知保洁员进行卫生打扫，保洁员确定卫生情况后，客房重新变为可预定，并且密码重新随机生成
5.老板可以设置经理，员工，保洁员的工资，根据业绩比例进行分配
# 主要实体
用户：用户id，账户名，密码，真实姓名，年龄，身份证号，权限，总绩效。
订单：订单id，房间id，用户id，开始时间，结束时间，总价格，当前状态(已付款，待付款，已入住，未入住，已取消)
房间：房间id，房间位置，房间价格，房间状态(0.停用，1.未预定，2.已预定，3.待清扫)，房间密码
配置：经理工资百分比，员工工资百分比，保洁员工资百分比，经理底薪，员工底薪，保洁员底薪
修改：
员工加手机号，房间加房间类型
个人信息管理（修改信息，头像修改）
经理：员工管理（增加删除员工），房间管理（增加，删除，修改为停用或未预定），订单查看；
员工：订房（1.显示房间列表->生成订单，填信息，），订单管理（付钱，修改房间，退房，取消订单，订单列表）
清洁工：查看待清扫房间列表，修改房间状态
管理员(人员管理（权限修改，密码重置），工资管理（修改），业绩（查看汇总，所有订单列表）)

122
jiudianmanage.sql
Unescape View File

@ -1,99 +1,85 @@
/*
Navicat Premium Data Transfer -- 由 Navicat 工具生成的数据库迁移脚本
Source Server : Mysql -- 源数据库配置别名
Source Server Type : MySQL -- 源数据库类型为 MySQL
Source Server Version : 80026 -- 源数据库版本（MySQL 8.0.26）
Source Host : localhost:3306 -- 源数据库地址（本地主机）和端口（3306）
Source Schema : jiudianmanage -- 源数据库名称（酒店管理系统数据库）
Navicat Premium Data Transfer
Target Server Type : MySQL -- 目标数据库类型
Target Server Version : 80026 -- 目标数据库版本
File Encoding : 65001 -- 文件编码为 UTF-8
Source Server : Mysql
Source Server Type : MySQL
Source Server Version : 80026
Source Host : localhost:3306
Source Schema : jiudianmanage
Date: 20/10/2021 18:46:26 -- 脚本生成时间
Target Server Type : MySQL
Target Server Version : 80026
File Encoding : 65001
Date: 20/10/2021 18:46:26
*/
-- 设置数据库字符集为 utf8mb4（支持 emoji 和所有 Unicode 字符）
SET NAMES utf8mb4;
-- 临时禁用外键约束（避免创建表时因依赖顺序报错，后续会重新启用）
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- 表结构：config（系统配置表）
-- 存储酒店管理系统的全局配置，如薪资标准、总营业额等
-- Table structure for config
-- ----------------------------
-- 若表已存在则删除（避免重复创建）
DROP TABLE IF EXISTS `config`;
-- 创建 config 表
CREATE TABLE `config` (
`id` int NOT NULL, -- 主键ID（配置记录唯一标识，通常仅1条记录）
`managesalary` double(10, 2) NULL DEFAULT NULL, -- 经理薪资（总长度10，小数点后2位）
`staffsalary` double(10, 2) NULL DEFAULT NULL, -- 普通员工薪资
`cleanerssalary` double(10, 2) NULL DEFAULT NULL, -- 清洁工薪资
`manage` double(10, 2) NULL DEFAULT NULL, -- 经理相关其他金额（如绩效、补贴）
`staff` double(10, 2) NULL DEFAULT NULL, -- 员工相关其他金额
`cleaner` double(10, 2) NULL DEFAULT NULL, -- 清洁工相关其他金额
`totalmoney` double(10, 2) NULL DEFAULT NULL, -- 酒店总营业额
`totalroom` double(10, 2) NULL DEFAULT NULL, -- 酒店总房间数（预留小数位，支持扩展）
PRIMARY KEY (`id`) USING BTREE -- 主键约束，使用 BTREE 索引
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic; -- 存储引擎为 InnoDB，字符集 utf8，行格式动态
`id` int NOT NULL,
`managesalary` double(10, 2) NULL DEFAULT NULL,
`staffsalary` double(10, 2) NULL DEFAULT NULL,
`cleanerssalary` double(10, 2) NULL DEFAULT NULL,
`manage` double(10, 2) NULL DEFAULT NULL,
`staff` double(10, 2) NULL DEFAULT NULL,
`cleaner` double(10, 2) NULL DEFAULT NULL,
`totalmoney` double(10, 2) NULL DEFAULT NULL,
`totalroom` double(10, 2) NULL DEFAULT NULL,
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- 表结构：order（订单表）
-- 存储客户入住订单信息，关联房间和操作用户
-- Table structure for order
-- ----------------------------
-- 若表已存在则删除
DROP TABLE IF EXISTS `order`;
-- 创建 order 表
CREATE TABLE `order` (
`orderid` int NOT NULL, -- 订单ID（主键，唯一标识订单）
`householdname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL, -- 客户姓名
`ID` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL, -- 客户身份证号
`starttime` datetime NULL DEFAULT NULL, -- 入住时间（日期时间类型）
`endtime` datetime NULL DEFAULT NULL, -- 退房时间（日期时间类型）
`money` double NULL DEFAULT NULL, -- 订单总金额
`state` int NULL DEFAULT NULL, -- 订单状态（如0-未支付、1-已支付、2-已取消）
`roomid` int NULL DEFAULT NULL, -- 关联房间ID（外键，对应 room 表的 roomid）
`userid` int NULL DEFAULT NULL, -- 关联用户ID（外键，对应 user 表的 userid，如创建订单的员工）
PRIMARY KEY (`orderid`) USING BTREE -- 主键约束
`orderid` int NOT NULL,
`householdname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`ID` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`starttime` datetime NULL DEFAULT NULL,
`endtime` datetime NULL DEFAULT NULL,
`money` double NULL DEFAULT NULL,
`state` int NULL DEFAULT NULL,
`roomid` int NULL DEFAULT NULL,
`userid` int NULL DEFAULT NULL,
PRIMARY KEY (`orderid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- 表结构：room（房间表）
-- 存储酒店房间的基础信息，如位置、价格、状态等
-- Table structure for room
-- ----------------------------
-- 若表已存在则删除
DROP TABLE IF EXISTS `room`;
-- 创建 room 表
CREATE TABLE `room` (
`roomid` int NOT NULL, -- 房间ID（主键，唯一标识房间）
`local` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL, -- 房间位置（如"3楼301室"）
`money` double NULL DEFAULT NULL, -- 房间单价（每晚价格）
`state` int NULL DEFAULT NULL, -- 房间状态（如0-空闲、1-已预订、2-已入住、3-待清洁）
`type` int NULL DEFAULT NULL, -- 房间类型（如0-单人间、1-双人间、2-套房）
PRIMARY KEY (`roomid`) USING BTREE -- 主键约束
`roomid` int NOT NULL,
`local` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`money` double NULL DEFAULT NULL,
`state` int NULL DEFAULT NULL,
`type` int NULL DEFAULT NULL,
PRIMARY KEY (`roomid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- 表结构：user（用户表）
-- 存储系统用户信息（员工、管理员等），含账号、权限等
-- Table structure for user
-- ----------------------------
-- 若表已存在则删除
DROP TABLE IF EXISTS `user`;
-- 创建 user 表
CREATE TABLE `user` (
`userid` int NOT NULL, -- 用户ID（主键，唯一标识用户）
`useraccount` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL, -- 登录账号
`password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL, -- 登录密码（通常加密存储）
`username` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL, -- 用户真实姓名
`age` int NULL DEFAULT NULL, -- 年龄
`power` int NULL DEFAULT NULL, -- 权限等级（如0-管理员、1-经理、2-普通员工）
`IDnumber` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL, -- 身份证号
`money` double NULL DEFAULT NULL, -- 员工薪资或账户余额
`photoUrl` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL, -- 头像图片路径
`phonenumber` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL, -- 联系电话
PRIMARY KEY (`userid`) USING BTREE -- 主键约束
`userid` int NOT NULL,
`useraccount` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`username` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`age` int NULL DEFAULT NULL,
`power` int NULL DEFAULT NULL,
`IDnumber` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`money` double NULL DEFAULT NULL,
`photoUrl` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`phonenumber` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
PRIMARY KEY (`userid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- 重新启用外键约束（确保表之间的关联关系生效）
SET FOREIGN_KEY_CHECKS = 1;
SET FOREIGN_KEY_CHECKS = 1;

15
src/main/java/com/jiudian/manage/config/CustomMVCConfiguration.java
Unescape View File

@ -1,5 +1,5 @@
package com.jiudian.manage.config;
// 导入Spring相关注解和类
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
@ -9,38 +9,27 @@ import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter
import java.nio.charset.Charset;
import java.util.List;
// 标记当前类为Spring配置类，用于定义Spring Bean和配置
//
@Configuration
// 自定义MVC配置类，继承WebMvcConfigurerAdapter以扩展Spring MVC的默认配置
// 注意：WebMvcConfigurerAdapter在Spring 5.0后已过时，推荐直接实现WebMvcConfigurer接口
public class CustomMVCConfiguration extends WebMvcConfigurerAdapter {
// 定义一个Bean，用于处理HTTP消息转换（主要是String类型响应）
@Bean
public HttpMessageConverter<String> responseBodyConverter() {
// 创建字符串HTTP消息转换器，并指定字符集为UTF-8，解决响应中文乱码问题
StringHttpMessageConverter converter = new StringHttpMessageConverter(
Charset.forName("UTF-8"));
return converter;
}
// 重写配置消息转换器的方法，用于注册自定义的消息转换器
@Override
public void configureMessageConverters(
List<HttpMessageConverter<?>> converters) {
// 调用父类方法，保留Spring MVC默认的消息转换器
super.configureMessageConverters(converters);
// 将自定义的字符串消息转换器添加到转换器列表中
converters.add(responseBodyConverter());
}
// 重写内容协商配置方法，用于配置请求内容协商策略
@Override
public void configureContentNegotiation(
ContentNegotiationConfigurer configurer) {
// 禁用路径扩展名作为内容协商的判断依据（例如禁用通过".json"".xml"后缀判断响应格式）
// 避免因路径后缀导致的请求格式解析问题
configurer.favorPathExtension(false);
}
}

71
src/main/java/com/jiudian/manage/controller/ConfigController.java
Unescape View File

@ -1,105 +1,64 @@
package com.jiudian.manage.controller;
// 定义包路径，属于酒店管理系统的控制层
package com.jiudian.manage.controller;
// 导入配置实体类
import com.jiudian.manage.model.Config;
// 导入配置服务接口
import com.jiudian.manage.service.ConfigService;
// 导入状态常量类
import com.jiudian.manage.until.State;
// 导入状态信号工具类（用于封装接口返回结果）
import com.jiudian.manage.until.StateSignal;
// 导入Spring自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
// 导入SpringMVC请求映射注解
import org.springframework.web.bind.annotation.RequestMapping;
// 导入请求参数注解
import org.springframework.web.bind.annotation.RequestParam;
// 导入REST风格控制器注解
import org.springframework.web.bind.annotation.RestController;
// 导入Map集合（用于返回接口结果）
import java.util.Map;
// 标识该类为REST风格控制器，所有方法返回值会自动转为JSON
//
@RestController
// 定义该控制器的基础请求路径，所有接口路径都以"/config"开头
@RequestMapping(value = "/config")
public class ConfigController {
// 自动注入ConfigService实例，用于调用业务层方法
@Autowired
ConfigService configService;
/**
* 获取系统配置信息的接口
* @return 包含配置信息的Map集合（封装了状态码、提示信息和配置数据）
*
* @return
*/
// 定义接口请求路径，完整路径为"/config/getConfig.do"
@RequestMapping(value = "/getConfig.do")
public Map getConfig(){
// 调用服务层方法获取配置信息
Config config = configService.get();
// 创建状态信号对象，用于封装返回结果
StateSignal signal = new StateSignal();
// 判断是否获取到配置信息
if(config!=null){
// 若获取成功，存入成功状态码
signal.put(State.SuccessCode);
// 存入成功提示信息
signal.put(State.SuccessMessage);
// 存入获取到的配置对象，键为"config"
signal.put("config",config);
}else {
// 若获取失败，存入错误状态码
signal.put(State.ErrorCode);
// 存入错误提示信息
signal.put(State.ErrorMessage);
}
// 返回封装好的结果Map
return signal.getResult();
}
/**
* 修改系统配置的接口
* @param managesalary 经理薪水百分比
* @param staffsalary 员工薪水百分比
* @param cleanerssalary 保洁员薪水百分比
* @param manage 经理底薪
* @param staff 员工底薪
* @param cleaner 保洁员底薪
* @param totalmoney 总营业额（可选参数，默认值为-1）
* @param totalroom 总卖出房数（可选参数，默认值为-1）
* @return 包含修改结果的Map集合（封装了状态码和提示信息）
* 修改配置
* @param managesalary 经理薪水百分比
* @param staffsalary 员工薪水百分比
* @param cleanerssalary 保洁员薪水百分比
* @param manage 经理底薪
* @param staff 员工底薪
* @param cleaner 保洁员底薪
* @param totalmoney 总营业额
* @param totalroom 总卖出房数
* @return
*/
// 定义接口请求路径，完整路径为"/config/updateConfig.do"
@RequestMapping(value = "/updateConfig.do")
public Map updateConfig(
@RequestParam double managesalary,
@RequestParam double staffsalary,
@RequestParam double cleanerssalary,
@RequestParam double manage,
@RequestParam double staff,
@RequestParam double cleaner,
@RequestParam(required = false,defaultValue = "-1") double totalmoney,
@RequestParam(required = false,defaultValue = "-1") double totalroom){
// 调用服务层方法执行修改操作，接收修改结果（布尔值）
public Map updateConfig(@RequestParam double managesalary,@RequestParam double staffsalary,@RequestParam double cleanerssalary,@RequestParam double manage,@RequestParam double staff,@RequestParam double cleaner,@RequestParam(required = false,defaultValue = "-1") double totalmoney,@RequestParam(required = false,defaultValue = "-1") double totalroom){
boolean update = configService.update(managesalary, staffsalary, cleanerssalary, manage, staff, cleaner, totalmoney, totalroom);
// 创建状态信号对象，用于封装返回结果
StateSignal signal = new StateSignal();
// 根据修改结果设置返回信息
if(update){
// 若修改成功，存入成功状态码
signal.put(State.SuccessCode);
// 存入成功提示信息
signal.put(State.SuccessMessage);
}else {
// 若修改失败，存入错误状态码
signal.put(State.ErrorCode);
// 存入错误提示信息
signal.put(State.ErrorMessage);
}
// 返回封装好的结果Map
return signal.getResult();
}
}

52
src/main/java/com/jiudian/manage/controller/FileController.java
Unescape View File

@ -16,64 +16,36 @@ import java.io.FileOutputStream;
import java.util.Map;
import java.util.Random;
import java.util.UUID;
//该控制器的主要功能：
//处理用户头像上传请求，路径为/upFile/upFilePhoto.do
//核心流程：
//生成唯一文件名（避免重复）
//定义文件存储路径（本地路径 + 数据库存储的相对路径）
//调用工具类上传文件到本地服务器
//调用用户服务更新数据库中的用户头像路径
//根据上传和数据库更新的结果，返回成功 / 失败的响应状态
// 标记为REST风格控制器，所有方法返回数据而非视图
@RestController
// 配置请求路径前缀，所有方法的请求路径都以"/upFile"开头
@RequestMapping(value = "/upFile")
public class FileController {
// 自动注入用户服务类，用于处理用户相关业务（此处主要用于更新用户头像路径）
@Autowired
UserService userService;
// 配置具体请求路径，处理用户头像上传请求
//z
@RequestMapping("/upFilePhoto.do")
// @RequestParam指定请求参数：file为上传的文件，userid为用户ID
public Map upFilePhoto(@RequestParam MultipartFile file, @RequestParam int userid) {
// 生成唯一文件名：UUID避免文件名重复 + 原始文件扩展名（保留文件类型）
String fileName = UUID.randomUUID().toString() + file.getOriginalFilename();
public Map upFilePhoto(@RequestParam MultipartFile file,@RequestParam int userid){
String fileName = UUID.randomUUID().toString()+file.getOriginalFilename();
// 本地文件存储路径（项目内的静态资源目录）
String filePath = ".\\src\\main\\resources\\static\\File\\";
// 数据库存储的相对路径（用于前端访问时拼接完整路径）
String RealfilePath = "File\\" + fileName;
// 调用用户服务，更新该用户的头像路径到数据库
String RealfilePath = "File"+"/"+fileName;
boolean photo = userService.photo(userid, RealfilePath);
// 标记文件上传是否成功
boolean uploadSuccess = false;
boolean b = false;
try {
// 调用文件工具类，将文件字节数据上传到指定路径
uploadSuccess = FileUtil.uploadFile(file.getBytes(), filePath, fileName);
b = FileUtil.uploadFile(file.getBytes(), filePath, fileName);
} catch (Exception e) {
// 捕获上传过程中的异常并打印堆栈信息
e.printStackTrace();
}
// 创建状态信号对象，用于封装响应结果
StateSignal signal = new StateSignal();
// 判断文件上传和数据库更新是否都成功
if (uploadSuccess && photo) {
// 都成功则返回成功状态码和消息
if(b&&photo){
signal.put(State.SuccessCode);
signal.put(State.SuccessMessage);
} else {
// 有一项失败则返回错误状态码和消息
}else {
signal.put(State.ErrorCode);
signal.put(State.ErrorMessage);
}
// 返回封装好的响应结果（Map格式）
return signal.getResult();
}
}
}

123
src/main/java/com/jiudian/manage/controller/OrderController.java
Unescape View File

@ -12,134 +12,91 @@ import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import java.util.Map;
//该控制器的主要功能：
//提供订单全生命周期的接口：添加、删除、修改状态、分页查询
//所有接口返回统一格式的响应结果（通过StateSignal封装状态码、提示信息及业务数据）
//依赖OrderServiceImpl处理具体业务逻辑，控制器层主要负责接收请求、参数传递和结果封装
//接口路径设计遵循 REST 风格，通过@RequestMapping指定具体访问路径，便于前端调用
// 标记为REST风格控制器，所有方法返回JSON数据而非视图
@RestController
// 配置请求路径前缀，所有订单相关接口路径都以"/order"开头
@RequestMapping(value = "/order")
public class OrderController {
// 自动注入订单服务实现类，用于处理订单相关业务逻辑
@Autowired
OrderServiceImpl orderService;
//
/**
* 添加订单接口
* 添加订单
* @param householdname 入住人姓名
* @param id 入住人身份证号
* @param starttime 入住开始时间
* @param endtime 入住结束时间
* @param roomid 房间ID（关联对应的房间）
* @param userid 用户ID（下单用户的ID）
* @return 包含操作结果的Map（状态码、提示信息）
* @param id 入住人身份证号
* @param starttime 开始时间
* @param endtime 结束时间
* @param roomid 房间id
* @param userid 用户id
* @return
*/
@RequestMapping("/addOrder.do")
public Map addOrder(
@RequestParam String householdname,
@RequestParam String id,
@RequestParam String starttime,
@RequestParam String endtime,
@RequestParam int roomid,
@RequestParam int userid
) {
// 调用订单服务添加订单，返回操作结果（成功/失败）
boolean isSuccess = orderService.addOrder(householdname, id, starttime, endtime, roomid, userid);
// 创建状态信号对象，用于封装响应结果
public Map addOrder(@RequestParam String householdname,@RequestParam String id,@RequestParam String starttime,@RequestParam String endtime,@RequestParam int roomid,@RequestParam int userid){
boolean b = orderService.addOrder(householdname, id, starttime, endtime, roomid, userid);
StateSignal signal = new StateSignal();
if (isSuccess) {
// 操作成功：添加成功状态码和提示信息
if(b){
signal.put(State.SuccessCode);
signal.put(State.SuccessMessage);
} else {
// 操作失败：添加错误状态码和提示信息
}else {
signal.put(State.ErrorCode);
signal.put(State.ErrorMessage);
}
// 返回封装好的响应结果（Map格式）
return signal.getResult();
return signal.getResult();
}
/**
* 删除订单接口（需管理员权限）
* @param orderid 要删除的订单ID
* @return 包含操作结果的Map（状态码、提示信息）
* 删除订单（管理员权限）
* @param orderid 订单id
* @return
*/
@RequestMapping("/delOrder.do")
public Map delOrder(@RequestParam int orderid) {
// 调用订单服务删除指定ID的订单，返回操作结果
boolean isSuccess = orderService.delOrder(orderid);
public Map delOrder(@RequestParam int orderid){
boolean b = orderService.delOrder(orderid);
StateSignal signal = new StateSignal();
if (isSuccess) {
if(b){
signal.put(State.SuccessCode);
signal.put(State.SuccessMessage);
} else {
}else {
signal.put(State.ErrorCode);
signal.put(State.ErrorMessage);
}
return signal.getResult();
return signal.getResult();
}
/**
* 修改订单状态接口
* @param orderid 要修改的订单ID
* @param state 新的状态码（如：已预订、已入住、已取消等）
* @return 包含操作结果的Map（状态码、提示信息）
* 修改订单的状态
* @param orderid 订单id
* @param state 状态码
* @return
*/
@RequestMapping("/updateOrderState.do")
public Map updateOrderState(@RequestParam int orderid, @RequestParam int state) {
// 调用订单服务更新指定订单的状态，返回操作结果
boolean isSuccess = orderService.updateOrderState(orderid, state);
public Map updateOrderState(@RequestParam int orderid,@RequestParam int state){
boolean b = orderService.updateOrderState(orderid, state);
StateSignal signal = new StateSignal();
if (isSuccess) {
if(b){
signal.put(State.SuccessCode);
signal.put(State.SuccessMessage);
} else {
}else {
signal.put(State.ErrorCode);
signal.put(State.ErrorMessage);
}
return signal.getResult();
return signal.getResult();
}
/**
* 获取所有订单（分页查询）
* @param pageNum 页码（第几页）
* @param pageSize 每页条数
* @return 包含订单列表和分页信息的Map
*/
@RequestMapping("/getAllOrder.do")
public Map getAllOrder(@RequestParam int pageNum, @RequestParam int pageSize) {
// 调用订单服务分页查询所有订单，返回订单列表
List<Order> orderList = orderService.getAllOrder(pageNum, pageSize);
public Map getAllOrder(@RequestParam int pageNum,@RequestParam int pageSize){
List<Order> allOrder = orderService.getAllOrder(pageNum, pageSize);
StateSignal signal = new StateSignal();
if (orderList != null) {
// 查询成功：添加状态信息、订单列表和分页参数
if(allOrder!=null){
signal.put(State.SuccessCode);
signal.put(State.SuccessMessage);
signal.put("List", orderList); // 订单列表数据
signal.put("pageNum", pageNum); // 当前页码
signal.put("pageSize", pageSize); // 每页条数
} else {
// 查询失败：添加错误状态信息
signal.put("List",allOrder);
signal.put("pageNum",pageNum);
signal.put("pageSize",pageSize);
}else {
signal.put(State.ErrorCode);
signal.put(State.ErrorMessage);
}
return signal.getResult();
return signal.getResult();
}
}
}

152
src/main/java/com/jiudian/manage/controller/RoomController.java
Unescape View File

@ -11,170 +11,82 @@ import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import java.util.Map;
//该控制器的主要功能：
//提供房间全生命周期的接口：添加、删除、更新、查询（按条件分页查询、按 ID 查询详情）
//接口设计特点：
//采用 REST 风格路径，统一前缀/room，便于前端识别和管理
//更新接口（updateRoom.do）支持部分字段更新，通过默认值区分是否需要更新该字段
//所有接口返回统一格式的响应结果（通过StateSignal封装状态码、提示信息及业务数据）
//核心职责：接收前端请求参数，调用RoomService处理业务逻辑，最终返回处理结果
// 标记为REST风格控制器，所有方法返回JSON数据而非视图
@RestController
// 配置请求路径前缀，所有房间相关接口路径都以"/room"开头
@RequestMapping(value = "/room")
public class RoomController {
// 自动注入房间服务接口，用于处理房间相关业务逻辑
@Autowired
RoomService roomService;
/**
* 添加房间接口
* @param local 房间位置（如：3楼301室）
* @param money 房间价格
* @param state 房间状态（如：0-空闲，1-已预订，2-已入住等）
* @param type 房间类型（如：1-单人间，2-双人间，3-套房等）
* @return 包含操作结果的Map（状态码、提示信息）
*/
@RequestMapping("/addRoom.do")
public Map addRoom(
@RequestParam String local,
@RequestParam double money,
@RequestParam int state,
@RequestParam int type
) {
// 调用房间服务添加房间，返回操作结果（成功/失败）
boolean isSuccess = roomService.addRoom(local, money, state, type);
// 创建状态信号对象，用于封装响应结果
public Map addRoom(@RequestParam String local,@RequestParam double money,@RequestParam int state,@RequestParam int type){
boolean b = roomService.addRoom(local, money, state, type);
StateSignal signal = new StateSignal();
if (isSuccess) {
// 操作成功：添加成功状态码和提示信息
if(b){
signal.put(State.SuccessCode);
signal.put(State.SuccessMessage);
} else {
// 操作失败：添加错误状态码和提示信息
}else {
signal.put(State.ErrorCode);
signal.put(State.ErrorMessage);
}
return signal.getResult();
return signal.getResult();
}
/**
* 删除房间接口
* @param roomid 要删除的房间ID
* @return 包含操作结果的Map（状态码、提示信息）
*/
@RequestMapping("/delRoom.do")
public Map delRoom(@RequestParam int roomid) {
// 调用房间服务删除指定ID的房间，返回操作结果
boolean isSuccess = roomService.delRoom(roomid);
public Map delRoom(@RequestParam int roomid){
boolean b = roomService.delRoom(roomid);
StateSignal signal = new StateSignal();
if (isSuccess) {
if(b){
signal.put(State.SuccessCode);
signal.put(State.SuccessMessage);
} else {
}else {
signal.put(State.ErrorCode);
signal.put(State.ErrorMessage);
}
return signal.getResult();
return signal.getResult();
}
/**
* 按状态和类型分页查询房间接口
* @param state 房间状态（查询条件）
* @param type 房间类型（查询条件）
* @param pageNum 页码（第几页）
* @param pageSize 每页条数
* @return 包含房间列表的Map（状态信息+房间数据）
*/
@RequestMapping("/getRoom.do")
public Map selectRoom(
@RequestParam int state,
@RequestParam int type,
@RequestParam int pageNum,
@RequestParam int pageSize
) {
// 调用房间服务按条件分页查询房间，返回房间列表
List<Room> roomList = roomService.getRoomByState(state, type, pageNum, pageSize);
public Map selectRoom(@RequestParam int state,@RequestParam int type,@RequestParam int pageNum,@RequestParam int pageSize){
List<Room> roomByState = roomService.getRoomByState(state, type,pageNum,pageSize);
StateSignal signal = new StateSignal();
if (roomList != null) {
// 查询成功：添加状态信息和房间列表数据
if(roomByState!=null){
signal.put(State.SuccessCode);
signal.put(State.SuccessMessage);
signal.put("List", roomList); // 房间列表
} else {
// 查询失败：添加错误状态信息
signal.put("List",roomByState);
}else {
signal.put(State.ErrorCode);
signal.put(State.ErrorMessage);
}
return signal.getResult();
return signal.getResult();
}
/**
* 更新房间信息接口（支持部分字段更新）
* @param roomid 要更新的房间ID（必传）
* @param local 房间位置（可选，默认"null"表示不更新）
* @param money 房间价格（可选，默认-1表示不更新）
* @param state 房间状态（可选，默认-1表示不更新）
* @param type 房间类型（可选，默认-1表示不更新）
* @return 包含操作结果的Map（状态码、提示信息）
*/
@RequestMapping("/updateRoom.do")
public Map updateRoom(
@RequestParam int roomid,
@RequestParam(required = false, defaultValue = "null") String local,
@RequestParam(required = false, defaultValue = "-1") double money,
@RequestParam(required = false, defaultValue = "-1") int state,
@RequestParam(required = false, defaultValue = "-1") int type
) {
// 调用房间服务更新房间信息，返回操作结果
boolean isSuccess = roomService.updateRoom(roomid, local, money, state, type);
public Map updateRoom(@RequestParam int roomid,@RequestParam(required = false,defaultValue = "null") String local,@RequestParam(required = false,defaultValue = "-1") double money,@RequestParam(required = false,defaultValue = "-1") int state,@RequestParam(required = false,defaultValue = "-1") int type){
boolean b = roomService.updateRoom(roomid, local, money, state, type);
StateSignal signal = new StateSignal();
if (isSuccess) {
if(b){
signal.put(State.SuccessCode);
signal.put(State.SuccessMessage);
} else {
}else {
signal.put(State.ErrorCode);
signal.put(State.ErrorMessage);
}
return signal.getResult();
return signal.getResult();
}
/**
* 根据ID查询房间详情接口
* @param roomid 房间ID
* @return 包含房间详情的Map（状态信息+房间对象）
*/
@RequestMapping("/getRoomById.do")
public Map getRoomById(@RequestParam int roomid) {
// 调用房间服务根据ID查询房间详情，返回房间对象
Room room = roomService.getRoomById(roomid);
public Map getRoomById(@RequestParam int roomid){
Room b = roomService.getRoomById(roomid);
StateSignal signal = new StateSignal();
if (room != null) {
// 查询成功：添加状态信息和房间详情
if(b!=null){
signal.put(State.SuccessCode);
signal.put(State.SuccessMessage);
signal.put("room", room); // 房间详情对象
} else {
// 查询失败：添加错误状态信息
signal.put("room",b);
}else {
signal.put(State.ErrorCode);
signal.put(State.ErrorMessage);
}
return signal.getResult();
return signal.getResult();
}
}
}

216
src/main/java/com/jiudian/manage/controller/UserController.java
Unescape View File

@ -16,256 +16,174 @@ import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.util.List;
import java.util.Map;
//该控制器的核心作用：
//覆盖用户全生命周期管理接口，包括登录（含验证码）、新增、修改、删除、查询（全量 / 按权限 / 按 ID），适配酒店系统的用户管理需求；
// 标记为REST风格控制器，所有接口返回JSON数据（非视图页面）
@RestController
// 配置请求路径前缀，所有用户相关接口的访问路径均以"/user"开头
@RequestMapping(value = "/user")
public class UserController {
// 自动注入用户服务实现类，依赖其处理用户相关的业务逻辑（如登录、增删改查）
@Autowired
UserServiceImpl userService;
/**
* 用户登录接口（已测试）
* @param useraccount 用户名（登录账号）
* @param password 密码
* @param icode 用户输入的验证码
* @param session HttpSession，用于获取服务器存储的验证码
* @return 包含登录结果的Map（状态码、提示信息、用户ID、用户权限）
* 登录(已测试)
* @param useraccount
* @param password
* @return
*/
@RequestMapping(value = "/login.do")
public Map login(
@RequestParam String useraccount,
@RequestParam String password,
@RequestParam String icode,
HttpSession session
){
// 创建状态信号对象，用于统一封装接口响应结果
public Map login(@RequestParam String useraccount, @RequestParam String password,@RequestParam String icode,HttpSession session){
StateSignal signal = new StateSignal();
// 从Session中获取服务器生成的验证码（ImageCode.CODENAME为验证码在Session中的存储键名）
String serverCode = (String) session.getAttribute(ImageCode.CODENAME);
// 打印日志，便于调试（服务器存储的验证码 vs 用户输入的验证码）
System.out.println("session: "+serverCode+" 实际"+icode);
// 第一步：校验验证码（注意：原代码"icode.equals(code)"存在笔误，应为"icode.equals(serverCode)"）
if(icode != null && serverCode != null && icode.equals(serverCode)){
// 第二步：验证码正确，调用服务层验证账号密码
// 返回值为int数组：index0=用户ID，index1=用户权限（如0-普通用户，1-管理员）
int[] loginResult = userService.login(useraccount, password);
// 第三步：判断账号密码验证结果
if(loginResult != null){
// 登录成功：封装成功状态、用户ID、用户权限
String code = (String) session.getAttribute(ImageCode.CODENAME);
System.out.println("session: "+code+" 实际"+icode);
if(icode!=null&&code!=null&&icode.equals(code)){
int[] login = userService.login(useraccount, password);
if(login!=null){
signal.put(State.SuccessCode);
signal.put(State.SuccessMessage);
signal.put("userid", loginResult[0]);
signal.put("power", loginResult[1]);
signal.put("userid",login[0]);
signal.put("power",login[1]);
}else {
// 登录失败（账号或密码错误）：封装错误状态
signal.put(State.ErrorCode);
signal.put(State.ErrorMessage);
}
}else{
// 验证码错误：封装错误状态及自定义提示
signal.put(State.ErrorCode);
signal.put("message","验证码输入错误");
}
// 返回封装好的响应结果（Map格式，便于前端解析）
return signal.getResult();
}
/**
* 生成验证码图片接口
* @param code 预留参数（未实际使用）
* @param response HttpServletResponse，用于向客户端输出验证码图片
* @param session HttpSession，用于存储生成的验证码（供登录时校验）
* @throws IOException 图片生成或输出过程中可能抛出IO异常
*/
@GetMapping("/createImage")
public void createImage(
@RequestParam String code,
HttpServletResponse response,
HttpSession session
) throws IOException {
// 调用工具类生成验证码图片，同时将验证码存入Session
ImageCode.createImage(response, session);
public void createImage(@RequestParam String code, HttpServletResponse response, HttpSession session) throws IOException {
ImageCode.createImage(response,session);
}
/**
* 添加用户接口（已测试）
* @param useraccount 用户名（账号，需唯一）
* @param password 密码
* @param power 权限（字符串格式，需转为int，如"0"-普通用户，"1"-管理员）
* @return 包含添加结果的Map（状态码、提示信息）
* 添加用户(已测试)
* @param useraccount 用户名
* @param password 密码
* @param power 权限
* @return
*/
@RequestMapping(value = "/addUser.do")
public Map addUser(
@RequestParam String useraccount,
@RequestParam String password,
@RequestParam String power
){
// 调用服务层添加用户，将权限参数从String转为int
boolean isAddSuccess = userService.addUser(useraccount, password, Integer.parseInt(power));
public Map addUser(@RequestParam String useraccount, @RequestParam String password, @RequestParam String power){
boolean add = userService.addUser(useraccount,password,Integer.parseInt(power));
StateSignal signal = new StateSignal();
if(isAddSuccess){
// 添加成功：封装成功状态
if(add){
signal.put(State.SuccessCode);
signal.put(State.SuccessMessage);
}else {
// 添加失败（如用户名已存在）：封装错误状态
signal.put(State.ErrorCode);
signal.put(State.ErrorMessage);
}
return signal.getResult();
}
/**
* 修改用户信息接口（已测试，支持部分字段更新）
* @param userid 要修改的用户ID（必传，唯一标识用户）
* @param password 密码（可选，默认"null"表示不修改）
* @param username 用户名（可选，默认"null"表示不修改）
* @param age 年龄（可选，默认"-1"表示不修改）
* @param power 权限（可选，默认"-1"表示不修改）
* @param IDnumber 身份证号（可选，默认"null"表示不修改）
* @param phonenumber 手机号（可选，默认"null"表示不修改）
* @return 包含修改结果的Map（状态码、提示信息）
* 修改用户数据(已测试)
* @param userid
* @param password
* @param username
* @param age
* @param power
* @param IDnumber
* @return
*/
@RequestMapping(value = "/updateUser.do")
public Map updateUser(
@RequestParam int userid,
@RequestParam(required = false, defaultValue = "null") String password,
@RequestParam(required = false, defaultValue = "null") String username,
@RequestParam(required = false, defaultValue = "-1") int age,
@RequestParam(required = false, defaultValue = "-1") int power,
@RequestParam(required = false, defaultValue = "null") String IDnumber,
@RequestParam(required = false, defaultValue = "null") String phonenumber
){
// 调用服务层修改用户信息，传入所有参数（服务层内部判断是否更新对应字段）
boolean isUpdateSuccess = userService.alterUser(userid, password, username, age, power, IDnumber, phonenumber);
public Map updateUser(@RequestParam int userid,@RequestParam(required = false,defaultValue = "null") String password,@RequestParam(required = false,defaultValue = "null") String username,@RequestParam(required = false,defaultValue = "-1") int age,@RequestParam(required = false,defaultValue = "-1") int power,@RequestParam(required = false,defaultValue = "null") String IDnumber,@RequestParam(required = false,defaultValue = "null") String phonenumber){
boolean upd = userService.alterUser(userid, password, username, age, power, IDnumber,phonenumber);
StateSignal signal = new StateSignal();
if(isUpdateSuccess){
if(upd){
signal.put(State.SuccessCode);
signal.put(State.SuccessMessage);
}else {
signal.put(State.ErrorCode);
signal.put(State.ErrorMessage);
}
return signal.getResult();
}
/**
* 删除用户接口（已测试）
* @param userid 要删除的用户ID（必传）
* @return 包含删除结果的Map（状态码、提示信息）
* 删除用户(已测试)
* @param userid 用户id
* @return
*/
@RequestMapping(value = "/delUser.do")
public Map delUser(@RequestParam("userid") Integer userid){
// 调用服务层删除指定ID的用户
boolean isDelSuccess = userService.delUser(userid);
public Map delUser(@RequestParam("userid")Integer userid){
boolean del = userService.delUser(userid);
StateSignal signal = new StateSignal();
if(isDelSuccess){
if(del){
signal.put(State.SuccessCode);
signal.put(State.SuccessMessage);
}else {
signal.put(State.ErrorCode);
signal.put(State.ErrorMessage);
}
return signal.getResult();
}
/**
* 获取所有用户列表（分页查询，已测试）
* @param pageNum 页码（如1表示第一页）
* @param pageSize 每页条数（如10表示每页显示10条）
* @return 包含用户列表及分页信息的Map（状态码、提示信息、用户列表、页码、每页条数）
* 获取用户列表(已测试)
* @return
*/
@RequestMapping(value = "/getAllUser.do")
public Map getAllUser(@RequestParam int pageNum, @RequestParam int pageSize){
// 调用服务层分页查询所有用户
List<User> userList = userService.getAllUser(pageNum, pageSize);
public Map getAllUser(@RequestParam int pageNum,@RequestParam int pageSize){
List<User> allUser = userService.getAllUser(pageNum,pageSize);
StateSignal signal = new StateSignal();
if(userList != null){
// 查询成功：封装成功状态、用户列表、分页参数
if(allUser!=null){
signal.put(State.SuccessCode);
signal.put(State.SuccessMessage);
signal.put("List", userList);
signal.put("pageNum", pageNum);
signal.put("pageSize", pageSize);
signal.put("List",allUser);
signal.put("pageNum",pageNum);
signal.put("pageSize",pageSize);
}else {
// 查询失败（如无数据）：封装错误状态
signal.put(State.ErrorCode);
signal.put(State.ErrorMessage);
}
return signal.getResult();
return signal.getResult();
}
/**
* 按权限获取用户列表（分页查询）
* @param power 权限值（如0-普通用户，1-管理员）
* @param pageNum 页码
* @param pageSize 每页条数
* @return 包含指定权限用户列表及分页信息的Map
* 获取对应权限的用户列表
* @param power
* @return
*/
@RequestMapping(value = "/getUserByPower.do")
public Map getUserByPower(
@RequestParam int power,
@RequestParam int pageNum,
@RequestParam int pageSize
){
// 调用服务层按权限分页查询用户
List<User> userList = userService.getUserByPower(power, pageNum, pageSize);
public Map getUserByPower(@RequestParam int power,@RequestParam int pageNum,@RequestParam int pageSize){
List<User> Users = userService.getUserByPower(power,pageNum,pageSize);
StateSignal signal = new StateSignal();
if(userList != null){
if(Users!=null){
signal.put(State.SuccessCode);
signal.put(State.SuccessMessage);
signal.put("List", userList);
signal.put("pageNum", pageNum);
signal.put("pageSize", pageSize);
signal.put("List",Users);
signal.put("pageNum",pageNum);
signal.put("pageSize",pageSize);
}else {
signal.put(State.ErrorCode);
signal.put(State.ErrorMessage);
}
return signal.getResult();
return signal.getResult();
}
/**
* 根据用户ID获取用户详情
* @param userid 用户ID
* @return 包含用户详情的Map（状态码、提示信息、用户对象）
* 通过userid获取信息
* @param userid 用户id
* @return
*/
@RequestMapping(value = "/getUserById.do")
public Map getUserById(@RequestParam int userid){
// 调用服务层根据ID查询单个用户详情
User user = userService.selectUser(userid);
StateSignal signal = new StateSignal();
if(user != null){
// 查询成功：封装成功状态及用户详情对象
if(user!=null){
signal.put(State.SuccessCode);
signal.put(State.SuccessMessage);
signal.put("user", user);
signal.put("user",user);
}else {
// 查询失败（如用户不存在）：封装错误状态
signal.put(State.ErrorCode);
signal.put(State.ErrorMessage);
}
return signal.getResult();
return signal.getResult();
}
}
}

39
src/main/java/com/jiudian/manage/mapper/ConfigMapper.java
Unescape View File

@ -2,55 +2,18 @@ package com.jiudian.manage.mapper;
import com.jiudian.manage.model.Config;
import org.springframework.stereotype.Repository;
//该 Mapper 接口的核心作用：
//作为配置表（Config 表）与 Java 代码的交互桥梁，通过 MyBatis 实现配置数据的增删改查；
//通常用于管理酒店管理系统的全局配置项（如酒店名称、联系电话、默认房间价格、系统开关等），这些配置无需频繁修改，但需要持久化存储；
//与 Service 层协同：Service 层（如 ConfigService）会注入该 Mapper，调用其方法完成配置数据的数据库操作，再对外提供配置查询、修改等业务接口。
// 标记为Spring的仓库组件，用于将Mapper接口纳入Spring容器管理，避免注入时出现Bean找不到的问题
@Repository
// 配置表(Config)的Mapper接口，定义与数据库交互的抽象方法
// 作用：通过MyBatis框架，将接口方法与SQL语句关联，实现配置数据的CRUD操作
public interface ConfigMapper {
/**
* 根据主键(ID)删除配置表中的一条记录
* @param id 配置记录的主键ID
* @return 受影响的行数（1表示删除成功，0表示未找到对应记录）
*/
int deleteByPrimaryKey(Integer id);
/**
* 插入一条完整的配置记录（所有字段都需传入，包括可能为null的字段）
* @param record 封装了配置数据的Config对象
* @return 受影响的行数（1表示插入成功，0表示插入失败）
*/
int insert(Config record);
/**
* 插入一条配置记录（只插入非null的字段，null字段不参与SQL插入，使用数据库默认值）
* @param record 封装了配置数据的Config对象
* @return 受影响的行数（1表示插入成功，0表示插入失败）
*/
int insertSelective(Config record);
/**
* 根据主键(ID)查询配置表中的一条记录
* @param id 配置记录的主键ID
* @return 封装了查询结果的Config对象（若未找到则返回null）
*/
Config selectByPrimaryKey(Integer id);
/**
* 根据主键(ID)更新配置记录（只更新非null的字段，null字段不更新，保留原数据）
* @param record 封装了待更新数据的Config对象（需包含主键ID）
* @return 受影响的行数（1表示更新成功，0表示未找到对应记录）
*/
int updateByPrimaryKeySelective(Config record);
/**
* 根据主键(ID)更新配置记录（更新所有字段，包括null字段，会覆盖原数据）
* @param record 封装了待更新数据的Config对象（需包含主键ID）
* @return 受影响的行数（1表示更新成功，0表示未找到对应记录）
*/
int updateByPrimaryKey(Config record);
}

40
src/main/java/com/jiudian/manage/mapper/OrderMapper.java
Unescape View File

@ -4,58 +4,20 @@ import com.jiudian.manage.model.Order;
import org.springframework.stereotype.Repository;
import java.util.List;
//：是订单数据在 Java 代码与数据库之间的 “桥梁”，OrderService 层会注入该 Mapper，调用其方法完成订单的增删改查（如 OrderServiceImpl 的 addOrder 方法会调用 insertSelective 插入订单）
// 标记为Spring仓库组件，将该Mapper接口纳入Spring容器管理，解决Service层注入时的Bean依赖问题
@Repository
// 订单表(Order表)的Mapper接口，定义与数据库交互的抽象方法
// 作用：通过MyBatis框架关联SQL语句，实现订单数据的CRUD（增删改查）操作，是订单业务数据持久化的核心接口
public interface OrderMapper {
/**
* 根据订单主键ID删除一条订单记录
* @param orderid 订单的唯一标识（主键ID）
* @return 受影响的行数（1表示删除成功，0表示未找到对应订单）
*/
int deleteByPrimaryKey(Integer orderid);
/**
* 插入一条完整的订单记录（所有字段均需传入，即使字段为null也会参与SQL插入，可能覆盖数据库默认值）
* @param record 封装了订单完整数据的Order对象（如userid、roomid、入住时间等）
* @return 受影响的行数（1表示插入成功，0表示插入失败）
*/
int insert(Order record);
/**
* 插入一条订单记录（仅插入非null的字段，null字段不生成到SQL中，使用数据库默认值）
* @param record 封装了订单部分/完整数据的Order对象
* @return 受影响的行数（1表示插入成功，0表示插入失败）
*/
int insertSelective(Order record);
/**
* 根据订单主键ID查询单条订单详情
* @param orderid 订单的唯一标识（主键ID）
* @return 封装了订单详情的Order对象（如未找到对应订单则返回null）
*/
Order selectByPrimaryKey(Integer orderid);
/**
* 根据订单主键ID更新订单记录（仅更新非null的字段，null字段不更新，保留原数据）
* @param record 封装了待更新数据的Order对象（必须包含主键orderid）
* @return 受影响的行数（1表示更新成功，0表示未找到对应订单）
*/
int updateByPrimaryKeySelective(Order record);
/**
* 根据订单主键ID更新订单记录（更新所有字段，即使字段为null也会覆盖原数据）
* @param record 封装了待更新完整数据的Order对象（必须包含主键orderid）
* @return 受影响的行数（1表示更新成功，0表示未找到对应订单）
*/
int updateByPrimaryKey(Order record);
/**
* 查询所有订单记录（注意：方法名"getAllUser"可能为笔误，语义上应为"getAllOrder"，实际功能是查询全量订单）
* @return 所有订单的List集合（若无订单数据则返回空集合，非null）
*/
List<Order> getAllUser();
}

41
src/main/java/com/jiudian/manage/mapper/RoomMapper.java
Unescape View File

@ -5,58 +5,21 @@ import org.springframework.stereotype.Repository;
import java.util.List;
// 标记为Spring仓库组件，将该Mapper接口纳入Spring容器管理，确保Service层可正常注入使用
@Repository
// 房间表(Room表)的Mapper接口，定义与数据库交互的抽象方法
// 作用：通过MyBatis框架关联SQL语句，实现房间数据的CRUD（增删改查）操作，是房间业务数据持久化的核心接口
public interface RoomMapper {
/**
* 根据房间主键ID删除一条房间记录
* @param roomid 房间的唯一标识（主键ID）
* @return 受影响的行数（1表示删除成功，0表示未找到对应房间）
*/
int deleteByPrimaryKey(Integer roomid);
/**
* 插入一条完整的房间记录（所有字段均需传入，null字段会参与SQL插入，可能覆盖数据库默认值）
* @param record 封装了房间完整数据的Room对象（如位置、价格、状态、类型等）
* @return 受影响的行数（1表示插入成功，0表示插入失败）
*/
int insert(Room record);
/**
* 插入一条房间记录（仅插入非null的字段，null字段不生成到SQL中，使用数据库默认值）
* @param record 封装了房间部分/完整数据的Room对象
* @return 受影响的行数（1表示插入成功，0表示插入失败）
*/
int insertSelective(Room record);
/**
* 根据房间主键ID查询单条房间详情
* @param roomid 房间的唯一标识（主键ID）
* @return 封装了房间详情的Room对象（如未找到对应房间则返回null）
*/
Room selectByPrimaryKey(Integer roomid);
/**
* 根据房间主键ID更新房间记录（仅更新非null的字段，null字段不更新，保留原数据）
* @param record 封装了待更新数据的Room对象（必须包含主键roomid）
* @return 受影响的行数（1表示更新成功，0表示未找到对应房间）
*/
int updateByPrimaryKeySelective(Room record);
/**
* 根据房间主键ID更新房间记录（更新所有字段，即使字段为null也会覆盖原数据）
* @param record 封装了待更新完整数据的Room对象（必须包含主键roomid）
* @return 受影响的行数（1表示更新成功，0表示未找到对应房间）
*/
int updateByPrimaryKey(Room record);
/**
* 根据房间状态和类型查询房间列表
* @param stateType 封装了查询条件的Room对象（主要使用state字段-房间状态、type字段-房间类型）
* @return 符合条件的房间List集合（若无匹配房间则返回空集合，非null）
*/
List<Room> selectRoomByStateType(Room stateType);
}

49
src/main/java/com/jiudian/manage/mapper/UserMapper.java
Unescape View File

@ -4,72 +4,23 @@ import com.jiudian.manage.model.User;
import org.springframework.stereotype.Repository;
import java.util.List;
// 标记为Spring仓库组件，将该Mapper接口纳入Spring容器管理，避免Service层注入时出现Bean缺失问题
@Repository
// 用户表(User表)的Mapper接口，定义与数据库交互的抽象方法
// 作用：通过MyBatis框架关联SQL语句，实现用户数据的CRUD（增删改查）操作，是用户业务数据持久化的核心接口
public interface UserMapper {
/**
* 根据用户主键ID删除一条用户记录
* @param userid 用户的唯一标识（主键ID）
* @return 受影响的行数（1表示删除成功，0表示未找到对应用户）
*/
int deleteByPrimaryKey(Integer userid);
/**
* 插入一条完整的用户记录（所有字段均需传入，null字段会参与SQL插入，可能覆盖数据库默认值）
* @param record 封装了用户完整数据的User对象（如账号、密码、权限、手机号等）
* @return 受影响的行数（1表示插入成功，0表示插入失败）
*/
int insert(User record);
/**
* 插入一条用户记录（仅插入非null的字段，null字段不生成到SQL中，使用数据库默认值）
* @param record 封装了用户部分/完整数据的User对象
* @return 受影响的行数（1表示插入成功，0表示插入失败）
*/
int insertSelective(User record);
/**
* 根据用户主键ID查询单条用户详情
* @param userid 用户的唯一标识（主键ID）
* @return 封装了用户详情的User对象（如未找到对应用户则返回null）
*/
User selectByPrimaryKey(Integer userid);
/**
* 根据用户主键ID更新用户记录（仅更新非null的字段，null字段不更新，保留原数据）
* @param record 封装了待更新数据的User对象（必须包含主键userid）
* @return 受影响的行数（1表示更新成功，0表示未找到对应用户）
*/
int updateByPrimaryKeySelective(User record);
/**
* 根据用户主键ID更新用户记录（更新所有字段，即使字段为null也会覆盖原数据）
* @param record 封装了待更新完整数据的User对象（必须包含主键userid）
* @return 受影响的行数（1表示更新成功，0表示未找到对应用户）
*/
int updateByPrimaryKey(User record);
/**
* 查询所有用户记录
* @return 所有用户的List集合（若无用户数据则返回空集合，非null）
*/
List<User> getAllUser();
/**
* 根据用户权限查询用户列表
* @param power 权限值（如0-普通用户，1-管理员）
* @return 符合该权限的用户List集合（若无匹配用户则返回空集合，非null）
*/
List<User> selectByPower(Integer power);
/**
* 根据用户账号（useraccount）查询单个用户
* @param useraccount 用户登录账号（需唯一）
* @return 匹配账号的User对象（用于登录时校验账号是否存在，无匹配则返回null）
*/
User selectByAccount(String useraccount);
}

33
src/main/java/com/jiudian/manage/model/Config.java
Unescape View File

@ -1,125 +1,92 @@
package com.jiudian.manage.model;
// 该包用于存放系统的数据模型类，对应数据库表结构
/**
* 系统配置信息模型类
* 对应数据库中的config表，用于存储酒店管理系统的全局配置参数
* 如人员薪资标准、人员数量统计、总营收、总房间数等
*/
public class Config {
// 配置记录的唯一标识（主键），自增整数类型
private Integer id;
// 管理人员的薪资标准（例如：管理员月薪，单位：元）
private Double managesalary;
// 普通员工的薪资标准（例如：前台员工月薪，单位：元）
private Double staffsalary;
// 保洁人员的薪资标准（例如：保洁员月薪，单位：元）
private Double cleanerssalary;
// 管理人员的总数量（系统中登记的管理员人数）
private Double manage;
// 普通员工的总数量（系统中登记的普通员工人数）
private Double staff;
// 保洁人员的总数量（系统中登记的保洁员人数）
private Double cleaner;
// 酒店累计的总营收金额（所有订单收入总和，单位：元）
private Double totalmoney;
// 酒店拥有的总房间数量（所有类型房间的总和）
private Double totalroom;
// 获取id字段值的方法
public Integer getId() {
return id;
}
// 设置id字段值的方法
public void setId(Integer id) {
this.id = id;
}
// 获取管理人员薪资标准的方法
public Double getManagesalary() {
return managesalary;
}
// 设置管理人员薪资标准的方法
public void setManagesalary(Double managesalary) {
this.managesalary = managesalary;
}
// 获取普通员工薪资标准的方法
public Double getStaffsalary() {
return staffsalary;
}
// 设置普通员工薪资标准的方法
public void setStaffsalary(Double staffsalary) {
this.staffsalary = staffsalary;
}
// 获取保洁人员薪资标准的方法
public Double getCleanerssalary() {
return cleanerssalary;
}
// 设置保洁人员薪资标准的方法
public void setCleanerssalary(Double cleanerssalary) {
this.cleanerssalary = cleanerssalary;
}
// 获取管理人员数量的方法
public Double getManage() {
return manage;
}
// 设置管理人员数量的方法
public void setManage(Double manage) {
this.manage = manage;
}
// 获取普通员工数量的方法
public Double getStaff() {
return staff;
}
// 设置普通员工数量的方法
public void setStaff(Double staff) {
this.staff = staff;
}
// 获取保洁人员数量的方法
public Double getCleaner() {
return cleaner;
}
// 设置保洁人员数量的方法
public void setCleaner(Double cleaner) {
this.cleaner = cleaner;
}
// 获取酒店总营收的方法
public Double getTotalmoney() {
return totalmoney;
}
// 设置酒店总营收的方法
public void setTotalmoney(Double totalmoney) {
this.totalmoney = totalmoney;
}
// 获取酒店总房间数的方法
public Double getTotalroom() {
return totalroom;
}
// 设置酒店总房间数的方法
public void setTotalroom(Double totalroom) {
this.totalroom = totalroom;
}

44
src/main/java/com/jiudian/manage/model/Order.java
Unescape View File

@ -1,114 +1,94 @@
package com.jiudian.manage.model; // 定义该类所在import java.util.Date; // 导入日期类，用于处理订单的时间字段
package com.jiudian.manage.model;
import java.util.Date;
/**
* 订单实体类，对应数据库中的order表
* 用于封装酒店订单的所有信息，是订单数据在系统中流转的载体
*/
public class Order {
private Integer orderid; // 订单ID（主键，自增），唯一标识一条订单记录
private Integer orderid;
private String householdname; // 入住人姓名（预订房间的实际入住者姓名）
private String householdname;
private String id; // 入住人身份证号（用于身份核验，字符串类型适配18位身份证）
private String id;
private Date starttime; // 入住开始时间（订单的生效起始时间）
private Date starttime;
private Date endtime; // 入住结束时间（订单的生效截止时间）
private Date endtime;
private Double money; // 订单金额（该订单的总费用，单位：元）
private Double money;
private Integer state; // 订单状态（用数字标识：如0-已预订、1-已入住、2-已取消、3-已完成等）
private Integer state;
private Integer roomid; // 关联的房间ID（外键，关联room表的roomid，标识该订单对应的房间）
private Integer roomid;
private Integer userid; // 关联的用户ID（外键，关联user表的userid，标识下单的用户）
private Integer userid;
// 获取订单ID
public Integer getOrderid() {
return orderid;
}
// 设置订单ID（通常由数据库自增生成，前端无需传递）
public void setOrderid(Integer orderid) {
this.orderid = orderid;
}
// 获取入住人姓名
public String getHouseholdname() {
return householdname;
}
// 设置入住人姓名，自动去除字符串前后空格，避免无效空格影响数据准确性
public void setHouseholdname(String householdname) {
this.householdname = householdname == null ? null : householdname.trim();
}
// 获取入住人身份证号
public String getId() {
return id;
}
// 设置入住人身份证号，自动去除前后空格
public void setId(String id) {
this.id = id == null ? null : id.trim();
}
// 获取入住开始时间
public Date getStarttime() {
return starttime;
}
// 设置入住开始时间
public void setStarttime(Date starttime) {
this.starttime = starttime;
}
// 获取入住结束时间
public Date getEndtime() {
return endtime;
}
// 设置入住结束时间
public void setEndtime(Date endtime) {
this.endtime = endtime;
}
// 获取订单金额
public Double getMoney() {
return money;
}
// 设置订单金额（通常根据房间价格和入住时长计算得出）
public void setMoney(Double money) {
this.money = money;
}
// 获取订单状态
public Integer getState() {
return state;
}
// 设置订单状态（如用户取消订单时更新为"已取消"状态）
public void setState(Integer state) {
this.state = state;
}
// 获取关联的房间ID
public Integer getRoomid() {
return roomid;
}
// 设置关联的房间ID（下单时指定具体房间）
public void setRoomid(Integer roomid) {
this.roomid = roomid;
}
// 获取下单用户的ID
public Integer getUserid() {
return userid;
}
// 设置下单用户的ID（关联到具体的下单用户）
public void setUserid(Integer userid) {
this.userid = userid;
}

24
src/main/java/com/jiudian/manage/model/Room.java
Unescape View File

@ -1,66 +1,52 @@
package com.jiudian.manage.model;
/**
* 房间实体类，对应数据库中的room表
* 用于封装酒店房间的核心信息，是房间数据在系统各层流转的核心载体
*/
public class Room {
private Integer roomid; // 房间ID（主键，自增），唯一标识一间酒店房间
private Integer roomid;
private String local; // 房间位置（如"3楼301室"、"1楼豪华套房01"，描述房间的具体位置）
private String local;
private Double money; // 房间单价（单位：元/天，用于计算订单金额）
private Double money;
private Integer state; // 房间状态（数字标识：如0-空闲、1-已预订、2-已入住、3-维修中，控制房间是否可下单）
private Integer state;
private Integer type; // 房间类型（数字标识：如1-单人间、2-双人间、3-套房、4-亲子房，区分不同房型）
private Integer type;
// 获取房间ID（唯一标识，通常用于关联订单、查询房间详情）
public Integer getRoomid() {
return roomid;
}
// 设置房间ID（由数据库自增生成，前端无需手动传递）
public void setRoomid(Integer roomid) {
this.roomid = roomid;
}
// 获取房间位置
public String getLocal() {
return local;
}
// 设置房间位置，自动去除字符串前后空格（避免用户输入多余空格导致位置信息不规范）
public void setLocal(String local) {
this.local = local == null ? null : local.trim();
}
// 获取房间单价（用于订单创建时计算总费用：单价 × 入住天数）
public Double getMoney() {
return money;
}
// 设置房间单价（管理员可通过后台修改，如旺季调价）
public void setMoney(Double money) {
this.money = money;
}
// 获取房间状态（判断房间是否可预订的核心依据）
public Integer getState() {
return state;
}
// 设置房间状态（如订单创建后改"空闲"为"已预订"，退房后改"已入住"为"空闲"）
public void setState(Integer state) {
this.state = state;
}
// 获取房间类型（用于用户筛选房型，如"只看双人间"）
public Integer getType() {
return type;
}
// 设置房间类型（新增房间时指定，区分不同房型的服务与价格）
public void setType(Integer type) {
this.type = type;
}

44
src/main/java/com/jiudian/manage/model/User.java
Unescape View File

@ -1,126 +1,102 @@
package com.jiudian.manage.model;
/**
* 用户实体类，对应数据库中的user表
* 用于封装酒店管理系统中用户的所有核心信息，是用户数据在系统各层（Controller/Service/Mapper）流转的核心载体
*/
public class User {
private Integer userid; // 用户ID（主键，自增），唯一标识系统中的一个用户
private Integer userid;
private String useraccount; // 用户账号（登录时使用，需唯一，如手机号、自定义用户名）
private String useraccount;
private String password; // 用户密码（存储时通常会加密，登录时需解密或加密后对比）
private String password;
private String username; // 用户姓名（真实姓名，用于身份核验或订单信息展示）
private String username;
private Integer age; // 用户年龄（可选信息，用于用户画像或特定业务限制）
private Integer age;
private Integer power; // 用户权限（数字标识：如0-普通用户、1-管理员、2-员工，控制用户可操作的功能范围）
private Integer power;
private String idnumber; // 用户身份证号（用于身份验证，如预订房间时的实名登记）
private String idnumber;
private Double money; // 用户账户余额（可选，用于系统内支付、退款等资金相关操作）
private Double money;
private String photourl; // 用户头像URL（存储头像文件在服务器的相对路径，前端通过路径加载头像）
private String photourl;
private String phonenumber; // 用户手机号（用于联系用户、接收验证码或订单通知）
private String phonenumber;
// 获取用户ID（唯一标识，用于关联订单、更新用户信息等核心操作）
public Integer getUserid() {
return userid;
}
// 设置用户ID（由数据库自增生成，前端无需手动传递）
public void setUserid(Integer userid) {
this.userid = userid;
}
// 获取用户账号（登录时的核心凭证之一）
public String getUseraccount() {
return useraccount;
}
// 设置用户账号，自动去除前后空格（避免因多余空格导致账号登录失败）
public void setUseraccount(String useraccount) {
this.useraccount = useraccount == null ? null : useraccount.trim();
}
// 获取用户密码（注意：实际系统中需加密存储，此处仅为数据封装）
public String getPassword() {
return password;
}
// 设置用户密码，自动去除前后空格（避免密码中包含无效空格）
public void setPassword(String password) {
this.password = password == null ? null : password.trim();
}
// 获取用户姓名
public String getUsername() {
return username;
}
// 设置用户姓名，自动去除前后空格（规范姓名格式）
public void setUsername(String username) {
this.username = username == null ? null : username.trim();
}
// 获取用户年龄
public Integer getAge() {
return age;
}
// 设置用户年龄（通常由用户自主填写或系统根据身份证号解析）
public void setAge(Integer age) {
this.age = age;
}
// 获取用户权限（系统权限控制的核心依据，如管理员可删除订单，普通用户不可）
public Integer getPower() {
return power;
}
// 设置用户权限（由管理员分配，如新增管理员账号时设置power=1）
public void setPower(Integer power) {
this.power = power;
}
// 获取用户身份证号
public String getIdnumber() {
return idnumber;
}
// 设置用户身份证号，自动去除前后空格（确保身份证号格式准确，便于核验）
public void setIdnumber(String idnumber) {
this.idnumber = idnumber == null ? null : idnumber.trim();
}
// 获取用户账户余额（用于系统内支付相关业务）
public Double getMoney() {
return money;
}
// 设置用户账户余额（如充值、扣款后更新余额）
public void setMoney(Double money) {
this.money = money;
}
// 获取用户头像URL（前端通过该路径加载并展示用户头像）
public String getPhotourl() {
return photourl;
}
// 设置用户头像URL（用户上传头像后，存储服务器路径到该字段）
public void setPhotourl(String photourl) {
this.photourl = photourl == null ? null : photourl.trim();
}
// 获取用户手机号（用于发送订单通知、验证码等）
public String getPhonenumber() {
return phonenumber;
}
// 设置用户手机号，自动去除前后空格（确保手机号格式正确，避免无法接收短信）
public void setPhonenumber(String phonenumber) {
this.phonenumber = phonenumber == null ? null : phonenumber.trim();
}

54
src/main/java/com/jiudian/manage/service/impl/ConfigServiceImpl.java
Unescape View File

@ -6,75 +6,33 @@ import com.jiudian.manage.service.ConfigService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
// 标记为Spring的Service组件，纳入Spring容器管理，作为配置业务的具体实现类
@Service
// 实现ConfigService接口，重写接口定义的配置查询与更新方法
public class ConfigServiceImpl implements ConfigService {
// 自动注入ConfigMapper接口，通过Mapper与数据库交互，完成配置数据的CRUD
@Autowired
ConfigMapper configMapper;
/**
* 查询系统全局配置（默认查询主键ID为1的配置记录）
* 说明：系统通常只需要一套全局配置，故固定查询ID=1的记录，避免多配置记录混乱
* @return 封装了全局配置数据的Config对象（如薪资标准、人员数量、总营收等）
*/
@Override
public Config get() {
// 调用Mapper的按主键查询方法，获取ID=1的配置记录
return configMapper.selectByPrimaryKey(1);
}
/**
* 更新系统全局配置（支持部分字段更新）
* @param managesalary 管理人员薪资标准
* @param staffsalary 普通员工薪资标准
* @param cleanerssalary 保洁人员薪资标准
* @param manage 管理人员数量
* @param staff 普通员工数量
* @param cleaner 保洁人员数量
* @param totalmoney 酒店总营收（-1表示不更新该字段）
* @param totalroom 酒店总房间数（-1表示不更新该字段）
* @return 布尔值：true=更新成功，false=更新失败
*/
@Override
public boolean update(
double managesalary,
double staffsalary,
double cleanerssalary,
double manage,
double staff,
double cleaner,
double totalmoney,
double totalroom
) {
// 创建Config对象，封装待更新的配置数据
public boolean update(double managesalary, double staffsalary, double cleanerssalary, double manage, double staff, double cleaner, double totalmoney, double totalroom) {
Config config = new Config();
// 固定更新ID=1的配置记录（系统唯一全局配置）
config.setId(1);
// 设置必更新字段：薪资标准和人员数量（这两类配置通常需要同步更新）
config.setManagesalary(managesalary);
config.setStaffsalary(staffsalary);
config.setCleanerssalary(cleanerssalary);
config.setManage(manage);
config.setStaff(staff);
config.setCleaner(cleaner);
// 条件更新字段：总营收（仅当传入值≠-1时更新，避免覆盖无需修改的数据）
if(totalmoney != -1){
if(totalmoney!=-1){
config.setTotalmoney(totalmoney);
}
// 条件更新字段：总房间数（仅当传入值≠-1时更新）
if(totalroom != -1){
if(totalroom!=-1){
config.setTotalroom(totalroom);
}
// 调用Mapper的选择性更新方法（仅更新Config对象中非null的字段）
int affectedRows = configMapper.updateByPrimaryKeySelective(config);
// 根据受影响行数判断更新是否成功（>0表示有记录被修改，即更新成功）
return affectedRows > 0 ? true : false;
int i = configMapper.updateByPrimaryKeySelective(config);
return i>0?true:false;
}
}
}

162
src/main/java/com/jiudian/manage/service/impl/OrderServiceImpl.java
Unescape View File

@ -14,159 +14,101 @@ import org.springframework.stereotype.Service;
import java.util.List;
// 标记为Spring的Service组件，纳入容器管理，是订单业务逻辑的具体实现类
@Service
// 实现OrderService接口，重写接口定义的订单增删改查方法
public class OrderServiceImpl implements OrderService {
// 自动注入订单Mapper，用于订单表的数据库操作
@Autowired
OrderMapper orderMapper;
// 自动注入房间Mapper，用于关联操作房间表（如修改房间状态）
@Autowired
RoomMapper roomMapper;
// 自动注入配置Mapper，用于关联更新系统全局配置（如总营收、总订单数）
@Autowired
ConfigMapper configMapper;
/**
* 创建订单（核心业务：校验房间状态→计算订单金额→同步更新配置与房间状态）
* @param householdname 入住人姓名
* @param id 入住人身份证号
* @param starttime 入住开始时间（字符串格式，需转换为Date）
* @param endtime 入住结束时间（字符串格式，需转换为Date）
* @param roomid 关联的房间ID
* @param userid 下单用户ID
* @return 布尔值：true=创建成功，false=创建失败
*/
@Override
public boolean addOrder(
String householdname,
String id,
String starttime,
String endtime,
int roomid,
int userid
) {
// 1. 校验房间状态：查询指定房间，仅当房间状态为1（假设1=空闲）时允许下单
public boolean addOrder(String householdname, String id, String starttime, String endtime, int roomid, int userid) {
Room room = roomMapper.selectByPrimaryKey(roomid);
if (room.getState() != 1) { // 房间非空闲（如已预订、已入住），直接返回失败
if(room.getState()!=1){
return false;
}
// 2. 封装订单数据
Order order = new Order();
order.setHouseholdname(householdname); // 入住人姓名
order.setId(id); // 入住人身份证号
// 调用时间工具类，将字符串格式时间转换为Date类型（适配数据库时间字段）
order.setHouseholdname(householdname);
order.setId(id);
order.setStarttime(TimeUtil.formatterTime(starttime));
order.setEndtime(TimeUtil.formatterTime(endtime));
order.setRoomid(roomid); // 关联房间ID
order.setUserid(userid); // 关联下单用户ID
order.setState(0); // 设置订单初始状态（假设0=已预订）
// 3. 计算订单金额：入住天数 × 房间单价（调用工具类计算两个时间的天数差）
double orderMoney = TimeUtil.getBetweenDay(starttime, endtime) * room.getMoney();
order.setMoney(orderMoney);
order.setRoomid(roomid);
order.setUserid(userid);
order.setState(0);
double money = TimeUtil.getBetweenDay(starttime,endtime)*room.getMoney();
order.setMoney(money);
// 4. 更新系统全局配置：累加总订单数、总营收（操作Config表中id=1的全局配置）
Config config = configMapper.selectByPrimaryKey(1);
config.setTotalroom(config.getTotalroom() + 1); // 总订单数+1（字段名totalroom疑似笔误，应为totalOrder）
config.setTotalmoney(config.getTotalmoney() + orderMoney); // 总营收累加订单金额
configMapper.updateByPrimaryKeySelective(config); // 选择性更新配置（仅修改非null字段）
// 5. 插入订单数据到数据库
int insertCount = orderMapper.insertSelective(order);
if (insertCount > 0) { // 订单插入成功，继续更新房间状态
Room updateRoom = new Room();
updateRoom.setRoomid(roomid); // 指定要更新的房间ID
updateRoom.setState(2); // 修改房间状态为2（假设2=已预订，避免重复下单）
int roomUpdateCount = roomMapper.updateByPrimaryKeySelective(updateRoom);
// 房间状态更新成功，返回订单创建成功；否则返回失败
return roomUpdateCount > 0 ? true : false;
} else { // 订单插入失败，直接返回失败
config.setTotalroom(config.getTotalroom()+1);
config.setTotalmoney(config.getTotalmoney()+money);
configMapper.updateByPrimaryKeySelective(config);
int insert = orderMapper.insertSelective(order);
if(insert>0){
Room room1 = new Room();
room1.setRoomid(roomid);
room1.setState(2);
int i = roomMapper.updateByPrimaryKeySelective(room1);
if(i>0){
return true;
}else{
return false;
}
}else {
return false;
}
}
/**
* 删除订单（关联操作：删除订单前先恢复房间为空闲状态）
* @param orderid 要删除的订单ID
* @return 布尔值：true=删除成功，false=删除失败
*/
@Override
public boolean delOrder(int orderid) {
// 1. 根据订单ID查询订单详情，获取关联的房间ID
Order order = orderMapper.selectByPrimaryKey(orderid);
Integer roomid = order.getRoomid();
// 2. 先更新房间状态为1（空闲）：避免删除订单后房间仍处于占用状态
Room updateRoom = new Room();
updateRoom.setRoomid(roomid);
updateRoom.setState(1);
int roomUpdateCount = roomMapper.updateByPrimaryKeySelective(updateRoom);
// 3. 房间状态更新成功后，再删除订单
if (roomUpdateCount > 0) {
int deleteCount = orderMapper.deleteByPrimaryKey(orderid);
return deleteCount > 0 ? true : false; // 订单删除成功则返回true
Room room = new Room();
room.setRoomid(roomid);
room.setState(1);
int i = roomMapper.updateByPrimaryKeySelective(room);
if(i>0){
int i1 = orderMapper.deleteByPrimaryKey(orderid);
if(i1>0){
return true;
}
}
// 房间状态更新失败，直接返回删除失败
return false;
}
/**
* 更新订单状态（关联同步房间状态，确保订单与房间状态一致性）
* @param orderid 要更新的订单ID
* @param state 目标订单状态（数字标识，如2=已入住、3=已完成）
* @return 布尔值：true=更新成功，false=更新失败
*/
@Override
public boolean updateOrderState(int orderid, int state) {
// 1. 校验订单是否存在：根据ID查询订单，不存在则返回失败
Order order = orderMapper.selectByPrimaryKey(orderid);
if (order == null) {
if(order==null){
return false;
}
// 2. 获取订单关联的房间ID，准备同步更新房间状态
Integer roomid = order.getRoomid();
Room updateRoom = new Room();
updateRoom.setRoomid(roomid);
int roomUpdateCount = 1; // 初始化房间更新结果，默认成功（状态无需同步时用）
// 3. 根据订单目标状态，同步修改房间状态
if (state == 2) { // 假设订单状态2=已入住，对应房间状态3=已入住
updateRoom.setState(3);
roomUpdateCount = roomMapper.updateByPrimaryKeySelective(updateRoom);
Room room = new Room();
room.setRoomid(roomid);
int i = 1;
if(state==2){
room.setState(3);
i = roomMapper.updateByPrimaryKeySelective(room);
}
if (state == 3) { // 假设订单状态3=已完成（退房），对应房间状态1=空闲
updateRoom.setState(1);
roomUpdateCount = roomMapper.updateByPrimaryKeySelective(updateRoom);
if(state==3){
room.setState(1);
i = roomMapper.updateByPrimaryKeySelective(room);
}
// 4. 房间状态更新成功后，再更新订单状态
if (roomUpdateCount > 0) {
order.setState(state); // 设置订单新状态
int orderUpdateCount = orderMapper.updateByPrimaryKeySelective(order);
return orderUpdateCount > 0 ? true : false; // 订单状态更新成功则返回true
order.setState(state);
if(i>0){
int i1 = orderMapper.updateByPrimaryKeySelective(order);
if(i1>0){
return true;
}
}
// 房间状态更新失败，返回订单状态更新失败
return false;
}
/**
* 分页查询所有订单（使用PageHelper实现分页）
* @param pageNum 页码（第几页，从1开始）
* @param pageSize 每页条数（每页显示多少条订单）
* @return 分页后的订单列表（PageHelper自动处理分页逻辑）
*/
@Override
public List<Order> getAllOrder(int pageNum, int pageSize) {
// 1. 开启分页：PageHelper会自动拦截后续的查询SQL，添加分页条件（limit）
PageHelper.startPage(pageNum, pageSize);
// 2. 查询所有订单（注意：OrderMapper的getAllUser方法名疑似笔误，应为getAllOrder）
PageHelper.startPage(pageNum,pageSize);
return orderMapper.getAllUser();
}
}
}

127
src/main/java/com/jiudian/manage/service/impl/RoomServiceImpl.java
Unescape View File

@ -9,143 +9,72 @@ import org.springframework.stereotype.Service;
import java.util.List;
// 标记为Spring的Service组件，纳入容器管理，是房间业务逻辑的具体实现类
@Service
// 实现RoomService接口，重写接口定义的房间增删改查与状态管理方法
public class RoomServiceImpl implements RoomService {
// 自动注入房间Mapper，通过Mapper与数据库交互，完成房间数据的CRUD操作
@Autowired
RoomMapper roomMapper;
/**
* 新增房间（录入酒店新房间信息）
* @param local 房间位置（如"3楼302室"）
* @param money 房间单价（元/天）
* @param state 房间初始状态（如1=空闲、3=维修中）
* @param type 房间类型（如1=单人间、2=双人间）
* @return 布尔值：true=新增成功，false=新增失败
*/
@Override
public boolean addRoom(String local, double money, int state, int type) {
// 1. 封装房间数据到Room对象
Room room = new Room();
room.setLocal(local); // 设置房间位置
room.setMoney(money); // 设置房间单价
room.setState(state); // 设置初始状态
room.setType(type); // 设置房间类型
// 2. 调用Mapper的选择性插入方法（仅插入非null字段，适配初始值场景）
int insertCount = roomMapper.insertSelective(room);
// 3. 根据插入受影响行数判断是否成功（>0表示有记录插入）
return insertCount > 0 ? true : false;
room.setLocal(local);
room.setMoney(money);
room.setState(state);
room.setType(type);
int i = roomMapper.insertSelective(room);
return i>0?true:false;
}
/**
* 删除房间（从系统中移除指定房间）
* @param roomid 要删除的房间ID
* @return 布尔值：true=删除成功，false=删除失败（如房间不存在）
*/
@Override
public boolean delRoom(int roomid) {
// 1. 调用Mapper按主键删除房间
int deleteCount = roomMapper.deleteByPrimaryKey(roomid);
// 2. 根据删除受影响行数判断结果
return deleteCount > 0 ? true : false;
int i = roomMapper.deleteByPrimaryKey(roomid);
return i>0?true:false;
}
/**
* 更新房间信息（支持部分字段更新，非必传字段不修改）
* @param roomid 要更新的房间ID（必传，唯一标识房间）
* @param local 房间位置（"null"表示不更新）
* @param money 房间单价（-1表示不更新）
* @param state 房间状态（-1表示不更新）
* @param type 房间类型（-1表示不更新）
* @return 布尔值：true=更新成功，false=更新失败
*/
@Override
public boolean updateRoom(int roomid, String local, double money, int state, int type) {
// 1. 封装待更新数据（仅设置需要修改的字段）
Room room = new Room();
room.setRoomid(roomid); // 必传：指定更新的房间ID
// 条件设置字段：仅当参数非默认值时，才更新对应字段
if (!local.equals("null")) {
room.setLocal(local); // 更新房间位置
room.setRoomid(roomid);
if(!local.equals("null")){
room.setLocal(local);
}
if (money != -1) {
room.setMoney(money); // 更新房间单价
if(money!=-1){
room.setMoney(money);
}
if (state != -1) {
room.setState(state); // 更新房间状态
if(state!=-1){
room.setState(state);
}
if (type != -1) {
room.setType(type); // 更新房间类型
if(type!=-1){
room.setType(type);
}
// 2. 调用Mapper的选择性更新方法（仅更新Room对象中非null的字段）
int updateCount = roomMapper.updateByPrimaryKeySelective(room);
// 3. 根据更新受影响行数判断结果
return updateCount > 0 ? true : false;
int i = roomMapper.updateByPrimaryKeySelective(room);
return i>0?true:false;
}
/**
* 单独更新房间状态（简化状态修改流程，无需传递其他字段）
* @param roomid 要更新状态的房间ID
* @param state 目标状态（如1=空闲、2=已预订）
* @return 布尔值：true=状态更新成功，false=更新失败
*/
@Override
public boolean updateRoomState(int roomid, int state) {
// 1. 封装房间ID和目标状态
Room room = new Room();
room.setRoomid(roomid);
room.setState(state);
// 2. 调用选择性更新方法，仅修改状态字段
int updateCount = roomMapper.updateByPrimaryKeySelective(room);
// 3. 判断更新结果
return updateCount > 0 ? true : false;
int i = roomMapper.updateByPrimaryKeySelective(room);
return i>0?true:false;
}
/**
* 按状态和类型分页查询房间（支持多条件筛选+分页）
* @param state 房间状态（-1表示不筛选该条件）
* @param type 房间类型（-1表示不筛选该条件）
* @param pageNum 页码（第几页）
* @param pageSize 每页条数
* @return 分页后的房间列表（符合筛选条件）
*/
@Override
public List<Room> getRoomByState(int state, int type, int pageNum, int pageSize) {
// 1. 封装筛选条件（仅设置非-1的参数，避免筛选无效条件）
public List<Room> getRoomByState(int state, int type,int pageNum,int pageSize) {
Room room = new Room();
if (state != -1) {
room.setState(state); // 按状态筛选（如只查空闲房间）
if(state!=-1){
room.setState(state);
}
if (type != -1) {
room.setType(type); // 按类型筛选（如只查双人间）
if(type!=-1){
room.setType(type);
}
// 2. 开启分页：PageHelper自动拦截后续查询SQL，添加limit分页条件
PageHelper.startPage(pageNum, pageSize);
// 3. 调用Mapper按条件查询房间，返回分页后的列表
PageHelper.startPage(pageNum,pageSize);
return roomMapper.selectRoomByStateType(room);
}
/**
* 按ID查询单个房间详情（用于订单创建、房间信息展示）
* @param roomid 房间ID
* @return 房间详情对象（Room），不存在则返回null
*/
@Override
public Room getRoomById(int roomid) {
// 调用Mapper按主键查询房间详情
return roomMapper.selectByPrimaryKey(roomid);
}
}
}

187
src/main/java/com/jiudian/manage/service/impl/UserServiceImpl.java
Unescape View File

@ -10,206 +10,97 @@ import org.springframework.stereotype.Service;
import java.util.List;
// 标记为Spring的Service组件，纳入容器管理，是用户业务逻辑的具体实现类
@Service
// 实现UserService接口，重写接口定义的用户管理、登录、头像更新等核心方法
public class UserServiceImpl implements UserService {
// 自动注入用户Mapper，通过Mapper与数据库交互，完成用户数据的CRUD操作
@Autowired
UserMapper userMapper;
/**
* 根据用户ID查询单个用户详情（用于个人信息展示、权限校验）
* @param userid 用户ID（主键）
* @return 封装用户详情的User对象，不存在则返回null
*/
@Override
public User selectUser(int userid) {
// 调用Mapper按主键查询用户，直接返回结果
return userMapper.selectByPrimaryKey(userid);
}
/**
* 新增用户（用于管理员创建系统账号，如新增员工、管理员账号）
* @param account 用户账号（登录用，需唯一）
* @param password 用户密码（初始密码，后续可修改）
* @param power 用户权限（如0=普通用户、1=管理员）
* @return 布尔值：true=新增成功，false=新增失败（如账号已存在）
*/
public boolean addUser(String account, String password, int power) {
// 1. 封装用户基础数据
public boolean addUser(String account, String password, int power){
User user = new User();
user.setUseraccount(account); // 设置登录账号
user.setPassword(password); // 设置初始密码（注意：实际系统需加密存储）
user.setPower(power); // 设置用户权限
// 2. 生成短UUID作为默认身份证号（避免字段为空，后续用户可自行修改）
user.setUseraccount(account);
user.setPassword(password);
user.setPower(power);
user.setIdnumber(UUIDUtil.generateShortUuid());
// 3. 调用Mapper选择性插入用户（仅插入非null字段）
int insertCount = userMapper.insertSelective(user);
// 4. 根据插入受影响行数判断是否成功
return insertCount > 0 ? true : false;
int insert = userMapper.insertSelective(user);
return insert>0?true:false;
}
/**
* 删除用户（管理员权限，从系统中移除指定用户）
* @param userid 要删除的用户ID
* @return 布尔值：true=删除成功，false=删除失败（如用户不存在）
*/
@Override
public boolean delUser(int userid) {
// 1. 调用Mapper按主键删除用户
int deleteCount = userMapper.deleteByPrimaryKey(userid);
// 2. 根据删除受影响行数判断结果
return deleteCount > 0 ? true : false;
int i = userMapper.deleteByPrimaryKey(userid);
return i>0?true:false;
}
/**
* 修改用户信息（支持部分字段更新，非必传字段不修改）
* @param userid 要修改的用户ID（必传，唯一标识用户）
* @param password 新密码（"null"表示不更新）
* @param username 新姓名（"null"表示不更新）
* @param age 新年龄（-1表示不更新）
* @param power 新权限（-1表示不更新）
* @param IDnumber 新身份证号（"null"表示不更新）
* @param phonenumber 新手机号（"null"表示不更新）
* @return 布尔值：true=修改成功，false=修改失败
*/
@Override
public boolean alterUser(
int userid,
String password,
String username,
int age,
int power,
String IDnumber,
String phonenumber
) {
// 1. 封装待更新数据（仅设置非默认值的字段）
public boolean alterUser(int userid, String password, String username, int age, int power, String IDnumber,String phonenumber) {
User user = new User();
user.setUserid(userid); // 必传：指定修改的用户ID
// 条件设置字段：仅当参数非默认值时，才更新对应字段
if (!password.equals("null")) {
user.setPassword(password); // 更新密码
user.setUserid(userid);
if(!password.equals("null")){
user.setPassword(password);
}
if (!username.equals("null")) {
user.setUsername(username); // 更新姓名
if(!username.equals("null")){
user.setUsername(username);
}
if (age != -1) {
user.setAge(age); // 更新年龄
if(age!=-1){
user.setAge(age);
}
if (power != -1) {
user.setPower(power); // 更新权限（需管理员操作）
if(power!=-1){
user.setPower(power);
}
if (!IDnumber.equals("null")) {
user.setIdnumber(IDnumber); // 更新身份证号
if(!IDnumber.equals("null")){
user.setIdnumber(IDnumber);
}
if (!phonenumber.equals("null")) {
user.setPhonenumber(phonenumber); // 更新手机号
if(!phonenumber.equals("null")){
user.setPhonenumber(phonenumber);
}
// 2. 调用Mapper选择性更新用户（仅更新User对象中非null的字段）
int updateCount = userMapper.updateByPrimaryKeySelective(user);
// 3. 根据更新受影响行数判断结果
return updateCount > 0 ? true : false;
int i = userMapper.updateByPrimaryKeySelective(user);
return i>0?true:false;
}
/**
* 给用户账户充值（增加账户余额，用于系统内支付）
* @param userid 充值用户ID
* @param money 充值金额（单位：元）
* @return 布尔值：true=充值成功，false=充值失败
*/
@Override
public boolean addSlary(int userid, double money) {
// 1. 先查询用户当前余额（避免直接覆盖原有余额）
User user = userMapper.selectByPrimaryKey(userid);
Double currentMoney = user.getMoney();
// 2. 计算新余额：原有余额 + 充值金额
user.setMoney(money + currentMoney);
// 3. 调用Mapper全量更新用户（因需覆盖money字段，此处用全量更新而非选择性更新）
int updateCount = userMapper.updateByPrimaryKey(user);
// 4. 判断充值结果
return updateCount > 0 ? true : false;
Double money1 = user.getMoney();
user.setMoney(money+money1);
int i = userMapper.updateByPrimaryKey(user);
return i>0?true:false;
}
/**
* 分页查询所有用户（管理员用于用户列表管理）
* @param pageNum 页码（第几页）
* @param pageSize 每页条数
* @return 分页后的用户列表
*/
@Override
public List<User> getAllUser(int pageNum, int pageSize) {
// 1. 开启分页：PageHelper自动拦截后续查询SQL，添加limit分页条件
PageHelper.startPage(pageNum, pageSize);
// 2. 调用Mapper查询所有用户，返回分页列表
public List<User> getAllUser(int pageNum,int pageSize) {
PageHelper.startPage(pageNum,pageSize);
return userMapper.getAllUser();
}
/**
* 按权限分页查询用户（如查询所有管理员、所有普通用户）
* @param power 目标权限（如0=普通用户、1=管理员）
* @param pageNum 页码
* @param pageSize 每页条数
* @return 分页后的指定权限用户列表
*/
@Override
public List<User> getUserByPower(int power, int pageNum, int pageSize) {
// 1. 开启分页
PageHelper.startPage(pageNum, pageSize);
// 2. 调用Mapper按权限查询用户，返回分页列表
public List<User> getUserByPower(int power,int pageNum,int pageSize) {
PageHelper.startPage(pageNum,pageSize);
return userMapper.selectByPower(power);
}
/**
* 用户登录校验（验证账号密码，返回用户ID和权限）
* @param username 登录账号（对应useraccount字段）
* @param password 登录密码
* @return int数组：index0=用户ID，index1=用户权限；验证失败返回null
*/
@Override
public int[] login(String username, String password) {
// 1. 根据账号查询用户（账号唯一，仅返回一个用户）
User user = userMapper.selectByAccount(username);
// 2. 校验用户是否存在且密码匹配（注意：实际系统需加密对比密码，此处为明文对比）
if (user != null && user.getPassword().equals(password)) {
// 3. 验证成功，返回用户ID和权限
return new int[]{user.getUserid(), user.getPower()};
} else {
// 4. 验证失败（账号不存在或密码错误），返回null
if(user!=null&&user.getPassword().equals(password)){
return new int[]{user.getUserid(),user.getPower()};
}else{
return null;
}
}
/**
* 更新用户头像路径（用户上传头像后，同步更新数据库中的头像URL）
* @param userid 头像所属用户ID
* @param url 头像在服务器的存储路径（相对路径，如"File/xxx.jpg"）
* @return 布尔值：true=更新成功，false=更新失败
*/
@Override
public boolean photo(int userid, String url) {
// 1. 封装用户ID和头像路径
User user = new User();
user.setUserid(userid);
user.setPhotourl(url);
int i = userMapper.updateByPrimaryKeySelective(user);
return i>0?true:false;
}
// 2. 调用Mapper选择性更新，仅修改头像路径字段
int updateCount = userMapper.updateByPrimaryKeySelective(user);
// 3. 判断更新结果
return updateCount > 0 ? true : false;
}
}
}

34
src/main/java/com/jiudian/manage/until/FileUtil.java
Unescape View File

@ -1,44 +1,18 @@
package com.jiudian.manage.until; // 工具类包，存放系统通用工具方法
package com.jiudian.manage.until;
import java.io.File;
import java.io.FileOutputStream;
/**
* 文件操作工具类
* 提供文件上传的通用方法，支撑系统中文件（如用户头像、凭证图片）的服务器存储功能
*/
public class FileUtil {
/**
* 上传文件到服务器指定路径
* @param file 待上传的文件字节数组（前端传递的文件会转为字节数组形式传输）
* @param filePath 服务器上的文件存储目录路径（如"D:/hotel_upload/avatar/"）
* @param fileName 上传后的文件名（建议包含唯一标识，避免文件名重复覆盖）
* @return 布尔值：true=上传成功，false=上传失败（实际逻辑中当前仅返回true，异常通过throws抛出）
* @throws Exception 抛出文件操作相关异常（如IO异常、权限异常），需调用方捕获处理
*/
public static boolean uploadFile(byte[] file, String filePath, String fileName) throws Exception {
// 1. 根据存储目录路径创建File对象
File targetFile = new File(filePath);
// 2. 判断存储目录是否存在，不存在则创建多级目录（mkdirs()支持创建嵌套目录，mkdir()不支持）
if (!targetFile.exists()) {
if(!targetFile.exists()){
targetFile.mkdirs();
}
// 3. 创建文件输出流，指定文件存储路径（目录路径 + 文件名）
FileOutputStream out = new FileOutputStream(filePath + fileName);
// 4. 将文件字节数组写入到输出流（即写入到服务器文件）
FileOutputStream out = new FileOutputStream(filePath+fileName);
out.write(file);
// 5. 刷新输出流，确保所有字节都被写入文件
out.flush();
// 6. 关闭输出流，释放IO资源（避免资源泄漏）
out.close();
// 7. 文件写入完成，返回上传成功
return true;
}
}
}

60
src/main/java/com/jiudian/manage/until/ImageCode.java
Unescape View File

@ -9,77 +9,33 @@ import java.io.IOException;
import java.io.OutputStream;
import java.util.Random;
/**
* 验证码生成工具类
* 用于生成图形验证码，支撑用户登录时的安全校验，防止恶意登录或自动化脚本攻击
*/
public class ImageCode {
// 验证码在HttpSession中的存储键名（固定值，登录时需通过该键名获取Session中的验证码）
public static final String CODENAME = "ImageCode";
/**
* 生成图形验证码并响应给前端，同时将验证码存入Session
* @param response HttpServletResponse，用于向前端输出验证码图片
* @param session HttpSession，用于存储生成的验证码（供登录时校验）
* @throws IOException 图片写入响应流时可能抛出IO异常，需调用方处理
*/
public static final String CODENAME="ImageCode";
public static void createImage(HttpServletResponse response, HttpSession session) throws IOException {
// 1. 创建 BufferedImage 对象（验证码图片载体）：宽80px、高30px，RGB色彩模式
BufferedImage image = new BufferedImage(80, 30, BufferedImage.TYPE_INT_RGB);
// 2. 获取 Graphics 对象（用于在图片上绘制内容：背景、验证码文字、干扰元素等）
Graphics g = image.getGraphics();
// 3. 创建随机数对象（用于生成随机颜色、干扰元素位置等，增强验证码安全性）
Random r = new Random();
// 4. 绘制验证码背景：随机颜色填充矩形（覆盖整个图片区域，宽80px、高20px）
g.setColor(new Color(r.nextInt(255), r.nextInt(255), r.nextInt(255)));
g.fillRect(0, 0, 80, 20);
// 5. 生成4位随机验证码（数字+大写字母组合）
//获取生成的验证码
String code = getNumber();
// 6. 将生成的验证码存入Session：键为CODENAME，值为验证码，供后续登录校验使用
//绑定验证码
session.setAttribute(CODENAME, code);
// 7. 设置验证码文字样式：无衬线字体、加粗、字号25px
g.setFont(new Font(Font.SANS_SERIF, Font.BOLD, 25));
// 8. 设置验证码文字颜色：随机RGB颜色（与背景色区分，确保清晰可见）
g.setColor(new Color(r.nextInt(255), r.nextInt(255), r.nextInt(255)));
// 9. 绘制验证码文字到图片：起始位置（x=5px，y=25px），避免文字超出图片边界
g.drawString(code, 5, 25);
// 10. 设置响应头：指定返回内容类型为image/jpeg（告诉前端这是图片数据）
//设置消息头
response.setContentType("image/jpeg");
// 11. 获取响应输出流，将验证码图片以jpeg格式写入流，响应给前端
OutputStream os = response.getOutputStream();
ImageIO.write(image, "jpeg", os);
}
/**
* 生成4位随机验证码（包含数字0-9和大写字母A-Z，增强验证码复杂度）
* @return 4位随机字符串（验证码内容）
*/
public static String getNumber() {
// 1. 定义验证码字符池：包含数字和大写字母，共36个字符
public static String getNumber(){
String str = "1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ";
// 2. 初始化验证码字符串（用于拼接最终结果）
String code = "";
// 3. 循环4次，每次从字符池中随机选取1个字符，组成4位验证码
for (int i = 0; i < 4; i++) {
// 生成0到str长度-1的随机索引（确保不越界）
int index = (int) (Math.random() * str.length());
// 根据索引获取字符，拼接到验证码中
code += str.charAt(index);
for(int i= 0;i<4;i++){
int index = (int)(Math.random()*str.length());
code+=str.charAt(index);
}
// 4. 返回生成的4位验证码
return code;
}
}

32
src/main/java/com/jiudian/manage/until/State.java
Unescape View File

@ -1,41 +1,23 @@
package com.jiudian.manage.until;
/**
* 系统统一状态枚举类
* 定义接口响应的标准状态码和提示信息，确保所有接口返回格式一致，简化前后端交互逻辑
*/
public enum State {
// 成功状态：code=0，message=成功（用于所有业务操作成功的响应，如订单创建成功、用户登录成功）
SuccessCode("code", "0"),
SuccessMessage("message", "成功"),
public enum State {
SuccessCode("code","0"),SuccessMessage("message","成功"),
ErrorCode("code","-1"),ErrorMessage("message","失败")
;
// 失败状态：code=-1，message=失败（用于所有业务操作失败的通用响应，如参数错误、数据库操作失败）
ErrorCode("code", "-1"),
ErrorMessage("message", "失败");
// 状态对应的键名（如"code"表示状态码的键，"message"表示提示信息的键）
public String name;
// 状态对应的键值（如"0"是成功状态码的值，"成功"是成功提示的值）
public String message;
/**
* 枚举构造方法（枚举的构造方法默认私有，仅在枚举内部创建实例时使用）
* @param name 状态键名（如"code"、"message"）
* @param message 状态键值（如"0"、"成功"）
*/
State(String name, String message) {
State(String name,String message) {
this.name = name;
this.message = message;
}
// 获取状态键名的getter方法（供外部访问枚举的name属性）
public String getName() {
return name;
}
// 获取状态键值的getter方法（供外部访问枚举的message属性）
public String getMessage() {
return message;
}
}
}

57
src/main/java/com/jiudian/manage/until/TimeUtil.java
Unescape View File

@ -6,71 +6,38 @@ import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
/**
* 时间工具类
* 提供日期格式转换、跨年份日期差计算功能，核心支撑酒店订单模块的入住天数统计与金额计算
*/
public class TimeUtil {
/**
* 计算两个日期之间的天数差（结果为 date2 - date1 的差值，支持跨年份计算）
* 示例：date1="2025-02-28"、date2="2025-03-02" → 返回2；date1="2024-12-30"、date2="2025-01-02" → 返回3
*
* @param date1 起始日期字符串（格式必须为 yyyy-MM-dd，如"2025-05-01"）
* @param date2 结束日期字符串（格式必须为 yyyy-MM-dd，如"2025-05-05"）
* @return 两个日期的天数差（若date2在date1之前，可能返回负数，需在业务层判断合理性）
* 获取两个时间段的天数从date2-date1
* @param date1
* @param date2
* @return
*/
public static int getBetweenDay(String date1, String date2) {
// 创建GregorianCalendar实例（日历工具类），用于处理日期的年、日字段计算
public static int getBetweenDay(String date1, String date2) {
Calendar d1 = new GregorianCalendar();
// 将起始日期字符串转为Date类型，设置到日历对象d1中
d1.setTime(formatterTime(date1));
// 创建结束日期对应的日历对象d2，同理设置日期
Calendar d2 = new GregorianCalendar();
d2.setTime(formatterTime(date2));
// 第一步：计算同一年份内的天数差（DAY_OF_YEAR 表示当前日期是当年的第几天）
int days = d2.get(Calendar.DAY_OF_YEAR) - d1.get(Calendar.DAY_OF_YEAR);
// 获取结束日期的年份，判断是否跨年份（起始年份 != 结束年份）
int endYear = d2.get(Calendar.YEAR);
if (d1.get(Calendar.YEAR) != endYear) {
// 跨年份时，循环累加起始年份到结束年份之间每一年的总天数
int y2 = d2.get(Calendar.YEAR);
if (d1.get(Calendar.YEAR) != y2) {
do {
// 累加当前起始年份的总天数（getActualMaximum(DAY_OF_YEAR) 可自动处理闰年，如2024年返回366）
days += d1.getActualMaximum(Calendar.DAY_OF_YEAR);
// 起始年份加1，继续计算下一年，直到起始年份等于结束年份
d1.add(Calendar.YEAR, 1);
} while (d1.get(Calendar.YEAR) != endYear);
} while (d1.get(Calendar.YEAR) != y2);
}
// 返回最终计算的天数差
return days;
}
/**
* 将字符串格式的日期转为Date类型（固定格式：yyyy-MM-dd）
* 解决前端传递的日期字符串与后端Date类型不兼容问题，统一日期格式标准
*
* @param date 日期字符串（格式必须为 yyyy-MM-dd，如"2025-05-01"；格式错误会打印异常栈并返回null）
* @return 转换后的Date对象（转换失败时返回null）
*/
public static Date formatterTime(String date) {
// 创建SimpleDateFormat实例，指定目标日期格式为 yyyy-MM-dd
public static Date formatterTime(String date){
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
// 初始化Date对象，用于接收转换结果
Date newDate = null;
Date newDate=null;
try {
// 尝试将字符串日期解析为Date类型
newDate = formatter.parse(date);
newDate= formatter.parse(date);
} catch (ParseException e) {
// 解析失败（如日期格式错误，如"2025/05/01"）时，打印异常栈，便于排查问题
e.printStackTrace();
}
// 返回转换后的Date对象（失败时为null）
return newDate;
}
}
}

33
src/main/java/com/jiudian/manage/until/UUIDUtil.java
Unescape View File

@ -2,17 +2,7 @@ package com.jiudian.manage.until;
import java.util.UUID;
/**
* UUID工具类
* 提供短UUID生成功能，解决原生UUID（36位）过长、不便于存储/展示的问题，
* 生成的8位短UUID兼顾唯一性与简洁性，适用于临时标识、默认字段值等场景
*/
public class UUIDUtil {
/**
* 短UUID字符池
* 包含26个小写字母、10个数字、26个大写字母，共62个字符，
* 用于将16进制的UUID片段映射为短字符，保证生成结果的多样性与唯一性
*/
public static String[] chars = new String[] { "a", "b", "c", "d", "e", "f",
"g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s",
"t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5",
@ -21,34 +11,17 @@ public class UUIDUtil {
"W", "X", "Y", "Z" };
/**
* 生成8位长度的短UUID
* 基于JDK原生UUID（32位无分隔符形式）压缩转换，确保全局唯一性，
* 相比原生UUID更简洁，适合存储（如用户默认身份证号）或界面展示
*
* @return 8位随机唯一字符串（示例：xY3a7B9z）
* 生成8位UUID
* @return 8位UUID
*/
public static String generateShortUuid() {
// 初始化StringBuffer，用于拼接最终的8位短UUID
StringBuffer shortBuffer = new StringBuffer();
// 1. 生成原生UUID（格式：xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx）
// 2. 调用replace("-", "")去除分隔符，得到32位纯字母数字字符串
String uuid = UUID.randomUUID().toString().replace("-", "");
// 循环8次，每次处理4位原生UUID片段，生成1位短字符，最终组成8位短UUID
for (int i = 0; i < 8; i++) {
// 截取4位字符串（如第1次取0-4位、第2次取4-8位，直至取完32位）
String str = uuid.substring(i * 4, i * 4 + 4);
// 将4位16进制字符串转为10进制整数（如"a1b2"转为十进制整数41394）
int x = Integer.parseInt(str, 16);
// 对62取余（0x3E为十六进制，对应十进制62，与chars数组长度一致），
// 通过余数获取chars数组的索引，取出对应字符拼接到shortBuffer
shortBuffer.append(chars[x % 0x3E]);
}
// 返回最终生成的8位短UUID
return shortBuffer.toString();
}
}
}

2
src/main/resources/mappers/OrderMapper.xml
Unescape View File

@ -33,7 +33,7 @@
where orderid = #{orderid,jdbcType=INTEGER}
</delete>
<insert id="insert" parameterType="com.jiudian.manage.model.Order" >
insert into orderlist (orderid, householdname, ID,
insert into orderlist (orderid, householdname, ID,
starttime, endtime, money,
state, roomid, userid
)

28
src/main/resources/static/css/footer.css
Unescape View File

@ -1,30 +1,26 @@
/* 底部区域整体样式 */
.bs-docs-footer {
padding-top: 25px; /* 顶部内边距25像素，控制内容与顶部边缘的距离 */
padding-bottom: 50px; /* 底部内边距50像素，控制内容与底部边缘的距离 */
height: 12rem; /* 固定高度为12rem（相对单位，适配不同屏幕字体大小） */
color: #99979c; /* 文本默认颜色为浅灰色（适用于普通文本如版权信息） */
text-align: center; /* 所有内容水平居中对齐 */
background-color: rgba(0,0,0,.8); /* 背景为80%透明度的黑色，形成深色半透明效果 */
padding-top: 25px;
padding-bottom: 50px;
height: 12rem;
color: #99979c;
text-align: center;
background-color: rgba(0,0,0,.8);
}
/* 底部链接列表容器样式 */
.bs-docs-footer-links {
padding-left: 0; /* 清除列表默认左内边距，避免整体偏右 */
margin-bottom: 20px; /* 列表底部外边距20像素，与下方内容保持间距 */
padding-left: 0;
margin-bottom: 20px;
}
/* 链接列表项样式 */
.bs-docs-footer-links li {
display: inline-block; /* 将列表项改为行内块级元素，实现横向排列 */
display: inline-block;
}
/* 底部链接样式 */
.bs-docs-footer a {
color: #fff; /* 链接文字设为白色，与深色背景形成对比，提升可读性 */
color: #fff;
}
/* 底部段落样式 */
.bs-docs-footer p {
margin-bottom: 0; /* 清除段落默认底部外边距，避免多余空白 */
margin-bottom: 0;
}

106
src/main/resources/static/css/index.css
Unescape View File

@ -1,105 +1,95 @@
/* 导航栏默认样式 */
.navbar-default{
transition: all 0.6s; /* 所有样式变化添加0.6秒过渡动画（如背景色、尺寸等） */
background-color: rgba(0,0,0,.7); /* 导航栏背景为70%透明度的黑色 */
border: 0; /* 去除默认边框 */
border-radius: 0; /* 去除默认圆角，改为直角 */
transition: all 0.6s;
background-color: rgba(0,0,0,.7);
border: 0;
border-radius: 0;
}
/* 头部文本样式 */
.header{
text-align: center; /* 文本水平居中 */
letter-spacing: 1rem; /* 字符间距为1rem（增强标题视觉效果） */
.header{
text-align: center;
letter-spacing: 1rem;
}
/* 导航栏基础样式 */
.navbar{
min-height: 5.4rem !important; /* 强制设置导航栏最小高度为5.4rem（覆盖默认样式） */
min-height: 5.4rem !important;
}
/* 大屏幕适配（宽度≥1000px时生效） */
@media screen and (min-width:1000px){
.nav-con{
padding: 0 12rem; /* 导航内容左右内边距为12rem，在宽屏上拉开两侧距离 */
}
.nav-con{
padding: 0 12rem;
}
/* 标签样式 */
}
label{
display: none; /* 隐藏label标签（可能用于表单，此处暂时不需要显示） */
display: none;
}
/* 登录框容器样式 */
.logindiv{
border: 1px solid white; /* 白色边框 */
padding: 0rem 3.5rem; /* 左右内边距3.5rem，上下0 */
height: 32rem; /* 固定高度32rem */
background: rgba(255,255,255,.9); /* 90%透明度的白色背景（半透明白底） */
position: relative; /* 相对定位，便于内部元素绝对定位 */
margin-top: 5rem; /* 顶部外边距5rem，与上方内容拉开距离 */
border: 1px solid white;
padding: 0rem 3.5rem;
height: 32rem;
background: rgba(255,255,255,.9);
position: relative;
margin-top: 5rem;
}
/* 登录框标题样式 */
.login-h{
border-bottom: 2px solid #337AB7; /* 底部2px蓝色边框（分割标题与内容） */
text-align: center; /* 标题居中 */
letter-spacing: 2.5px; /* 字符间距2.5px，增强标题感 */
border-bottom: 2px solid #337AB7;
text-align: center;
letter-spacing: 2.5px;
}
/* 登录表单样式 */
.login-f{
padding-top: 2rem !important; /* 强制设置表单顶部内边距2rem（覆盖默认样式） */
padding-top: 2rem !important;
}
/* 表单输入框基础样式 */
.forminput{
height: 4rem; /* 输入框高度4rem */
height: 4rem;
}
/* 页面主体区域样式 */
.main{
background: url('../img/pexels-photo-545049.jpg') no-repeat; /* 背景图，不重复 */
background-repeat:no-repeat; /* 重复声明不重复（冗余但增强兼容性） */
background-size: cover; /* 背景图覆盖整个区域（自适应尺寸） */
min-height: 40rem; /* 最小高度40rem，保证内容区域高度 */
background: url('../img/pexels-photo-545049.jpg') no-repeat;
background-repeat:no-repeat;
background-size: cover;
min-height: 40rem;
}
/* 文本输入框和密码输入框样式 */
input[type="text"],
input[type="password"]{
text-indent:2.3rem; /* 文本缩进2.3rem（给左侧图标留出空间） */
font-weight:normal; /* 字体常规粗细 */
color:black; /* 输入文本为黑色 */
background:url('../img/login-sprite.png') no-repeat white; /* 白色背景+左侧精灵图图标 */
background-position:3% 10%; /* 图标位置：水平3%，垂直10%（文本框图标位置） */
text-indent:2.3rem;
font-weight:normal;
color:black;
background:url('../img/login-sprite.png') no-repeat white;
background-position:3% 10%;
}
/* 密码输入框单独调整图标位置 */
input[type="password"]{
background-position:3% 90%; /* 图标位置：水平3%，垂直90%（密码框图标位置） */
background-position:3% 90%;
}
/* 验证码输入框图标位置 */
.inputcode{
background-position:3% 90% !important; /* 强制验证码框图标位置与密码框一致 */
background-position:3% 90% !important;
}
/* 验证码图片样式 */
.code{
height: 4rem; /* 高度4rem（与输入框对齐） */
width: 100%; /* 宽度占满父容器 */
border:1px solid #3D86ED; /* 蓝色边框 */
border-radius: 5px; /* 5px圆角 */
height: 4rem;
width: 100%;
border:1px solid #3D86ED;
border-radius: 5px;
}
/* 登录按钮默认样式 */
.loginbtn{
background: #419FD8; /* 按钮背景为浅蓝色 */
color: white; /* 文字白色 */
background: #419FD8;
color: white;
}
/* 登录按钮 hover 效果 */
.loginbtn:hover{
background: #5D89FA; /* 鼠标悬浮时背景变为深蓝色 */
color: white; /* 文字保持白色 */
background: #5D89FA;
color: white;
}

124
src/main/resources/static/css/myCenter.css
Unescape View File

@ -1,131 +1,117 @@
/* 导航栏默认样式 */
.navbar-default{
transition: all 0.6s; /* 所有样式变化添加0.6秒过渡动画（如交互状态变化） */
background-color: #219ED8; /* 导航栏背景色为亮蓝色 */
border: 0; /* 去除默认边框 */
border-radius: 0; /* 去除默认圆角，使用直角设计 */
transition: all 0.6s;
background-color: #219ED8;
border: 0;
border-radius: 0;
}
/* 头部文本样式 */
.header{
text-align: center; /* 文本水平居中对齐 */
letter-spacing: 1rem; /* 字符间距1rem，增强标题视觉效果 */
.header{
text-align: center;
letter-spacing: 1rem;
}
/* 导航栏基础尺寸 */
.navbar{
min-height: 5.4rem !important; /* 强制设置导航栏最小高度为5.4rem（覆盖默认样式） */
min-height: 5.4rem !important;
}
/* 大屏幕适配（宽度≥1000px时生效） */
@media screen and (min-width:1000px){
.nav-con{
padding: 0 12rem; /* 导航内容左右内边距12rem，在宽屏上扩展两侧空间 */
}
.nav-con{
padding: 0 12rem;
}
}
/* 标签元素样式 */
label{
display: none; /* 隐藏label标签（可能用于表单，此处暂不需要显示） */
display: none;
}
/* 导航栏链接文字样式 */
.navbar-default .navbar-nav>li>a {
color: white; /* 导航链接文字为白色（与蓝色背景对比） */
color: white;
}
/* 导航列表项间距 */
li.navli{
margin-right: 40px; /* 列表项右侧间距40px，拉开导航项距离 */
margin-right: 40px;
}
/* 导航栏切换按钮交互样式 */
.navbar-default .navbar-toggle:hover,.navbar-default .navbar-toggle:focus{
background: transparent; /* 鼠标悬浮/聚焦时按钮背景透明 */
background: transparent;
}
/* 导航栏切换按钮边框 */
.navbar-default .navbar-toggle {
border-color: white; /* 切换按钮边框为白色 */
border-color: white;
}
/* 导航栏切换按钮图标 */
.navbar-default .navbar-toggle .icon-bar {
background-color: white; /* 汉堡菜单图标为白色（与蓝色背景对比） */
background-color: white;
}
/* 导航下拉菜单激活状态 */
.navbar-default .navbar-nav>.open>a,
.navbar-default .navbar-nav>.open>a:focus,
.navbar-default .navbar-nav>.open>a:hover{
background: transparent; /* 激活状态背景透明 */
color: white; /* 文字保持白色 */
transition: all 0.6s; /* 过渡动画0.6秒 */
transform: scale(1.0,1.2); /* Y轴方向拉伸1.2倍（纵向放大效果） */
.navbar-default .navbar-nav>.open>a, .navbar-default .navbar-nav>.open>a:focus, .navbar-default .navbar-nav>.open>a:hover{
background: transparent;
color: white;
transition: all 0.6s;
transform: scale(1.0,1.2);
}
/* 导航链接内边距 */
.navbar-nav>li>a{
padding-top: 1.7rem; /* 链接顶部内边距1.7rem，调整垂直位置 */
padding-top: 1.7rem;
}
/* 导航链接悬浮效果 */
.navbar-default .navbar-nav>li>a:hover{
color: white; /* 悬浮时文字保持白色 */
transition: all 0.6s; /* 过渡动画0.6秒 */
color: white;
transition: all 0.6s;
}
/* 主体区域样式 */
.main{
margin-top: -20px; /* 顶部负外边距，抵消上方元素的默认间距 */
margin-top: -20px;
}
/* 清除内边距 */
.nopadding{
padding: 0; /* 移除元素所有内边距 */
padding: 0;
}
/* 侧边导航容器 */
.navlist{
min-height: 58rem; /* 最小高度58rem，保证侧边栏高度 */
background: #254552; /* 侧边栏背景色为深青灰色 */
min-height: 58rem;
background: #254552;
}
/* 侧边栏链接样式 */
a.list-group-item{
color: #C2D2CB; /* 链接文字为浅灰绿色 */
padding-left: 3rem; /* 左侧内边距3rem，文字右移留出图标空间 */
color: #C2D2CB;
padding-left: 3rem;
}
/* 侧边栏列表项基础样式 */
.list-group-item{
background-color:transparent; /* 背景透明（继承父容器深青灰色） */
color: #C2D2CB; /* 文字颜色为浅灰绿色 */
border:0; /* 去除边框 */
border-radius: 0; /* 去除圆角 */
background-color:transparent;
color: #C2D2CB;
border:0;
border-radius: 0;
}
/* 侧边栏列表项交互样式 */
.list-group-item:hover,.list-group-item:focus{
background-color:transparent !important; /* 悬浮/聚焦时背景保持透明（强制覆盖） */
color: #C2D2CB !important; /* 文字颜色保持不变（强制覆盖） */
background-color:transparent !important;
color: #C2D2CB !important;
}
/* 侧边栏列表项激活状态 */
.list-group-item.active,.list-group-item.active:hover{
background: #20343D !important; /* 激活项背景为更深的青灰色 */
color:white !important; /* 激活项文字为白色（强制覆盖） */
border: 0; /* 去除边框 */
background: #20343D !important;
color:white !important;
border: 0;
}
/* 图标间距 */
.glyphicon{
margin-right: 10px; /* 图标右侧间距10px，与文字拉开距离 */
margin-right: 10px;
}
/* 主内容框架 */
.mainFrame{
width: 100%; /* 宽度占满父容器 */
min-height: 60rem; /* 最小高度60rem，保证主内容区域高度 */
}
width: 100%;
min-height: 60rem;
}

43
src/main/resources/static/css/pages.css
Unescape View File

@ -1,41 +1,36 @@
/* 清除左右内边距 */
.nopadding{
padding-left: 0; /* 移除左侧内边距 */
padding-right: 0; /* 移除右侧内边距 */
padding-left: 0;
padding-right: 0;
}
/* 用户头像样式 */
.userpic{
width: 50%; /* 头像宽度为父容器的50%（自适应大小） */
border-radius: 50%; /* 圆形头像（圆角值为50%） */
border: 1px solid black; /* 1px黑色边框，突出头像轮廓 */
margin-left:25%; /* 左侧外边距25%，配合50%宽度实现水平居中 */
width: 50%;
border-radius: 50%;
border: 1px solid black;
margin-left:25%;
}
/* 用户名文本样式 */
.username{
text-align: center; /* 文本水平居中 */
margin-top: 20px; /* 顶部外边距20px，与头像保持距离 */
font-size: 1.7rem; /* 字体大小1.7rem（相对单位，适配不同屏幕） */
text-align: center;
margin-top: 20px;
font-size: 1.7rem;
}
/* 图标间距调整 */
.glyphicon{
margin-right: 0 ; /* 清除图标右侧默认间距（覆盖之前的10px设置） */
margin-right: 0;
}
/* 数据项容器样式 */
.fdata {
padding-left: 2%; /* 左侧内边距2%，内容稍向右移 */
width: 100%; /* 宽度占满父容器 */
margin: 0 auto; /* 水平居中（在父容器内） */
line-height: 3.2; /* 行高3.2倍，提升文本垂直间距 */
border-bottom: 2px solid #e6e6e6; /* 底部2px浅灰色边框，分隔数据项 */
overflow: hidden; /* 隐藏溢出内容（防止内部浮动元素影响布局） */
float: left; /* 左浮动，使多个数据项横向排列或紧凑布局 */
padding-left: 2%;
width: 100%;
margin: 0 auto;
line-height: 3.2;
border-bottom: 2px solid #e6e6e6;
overflow: hidden;
float: left;
}
/* 信息修改区域样式 */
.alterinfo{
margin-bottom: 20px !important; /* 强制设置底部外边距20px（覆盖其他样式），与下方内容分隔 */
margin-bottom: 20px !important;
}

155
src/main/resources/static/index.html
Unescape View File

@ -1,111 +1,84 @@
<!DOCTYPE html>
<html>
<head>
<title>酒店管理系统</title>
<!-- 设定页面字符编码为UTF-8，确保中文正常显示 -->
<meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
<!-- 移动端适配配置：设置视口宽度为设备宽度，初始缩放比例1，禁止用户手动缩放 -->
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<!-- 引入Bootstrap基础样式库，提供导航栏、表单、按钮等组件的默认样式 -->
<link rel="stylesheet" type="text/css" href="css/bootstrap.min.css">
<!-- 引入登录页专属样式，定制登录框布局、颜色、字体等，匹配系统视觉风格 -->
<link rel="stylesheet" type="text/css" href="css/index.css">
<!-- 引入页脚样式，控制页脚文字、链接的排版与样式 -->
<link rel="stylesheet" type="text/css" href="css/footer.css">
<title>酒店管理系统</title>
<meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<link rel="stylesheet" type="text/css" href="css/bootstrap.min.css">
<link rel="stylesheet" type="text/css" href="css/index.css">
<link rel="stylesheet" type="text/css" href="css/footer.css">
</head>
<body>
<!-- 页面主体容器：使用Bootstrap的container-fluid类占满屏幕宽度，清除默认内边距 -->
<div class="container-fluid main" id="main" style="padding: 0">
<!-- 顶部导航栏：采用Bootstrap的navbar组件，作为系统标识区域 -->
<nav class="navbar navbar-default">
<div class="container-fluid nav-con">
<div class="navbar-header">
<!-- 系统名称：设置较大字体和字母间距，使用浅色调突出显示，提升视觉辨识度 -->
<a class="navbar-brand" href="#" style="padding-top: 2rem;color: #EDEDED">
<span style="font-size: 2.3rem;padding-right: 2rem;letter-spacing: 2px">酒店管理系统</span>
</a>
</div>
<nav class="navbar navbar-default">
<div class="container-fluid nav-con">
<div class="navbar-header">
<a class="navbar-brand" href="#" style="padding-top: 2rem;color: #EDEDED">
<span style="font-size: 2.3rem;padding-right: 2rem;letter-spacing: 2px">酒店管理系统</span>
</a>
</div>
</div>
</nav>
<div class="col-md-7 col-xs-1"></div>
<div class="col-md-3 col-xs-10 logindiv">
<div class="login-h">
<h3 class="loginh">
登录
</h3>
</div>
<form class="form-horizontal login-f">
<div class="form-group">
<label for="inputName" class="col-sm-2 control-label">Username</label>
<div class="col-md-12 col-xs-12">
<input type="text" class="form-control forminput" id="inputName" placeholder="账号 Account">
</div>
</nav>
<!-- 左侧空白占位区：通过Bootstrap栅格系统的col-md-7和col-xs-1类，实现登录框在PC端和移动端的居中效果 -->
<div class="col-md-7 col-xs-1"></div>
<!-- 登录框容器：PC端占3列、移动端占10列，通过自定义logindiv类控制登录框样式 -->
<div class="col-md-3 col-xs-10 logindiv">
<!-- 登录标题区：通过login-h和loginh类控制标题样式，明确“登录”功能 -->
<div class="login-h">
<h3 class="loginh">
登录
</h3>
</div>
<div class="form-group">
<label for="inputPassword" class="col-sm-2 control-label">Password</label>
<div class="col-md-12 col-xs-12">
<input type="password" class="form-control forminput" id="inputPassword" placeholder="密码 Password">
</div>
<!-- 登录表单：采用Bootstrap的form-horizontal类实现水平表单布局，结构清晰 -->
<form class="form-horizontal login-f">
<!-- 账号输入组：包含标签和输入框 -->
<div class="form-group">
<label for="inputName" class="col-sm-2 control-label">Username</label>
<div class="col-md-12 col-xs-12">
<!-- 账号输入框：通过forminput类统一样式，占位提示同时包含中英文，适配不同用户 -->
<input type="text" class="form-control forminput" id="inputName" placeholder="账号 Account">
</div>
</div>
<!-- 密码输入组：包含标签和密码类型输入框 -->
<div class="form-group">
<label for="inputPassword" class="col-sm-2 control-label">Password</label>
<div class="col-md-12 col-xs-12">
<!-- 密码输入框：type设为password隐藏输入内容，保护隐私，占位提示包含中英文 -->
<input type="password" class="form-control forminput" id="inputPassword" placeholder="密码 Password">
</div>
</div>
<!-- 验证码输入组：包含标签、输入框和验证码图片 -->
<div class="form-group">
<label for="inputCode" class="col-sm-2 control-label">Code</label>
<div class="col-md-8 col-xs-7">
<!-- 验证码输入框：通过inputcode类控制宽度，适配右侧图片区域 -->
<input type="text" class="form-control forminput inputcode" id="inputCode" placeholder="验证码 code">
</div>
<div class="col-md-4 col-xs-5" style="padding-left:0">
<!-- 验证码图片：id为code，用于JS动态加载验证码，点击可刷新 -->
<img class="code" id="code" src=" ">
</div>
</div>
<!-- 空白表单组：仅用于调整表单间距，优化页面布局美观度 -->
<div class="form-group">
</div>
<!-- 登录按钮组：控制按钮居中显示 -->
<div class="form-group">
<div class="col-md-offset-3 col-md-6 col-xs-12">
<!-- 登录按钮：添加transition过渡动画提升点击反馈，id为loginBtn用于JS绑定点击事件 -->
<button type="button" id="loginBtn" class="form-control btn loginbtn" style="transition: all 0.6s;" >登 录</button>
</div>
</form>
</div>
</div>
</div>
<div class="form-group">
<label for="inputCode" class="col-sm-2 control-label">Code</label>
<div class="col-md-8 col-xs-7">
<input type="text" class="form-control forminput inputcode" id="inputCode" placeholder="验证码 code">
</div>
<div class="col-md-4 col-xs-5" style="padding-left:0">
<img class="code" id="code" src=" ">
</div>
</div>
<div class="form-group">
</div>
<div class="form-group">
<div class="col-md-offset-3 col-md-6 col-xs-12">
<button type="button" id="loginBtn" class="form-control btn loginbtn" style="transition: all 0.6s;" >登 录</button>
</div>
</form>
</div>
</div>
</div>
<!-- 页脚区域：包含系统相关链接和版权信息，通过bs-docs-footer类控制样式 -->
<footer class="bs-docs-footer">
<div class="col-md-12">
<p>
<!-- 系统辅助链接：提供关于系统、联系我们等入口，方便用户了解系统 -->
<a href="#">关于本站</a>
<a href="#">廉正举报</a>
<a href="#">开放平台</a>
<a href="#">诚征英才</a>
<a href="#">联系我们</a>
<a href="#">网站地图</a><br/><br/>
<!-- 版权信息：标明开发主体和年份，符合项目规范 -->
<em>2025 合肥师范学院 软件工程</em>
</p>
<div class="col-md-12">
<p>
<a href="#">关于本站</a>
<a href="#">廉正举报</a>
<a href="#">开放平台</a>
<a href="#">诚征英才</a>
<a href="#">联系我们</a>
<a href="#">网站地图</a><br/><br/>
<em>Copyright © 2018 西安工业大学 All Rights Reserved</em>
</p>
</div>
</div>
</footer>
</body>
</html>
<!-- 引入jQuery库：提供DOM操作、AJAX请求等核心功能，是后续JS逻辑的基础 -->
<script type="text/javascript" src="js/jquery.min.js"></script>
<!-- 引入Bootstrap JS库：支持导航栏、表单等组件的基础交互效果 -->
<script type="text/javascript" src="js/bootstrap.min.js"></script>
<!-- 引入登录页专属JS：实现验证码加载刷新、登录表单校验、登录请求提交等核心逻辑 -->
<script type="text/javascript" src="js/index.js"></script>
<script type="text/javascript" src="js/index.js"></script>

125
src/main/resources/static/js/ad_manage.js
Unescape View File

@ -1,15 +1,12 @@
// 定义分页相关变量：当前页码、每页显示数量、当前页数据条数
var pageNum=1;// 当前页码，初始为第1页
var pageSize=8;// 每页显示8条数据
var l;// 用于记录当前页实际加载的数据条数
// 页面DOM加载完成后执行
var pageNum=1;
var pageSize=8;
var l;
$(document).ready(function(){
getStaffList(); // 调用函数，调用获取员工列表的函数，初始化页面数据
// 绑定"上一页"按钮点击事件，点击时调用getPre()函数
getStaffList();
$("#pre").on('click',function(){
getPre();
});
// 绑定"下一页"按钮点击事件，点击时调用getNext()函数
$("#next").on('click',function(){
getNext();
});
@ -19,82 +16,64 @@ $(document).ready(function(){
//判断对象/JSON是否为空 空返回1 非空返回0
function isEmptyObject(e) {
var t;
for (t in e) // 遍历对象属性，若存在属性则说明非空
for (t in e)
return 0;
return 1;
}
// 存储当前页的员工列表数据
var list;
// 获取员工列表数据的函数
function getStaffList(){
$.ajax({
type:"post",// 请求类型为POST
url:"../user/getAllUser.do",// 请求后端接口地址
dataType:"JSON",// 预期返回数据类型为JSON
data:{// 传递给后端的参数：当前页码和每页数量
type:"post",
url:"../user/getAllUser.do",
dataType:"JSON",
data:{
"pageNum":pageNum,
"pageSize":pageSize
},
// 请求成功的回调函数
success:function(data){
// 后端返回状态码为"0"表示成功
if(data.code=="0"){
// 若当前页数据为空且页码大于0，回退到上一页并重新加载
if(isEmptyObject(data.List)&&pageNum>0){
pageNum=pageNum-1;
getStaffList();
}
else{
var power=" ";// 存储职位名称
var htmlStr=" ";// 存储表格行HTML
var btnStr=" ";// 存储操作按钮HTML
list=data.List;// 将后端返回的列表数据存入全局变量
l=0;// 重置当前页数据条数计数
// 显示上一页和下一页按钮（默认先显示，后续根据情况隐藏）
var power=" ";
var htmlStr=" ";
var btnStr=" ";
list=data.List;
l=0;
$("#pre").css("display","block");
$("#next").css("display","block");
// 清空表格内容并添加表头
$("#staffList").empty();
$("#staffList").append("<tr><th>账号</th><th>员工号</th><th>姓名</th><th>年龄</th><th>职位</th><th>联系方式</th><th>操作</th></tr>")
// 遍历员工列表，生成表格内容
for(i in list){
// 根据权限值(power)设置职位名称和操作按钮
if(list[i].power=="0") {
power="管理员";
btnStr=" ";// 管理员无操作按钮
btnStr=" ";
}
else if(list[i].power=="1") {
power="经理";
// 经理的操作按钮：设置为员工、删除
btnStr="<input type=\"button\" id=\"setStaff\" data-userid=\""+list[i].userid+"\" class=\"btn btn-success\" value=\"设置为员工\"/> <input type=\"button\" id=\"delUser\" data-userid=\""+list[i].userid+"\" class=\"btn btn-danger\" value=\"删除\"/>"
}
else if(list[i].power=="2") {
power="员工";// 员工的操作按钮：设置为经理、重置密码、删除
power="员工";
btnStr="<input type=\"button\" id=\"setManage\" data-userid=\""+list[i].userid+"\" class=\"btn btn-success\" value=\"设置为经理\"/> <input type=\"button\" id=\"setPwd\" data-userid=\""+list[i].userid+"\" class=\"btn btn-info\" value=\"重置密码\"/> <input type=\"button\" id=\"delUser\" data-userid=\""+list[i].userid+"\" class=\"btn btn-danger\" value=\"删除\"/>"
}
else {
power="清洁工";
// 清洁工的操作按钮：重置密码、删除
btnStr="<input type=\"button\" id=\"setPwd\" data-userid=\""+list[i].userid+"\" class=\"btn btn-info\" value=\"重置密码\"/> <input type=\"button\" id=\"delUser\" data-userid=\""+list[i].userid+"\" class=\"btn btn-danger\" value=\"删除\"/> "
}
// 拼接当前员工的表格行HTML
htmlStr="<tr data-userid=\""+list[i].userid+"\"><td>"+list[i].useraccount+"</td><td>"+list[i].idnumber+"</td><td>"+list[i].username+"</td><td>"+list[i].age+"</td><td>"+power+"</td><td>"+list[i].phonenumber+"</td><td>"+btnStr+"</td></tr>";
// 将表格行添加到表格中
$("#staffList").append(htmlStr);
l++;// 累加当前页数据条数
l++;
//console.log(htmlStr)
}
// 若当前是第1页，隐藏"上一页"按钮
if(pageNum=="1") $("#pre").css("display","none");
// 若当前页数据条数小于每页显示数量，说明是最后一页，隐藏"下一页"按钮
if(pageSize>l) $("#next").css("display","none");
// 绑定操作按钮的点击事件
btnOn();
}
@ -106,85 +85,72 @@ function getStaffList(){
},
// 请求失败的回调函数
error:function(){
alert("获取员工列表发生错误")
}
})
}
// 绑定操作按钮的点击事件
function btnOn(){
// 绑定"设置为员工"按钮事件，调用setPosition并传递权限值"2"
$("input").filter("#setStaff").on('click',function(event){
setPosition(event,"2");
});
// 绑定"设置为经理"按钮事件，调用setPosition并传递权限值"1"
$("input").filter("#setManage").on('click',function(event){
setPosition(event,"1");
});
// 绑定"重置密码"按钮事件，调用setPwd
$("input").filter("#setPwd").on('click',function(event){
setPwd(event);
});
// 绑定"删除"按钮事件，调用delUser
$("input").filter("#delUser").on('click',function(event){
delUser(event);
});
// 绑定"跳转页码"按钮事件，调用setPage
$("input").filter("#setPageBtn").on('click',function( ){
setPage( );
})
}
// 上一页功能：页码减1并重新加载列表
function getPre(){
pageNum=pageNum-1;
getStaffList();
}
// 下一页功能：页码加1并重新加载列表
function getNext(){
pageNum=pageNum+1;
getStaffList();
}
// 跳转指定页码功能
function setPage(){
// 验证输入的页码是否合法（大于0）
if($("#inputPage").val()<0 || $("#inputPage").val()==0)
alert("请输入正确页码");
else{
pageNum=$("#inputPage").val(); // 更新页码
getStaffList();// 重新加载列表
pageNum=$("#inputPage").val();
getStaffList();
}
}
// 修改员工职位（权限）的函数
function setPosition(event,alter){
var userid=$(event.target).data("userid"); // 获取目标员工的ID
var info;// 存储目标员工的详细信息
// 从当前列表中查找目标员
var userid=$(event.target).data("userid");
var info;
for(i in list){
if(list[i].userid==userid){
info=list[i];
}
}
// 发送AJAX请求修改权限
$.ajax({
type:"POST",
url:"../user/updateUser.do",// 后端修改用户接口
url:"../user/updateUser.do",
dataType:"JSON",
data:{// 传递用户ID和新权限值
data:{
"userid":info.userid,
"power":alter
},
success:function(data){
if(data.code==0){// 修改成功
if(data.code==0){
alert("修改成功");
getStaffList();// 重新加载列表刷新数据
getStaffList();
}
else
alert("修改失败")
@ -196,30 +162,27 @@ function setPosition(event,alter){
}
// 重置员工密码的函数
function setPwd(event){
var userid=$(event.target).data("userid");// 获取目标员工的ID
var info;// 存储目标员工的详细信息
// 从当前列表中查找目标员工
var userid=$(event.target).data("userid");
var info;
for(i in list){
if(list[i].userid==userid){
info=list[i];
}
}
info.password="111111"; // 重置密码为"111111"
// 发送AJAX请求修改密码
info.password="111111";
$.ajax({
type:"POST",
url:"../user/updateUser.do",// 后端修改用户接口
url:"../user/updateUser.do",
dataType:"JSON",
data:{// 传递用户ID和新密码
data:{
"userid":info.userid,
"password":info.password
},
success:function(data){
if(data.code==0){// 修改成功
if(data.code==0){
alert("修改成功");
getStaffList(); // 重新加载列表刷新数据
getStaffList();
}
else
alert("修改失败")
@ -229,24 +192,22 @@ function setPwd(event){
}
})
}
// 删除员工的函数
function delUser(event){
var userid=$(event.target).data("userid"); // 获取目标员工的ID
// 发送AJAX请求删除用户
var userid=$(event.target).data("userid");
$.ajax({
type:"POST",
url:"../user/delUser.do",// 后端删除用户接口
url:"../user/delUser.do",
dataType:"JSON",
data:{ // 传递用户ID
data:{
"userid":userid
},
success:function(data){
if(data.code==0){// 删除成功
if(data.code==0){
alert("删除成功");
// 若当前页只剩1条数据，删除后页码回退1页
if(l==1)
pageNum=pageNum-1;
getStaffList();// 重新加载列表刷新数据
getStaffList();
}
else
alert("删除失败")

122
src/main/resources/static/js/ad_order.js
Unescape View File

@ -1,17 +1,13 @@
// 定义分页相关变量：当前页码、每页显示数量、当前页数据条数
var pageNum=1;// 当前页码，初始为第1页
var pageSize=8;// 每页显示8条数据
var l;// 记录当前页实际加载的数据条数
var pageNum=1;
var pageSize=8;
var l;
// 页面DOM加载完成后执行初始化操作
$(document).ready(function(){
getorderList(); // 加载订单列表
getConfig();// 加载系统配置信息
// 绑定"上一页"按钮点击事件
getorderList();
getConfig();
$("#pre").on('click',function(){
getPre();
});
// 绑定"下一页"按钮点击事件
});
$("#next").on('click',function(){
getNext();
});
@ -21,150 +17,123 @@ $(document).ready(function(){
//判断对象/JSON是否为空 空返回1 非空返回0
function isEmptyObject(e) {
var t;
for (t in e)// 遍历对象属性，存在属性则非空
for (t in e)
return 0;
return 1;
}
// 存储当前页的订单列表数据
var list;
// 获取订单列表数据
function getorderList(){
$.ajax({
type:"post",// 请求类型为POST
url:"../order/getAllOrder.do", // 后端获取订单列表的接口
dataType:"JSON",// 预期返回JSON格式数据
data:{// 传递分页参数
type:"post",
url:"../order/getAllOrder.do",
dataType:"JSON",
data:{
"pageNum":pageNum,
"pageSize":pageSize
},
// 请求成功的回调函数
success:function(data){
// 若当前页数据为空且页码>0，回退到上一页重新加载
if(isEmptyObject(data.List)&&pageNum>0){
pageNum=pageNum-1;
getorderList();
}
else{
list=data.List;// 存储订单列表数据
var htmlStr=" ";// 表格行HTML字符串
var btnStr=" ";// 操作按钮HTML字符串
var state=" ";// 订单状态文本
var sdate;// 入住日期（格式化后）
var edate;// 退房日期（格式化后）
l=0;// 重置当前页数据计数
// 显示分页按钮（默认先显示，后续根据情况隐藏）
list=data.List;
var htmlStr=" ";
var btnStr=" ";
var state=" ";
var sdate;
var edate;
l=0;
$("#pre").css("display","block");
$("#next").css("display","block");
// 清空表格并添加表头
$("#orderList").empty();
$("#orderList").append("<tr><th>入住人</th><th>身份证号</th><th>开始时间</th><th>结束时间</th><th>总金额</th><th>状态</th><th>操作</th></tr>")
for(i in list){
// 从时间字符串中提取日期部分（格式：年-月-日）
sdate=/\d{4}-\d{1,2}-\d{1,2}/g.exec(list[i].starttime);
edate=/\d{4}-\d{1,2}-\d{1,2}/g.exec(list[i].endtime);
// 根据订单状态（state）设置状态文本和操作按钮
if(list[i].state=="0"){
state="未付款";
// 未付款订单：仅显示"查看房间"按钮（关联模态框）
btnStr="<input type=\"button\" class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\" data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\">";
}
else if(list[i].state=="1"){
state="已付款";
// 已付款订单：仅显示"查看房间"按钮
btnStr="<input type=\"button\" class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\" data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\"> ";
}
else if(list[i].state=="2"){
state="已完成";
// 已完成订单：显示"查看房间"和"删除"按钮
btnStr="<input type=\"button\" class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\" data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\"> <input type=\"button\" class=\"btn btn-success\" data-orderid=\""+list[i].orderid+"\" id=\"delOrder\" value=\"删除\">";
}
else{
state="已取消";
// 已取消订单：显示"查看房间"和"删除"按钮
btnStr="<input type=\"button\" class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\" data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\"> <input type=\"button\" class=\"btn btn-success\" data-orderid=\""+list[i].orderid+"\" id=\"delOrder\" value=\"删除\">";
}
// 拼接订单表格行HTML
htmlStr="<tr data-orderid=\""+list[i].orderid+"\"><td>"+list[i].householdname+"</td><td>"+list[i].id+"</td><td>"+sdate+"</td><td>"+edate+"</td><td>"+list[i].money+"</td><td>"+state+"</td><td>"+btnStr+"</td></tr>";
// 添加到表格中
$("#orderList").append(htmlStr);
l++;// 累加当前页数据条数
l++;
}
// 若为第1页，隐藏"上一页"按钮
if(pageNum=="1") $("#pre").css("display","none");
// 若当前页数据少于每页数量，说明是最后一页，隐藏"下一页"按钮
if(pageSize>l) $("#next").css("display","none");
// 绑定操作按钮事件
btnOn();
}
},
// 请求失败的回调
error:function(){
alert("获取订单列表发生错误")
}
})
}
// 绑定操作按钮的点击事件
function btnOn(){
// 绑定"跳转页码"按钮事件
$("input").filter("#setPageBtn").on('click',function( ){
setPage( );
});
// 绑定"查看房间"按钮事件
$("input").filter("#showRoom").on('click',function(event){
showRoom(event);
})
// 绑定"删除订单"按钮事件
$("input").filter("#delOrder").on('click',function(event){
delOrder(event);
});
}
// 上一页功能：页码减1并重新加载列表
function getPre(){
pageNum=pageNum-1;
getorderList();
}
// 下一页功能：页码加1并重新加载列表
function getNext(){
pageNum=pageNum+1;
getorderList();
}
// 跳转指定页码功能
function setPage(){
// 验证页码合法性（必须大于0）
if($("#inputPage").val()<0 || $("#inputPage").val()==0)
alert("请输入正确页码");
else{
pageNum=$("#inputPage").val();// 更新页码
getorderList();// 重新加载列表
pageNum=$("#inputPage").val();
getorderList();
}
}
// 删除订单功能
function delOrder(event){
var orderid=$(event.target).data("orderid");// 获取订单ID
var orderid=$(event.target).data("orderid");
$.ajax({
type:"POST",
url:"../order/delOrder.do",// 后端删除订单接口
url:"../order/delOrder.do",
dataType:"JSON",
data:{// 传递订单ID
data:{
"orderid":orderid
},
success:function(data){
if(data.code==0){// 删除成功
if(data.code==0){
alert("删除成功");
// 若当前页只剩1条数据，删除后页码回退1页
if(l==1)
pageNum=pageNum-1;
getorderList();// 重新加载列表刷新数据
getorderList();
}
else
alert("删除失败")
@ -176,25 +145,23 @@ function delOrder(event){
}
// 查看房间详情功能（点击后显示模态框）
function showRoom(event){
var roomid=$(event.target).data("roomid");// 获取房间ID
var roomid=$(event.target).data("roomid");
$.ajax({
type:"POST",
url:"../room/getRoomById.do",// 后端获取房间详情接口
url:"../room/getRoomById.do",
dataType:"JSON",
data:{// 传递房间ID
data:{
"roomid":roomid
},
success:function(data){
var room=data.room;// 房间详情数据
if(data.code==0){// 获取成功
var htmlStr=" ";// 房间信息表格HTML
var state=" ";// 房间状态文本
var type=" ";// 房间类型文本
// 清空模态框中的表格
var room=data.room;
if(data.code==0){
var htmlStr=" ";
var state=" ";
var type=" ";
$("#roomTable").empty();
// 转换房间状态编码为文本
if(room.state=="0")
state="停用";
else if(room.state=="1")
@ -203,7 +170,6 @@ function showRoom(event){
state="已预定(入住)";
else
state="待清扫";
// 转换房间类型编码为文本
if(room.type=="1")
type="单人间";
else if(room.type=="2")
@ -212,9 +178,7 @@ function showRoom(event){
type="大床房";
else
type="套房";
// 拼接房间信息表格HTML
htmlStr="<tr><th>位置</th><td>"+room.local+"</td></tr><tr><th>价格</th><td>"+room.money+"</td></tr><tr><th>类型</th><td>"+type+"</td></tr><tr><th>状态</th><td>"+state+"</td></tr>"
// 添加到模态框表格中
$("#roomTable").append(htmlStr);
}
else
@ -226,17 +190,15 @@ function showRoom(event){
})
}
// 获取系统配置信息（如总营业额、总房间数）
function getConfig(){
$.ajax({
type:"POST",
url:"../config/getConfig.do",// 后端获取配置接口
url:"../config/getConfig.do",
dataType:"JSON",
data:{},// 无参数
data:{},
success:function(data){
if(data.code=="0"){// 获取成功
var config=data.config;// 配置数据
// 更新页面上的总金额和总房间数显示
if(data.code=="0"){
var config=data.config;
$("#totalMoney").text(config.totalmoney);
$("#totalRoom").text(config.totalroom);
}

54
src/main/resources/static/js/ad_salary.js
Unescape View File

@ -1,52 +1,39 @@
// 页面DOM加载完成后执行的初始化函数
$(document).ready(function(){
// 加载配置信息
getConfig();
// 给"查看配置"按钮绑定点击事件，点击时切换显示的标签页
$("#showConfig").click(function(){
changeTab();
});
// 给"修改配置"按钮绑定点击事件，点击时切换显示的标签页
$("#alterConfig").click(function(){
changeTab();
});
// 给"确认修改"按钮绑定点击事件，点击时执行修改配置的逻辑
$("#alterConfigBtn").click(function(){
alterConfig();
})
})
// 全局变量，用于存储从后端获取的配置信息
var config;
//判断字符串是否为空 空返回1 非空返回0
function isEmptyString(str){
// 如果字符串是'null'或空字符串，视为空
if(str=='null'||str=='')
return 1;
return 0;
}
// 从后端获取配置信息并展示
function getConfig(){
// 发起AJAX POST请求
$.ajax({
type:"POST",// 请求类型
url:"../config/getConfig.do", // 请求后端接口地址
dataType:"JSON", // 预期后端返回的数据类型
data:{},// 请求参数（无参数）
// 请求成功的回调函数
type:"POST",
url:"../config/getConfig.do",
dataType:"JSON",
data:{},
success:function(data){
// 后端返回成功状态码（假设code="0"为成功）
if(data.code=="0"){
// 存储配置信息到全局变量
config=data.config;
// 拼接配置信息的HTML字符串（用于展示表格）
var htmlStr="<tr><td>经理</td><td>"+config.manage+"</td><td>"+config.managesalary+"%</td></tr>"+
"<tr><td>员工</td><td>"+config.staff+"</td><td>"+config.staffsalary+"%</td></tr>"+
"<tr><td>清洁工</td><td>"+config.cleaner+"</td><td>"+config.cleanerssalary+"%</td></tr>";
// 将HTML添加到表格中展示
$("#configList").append(htmlStr);
// 给修改表单的输入框赋值（默认显示当前配置）
$("#inputMS").val(config.manage);
$("#inputSS").val(config.staff);
$("#inputCS").val(config.cleaner);
@ -55,12 +42,10 @@ function getConfig(){
$("#inputC").val(config.cleanerssalary);
}
else{
// 后端返回失败，提示错误
alert("获取配置错误");
}
},
// 请求失败的回调函数
error:function(){
alert("获取配置发生错误")
}
@ -68,35 +53,27 @@ function getConfig(){
});
}
// 切换标签页（切换"查看配置"和"修改配置"区域的显示状态）
function changeTab(){
// 获取两个区域当前的显示状态
var info=$("#showConfigDiv").css("display"); // 查看配置区域
var alter=$("#alterConfigDiv").css("display");// 修改配置区域
// 如果查看区域正在显示，则隐藏查看区域，显示修改区域（带动画）
var info=$("#showConfigDiv").css("display");
var alter=$("#alterConfigDiv").css("display");
if(info=="block"){
$("#showConfigDiv").css("display","none");
$("#alterConfigDiv").fadeIn(); // 淡入动画
$("#alterConfigDiv").fadeIn();
}
else{
// 否则隐藏修改区域，显示查看区域（带动画）
$("#alterConfigDiv").css("display","none")
$("#showConfigDiv").fadeIn();// 淡入动画
$("#showConfigDiv").fadeIn();
}
}
// 提交修改配置的请求
function alterConfig(){
// 校验输入框是否为空（调用isEmptyString函数）
if(isEmptyString($("#inputMS").val())||isEmptyString($("#inputM").val())||isEmptyString($("#inputSS").val())||isEmptyString($("#inputS").val())||isEmptyString($("#inputCS").val())||isEmptyString($("#inputC").val()))
alert("请填写全内容");// 有空值则提示
alert("请填写全内容");
else{
// 输入完整，发起修改请求
$.ajax({
type:"POST", // 请求类型
url:"../config/updateConfig.do",// 后端修改接口地址
dataType:"JSON", // 预期返回数据类型
// 请求参数（从输入框获取新的配置值）
type:"POST",
url:"../config/updateConfig.do",
dataType:"JSON",
data:{
"managesalary":$("#inputM").val(),
"staffsalary":$("#inputS").val(),
@ -105,7 +82,6 @@ function alterConfig(){
"staff":$("#inputSS").val(),
"cleaner":$("#inputCS").val()
},
// 请求成功的回调函数
success:function(data){
if(data.code=="0"){
alert("修改成功");
@ -114,11 +90,9 @@ function alterConfig(){
else{
alert("修改配置错误");
}
// 无论成功与否，刷新页面重新加载配置
window.location.reload();
},
// 请求失败的回调函数
error:function(){
alert("修改配置发生错误")
}

139
src/main/resources/static/js/all_infor.js
Unescape View File

@ -1,44 +1,31 @@
// 扩展jQuery方法：添加获取URL参数的功能
(function($){
// 定义$.getData方法，用于从URL查询参数中获取指定名称的值
$.getData=function(name){
// 构建正则表达式，匹配URL中"name=value"的参数格式
var reg=new RegExp("(^|&)"+name+"=([^&]+)(&|$)?");
// 从URL的查询字符串（?后的部分）中提取参数并匹配正则
var result = window.location.search.substr(1).match(reg);
// 若匹配到结果则返回参数值，否则返回null
if (result!= null) return result[2]; return null;
if (result!= null) return result[2]; return null;
}
})(jQuery);
// 从URL参数中获取userid和power（用户ID和权限等级）
var userid=$.getData('userid');
var power=$.getData('power');
// 页面DOM加载完成后执行的初始化函数
$(document).ready(function(){
// 设置用户头像的宽高相等（正方形）
var w=$("#userpic").width();
$("#userpic").height(w);
// 给隐藏输入框赋值userid（可能用于表单提交时传递用户ID）
$("#inputNone").attr("value",userid);
// 绑定"查看信息"按钮点击事件，切换标签页
$("#showInfo").click(function(){
changeTab();
});
// 绑定"修改信息"按钮点击事件，切换标签页
$("#showAlter").click(function(){
changeTab();
});
// 加载用户基本信息
getInfo();
// 加载用户薪资信息（根据权限判断是否显示）
getSalary();
// 绑定"确认修改信息"按钮点击事件，执行修改信息逻辑
$("#alterInfoBtn").click(function(){
alterInfo();
});
// 绑定"确认修改密码"按钮点击事件，执行修改密码逻辑
$("#alterPwdBtn").click(function(){
alterPwd();
})
@ -48,7 +35,6 @@ $(document).ready(function(){
//判断对象/JSON是否为空 空返回1 非空返回0
function isEmptyObject(e) {
var t;
// 遍历对象，若存在属性则非空
for (t in e)
return 0;
return 1;
@ -56,97 +42,85 @@ function isEmptyObject(e) {
//判断字符串是否为空 空返回1 非空返回0
function isEmptyString(str){
// 若字符串为'null'或空字符串，视为空
if(str=='null'||str=='')
return 1;
return 0;
}
// 切换标签页（切换"查看信息"和"修改信息"区域的显示状态）
function changeTab(){
// 获取两个区域当前的显示状态
var info=$("#showInfodiv").css("display");// 查看信息区域
var alter=$("#showAlterdiv").css("display"); // 修改信息区域
// 若查看区域显示，则隐藏查看区域，淡入显示修改区域
var info=$("#showInfodiv").css("display");
var alter=$("#showAlterdiv").css("display");
if(info=="block"){
$("#showInfodiv").css("display","none");
$("#showAlterdiv").fadeIn();
$("#showAlterdiv").fadeIn();
}
else{
// 否则隐藏修改区域，淡入显示查看区域
$("#showAlterdiv").css("display","none")
$("#showInfodiv").fadeIn();
}
}
// 全局变量，用于存储用户信息
var info;
// 从后端获取用户详情信息并展示
function getInfo(){
$.ajax({
type:"POST", // 请求类型
url:"../user/getUserById.do",// 后端接口地址（根据用户ID获取信息）
dataType:"JSON",// 预期返回数据类型
type:"POST",
url:"../user/getUserById.do",
dataType:"JSON",
data:{
"userid":userid // 请求参数：用户ID
"userid":userid
},
// 请求成功的回调函数
success:function(data){
if(data.code==0){// 后端返回成功状态（code=0）
info=data.user;// 存储用户信息到全局变量
var span=$("span");// 获取所有span标签
// 设置用户头像图片路径
if(data.code==0){
info=data.user;
var span=$("span");
$("#userpic").attr("src",'../'+info.photourl)
// 填充查看区域的用户信息（账号、身份证号、姓名、年龄、手机号）
span.filter("#account").text(info.useraccount);
span.filter("#idnum").text(info.idnumber);
span.filter("#name").text(info.username);
$("#inputName").val(info.username);
// 填充修改区域的输入框（默认显示当前信息）
span.filter("#age").text(info.age);
$("#inputAge").val(info.age)
span.filter("#phone").text(info.phonenumber);
$("#inputPhone").val(info.phonenumber)
}
else{
alert("获取信息失败");// 后端返回失败
alert("获取信息失败");
}
},
// 请求失败的回调函数
error:function(){
alert("获取信息出现错误");
}
})
}
// 提交用户基本信息修改请求
function alterInfo(){
// 从输入框获取修改后的信息
var name=$("#inputName").val();
var age=$("#inputAge").val();
var phone=$("#inputPhone").val();
// 校验输入是否为空
if(isEmptyString(name) || isEmptyString(age) || isEmptyString(phone)){
alert("请填写全信息");
}
else{
// 输入完整，发起修改请求
$.ajax({
type:"POST",
url:"../user/updateUser.do",// 后端修改用户信息接口
url:"../user/updateUser.do",
dataType:"JSON",
data:{
"userid":userid, // 用户ID（不变）
"password":info.password, // 密码（不变，从原有信息获取）
"username":name,// 新姓名
"age":age, // 新年龄
"power":power,// 权限等级（不变）
"IDnumber":info.idnumber, // 身份证号（不变）
"phonenumber":phone // 新手机号
"userid":userid,
"password":info.password,
"username":name,
"age":age,
"power":power,
"IDnumber":info.idnumber,
"phonenumber":phone
},
success:function(data){
if(data.code==0){
alert("修改成功");
window.location.reload();// 刷新页面加载最新信息
window.location.reload();
}
else
alert("修改失败")
@ -157,36 +131,32 @@ function alterInfo(){
})
}
}
// 提交密码修改请求
function alterPwd(){
// 从输入框获取密码信息
var oldPwd=$("#inputoldPwd").val();// 原密码
var newPwd=$("#inputnewPwd").val(); // 新密码
var renewPwd=$("#inputrenewPwd").val(); // 确认新密码
var oldPwd=$("#inputoldPwd").val();
var newPwd=$("#inputnewPwd").val();
var renewPwd=$("#inputrenewPwd").val();
if(isEmptyString(oldPwd) || isEmptyString(newPwd) || isEmptyString(renewPwd)){
alert("请填写全信息");
}
// 校验原密码是否正确（与原有信息比对）
else if(oldPwd!=info.password)
alert("原密码不正确");
// 校验新密码两次输入是否一致
else if(newPwd!=renewPwd)
alert("新密码输入错误")
else{
// 校验通过，发起密码修改请求
$.ajax({
type:"POST",
url:"../user/updateUser.do",// 后端修改用户信息接口（复用）
url:"../user/updateUser.do",
dataType:"JSON",
data:{
"userid":userid,// 用户ID
"password":newPwd // 新密码
"userid":userid,
"password":newPwd
},
success:function(data){
if(data.code==0){
alert("修改成功");
window.location.reload(); // 刷新页面
window.location.reload();
}
else
alert("修改失败")
@ -198,38 +168,31 @@ function alterPwd(){
}
}
// 获取并展示用户薪资信息（根据权限判断是否显示）
function getSalary(){
// 若权限不为"0"（假设0为非员工/游客，1/2/3为不同角色），则显示薪资区域
if(power!="0"){
$("#showS").css("display","block");// 显示薪资标签
$("#showC").css("display","block");// 显示提成标签
// 从后端获取薪资配置信息
$("#showS").css("display","block");
$("#showC").css("display","block");
$.ajax({
type:"POST",
url:"../config/getConfig.do",// 后端获取配置接口
url:"../config/getConfig.do",
dataType:"JSON",
data:{},// 无参数
data:{},
success:function(data){
if(data.code=="0"){// 配置获取成功
var config=data.config;// 薪资配置信息
// 根据权限等级显示对应角色的薪资和提成比例
if(power=="1"){ // 假设1为经理
$("#salary").text(config.manage); // 经理基础薪资
$("#commission").text(config.managesalary+"%");// 经理提成比例
if(data.code=="0"){
var config=data.config;
if(power=="1"){
$("#salary").text(config.manage);
$("#commission").text(config.managesalary+"%");
}
else if(power=="2"){// 假设2为员工
$("#salary").text(config.staff);// 员工基础薪资
$("#commission").text(config.staffsalary+"%");// 员工提成比例
else if(power=="2"){
$("#salary").text(config.staff);
$("#commission").text(config.staffsalary+"%");
}
else{ // 其他权限（假设为清洁工）
$("#salary").text(config.cleaner); // 清洁工基础薪资
$("#commission").text(config.cleanerssalary+"%");// 清洁工提成比例
else{
$("#salary").text(config.cleaner);
$("#commission").text(config.cleanerssalary+"%");
}
}
else{
alert("获取配置错误");

4106
src/main/resources/static/js/bootstrap-datepicker.js
View File

File diff suppressed because it is too large Load Diff

14
src/main/resources/static/js/cleaner_room.js
Unescape View File

@ -2,7 +2,6 @@ var pageNum=1;
var pageSize=8;
var l;
// 页面DOM加载完成后执行初始化操作
$(document).ready(function(){
getroomList();
$("#pre").on('click',function(){
@ -24,7 +23,6 @@ function isEmptyObject(e) {
var list;
// 从后端获取房间列表并展示
function getroomList(){
$.ajax({
type:"post",
@ -36,15 +34,12 @@ function getroomList(){
"pageNum":pageNum,
"pageSize":pageSize
},
// 请求成功的回调函数
success:function(data){
// 若当前页无数据且页码大于0，回退到上一页并重新加载
if(isEmptyObject(data.List)&&pageNum>0){
pageNum=pageNum-1;
getroomList();
}
else{
// 存储房间列表数据
list=data.List;
var power=" ";
var htmlStr=" ";
@ -52,13 +47,11 @@ function getroomList(){
var state=" ";
var type=" ";
l=0;
// 默认显示上一页、下一页按钮
$("#pre").css("display","block");
$("#next").css("display","block");
$("#roomList").empty();
$("#roomList").append("<tr><th>位置</th><th>价格</th><th>状态</th><th>类型</th><th>操作</th></tr>");
state="未清扫";
// 遍历房间列表，拼接表格内容
for(i in list){
if(list[i].type=="1")
type="单人间";
@ -79,14 +72,12 @@ function getroomList(){
}
},
// 请求失败的回调函数
error:function(){
alert("获取房间列表发生错误")
}
})
}
// 绑定页面中操作按钮的点击事件
function btnOn(){;
$("input").filter("#setPageBtn").on('click',function( ){
setPage( );
@ -96,7 +87,6 @@ function btnOn(){;
});
}
// 修改房间状态为"已清扫"
function setRoom(event){
var roomid=$(event.target).data("roomid");
$.ajax({
@ -107,7 +97,6 @@ function setRoom(event){
"roomid":roomid,
"state":"1"
},
// 请求成功的回调函数
success:function(data){
if(data.code==0){
alert("修改成功");
@ -124,19 +113,16 @@ function setRoom(event){
})
}
// 加载上一页数据
function getPre(){
pageNum=pageNum-1;
getroomList();
}
// 加载下一页数据
function getNext(){
pageNum=pageNum+1;
getroomList();
}
// 跳转到指定页码
function setPage(){
if($("#inputPage").val()<0 || $("#inputPage").val()==0)
alert("请输入正确页码");

4
src/main/resources/static/js/index.js
Unescape View File

@ -1,4 +1,3 @@
// 页面DOM加载完成后执行初始化操作
$(document).ready(function(){
getCode();
var h=$(window).height();
@ -22,7 +21,6 @@ function login(){
var user=$("#inputName").val();
var pwd=$("#inputPassword").val();
var code=$("#inputCode").val();
// 发起AJAX登录请求
$.ajax({
type:"POST",
url:"./user/login.do",
@ -32,7 +30,6 @@ function login(){
"password":pwd,
"icode":code
},
// 请求成功的回调函数（后端返回数据后执行）
success:function(data){
console.log(data)
if(data.code=="0"){
@ -43,7 +40,6 @@ function login(){
alert("验证码或密码错误")
}
},
// 请求失败的回调函数（网络错误或接口异常时执行）
error:function(){
alert("登录 发生错误");
}

33
src/main/resources/static/js/manage_room.js
Unescape View File

@ -2,7 +2,6 @@ var pageNum=1;
var pageSize=8;
var l;
// 页面DOM加载完成后执行初始化操作
$(document).ready(function(){
getroomList();
$("#pre").on('click',function(){
@ -40,7 +39,6 @@ function isEmptyString(str){
var list;
// 从后端获取房间列表并展示
function getroomList(){
$.ajax({
type:"post",
@ -52,7 +50,6 @@ function getroomList(){
"pageNum":pageNum,
"pageSize":pageSize
},
// 请求成功的回调函数
success:function(data){
if(isEmptyObject(data.List)&&pageNum>0){
pageNum=pageNum-1;
@ -66,12 +63,10 @@ function getroomList(){
var state=" ";
var type=" ";
l=0;
// 默认显示上一页、下一页按钮
$("#pre").css("display","block");
$("#next").css("display","block");
$("#roomList").empty();
$("#roomList").append("<tr><th>位置</th><th>价格</th><th>状态</th><th>类型</th><th>操作</th></tr>")
// 遍历房间列表，生成表格内容
for(i in list){
if(list[i].state=="0"){
state="停用";
@ -89,7 +84,6 @@ function getroomList(){
state="待清扫";
btnStr="<input type=\"button\" class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"setStop\" value=\"改为停用\"> <input type=\"button\" class=\"btn btn-success\" data-toggle=\"modal\" data-target=\"#alterRoom\" data-roomid=\""+list[i].roomid+"\" id=\"setRoom\" value=\"修改信息\"> <input type=\"button\" class=\"btn btn-danger\" data-roomid=\""+list[i].roomid+"\" value=\"删除\" id=\"delRoom\">";
}
// 根据房间类型编码转换为文本
if(list[i].type=="1")
type="单人间";
@ -99,7 +93,6 @@ function getroomList(){
type="大床房";
else
type="套房"
// 拼接表格行（包含房间信息和操作按钮）
htmlStr="<tr data-roomid=\""+list[i].roomid+"\"><td>"+list[i].local+"</td><td>"+list[i].money+"</td><td>"+state+"</td><td>"+type+"</td><td>"+btnStr+"</td></tr>";
$("#roomList").append(htmlStr);
@ -111,14 +104,12 @@ function getroomList(){
}
},
// 请求失败的回调函数
error:function(){
alert("获取房间列表发生错误")
}
})
}
// 绑定页面中所有操作按钮的点击事件
function btnOn(){
$("input").filter("#delRoom").on('click',function(event){
delRoom(event);
@ -137,17 +128,17 @@ function btnOn(){
});
}
// 加载上一页数据
function getPre(){
pageNum=pageNum-1;
getroomList();
}
// 加载下一页数据
function getNext(){
pageNum=pageNum+1;
getroomList();
}
// 填充房间修改表单（将当前房间信息显示到修改弹窗中）
function setRoom(event){
var roomid=$(event.target).data("roomid");
var info;
@ -156,13 +147,12 @@ function setRoom(event){
info=list[i];
}
}
// 将房间信息填充到修改表单的输入框中
$("#reinputLocal").val(info.local);
$("#reinputPrice").val(info.money);
$("#reinputType").val(info.type);
$("#reinputid").val(roomid);
}
// 提交房间信息修改请求（AJAX）
function setRoomajax( ){
$.ajax({
type:"POST",
@ -174,7 +164,6 @@ function setRoomajax( ){
"type":$("#reinputType").val(),
"local":$("#reinputLocal").val()
},
// 请求成功的回调函数
success:function(data){
if(data.code==0){
alert("修改成功");
@ -183,7 +172,6 @@ function setRoomajax( ){
$("#reinputType").val("");
$("#reinputid").val("");
$('#alterRoom').modal('toggle');
// 无论成功与否，重新加载房间列表展示最新数据
getroomList();
}
else{
@ -196,7 +184,7 @@ function setRoomajax( ){
}
})
}
// 修改房间状态（启用/停用）
function setState(event,alter){
var roomid=$(event.target).data("roomid");
$.ajax({
@ -207,11 +195,9 @@ function setState(event,alter){
"roomid":roomid,
"state":alter
},
// 请求成功的回调函数
success:function(data){
if(data.code==0){
alert("修改成功");
// 重新加载房间列表展示最新状态
getroomList();
}
else
@ -222,9 +208,9 @@ function setState(event,alter){
}
})
}
// 跳转到指定页码
function setPage(){
// 校验输入的页码是否合法（必须大于0）
if($("#inputPage").val()<0 || $("#inputPage").val()==0)
alert("请输入正确页码");
else{
@ -234,7 +220,7 @@ function setPage(){
}
// 删除房间
function delRoom(event){
var roomid=$(event.target).data("roomid");
$.ajax({
@ -244,7 +230,6 @@ function delRoom(event){
data:{
"roomid":roomid
},
// 请求成功的回调函数
success:function(data){
if(data.code==0){
alert("删除成功");
@ -261,7 +246,7 @@ function delRoom(event){
})
}
// 添加新房间
function addRoom(){
if(isEmptyString($("#inputLocal").val())||isEmptyString($("#inputLocal").val())||isEmptyString($("#inputType").val()))
alert("请填写全内容");

21
src/main/resources/static/js/manage_staff.js
Unescape View File

@ -1,7 +1,7 @@
var pageNum=1;
var pageSize=8;
var l;
// 页面DOM加载完成后执行初始化操作
$(document).ready(function(){
getStaffList();
$("#pre").on('click',function(){
@ -34,7 +34,6 @@ function isEmptyString(str){
var list;
// 从后端获取员工列表并展示
function getStaffList(){
$.ajax({
type:"post",
@ -46,9 +45,7 @@ function getStaffList(){
"power":"2"
},
success:function(data){
// 后端返回成功状态（code=0）
if(data.code=="0"){
// 若当前页无数据且页码大于0，回退到上一页并重新加载
if(isEmptyObject(data.List)&&pageNum>0){
pageNum=pageNum-1;
getStaffList();
@ -59,12 +56,10 @@ function getStaffList(){
var btnStr=" ";
list=data.List;
l=0;
// 默认显示上一页、下一页按钮
$("#pre").css("display","block");
$("#next").css("display","block");
$("#staffList").empty();
$("#staffList").append("<tr><th>账号</th><th>员工号</th><th>姓名</th><th>年龄</th><th>职位</th><th>联系方式</th><th>操作</th></tr>")
// 遍历员工列表，生成表格内容
for(i in list){
btnStr="<input type=\"button\" id=\"delUser\" data-userid=\""+list[i].userid+"\" class=\"btn btn-danger\" value=\"删除\"/>"
htmlStr="<tr data-userid=\""+list[i].userid+"\"><td>"+list[i].useraccount+"</td><td>"+list[i].idnumber+"</td><td>"+list[i].username+"</td><td>"+list[i].age+"</td><td>"+"员工"+"</td><td>"+list[i].phonenumber+"</td><td>"+btnStr+"</td></tr>";
@ -72,7 +67,6 @@ function getStaffList(){
//console.log(htmlStr);
l++;
}
// 若当前是第1页，隐藏"上一页"按钮
if(pageNum=="1") $("#pre").css("display","none");
if(pageSize>l) $("#next").css("display","none");
btnOn();
@ -89,7 +83,7 @@ function getStaffList(){
}
})
}
// 绑定页面中操作按钮的点击事件
function btnOn(){
$("input").filter("#delUser").on('click',function(event){
delUser(event);
@ -98,18 +92,18 @@ function btnOn(){
setPage( );
})
}
// 加载上一页数据
function getPre(){
pageNum=pageNum-1;
getStaffList();
}
// 加载下一页数据
function getNext(){
pageNum=pageNum+1;
getStaffList();
}
// 跳转到指定页码
function setPage(){
if($("#inputPage").val()<0 || $("#inputPage").val()==0)
@ -121,7 +115,7 @@ function setPage(){
}
// 删除员工
function delUser(event){
var userid=$(event.target).data("userid");
$.ajax({
@ -147,7 +141,7 @@ function delUser(event){
})
}
// 添加新员工
function addUser(){
if(isEmptyString($("#inputAccount").val())||isEmptyString($("#inputPwd").val()))
alert("请填写全内容");
@ -172,7 +166,6 @@ function addUser(){
else
alert("添加失败")
},
// 重新加载员工列表展示新添加的员工
error:function(){
alert("添加用户出现错误");
}

9
src/main/resources/static/js/myCenter.js
Unescape View File

@ -1,4 +1,3 @@
// 定义jQuery扩展方法：从URL参数中获取指定名称的值
(function($){
$.getData=function(name){
var reg=new RegExp("(^|&)"+name+"=([^&]+)(&|$)?");
@ -6,11 +5,11 @@
if (result!= null) return result[2]; return null;
}
})(jQuery);
// 从URL参数中获取用户权限（power）和用户ID（userid）
var power=$.getData('power');
var userid=$.getData('userid');
// 页面DOM加载完成后执行初始化操作
$(document).ready(function(){
$("#mainFrame").attr("src","all_infor.html?userid="+userid+"&power="+power);
$("inputNone").attr("value",userid);
@ -19,7 +18,7 @@ $(document).ready(function(){
$("#mainFrame").css("height",h);
setList();
})
// 根据用户权限生成侧边栏菜单
function setList(){
var tagList=" ";
if(power=="0"){
@ -40,7 +39,7 @@ function setList(){
changeColor(event)
});
}
// 切换菜单选中状态（高亮当前点击的菜单，取消其他菜单的高亮）
function changeColor(event){
var obj=event.target;
var objSi=$(obj).siblings();

34
src/main/resources/static/js/staff_cleaner.js
Unescape View File

@ -2,7 +2,6 @@ var pageNum=1;
var pageSize=8;
var l;
/ 页面DOM加载完成后执行初始化操作
$(document).ready(function(){
getStaffList();
$("#pre").on('click',function(){
@ -32,9 +31,8 @@ function isEmptyString(str){
return 0;
}
// 全局变量：存储清洁工列表数据
var list;
// 从后端获取清洁工列表并展示
function getStaffList(){
$.ajax({
type:"post",
@ -45,7 +43,6 @@ function getStaffList(){
"pageSize":pageSize,
"power":"3"
},
// 请求成功的回调函数
success:function(data){
if(data.code){
if(isEmptyObject(data.List)&&pageNum>0){
@ -57,13 +54,11 @@ function getStaffList(){
var htmlStr=" ";
var btnStr=" ";
list=data.List;
l=0;// 重置当前页记录数
// 默认显示上一页、下一页按钮
l=0;
$("#pre").css("display","block");
$("#next").css("display","block");
$("#staffList").empty();
$("#staffList").append("<tr><th>账号</th><th>员工号</th><th>姓名</th><th>年龄</th><th>职位</th><th>联系方式</th><th>操作</th></tr>")
// 遍历清洁工列表，生成表格内容
for(i in list){
btnStr="<input type=\"button\" id=\"delUser\" data-userid=\""+list[i].userid+"\" class=\"btn btn-danger\" value=\"删除\"/>"
htmlStr="<tr data-userid=\""+list[i].userid+"\"><td>"+list[i].useraccount+"</td><td>"+list[i].idnumber+"</td><td>"+list[i].username+"</td><td>"+list[i].age+"</td><td>"+"清洁工"+"</td><td>"+list[i].phonenumber+"</td><td>"+btnStr+"</td></tr>";
@ -73,12 +68,10 @@ function getStaffList(){
}
if(pageNum=="1") $("#pre").css("display","none");
if(pageSize>l) $("#next").css("display","none");
// 绑定操作按钮的点击事件
btnOn();
}
}
else{
// 后端返回失败状态，仍尝试渲染列表（兼容处理）
alert("获取员工列表失败");
var power=" ";
var htmlStr=" ";
@ -108,29 +101,27 @@ function getStaffList(){
}
})
}
// 绑定操作按钮的点击事件
function btnOn(){
// 给"删除清洁工"按钮绑定点击事件，触发删除逻辑
$("input").filter("#delUser").on('click',function(event){
delUser(event);
});
// 给"跳转页码"按钮绑定点击事件，触发页码跳转
$("input").filter("#setPageBtn").on('click',function( ){
setPage( );
})
}
// 加载上一页数据
function getPre(){
pageNum=pageNum-1; // 页码减1
pageNum=pageNum-1;
getStaffList();
}
// 加载下一页数据
function getNext(){
pageNum=pageNum+1;
getStaffList();
}
// 跳转到指定页码
function setPage(){
if($("#inputPage").val()<0 || $("#inputPage").val()==0)
@ -142,7 +133,7 @@ function setPage(){
}
// 删除清洁工
function delUser(event){
var userid=$(event.target).data("userid");
$.ajax({
@ -168,7 +159,7 @@ function delUser(event){
})
}
// 添加新清洁工
function addUser(){
if(isEmptyString($("#inputAccount").val())||isEmptyString($("#inputPwd").val()))
alert("请填写全内容");
@ -178,9 +169,9 @@ function addUser(){
url:"../user/addUser.do",
dataType:"JSON",
data:{
"useraccount":$("#inputAccount").val(),// 清洁工账号
"password":$("#inputPwd").val(), // 清洁工密码
"power":"3" // 权限设置：3表示清洁工
"useraccount":$("#inputAccount").val(),
"password":$("#inputPwd").val(),
"power":"3"
},
success:function(data){
if(data.code==0){
@ -188,7 +179,6 @@ function addUser(){
$('#addUser').modal('toggle');
$("#inputAccount").val("");
$("#inputPwd").val("")
// 重新加载列表展示新添加的清洁工
getStaffList();
}
else

30
src/main/resources/static/js/staff_order.js
Unescape View File

@ -3,7 +3,6 @@ var pageSize=8;
var l;
$(document).ready(function(){
// 加载订单列表数据
getorderList();
$("#pre").on('click',function(){
getPre();
@ -17,16 +16,14 @@ $(document).ready(function(){
//判断对象/JSON是否为空 空返回1 非空返回0
function isEmptyObject(e) {
var t;
// 遍历对象，若存在属性则非空
for (t in e)
return 0;
return 1;
}
// 全局变量：存储订单列表数据
var list;
// 从后端获取订单列表并展示
function getorderList(){
$.ajax({
type:"post",
@ -36,7 +33,6 @@ function getorderList(){
"pageNum":pageNum,
"pageSize":pageSize
},
// 请求成功的回调函数
success:function(data){
if(isEmptyObject(data.List)&&pageNum>0){
pageNum=pageNum-1;
@ -50,16 +46,13 @@ function getorderList(){
var sdate;
var edate;
l=0;
// 默认显示上一页、下一页按钮
$("#pre").css("display","block");
$("#next").css("display","block");
$("#orderList").empty();
$("#orderList").append("<tr><th>入住人</th><th>身份证号</th><th>开始时间</th><th>结束时间</th><th>总金额</th><th>状态</th><th>操作</th></tr>")
// 遍历订单列表，生成表格内容
for(i in list){
sdate=/\d{4}-\d{1,2}-\d{1,2}/g.exec(list[i].starttime);
edate=/\d{4}-\d{1,2}-\d{1,2}/g.exec(list[i].endtime);
// 根据订单状态编码设置状态文本和操作按钮
if(list[i].state=="0"){
state="未付款";
btnStr="<input type=\"button\" class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\" data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\"> <input type=\"button\" class=\"btn btn-success\" data-orderid=\""+list[i].orderid+"\" id=\"setPaied\" value=\"已收款\"> <input type=\"button\" class=\"btn btn-danger\" data-orderid=\""+list[i].orderid+"\" id=\"setNone\" value=\"取消\">";
@ -76,7 +69,6 @@ function getorderList(){
state="已取消";
btnStr="<input type=\"button\" class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\" data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\">";
}
// 拼接表格行（包含订单信息和操作按钮）
htmlStr="<tr data-orderid=\""+list[i].orderid+"\"><td>"+list[i].householdname+"</td><td>"+list[i].id+"</td><td>"+sdate+"</td><td>"+edate+"</td><td>"+list[i].money+"</td><td>"+state+"</td><td>"+btnStr+"</td></tr>";
$("#orderList").append(htmlStr);
l++;
@ -92,41 +84,37 @@ function getorderList(){
}
})
}
// 绑定页面中操作按钮的点击事件
function btnOn(){
// 给"跳转页码"按钮绑定点击事件，触发页码跳转
$("input").filter("#setPageBtn").on('click',function( ){
setPage( );
});
// 给"查看房间"按钮绑定点击事件，触发查看房间详情
$("input").filter("#showRoom").on('click',function(event){
showRoom(event);
})
// 给"已收款"按钮绑定点击事件，将订单状态改为"已付款"（1）
$("input").filter("#setPaied").on('click',function(event){
setState(event,"1");
});
// 给"退房"按钮绑定点击事件，将订单状态改为"已完成"（2）
$("input").filter("#setFinish").on('click',function(event){
setState(event,"2");
});
// 给"取消"按钮绑定点击事件，将订单状态改为"已取消"（3）
$("input").filter("#setNone").on('click',function(event){
setState(event,"3");
});
}
// 加载上一页数据
function getPre(){
pageNum=pageNum-1;
getorderList();
}
// 加载下一页数据
function getNext(){
pageNum=pageNum+1;
getorderList();
}
// 修改订单状态
function setState(event,alter){
var orderid=$(event.target).data("orderid");
$.ajax({
@ -150,7 +138,7 @@ function setState(event,alter){
}
})
}
// 跳转到指定页码
function setPage(){
if($("#inputPage").val()<0 || $("#inputPage").val()==0)
@ -161,7 +149,7 @@ function setPage(){
}
}
// 查看订单对应的房间详情
function showRoom(event){
var roomid=$(event.target).data("roomid");
$.ajax({
@ -186,7 +174,6 @@ function showRoom(event){
state="已预定(入住)";
else
state="待清扫";
// 转换房间类型编码为文本
if(room.type=="1")
type="单人间";
else if(room.type=="2")
@ -195,7 +182,6 @@ function showRoom(event){
type="大床房";
else
type="套房";
// 拼接房间详情表格内容（位置、价格、类型、状态）
htmlStr="<tr><th>位置</th><td>"+room.local+"</td></tr><tr><th>价格</th><td>"+room.money+"</td></tr><tr><th>类型</th><td>"+type+"</td></tr><tr><th>状态</th><td>"+state+"</td></tr>"
$("#roomTable").append(htmlStr);
}

37
src/main/resources/static/js/staff_room.js
Unescape View File

@ -1,4 +1,3 @@
// 定义jQuery扩展方法：从URL参数中获取指定名称的值
(function($){
$.getData=function(name){
var reg=new RegExp("(^|&)"+name+"=([^&]+)(&|$)?");
@ -6,7 +5,7 @@
if (result!= null) return result[2]; return null;
}
})(jQuery);
// 从URL参数中获取员工ID（当前登录员工）
var staffid=$.getData("userid");
var pageNum=1;
var pageSize=8;
@ -14,30 +13,27 @@ var choose;
var l;
$(document).ready(function(){
// 加载可预订的房间列表
getroomList();
// 初始化开始日期选择器（datepicker插件）
$('#dateStart').datepicker({
language: 'zh-CN',
format: 'yyyy-mm-dd',
autoclose: true
}).on('changeDate',function(e){
// 选择开始日期后，设置结束日期的最小可选值为开始日期
var startTime = e.date;
$('#dateEnd').datepicker('setStartDate',startTime);
});
// 初始化结束日期选择器（datepicker插件）
$('#dateEnd').datepicker({
language: 'zh-CN',
format: 'yyyy-mm-dd',
autoclose: true
}).on('changeDate',function(e){
// 选择结束日期后，设置开始日期的最大可选值为结束日期
var endTime = e.date;
$('#dateStart').datepicker('setEndDate',endTime);
});
// 绑定"上一页"按钮点击事件
$("#pre").on('click',function(){
getPre();
});
@ -69,7 +65,6 @@ function isEmptyString(str){
var list;
// 从后端获取可预订的房间列表（状态为"未预定"）
function getroomList(){
$.ajax({
type:"post",
@ -81,7 +76,6 @@ function getroomList(){
"pageNum":pageNum,
"pageSize":pageSize
},
// 请求成功的回调函数
success:function(data){
if(isEmptyObject(data.List)&&pageNum>0){
pageNum=pageNum-1;
@ -95,15 +89,12 @@ function getroomList(){
var state=" ";
var type=" ";
l=0;
// 默认显示分页按钮
$("#pre").css("display","block");
$("#next").css("display","block");
$("#roomList").empty();
$("#roomList").append("<tr><th>位置</th><th>价格</th><th>状态</th><th>类型</th><th>操作</th></tr>");
state="未预定";
// 遍历房间列表生成表格内容
for(i in list){
// 转换房间类型编码为文本
for(i in list){
if(list[i].type=="1")
type="单人间";
else if(list[i].type=="2")
@ -112,13 +103,11 @@ function getroomList(){
type="大床房";
else
type="套房"
// 操作按钮：生成订单（绑定房间ID，点击打开弹窗）
btnStr="<input type=\"button\" class=\"btn btn-success\" data-roomid=\""+list[i].roomid+"\" id=\"chooseRoomBtn\" data-toggle=\"modal\" data-target=\"#chooseRoom\" value=\"生成订单\">";
htmlStr="<tr data-roomid=\""+list[i].roomid+"\"><td>"+list[i].local+"</td><td>"+list[i].money+"</td><td>"+state+"</td><td>"+type+"</td><td>"+btnStr+"</td></tr>";
$("#roomList").append(htmlStr);
l++;// 累加记录数
l++;
}
// 分页按钮控制：第1页隐藏上一页，最后一页隐藏下一页
if(pageNum=="1") $("#pre").css("display","none");
if(pageSize>l) $("#next").css("display","none");
btnOn();
@ -130,7 +119,7 @@ function getroomList(){
}
})
}
// 绑定页面操作按钮的点击事件
function btnOn(){;
$("input").filter("#setPageBtn").on('click',function( ){
setPage( );
@ -139,17 +128,17 @@ function btnOn(){;
chooseRoomBtn(event);
});
}
// 加载上一页数据
function getPre(){
pageNum=pageNum-1;
getroomList();
}
// 加载下一页数据
function getNext(){
pageNum=pageNum+1;
getroomList();
}
// 跳转到指定页码
function setPage(){
if($("#inputPage").val()<0 || $("#inputPage").val()==0)
alert("请输入正确页码");
@ -159,7 +148,7 @@ function setPage(){
}
}
// 选择房间并填充订单弹窗信息
function chooseRoomBtn(event){
var roomid=$(event.target).data("roomid");
choose=roomid;
@ -169,7 +158,7 @@ function chooseRoomBtn(event){
}
}
}
// 提交添加订单请求
function addOrder(){
if(isEmptyString($("#inputName").val())||isEmptyString($("#inputId").val())||isEmptyString($("#dateStart").val())||isEmptyString($("#dateEnd").val()))
alert("请填写全内容");
@ -194,9 +183,7 @@ function addOrder(){
$("#inputId").val("");
$("#dateStart").val("");
$("#dateEnd").val("");
// 关闭订单弹窗
$('#chooseRoom').modal('toggle');
// 跳转到订单管理页面
window.location.href="staff_order.html";
}
},

63
src/main/resources/static/pages/ad_manage.html
Unescape View File

@ -1,55 +1,42 @@
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
<!-- 适配移动端：设置视口，确保页面在不同设备上自适应显示 -->
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<!-- 引入Bootstrap样式库：提供基础UI组件（表格、按钮、表单等）的样式支持 -->
<link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
<!-- 引入自定义个人中心样式：补充项目专属的样式（如布局、颜色） -->
<link rel="stylesheet" type="text/css" href="../css/myCenter.css">
<!-- 引入自定义页面通用样式：统一页面间的基础样式（如边距、字体） -->
<link rel="stylesheet" type="text/css" href="../css/pages.css">
<meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
<link rel="stylesheet" type="text/css" href="../css/myCenter.css">
<link rel="stylesheet" type="text/css" href="../css/pages.css">
</head>
<body>
<!-- 主体内容容器：占11列（Bootstrap栅格系统），清除默认内边距，设置顶部和左侧内边距控制位置 -->
<div class="col-md-11 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 3rem">
<!-- 表格响应式容器：在小屏幕上自动出现横向滚动条，确保表格内容不溢出 -->
<div class="table-responsive">
<!-- 表格组件：边框样式、鼠标悬浮高亮，设置顶部间距，通过ID关联JS操作 -->
<table class="table table-bordered table-hover" style="margin-top: 10px" id="staffList">
<!-- 表格表头：定义列名，对应员工管理所需的核心信息字段 -->
<tr><th>账号</th><th>员工号</th><th>姓名</th><th>年龄</th><th>职位</th><th>联系方式</th><th>操作</th></tr>
</table>
<!-- 分页控制区域：占12列（全屏宽度），使用内联表单布局 -->
<div class="col-md-12">
<form class="form-inline">
<!-- 上一页按钮组：设置右侧间距，通过ID供JS绑定点击事件 -->
<div class="form-group" style="margin-right: 10xp">
<a href="#" id="pre">上一页 </a>
</div>
<!-- （注释掉的）页码跳转功能：输入页码后点击按钮跳转，当前未启用 -->
<!--<div class="form-group">
<input type="text" style="width: 5rem" class="form-control" id="inputPage">
<input type="button" id="setPageBtn" class="btn btn-default" value="跳转">
</div>-->
<!-- 下一页按钮组：设置左侧间距，通过ID供JS绑定点击事件 -->
<div class="form-group" style="margin-left: 10px">
<a href="#" id="next">下一页</a>
</div>
</form>
<div class="table-responsive">
<table class="table table-bordered table-hover" style="margin-top: 10px" id="staffList">
<tr><th>账号</th><th>员工号</th><th>姓名</th><th>年龄</th><th>职位</th><th>联系方式</th><th>操作</th></tr>
</table>
<div class="col-md-12">
<form class="form-inline">
<div class="form-group" style="margin-right: 10xp">
<a href="#" id="pre">上一页 </a>
</div>
<!--<div class="form-group">
<input type="text" style="width: 5rem" class="form-control" id="inputPage">
<input type="button" id="setPageBtn" class="btn btn-default" value="跳转">
</div>-->
<div class="form-group" style="margin-left: 10px">
<a href="#" id="next">下一页</a>
</div>
</form>
</div>
</div>
</div>
</body>
</html>
<!-- 引入jQuery库：提供DOM操作、AJAX请求等基础功能，是Bootstrap和自定义JS的依赖 -->
<script type="text/javascript" src="../js/jquery.min.js"></script>
<!-- 引入Bootstrap JS库：实现模态框、下拉菜单等组件的交互功能 -->
<script type="text/javascript" src="../js/bootstrap.min.js"></script>
<!-- 引入员工管理自定义JS：实现表格数据加载、分页切换等核心业务逻辑 -->
<script type="text/javascript" src="../js/ad_manage.js"></script>
<script type="text/javascript" src="../js/ad_manage.js"></script>

125
src/main/resources/static/pages/ad_order.html
Unescape View File

@ -1,91 +1,78 @@
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
<!-- 移动端适配：设置视口属性，确保页面在手机、平板等设备上自适应显示，禁止缩放 -->
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<!-- 引入Bootstrap样式库：提供表格、按钮、模态框等基础UI组件的默认样式，减少自定义CSS工作量 -->
<link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
<!-- 引入自定义个人中心样式：补充项目专属的布局、颜色等样式，确保页面风格统一 -->
<link rel="stylesheet" type="text/css" href="../css/myCenter.css">
<!-- 引入自定义页面通用样式：统一各页面的边距、字体、间距等基础样式 -->
<link rel="stylesheet" type="text/css" href="../css/pages.css">
<meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
<link rel="stylesheet" type="text/css" href="../css/myCenter.css">
<link rel="stylesheet" type="text/css" href="../css/pages.css">
</head>
<body>
<!-- 左侧订单列表区域：占9列（Bootstrap栅格），清除默认内边距，设置顶部和左侧内边距控制位置 -->
<div class="col-md-9 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 2rem">
<!-- 响应式表格容器：小屏幕下自动显示横向滚动条，避免表格内容溢出页面 -->
<div class="table-responsive">
<!-- 订单表格：带边框、鼠标悬浮高亮效果，通过ID供JS动态渲染数据 -->
<table class="table table-bordered table-hover" style="margin-top: 10px" id="orderList">
<!-- 表格表头：定义订单核心信息列，与后端返回的订单数据字段对应 -->
<tr><th>入住人</th><th>身份证号</th><th>开始时间</th><th>结束时间</th><th>总金额</th><th>状态</th><th>操作</th></tr>
</table>
<!-- 分页控制区：占12列（全屏宽度），采用内联表单布局使元素横向排列 -->
<div class="col-md-12">
<form class="form-inline">
<!-- 上一页按钮：设置右侧间距，通过ID供JS绑定分页切换事件 -->
<div class="form-group" style="margin-right: 10xp">
<a href="#" id="pre">上一页 </a>
</div>
<!-- （注释待启用）页码跳转功能：输入页码后点击按钮跳转，当前暂未实现 -->
<!--<div class="form-group">
<input type="text" style="width: 5rem" class="form-control" id="inputPage">
<input type="button" id="setPageBtn" class="btn btn-default" value="跳转">
</div>-->
<!-- 下一页按钮：设置左侧间距，通过ID供JS绑定分页切换事件 -->
<div class="form-group" style="margin-left: 10px">
<a href="#" id="next">下一页</a>
</div>
</form>
<div class="table-responsive">
<table class="table table-bordered table-hover" style="margin-top: 10px" id="orderList">
<tr><th>入住人</th><th>身份证号</th><th>开始时间</th><th>结束时间</th><th>总金额</th><th>状态</th><th>操作</th></tr>
</table>
<div class="col-md-12">
<form class="form-inline">
<div class="form-group" style="margin-right: 10xp">
<a href="#" id="pre">上一页 </a>
</div>
<!--<div class="form-group">
<input type="text" style="width: 5rem" class="form-control" id="inputPage">
<input type="button" id="setPageBtn" class="btn btn-default" value="跳转">
</div>-->
<div class="form-group" style="margin-left: 10px">
<a href="#" id="next">下一页</a>
</div>
</form>
</div>
</div>
</div>
<!-- 右侧数据统计区域：占3列（Bootstrap栅格），与左侧订单列表并列，展示核心运营数据 -->
<div class="col-md-3 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 20px">
<!-- 总交易额统计卡片：使用列表组样式，通过ID供JS填充统计数据 -->
<div class="col-md-8 col-xs-6 nopadding">
<ul class="list-group">
<li class="list-group-item" style="color:black !important;border: 0.5px solid #C8C8BF">
<span class="badge" id="totalMoney"> </span> <!-- 徽章样式显示金额数据，更醒目 -->
总交易额
</li>
</ul>
</div>
<!-- 总订房数统计卡片：与交易额卡片样式统一，通过ID供JS填充数据 -->
<div class="col-md-8 col-xs-6 nopadding">
<ul class="list-group">
<li class="list-group-item" style="color:black !important;border: 0.5px solid #C8C8BF">
<span class="badge" id="totalRoom"> </span> <!-- 徽章样式显示数量数据 -->
总订房数
</li>
</ul>
</div>
<div class="col-md-8 col-xs-6 nopadding">
<ul class="list-group">
<li class="list-group-item" style="color:black !important;border: 0.5px solid #C8C8BF">
<span class="badge" id="totalMoney"> </span>
总交易额
</li>
</ul>
</div>
<div class="col-md-8 col-xs-6 nopadding">
<ul class="list-group">
<li class="list-group-item" style="color:black !important;border: 0.5px solid #C8C8BF">
<span class="badge" id="totalRoom"> </span>
总订房数
</li>
</ul>
</div>
</div>
</body>
</html>
<!-- 房间详情模态框：隐藏状态，点击订单“操作”列按钮时弹出，展示订单关联的房间信息 -->
<div class="modal fade" id="showRoomT" tabindex="-1" role="dialog" aria-labelledby="myModalLabel">
<div class="modal-dialog" role="document"> <!-- 模态框容器，控制弹窗大小和位置 -->
<div class="modal-content"> <!-- 模态框内容区域，包含头部、主体 -->
<div class="modal-header"> <!-- 模态框头部：标题+关闭按钮 -->
<button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
<h4 class="modal-title" id="myModalLabel">房间详情</h4> <!-- 模态框标题 -->
</div>
<div class="modal-body"> <!-- 模态框主体：展示房间详情的表格 -->
<table class="table table-bordered table-hover" style="margin-top:10px" id="roomTable">
</table> <!-- 表格通过ID供JS动态渲染房间数据（如房间号、位置、价格） -->
</div>
</div>
<div class="modal-dialog" role="document">
<div class="modal-content">
<div class="modal-header">
<button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
<h4 class="modal-title" id="myModalLabel">房间详情</h4>
</div>
<div class="modal-body">
<table class="table table-bordered table-hover" style="margin-top:10px" id="roomTable">
</table>
</div>
</div>
</div>
</div>
<!-- 引入依赖JS文件：确保DOM加载完成前加载核心库，避免报错 -->
<script type="text/javascript" src="../js/jquery.min.js"></script> <!-- jQuery：提供DOM操作、AJAX请求核心能力 -->
<script type="text/javascript" src="../js/bootstrap.min.js"></script> <!-- Bootstrap JS：实现模态框弹出/关闭、响应式交互 -->
<script type="text/javascript" src="../js/ad_order.js"></script> <!-- 订单管理自定义JS：实现数据加载、分页、模态框交互等业务逻辑 -->
<script type="text/javascript" src="../js/jquery.min.js"></script>
<script type="text/javascript" src="../js/bootstrap.min.js"></script>
<script type="text/javascript" src="../js/ad_order.js"></script>

120
src/main/resources/static/pages/ad_salary.html
Unescape View File

@ -1,73 +1,73 @@
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
<!-- 移动端适配配置：控制页面在不同设备上的缩放行为，确保移动端显示正常 -->
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<!-- 引入Bootstrap基础样式：提供表格、按钮、输入框等组件的默认样式，保证界面统一性 -->
<link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
<!-- 引入自定义个人中心样式：补充项目专属的布局、颜色等样式，匹配整体设计风格 -->
<link rel="stylesheet" type="text/css" href="../css/myCenter.css">
<!-- 引入自定义通用页面样式：统一各页面的边距、字体等基础样式，减少重复代码 -->
<link rel="stylesheet" type="text/css" href="../css/pages.css">
<meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
<link rel="stylesheet" type="text/css" href="../css/myCenter.css">
<link rel="stylesheet" type="text/css" href="../css/pages.css">
</head>
<body>
<!-- 主体内容容器：占6列（Bootstrap栅格系统），清除默认内边距，设置顶部和左侧内边距调整位置 -->
<div class="col-md-6 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 3rem">
<!-- 配置查看面板（默认显示）：用于展示当前薪资配置数据 -->
<div class="table-responsive" id="showConfigDiv">
<!-- “更改配置”按钮：带铅笔图标，点击切换到编辑面板，通过ID绑定JS事件 -->
<a href="#" id="showConfig" style="font-size:1.7rem">
<span class="glyphicon glyphicon-pencil"></span> <!-- Bootstrap内置图标，标识“编辑”功能 -->
<span>更改配置</span>
</a>
<!-- 配置展示表格：带边框、鼠标悬浮高亮效果，通过ID供JS动态渲染数据 -->
<table class="table table-bordered table-hover" style="margin-top: 10px" id="configList">
<!-- 表格表头：定义“职位”“底薪”“提成”三列，对应薪资配置的核心字段 -->
<tr><th style="width: 100px">职位</th><th>底薪</th><th>提成</th></tr>
</table>
</div>
<div class="table-responsive" id="showConfigDiv">
<a href="#" id="showConfig" style="font-size:1.7rem">
<span class="glyphicon glyphicon-pencil"></span>
<span>更改配置</span>
</a>
<table class="table table-bordered table-hover" style="margin-top: 10px" id="configList">
<tr><th style="width: 100px">职位</th><th>底薪</th><th>提成</th></tr>
</table>
</div>
<div class="table-responsive" id="alterConfigDiv" style="display: none">
<a href="#" id="alterConfig" style="font-size:1.7rem">
<span class="glyphicon glyphicon-pencil"></span>
<span>返回</span>
</a>
<table class="table table-bordered table-hover" style="margin-top: 10px">
<tr><th style="width: 100px">职位</th><th>底薪</th><th>提成</th></tr>
<tr>
<th>经理</th>
<th>
<input type="text" class="form-control" id="inputMS">
</th>
<th>
<input type="text" class="form-control" id="inputM">
</th>
</tr>
<tr>
<th>员工</th>
<th>
<input type="text" class="form-control" id="inputSS">
</th>
<th>
<input type="text" class="form-control" id="inputS">
</th>
</tr>
<tr>
<th>清洁工</th>
<th>
<input type="text" class="form-control" id="inputCS">
</th>
<th>
<input type="text" class="form-control" id="inputC">
</th>
</tr>
</table>
<input style="float: right" type="button" id="alterConfigBtn" class="btn btn-success" value="确定"/>
</div>
<!-- 配置编辑面板（默认隐藏）：用于修改薪资配置，初始通过display: none隐藏 -->
<div class="table-responsive" id="alterConfigDiv" style="display: none">
<!-- “返回”按钮：点击切换回查看面板，通过ID绑定JS事件 -->
<a href="#" id="alterConfig" style="font-size:1.7rem">
<span class="glyphicon glyphicon-pencil"></span>
<span>返回</span>
</a>
<!-- 配置编辑表格：包含输入框，供管理员输入新的薪资数据 -->
<table class="table table-bordered table-hover" style="margin-top: 10px">
<tr><th style="width: 100px">职位</th><th>底薪</th><th>提成</th></tr>
<!-- 经理薪资编辑行：输入框通过ID供JS获取新值 -->
<tr>
<th>经理</th>
<th><input type="text" class="form-control" id="inputMS"></th> <!-- 经理底薪输入框 -->
<th><input type="text" class="form-control" id="inputM"></th> <!-- 经理提成输入框 -->
</tr>
<!-- 普通员工薪资编辑行 -->
<tr>
<th>员工</th>
<th><input type="text" class="form-control" id="inputSS"></th> <!-- 员工底薪输入框 -->
<th><input type="text" class="form-control" id="inputS"></th> <!-- 员工提成输入框 -->
</tr>
<!-- 清洁工薪资编辑行 -->
<tr>
<th>清洁工</th>
<th><input type="text" class="form-control" id="inputCS"></th> <!-- 清洁工底薪输入框 -->
<th><input type="text" class="form-control" id="inputC"></th> <!-- 清洁工提成输入框 -->
</tr>
</table>
<!-- 确认修改按钮：右对齐，绿色按钮突出“确认”操作，通过ID绑定JS提交事件 -->
<input style="float: right" type="button" id="alterConfigBtn" class="btn btn-success" value="确定"/>
</div>
</div>
</body>
</html>
<!-- 引入依赖JS文件：确保DOM加载前加载核心库，避免交互逻辑报错 -->
<script type="text/javascript" src="../js/jquery.min.js"></script> <!-- jQuery：提供DOM操作、AJAX请求能力 -->
<script type="text/javascript" src="../js/bootstrap.min.js"></script> <!-- Bootstrap JS：支持图标渲染、组件交互 -->
<script type="text/javascript" src="../js/ad_salary.js"></script> <!-- 薪资配置自定义JS：实现面板切换、数据加载与提交 -->
</html>
<script type="text/javascript" src="../js/jquery.min.js"></script>
<script type="text/javascript" src="../js/bootstrap.min.js"></script>
<script type="text/javascript" src="../js/ad_salary.js"></script>

215
src/main/resources/static/pages/all_infor.html
Unescape View File

@ -1,73 +1,180 @@
<!DOCTYPE html>
<html>
<head>
<title>用户信息</title>
<meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
<!-- 移动端适配：设置视口，确保页面在手机、平板等设备上自适应显示，禁止缩放 -->
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<!-- 引入Bootstrap样式库：提供表格、按钮、输入框等基础UI组件的默认样式，保证界面统一性 -->
<link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
<!-- 引入自定义个人中心样式：补充项目专属的布局、颜色、字体等样式，匹配整体设计风格 -->
<link rel="stylesheet" type="text/css" href="../css/myCenter.css">
<!-- 引入自定义页面通用样式：统一各页面的边距、间距等基础样式，减少重复代码 -->
<link rel="stylesheet" type="text/css" href="../css/pages.css">
</head>
<body>
<!-- 主体内容容器：占6列（Bootstrap栅格），清除默认内边距，设置顶部和左侧内边距控制位置 -->
<div class="col-md-6 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 3rem">
<!-- 配置查看面板（默认显示）：用于展示当前系统中的薪资配置信息 -->
<div class="table-responsive" id="showConfigDiv">
<!-- 更改配置按钮：带铅笔图标，点击切换到编辑面板，通过ID供JS绑定点击事件 -->
<a href="#" id="showConfig" style="font-size:1.7rem">
<span class="glyphicon glyphicon-pencil"></span> <!-- Bootstrap图标：表示“编辑”操作 -->
<span>更改配置</span>
</a>
<!-- 配置展示表格：带边框、鼠标悬浮高亮，通过ID供JS动态渲染当前薪资配置数据 -->
<table class="table table-bordered table-hover" style="margin-top: 10px" id="configList">
<!-- 表格表头：定义“职位”“底薪”“提成”三列，与薪资配置数据字段对应 -->
<tr><th style="width: 100px">职位</th><th>底薪</th><th>提成</th></tr>
</table>
<div class="col-md-12 col-xs-12 nopadding" style="padding-top:4rem;">
<div class="col-md-3 col-xs-4 nopadding" style="margin-bottom:10px">
<img id="userpic" class="userpic" src=" "/>
<div class="col-md-12 col-xs-12 username">
<a href="#" data-toggle="modal" data-target="#changePic">
<span class="glyphicon glyphicon-pencil"></span>
<span>修改头像</span>
</a>
</div>
</div>
<div class="col-md-6 col-xs-8 nopadding" style="border-left:1px solid gray;padding-left: 20px">
<div class="col-md-12 col-xs-12" style="font-size: 1.5rem;margin-bottom: 10px;display: block" id="showInfodiv">
<a href="#" id="showInfo">
<span class="glyphicon glyphicon-pencil"></span>
<span>修改信息</span>
</a>
<div class="fdata">
<p>
<span>账号 Account ：</span>
<span class="value" id="account">用户名</span>
<a href="#" style="margin-left: 20px" data-toggle="modal" data-target="#changePwd">
<span class="glyphicon glyphicon-pencil"></span>
<span>修改密码</span>
</a>
</p>
</div>
<div class="fdata">
<p>
<span>工号 ID ：</span>
<span class="value" id="idnum"></span>
</p>
</div>
<div class="fdata">
<p>
<span>姓名 Name ：</span>
<span class="value" id="name"></span>
</p>
</div>
<div class="fdata" id="showS" style="display: none">
<p>
<span>底薪 Basic Salary ：</span>
<span class="value" id="salary"></span>
</p>
</div>
<div class="fdata" id="showC" style="display: none">
<p>
<span>提成 Commission ：</span>
<span class="value" id="commission"></span>
</p>
</div>
<div class="fdata">
<p>
<span>年龄 Age ：</span>
<span class="value" id="age"></span>
</p>
</div>
<div class="fdata">
<p>
<span>手机号 PhoneNumber ：</span>
<span class="value" id="phone"></span>
</p>
</div>
</div>
<div class="col-md-12 col-xs-12" style="font-size:1.5rem;margin-bottom: 10px;display: none" id="showAlterdiv">
<a href="#" id="showAlter">
<span class="glyphicon glyphicon-chevron-left"></span>
<span>返回</span>
</a>
<form class="form-inline" style="margin-top: 10px">
<div class="form-group alterinfo col-xs-12 col-md-12">姓名：
<label for="name">Name</label>
<input type="text" name="name" class="form-control" id="inputName">
</div>
<div class="form-group alterinfo col-xs-12 col-md-12">年龄：
<label for="age">Age</label>
<input type="text" name="age" class="form-control" id="inputAge">
</div>
<div class="form-group alterinfo col-xs-12 col-md-12">手机号：
<label for="phone">Phone</label>
<input type="text" name="phone" class="form-control" id="inputPhone">
</div>
<div class="form-group alterinfo col-xs-12 col-md-12">
<input type="button" id="alterInfoBtn" class="btn btn-success" value="确定"/>
</div>
</form>
</div>
<!-- 配置编辑面板（默认隐藏）：用于修改薪资配置，通过style="display: none"控制初始隐藏 -->
<div class="table-responsive" id="alterConfigDiv" style="display: none">
<!-- 返回按钮：点击切换回查看面板，通过ID供JS绑定点击事件 -->
<a href="#" id="alterConfig" style="font-size:1.7rem">
<span class="glyphicon glyphicon-pencil"></span>
<span>返回</span>
</a>
<!-- 配置编辑表格：包含输入框，供管理员输入新的薪资和提成数据 -->
<table class="table table-bordered table-hover" style="margin-top: 10px">
<tr><th style="width: 100px">职位</th><th>底薪</th><th>提成</th></tr>
<!-- 经理薪资编辑行：输入框通过ID供JS获取新值 -->
<tr>
<th>经理</th>
<th><input type="text" class="form-control" id="inputMS"></th> <!-- 经理底薪输入框 -->
<th><input type="text" class="form-control" id="inputM"></th> <!-- 经理提成输入框 -->
</tr>
<!-- 员工薪资编辑行 -->
<tr>
<th>员工</th>
<th><input type="text" class="form-control" id="inputSS"></th> <!-- 员工底薪输入框 -->
<th><input type="text" class="form-control" id="inputS"></th> <!-- 员工提成输入框 -->
</tr>
<!-- 清洁工薪资编辑行 -->
<tr>
<th>清洁工</th>
<th><input type="text" class="form-control" id="inputCS"></th> <!-- 清洁工底薪输入框 -->
<th><input type="text" class="form-control" id="inputC"></th> <!-- 清洁工提成输入框 -->
</tr>
</table>
<!-- 确认修改按钮：点击提交新的薪资配置，通过ID供JS绑定点击事件，绿色按钮突出“确认”操作 -->
<input style="float: right" type="button" id="alterConfigBtn" class="btn btn-success" value="确定"/>
</div>
</div>
</body>
</html>
<!-- 引入依赖JS文件：确保DOM加载前加载核心库，避免交互逻辑报错 -->
<script type="text/javascript" src="../js/jquery.min.js"></script> <!-- jQuery：提供DOM操作、AJAX请求核心能力 -->
<script type="text/javascript" src="../js/bootstrap.min.js"></script> <!-- Bootstrap JS：支持图标渲染、组件交互 -->
<script type="text/javascript" src="../js/ad_salary.js"></script> <!-- 薪资配置自定义JS：实现查看/编辑面板切换、数据加载与提交等业务逻辑 -->
<div class="modal fade" id="changePic" tabindex="-1" role="dialog">
<div class="modal-dialog" role="document">
<div class="modal-content">
<div class="modal-header">
<button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
<h4 class="modal-title">修改头像</h4>
</div>
<div class="modal-body">
<script type="text/javascript">
function saveReport(){
$("#uploadProfile").ajaxSubmit(function(data){
console.log(data);
if(data.code==0)
alert("修改头像成功!");
else
alert("修改头像失败!");
window.location.reload();
});
return false;
//必须返回false，否则表单会自己再做一次提交操作，并且页面跳转
}
</script>
<form action="../upFile/upFilePhoto.do" method="post" enctype="multipart/form-data" onsubmit="return saveReport()" id="uploadProfile">
<input type="text" name="userid" class="form-control" id="inputNone" style="display: none;">文件大小1M以内
<input id="inputFile" name="file" class="btn-file-molding" type="file"><br/>
<input type="submit" id="alterProfile" class="btn btn-success" value="修改头像"/>
<form>
</div>
</div>
</div>
</div>
<div class="modal fade" id="changePwd" tabindex="-1" role="dialog">
<div class="modal-dialog" role="document">
<div class="modal-content">
<div class="modal-header">
<button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
<h4 class="modal-title">修改密码</h4>
</div>
<div class="modal-body" style="width: 80%;padding-left:20%">
<div class="form-group alterinfo">请输入原密码：
<label for="oldPwd">oldPwd</label>
<input type="password" name="oldPwd" class="form-control" id="inputoldPwd">
</div>
<div class="form-group alterinfo">请输入新密码：
<label for="newPwd">newPwd</label>
<input type="password" name="newPwd" class="form-control" id="inputnewPwd">
</div>
<div class="form-group alterinfo">确认新密码：
<label for="renewPwd">newPwd</label>
<input type="password" name="renewPwd" class="form-control" id="inputrenewPwd">
</div>
<div class="form-group alterinfo">
<input type="button" id="alterPwdBtn" class="btn btn-success" value="确定"/>
</div>
</div>
</div>
</div>
</div>
</html>
<script type="text/javascript" src="../js/jquery.min.js"></script>
<script type="text/javascript" src="../js/bootstrap.min.js"></script>
<script type="text/javascript" src="../js/jquery-form.js"></script>
<script type="text/javascript" src="../js/all_infor.js"></script>

67
src/main/resources/static/pages/cleaner_room.html
Unescape View File

@ -1,53 +1,44 @@
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
<!-- 移动端适配：控制页面在手机、平板等设备上的缩放，确保自适应显示，禁止手动缩放 -->
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<!-- 引入Bootstrap基础样式：提供表格、按钮、表单等组件的默认样式，保证界面美观统一 -->
<link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
<!-- 引入自定义个人中心样式：补充项目专属的布局、颜色、字体等样式，匹配整体设计风格 -->
<link rel="stylesheet" type="text/css" href="../css/myCenter.css">
<!-- 引入自定义通用页面样式：统一各页面的边距、间距等基础样式，减少重复代码 -->
<link rel="stylesheet" type="text/css" href="../css/pages.css">
<meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
<link rel="stylesheet" type="text/css" href="../css/myCenter.css">
<link rel="stylesheet" type="text/css" href="../css/pages.css">
</head>
<body>
<!-- 主体内容容器：占8列（Bootstrap栅格系统），清除默认内边距，设置顶部和左侧内边距调整位置 -->
<div class="col-md-8 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 3rem">
<!-- 响应式表格容器：小屏幕下自动显示横向滚动条，避免表格内容溢出页面 -->
<div class="table-responsive">
<!-- 房间列表表格：带边框、鼠标悬浮高亮效果，通过ID供JS动态渲染房间数据 -->
<table class="table table-bordered table-hover" style="margin-top: 10px" id="roomList">
<!-- 表格表头：定义“位置”“价格”“状态”“类型”“操作”五列，对应房间管理核心信息 -->
<tr><th>位置</th><th>价格</th><th>状态</th><th>类型</th><th>操作</th></tr>
</table>
<!-- 分页控制区：占12列（全屏宽度），采用内联表单布局使分页元素横向排列 -->
<div class="col-md-12">
<form class="form-inline">
<!-- 上一页按钮：设置右侧间距，通过ID供JS绑定分页切换事件 -->
<div class="form-group" style="margin-right: 10xp">
<a href="#" id="pre">上一页 </a>
</div>
<!-- （注释待启用）页码跳转功能：输入页码后点击按钮跳转，当前暂未实现 -->
<!--<div class="form-group">
<input type="text" style="width: 5rem" class="form-control" id="inputPage">
<input type="button" id="setPageBtn" class="btn btn-default" value="跳转">
</div>-->
<!-- 下一页按钮：设置左侧间距，通过ID供JS绑定分页切换事件 -->
<div class="form-group" style="margin-left: 10px">
<a href="#" id="next">下一页</a>
</div>
</form>
<div class="table-responsive">
<table class="table table-bordered table-hover" style="margin-top: 10px" id="roomList">
<tr><th>位置</th><th>价格</th><th>状态</th><th>类型</th><th>操作</th></tr>
</table>
<div class="col-md-12">
<form class="form-inline">
<div class="form-group" style="margin-right: 10xp">
<a href="#" id="pre">上一页 </a>
</div>
<!--<div class="form-group">
<input type="text" style="width: 5rem" class="form-control" id="inputPage">
<input type="button" id="setPageBtn" class="btn btn-default" value="跳转">
</div>-->
<div class="form-group" style="margin-left: 10px">
<a href="#" id="next">下一页</a>
</div>
</form>
</div>
</div>
</div>
</body>
</html>
<script type="text/javascript" src="../js/jquery.min.js"></script>
<script type="text/javascript" src="../js/bootstrap.min.js"></script>
<script type="text/javascript" src="../js/cleaner_room.js"></script>
<!-- 引入依赖JS文件：确保DOM加载前加载核心库，避免交互逻辑报错 -->
<script type="text/javascript" src="../js/jquery.min.js"></script> <!-- jQuery：提供DOM操作、AJAX请求核心能力 -->
<script type="text/javascript" src="../js/bootstrap.min.js"></script> <!-- Bootstrap JS：支持响应式组件交互（如表格样式渲染） -->
<script type="text/javascript" src="../js/cleaner_room.js"></script> <!-- 清洁工房间管理自定义JS：实现房间数据加载、分页切换、操作按钮功能等业务逻辑 -->

206
src/main/resources/static/pages/manage_room.html
Unescape View File

@ -1,136 +1,114 @@
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
<!-- 移动端适配：控制页面在不同设备上的缩放行为，确保移动端显示正常且禁止手动缩放 -->
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<!-- 引入Bootstrap基础样式：提供表格、模态框、按钮等组件的默认样式，保证界面统一性 -->
<link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
<!-- 引入自定义个人中心样式：补充项目专属的布局、颜色等样式，匹配整体设计风格 -->
<link rel="stylesheet" type="text/css" href="../css/myCenter.css">
<!-- 引入自定义通用页面样式：统一各页面的边距、字体等基础样式，减少重复代码 -->
<link rel="stylesheet" type="text/css" href="../css/pages.css">
<meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
<link rel="stylesheet" type="text/css" href="../css/myCenter.css">
<link rel="stylesheet" type="text/css" href="../css/pages.css">
</head>
<body>
<!-- 主体内容容器：占10列（Bootstrap栅格系统），清除默认内边距，设置顶部和左侧内边距调整位置 -->
<div class="col-md-10 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 3rem">
<!-- 响应式表格容器：小屏幕下自动显示横向滚动条，避免表格内容溢出页面 -->
<div class="table-responsive">
<!-- “添加房间”按钮：带铅笔图标，点击通过data属性触发“添加房间”模态框 -->
<a href="#" style="font-size:1.7rem" data-toggle="modal" data-target="#addRoom" >
<span class="glyphicon glyphicon-pencil"></span> <!-- Bootstrap内置图标，标识“新增”功能 -->
<span>添加房间</span>
</a>
<!-- 房间列表表格：带边框、鼠标悬浮高亮效果，固定列宽避免布局混乱，通过ID供JS动态渲染数据 -->
<table class="table table-bordered table-hover" style="margin-top: 10px" id="roomList">
<!-- 表格表头：定义“位置”“价格”“状态”“类型”“操作”五列，对应房间管理核心字段 -->
<tr><th style="width:100px">位置</th><th style="width:100px">价格</th><th style="width:100px">状态</th><th style="width:100px">类型</th><th>操作</th></tr>
</table>
<!-- 分页控制区：占12列（全屏宽度），采用内联表单布局使分页元素横向排列 -->
<div class="col-md-12">
<form class="form-inline">
<!-- 上一页按钮：设置右侧间距，通过ID供JS绑定分页切换事件 -->
<div class="form-group" style="margin-right: 10xp">
<a href="#" id="pre">上一页 </a>
</div>
<!-- （注释待启用）页码跳转功能：输入页码后点击按钮跳转，当前暂未实现 -->
<!--<div class="form-group">
<input type="text" style="width: 5rem" class="form-control" id="inputPage">
<input type="button" id="setPageBtn" class="btn btn-default" value="跳转">
</div>-->
<!-- 下一页按钮：设置左侧间距，通过ID供JS绑定分页切换事件 -->
<div class="form-group" style="margin-left: 10px">
<a href="#" id="next">下一页</a>
</div>
</form>
<div class="table-responsive">
<a href="#" style="font-size:1.7rem" data-toggle="modal" data-target="#addRoom" >
<span class="glyphicon glyphicon-pencil"></span>
<span>添加房间</span>
</a>
<table class="table table-bordered table-hover" style="margin-top: 10px" id="roomList">
<tr><th style="width:100px">位置</th><th style="width:100px">价格</th><th style="width:100px">状态</th><th style="width:100px">类型</th><th>操作</th></tr>
</table>
<div class="col-md-12">
<form class="form-inline">
<div class="form-group" style="margin-right: 10xp">
<a href="#" id="pre">上一页 </a>
</div>
<!--<div class="form-group">
<input type="text" style="width: 5rem" class="form-control" id="inputPage">
<input type="button" id="setPageBtn" class="btn btn-default" value="跳转">
</div>-->
<div class="form-group" style="margin-left: 10px">
<a href="#" id="next">下一页</a>
</div>
</form>
</div>
</div>
</div>
</body>
<!-- 新增房间模态框：隐藏状态，通过data-target="#addRoom"触发显示，用于录入新房间信息 -->
<div class="modal fade" id="addRoom" tabindex="-1" role="dialog">
<div class="modal-dialog" role="document"> <!-- 模态框容器，控制弹窗大小和位置 -->
<div class="modal-content"> <!-- 模态框内容区域，包含头部、主体 -->
<div class="modal-header"> <!-- 模态框头部：标题+关闭按钮 -->
<button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
<h4 class="modal-title">添加房间</h4> <!-- 模态框标题，明确功能用途 -->
</div>
<div class="modal-body" style="width: 80%;padding-left:20%"> <!-- 模态框主体：表单区域，居中布局 -->
<!-- 房间位置输入项：标签+输入框，通过ID供JS获取输入值 -->
<div class="form-group alterinfo">请输入位置：
<label for="inputLocal">inputPrice</label> <!-- 标签for属性与输入框ID关联，提升可访问性 -->
<input type="text" name="inputLocal" class="form-control" id="inputLocal">
</div>
<!-- 房间价格输入项 -->
<div class="form-group alterinfo">请输入价格：
<label for="inputPrice">inputPrice</label>
<input type="text" name="inputPrice" class="form-control" id="inputPrice">
</div>
<!-- 房间类型下拉选择项：预设单人间、双人间等选项，通过ID供JS获取选择值 -->
<div class="form-group alterinfo">请选择类型：
<select class="form-control" id="inputType">
<option value="1">单人间</option>
<option value="2">双人间</option>
<option value="3">大床房</option>
<option value="4">套房</option>
</select>
</div>
<!-- 确认添加按钮：绿色按钮突出“确认”操作，通过ID供JS绑定提交事件 -->
<div class="form-group alterinfo">
<input type="button" id="addRoomBtn" class="btn btn-success" value="确定"/>
</div>
</div>
</div>
<div class="modal-dialog" role="document">
<div class="modal-content">
<div class="modal-header">
<button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
<h4 class="modal-title">添加房间</h4>
</div>
<div class="modal-body" style="width: 80%;padding-left:20%">
<div class="form-group alterinfo">请输入位置：
<label for="inputLocal">inputPrice</label>
<input type="text" name="inputLocal" class="form-control" id="inputLocal">
</div>
<div class="form-group alterinfo">请输入价格：
<label for="inputPrice">inputPrice</label>
<input type="text" name="inputPrice" class="form-control" id="inputPrice">
</div>
<div class="form-group alterinfo">请选择类型：
<select class="form-control" id="inputType">
<option value="1">单人间</option>
<option value="2">双人间</option>
<option value="3">大床房</option>
<option value="4">套房</option>
</select>
</div>
<div class="form-group alterinfo">
<input type="button" id="addRoomBtn" class="btn btn-success" value="确定"/>
</div>
</div>
</div>
</div>
</div>
<!-- 修改房间模态框：隐藏状态，点击表格“操作”列的修改按钮触发，用于更新房间信息 -->
<div class="modal fade" id="alterRoom" tabindex="-1" role="dialog">
<div class="modal-dialog" role="document">
<div class="modal-content">
<div class="modal-header">
<button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
<h4 class="modal-title">修改房间</h4>
</div>
<div class="modal-body" style="width: 80%;padding-left:20%">
<!-- 房间ID隐藏输入项：存储待修改房间的ID，不显示给用户，通过ID供JS传递参数 -->
<div class="form-group alterinfo" style="display:none">
<input type="text" class="form-control" id="reinputid">
</div>
<!-- 房间位置修改输入项：默认填充待修改房间的当前位置 -->
<div class="form-group alterinfo">请输入位置：
<label for="reinputLocal">inputPrice</label>
<input type="text" name="reinputLocal" class="form-control" id="reinputLocal">
</div>
<!-- 房间价格修改输入项：默认填充当前价格 -->
<div class="form-group alterinfo">请输入价格：
<label for="reinputPrice">inputPrice</label>
<input type="text" name="reinputPrice" class="form-control" id="reinputPrice">
</div>
<!-- 房间类型修改下拉项：默认选中当前类型 -->
<div class="form-group alterinfo">请选择类型：
<select class="form-control" id="reinputType">
<option value="1">单人间</option>
<option value="2">双人间</option>
<option value="3">大床房</option>
<option value="4">套房</option>
</select>
</div>
<!-- 确认修改按钮：通过ID供JS绑定提交事件，提交修改后关闭模态框并刷新表格 -->
<div class="form-group alterinfo">
<input type="button" id="setRoomBtn" class="btn btn-success" value="确定"/>
</div>
</div>
</div>
<div class="modal-dialog" role="document">
<div class="modal-content">
<div class="modal-header">
<button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
<h4 class="modal-title">修改房间</h4>
</div>
<div class="modal-body" style="width: 80%;padding-left:20%">
<div class="form-group alterinfo" style="display:none">
<input type="text" class="form-control" id="reinputid">
</div>
<div class="form-group alterinfo">请输入位置：
<label for="reinputLocal">inputPrice</label>
<input type="text" name="reinputLocal" class="form-control" id="reinputLocal">
</div>
<div class="form-group alterinfo">请输入价格：
<label for="reinputPrice">inputPrice</label>
<input type="text" name="reinputPrice" class="form-control" id="reinputPrice">
</div>
<div class="form-group alterinfo">请选择类型：
<select class="form-control" id="reinputType">
<option value="1">单人间</option>
<option value="2">双人间</option>
<option value="3">大床房</option>
<option value="4">套房</option>
</select>
</div>
<div class="form-group alterinfo">
<input type="button" id="setRoomBtn" class="btn btn-success" value="确定"/>
</div>
</div>
</div>
</div>
</div>
</html>
<!-- 引入依赖JS文件：确保DOM加载前加载核心库，避免交互逻辑报错 -->
<script type="text/javascript" src="../js/jquery.min.js"></script> <!-- jQuery：提供DOM操作、AJAX请求核心能力 -->
<script type="text/javascript" src="../js/bootstrap.min.js"></script> <!-- Bootstrap JS：实现模态框弹出/关闭、下拉选择等组件交互 -->
<script type="text/javascript" src="../js/manage_room.js"></script> <!-- 管理员房间管理自定义JS：实现房间数据加载、新增/修改/分页等核心逻辑 -->
<script type="text/javascript" src="../js/jquery.min.js"></script>
<script type="text/javascript" src="../js/bootstrap.min.js"></script>
<script type="text/javascript" src="../js/manage_room.js"></script>

120
src/main/resources/static/pages/manage_staff.html
Unescape View File

@ -1,86 +1,70 @@
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
<!-- 移动端适配：控制页面在手机、平板等设备上的缩放，确保自适应显示且禁止手动缩放 -->
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<!-- 引入Bootstrap基础样式：提供表格、模态框、按钮等组件的默认样式，保证界面统一性 -->
<link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
<!-- 引入自定义个人中心样式：补充项目专属的布局、颜色等样式，匹配整体设计风格 -->
<link rel="stylesheet" type="text/css" href="../css/myCenter.css">
<!-- 引入自定义通用页面样式：统一各页面的边距、字体等基础样式，减少重复代码 -->
<link rel="stylesheet" type="text/css" href="../css/pages.css">
<meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
<link rel="stylesheet" type="text/css" href="../css/myCenter.css">
<link rel="stylesheet" type="text/css" href="../css/pages.css">
</head>
<body>
<!-- 主体内容容器：占11列（Bootstrap栅格系统），清除默认内边距，设置顶部和左侧内边距调整位置 -->
<div class="col-md-11 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 3rem">
<!-- 响应式表格容器：小屏幕下自动显示横向滚动条，避免表格内容溢出页面 -->
<div class="table-responsive">
<!-- “添加员工”按钮：带铅笔图标，通过data属性触发“添加员工”模态框，明确功能用途 -->
<a href="#" style="font-size:1.7rem" data-toggle="modal" data-target="#addUser" >
<span class="glyphicon glyphicon-pencil"></span> <!-- Bootstrap内置图标，增强“新增”操作辨识度 -->
<span>添加员工</span>
</a>
<!-- 员工列表表格：带边框、鼠标悬浮高亮效果，通过ID供JS动态渲染员工数据 -->
<table class="table table-bordered table-hover" style="margin-top: 10px" id="staffList">
<!-- 表格表头：定义“账号”“员工号”“姓名”等核心字段，覆盖员工管理关键信息 -->
<tr><th>账号</th><th>员工号</th><th>姓名</th><th>年龄</th><th>职位</th><th>联系方式</th><th>操作</th></tr>
</table>
<!-- 分页控制区：占12列（全屏宽度），采用内联表单布局使分页元素横向排列 -->
<div class="col-md-12">
<form class="form-inline">
<!-- 上一页按钮：设置右侧间距，通过ID供JS绑定分页切换事件 -->
<div class="form-group" style="margin-right: 10xp">
<a href="#" id="pre">上一页 </a>
</div>
<!-- （注释待启用）页码跳转功能：输入页码后点击按钮跳转，当前暂未实现 -->
<!--<div class="form-group">
<input type="text" style="width: 5rem" class="form-control" id="inputPage">
<input type="button" id="setPageBtn" class="btn btn-default" value="跳转">
</div>-->
<!-- 下一页按钮：设置左侧间距，通过ID供JS绑定分页切换事件 -->
<div class="form-group" style="margin-left: 10px">
<a href="#" id="next">下一页</a>
</div>
</form>
<div class="table-responsive">
<a href="#" style="font-size:1.7rem" data-toggle="modal" data-target="#addUser" >
<span class="glyphicon glyphicon-pencil"></span>
<span>添加员工</span>
</a>
<table class="table table-bordered table-hover" style="margin-top: 10px" id="staffList">
<tr><th>账号</th><th>员工号</th><th>姓名</th><th>年龄</th><th>职位</th><th>联系方式</th><th>操作</th></tr>
</table>
<div class="col-md-12">
<form class="form-inline">
<div class="form-group" style="margin-right: 10xp">
<a href="#" id="pre">上一页 </a>
</div>
<!--<div class="form-group">
<input type="text" style="width: 5rem" class="form-control" id="inputPage">
<input type="button" id="setPageBtn" class="btn btn-default" value="跳转">
</div>-->
<div class="form-group" style="margin-left: 10px">
<a href="#" id="next">下一页</a>
</div>
</form>
</div>
</div>
</div>
</body>
<!-- 新增员工模态框：隐藏状态，通过data-target="#addUser"触发显示，用于录入新员工基础信息 -->
<div class="modal fade" id="addUser" tabindex="-1" role="dialog">
<div class="modal-dialog" role="document"> <!-- 模态框容器，控制弹窗大小和位置 -->
<div class="modal-content"> <!-- 模态框内容区域，包含头部、主体 -->
<div class="modal-header"> <!-- 模态框头部：标题+关闭按钮，明确功能并支持关闭操作 -->
<button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
<h4 class="modal-title">添加员工</h4> <!--