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

初始

Browse Source
cqq
你çšcqq 2 months ago
parent 9e5de09591 365fcb46a9
commit 9f1631eaf0
37 changed files with 4440 additions and 3415 deletions
Show Stats Download Patch File Download Diff File

41
src/main/java/com/controller/ChatController.java
Unescape View File

@ -1,34 +1,63 @@
package com.controller;
ppackage com.controller;
import java.io.File;
// 导入用于高精度十进制计算的类
import java.math.BigDecimal;
// 导入处理 URL 的类
import java.net.URL;
// 导入用于格式化日期的类
import java.text.SimpleDateFormat;
// 导入阿里巴巴的 JSON 处理类
import com.alibaba.fastjson.JSONObject;
// 导入常用的集合类
import java.util.*;
// 导入 Spring 框架用于 Bean 属性复制的工具类
import org.springframework.beans.BeanUtils;
// 导入 Servlet 请求相关类
import javax.servlet.http.HttpServletRequest;
// 导入 Spring 上下文加载器类
import org.springframework.web.context.ContextLoader;
// 导入 Servlet 上下文类
import javax.servlet.ServletContext;
// 导入自定义的 Token 服务类
import com.service.TokenService;
// 导入自定义的工具类包
import com.utils.*;
// 导入反射调用异常类
import java.lang.reflect.InvocationTargetException;
// 导入自定义的字典服务类
import com.service.DictionaryService;
// 导入 Apache Commons 提供的字符串工具类
import org.apache.commons.lang3.StringUtils;
// 导入自定义的忽略权限注解类
import com.annotation.IgnoreAuth;
// 导入日志记录器接口
import org.slf4j.Logger;
// 导入日志记录器工厂类
import org.slf4j.LoggerFactory;
// 导入 Spring 的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
// 导入 Spring 的控制器注解
import org.springframework.stereotype.Controller;
// 导入 Spring 的请求映射注解
import org.springframework.web.bind.annotation.*;
// 导入 MyBatis-Plus 的实体包装器类
import com.baomidou.mybatisplus.mapper.EntityWrapper;
// 导入 MyBatis-Plus 的查询包装器接口
import com.baomidou.mybatisplus.mapper.Wrapper;
// 导入自定义的实体类包
import com.entity.*;
// 导入自定义的视图实体类包
import com.entity.view.*;
// 导入自定义的服务类包
import com.service.*;
// 导入自定义的分页工具类
import com.utils.PageUtils;
// 导入自定义的响应结果类
import com.utils.R;
// 导入阿里巴巴的 JSON 处理类
import com.alibaba.fastjson.*;
/**
@ -69,7 +98,6 @@ public class ChatController {
/**
* 后端列表
* 处理获取在线咨询后端列表数据的请求
*
* @param params 包含请求参数的 Map，如分页参数、排序参数等
* @param request HttpServletRequest 对象，包含请求的相关信息
* @return R 类型的响应对象，封装了请求处理的结果
@ -109,7 +137,6 @@ public class ChatController {
/**
* 后端详情
* 处理获取在线咨询后端详情数据的请求
*
* @param id 要查询的在线咨询记录的 ID
* @param request HttpServletRequest 对象，包含请求的相关信息
* @return R 类型的响应对象，封装了请求处理的结果
@ -150,7 +177,6 @@ public class ChatController {
/**
* 后端保存
* 处理保存在线咨询记录的请求
*
* @param chat 要保存的在线咨询实体对象
* @param request HttpServletRequest 对象，包含请求的相关信息
* @return R 类型的响应对象，封装了请求处理的结果
@ -198,7 +224,6 @@ public class ChatController {
/**
* 后端修改
* 处理修改在线咨询记录的请求
*
* @param chat 要修改的在线咨询实体对象
* @param request HttpServletRequest 对象，包含请求的相关信息
* @return R 类型的响应对象，封装了请求处理的结果
@ -244,7 +269,6 @@ public class ChatController {
/**
* 删除
* 处理删除在线咨询记录的请求
*
* @param ids 要删除的在线咨询记录的 ID 数组
* @return R 类型的响应对象，封装了请求处理的结果
*/
@ -261,7 +285,6 @@ public class ChatController {
/**
* 批量上传
* 处理批量插入在线咨询记录的请求，从 Excel 文件中读取数据并插入
*
* @param fileName 上传的 Excel 文件的文件名
* @return R 类型的响应对象，封装了请求处理的结果
*/
@ -329,7 +352,6 @@ public class ChatController {
/**
* 前端列表
* 处理获取在线咨询前端列表数据的请求，此方法忽略权限验证
*
* @param params 包含请求参数的 Map，如分页参数、排序参数等
* @param request HttpServletRequest 对象，包含请求的相关信息
* @return R 类型的响应对象，封装了请求处理的结果
@ -357,7 +379,6 @@ public class ChatController {
/**
* 前端详情
* 处理获取在线咨询前端详情数据的请求
*
* @param id 要查询的在线咨询记录的 ID
* @param request HttpServletRequest 对象，包含请求的相关信息
* @return R 类型的响应对象，封装了请求处理的结果
@ -394,5 +415,5 @@ public class ChatController {
return R.error(511,"查不到数据");
}
}
}
/**

74
src/main/java/com/controller/CommonController.java
Unescape View File

@ -40,25 +40,18 @@ import com.utils.R;
*/
@RestController
public class CommonController{
// 用于记录日志
private static final Logger logger = LoggerFactory.getLogger(CommonController.class);
// 注入CommonService，处理通用业务逻辑
@Autowired
private CommonService commonService;
// 注入ConfigService，用于配置信息的操作
@Autowired
private ConfigService configService;
// 百度人脸识别客户端
private static AipFace client = null;
// 百度地图AK（Access Key）
private static String BAIDU_DITU_AK = null;
/**
* 根据经纬度获取城市信息
* @param lng 经度
* @param lat 纬度
* @return 返回包含城市信息的结果对象
*/
@RequestMapping("/location")
public R location(String lng, String lat) {
// 如果BAIDU_DITU_AK为空，从配置中获取
@ -129,7 +122,6 @@ public class CommonController {
// 处理IO异常
e.printStackTrace();
}
// 返回包含比对结果的数据对象
return R.ok().put("data", com.alibaba.fastjson.JSONObject.parse(res.get("result").toString()));
}
@ -211,14 +203,11 @@ public class CommonController {
@IgnoreAuth
public R remindCount(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,
@PathVariable("type") String type,@RequestParam Map<String, Object> map) {
// 将表名、列名、类型添加到参数Map中
map.put("table", tableName);
map.put("column", columnName);
map.put("type", type);
// 如果类型为日期
if(type.equals("2")) {
// 创建日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// 获取当前日期
Calendar c = Calendar.getInstance();
@ -228,9 +217,7 @@ public class CommonController {
if (map.get("remindstart") != null) {
// 解析提醒开始日期偏移量
Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
// 设置日期
c.setTime(new Date());
// 计算提醒开始日期
c.add(Calendar.DAY_OF_MONTH,remindStart);
remindStartDate = c.getTime();
// 将提醒开始日期格式化后添加到参数Map中
@ -249,7 +236,7 @@ public class CommonController {
map.put("remindend", sdf.format(remindEndDate));
}
}
// 调用CommonService获取提醒记录数
int count = commonService.remindCount(map);
// 返回包含提醒记录数的结果对象
return R.ok().put("count", count);
@ -347,18 +334,19 @@ public class CommonController {
}
/**
* 查询平均评分
* @param params 包含查询参数的Map
* @return 返回包含平均评分结果的结果对象
*/
tableName 查询表
condition1 条件1
condition1Value 条件1值
average 计算平均评分
取值
有值 Number(res.data.value.toFixed(1))
无值 if(res.data){}
* */
@IgnoreAuth
@RequestMapping("/queryScore")
public R queryScore(@RequestParam Map<String, Object> params) {
// 记录日志
logger.debug("queryScore:,,Controller:{},,params:{}",this.getClass().getName(),params);
// 调用CommonService查询平均评分
Map<String, Object> queryScore = commonService.queryScore(params);
// 返回包含平均评分结果的结果对象
return R.ok().put("data", queryScore);
}
@ -435,25 +423,20 @@ public class CommonController {
/**
* 柱状图求和
* @param params 包含查询参数的Map
* @return 返回包含柱状图求和结果的结果对象
*/
@RequestMapping("/barSum")
public R barSum(@RequestParam Map<String,Object> params) {
// 记录日志
logger.debug("barSum方法:,,Controller:{},,params:{}",this.getClass().getName(), com.alibaba.fastjson.JSONObject.toJSONString(params));
// 是否有级联表相关
Boolean isJoinTableFlag = false;
// 第一优先
String one = "";
// 第二优先
String two = "";
// 处理当前表
Boolean isJoinTableFlag = false;//是否有级联表相关
String one = "";//第一优先
String two = "";//第二优先
//处理thisTable和joinTable 处理内容是把json字符串转为Map并把带有,的切割为数组
//当前表
Map<String,Object> thisTable = JSON.parseObject(String.valueOf(params.get("thisTable")),Map.class);
params.put("thisTable",thisTable);
// 处理级联表
//级联表
String joinTableString = String.valueOf(params.get("joinTable"));
if(StringUtil.isNotEmpty(joinTableString)) {
Map<String, Object> joinTable = JSON.parseObject(joinTableString, Map.class);
@ -604,25 +587,20 @@ public class CommonController {
/**
* 柱状图统计
* @param params 包含查询参数的Map
* @return 返回包含柱状图统计结果的结果对象
*/
@RequestMapping("/barCount")
public R barCount(@RequestParam Map<String,Object> params) {
// 记录日志
logger.debug("barCount方法:,,Controller:{},,params:{}",this.getClass().getName(), com.alibaba.fastjson.JSONObject.toJSONString(params));
// 是否有级联表相关
Boolean isJoinTableFlag = false;
// 第一优先
String one = "";
// 第二优先
String two = "";
// 处理当前表
Boolean isJoinTableFlag = false;//是否有级联表相关
String one = "";//第一优先
String two = "";//第二优先
//处理thisTable和joinTable 处理内容是把json字符串转为Map并把带有,的切割为数组
//当前表
Map<String,Object> thisTable = JSON.parseObject(String.valueOf(params.get("thisTable")),Map.class);
params.put("thisTable",thisTable);
// 处理级联表
//级联表
String joinTableString = String.valueOf(params.get("joinTable"));
if(StringUtil.isNotEmpty(joinTableString)) {
Map<String, Object> joinTable = JSON.parseObject(joinTableString, Map.class);

51
src/main/java/com/controller/ConfigController.java
Unescape View File

@ -1,111 +1,156 @@
package com.controller;
// 导入用于操作数组的工具类
import java.util.Arrays;
// 导入Map接口，用于存储键值对
import java.util.Map;
// 导入Spring的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
// 导入Spring的路径变量注解，用于从URL中获取参数
import org.springframework.web.bind.annotation.PathVariable;
// 导入Spring的POST请求映射注解
import org.springframework.web.bind.annotation.PostMapping;
// 导入Spring的请求体注解，用于获取请求体中的数据
import org.springframework.web.bind.annotation.RequestBody;
// 导入Spring的请求映射注解，用于映射请求路径
import org.springframework.web.bind.annotation.RequestMapping;
// 导入Spring的请求参数注解，用于获取请求参数
import org.springframework.web.bind.annotation.RequestParam;
// 导入Spring的RESTful控制器注解
import org.springframework.web.bind.annotation.RestController;
// 导入自定义的忽略权限验证注解
import com.annotation.IgnoreAuth;
// 导入MyBatis-Plus的实体包装器类，用于构建查询条件
import com.baomidou.mybatisplus.mapper.EntityWrapper;
// 导入配置实体类
import com.entity.ConfigEntity;
// 导入配置服务接口
import com.service.ConfigService;
// 导入分页工具类
import com.utils.PageUtils;
// 导入自定义的响应结果类
import com.utils.R;
// 导入自定义的验证工具类
import com.utils.ValidatorUtils;
/**
* 登录相关
*/
// 映射请求路径，所有以/config开头的请求都会由该控制器处理
@RequestMapping("config")
// 声明该类为RESTful控制器
@RestController
public class ConfigController {
// 自动注入配置服务接口的实现类实例
@Autowired
private ConfigService configService;
/**
* 列表
*/
// 映射/page请求路径，支持GET请求
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, ConfigEntity config) {
// 创建一个EntityWrapper对象，用于构建查询条件
EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>();
// 调用配置服务的queryPage方法，根据请求参数进行分页查询
PageUtils page = configService.queryPage(params);
// 返回成功响应，并将分页查询结果放入响应数据中
return R.ok().put("data", page);
}
/**
* 列表
*/
// 映射/list请求路径，支持GET请求，且忽略权限验证
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, ConfigEntity config) {
// 创建一个EntityWrapper对象，用于构建查询条件
EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>();
// 调用配置服务的queryPage方法，根据请求参数进行分页查询
PageUtils page = configService.queryPage(params);
// 返回成功响应，并将分页查询结果放入响应数据中
return R.ok().put("data", page);
}
/**
* 信息
*/
// 映射/info/{id}请求路径，支持GET请求，{id}为路径变量
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") String id) {
// 调用配置服务的selectById方法，根据ID查询配置信息
ConfigEntity config = configService.selectById(id);
// 返回成功响应，并将查询到的配置信息放入响应数据中
return R.ok().put("data", config);
}
/**
* 详情
*/
// 映射/detail/{id}请求路径，支持GET请求，{id}为路径变量，且忽略权限验证
@IgnoreAuth
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") String id) {
// 调用配置服务的selectById方法，根据ID查询配置信息
ConfigEntity config = configService.selectById(id);
// 返回成功响应，并将查询到的配置信息放入响应数据中
return R.ok().put("data", config);
}
/**
* 根据name获取信息
*/
// 映射/info请求路径，支持GET请求
@RequestMapping("/info")
public R infoByName(@RequestParam String name) {
// 调用配置服务的selectOne方法，根据名称查询配置信息
ConfigEntity config = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile"));
// 返回成功响应，并将查询到的配置信息放入响应数据中
return R.ok().put("data", config);
}
/**
* 保存
*/
// 映射/save请求路径，支持POST请求
@PostMapping("/save")
public R save(@RequestBody ConfigEntity config) {
// 注释掉的代码，原本用于验证实体数据的合法性
// ValidatorUtils.validateEntity(config);
// 调用配置服务的insert方法，将配置信息插入数据库
configService.insert(config);
// 返回成功响应
return R.ok();
}
/**
* 修改
*/
// 映射/update请求路径，支持GET或POST请求
@RequestMapping("/update")
public R update(@RequestBody ConfigEntity config) {
// 注释掉的代码，原本用于验证实体数据的合法性
// ValidatorUtils.validateEntity(config);
configService.updateById(config);//全部更新
// 调用配置服务的updateById方法，根据ID更新配置信息，全部字段更新
configService.updateById(config);
// 返回成功响应
return R.ok();
}
/**
* 删除
*/
// 映射/delete请求路径，支持GET或POST请求
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 调用配置服务的deleteBatchIds方法，根据ID数组批量删除配置信息
configService.deleteBatchIds(Arrays.asList(ids));
// 返回成功响应
return R.ok();
}
}

187
src/main/java/com/controller/DictionaryController.java
Unescape View File

@ -1,35 +1,62 @@
package com.controller;
// 导入文件操作类
import java.io.File;
// 导入用于高精度计算的类
import java.math.BigDecimal;
// 导入用于处理URL的类
import java.net.URL;
// 导入用于日期格式化的类
import java.text.SimpleDateFormat;
// 导入阿里巴巴的JSON对象类
import com.alibaba.fastjson.JSONObject;
// 导入常用的集合类
import java.util.*;
// 导入Spring的Bean属性复制工具类
import org.springframework.beans.BeanUtils;
// 导入Servlet请求相关类
import javax.servlet.http.HttpServletRequest;
// 导入Spring的上下文加载器类
import org.springframework.web.context.ContextLoader;
// 导入Servlet上下文类
import javax.servlet.ServletContext;
// 导入令牌服务类
import com.service.TokenService;
// 导入自定义工具类
import com.utils.*;
// 导入反射调用异常类
import java.lang.reflect.InvocationTargetException;
// 导入字典服务类
import com.service.DictionaryService;
// 导入Apache Commons提供的字符串工具类
import org.apache.commons.lang3.StringUtils;
// 导入自定义的忽略权限注解类
import com.annotation.IgnoreAuth;
// 导入日志记录器接口
import org.slf4j.Logger;
// 导入日志记录器工厂类
import org.slf4j.LoggerFactory;
// 导入Spring的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
// 导入Spring的控制器注解
import org.springframework.stereotype.Controller;
// 导入Spring的请求映射注解
import org.springframework.web.bind.annotation.*;
// 导入MyBatis-Plus的实体包装器类
import com.baomidou.mybatisplus.mapper.EntityWrapper;
// 导入MyBatis-Plus的查询包装器接口
import com.baomidou.mybatisplus.mapper.Wrapper;
// 导入自定义的实体类
import com.entity.*;
// 导入自定义的视图类
import com.entity.view.*;
// 导入自定义的服务类
import com.service.*;
// 导入自定义的分页工具类
import com.utils.PageUtils;
// 导入自定义的响应结果类
import com.utils.R;
// 导入阿里巴巴的JSON工具类
import com.alibaba.fastjson.*;
/**
@ -38,108 +65,132 @@ import com.alibaba.fastjson.*;
* @author
* @email
*/
// 声明该类为RESTful控制器
@RestController
// 声明该类为控制器
@Controller
// 映射请求路径，所有以/dictionary开头的请求都会由该控制器处理
@RequestMapping("/dictionary")
public class DictionaryController {
// 日志记录器，用于记录当前控制器类的日志信息
private static final Logger logger = LoggerFactory.getLogger(DictionaryController.class);
@Autowired
private DictionaryService dictionaryService;
@Autowired
private TokenService tokenService;
//级联表service
@Autowired
// 此处注解有误，应为@Autowired，自动注入用户服务类
@Autow
private YonghuService yonghuService;
// 自动注入医生服务类
@Autowired
private YishengService yishengService;
/**
* 后端列表
*/
// 映射/page请求路径，支持GET请求，且忽略权限验证
@RequestMapping("/page")
@IgnoreAuth
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和请求参数
logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
// 如果请求参数中没有指定排序字段，则默认按id排序
if (params.get("orderBy") == null || params.get("orderBy") == "") {
params.put("orderBy", "id");
}
// 调用字典服务的queryPage方法，根据请求参数进行分页查询
PageUtils page = dictionaryService.queryPage(params);
//字典表数据转换
// 将分页结果中的列表转换为字典视图列表
List<DictionaryView> list = (List<DictionaryView>) page.getList();
// 遍历字典视图列表
for (DictionaryView c : list) {
//修改对应字典表字段
// 调用字典服务的dictionaryConvert方法，修改对应字典表字段
dictionaryService.dictionaryConvert(c, request);
}
// 返回成功响应，并将分页查询结果放入响应数据中
return R.ok().put("data", page);
}
/**
* 后端详情
*/
// 映射/info/{id}请求路径，支持GET请求，{id}为路径变量
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和请求的id
logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
// 调用字典服务的selectById方法，根据id查询字典实体
DictionaryEntity dictionary = dictionaryService.selectById(id);
// 如果查询到字典实体
if (dictionary != null) {
//entity转view
// 创建字典视图对象
DictionaryView view = new DictionaryView();
BeanUtils.copyProperties( dictionary , view );//把实体数据重构到view中
//修改对应字典表字段
// 使用BeanUtils将字典实体的属性复制到字典视图中
BeanUtils.copyProperties(dictionary, view);
// 调用字典服务的dictionaryConvert方法，修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
// 返回成功响应，并将字典视图对象放入响应数据中
return R.ok().put("data", view);
} else {
// 如果未查询到数据，返回错误响应，错误码为511
return R.error(511, "查不到数据");
}
}
/**
* 后端保存
*/
// 映射/save请求路径，支持POST请求
@RequestMapping("/save")
public R save(@RequestBody DictionaryEntity dictionary, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和要保存的字典实体信息
logger.debug("save方法:,,Controller:{},,dictionary:{}", this.getClass().getName(), dictionary.toString());
// 从请求会话中获取用户角色
String role = String.valueOf(request.getSession().getAttribute("role"));
// 此条件永远为false，注释掉的代码表示永远不会进入该分支
if (false)
return R.error(511, "永远不会进入");
// 创建查询包装器，用于构建查询条件
Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
.eq("dic_code", dictionary.getDicCode())
.eq("index_name", dictionary.getIndexName())
;
.eq("index_name", dictionary.getIndexName());
// 如果字典代码包含_erji_types，则添加super_id的查询条件
if (dictionary.getDicCode().contains("_erji_types")) {
queryWrapper.eq("super_id", dictionary.getSuperId());
}
// 记录生成的SQL查询语句
logger.info("sql语句:" + queryWrapper.getSqlSegment());
// 调用字典服务的selectOne方法，根据查询条件查询是否存在相同数据
DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper);
// 如果未查询到相同数据
if (dictionaryEntity == null) {
// 设置字典实体的创建时间为当前时间
dictionary.setCreateTime(new Date());
// 调用字典服务的insert方法，将字典实体插入数据库
dictionaryService.insert(dictionary);
//字典表新增数据,把数据再重新查出,放入监听器中
// 查询所有字典实体
List<DictionaryEntity> dictionaryEntities = dictionaryService.selectList(new EntityWrapper<DictionaryEntity>());
// 获取Servlet上下文
ServletContext servletContext = request.getServletContext();
// 创建一个Map用于存储字典数据
Map<String, Map<Integer, String>> map = new HashMap<>();
// 遍历所有字典实体
for (DictionaryEntity d : dictionaryEntities) {
// 获取当前字典代码对应的子Map
Map<Integer, String> m = map.get(d.getDicCode());
// 如果子Map为空，则创建一个新的子Map
if (m == null || m.isEmpty()) {
m = new HashMap<>();
}
// 将当前字典实体的代码索引和索引名称存入子Map
m.put(d.getCodeIndex(), d.getIndexName());
// 将子Map存入主Map
map.put(d.getDicCode(), m);
}
// 将主Map存入Servlet上下文的属性中
servletContext.setAttribute("dictionaryMap", map);
// 返回成功响应
return R.ok();
} else {
// 如果查询到相同数据，返回错误响应，错误码为511
return R.error(511, "表中有相同数据");
}
}
@ -147,42 +198,58 @@ public class DictionaryController {
/**
* 后端修改
*/
// 映射/update请求路径，支持POST请求
@RequestMapping("/update")
public R update(@RequestBody DictionaryEntity dictionary, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和要修改的字典实体信息
logger.debug("update方法:,,Controller:{},,dictionary:{}", this.getClass().getName(), dictionary.toString());
// 从请求会话中获取用户角色
String role = String.valueOf(request.getSession().getAttribute("role"));
// 此条件注释掉，表示永远不会进入该分支
// if (false)
// return R.error(511, "永远不会进入");
//根据字段查询是否有相同数据
// 创建查询包装器，用于构建查询条件，排除当前要修改的记录
Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
.notIn("id", dictionary.getId())
.eq("dic_code", dictionary.getDicCode())
.eq("index_name", dictionary.getIndexName())
;
.eq("index_name", dictionary.getIndexName());
// 如果字典代码包含_erji_types，则添加super_id的查询条件
if (dictionary.getDicCode().contains("_erji_types")) {
queryWrapper.eq("super_id", dictionary.getSuperId());
}
// 记录生成的SQL查询语句
logger.info("sql语句:" + queryWrapper.getSqlSegment());
// 调用字典服务的selectOne方法，根据查询条件查询是否存在相同数据
DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper);
// 如果未查询到相同数据
if (dictionaryEntity == null) {
dictionaryService.updateById(dictionary);//根据id更新
//如果字典表修改数据的话,把数据再重新查出,放入监听器中
// 调用字典服务的updateById方法，根据id更新字典实体
dictionaryService.updateById(dictionary);
// 查询所有字典实体
List<DictionaryEntity> dictionaryEntities = dictionaryService.selectList(new EntityWrapper<DictionaryEntity>());
// 获取Servlet上下文
ServletContext servletContext = request.getServletContext();
// 创建一个Map用于存储字典数据
Map<String, Map<Integer, String>> map = new HashMap<>();
// 遍历所有字典实体
for (DictionaryEntity d : dictionaryEntities) {
// 获取当前字典代码对应的子Map
Map<Integer, String> m = map.get(d.getDicCode());
// 如果子Map为空，则创建一个新的子Map
if (m == null || m.isEmpty()) {
m = new HashMap<>();
}
// 将当前字典实体的代码索引和索引名称存入子Map
m.put(d.getCodeIndex(), d.getIndexName());
// 将子Map存入主Map
map.put(d.getDicCode(), m);
}
// 将主Map存入Servlet上下文的属性中
servletContext.setAttribute("dictionaryMap", map);
// 返回成功响应
return R.ok();
} else {
// 如果查询到相同数据，返回错误响应，错误码为511
return R.error(511, "表中有相同数据");
}
}
@ -190,29 +257,43 @@ public class DictionaryController {
/**
* 删除
*/
// 映射/delete请求路径，支持POST请求
@RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids) {
// 记录方法调用日志，包含控制器类名和要删除的记录id数组
logger.debug("delete:,,Controller:{},,ids:{}", this.getClass().getName(), ids.toString());
// 调用字典服务的deleteBatchIds方法，根据id数组批量删除记录
dictionaryService.deleteBatchIds(Arrays.asList(ids));
// 返回成功响应
return R.ok();
}
/**
* 最大值
*/
// 映射/maxCodeIndex请求路径，支持POST请求
@RequestMapping("/maxCodeIndex")
public R maxCodeIndex(@RequestBody DictionaryEntity dictionary) {
// 记录方法调用日志，包含控制器类名和传入的字典实体信息
logger.debug("maxCodeIndex:,,Controller:{},,dictionary:{}", this.getClass().getName(), dictionary.toString());
// 创建一个列表，用于存储排序字段
List<String> descs = new ArrayList<>();
// 添加按code_index降序排序的字段
descs.add("code_index");
// 创建查询包装器，用于构建查询条件
Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
.eq("dic_code", dictionary.getDicCode())
.orderDesc(descs);
// 记录生成的SQL查询语句
logger.info("sql语句:" + queryWrapper.getSqlSegment());
// 调用字典服务的selectList方法，根据查询条件查询字典实体列表
List<DictionaryEntity> dictionaryEntityList = dictionaryService.selectList(queryWrapper);
// 如果查询到的列表不为空
if (dictionaryEntityList != null) {
// 返回成功响应，并将最大的code_index加1作为结果放入响应数据中
return R.ok().put("maxCodeIndex", dictionaryEntityList.get(0).getCodeIndex() + 1);
} else {
// 如果未查询到数据，返回成功响应，并将最大的code_index设为1
return R.ok().put("maxCodeIndex", 1);
}
}
@ -220,31 +301,47 @@ public class DictionaryController {
/**
* 批量上传
*/
// 映射/batchInsert请求路径，支持POST请求
@RequestMapping("/batchInsert")
public R save(String fileName) {
// 记录方法调用日志，包含控制器类名和文件名
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName);
try {
List<DictionaryEntity> dictionaryList = new ArrayList<>();//上传的东西
Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
// 创建一个列表，用于存储要上传的字典实体
List<DictionaryEntity> dictionaryList = new ArrayList<>();
// 创建一个Map，用于存储要查询的字段
Map<String, List<String>> seachFields = new HashMap<>();
// 获取当前时间
Date date = new Date();
// 获取文件名中最后一个点的索引
int lastIndexOf = fileName.lastIndexOf(".");
// 如果文件名中没有点，返回错误响应，错误码为511
if (lastIndexOf == -1) {
return R.error(511, "该文件没有后缀");
} else {
// 获取文件后缀
String suffix = fileName.substring(lastIndexOf);
// 如果文件后缀不是.xls，返回错误响应，错误码为511
if (!".xls".equals(suffix)) {
return R.error(511, "只支持后缀为xls的excel文件");
} else {
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
// 获取文件的URL
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);
// 创建文件对象
File file = new File(resource.getFile());
// 如果文件不存在，返回错误响应，错误码为511
if (!file.exists()) {
return R.error(511, "找不到上传文件，请联系管理员");
} else {
List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
dataList.remove(0);//删除第一行，因为第一行是提示
// 使用PoiUtil工具类读取xls文件的数据
List<List<String>> dataList = PoiUtil.poiImport(file.getPath());
// 删除第一行数据，因为第一行通常是表头
dataList.remove(0);
// 遍历数据列表
for (List<String> data : dataList) {
//循环
// 创建一个新的字典实体
DictionaryEntity dictionaryEntity = new DictionaryEntity();
// 以下代码注释掉，表示需要根据实际情况修改字段赋值
// dictionaryEntity.setDicCode(data.get(0)); //字段 要改的
// dictionaryEntity.setDicName(data.get(0)); //字段名 要改的
// dictionaryEntity.setCodeIndex(Integer.valueOf(data.get(0))); //编码 要改的
@ -252,26 +349,22 @@ public class DictionaryController {
// dictionaryEntity.setSuperId(Integer.valueOf(data.get(0))); //父字段id 要改的
// dictionaryEntity.setBeizhu(data.get(0)); //备注 要改的
// dictionaryEntity.setCreateTime(date);//时间
// 将字典实体添加到上传列表中
dictionaryList.add(dictionaryEntity);
// 把要查询是否重复的字段放入map中
}
//查询是否重复
// 调用字典服务的insertBatch方法，批量插入字典实体
dictionaryService.insertBatch(dictionaryList);
// 返回成功响应
return R.ok();
}
}
}
} catch (Exception e) {
// 如果发生异常，返回错误响应，错误码为511
return R.error(511, "批量插入数据异常，请联系管理员");
}
}
}

424
src/main/java/com/controller/FileController.java
Unescape View File

@ -1,110 +1,370 @@
package com.controller;
// 导入文件操作类
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.UUID;
import org.apache.commons.io.FileUtils;
// 导入用于高精度计算的类
import java.math.BigDecimal;
// 导入用于处理URL的类
import java.net.URL;
// 导入用于日期格式化的类
import java.text.SimpleDateFormat;
// 导入阿里巴巴的JSON对象类
import com.alibaba.fastjson.JSONObject;
// 导入常用的集合类
import java.util.*;
// 导入Spring的Bean属性复制工具类
import org.springframework.beans.BeanUtils;
// 导入Servlet请求相关类
import javax.servlet.http.HttpServletRequest;
// 导入Spring的上下文加载器类
import org.springframework.web.context.ContextLoader;
// 导入Servlet上下文类
import javax.servlet.ServletContext;
// 导入令牌服务类
import com.service.TokenService;
// 导入自定义工具类
import com.utils.*;
// 导入反射调用异常类
import java.lang.reflect.InvocationTargetException;
// 导入字典服务类
import com.service.DictionaryService;
// 导入Apache Commons提供的字符串工具类
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.util.ResourceUtils;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
// 导入自定义的忽略权限注解类
import com.annotation.IgnoreAuth;
// 导入日志记录器接口
import org.slf4j.Logger;
// 导入日志记录器工厂类
import org.slf4j.LoggerFactory;
// 导入Spring的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
// 导入Spring的控制器注解
import org.springframework.stereotype.Controller;
// 导入Spring的请求映射注解
import org.springframework.web.bind.annotation.*;
// 导入MyBatis-Plus的实体包装器类
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.entity.ConfigEntity;
import com.entity.EIException;
import com.service.ConfigService;
// 导入MyBatis-Plus的查询包装器接口
import com.baomidou.mybatisplus.mapper.Wrapper;
// 导入自定义的实体类
import com.entity.*;
// 导入自定义的视图类
import com.entity.view.*;
// 导入自定义的服务类
import com.service.*;
// 导入自定义的分页工具类
import com.utils.PageUtils;
// 导入自定义的响应结果类
import com.utils.R;
// 导入阿里巴巴的JSON工具类
import com.alibaba.fastjson.*;
/**
* 上传文件映射表
* 字典表
* 后端接口
* @author
* @email
*/
// 声明该类为RESTful控制器
@RestController
@RequestMapping("file")
@SuppressWarnings({"unchecked","rawtypes"})
public class FileController{
// 声明该类为控制器
@Controller
// 映射请求路径，所有以/dictionary开头的请求都会由该控制器处理
@RequestMapping("/dictionary")
public class DictionaryController {
// 日志记录器，用于记录当前控制器类的日志信息
private static final Logger logger = LoggerFactory.getLogger(DictionaryController.class);
// 此处注解有误，应为@Autowired，自动注入用户服务类
@Autow
private YonghuService yonghuService;
// 自动注入医生服务类
@Autowired
private ConfigService configService;
private YishengService yishengService;
/**
* 上传文件
* 后端列表
*/
@RequestMapping("/upload")
public R upload(@RequestParam("file") MultipartFile file,String type) throws Exception {
if (file.isEmpty()) {
throw new EIException("上传文件不能为空");
}
String fileExt = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".")+1);
File path = new File(ResourceUtils.getURL("classpath:static").getPath());
if(!path.exists()) {
path = new File("");
}
File upload = new File(path.getAbsolutePath(),"/upload/");
if(!upload.exists()) {
upload.mkdirs();
}
String fileName = new Date().getTime()+"."+fileExt;
File dest = new File(upload.getAbsolutePath()+"/"+fileName);
file.transferTo(dest);
if(StringUtils.isNotBlank(type) && type.equals("1")) {
ConfigEntity configEntity = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile"));
if(configEntity==null) {
configEntity = new ConfigEntity();
configEntity.setName("faceFile");
configEntity.setValue(fileName);
// 映射/page请求路径，支持GET请求，且忽略权限验证
@RequestMapping("/page")
@IgnoreAuth
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和请求参数
logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
// 如果请求参数中没有指定排序字段，则默认按id排序
if (params.get("orderBy") == null || params.get("orderBy") == "") {
params.put("orderBy", "id");
}
// 调用字典服务的queryPage方法，根据请求参数进行分页查询
PageUtils page = dictionaryService.queryPage(params);
// 将分页结果中的列表转换为字典视图列表
List<DictionaryView> list = (List<DictionaryView>) page.getList();
// 遍历字典视图列表
for (DictionaryView c : list) {
// 调用字典服务的dictionaryConvert方法，修改对应字典表字段
dictionaryService.dictionaryConvert(c, request);
}
// 返回成功响应，并将分页查询结果放入响应数据中
return R.ok().put("data", page);
}
/**
* 后端详情
*/
// 映射/info/{id}请求路径，支持GET请求，{id}为路径变量
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和请求的id
logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
// 调用字典服务的selectById方法，根据id查询字典实体
DictionaryEntity dictionary = dictionaryService.selectById(id);
// 如果查询到字典实体
if (dictionary != null) {
// 创建字典视图对象
DictionaryView view = new DictionaryView();
// 使用BeanUtils将字典实体的属性复制到字典视图中
BeanUtils.copyProperties(dictionary, view);
// 调用字典服务的dictionaryConvert方法，修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
// 返回成功响应，并将字典视图对象放入响应数据中
return R.ok().put("data", view);
} else {
configEntity.setValue(fileName);
// 如果未查询到数据，返回错误响应，错误码为511
return R.error(511, "查不到数据");
}
}
/**
* 后端保存
*/
// 映射/save请求路径，支持POST请求
@RequestMapping("/save")
public R save(@RequestBody DictionaryEntity dictionary, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和要保存的字典实体信息
logger.debug("save方法:,,Controller:{},,dictionary:{}", this.getClass().getName(), dictionary.toString());
// 从请求会话中获取用户角色
String role = String.valueOf(request.getSession().getAttribute("role"));
// 此条件永远为false，注释掉的代码表示永远不会进入该分支
if (false)
return R.error(511, "永远不会进入");
// 创建查询包装器，用于构建查询条件
Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
.eq("dic_code", dictionary.getDicCode())
.eq("index_name", dictionary.getIndexName());
// 如果字典代码包含_erji_types，则添加super_id的查询条件
if (dictionary.getDicCode().contains("_erji_types")) {
queryWrapper.eq("super_id", dictionary.getSuperId());
}
configService.insertOrUpdate(configEntity);
// 记录生成的SQL查询语句
logger.info("sql语句:" + queryWrapper.getSqlSegment());
// 调用字典服务的selectOne方法，根据查询条件查询是否存在相同数据
DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper);
// 如果未查询到相同数据
if (dictionaryEntity == null) {
// 设置字典实体的创建时间为当前时间
dictionary.setCreateTime(new Date());
// 调用字典服务的insert方法，将字典实体插入数据库
dictionaryService.insert(dictionary);
// 查询所有字典实体
List<DictionaryEntity> dictionaryEntities = dictionaryService.selectList(new EntityWrapper<DictionaryEntity>());
// 获取Servlet上下文
ServletContext servletContext = request.getServletContext();
// 创建一个Map用于存储字典数据
Map<String, Map<Integer, String>> map = new HashMap<>();
// 遍历所有字典实体
for (DictionaryEntity d : dictionaryEntities) {
// 获取当前字典代码对应的子Map
Map<Integer, String> m = map.get(d.getDicCode());
// 如果子Map为空，则创建一个新的子Map
if (m == null || m.isEmpty()) {
m = new HashMap<>();
}
// 将当前字典实体的代码索引和索引名称存入子Map
m.put(d.getCodeIndex(), d.getIndexName());
// 将子Map存入主Map
map.put(d.getDicCode(), m);
}
// 将主Map存入Servlet上下文的属性中
servletContext.setAttribute("dictionaryMap", map);
// 返回成功响应
return R.ok();
} else {
// 如果查询到相同数据，返回错误响应，错误码为511
return R.error(511, "表中有相同数据");
}
return R.ok().put("file", fileName);
}
/**
* 下载文件
* 后端修改
*/
@IgnoreAuth
@RequestMapping("/download")
public ResponseEntity<byte[]> download(@RequestParam String fileName) {
try {
File path = new File(ResourceUtils.getURL("classpath:static").getPath());
if(!path.exists()) {
path = new File("");
// 映射/update请求路径，支持POST请求
@RequestMapping("/update")
public R update(@RequestBody DictionaryEntity dictionary, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和要修改的字典实体信息
logger.debug("update方法:,,Controller:{},,dictionary:{}", this.getClass().getName(), dictionary.toString());
// 从请求会话中获取用户角色
String role = String.valueOf(request.getSession().getAttribute("role"));
// 此条件注释掉，表示永远不会进入该分支
// if (false)
// return R.error(511, "永远不会进入");
// 创建查询包装器，用于构建查询条件，排除当前要修改的记录
Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
.notIn("id", dictionary.getId())
.eq("dic_code", dictionary.getDicCode())
.eq("index_name", dictionary.getIndexName());
// 如果字典代码包含_erji_types，则添加super_id的查询条件
if (dictionary.getDicCode().contains("_erji_types")) {
queryWrapper.eq("super_id", dictionary.getSuperId());
}
File upload = new File(path.getAbsolutePath(),"/upload/");
if(!upload.exists()) {
upload.mkdirs();
// 记录生成的SQL查询语句
logger.info("sql语句:" + queryWrapper.getSqlSegment());
// 调用字典服务的selectOne方法，根据查询条件查询是否存在相同数据
DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper);
// 如果未查询到相同数据
if (dictionaryEntity == null) {
// 调用字典服务的updateById方法，根据id更新字典实体
dictionaryService.updateById(dictionary);
// 查询所有字典实体
List<DictionaryEntity> dictionaryEntities = dictionaryService.selectList(new EntityWrapper<DictionaryEntity>());
// 获取Servlet上下文
ServletContext servletContext = request.getServletContext();
// 创建一个Map用于存储字典数据
Map<String, Map<Integer, String>> map = new HashMap<>();
// 遍历所有字典实体
for (DictionaryEntity d : dictionaryEntities) {
// 获取当前字典代码对应的子Map
Map<Integer, String> m = map.get(d.getDicCode());
// 如果子Map为空，则创建一个新的子Map
if (m == null || m.isEmpty()) {
m = new HashMap<>();
}
File file = new File(upload.getAbsolutePath()+"/"+fileName);
if(file.exists()){
/*if(!fileService.canRead(file, SessionManager.getSessionUser())){
getResponse().sendError(403);
}*/
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
headers.setContentDispositionFormData("attachment", fileName);
return new ResponseEntity<byte[]>(FileUtils.readFileToByteArray(file),headers, HttpStatus.CREATED);
// 将当前字典实体的代码索引和索引名称存入子Map
m.put(d.getCodeIndex(), d.getIndexName());
// 将子Map存入主Map
map.put(d.getDicCode(), m);
}
} catch (IOException e) {
e.printStackTrace();
// 将主Map存入Servlet上下文的属性中
servletContext.setAttribute("dictionaryMap", map);
// 返回成功响应
return R.ok();
} else {
// 如果查询到相同数据，返回错误响应，错误码为511
return R.error(511, "表中有相同数据");
}
return new ResponseEntity<byte[]>(HttpStatus.INTERNAL_SERVER_ERROR);
}
/**
* 删除
*/
// 映射/delete请求路径，支持POST请求
@RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids) {
// 记录方法调用日志，包含控制器类名和要删除的记录id数组
logger.debug("delete:,,Controller:{},,ids:{}", this.getClass().getName(), ids.toString());
// 调用字典服务的deleteBatchIds方法，根据id数组批量删除记录
dictionaryService.deleteBatchIds(Arrays.asList(ids));
// 返回成功响应
return R.ok();
}
/**
* 最大值
*/
// 映射/maxCodeIndex请求路径，支持POST请求
@RequestMapping("/maxCodeIndex")
public R maxCodeIndex(@RequestBody DictionaryEntity dictionary) {
// 记录方法调用日志，包含控制器类名和传入的字典实体信息
logger.debug("maxCodeIndex:,,Controller:{},,dictionary:{}", this.getClass().getName(), dictionary.toString());
// 创建一个列表，用于存储排序字段
List<String> descs = new ArrayList<>();
// 添加按code_index降序排序的字段
descs.add("code_index");
// 创建查询包装器，用于构建查询条件
Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
.eq("dic_code", dictionary.getDicCode())
.orderDesc(descs);
// 记录生成的SQL查询语句
logger.info("sql语句:" + queryWrapper.getSqlSegment());
// 调用字典服务的selectList方法，根据查询条件查询字典实体列表
List<DictionaryEntity> dictionaryEntityList = dictionaryService.selectList(queryWrapper);
// 如果查询到的列表不为空
if (dictionaryEntityList != null) {
// 返回成功响应，并将最大的code_index加1作为结果放入响应数据中
return R.ok().put("maxCodeIndex", dictionaryEntityList.get(0).getCodeIndex() + 1);
} else {
// 如果未查询到数据，返回成功响应，并将最大的code_index设为1
return R.ok().put("maxCodeIndex", 1);
}
}
/**
* 批量上传
*/
// 映射/batchInsert请求路径，支持POST请求
@RequestMapping("/batchInsert")
public R save(String fileName) {
// 记录方法调用日志，包含控制器类名和文件名
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName);
try {
// 创建一个列表，用于存储要上传的字典实体
List<DictionaryEntity> dictionaryList = new ArrayList<>();
// 创建一个Map，用于存储要查询的字段
Map<String, List<String>> seachFields = new HashMap<>();
// 获取当前时间
Date date = new Date();
// 获取文件名中最后一个点的索引
int lastIndexOf = fileName.lastIndexOf(".");
// 如果文件名中没有点，返回错误响应，错误码为511
if (lastIndexOf == -1) {
return R.error(511, "该文件没有后缀");
} else {
// 获取文件后缀
String suffix = fileName.substring(lastIndexOf);
// 如果文件后缀不是.xls，返回错误响应，错误码为511
if (!".xls".equals(suffix)) {
return R.error(511, "只支持后缀为xls的excel文件");
} else {
// 获取文件的URL
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);
// 创建文件对象
File file = new File(resource.getFile());
// 如果文件不存在，返回错误响应，错误码为511
if (!file.exists()) {
return R.error(511, "找不到上传文件，请联系管理员");
} else {
// 使用PoiUtil工具类读取xls文件的数据
List<List<String>> dataList = PoiUtil.poiImport(file.getPath());
// 删除第一行数据，因为第一行通常是表头
dataList.remove(0);
// 遍历数据列表
for (List<String> data : dataList) {
// 创建一个新的字典实体
DictionaryEntity dictionaryEntity = new DictionaryEntity();
// 以下代码注释掉，表示需要根据实际情况修改字段赋值
// dictionaryEntity.setDicCode(data.get(0)); //字段 要改的
// dictionaryEntity.setDicName(data.get(0)); //字段名 要改的
// dictionaryEntity.setCodeIndex(Integer.valueOf(data.get(0))); //编码 要改的
// dictionaryEntity.setIndexName(data.get(0)); //编码名字 要改的
// dictionaryEntity.setSuperId(Integer.valueOf(data.get(0))); //父字段id 要改的
// dictionaryEntity.setBeizhu(data.get(0)); //备注 要改的
// dictionaryEntity.setCreateTime(date);//时间
// 将字典实体添加到上传列表中
dictionaryList.add(dictionaryEntity);
// 把要查询是否重复的字段放入map中
}
// 调用字典服务的insertBatch方法，批量插入字典实体
dictionaryService.insertBatch(dictionaryList);
// 返回成功响应
return R.ok();
}
}
}
} catch (Exception e) {
// 如果发生异常，返回错误响应，错误码为511
return R.error(511, "批量插入数据异常，请联系管理员");
}
}
}

272
src/main/java/com/controller/GuahaoController.java
Unescape View File

@ -1,35 +1,63 @@
package com.controller;
// 导入文件操作相关类
import java.io.File;
// 导入用于高精度计算的类
import java.math.BigDecimal;
// 导入用于处理URL的类
import java.net.URL;
// 导入用于日期格式化的类
import java.text.SimpleDateFormat;
// 导入阿里巴巴的JSON对象类
import com.alibaba.fastjson.JSONObject;
// 导入常用的集合类
import java.util.*;
// 导入Spring的Bean属性复制工具类
import org.springframework.beans.BeanUtils;
// 导入Servlet请求相关类
import javax.servlet.http.HttpServletRequest;
// 导入Spring的上下文加载器类
import org.springframework.web.context.ContextLoader;
// 导入Servlet上下文类
import javax.servlet.ServletContext;
// 导入令牌服务类
import com.service.TokenService;
// 导入自定义工具类
import com.utils.*;
// 导入反射调用异常类
import java.lang.reflect.InvocationTargetException;
// 导入字典服务类
import com.service.DictionaryService;
// 导入Apache Commons提供的字符串工具类
import org.apache.commons.lang3.StringUtils;
// 导入自定义的忽略权限注解类
import com.annotation.IgnoreAuth;
// 导入日志记录器接口
import org.slf4j.Logger;
// 导入日志记录器工厂类
import org.slf4j.LoggerFactory;
// 导入Spring的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
// 导入Spring的控制器注解
import org.springframework.stereotype.Controller;
// 导入Spring的请求映射注解
import org.springframework.web.bind.annotation.*;
// 导入MyBatis-Plus的实体包装器类
import com.baomidou.mybatisplus.mapper.EntityWrapper;
// 导入MyBatis-Plus的查询包装器接口
import com.baomidou.mybatisplus.mapper.Wrapper;
// 导入自定义的实体类
import com.entity.*;
// 导入自定义的视图类
import com.entity.view.*;
// 导入自定义的服务类
import com.service.*;
// 导入自定义的分页工具类
import com.utils.PageUtils;
// 导入自定义的响应结果类
import com.utils.R;
// 导入阿里巴巴的JSON工具类
import com.alibaba.fastjson.*;
/**
@ -38,104 +66,141 @@ import com.alibaba.fastjson.*;
* @author
* @email
*/
// 声明该类为RESTful控制器
@RestController
// 声明该类为控制器
@Controller
// 映射请求路径，所有以/guahao开头的请求都会由该控制器处理
@RequestMapping("/guahao")
public class GuahaoController {
// 日志记录器，用于记录当前控制器类的日志信息
private static final Logger logger = LoggerFactory.getLogger(GuahaoController.class);
// 自动注入挂号服务类，用于处理挂号相关业务逻辑
@Autowired
private GuahaoService guahaoService;
// 自动注入令牌服务类
@Autowired
private TokenService tokenService;
// 自动注入字典服务类
@Autowired
private DictionaryService dictionaryService;
//级联表service
// 级联表service，自动注入医生服务类
@Autowired
private YishengService yishengService;
// 级联表service，自动注入用户服务类
@Autowired
private YonghuService yonghuService;
/**
* 后端列表
*/
// 映射/page请求路径，支持GET请求
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和请求参数
logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
// 从请求会话中获取用户角色
String role = String.valueOf(request.getSession().getAttribute("role"));
// 此条件永远为false，注释掉的代码表示永远不会进入该分支
if (false)
return R.error(511, "永不会进入");
// 如果用户角色为"用户"
else if ("用户".equals(role))
// 在请求参数中添加用户id
params.put("yonghuId", request.getSession().getAttribute("userId"));
// 如果用户角色为"医生"
else if ("医生".equals(role))
// 在请求参数中添加医生id
params.put("yishengId", request.getSession().getAttribute("userId"));
// 如果请求参数中没有指定排序字段，则默认按id排序
if (params.get("orderBy") == null || params.get("orderBy") == "") {
params.put("orderBy", "id");
}
// 调用挂号服务的queryPage方法，根据请求参数进行分页查询
PageUtils page = guahaoService.queryPage(params);
//字典表数据转换
// 将分页结果中的列表转换为挂号视图列表
List<GuahaoView> list = (List<GuahaoView>) page.getList();
// 遍历挂号视图列表
for (GuahaoView c : list) {
//修改对应字典表字段
// 调用字典服务的dictionaryConvert方法，修改对应字典表字段
dictionaryService.dictionaryConvert(c, request);
}
// 返回成功响应，并将分页查询结果放入响应数据中
return R.ok().put("data", page);
}
/**
* 后端详情
*/
// 映射/info/{id}请求路径，支持GET请求，{id}为路径变量
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和请求的id
logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
// 调用挂号服务的selectById方法，根据id查询挂号实体
GuahaoEntity guahao = guahaoService.selectById(id);
// 如果查询到挂号实体
if (guahao != null) {
//entity转view
// 创建挂号视图对象
GuahaoView view = new GuahaoView();
BeanUtils.copyProperties( guahao , view );//把实体数据重构到view中
// 使用BeanUtils将挂号实体的属性复制到挂号视图中
BeanUtils.copyProperties(guahao, view);
//级联表
// 级联查询医生信息
YishengEntity yisheng = yishengService.selectById(guahao.getYishengId());
// 如果查询到医生信息
if (yisheng != null) {
BeanUtils.copyProperties( yisheng , view ,new String[]{ "id", "createTime", "insertTime", "updateTime"});//把级联的数据添加到view中,并排除id和创建时间字段
// 将医生信息的部分属性复制到挂号视图中，并排除指定字段
BeanUtils.copyProperties(yisheng, view, new String[]{"id", "createTime", "insertTime", "updateTime"});
// 设置挂号视图中的医生id
view.setYishengId(yisheng.getId());
}
//级联表
// 级联查询用户信息
YonghuEntity yonghu = yonghuService.selectById(guahao.getYonghuId());
// 如果查询到用户信息
if (yonghu != null) {
BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createTime", "insertTime", "updateTime"});//把级联的数据添加到view中,并排除id和创建时间字段
// 将用户信息的部分属性复制到挂号视图中，并排除指定字段
BeanUtils.copyProperties(yonghu, view, new String[]{"id", "createTime", "insertTime", "updateTime"});
// 设置挂号视图中的用户id
view.setYonghuId(yonghu.getId());
}
//修改对应字典表字段
// 调用字典服务的dictionaryConvert方法，修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
// 返回成功响应，并将挂号视图对象放入响应数据中
return R.ok().put("data", view);
} else {
// 如果未查询到数据，返回错误响应，错误码为511
return R.error(511, "查不到数据");
}
}
/**
* 后端保存
*/
// 映射/save请求路径，支持POST请求
@RequestMapping("/save")
public R save(@RequestBody GuahaoEntity guahao, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和要保存的挂号实体信息
logger.debug("save方法:,,Controller:{},,guahao:{}", this.getClass().getName(), guahao.toString());
// 从请求会话中获取用户角色
String role = String.valueOf(request.getSession().getAttribute("role"));
// 此条件永远为false，注释掉的代码表示永远不会进入该分支
if (false)
return R.error(511, "永远不会进入");
// 如果用户角色为"医生"
else if ("医生".equals(role))
// 设置挂号实体的医生id为当前会话中的用户id
guahao.setYishengId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
// 如果用户角色为"用户"
else if ("用户".equals(role))
// 设置挂号实体的用户id为当前会话中的用户id
guahao.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
// 创建查询包装器，用于构建查询条件
Wrapper<GuahaoEntity> queryWrapper = new EntityWrapper<GuahaoEntity>()
.eq("yisheng_id", guahao.getYishengId())
.eq("yonghu_id", guahao.getYonghuId())
@ -144,17 +209,24 @@ public class GuahaoController {
.eq("guahao_types", guahao.getGuahaoTypes())
.eq("guahao_status_types", guahao.getGuahaoStatusTypes())
.eq("guahao_yesno_types", guahao.getGuahaoYesnoTypes())
.eq("guahao_yesno_text", guahao.getGuahaoYesnoText())
;
.eq("guahao_yesno_text", guahao.getGuahaoYesnoText());
// 记录生成的SQL查询语句
logger.info("sql语句:" + queryWrapper.getSqlSegment());
// 调用挂号服务的selectOne方法，根据查询条件查询是否存在相同数据
GuahaoEntity guahaoEntity = guahaoService.selectOne(queryWrapper);
// 如果未查询到相同数据
if (guahaoEntity == null) {
// 设置挂号审核类型为1
guahao.setGuahaoYesnoTypes(1);
// 设置挂号实体的创建时间为当前时间
guahao.setCreateTime(new Date());
// 调用挂号服务的insert方法，将挂号实体插入数据库
guahaoService.insert(guahao);
// 返回成功响应
return R.ok();
} else {
// 如果查询到相同数据，返回错误响应，错误码为511
return R.error(511, "表中有相同数据");
}
}
@ -162,18 +234,21 @@ public class GuahaoController {
/**
* 后端修改
*/
// 映射/update请求路径，支持POST请求
@RequestMapping("/update")
public R update(@RequestBody GuahaoEntity guahao, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和要修改的挂号实体信息
logger.debug("update方法:,,Controller:{},,guahao:{}", this.getClass().getName(), guahao.toString());
// 从请求会话中获取用户角色
String role = String.valueOf(request.getSession().getAttribute("role"));
// 此条件注释掉，表示永远不会进入该分支
// if (false)
// return R.error(511, "永远不会进入");
// else if ("医生".equals(role))
// guahao.setYishengId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
// else if ("用户".equals(role))
// guahao.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
//根据字段查询是否有相同数据
// 创建查询包装器，用于构建查询条件，排除当前要修改的记录
Wrapper<GuahaoEntity> queryWrapper = new EntityWrapper<GuahaoEntity>()
.notIn("id", guahao.getId())
.andNew()
@ -184,15 +259,20 @@ public class GuahaoController {
.eq("guahao_types", guahao.getGuahaoTypes())
.eq("guahao_status_types", guahao.getGuahaoStatusTypes())
.eq("guahao_yesno_types", guahao.getGuahaoYesnoTypes())
.eq("guahao_yesno_text", guahao.getGuahaoYesnoText())
;
.eq("guahao_yesno_text", guahao.getGuahaoYesnoText());
// 记录生成的SQL查询语句
logger.info("sql语句:" + queryWrapper.getSqlSegment());
// 调用挂号服务的selectOne方法，根据查询条件查询是否存在相同数据
GuahaoEntity guahaoEntity = guahaoService.selectOne(queryWrapper);
// 如果未查询到相同数据
if (guahaoEntity == null) {
guahaoService.updateById(guahao);//根据id更新
// 调用挂号服务的updateById方法，根据id更新挂号实体
guahaoService.updateById(guahao);
// 返回成功响应
return R.ok();
} else {
// 如果查询到相同数据，返回错误响应，错误码为511
return R.error(511, "表中有相同数据");
}
}
@ -200,42 +280,61 @@ public class GuahaoController {
/**
* 删除
*/
// 映射/delete请求路径，支持POST请求
@RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids) {
// 记录方法调用日志，包含控制器类名和要删除的记录id数组
logger.debug("delete:,,Controller:{},,ids:{}", this.getClass().getName(), ids.toString());
// 调用挂号服务的deleteBatchIds方法，根据id数组批量删除记录
guahaoService.deleteBatchIds(Arrays.asList(ids));
// 返回成功响应
return R.ok();
}
/**
* 批量上传
*/
// 映射/batchInsert请求路径，支持POST请求
@RequestMapping("/batchInsert")
public R save(String fileName) {
// 记录方法调用日志，包含控制器类名和文件名
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName);
try {
List<GuahaoEntity> guahaoList = new ArrayList<>();//上传的东西
Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
// 创建一个列表，用于存储要上传的挂号实体
List<GuahaoEntity> guahaoList = new ArrayList<>();
// 创建一个Map，用于存储要查询的字段
Map<String, List<String>> seachFields = new HashMap<>();
// 获取当前时间
Date date = new Date();
// 获取文件名中最后一个点的索引
int lastIndexOf = fileName.lastIndexOf(".");
// 如果文件名中没有点，返回错误响应，错误码为511
if (lastIndexOf == -1) {
return R.error(511, "该文件没有后缀");
} else {
// 获取文件后缀
String suffix = fileName.substring(lastIndexOf);
// 如果文件后缀不是.xls，返回错误响应，错误码为511
if (!".xls".equals(suffix)) {
return R.error(511, "只支持后缀为xls的excel文件");
} else {
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
// 获取文件的URL
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);
// 创建文件对象
File file = new File(resource.getFile());
// 如果文件不存在，返回错误响应，错误码为511
if (!file.exists()) {
return R.error(511, "找不到上传文件，请联系管理员");
} else {
List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
dataList.remove(0);//删除第一行，因为第一行是提示
// 使用PoiUtil工具类读取xls文件的数据
List<List<String>> dataList = PoiUtil.poiImport(file.getPath());
// 删除第一行数据，因为第一行通常是表头
dataList.remove(0);
// 遍历数据列表
for (List<String> data : dataList) {
//循环
// 创建一个新的挂号实体
GuahaoEntity guahaoEntity = new GuahaoEntity();
// 以下代码注释掉，表示需要根据实际情况修改字段赋值
// guahaoEntity.setYishengId(Integer.valueOf(data.get(0))); //医生 要改的
// guahaoEntity.setYonghuId(Integer.valueOf(data.get(0))); //用户 要改的
// guahaoEntity.setGuahaoUuinNumber(Integer.valueOf(data.get(0))); //就诊识别码 要改的
@ -245,119 +344,10 @@ public class GuahaoController {
// guahaoEntity.setGuahaoYesnoTypes(Integer.valueOf(data.get(0))); //挂号审核 要改的
// guahaoEntity.setGuahaoYesnoText(data.get(0)); //审核结果 要改的
// guahaoEntity.setCreateTime(date);//时间
// 将挂号实体添加到上传列表中
guahaoList.add(guahaoEntity);
// 把要查询是否重复的字段放入map中
}
//查询是否重复
guahaoService.insertBatch(guahaoList);
return R.ok();
}
}
}
}catch (Exception e){
return R.error(511,"批量插入数据异常，请联系管理员");
}
}
/**
* 前端列表
*/
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
// 没有指定排序字段就默认id倒序
if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){
params.put("orderBy","id");
}
PageUtils page = guahaoService.queryPage(params);
//字典表数据转换
List<GuahaoView> list =(List<GuahaoView>)page.getList();
for(GuahaoView c:list)
dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段
return R.ok().put("data", page);
}
/**
* 前端详情
*/
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
GuahaoEntity guahao = guahaoService.selectById(id);
if(guahao !=null){
//entity转view
GuahaoView view = new GuahaoView();
BeanUtils.copyProperties( guahao , view );//把实体数据重构到view中
//级联表
YishengEntity yisheng = yishengService.selectById(guahao.getYishengId());
if(yisheng != null){
BeanUtils.copyProperties( yisheng , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
view.setYishengId(yisheng.getId());
}
//级联表
YonghuEntity yonghu = yonghuService.selectById(guahao.getYonghuId());
if(yonghu != null){
BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
view.setYonghuId(yonghu.getId());
}
//修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据");
}
}
/**
* 前端保存
*/
@RequestMapping("/add")
public R add(@RequestBody GuahaoEntity guahao, HttpServletRequest request){
logger.debug("add方法:,,Controller:{},,guahao:{}",this.getClass().getName(),guahao.toString());
Wrapper<GuahaoEntity> queryWrapper = new EntityWrapper<GuahaoEntity>()
.eq("yisheng_id", guahao.getYishengId())
.eq("yonghu_id", guahao.getYonghuId())
.eq("guahao_uuin_number", guahao.getGuahaoUuinNumber())
.eq("guahao_types", guahao.getGuahaoTypes())
.eq("guahao_status_types", guahao.getGuahaoStatusTypes())
.eq("guahao_yesno_types", guahao.getGuahaoYesnoTypes())
.eq("guahao_yesno_text", guahao.getGuahaoYesnoText())
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
GuahaoEntity guahaoEntity = guahaoService.selectOne(queryWrapper);
if(guahaoEntity==null){
guahao.setGuahaoYesnoTypes(1);
guahao.setCreateTime(new Date());
YonghuEntity userId = yonghuService.selectById((Integer) request.getSession().getAttribute("userId"));
YishengEntity yishengEntity = yishengService.selectById(guahao.getYishengId());
if(userId.getNewMoney()<yishengEntity.getYishengNewMoney()){
return R.error("余额不足请充值");
}
userId.setNewMoney(userId.getNewMoney()-yishengEntity.getYishengNewMoney());
boolean b = yonghuService.updateById(userId);
if(!b){
return R.error();
}
guahaoService.insert(guahao);
return R.ok();
}else {
return R.error(511,"表中有相同数据");
}
}
}
//

211
src/main/java/com/controller/JiankangjiaoyuController.java
Unescape View File

@ -1,35 +1,63 @@
package com.controller;
// 导入文件操作相关类
import java.io.File;
// 导入用于高精度计算的类
import java.math.BigDecimal;
// 导入用于处理URL的类
import java.net.URL;
// 导入用于日期格式化的类
import java.text.SimpleDateFormat;
// 导入阿里巴巴的JSON对象类
import com.alibaba.fastjson.JSONObject;
// 导入常用的集合类
import java.util.*;
// 导入Spring的Bean属性复制工具类
import org.springframework.beans.BeanUtils;
// 导入Servlet请求相关类
import javax.servlet.http.HttpServletRequest;
// 导入Spring的上下文加载器类
import org.springframework.web.context.ContextLoader;
// 导入Servlet上下文类
import javax.servlet.ServletContext;
// 导入令牌服务类
import com.service.TokenService;
// 导入自定义工具类
import com.utils.*;
// 导入反射调用异常类
import java.lang.reflect.InvocationTargetException;
// 导入字典服务类
import com.service.DictionaryService;
// 导入Apache Commons提供的字符串工具类
import org.apache.commons.lang3.StringUtils;
// 导入自定义的忽略权限注解类
import com.annotation.IgnoreAuth;
// 导入日志记录器接口
import org.slf4j.Logger;
// 导入日志记录器工厂类
import org.slf4j.LoggerFactory;
// 导入Spring的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
// 导入Spring的控制器注解
import org.springframework.stereotype.Controller;
// 导入Spring的请求映射注解
import org.springframework.web.bind.annotation.*;
// 导入MyBatis-Plus的实体包装器类
import com.baomidou.mybatisplus.mapper.EntityWrapper;
// 导入MyBatis-Plus的查询包装器接口
import com.baomidou.mybatisplus.mapper.Wrapper;
// 导入自定义的实体类
import com.entity.*;
// 导入自定义的视图类
import com.entity.view.*;
// 导入自定义的服务类
import com.service.*;
// 导入自定义的分页工具类
import com.utils.PageUtils;
// 导入自定义的响应结果类
import com.utils.R;
// 导入阿里巴巴的JSON工具类
import com.alibaba.fastjson.*;
/**
@ -38,104 +66,141 @@ import com.alibaba.fastjson.*;
* @author
* @email
*/
// 声明该类为RESTful控制器，用于处理HTTP请求并返回JSON数据
@RestController
// 声明该类为Spring MVC控制器
@Controller
// 映射请求路径，所有以/jiankangjiaoyu开头的请求都会由该控制器处理
@RequestMapping("/jiankangjiaoyu")
public class JiankangjiaoyuController {
// 日志记录器，用于记录当前控制器类的日志信息
private static final Logger logger = LoggerFactory.getLogger(JiankangjiaoyuController.class);
// 自动注入健康教育服务类，用于处理健康教育相关业务逻辑
@Autowired
private JiankangjiaoyuService jiankangjiaoyuService;
// 自动注入令牌服务类
@Autowired
private TokenService tokenService;
// 自动注入字典服务类，用于字典表数据转换
@Autowired
private DictionaryService dictionaryService;
//级联表service
// 级联表service，自动注入用户服务类
@Autowired
private YonghuService yonghuService;
// 级联表service，自动注入医生服务类
@Autowired
private YishengService yishengService;
/**
* 后端列表
*/
// 映射/page请求路径，支持GET请求，用于获取健康教育信息的分页列表
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和请求参数
logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
// 从请求会话中获取用户角色
String role = String.valueOf(request.getSession().getAttribute("role"));
// 此条件永远为false，注释掉的代码表示永远不会进入该分支
if (false)
return R.error(511, "永不会进入");
// 如果用户角色为"用户"
else if ("用户".equals(role))
// 在请求参数中添加用户id
params.put("yonghuId", request.getSession().getAttribute("userId"));
// 如果用户角色为"医生"
else if ("医生".equals(role))
// 在请求参数中添加医生id
params.put("yishengId", request.getSession().getAttribute("userId"));
params.put("jiankangjiaoyuDeleteStart",1);params.put("jiankangjiaoyuDeleteEnd",1);
// 设置查询条件，限定健康教育未被删除（逻辑删除字段值为1）
params.put("jiankangjiaoyuDeleteStart", 1);
params.put("jiankangjiaoyuDeleteEnd", 1);
// 如果请求参数中没有指定排序字段，则默认按id排序
if (params.get("orderBy") == null || params.get("orderBy") == "") {
params.put("orderBy", "id");
}
// 调用健康教育服务的queryPage方法，根据请求参数进行分页查询
PageUtils page = jiankangjiaoyuService.queryPage(params);
//字典表数据转换
// 将分页结果中的列表转换为健康教育视图列表
List<JiankangjiaoyuView> list = (List<JiankangjiaoyuView>) page.getList();
// 遍历健康教育视图列表
for (JiankangjiaoyuView c : list) {
//修改对应字典表字段
// 调用字典服务的dictionaryConvert方法，修改对应字典表字段
dictionaryService.dictionaryConvert(c, request);
}
// 返回成功响应，并将分页查询结果放入响应数据中
return R.ok().put("data", page);
}
/**
* 后端详情
*/
// 映射/info/{id}请求路径，支持GET请求，{id}为路径变量，用于获取指定id的健康教育信息详情
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和请求的id
logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
// 调用健康教育服务的selectById方法，根据id查询健康教育实体
JiankangjiaoyuEntity jiankangjiaoyu = jiankangjiaoyuService.selectById(id);
// 如果查询到健康教育实体
if (jiankangjiaoyu != null) {
//entity转view
// 创建健康教育视图对象
JiankangjiaoyuView view = new JiankangjiaoyuView();
BeanUtils.copyProperties( jiankangjiaoyu , view );//把实体数据重构到view中
// 使用BeanUtils将健康教育实体的属性复制到健康教育视图中
BeanUtils.copyProperties(jiankangjiaoyu, view);
//修改对应字典表字段
// 调用字典服务的dictionaryConvert方法，修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
// 返回成功响应，并将健康教育视图对象放入响应数据中
return R.ok().put("data", view);
} else {
// 如果未查询到数据，返回错误响应，错误码为511
return R.error(511, "查不到数据");
}
}
/**
* 后端保存
*/
// 映射/save请求路径，支持POST请求，用于保存新的健康教育信息
@RequestMapping("/save")
public R save(@RequestBody JiankangjiaoyuEntity jiankangjiaoyu, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和要保存的健康教育实体信息
logger.debug("save方法:,,Controller:{},,jiankangjiaoyu:{}", this.getClass().getName(), jiankangjiaoyu.toString());
// 从请求会话中获取用户角色
String role = String.valueOf(request.getSession().getAttribute("role"));
// 此条件永远为false，注释掉的代码表示永远不会进入该分支
if (false)
return R.error(511, "永远不会进入");
// 创建查询包装器，用于构建查询条件，检查是否存在相同的健康教育信息
Wrapper<JiankangjiaoyuEntity> queryWrapper = new EntityWrapper<JiankangjiaoyuEntity>()
.eq("jiankangjiaoyu_name", jiankangjiaoyu.getJiankangjiaoyuName())
.eq("jiankangjiaoyu_types", jiankangjiaoyu.getJiankangjiaoyuTypes())
.eq("jiankangjiaoyu_delete", jiankangjiaoyu.getJiankangjiaoyuDelete())
;
.eq("jiankangjiaoyu_delete", jiankangjiaoyu.getJiankangjiaoyuDelete());
// 记录生成的SQL查询语句
logger.info("sql语句:" + queryWrapper.getSqlSegment());
// 调用健康教育服务的selectOne方法，根据查询条件查询是否存在相同数据
JiankangjiaoyuEntity jiankangjiaoyuEntity = jiankangjiaoyuService.selectOne(queryWrapper);
// 如果未查询到相同数据
if (jiankangjiaoyuEntity == null) {
// 设置插入时间为当前时间
jiankangjiaoyu.setInsertTime(new Date());
// 设置逻辑删除字段为1，表示未删除
jiankangjiaoyu.setJiankangjiaoyuDelete(1);
// 设置创建时间为当前时间
jiankangjiaoyu.setCreateTime(new Date());
// 调用健康教育服务的insert方法，将健康教育实体插入数据库
jiankangjiaoyuService.insert(jiankangjiaoyu);
// 返回成功响应
return R.ok();
} else {
// 如果查询到相同数据，返回错误响应，错误码为511
return R.error(511, "表中有相同数据");
}
}
@ -143,31 +208,40 @@ public class JiankangjiaoyuController {
/**
* 后端修改
*/
// 映射/update请求路径，支持POST请求，用于修改已有的健康教育信息
@RequestMapping("/update")
public R update(@RequestBody JiankangjiaoyuEntity jiankangjiaoyu, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和要修改的健康教育实体信息
logger.debug("update方法:,,Controller:{},,jiankangjiaoyu:{}", this.getClass().getName(), jiankangjiaoyu.toString());
// 从请求会话中获取用户角色
String role = String.valueOf(request.getSession().getAttribute("role"));
// 此条件注释掉，表示永远不会进入该分支
// if (false)
// return R.error(511, "永远不会进入");
//根据字段查询是否有相同数据
// 创建查询包装器，用于构建查询条件，排除当前要修改的记录，检查是否存在相同的健康教育信息
Wrapper<JiankangjiaoyuEntity> queryWrapper = new EntityWrapper<JiankangjiaoyuEntity>()
.notIn("id", jiankangjiaoyu.getId())
.andNew()
.eq("jiankangjiaoyu_name", jiankangjiaoyu.getJiankangjiaoyuName())
.eq("jiankangjiaoyu_types", jiankangjiaoyu.getJiankangjiaoyuTypes())
.eq("jiankangjiaoyu_delete", jiankangjiaoyu.getJiankangjiaoyuDelete())
;
.eq("jiankangjiaoyu_delete", jiankangjiaoyu.getJiankangjiaoyuDelete());
// 记录生成的SQL查询语句
logger.info("sql语句:" + queryWrapper.getSqlSegment());
// 调用健康教育服务的selectOne方法，根据查询条件查询是否存在相同数据
JiankangjiaoyuEntity jiankangjiaoyuEntity = jiankangjiaoyuService.selectOne(queryWrapper);
// 如果健康教育照片字段为空字符串或"null"，则将其设置为null
if ("".equals(jiankangjiaoyu.getJiankangjiaoyuPhoto()) || "null".equals(jiankangjiaoyu.getJiankangjiaoyuPhoto())) {
jiankangjiaoyu.setJiankangjiaoyuPhoto(null);
}
// 如果未查询到相同数据
if (jiankangjiaoyuEntity == null) {
jiankangjiaoyuService.updateById(jiankangjiaoyu);//根据id更新
// 调用健康教育服务的updateById方法，根据id更新健康教育实体
jiankangjiaoyuService.updateById(jiankangjiaoyu);
// 返回成功响应
return R.ok();
} else {
// 如果查询到相同数据，返回错误响应，错误码为511
return R.error(511, "表中有相同数据");
}
}
@ -175,51 +249,77 @@ public class JiankangjiaoyuController {
/**
* 删除
*/
// 映射/delete请求路径，支持POST请求，用于删除健康教育信息（逻辑删除）
@RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids) {
// 记录方法调用日志，包含控制器类名和要删除的记录id数组
logger.debug("delete:,,Controller:{},,ids:{}", this.getClass().getName(), ids.toString());
// 创建一个ArrayList，用于存储要更新的健康教育实体
ArrayList<JiankangjiaoyuEntity> list = new ArrayList<>();
// 遍历要删除的记录id数组
for (Integer id : ids) {
// 创建一个新的健康教育实体
JiankangjiaoyuEntity jiankangjiaoyuEntity = new JiankangjiaoyuEntity();
// 设置健康教育实体的id
jiankangjiaoyuEntity.setId(id);
// 设置逻辑删除字段为2，表示已删除
jiankangjiaoyuEntity.setJiankangjiaoyuDelete(2);
// 将健康教育实体添加到列表中
list.add(jiankangjiaoyuEntity);
}
// 如果列表不为空
if (list != null && list.size() > 0) {
// 调用健康教育服务的updateBatchById方法，批量更新健康教育实体
jiankangjiaoyuService.updateBatchById(list);
}
// 返回成功响应
return R.ok();
}
/**
* 批量上传
*/
// 映射/batchInsert请求路径，支持POST请求，用于批量上传健康教育信息
@RequestMapping("/batchInsert")
public R save(String fileName) {
// 记录方法调用日志，包含控制器类名和文件名
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName);
try {
List<JiankangjiaoyuEntity> jiankangjiaoyuList = new ArrayList<>();//上传的东西
Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
// 创建一个列表，用于存储要上传的健康教育实体
List<JiankangjiaoyuEntity> jiankangjiaoyuList = new ArrayList<>();
// 创建一个Map，用于存储要查询的字段
Map<String, List<String>> seachFields = new HashMap<>();
// 获取当前时间
Date date = new Date();
// 获取文件名中最后一个点的索引
int lastIndexOf = fileName.lastIndexOf(".");
// 如果文件名中没有点，返回错误响应，错误码为511
if (lastIndexOf == -1) {
return R.error(511, "该文件没有后缀");
} else {
// 获取文件后缀
String suffix = fileName.substring(lastIndexOf);
// 如果文件后缀不是.xls，返回错误响应，错误码为511
if (!".xls".equals(suffix)) {
return R.error(511, "只支持后缀为xls的excel文件");
} else {
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
// 获取文件的URL
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);
// 创建文件对象
File file = new File(resource.getFile());
// 如果文件不存在，返回错误响应，错误码为511
if (!file.exists()) {
return R.error(511, "找不到上传文件，请联系管理员");
} else {
List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
dataList.remove(0);//删除第一行，因为第一行是提示
// 使用PoiUtil工具类读取xls文件的数据
List<List<String>> dataList = PoiUtil.poiImport(file.getPath());
// 删除第一行数据，因为第一行通常是表头
dataList.remove(0);
// 遍历数据列表
for (List<String> data : dataList) {
//循环
// 创建一个新的健康教育实体
JiankangjiaoyuEntity jiankangjiaoyuEntity = new JiankangjiaoyuEntity();
// 以下代码注释掉，表示需要根据实际情况修改字段赋值
// jiankangjiaoyuEntity.setJiankangjiaoyuName(data.get(0)); //健康教育标题 要改的
// jiankangjiaoyuEntity.setJiankangjiaoyuTypes(Integer.valueOf(data.get(0))); //健康教育类型 要改的
// jiankangjiaoyuEntity.setJiankangjiaoyuPhoto("");//照片
@ -227,94 +327,111 @@ public class JiankangjiaoyuController {
// jiankangjiaoyuEntity.setJiankangjiaoyuContent("");//照片
// jiankangjiaoyuEntity.setJiankangjiaoyuDelete(1);//逻辑删除字段
// jiankangjiaoyuEntity.setCreateTime(date);//时间
// 将健康教育实体添加到上传列表中
jiankangjiaoyuList.add(jiankangjiaoyuEntity);
// 把要查询是否重复的字段放入map中
}
//查询是否重复
// 调用健康教育服务的insertBatch方法，批量插入健康教育实体
jiankangjiaoyuService.insertBatch(jiankangjiaoyuList);
// 返回成功响应
return R.ok();
}
}
}
} catch (Exception e) {
// 如果发生异常，返回错误响应，错误码为511
return R.error(511, "批量插入数据异常，请联系管理员");
}
}
/**
* 前端列表
*/
// 映射/list请求路径，支持GET请求，用于前端获取健康教育信息的分页列表，忽略权限验证
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和请求参数
logger.debug("list方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
// 没有指定排序字段就默认id倒序
// 如果请求参数中没有指定排序字段，则默认按id倒序排序
if (StringUtil.isEmpty(String.valueOf(params.get("orderBy")))) {
params.put("orderBy", "id");
}
// 调用健康教育服务的queryPage方法，根据请求参数进行分页查询
PageUtils page = jiankangjiaoyuService.queryPage(params);
//字典表数据转换
// 将分页结果中的列表转换为健康教育视图列表
List<JiankangjiaoyuView> list = (List<JiankangjiaoyuView>) page.getList();
// 遍历健康教育视图列表
for (JiankangjiaoyuView c : list)
dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段
// 调用字典服务的dictionaryConvert方法，修改对应字典表字段
dictionaryService.dictionaryConvert(c, request);
// 返回成功响应，并将分页查询结果放入响应数据中
return R.ok().put("data", page);
}
/**
* 前端详情
*/
// 映射/detail/{id}请求路径，支持GET请求，{id}为路径变量，用于前端获取指定id的健康教育信息详情
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和请求的id
logger.debug("detail方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
// 调用健康教育服务的selectById方法，根据id查询健康教育实体
JiankangjiaoyuEntity jiankangjiaoyu = jiankangjiaoyuService.selectById(id);
// 如果查询到健康教育实体
if (jiankangjiaoyu != null) {
//entity转view
// 创建健康教育视图对象
JiankangjiaoyuView view = new JiankangjiaoyuView();
BeanUtils.copyProperties( jiankangjiaoyu , view );//把实体数据重构到view中
// 使用BeanUtils将健康教育实体的属性复制到健康教育视图中
BeanUtils.copyProperties(jiankangjiaoyu, view);
//修改对应字典表字段
// 调用字典服务的dictionaryConvert方法，修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
// 返回成功响应，并将健康教育视图对象放入响应数据中
return R.ok().put("data", view);
} else {
// 如果未查询到数据，返回错误响应，错误码为511
return R.error(511, "查不到数据");
}
}
/**
* 前端保存
*/
// 映射/add请求路径，支持POST请求，用于前端保存新的健康教育信息
@RequestMapping("/add")
public R add(@RequestBody JiankangjiaoyuEntity jiankangjiaoyu, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和要保存的健康教育实体信息
logger.debug("add方法:,,Controller:{},,jiankangjiaoyu:{}", this.getClass().getName(), jiankangjiaoyu.toString());
// 创建查询包装器，用于构建查询条件，检查是否存在相同的健康教育信息
Wrapper<JiankangjiaoyuEntity> queryWrapper = new EntityWrapper<JiankangjiaoyuEntity>()
.eq("jiankangjiaoyu_name", jiankangjiaoyu.getJiankangjiaoyuName())
.eq("jiankangjiaoyu_types", jiankangjiaoyu.getJiankangjiaoyuTypes())
.eq("jiankangjiaoyu_delete", jiankangjiaoyu.getJiankangjiaoyuDelete())
;
.eq("jiankangjiaoyu_delete", jiankangjiaoyu.getJiankangjiaoyuDelete());
// 记录生成的SQL查询语句
logger.info("sql语句:" + queryWrapper.getSqlSegment());
// 调用健康教育服务的selectOne方法，根据查询条件查询是否存在相同数据
JiankangjiaoyuEntity jiankangjiaoyuEntity = jiankangjiaoyuService.selectOne(queryWrapper);
// 如果未查询到相同数据
if (jiankangjiaoyuEntity == null) {
// 设置插入时间为当前时间
jiankangjiaoyu.setInsertTime(new Date());
// 设置逻辑删除字段为1，表示未删除
jiankangjiaoyu.setJiankangjiaoyuDelete(1);
// 设置创建时间为当前时间
jiankangjiaoyu.setCreateTime(new Date());
// 调用健康教育服务的insert方法，将健康教育实体插入数据库
jiankangjiaoyuService.insert(jiankangjiaoyu);
// 返回成功响应
return R.ok();
} else {
// 如果查询到相同数据，返回错误响应，错误码为511
return R.error(511, "表中有相同数据");
}
}
}

202
src/main/java/com/controller/NewsController.java
Unescape View File

@ -1,35 +1,63 @@
package com.controller;
// 导入文件操作相关类
import java.io.File;
// 导入用于高精度计算的类
import java.math.BigDecimal;
// 导入用于处理URL的类
import java.net.URL;
// 导入用于日期格式化的类
import java.text.SimpleDateFormat;
// 导入阿里巴巴的JSON对象类
import com.alibaba.fastjson.JSONObject;
// 导入常用的集合类
import java.util.*;
// 导入Spring的Bean属性复制工具类
import org.springframework.beans.BeanUtils;
// 导入Servlet请求相关类
import javax.servlet.http.HttpServletRequest;
// 导入Spring的上下文加载器类
import org.springframework.web.context.ContextLoader;
// 导入Servlet上下文类
import javax.servlet.ServletContext;
// 导入令牌服务类
import com.service.TokenService;
// 导入自定义工具类
import com.utils.*;
// 导入反射调用异常类
import java.lang.reflect.InvocationTargetException;
// 导入字典服务类
import com.service.DictionaryService;
// 导入Apache Commons提供的字符串工具类
import org.apache.commons.lang3.StringUtils;
// 导入自定义的忽略权限注解类
import com.annotation.IgnoreAuth;
// 导入日志记录器接口
import org.slf4j.Logger;
// 导入日志记录器工厂类
import org.slf4j.LoggerFactory;
// 导入Spring的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
// 导入Spring的控制器注解
import org.springframework.stereotype.Controller;
// 导入Spring的请求映射注解
import org.springframework.web.bind.annotation.*;
// 导入MyBatis-Plus的实体包装器类
import com.baomidou.mybatisplus.mapper.EntityWrapper;
// 导入MyBatis-Plus的查询包装器接口
import com.baomidou.mybatisplus.mapper.Wrapper;
// 导入自定义的实体类
import com.entity.*;
// 导入自定义的视图类
import com.entity.view.*;
// 导入自定义的服务类
import com.service.*;
// 导入自定义的分页工具类
import com.utils.PageUtils;
// 导入自定义的响应结果类
import com.utils.R;
// 导入阿里巴巴的JSON工具类
import com.alibaba.fastjson.*;
/**
@ -38,101 +66,135 @@ import com.alibaba.fastjson.*;
* @author
* @email
*/
// 声明该类为RESTful控制器，用于处理HTTP请求并返回JSON数据
@RestController
// 声明该类为Spring MVC控制器
@Controller
// 映射请求路径，所有以/news开头的请求都会由该控制器处理
@RequestMapping("/news")
public class NewsController {
// 日志记录器，用于记录当前控制器类的日志信息
private static final Logger logger = LoggerFactory.getLogger(NewsController.class);
// 自动注入新闻服务类，用于处理新闻相关业务逻辑
@Autowired
private NewsService newsService;
// 自动注入令牌服务类
@Autowired
private TokenService tokenService;
// 自动注入字典服务类，用于字典表数据转换
@Autowired
private DictionaryService dictionaryService;
//级联表service
// 级联表service，自动注入用户服务类
@Autowired
private YonghuService yonghuService;
// 级联表service，自动注入医生服务类
@Autowired
private YishengService yishengService;
/**
* 后端列表
*/
// 映射/page请求路径，支持GET请求，用于获取公告信息的分页列表
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和请求参数
logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
// 从请求会话中获取用户角色
String role = String.valueOf(request.getSession().getAttribute("role"));
// 此条件永远为false，注释掉的代码表示永远不会进入该分支
if (false)
return R.error(511, "永不会进入");
// 如果用户角色为"用户"
else if ("用户".equals(role))
// 在请求参数中添加用户id
params.put("yonghuId", request.getSession().getAttribute("userId"));
// 如果用户角色为"医生"
else if ("医生".equals(role))
// 在请求参数中添加医生id
params.put("yishengId", request.getSession().getAttribute("userId"));
// 如果请求参数中没有指定排序字段，则默认按id排序
if (params.get("orderBy") == null || params.get("orderBy") == "") {
params.put("orderBy", "id");
}
// 调用新闻服务的queryPage方法，根据请求参数进行分页查询
PageUtils page = newsService.queryPage(params);
//字典表数据转换
// 将分页结果中的列表转换为新闻视图列表
List<NewsView> list = (List<NewsView>) page.getList();
// 遍历新闻视图列表
for (NewsView c : list) {
//修改对应字典表字段
// 调用字典服务的dictionaryConvert方法，修改对应字典表字段
dictionaryService.dictionaryConvert(c, request);
}
// 返回成功响应，并将分页查询结果放入响应数据中
return R.ok().put("data", page);
}
/**
* 后端详情
*/
// 映射/info/{id}请求路径，支持GET请求，{id}为路径变量，用于获取指定id的公告信息详情
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和请求的id
logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
// 调用新闻服务的selectById方法，根据id查询新闻实体
NewsEntity news = newsService.selectById(id);
// 如果查询到新闻实体
if (news != null) {
//entity转view
// 创建新闻视图对象
NewsView view = new NewsView();
BeanUtils.copyProperties( news , view );//把实体数据重构到view中
// 使用BeanUtils将新闻实体的属性复制到新闻视图中
BeanUtils.copyProperties(news, view);
//修改对应字典表字段
// 调用字典服务的dictionaryConvert方法，修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
// 返回成功响应，并将新闻视图对象放入响应数据中
return R.ok().put("data", view);
} else {
// 如果未查询到数据，返回错误响应，错误码为511
return R.error(511, "查不到数据");
}
}
/**
* 后端保存
*/
// 映射/save请求路径，支持POST请求，用于保存新的公告信息
@RequestMapping("/save")
public R save(@RequestBody NewsEntity news, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和要保存的新闻实体信息
logger.debug("save方法:,,Controller:{},,news:{}", this.getClass().getName(), news.toString());
// 从请求会话中获取用户角色
String role = String.valueOf(request.getSession().getAttribute("role"));
// 此条件永远为false，注释掉的代码表示永远不会进入该分支
if (false)
return R.error(511, "永远不会进入");
// 创建查询包装器，用于构建查询条件，检查是否存在相同的公告信息
Wrapper<NewsEntity> queryWrapper = new EntityWrapper<NewsEntity>()
.eq("news_name", news.getNewsName())
.eq("news_types", news.getNewsTypes())
;
.eq("news_types", news.getNewsTypes());
// 记录生成的SQL查询语句
logger.info("sql语句:" + queryWrapper.getSqlSegment());
// 调用新闻服务的selectOne方法，根据查询条件查询是否存在相同数据
NewsEntity newsEntity = newsService.selectOne(queryWrapper);
// 如果未查询到相同数据
if (newsEntity == null) {
// 设置插入时间为当前时间
news.setInsertTime(new Date());
// 设置创建时间为当前时间
news.setCreateTime(new Date());
// 调用新闻服务的insert方法，将新闻实体插入数据库
newsService.insert(news);
// 返回成功响应
return R.ok();
} else {
// 如果查询到相同数据，返回错误响应，错误码为511
return R.error(511, "表中有相同数据");
}
}
@ -140,30 +202,39 @@ public class NewsController {
/**
* 后端修改
*/
// 映射/update请求路径，支持POST请求，用于修改已有的公告信息
@RequestMapping("/update")
public R update(@RequestBody NewsEntity news, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和要修改的新闻实体信息
logger.debug("update方法:,,Controller:{},,news:{}", this.getClass().getName(), news.toString());
// 从请求会话中获取用户角色
String role = String.valueOf(request.getSession().getAttribute("role"));
// 此条件注释掉，表示永远不会进入该分支
// if (false)
// return R.error(511, "永远不会进入");
//根据字段查询是否有相同数据
// 创建查询包装器，用于构建查询条件，排除当前要修改的记录，检查是否存在相同的公告信息
Wrapper<NewsEntity> queryWrapper = new EntityWrapper<NewsEntity>()
.notIn("id", news.getId())
.andNew()
.eq("news_name", news.getNewsName())
.eq("news_types", news.getNewsTypes())
;
.eq("news_types", news.getNewsTypes());
// 记录生成的SQL查询语句
logger.info("sql语句:" + queryWrapper.getSqlSegment());
// 调用新闻服务的selectOne方法，根据查询条件查询是否存在相同数据
NewsEntity newsEntity = newsService.selectOne(queryWrapper);
// 如果新闻照片字段为空字符串或"null"，则将其设置为null
if ("".equals(news.getNewsPhoto()) || "null".equals(news.getNewsPhoto())) {
news.setNewsPhoto(null);
}
// 如果未查询到相同数据
if (newsEntity == null) {
newsService.updateById(news);//根据id更新
// 调用新闻服务的updateById方法，根据id更新新闻实体
newsService.updateById(news);
// 返回成功响应
return R.ok();
} else {
// 如果查询到相同数据，返回错误响应，错误码为511
return R.error(511, "表中有相同数据");
}
}
@ -171,134 +242,145 @@ public class NewsController {
/**
* 删除
*/
// 映射/delete请求路径，支持POST请求，用于删除公告信息
@RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids) {
// 记录方法调用日志，包含控制器类名和要删除的记录id数组
logger.debug("delete:,,Controller:{},,ids:{}", this.getClass().getName(), ids.toString());
// 调用新闻服务的deleteBatchIds方法，根据id数组批量删除记录
newsService.deleteBatchIds(Arrays.asList(ids));
// 返回成功响应
return R.ok();
}
/**
* 批量上传
*/
// 映射/batchInsert请求路径，支持POST请求，用于批量上传公告信息
@RequestMapping("/batchInsert")
public R save(String fileName) {
// 记录方法调用日志，包含控制器类名和文件名
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName);
try {
List<NewsEntity> newsList = new ArrayList<>();//上传的东西
Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
// 创建一个列表，用于存储要上传的新闻实体
List<NewsEntity> newsList = new ArrayList<>();
// 创建一个Map，用于存储要查询的字段
Map<String, List<String>> seachFields = new HashMap<>();
// 获取当前时间
Date date = new Date();
// 获取文件名中最后一个点的索引
int lastIndexOf = fileName.lastIndexOf(".");
// 如果文件名中没有点，返回错误响应，错误码为511
if (lastIndexOf == -1) {
return R.error(511, "该文件没有后缀");
} else {
// 获取文件后缀
String suffix = fileName.substring(lastIndexOf);
// 如果文件后缀不是.xls，返回错误响应，错误码为511
if (!".xls".equals(suffix)) {
return R.error(511, "只支持后缀为xls的excel文件");
} else {
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
// 获取文件的URL
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);
// 创建文件对象
File file = new File(resource.getFile());
// 如果文件不存在，返回错误响应，错误码为511
if (!file.exists()) {
return R.error(511, "找不到上传文件，请联系管理员");
} else {
List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
dataList.remove(0);//删除第一行，因为第一行是提示
// 使用PoiUtil工具类读取xls文件的数据
List<List<String>> dataList = PoiUtil.poiImport(file.getPath());
// 删除第一行数据，因为第一行通常是表头
dataList.remove(0);
// 遍历数据列表
for (List<String> data : dataList) {
//循环
// 创建一个新的新闻实体
NewsEntity newsEntity = new NewsEntity();
// 以下代码注释掉，表示需要根据实际情况修改字段赋值
// newsEntity.setNewsName(data.get(0)); //公告名称 要改的
// newsEntity.setNewsPhoto("");//照片
// newsEntity.setNewsTypes(Integer.valueOf(data.get(0))); //公告类型 要改的
// newsEntity.setInsertTime(date);//时间
// newsEntity.setNewsContent("");//照片
// newsEntity.setCreateTime(date);//时间
// 将新闻实体添加到上传列表中
newsList.add(newsEntity);
// 把要查询是否重复的字段放入map中
}
//查询是否重复
// 调用新闻服务的insertBatch方法，批量插入新闻实体
newsService.insertBatch(newsList);
// 返回成功响应
return R.ok();
}
}
}
} catch (Exception e) {
// 如果发生异常，返回错误响应，错误码为511
return R.error(511, "批量插入数据异常，请联系管理员");
}
}
/**
* 前端列表
*/
// 映射/list请求路径，支持GET请求，用于前端获取公告信息的分页列表，忽略权限验证
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和请求参数
logger.debug("list方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
// 没有指定排序字段就默认id倒序
// 如果请求参数中没有指定排序字段，则默认按id倒序排序
if (StringUtil.isEmpty(String.valueOf(params.get("orderBy")))) {
params.put("orderBy", "id");
}
// 调用新闻服务的queryPage方法，根据请求参数进行分页查询
PageUtils page = newsService.queryPage(params);
//字典表数据转换
// 将分页结果中的列表转换为新闻视图列表
List<NewsView> list = (List<NewsView>) page.getList();
// 遍历新闻视图列表
for (NewsView c : list)
dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段
// 调用字典服务的dictionaryConvert方法，修改对应字典表字段
dictionaryService.dictionaryConvert(c, request);
// 返回成功响应，并将分页查询结果放入响应数据中
return R.ok().put("data", page);
}
/**
* 前端详情
*/
// 映射/detail/{id}请求路径，支持GET请求，{id}为路径变量，用于前端获取指定id的公告信息详情
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和请求的id
logger.debug("detail方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
// 调用新闻服务的selectById方法，根据id查询新闻实体
NewsEntity news = newsService.selectById(id);
// 如果查询到新闻实体
if (news != null) {
//entity转view
// 创建新闻视图对象
NewsView view = new NewsView();
BeanUtils.copyProperties( news , view );//把实体数据重构到view中
// 使用BeanUtils将新闻实体的属性复制到新闻视图中
BeanUtils.copyProperties(news, view);
//修改对应字典表字段
// 调用字典服务的dictionaryConvert方法，修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
// 返回成功响应，并将新闻视图对象放入响应数据中
return R.ok().put("data", view);
} else {
// 如果未查询到数据，返回错误响应，错误码为511
return R.error(511, "查不到数据");
}
}
/**
* 前端保存
*/
// 映射/add请求路径，支持POST请求，用于前端保存新的公告信息
@RequestMapping("/add")
public R add(@RequestBody NewsEntity news, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和要保存的新闻实体信息
logger.debug("add方法:,,Controller:{},,news:{}", this.getClass().getName(), news.toString());
Wrapper<NewsEntity> queryWrapper = new EntityWrapper<NewsEntity>()
.eq("news_name", news.getNewsName())
.eq("news_types", news.getNewsTypes())
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
NewsEntity newsEntity = newsService.selectOne(queryWrapper);
if(newsEntity==null){
news.setInsertTime(new Date());
news.setCreateTime(new Date());
newsService.insert(news);
return R.ok();
}else {
return R.error(511,"表中有相同数据");
}
}
}
// 创建查询包装器，用于构建查询条件，检查是否存在相同的公告信息

98
src/main/java/com/controller/UsersController.java
Unescape View File

@ -1,7 +1,5 @@
package com.controller;
import java.util.Arrays;
import java.util.Map;
@ -28,31 +26,49 @@ import com.utils.R;
/**
* 登录相关
*/
// 定义请求映射路径，所有以/users开头的请求会被该控制器处理
@RequestMapping("users")
// 声明该类为一个RESTful风格的控制器，用于处理HTTP请求并返回JSON数据
@RestController
public class UsersController {
// 自动注入UsersService，用于处理与用户相关的业务逻辑
@Autowired
private UsersService usersService;
// 自动注入TokenService，用于处理与令牌相关的业务逻辑
@Autowired
private TokenService tokenService;
/**
* 登录
* 处理用户登录请求
* @param username 用户名
* @param password 密码
* @param captcha 验证码（当前代码未实际使用该参数）
* @param request HTTP请求对象
* @return R类型的响应对象，包含登录结果信息
*/
@IgnoreAuth
@IgnoreAuth // 忽略权限验证的注解
@PostMapping(value = "/login")
public R login(String username, String password, String captcha, HttpServletRequest request) {
// 根据用户名查询用户实体
UsersEntity user = usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username));
// 如果用户不存在或者用户输入的密码与数据库中存储的密码不匹配
if (user == null || !user.getPassword().equals(password)) {
// 返回错误响应，提示账号或密码不正确
return R.error("账号或密码不正确");
}
// 生成用户令牌，参数依次为用户ID、用户名、用户类型标识、用户角色
String token = tokenService.generateToken(user.getId(), username, "users", user.getRole());
// 创建一个成功的响应对象
R r = R.ok();
// 将生成的令牌放入响应数据中
r.put("token", token);
// 将用户的角色信息放入响应数据中
r.put("role", user.getRole());
// 将用户的ID信息放入响应数据中
r.put("userId", user.getId());
// 返回响应对象
return r;
}
@ -62,11 +78,15 @@ public class UsersController {
@IgnoreAuth
@PostMapping(value = "/register")
public R register(@RequestBody UsersEntity user) {
// ValidatorUtils.validateEntity(user);
// ValidatorUtils.validateEntity(user); // 被注释掉的代码，可能用于验证用户实体的合法性，目前未启用
// 根据用户名查询数据库，判断用户是否已经存在
if (usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())) != null) {
// 如果用户已存在，返回错误响应
return R.error("用户已存在");
}
// 将新用户插入到数据库中
usersService.insert(user);
// 返回成功响应
return R.ok();
}
@ -75,94 +95,140 @@ public class UsersController {
*/
@GetMapping(value = "logout")
public R logout(HttpServletRequest request) {
// 使当前用户的会话失效，实现退出登录
request.getSession().invalidate();
// 返回成功响应，并附带退出成功的提示信息
return R.ok("退出成功");
}
/**
* 密码重置
* 处理用户密码重置请求
* @param username 用户名
* @param request HTTP请求对象
* @return R类型的响应对象，包含密码重置结果信息
*/
@IgnoreAuth
@IgnoreAuth // 忽略权限验证的注解
@RequestMapping(value = "/resetPass")
public R resetPass(String username, HttpServletRequest request) {
// 根据用户名查询用户实体
UsersEntity user = usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username));
// 如果用户不存在
if (user == null) {
// 返回错误响应，提示账号不存在
return R.error("账号不存在");
}
// 将用户密码重置为默认值123456
user.setPassword("123456");
// 更新用户信息到数据库（第二个参数为null，可能表示更新时不设置额外的条件）
usersService.update(user, null);
// 返回成功响应，并附带密码已重置的提示信息
return R.ok("密码已重置为：123456");
}
/**
* 列表
* 处理获取用户列表的分页请求
* @param params 包含分页和查询条件的参数Map
* @param user 用户实体对象，可能用于构建查询条件
* @return R类型的响应对象，包含分页后的用户列表数据
*/
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, UsersEntity user) {
// 创建一个EntityWrapper对象，用于构建查询条件
EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>();
// 调用usersService的queryPage方法进行分页查询，MPUtil.sort等方法用于处理查询条件和排序
PageUtils page = usersService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params));
// 返回成功响应，并将分页结果数据放入响应中
return R.ok().put("data", page);
}
/**
* 列表
* 处理获取用户列表的请求
* @param user 用户实体对象，用于构建查询条件
* @return R类型的响应对象，包含用户列表数据
*/
@RequestMapping("/list")
public R list(UsersEntity user) {
// 创建一个EntityWrapper对象
EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>();
// 根据用户实体对象构建查询条件，使用MPUtil.allEQMapPre方法设置相等条件
ew.allEq(MPUtil.allEQMapPre(user, "user"));
// 调用usersService的selectListView方法查询用户列表，并将结果放入响应中返回
return R.ok().put("data", usersService.selectListView(ew));
}
/**
* 信息
* 处理获取指定用户信息的请求
* @param id 用户ID，通过路径变量获取
* @return R类型的响应对象，包含指定用户的信息
*/
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") String id) {
// 根据用户ID查询用户实体
UsersEntity user = usersService.selectById(id);
// 返回成功响应，并将用户信息放入响应中
return R.ok().put("data", user);
}
/**
* 获取用户的session用户信息
* 处理获取当前会话用户信息的请求
* @param request HTTP请求对象
* @return R类型的响应对象，包含当前会话用户的信息
*/
@RequestMapping("/session")
public R getCurrUser(HttpServletRequest request) {
// 从当前会话中获取用户ID
Integer id = (Integer) request.getSession().getAttribute("userId");
// 根据用户ID查询用户实体
UsersEntity user = usersService.selectById(id);
// 返回成功响应，并将用户信息放入响应中
return R.ok().put("data", user);
}
/**
* 保存
* 处理保存新用户的请求
* @param user 用户实体对象，通过请求体获取
* @return R类型的响应对象，包含保存结果信息
*/
@PostMapping("/save")
public R save(@RequestBody UsersEntity user) {
// ValidatorUtils.validateEntity(user);
// ValidatorUtils.validateEntity(user); // 被注释掉的代码，可能用于验证用户实体的合法性，目前未启用
// 根据用户名查询数据库，判断用户是否已经存在
if (usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())) != null) {
// 如果用户已存在，返回错误响应
return R.error("用户已存在");
}
// 设置用户密码为默认值123456
user.setPassword("123456");
// 将用户插入到数据库中
usersService.insert(user);
// 返回成功响应
return R.ok();
}
/**
* 修改
* 处理更新用户信息的请求
* @param user 用户实体对象，通过请求体获取
* @return R类型的响应对象，包含更新结果信息
*/
@RequestMapping("/update")
public R update(@RequestBody UsersEntity user) {
// ValidatorUtils.validateEntity(user);
// ValidatorUtils.validateEntity(user); // 被注释掉的代码，可能用于验证用户实体的合法性，目前未启用
// 根据用户ID更新用户信息到数据库
usersService.updateById(user); // 全部更新
// 返回成功响应
return R.ok();
}
/**
* 删除
* 处理删除用户的请求
* @param ids 要删除的用户ID数组，通过请求体获取
* @return R类型的响应对象，包含删除结果信息
*/
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 根据用户ID数组批量删除用户
usersService.deleteBatchIds(Arrays.asList(ids));
// 返回成功响应
return R.ok();
}
}

230
src/main/java/com/controller/YishengController.java
Unescape View File

@ -38,24 +38,27 @@ import com.alibaba.fastjson.*;
* @email
*/
@RestController
// 声明为Spring MVC控制器
@Controller
// 定义请求映射路径，所有以/yisheng开头的请求由该控制器处理
@RequestMapping("/yisheng")
public class YishengController {
// 日志记录器，用于记录当前控制器的日志信息
private static final Logger logger = LoggerFactory.getLogger(YishengController.class);
// 自动注入医生服务类，用于处理医生相关业务逻辑
@Autowired
private YishengService yishengService; // 医生服务
private YishengService yishengService;
@Autowired
private TokenService tokenService; // token服务
private TokenService tokenService;
@Autowired
private DictionaryService dictionaryService; // 字典服务
//级联表service
private DictionaryService dictionaryService;
// 级联表service，自动注入用户服务类
@Autowired
private YonghuService yonghuService; // 用户服务
private YonghuService yonghuService;
/**
* 后端列表
@ -63,25 +66,25 @@ public class YishengController {
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
String role = String.valueOf(request.getSession().getAttribute("role"));
if(false)
return R.error(511,"永不会进入");
else if("用户".equals(role))
params.put("yonghuId",request.getSession().getAttribute("userId")); // 如果是用户角色，添加用户ID参数
params.put("yonghuId",request.getSession().getAttribute("userId"));
else if("医生".equals(role))
params.put("yishengId",request.getSession().getAttribute("userId")); // 如果是医生角色，添加医生ID参数
params.put("yishengId",request.getSession().getAttribute("userId"));
if(params.get("orderBy")==null || params.get("orderBy")==""){
params.put("orderBy","id"); // 默认按ID排序
params.put("orderBy","id");
}
PageUtils page = yishengService.queryPage(params); // 分页查询
PageUtils page = yishengService.queryPage(params);
//字典表数据转换
List<YishengView> list =(List<YishengView>)page.getList();
for(YishengView c:list){
//修改对应字典表字段
dictionaryService.dictionaryConvert(c, request); // 转换字典字段
dictionaryService.dictionaryConvert(c, request);
}
return R.ok().put("data", page); // 返回分页数据
return R.ok().put("data", page);
}
/**
@ -90,17 +93,17 @@ public class YishengController {
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
YishengEntity yisheng = yishengService.selectById(id); // 根据ID查询医生
YishengEntity yisheng = yishengService.selectById(id);
if(yisheng !=null){
//entity转view
YishengView view = new YishengView();
BeanUtils.copyProperties( yisheng , view );//把实体数据重构到view中
//修改对应字典表字段
dictionaryService.dictionaryConvert(view, request); // 转换字典字段
return R.ok().put("data", view); // 返回医生详情
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据"); // 查询不到返回错误
return R.error(511,"查不到数据");
}
}
@ -109,27 +112,27 @@ public class YishengController {
*/
@RequestMapping("/save")
public R save(@RequestBody YishengEntity yisheng, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和要保存的医生实体信息
logger.debug("save方法:,,Controller:{},,yisheng:{}", this.getClass().getName(), yisheng.toString());
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
String role = String.valueOf(request.getSession().getAttribute("role"));
if(false)
return R.error(511,"永远不会进入");
// 构建查询条件：用户名或手机号
Wrapper<YishengEntity> queryWrapper = new EntityWrapper<YishengEntity>()
.eq("username", yisheng.getUsername())
.or()
.eq("yisheng_phone", yisheng.getYishengPhone());
logger.info("sql语句:"+queryWrapper.getSqlSegment());
YishengEntity yishengEntity = yishengService.selectOne(queryWrapper); // 查询是否已存在
YishengEntity yishengEntity = yishengService.selectOne(queryWrapper);
if(yishengEntity==null){
yisheng.setCreateTime(new Date()); // 设置创建时间
yisheng.setPassword("123456"); // 设置默认密码
yishengService.insert(yisheng); // 插入新医生数据
return R.ok(); // 返回成功
yisheng.setCreateTime(new Date());
yisheng.setPassword("123456");
yishengService.insert(yisheng);
return R.ok();
}else {
return R.error(511,"账户或者联系方式已经被使用"); // 已存在返回错误
return R.error(511,"账户或者联系方式已经被使用");
}
}
@ -138,27 +141,31 @@ public class YishengController {
*/
@RequestMapping("/update")
public R update(@RequestBody YishengEntity yisheng, HttpServletRequest request) {
// 记录方法调用日志，包含控制器类名和要更新的医生实体信息
logger.debug("update方法:,,Controller:{},,yisheng:{}", this.getClass().getName(), yisheng.toString());
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
// 构建查询条件：排除当前ID，查询用户名或手机号是否已被其他记录使用
String role = String.valueOf(request.getSession().getAttribute("role"));
// if(false)
// return R.error(511,"永远不会进入");
//根据字段查询是否有相同数据
Wrapper<YishengEntity> queryWrapper = new EntityWrapper<YishengEntity>()
.notIn("id",yisheng.getId())
.andNew()
.eq("username", yisheng.getUsername())
.or()
.eq("yisheng_phone", yisheng.getYishengPhone());
.eq("yisheng_phone", yisheng.getYishengPhone())
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
YishengEntity yishengEntity = yishengService.selectOne(queryWrapper); // 查询是否冲突
YishengEntity yishengEntity = yishengService.selectOne(queryWrapper);
if("".equals(yisheng.getYishengPhoto()) || "null".equals(yisheng.getYishengPhoto())){
yisheng.setYishengPhoto(null); // 处理空照片
yisheng.setYishengPhoto(null);
}
if(yishengEntity==null){
yishengService.updateById(yisheng);//根据id更新
return R.ok(); // 返回成功
return R.ok();
}else {
return R.error(511,"账户或者联系方式已经被使用"); // 冲突返回错误
return R.error(511,"账户或者联系方式已经被使用");
}
}
@ -168,40 +175,56 @@ public class YishengController {
@RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids){
logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
yishengService.deleteBatchIds(Arrays.asList(ids)); // 批量删除
return R.ok(); // 返回成功
yishengService.deleteBatchIds(Arrays.asList(ids));
return R.ok();
}
/**
* 批量上传
* 批量上传医生信息
*/
@RequestMapping("/batchInsert")
public R save(String fileName) {
// 记录方法调用日志，包含控制器类名和文件名
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName);
try {
List<YishengEntity> yishengList = new ArrayList<>(); // 上传的数据列表
List<YishengEntity> yishengList = new ArrayList<>();//上传的东西
Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
Date date = new Date();
// 获取文件名中最后一个点的索引
int lastIndexOf = fileName.lastIndexOf(".");
if(lastIndexOf == -1){
return R.error(511,"该文件没有后缀"); // 文件后缀检查
return R.error(511,"该文件没有后缀");
}else{
String suffix = fileName.substring(lastIndexOf);
if(!".xls".equals(suffix)){
return R.error(511,"只支持后缀为xls的excel文件"); // 文件格式检查
return R.error(511,"只支持后缀为xls的excel文件");
}else{
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
File file = new File(resource.getFile());
if(!file.exists()){
return R.error(511,"找不到上传文件，请联系管理员"); // 文件存在检查
return R.error(511,"找不到上传文件，请联系管理员");
}else{
List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
dataList.remove(0); // 删除第一行提示行
dataList.remove(0);//删除第一行，因为第一行是提示
for(List<String> data:dataList){
//循环处理每行数据
//循环
YishengEntity yishengEntity = new YishengEntity();
// 这里注释掉的代码是字段映射示例，实际使用时需要根据Excel列对应关系修改
yishengList.add(yishengEntity); // 添加到列表
// yishengEntity.setYishengUuidNumber(data.get(0)); //医生工号 要改的
// yishengEntity.setUsername(data.get(0)); //账户 要改的
// //yishengEntity.setPassword("123456");//密码
// yishengEntity.setYishengName(data.get(0)); //医生名称 要改的
// yishengEntity.setYishengTypes(Integer.valueOf(data.get(0))); //科室 要改的
// yishengEntity.setZhiweiTypes(Integer.valueOf(data.get(0))); //职位 要改的
// yishengEntity.setYishengZhichneg(data.get(0)); //职称 要改的
// yishengEntity.setYishengPhoto("");//照片
// yishengEntity.setYishengPhone(data.get(0)); //联系方式 要改的
// yishengEntity.setYishengGuahao(data.get(0)); //挂号须知 要改的
// yishengEntity.setYishengEmail(data.get(0)); //邮箱 要改的
// yishengEntity.setYishengNewMoney(data.get(0)); //挂号价格 要改的
// yishengEntity.setYishengContent("");//照片
// yishengEntity.setCreateTime(date);//时间
yishengList.add(yishengEntity);
//把要查询是否重复的字段放入map中
//医生工号
@ -261,13 +284,13 @@ public class YishengController {
}
return R.error(511, "数据库的该表中的 [联系方式] 字段已经存在 存在数据为:" + repeatFields.toString());
}
yishengService.insertBatch(yishengList); // 批量插入
yishengService.insertBatch(yishengList);
return R.ok();
}
}
}
}catch (Exception e){
return R.error(511,"批量插入数据异常，请联系管理员"); // 异常处理
return R.error(511,"批量插入数据异常，请联系管理员");
}
}
@ -277,16 +300,21 @@ public class YishengController {
@IgnoreAuth
@RequestMapping(value = "/login")
public R login(String username, String password, String captcha, HttpServletRequest request) {
YishengEntity yisheng = yishengService.selectOne(new EntityWrapper<YishengEntity>().eq("username", username)); // 根据用户名查询
YishengEntity yisheng = yishengService.selectOne(new EntityWrapper<YishengEntity>().eq("username", username));
if(yisheng==null || !yisheng.getPassword().equals(password))
return R.error("账号或密码不正确"); // 验证账号密码
String token = tokenService.generateToken(yisheng.getId(),username, "yisheng", "医生"); // 生成token
return R.error("账号或密码不正确");
// // 获取监听器中的字典表
// ServletContext servletContext = ContextLoader.getCurrentWebApplicationContext().getServletContext();
// Map<String, Map<Integer, String>> dictionaryMap= (Map<String, Map<Integer, String>>) servletContext.getAttribute("dictionaryMap");
// Map<Integer, String> role_types = dictionaryMap.get("role_types");
// role_types.get(.getRoleTypes());
String token = tokenService.generateToken(yisheng.getId(),username, "yisheng", "医生");
R r = R.ok();
r.put("token", token); // 返回token
r.put("role","医生"); // 返回角色
r.put("username",yisheng.getYishengName()); // 返回医生姓名
r.put("tableName","yisheng"); // 返回表名
r.put("userId",yisheng.getId()); // 返回用户ID
r.put("token", token);
r.put("role","医生");
r.put("username",yisheng.getYishengName());
r.put("tableName","yisheng");
r.put("userId",yisheng.getId());
return r;
}
@ -296,18 +324,19 @@ public class YishengController {
@IgnoreAuth
@PostMapping(value = "/register")
public R register(@RequestBody YishengEntity yisheng){
// 构建查询条件：用户名或手机号
// ValidatorUtils.validateEntity(user);
Wrapper<YishengEntity> queryWrapper = new EntityWrapper<YishengEntity>()
.eq("username", yisheng.getUsername())
.or()
.eq("yisheng_phone", yisheng.getYishengPhone());
YishengEntity yishengEntity = yishengService.selectOne(queryWrapper); // 查询是否已存在
.eq("yisheng_phone", yisheng.getYishengPhone())
;
YishengEntity yishengEntity = yishengService.selectOne(queryWrapper);
if(yishengEntity != null)
return R.error("账户或者联系方式已经被使用"); // 已存在返回错误
yisheng.setYishengNewMoney(0.0); // 设置初始金额
yisheng.setCreateTime(new Date()); // 设置创建时间
yishengService.insert(yisheng); // 插入新医生
return R.ok(); // 返回成功
return R.error("账户或者联系方式已经被使用");
yisheng.setYishengNewMoney(0.0);
yisheng.setCreateTime(new Date());
yishengService.insert(yisheng);
return R.ok();
}
/**
@ -316,60 +345,66 @@ public class YishengController {
@GetMapping(value = "/resetPassword")
public R resetPassword(Integer id){
YishengEntity yisheng = new YishengEntity();
yisheng.setPassword("123456"); // 重置为默认密码
yisheng.setPassword("123456");
yisheng.setId(id);
yishengService.updateById(yisheng); // 更新密码
return R.ok(); // 返回成功
yishengService.updateById(yisheng);
return R.ok();
}
/**
* 忘记密码
*/
@IgnoreAuth
@RequestMapping(value = "/resetPass")
public R resetPass(String username, HttpServletRequest request) {
YishengEntity yisheng = yishengService.selectOne(new EntityWrapper<YishengEntity>().eq("username", username)); // 根据用户名查询
YishengEntity yisheng = yishengService.selectOne(new EntityWrapper<YishengEntity>().eq("username", username));
if(yisheng!=null){
yisheng.setPassword("123456"); // 重置为默认密码
boolean b = yishengService.updateById(yisheng); // 更新密码
yisheng.setPassword("123456");
boolean b = yishengService.updateById(yisheng);
if(!b){
return R.error(); // 更新失败
return R.error();
}
}else{
return R.error("账号不存在"); // 账号不存在
return R.error("账号不存在");
}
return R.ok(); // 返回成功
return R.ok();
}
/**
* 获取用户的session用户信息
*/
@RequestMapping("/session")
public R getCurrYisheng(HttpServletRequest request){
Integer id = (Integer)request.getSession().getAttribute("userId"); // 获取session中的用户ID
YishengEntity yisheng = yishengService.selectById(id); // 查询用户信息
Integer id = (Integer)request.getSession().getAttribute("userId");
YishengEntity yisheng = yishengService.selectById(id);
if(yisheng !=null){
//entity转view
YishengView view = new YishengView();
BeanUtils.copyProperties( yisheng , view ); // 复制属性到view
BeanUtils.copyProperties( yisheng , view );//把实体数据重构到view中
//修改对应字典表字段
dictionaryService.dictionaryConvert(view, request); // 转换字典字段
return R.ok().put("data", view); // 返回用户信息
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据"); // 查询不到返回错误
return R.error(511,"查不到数据");
}
}
/**
* 退出
*/
@GetMapping(value = "logout")
public R logout(HttpServletRequest request) {
request.getSession().invalidate(); // 使session失效
return R.ok("退出成功"); // 返回退出成功
request.getSession().invalidate();
return R.ok("退出成功");
}
/**
* 前端列表
*/
@ -382,13 +417,13 @@ public class YishengController {
if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){
params.put("orderBy","id");
}
PageUtils page = yishengService.queryPage(params); // 分页查询
PageUtils page = yishengService.queryPage(params);
//字典表数据转换
List<YishengView> list =(List<YishengView>)page.getList();
for(YishengView c:list)
dictionaryService.dictionaryConvert(c, request); // 转换字典字段
return R.ok().put("data", page); // 返回分页数据
dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段
return R.ok().put("data", page);
}
/**
@ -397,40 +432,45 @@ public class YishengController {
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
YishengEntity yisheng = yishengService.selectById(id); // 根据ID查询
YishengEntity yisheng = yishengService.selectById(id);
if(yisheng !=null){
//entity转view
YishengView view = new YishengView();
BeanUtils.copyProperties( yisheng , view ); // 复制属性到view
BeanUtils.copyProperties( yisheng , view );//把实体数据重构到view中
//修改对应字典表字段
dictionaryService.dictionaryConvert(view, request); // 转换字典字段
return R.ok().put("data", view); // 返回详情
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据"); // 查询不到返回错误
return R.error(511,"查不到数据");
}
}
/**
* 前端保存
*/
@RequestMapping("/add")
public R add(@RequestBody YishengEntity yisheng, HttpServletRequest request){
logger.debug("add方法:,,Controller:{},,yisheng:{}",this.getClass().getName(),yisheng.toString());
// 构建查询条件：用户名或手机号
Wrapper<YishengEntity> queryWrapper = new EntityWrapper<YishengEntity>()
.eq("username", yisheng.getUsername())
.or()
.eq("yisheng_phone", yisheng.getYishengPhone());
.eq("yisheng_phone", yisheng.getYishengPhone())
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
YishengEntity yishengEntity = yishengService.selectOne(queryWrapper); // 查询是否已存在
YishengEntity yishengEntity = yishengService.selectOne(queryWrapper);
if(yishengEntity==null){
yisheng.setCreateTime(new Date()); // 设置创建时间
yisheng.setPassword("123456"); // 设置默认密码
yishengService.insert(yisheng); // 插入新医生
return R.ok(); // 返回成功
yisheng.setCreateTime(new Date());
yisheng.setPassword("123456");
yishengService.insert(yisheng);
return R.ok();
}else {
return R.error(511,"账户或者联系方式已经被使用"); // 已存在返回错误
return R.error(511,"账户或者联系方式已经被使用");
}
}
}

110
src/main/java/com/controller/YonghuController.java
Unescape View File

@ -32,7 +32,7 @@ import com.utils.R;
import com.alibaba.fastjson.*;
/**
* 用户控制器
* 用户
* 后端接口
* @author
* @email
@ -44,43 +44,37 @@ public class YonghuController {
private static final Logger logger = LoggerFactory.getLogger(YonghuController.class);
@Autowired
private YonghuService yonghuService; // 用户服务
private YonghuService yonghuService;
@Autowired
private TokenService tokenService; // token服务
private TokenService tokenService;
@Autowired
private DictionaryService dictionaryService; // 字典服务
//级联表service
@Autowired
private YishengService yishengService; // 医生服务
private YishengService yishengService;
/**
* 后端列表
* 分页查询用户数据
*/
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
String role = String.valueOf(request.getSession().getAttribute("role"));
// 权限控制
if(false)
return R.error(511,"永不会进入");
else if("用户".equals(role))
params.put("yonghuId",request.getSession().getAttribute("userId")); // 如果是用户角色，只查询自己的数据
params.put("yonghuId",request.getSession().getAttribute("userId"));
else if("医生".equals(role))
params.put("yishengId",request.getSession().getAttribute("userId")); // 如果是医生角色，添加医生ID参数
// 设置查询未删除的用户（删除状态为1表示未删除）
params.put("yishengId",request.getSession().getAttribute("userId"));
params.put("yonghuDeleteStart",1);params.put("yonghuDeleteEnd",1);
// 默认按id排序
if(params.get("orderBy")==null || params.get("orderBy")==""){
params.put("orderBy","id");
}
// 调用服务层查询分页数据
PageUtils page = yonghuService.queryPage(params);
//字典表数据转换
@ -94,12 +88,10 @@ public class YonghuController {
/**
* 后端详情
* 根据ID查询用户详情
*/
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
// 根据ID查询用户
YonghuEntity yonghu = yonghuService.selectById(id);
if(yonghu !=null){
//entity转view
@ -116,7 +108,6 @@ public class YonghuController {
/**
* 后端保存
* 新增用户
*/
@RequestMapping("/save")
public R save(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
@ -126,7 +117,6 @@ public class YonghuController {
if(false)
return R.error(511,"永远不会进入");
// 构建查询条件：检查用户名、手机号、身份证号是否已存在
Wrapper<YonghuEntity> queryWrapper = new EntityWrapper<YonghuEntity>()
.eq("username", yonghu.getUsername())
.or()
@ -134,16 +124,16 @@ public class YonghuController {
.or()
.eq("yonghu_id_number", yonghu.getYonghuIdNumber())
.andNew()
.eq("yonghu_delete", 1) // 未删除的用户
.eq("yonghu_delete", 1)
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper);
if(yonghuEntity==null){
yonghu.setYonghuDelete(1); // 设置未删除状态
yonghu.setCreateTime(new Date()); // 设置创建时间
yonghu.setPassword("123456"); // 设置默认密码
yonghuService.insert(yonghu); // 插入新用户
yonghu.setYonghuDelete(1);
yonghu.setCreateTime(new Date());
yonghu.setPassword("123456");
yonghuService.insert(yonghu);
return R.ok();
}else {
return R.error(511,"账户或者用户手机号或者用户身份证号已经被使用");
@ -152,16 +142,17 @@ public class YonghuController {
/**
* 后端修改
* 更新用户信息
*/
@RequestMapping("/update")
public R update(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
logger.debug("update方法:,,Controller:{},,yonghu:{}",this.getClass().getName(),yonghu.toString());
String role = String.valueOf(request.getSession().getAttribute("role"));
// 构建查询条件：检查其他用户是否已使用要修改的用户名、手机号或身份证号
// if(false)
// return R.error(511,"永远不会进入");
//根据字段查询是否有相同数据
Wrapper<YonghuEntity> queryWrapper = new EntityWrapper<YonghuEntity>()
.notIn("id",yonghu.getId()) // 排除当前用户
.notIn("id",yonghu.getId())
.andNew()
.eq("username", yonghu.getUsername())
.or()
@ -169,12 +160,11 @@ public class YonghuController {
.or()
.eq("yonghu_id_number", yonghu.getYonghuIdNumber())
.andNew()
.eq("yonghu_delete", 1) // 未删除的用户
.eq("yonghu_delete", 1)
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper);
// 处理空照片
if("".equals(yonghu.getYonghuPhoto()) || "null".equals(yonghu.getYonghuPhoto())){
yonghu.setYonghuPhoto(null);
}
@ -188,7 +178,6 @@ public class YonghuController {
/**
* 删除
* 逻辑删除用户（将删除状态设为2）
*/
@RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids){
@ -197,18 +186,17 @@ public class YonghuController {
for(Integer id:ids){
YonghuEntity yonghuEntity = new YonghuEntity();
yonghuEntity.setId(id);
yonghuEntity.setYonghuDelete(2); // 设置删除状态为2
yonghuEntity.setYonghuDelete(2);
list.add(yonghuEntity);
}
if(list != null && list.size() >0){
yonghuService.updateBatchById(list); // 批量更新
yonghuService.updateBatchById(list);
}
return R.ok();
}
/**
* 批量上传
* 通过Excel批量导入用户数据
*/
@RequestMapping("/batchInsert")
public R save( String fileName){
@ -235,9 +223,20 @@ public class YonghuController {
for(List<String> data:dataList){
//循环
YonghuEntity yonghuEntity = new YonghuEntity();
// 这里注释掉的代码是示例，实际应该根据Excel列映射字段
// yonghuEntity.setUsername(data.get(0)); //账户 要改的
// //yonghuEntity.setPassword("123456");//密码
// yonghuEntity.setYonghuName(data.get(0)); //用户姓名 要改的
// yonghuEntity.setYonghuPhoto("");//照片
// yonghuEntity.setYonghuPhone(data.get(0)); //用户手机号 要改的
// yonghuEntity.setYonghuIdNumber(data.get(0)); //用户身份证号 要改的
// yonghuEntity.setYonghuEmail(data.get(0)); //邮箱 要改的
// yonghuEntity.setSexTypes(Integer.valueOf(data.get(0))); //性别 要改的
// yonghuEntity.setNewMoney(data.get(0)); //余额 要改的
// yonghuEntity.setYonghuDelete(1);//逻辑删除字段
// yonghuEntity.setCreateTime(date);//时间
yonghuList.add(yonghuEntity);
//把要查询是否重复的字段放入map中
//账户
if(seachFields.containsKey("username")){
@ -308,19 +307,20 @@ public class YonghuController {
/**
* 登录
* 用户登录接口
*/
@IgnoreAuth
@RequestMapping(value = "/login")
public R login(String username, String password, String captcha, HttpServletRequest request) {
// 根据用户名查询用户
YonghuEntity yonghu = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("username", username));
if(yonghu==null || !yonghu.getPassword().equals(password))
return R.error("账号或密码不正确");
else if(yonghu.getYonghuDelete() != 1)
return R.error("账户已被删除");
// 生成token
// // 获取监听器中的字典表
// ServletContext servletContext = ContextLoader.getCurrentWebApplicationContext().getServletContext();
// Map<String, Map<Integer, String>> dictionaryMap= (Map<String, Map<Integer, String>>) servletContext.getAttribute("dictionaryMap");
// Map<Integer, String> role_types = dictionaryMap.get("role_types");
// role_types.get(.getRoleTypes());
String token = tokenService.generateToken(yonghu.getId(),username, "yonghu", "用户");
R r = R.ok();
r.put("token", token);
@ -333,12 +333,11 @@ public class YonghuController {
/**
* 注册
* 用户注册接口
*/
@IgnoreAuth
@PostMapping(value = "/register")
public R register(@RequestBody YonghuEntity yonghu){
// 检查用户名、手机号、身份证号是否已存在
// ValidatorUtils.validateEntity(user);
Wrapper<YonghuEntity> queryWrapper = new EntityWrapper<YonghuEntity>()
.eq("username", yonghu.getUsername())
.or()
@ -351,8 +350,6 @@ public class YonghuController {
YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper);
if(yonghuEntity != null)
return R.error("账户或者用户手机号或者用户身份证号已经被使用");
// 设置默认值
yonghu.setNewMoney(0.0);
yonghu.setYonghuDelete(1);
yonghu.setCreateTime(new Date());
@ -362,27 +359,26 @@ public class YonghuController {
/**
* 重置密码
* 将用户密码重置为默认值123456
*/
@GetMapping(value = "/resetPassword")
public R resetPassword(Integer id){
YonghuEntity yonghu = new YonghuEntity();
yonghu.setPassword("123456"); // 设置默认密码
yonghu.setPassword("123456");
yonghu.setId(id);
yonghuService.updateById(yonghu);
return R.ok();
}
/**
* 忘记密码
* 通过用户名重置密码
*/
@IgnoreAuth
@RequestMapping(value = "/resetPass")
public R resetPass(String username, HttpServletRequest request) {
YonghuEntity yonghu = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("username", username));
if(yonghu!=null){
yonghu.setPassword("123456"); // 重置为默认密码
yonghu.setPassword("123456");
boolean b = yonghuService.updateById(yonghu);
if(!b){
return R.error();
@ -393,9 +389,9 @@ public class YonghuController {
return R.ok();
}
/**
* 获取用户的session用户信息
* 获取当前登录用户的信息
*/
@RequestMapping("/session")
public R getCurrYonghu(HttpServletRequest request){
@ -414,19 +410,21 @@ public class YonghuController {
}
}
/**
* 退出
* 用户注销登录
*/
@GetMapping(value = "logout")
public R logout(HttpServletRequest request) {
request.getSession().invalidate(); // 使session失效
request.getSession().invalidate();
return R.ok("退出成功");
}
/**
* 前端列表
* 提供给前端使用的用户列表接口
*/
@IgnoreAuth
@RequestMapping("/list")
@ -448,13 +446,14 @@ public class YonghuController {
/**
* 前端详情
* 提供给前端使用的用户详情接口
*/
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
YonghuEntity yonghu = yonghuService.selectById(id);
if(yonghu !=null){
//entity转view
YonghuView view = new YonghuView();
BeanUtils.copyProperties( yonghu , view );//把实体数据重构到view中
@ -467,14 +466,13 @@ public class YonghuController {
}
}
/**
* 前端保存
* 提供给前端使用的用户新增接口
*/
@RequestMapping("/add")
public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
logger.debug("add方法:,,Controller:{},,yonghu:{}",this.getClass().getName(),yonghu.toString());
// 检查用户名、手机号、身份证号是否已存在
Wrapper<YonghuEntity> queryWrapper = new EntityWrapper<YonghuEntity>()
.eq("username", yonghu.getUsername())
.or()
@ -487,13 +485,15 @@ public class YonghuController {
logger.info("sql语句:"+queryWrapper.getSqlSegment());
YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper);
if(yonghuEntity==null){
yonghu.setYonghuDelete(1); // 设置未删除状态
yonghu.setCreateTime(new Date()); // 设置创建时间
yonghu.setPassword("123456"); // 设置默认密码
yonghu.setYonghuDelete(1);
yonghu.setCreateTime(new Date());
yonghu.setPassword("123456");
yonghuService.insert(yonghu);
return R.ok();
}else {
return R.error(511,"账户或者用户手机号或者用户身份证号已经被使用");
}
}
}

117
src/main/java/com/entity/ChatEntity.java
Unescape View File

@ -1,23 +1,36 @@
package com.entity;
// 导入 MyBatis-Plus 用于指定主键的注解
import com.baomidou.mybatisplus.annotations.TableId;
// 导入 MyBatis-Plus 用于指定数据库表名的注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入 JSR 303 验证注解，确保字段不为空字符串
import javax.validation.constraints.NotBlank;
// 导入 JSR 303 验证注解，确保集合或数组不为空
import javax.validation.constraints.NotEmpty;
// 导入 JSR 303 验证注解，确保字段不为 null
import javax.validation.constraints.NotNull;
// 导入 Jackson 注解，用于忽略 JSON 序列化和反序列化时的某些属性
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 导入反射调用可能抛出的异常类
import java.lang.reflect.InvocationTargetException;
// 导入序列化接口
import java.io.Serializable;
// 导入日期类
import java.util.Date;
// 导入列表集合类
import java.util.List;
// 导入 Spring 框架用于日期格式化的注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入 Jackson 用于 JSON 序列化时日期格式化的注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入 Apache Commons BeanUtils 工具类，用于对象属性复制
import org.apache.commons.beanutils.BeanUtils;
// 导入 MyBatis-Plus 用于指定字段的注解
import com.baomidou.mybatisplus.annotations.TableField;
// 导入 MyBatis-Plus 字段填充策略枚举
import com.baomidou.mybatisplus.enums.FieldFill;
// 导入 MyBatis-Plus 主键生成策略枚举
import com.baomidou.mybatisplus.enums.IdType;
/**
@ -26,240 +39,260 @@ import com.baomidou.mybatisplus.enums.IdType;
* @author
* @email
*/
// 指定该类对应数据库中的 chat 表
@TableName("chat")
// 实现 Serializable 接口，使该类的对象可以进行序列化和反序列化操作
public class ChatEntity<T> implements Serializable {
// 序列化版本号，确保序列化和反序列化的兼容性
private static final long serialVersionUID = 1L;
// 无参构造函数，方便创建 ChatEntity 类的实例
public ChatEntity() {
}
// 带参构造函数，接收一个泛型对象 t，将其属性复制到当前 ChatEntity 对象
public ChatEntity(T t) {
try {
// 使用 BeanUtils 工具类复制属性
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
// 若复制属性过程中出现异常，打印异常堆栈信息
e.printStackTrace();
}
}
/**
* 主键
*/
// 指定该字段为主键，且主键生成策略为自增
@TableId(type = IdType.AUTO)
// 指定该字段对应数据库表中的 id 字段
@TableField(value = "id")
// 主键，用于唯一标识一条在线咨询记录
private Integer id;
/**
* 提问用户
*/
// 指定该字段对应数据库表中的 yonghu_id 字段
@TableField(value = "yonghu_id")
// 提问用户的 ID，关联用户表
private Integer yonghuId;
/**
* 问题
*/
// 指定该字段对应数据库表中的 chat_issue 字段
@TableField(value = "chat_issue")
// 用户提出的问题内容
private String chatIssue;
/**
* 问题时间
*/
// 设置 JSON 序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss"
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
// 用于 Spring MVC 接收表单数据时将日期字符串转换为 Date 对象
@DateTimeFormat
// 指定该字段对应数据库表中的 issue_time 字段
@TableField(value = "issue_time")
// 用户提出问题的时间
private Date issueTime;
/**
* 回复
*/
// 指定该字段对应数据库表中的 chat_reply 字段
@TableField(value = "chat_reply")
// 针对用户问题的回复内容
private String chatReply;
/**
* 回复时间
*/
// 设置 JSON 序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss"
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
// 用于 Spring MVC 接收表单数据时将日期字符串转换为 Date 对象
@DateTimeFormat
// 指定该字段对应数据库表中的 reply_time 字段
@TableField(value = "reply_time")
// 回复用户问题的时间
private Date replyTime;
/**
* 状态
*/
// 指定该字段对应数据库表中的 zhuangtai_types 字段
@TableField(value = "zhuangtai_types")
// 在线咨询的状态，可能用整数表示不同状态，如 0 表示待回复，1 表示已回复等
private Integer zhuangtaiTypes;
/**
* 数据类型
*/
// 指定该字段对应数据库表中的 chat_types 字段
@TableField(value = "chat_types")
// 在线咨询的数据类型，可能用整数表示不同类型，如 1 表示文字咨询，2 表示图片咨询等
private Integer chatTypes;
/**
* 创建时间
*/
// 设置 JSON 序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss"
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
// 用于 Spring MVC 接收表单数据时将日期字符串转换为 Date 对象
@DateTimeFormat
// 指定该字段对应数据库表中的 insert_time 字段，且在插入数据时自动填充
@TableField(value = "insert_time", fill = FieldFill.INSERT)
// 该条在线咨询记录的创建时间
private Date insertTime;
/**
* 设置：主键
*/
// 获取主键的方法
public Integer getId() {
return id;
}
/**
* 获取：主键
*/
// 设置主键的方法
public void setId(Integer id) {
this.id = id;
}
/**
* 设置：提问用户
*/
// 获取提问用户 ID 的方法
public Integer getYonghuId() {
return yonghuId;
}
/**
* 获取：提问用户
*/
// 设置提问用户 ID 的方法
public void setYonghuId(Integer yonghuId) {
this.yonghuId = yonghuId;
}
/**
* 设置：问题
*/
// 获取问题内容的方法
public String getChatIssue() {
return chatIssue;
}
/**
* 获取：问题
*/
// 设置问题内容的方法
public void setChatIssue(String chatIssue) {
this.chatIssue = chatIssue;
}
/**
* 设置：问题时间
*/
// 获取问题时间的方法
public Date getIssueTime() {
return issueTime;
}
/**
* 获取：问题时间
*/
// 设置问题时间的方法
public void setIssueTime(Date issueTime) {
this.issueTime = issueTime;
}
/**
* 设置：回复
*/
// 获取回复内容的方法
public String getChatReply() {
return chatReply;
}
/**
* 获取：回复
*/
// 设置回复内容的方法
public void setChatReply(String chatReply) {
this.chatReply = chatReply;
}
/**
* 设置：回复时间
*/
// 获取回复时间的方法
public Date getReplyTime() {
return replyTime;
}
/**
* 获取：回复时间
*/
// 设置回复时间的方法
public void setReplyTime(Date replyTime) {
this.replyTime = replyTime;
}
/**
* 设置：状态
*/
// 获取状态的方法
public Integer getZhuangtaiTypes() {
return zhuangtaiTypes;
}
/**
* 获取：状态
*/
// 设置状态的方法
public void setZhuangtaiTypes(Integer zhuangtaiTypes) {
this.zhuangtaiTypes = zhuangtaiTypes;
}
/**
* 设置：数据类型
*/
// 获取数据类型的方法
public Integer getChatTypes() {
return chatTypes;
}
/**
* 获取：数据类型
*/
// 设置数据类型的方法
public void setChatTypes(Integer chatTypes) {
this.chatTypes = chatTypes;
}
/**
* 设置：创建时间
*/
// 获取创建时间的方法
public Date getInsertTime() {
return insertTime;
}
/**
* 获取：创建时间
*/
// 设置创建时间的方法
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
// 重写 toString 方法，方便打印对象信息
@Override
public String toString() {
return "Chat{" +

6
src/main/java/com/entity/ConfigEntity.java
Unescape View File

@ -13,13 +13,12 @@ import com.baomidou.mybatisplus.enums.IdType;
*/
@TableName("config")
public class ConfigEntity implements Serializable{
private static final long serialVersionUID = 1L;
// 定义主键字段
@TableId(type = IdType.AUTO)
private Long id;
/**
* key
* name
*/
private String name;
@ -51,5 +50,4 @@ private static final long serialVersionUID = 1L;
public void setValue(String value) {
this.value = value;
}
}

103
src/main/java/com/entity/DictionaryEntity.java
Unescape View File

@ -1,23 +1,34 @@
package com.entity;
// 导入 MyBatis-Plus 用于指定主键的注解
import com.baomidou.mybatisplus.annotations.TableId;
// 导入 MyBatis-Plus 用于指定数据库表名的注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入 JSR 303 验证注解（在当前代码中未实际使用）
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
// 导入 Jackson 注解（在当前代码中未实际使用）
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 导入反射调用可能抛出的异常类
import java.lang.reflect.InvocationTargetException;
// 导入序列化接口
import java.io.Serializable;
// 导入日期类
import java.util.Date;
// 导入列表集合类（在当前代码中未实际使用）
import java.util.List;
// 导入 Spring 框架用于日期格式化的注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入 Jackson 用于 JSON 序列化时日期格式化的注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入 Apache Commons BeanUtils 工具类，用于对象属性复制
import org.apache.commons.beanutils.BeanUtils;
// 导入 MyBatis-Plus 用于指定字段的注解
import com.baomidou.mybatisplus.annotations.TableField;
// 导入 MyBatis-Plus 字段填充策略枚举
import com.baomidou.mybatisplus.enums.FieldFill;
// 导入 MyBatis-Plus 主键生成策略枚举
import com.baomidou.mybatisplus.enums.IdType;
/**
@ -26,213 +37,229 @@ import com.baomidou.mybatisplus.enums.IdType;
* @author
* @email
*/
// 使用 TableName 注解指定该类对应的数据库表名为 "dictionary"
@TableName("dictionary")
// 定义泛型类 DictionaryEntity，实现 Serializable 接口，以便对象可以进行序列化和反序列化
public class DictionaryEntity<T> implements Serializable {
// 定义序列化版本号，用于保证在不同版本的类之间进行序列化和反序列化时的兼容性
private static final long serialVersionUID = 1L;
// 无参构造函数，用于创建 DictionaryEntity 对象
public DictionaryEntity() {
}
// 带参构造函数，接受一个泛型对象 t，通过 BeanUtils.copyProperties 方法
// 将对象 t 的属性复制到当前 DictionaryEntity 对象中
public DictionaryEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
// 如果在复制属性过程中出现异常，打印异常堆栈信息
e.printStackTrace();
}
}
/**
* 主键
*/
// 使用 TableId 注解指定该字段为主键，主键生成策略为自动增长（AUTO）
@TableId(type = IdType.AUTO)
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "id"
@TableField(value = "id")
// 存储字典表记录的主键值，用于唯一标识一条记录
private Integer id;
/**
* 字段
*/
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "dic_code"
@TableField(value = "dic_code")
// 存储字典表中的字段代码，可能用于标识不同的字典项类别等
private String dicCode;
/**
* 字段名
*/
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "dic_name"
@TableField(value = "dic_name")
// 存储字典表中字段的名称，与 dicCode 对应，提供更易读的名称标识
private String dicName;
/**
* 编码
*/
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "code_index"
@TableField(value = "code_index")
// 存储字典表中某一字典项的编码值，可能用于内部编码或排序等用途
private Integer codeIndex;
/**
* 编码名字
*/
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "index_name"
@TableField(value = "index_name")
// 存储编码对应的名称，与 codeIndex 对应，提供更详细的编码描述
private String indexName;
/**
* 父字段id
*/
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "super_id"
@TableField(value = "super_id")
// 存储当前字典项的父字段 ID，用于表示字典项之间的层级关系
private Integer superId;
/**
* 备注
*/
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "beizhu"
@TableField(value = "beizhu")
// 存储关于当前字典项的备注信息，用于记录额外的说明或注意事项
private String beizhu;
/**
* 创建时间
*/
// 设置 JSON 序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss"
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
// 用于 Spring MVC 接收表单数据时将日期字符串转换为 Date 对象
@DateTimeFormat
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "create_time"，
// 并设置在插入数据时自动填充当前时间
@TableField(value = "create_time", fill = FieldFill.INSERT)
// 存储字典表记录的创建时间，用于记录数据的创建时间戳
private Date createTime;
/**
* 设置：主键
*/
// 获取主键值的方法，外部可以通过调用该方法获取 id 字段的值
public Integer getId() {
return id;
}
/**
* 获取：主键
*/
// 设置主键值的方法，外部可以通过调用该方法设置 id 字段的值
public void setId(Integer id) {
this.id = id;
}
/**
* 设置：字段
*/
// 获取字段代码值的方法，外部可以通过调用该方法获取 dicCode 字段的值
public String getDicCode() {
return dicCode;
}
/**
* 获取：字段
*/
// 设置字段代码值的方法，外部可以通过调用该方法设置 dicCode 字段的值
public void setDicCode(String dicCode) {
this.dicCode = dicCode;
}
/**
* 设置：字段名
*/
// 获取字段名称值的方法，外部可以通过调用该方法获取 dicName 字段的值
public String getDicName() {
return dicName;
}
/**
* 获取：字段名
*/
// 设置字段名称值的方法，外部可以通过调用该方法设置 dicName 字段的值
public void setDicName(String dicName) {
this.dicName = dicName;
}
/**
* 设置：编码
*/
// 获取编码值的方法，外部可以通过调用该方法获取 codeIndex 字段的值
public Integer getCodeIndex() {
return codeIndex;
}
/**
* 获取：编码
*/
// 设置编码值的方法，外部可以通过调用该方法设置 codeIndex 字段的值
public void setCodeIndex(Integer codeIndex) {
this.codeIndex = codeIndex;
}
/**
* 设置：编码名字
*/
// 获取编码名称值的方法，外部可以通过调用该方法获取 indexName 字段的值
public String getIndexName() {
return indexName;
}
/**
* 获取：编码名字
*/
// 设置编码名称值的方法，外部可以通过调用该方法设置 indexName 字段的值
public void setIndexName(String indexName) {
this.indexName = indexName;
}
/**
* 设置：父字段id
*/
// 获取父字段 ID 值的方法，外部可以通过调用该方法获取 superId 字段的值
public Integer getSuperId() {
return superId;
}
/**
* 获取：父字段id
*/
// 设置父字段 ID 值的方法，外部可以通过调用该方法设置 superId 字段的值
public void setSuperId(Integer superId) {
this.superId = superId;
}
/**
* 设置：备注
*/
// 获取备注信息值的方法，外部可以通过调用该方法获取 beizhu 字段的值
public String getBeizhu() {
return beizhu;
}
/**
* 获取：备注
*/
// 设置备注信息值的方法，外部可以通过调用该方法设置 beizhu 字段的值
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
/**
* 设置：创建时间
*/
// 获取创建时间值的方法，外部可以通过调用该方法获取 createTime 字段的值
public Date getCreateTime() {
return createTime;
}
/**
* 获取：创建时间
*/
// 设置创建时间值的方法，外部可以通过调用该方法设置 createTime 字段的值
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
// 重写 toString 方法，返回对象的字符串表示，方便调试和日志记录
@Override
public String toString() {
return "Dictionary{" +

18
src/main/java/com/entity/EIException.java
Unescape View File

@ -1,52 +1,64 @@
package com.entity;
/**
* 自定义异常
*/
// 定义一个名为EIException的类，它继承自RuntimeException，表明这是一个运行时异常类
public class EIException extends RuntimeException {
// 定义序列化版本号，用于在序列化和反序列化过程中确保兼容性
private static final long serialVersionUID = 1L;
// 用于存储异常的详细信息，描述异常发生的情况
private String msg;
// 用于存储异常的状态码，默认值为500，通常表示服务器内部错误
private int code = 500;
// 构造函数，接受一个字符串参数msg，将其设置为异常信息，并调用父类的构造函数传递异常信息
public EIException(String msg) {
super(msg);
this.msg = msg;
}
// 构造函数，接受一个字符串参数msg和一个Throwable对象e，
// 将msg设置为异常信息，调用父类的构造函数传递异常信息和异常原因
public EIException(String msg, Throwable e) {
super(msg, e);
this.msg = msg;
}
// 构造函数，接受一个字符串参数msg和一个整数参数code，
// 将msg设置为异常信息，code设置为异常状态码，并调用父类的构造函数传递异常信息
public EIException(String msg, int code) {
super(msg);
this.msg = msg;
this.code = code;
}
// 构造函数，接受一个字符串参数msg、一个整数参数code和一个Throwable对象e，
// 将msg设置为异常信息，code设置为异常状态码，调用父类的构造函数传递异常信息和异常原因
public EIException(String msg, int code, Throwable e) {
super(msg, e);
this.msg = msg;
this.code = code;
}
// 获取异常信息的方法，返回存储的异常信息字符串
public String getMsg() {
return msg;
}
// 设置异常信息的方法，将传入的字符串设置为新的异常信息
public void setMsg(String msg) {
this.msg = msg;
}
// 获取异常状态码的方法，返回存储的异常状态码
public int getCode() {
return code;
}
// 设置异常状态码的方法，将传入的整数设置为新的异常状态码
public void setCode(int code) {
this.code = code;
}
}

123
src/main/java/com/entity/GuahaoEntity.java
Unescape View File

@ -1,23 +1,34 @@
package com.entity;
// 导入 MyBatis-Plus 用于指定主键的注解
import com.baomidou.mybatisplus.annotations.TableId;
// 导入 MyBatis-Plus 用于指定数据库表名的注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入 JSR 303 验证注解（在当前代码中未实际使用）
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
// 导入 Jackson 注解（在当前代码中未实际使用）
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 导入反射调用可能抛出的异常类
import java.lang.reflect.InvocationTargetException;
// 导入序列化接口
import java.io.Serializable;
// 导入日期类
import java.util.Date;
// 导入列表集合类（在当前代码中未实际使用）
import java.util.List;
// 导入 Spring 框架用于日期格式化的注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入 Jackson 用于 JSON 序列化时日期格式化的注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入 Apache Commons BeanUtils 工具类，用于对象属性复制
import org.apache.commons.beanutils.BeanUtils;
// 导入 MyBatis-Plus 用于指定字段的注解
import com.baomidou.mybatisplus.annotations.TableField;
// 导入 MyBatis-Plus 字段填充策略枚举
import com.baomidou.mybatisplus.enums.FieldFill;
// 导入 MyBatis-Plus 主键生成策略枚举
import com.baomidou.mybatisplus.enums.IdType;
/**
@ -26,261 +37,281 @@ import com.baomidou.mybatisplus.enums.IdType;
* @author
* @email
*/
// 使用 TableName 注解指定该类对应的数据库表名为 "guahao"
@TableName("guahao")
// 定义泛型类 GuahaoEntity，实现 Serializable 接口，以便对象可以进行序列化和反序列化
public class GuahaoEntity<T> implements Serializable {
// 定义序列化版本号，用于保证在不同版本的类之间进行序列化和反序列化时的兼容性
private static final long serialVersionUID = 1L;
// 无参构造函数，用于创建 GuahaoEntity 对象
public GuahaoEntity() {
}
// 带参构造函数，接受一个泛型对象 t，通过 BeanUtils.copyProperties 方法
// 将对象 t 的属性复制到当前 GuahaoEntity 对象中
public GuahaoEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
// 如果在复制属性过程中出现异常，打印异常堆栈信息
e.printStackTrace();
}
}
/**
* 主键
*/
// 使用 TableId 注解指定该字段为主键，主键生成策略为自动增长（AUTO）
@TableId(type = IdType.AUTO)
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "id"
@TableField(value = "id")
// 存储挂号记录的主键值，用于唯一标识一条挂号记录
private Integer id;
/**
* 医生
*/
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "yisheng_id"
@TableField(value = "yisheng_id")
// 存储挂号对应的医生 ID，关联医生表
private Integer yishengId;
/**
* 用户
*/
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "yonghu_id"
@TableField(value = "yonghu_id")
// 存储挂号的用户 ID，关联用户表
private Integer yonghuId;
/**
* 就诊识别码
*/
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "guahao_uuin_number"
@TableField(value = "guahao_uuin_number")
// 存储就诊的唯一识别码，用于标识具体的就诊记录
private String guahaoUuinNumber;
/**
* 挂号时间
*/
// 设置 JSON 序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd"
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd")
// 用于 Spring MVC 接收表单数据时将日期字符串转换为 Date 对象
@DateTimeFormat
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "guahao_time"
@TableField(value = "guahao_time")
// 存储挂号的具体时间
private Date guahaoTime;
/**
* 时间类型
*/
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "guahao_types"
@TableField(value = "guahao_types")
// 存储挂号的时间类型，可能表示上午、下午、晚上等不同时间段，用整数标识
private Integer guahaoTypes;
/**
* 挂号状态
*/
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "guahao_status_types"
@TableField(value = "guahao_status_types")
// 存储挂号的状态，例如已挂号、已取消、已就诊等，用整数标识不同状态
private Integer guahaoStatusTypes;
/**
* 挂号审核
*/
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "guahao_yesno_types"
@TableField(value = "guahao_yesno_types")
// 存储挂号审核的结果，可能表示通过、不通过等，用整数标识
private Integer guahaoYesnoTypes;
/**
* 审核结果
*/
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "guahao_yesno_text"
@TableField(value = "guahao_yesno_text")
// 存储挂号审核结果的具体文本描述，例如不通过的原因等
private String guahaoYesnoText;
/**
* 创建时间
*/
// 设置 JSON 序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss"
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
// 用于 Spring MVC 接收表单数据时将日期字符串转换为 Date 对象
@DateTimeFormat
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "create_time"，
// 并设置在插入数据时自动填充当前时间
@TableField(value = "create_time", fill = FieldFill.INSERT)
// 存储挂号记录的创建时间，用于记录数据的创建时间戳
private Date createTime;
/**
* 设置：主键
*/
// 获取主键值的方法，外部可以通过调用该方法获取 id 字段的值
public Integer getId() {
return id;
}
/**
* 获取：主键
*/
// 设置主键值的方法，外部可以通过调用该方法设置 id 字段的值
public void setId(Integer id) {
this.id = id;
}
/**
* 设置：医生
*/
// 获取医生 ID 值的方法，外部可以通过调用该方法获取 yishengId 字段的值
public Integer getYishengId() {
return yishengId;
}
/**
* 获取：医生
*/
// 设置医生 ID 值的方法，外部可以通过调用该方法设置 yishengId 字段的值
public void setYishengId(Integer yishengId) {
this.yishengId = yishengId;
}
/**
* 设置：用户
*/
// 获取用户 ID 值的方法，外部可以通过调用该方法获取 yonghuId 字段的值
public Integer getYonghuId() {
return yonghuId;
}
/**
* 获取：用户
*/
// 设置用户 ID 值的方法，外部可以通过调用该方法设置 yonghuId 字段的值
public void setYonghuId(Integer yonghuId) {
this.yonghuId = yonghuId;
}
/**
* 设置：就诊识别码
*/
// 获取就诊识别码值的方法，外部可以通过调用该方法获取 guahaoUuinNumber 字段的值
public String getGuahaoUuinNumber() {
return guahaoUuinNumber;
}
/**
* 获取：就诊识别码
*/
// 设置就诊识别码值的方法，外部可以通过调用该方法设置 guahaoUuinNumber 字段的值
public void setGuahaoUuinNumber(String guahaoUuinNumber) {
this.guahaoUuinNumber = guahaoUuinNumber;
}
/**
* 设置：挂号时间
*/
// 获取挂号时间值的方法，外部可以通过调用该方法获取 guahaoTime 字段的值
public Date getGuahaoTime() {
return guahaoTime;
}
/**
* 获取：挂号时间
*/
// 设置挂号时间值的方法，外部可以通过调用该方法设置 guahaoTime 字段的值
public void setGuahaoTime(Date guahaoTime) {
this.guahaoTime = guahaoTime;
}
/**
* 设置：时间类型
*/
// 获取时间类型值的方法，外部可以通过调用该方法获取 guahaoTypes 字段的值
public Integer getGuahaoTypes() {
return guahaoTypes;
}
/**
* 获取：时间类型
*/
// 设置时间类型值的方法，外部可以通过调用该方法设置 guahaoTypes 字段的值
public void setGuahaoTypes(Integer guahaoTypes) {
this.guahaoTypes = guahaoTypes;
}
/**
* 设置：挂号状态
*/
// 获取挂号状态值的方法，外部可以通过调用该方法获取 guahaoStatusTypes 字段的值
public Integer getGuahaoStatusTypes() {
return guahaoStatusTypes;
}
/**
* 获取：挂号状态
*/
// 设置挂号状态值的方法，外部可以通过调用该方法设置 guahaoStatusTypes 字段的值
public void setGuahaoStatusTypes(Integer guahaoStatusTypes) {
this.guahaoStatusTypes = guahaoStatusTypes;
}
/**
* 设置：挂号审核
*/
// 获取挂号审核值的方法，外部可以通过调用该方法获取 guahaoYesnoTypes 字段的值
public Integer getGuahaoYesnoTypes() {
return guahaoYesnoTypes;
}
/**
* 获取：挂号审核
*/
// 设置挂号审核值的方法，外部可以通过调用该方法设置 guahaoYesnoTypes 字段的值
public void setGuahaoYesnoTypes(Integer guahaoYesnoTypes) {
this.guahaoYesnoTypes = guahaoYesnoTypes;
}
/**
* 设置：审核结果
*/
// 获取审核结果值的方法，外部可以通过调用该方法获取 guahaoYesnoText 字段的值
public String getGuahaoYesnoText() {
return guahaoYesnoText;
}
/**
* 获取：审核结果
*/
// 设置审核结果值的方法，外部可以通过调用该方法设置 guahaoYesnoText 字段的值
public void setGuahaoYesnoText(String guahaoYesnoText) {
this.guahaoYesnoText = guahaoYesnoText;
}
/**
* 设置：创建时间
*/
// 获取创建时间值的方法，外部可以通过调用该方法获取 createTime 字段的值
public Date getCreateTime() {
return createTime;
}
/**
* 获取：创建时间
*/
// 设置创建时间值的方法，外部可以通过调用该方法设置 createTime 字段的值
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
// 重写 toString 方法，返回对象的字符串表示，方便调试和日志记录
@Override
public String toString() {
return "Guahao{" +

104
src/main/java/com/entity/JiankangjiaoyuEntity.java
Unescape View File

@ -1,23 +1,34 @@
package com.entity;
// 导入 MyBatis-Plus 用于指定主键的注解
import com.baomidou.mybatisplus.annotations.TableId;
// 导入 MyBatis-Plus 用于指定数据库表名的注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入 JSR 303 验证注解，可用于字段验证，当前代码未使用这些注解进行实际验证
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
// 导入 Jackson 注解，可用于忽略 JSON 序列化和反序列化时的某些属性，当前代码未使用
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 导入反射调用可能抛出的异常类
import java.lang.reflect.InvocationTargetException;
// 导入序列化接口，使该类的对象可以进行序列化和反序列化操作
import java.io.Serializable;
// 导入日期类
import java.util.Date;
// 导入列表集合类，当前代码未使用
import java.util.List;
// 导入 Spring 框架用于日期格式化的注解，用于将字符串日期转换为 Date 对象
import org.springframework.format.annotation.DateTimeFormat;
// 导入 Jackson 用于 JSON 序列化时日期格式化的注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入 Apache Commons BeanUtils 工具类，用于对象属性复制
import org.apache.commons.beanutils.BeanUtils;
// 导入 MyBatis-Plus 用于指定字段的注解
import com.baomidou.mybatisplus.annotations.TableField;
// 导入 MyBatis-Plus 字段填充策略枚举
import com.baomidou.mybatisplus.enums.FieldFill;
// 导入 MyBatis-Plus 主键生成策略枚举
import com.baomidou.mybatisplus.enums.IdType;
/**
@ -26,215 +37,232 @@ import com.baomidou.mybatisplus.enums.IdType;
* @author
* @email
*/
// 指定该类对应数据库中的 jiankangjiaoyu 表
@TableName("jiankangjiaoyu")
// 定义泛型类，实现 Serializable 接口
public class JiankangjiaoyuEntity<T> implements Serializable {
// 序列化版本号，确保序列化和反序列化的兼容性
private static final long serialVersionUID = 1L;
// 无参构造函数，方便创建 JiankangjiaoyuEntity 类的实例
public JiankangjiaoyuEntity() {
}
// 带参构造函数，接收一个泛型对象 t，将其属性复制到当前 JiankangjiaoyuEntity 对象
public JiankangjiaoyuEntity(T t) {
try {
// 使用 BeanUtils 工具类复制属性
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
// 若复制属性过程中出现异常，打印异常堆栈信息
e.printStackTrace();
}
}
/**
* 主键
*/
// 指定该字段为主键，且主键生成策略为自增
@TableId(type = IdType.AUTO)
// 指定该字段对应数据库表中的 id 字段
@TableField(value = "id")
// 主键，用于唯一标识一条健康教育记录
private Integer id;
/**
* 健康教育标题
*/
// 指定该字段对应数据库表中的 jiankangjiaoyu_name 字段
@TableField(value = "jiankangjiaoyu_name")
// 健康教育的标题
private String jiankangjiaoyuName;
/**
* 健康教育类型
*/
// 指定该字段对应数据库表中的 jiankangjiaoyu_types 字段
@TableField(value = "jiankangjiaoyu_types")
// 健康教育的类型，用整数表示不同类型
private Integer jiankangjiaoyuTypes;
/**
* 健康教育图片
*/
// 指定该字段对应数据库表中的 jiankangjiaoyu_photo 字段
@TableField(value = "jiankangjiaoyu_photo")
// 健康教育相关图片的存储路径
private String jiankangjiaoyuPhoto;
/**
* 健康教育时间
*/
// 设置 JSON 序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss"
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
// 用于 Spring MVC 接收表单数据时将日期字符串转换为 Date 对象
@DateTimeFormat
// 指定该字段对应数据库表中的 insert_time 字段，且在插入数据时自动填充
@TableField(value = "insert_time", fill = FieldFill.INSERT)
// 健康教育的时间
private Date insertTime;
/**
* 健康教育详情
*/
// 指定该字段对应数据库表中的 jiankangjiaoyu_content 字段
@TableField(value = "jiankangjiaoyu_content")
// 健康教育的详细内容
private String jiankangjiaoyuContent;
/**
* 假删
*/
// 指定该字段对应数据库表中的 jiankangjiaoyu_delete 字段
@TableField(value = "jiankangjiaoyu_delete")
// 假删除标记，用整数表示是否删除，如 0 表示未删除，1 表示已删除
private Integer jiankangjiaoyuDelete;
/**
* 创建时间
*/
// 设置 JSON 序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss"
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
// 用于 Spring MVC 接收表单数据时将日期字符串转换为 Date 对象
@DateTimeFormat
// 指定该字段对应数据库表中的 create_time 字段，且在插入数据时自动填充
@TableField(value = "create_time", fill = FieldFill.INSERT)
// 该条健康教育记录的创建时间
private Date createTime;
/**
* 设置：主键
*/
// 获取主键的方法
public Integer getId() {
return id;
}
/**
* 获取：主键
*/
// 设置主键的方法
public void setId(Integer id) {
this.id = id;
}
/**
* 设置：健康教育标题
*/
// 获取健康教育标题的方法
public String getJiankangjiaoyuName() {
return jiankangjiaoyuName;
}
/**
* 获取：健康教育标题
*/
// 设置健康教育标题的方法
public void setJiankangjiaoyuName(String jiankangjiaoyuName) {
this.jiankangjiaoyuName = jiankangjiaoyuName;
}
/**
* 设置：健康教育类型
*/
// 获取健康教育类型的方法
public Integer getJiankangjiaoyuTypes() {
return jiankangjiaoyuTypes;
}
/**
* 获取：健康教育类型
*/
// 设置健康教育类型的方法
public void setJiankangjiaoyuTypes(Integer jiankangjiaoyuTypes) {
this.jiankangjiaoyuTypes = jiankangjiaoyuTypes;
}
/**
* 设置：健康教育图片
*/
// 获取健康教育图片路径的方法
public String getJiankangjiaoyuPhoto() {
return jiankangjiaoyuPhoto;
}
/**
* 获取：健康教育图片
*/
// 设置健康教育图片路径的方法
public void setJiankangjiaoyuPhoto(String jiankangjiaoyuPhoto) {
this.jiankangjiaoyuPhoto = jiankangjiaoyuPhoto;
}
/**
* 设置：健康教育时间
*/
// 获取健康教育时间的方法
public Date getInsertTime() {
return insertTime;
}
/**
* 获取：健康教育时间
*/
// 设置健康教育时间的方法
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
/**
* 设置：健康教育详情
*/
// 获取健康教育详情的方法
public String getJiankangjiaoyuContent() {
return jiankangjiaoyuContent;
}
/**
* 获取：健康教育详情
*/
// 设置健康教育详情的方法
public void setJiankangjiaoyuContent(String jiankangjiaoyuContent) {
this.jiankangjiaoyuContent = jiankangjiaoyuContent;
}
/**
* 设置：假删
*/
// 获取假删除标记的方法
public Integer getJiankangjiaoyuDelete() {
return jiankangjiaoyuDelete;
}
/**
* 获取：假删
*/
// 设置假删除标记的方法
public void setJiankangjiaoyuDelete(Integer jiankangjiaoyuDelete) {
this.jiankangjiaoyuDelete = jiankangjiaoyuDelete;
}
/**
* 设置：创建时间
*/
// 获取创建时间的方法
public Date getCreateTime() {
return createTime;
}
/**
* 获取：创建时间
*/
// 设置创建时间的方法
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
// 重写 toString 方法，方便打印对象信息
@Override
public String toString() {
return "Jiankangjiaoyu{" +

97
src/main/java/com/entity/NewsEntity.java
Unescape View File

@ -1,23 +1,34 @@
package com.entity;
// 导入 MyBatis-Plus 用于指定主键的注解
import com.baomidou.mybatisplus.annotations.TableId;
// 导入 MyBatis-Plus 用于指定数据库表名的注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入 JSR 303 验证注解（当前未实际使用）
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
// 导入 Jackson 用于忽略属性的注解（当前未实际使用）
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 导入反射调用可能抛出的异常类
import java.lang.reflect.InvocationTargetException;
// 导入序列化接口
import java.io.Serializable;
// 导入日期类
import java.util.Date;
// 导入列表类（当前未实际使用）
import java.util.List;
// 导入 Spring 用于日期格式化的注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入 Jackson 用于 JSON 序列化时日期格式化的注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入 Apache Commons BeanUtils 工具类，用于对象属性复制
import org.apache.commons.beanutils.BeanUtils;
// 导入 MyBatis-Plus 用于指定字段的注解
import com.baomidou.mybatisplus.annotations.TableField;
// 导入 MyBatis-Plus 字段填充策略枚举
import com.baomidou.mybatisplus.enums.FieldFill;
// 导入 MyBatis-Plus 主键生成策略枚举
import com.baomidou.mybatisplus.enums.IdType;
/**
@ -26,192 +37,210 @@ import com.baomidou.mybatisplus.enums.IdType;
* @author
* @email
*/
// 使用 TableName 注解指定该类对应的数据库表名为 "news"
@TableName("news")
// 定义泛型类 NewsEntity，实现 Serializable 接口，用于对象的序列化和反序列化
public class NewsEntity<T> implements Serializable {
// 定义序列化版本号，保证序列化和反序列化的兼容性
private static final long serialVersionUID = 1L;
// 无参构造函数，用于创建 NewsEntity 对象
public NewsEntity() {
}
// 带参构造函数，接受一个泛型对象 t，通过 BeanUtils.copyProperties 方法
// 将对象 t 的属性复制到当前 NewsEntity 对象中
public NewsEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
// 如果在复制属性过程中出现异常，打印异常堆栈信息
e.printStackTrace();
}
}
/**
* 主键
*/
// 使用 TableId 注解指定该字段为主键，主键生成策略为自动增长（IdType.AUTO）
@TableId(type = IdType.AUTO)
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "id"
@TableField(value = "id")
// 存储公告信息记录的主键值，用于唯一标识一条公告记录
private Integer id;
/**
* 公告名称
*/
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "news_name"
@TableField(value = "news_name")
// 存储公告的名称
private String newsName;
/**
* 公告图片
*/
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "news_photo"
@TableField(value = "news_photo")
// 存储公告相关图片的路径或标识
private String newsPhoto;
/**
* 公告类型
*/
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "news_types"
@TableField(value = "news_types")
// 存储公告的类型，用整数表示不同的公告类型，如通知、公告等
private Integer newsTypes;
/**
* 公告发布时间
*/
// 设置 JSON 序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss"
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
// 用于 Spring MVC 接收表单数据时将日期字符串转换为 Date 对象
@DateTimeFormat
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "insert_time"，
// 并设置在插入数据时自动填充当前时间
@TableField(value = "insert_time", fill = FieldFill.INSERT)
// 存储公告的发布时间
private Date insertTime;
/**
* 公告详情
*/
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "news_content"
@TableField(value = "news_content")
// 存储公告的详细内容
private String newsContent;
/**
* 创建时间
*/
// 设置 JSON 序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss"
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
// 用于 Spring MVC 接收表单数据时将日期字符串转换为 Date 对象
@DateTimeFormat
// 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "create_time"，
// 并设置在插入数据时自动填充当前时间
@TableField(value = "create_time", fill = FieldFill.INSERT)
// 存储公告记录的创建时间，用于记录数据的创建时间戳
private Date createTime;
/**
* 设置：主键
*/
// 获取主键值的方法
public Integer getId() {
return id;
}
/**
* 获取：主键
*/
// 设置主键值的方法
public void setId(Integer id) {
this.id = id;
}
/**
* 设置：公告名称
*/
// 获取公告名称值的方法
public String getNewsName() {
return newsName;
}
/**
* 获取：公告名称
*/
// 设置公告名称值的方法
public void setNewsName(String newsName) {
this.newsName = newsName;
}
/**
* 设置：公告图片
*/
// 获取公告图片路径值的方法
public String getNewsPhoto() {
return newsPhoto;
}
/**
* 获取：公告图片
*/
// 设置公告图片路径值的方法
public void setNewsPhoto(String newsPhoto) {
this.newsPhoto = newsPhoto;
}
/**
* 设置：公告类型
*/
// 获取公告类型值的方法
public Integer getNewsTypes() {
return newsTypes;
}
/**
* 获取：公告类型
*/
// 设置公告类型值的方法
public void setNewsTypes(Integer newsTypes) {
this.newsTypes = newsTypes;
}
/**
* 设置：公告发布时间
*/
// 获取公告发布时间值的方法
public Date getInsertTime() {
return insertTime;
}
/**
* 获取：公告发布时间
*/
// 设置公告发布时间值的方法
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
/**
* 设置：公告详情
*/
// 获取公告详情值的方法
public String getNewsContent() {
return newsContent;
}
/**
* 获取：公告详情
*/
// 设置公告详情值的方法
public void setNewsContent(String newsContent) {
this.newsContent = newsContent;
}
/**
* 设置：创建时间
*/
// 获取创建时间值的方法
public Date getCreateTime() {
return createTime;
}
/**
* 获取：创建时间
*/
// 设置创建时间值的方法
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
// 重写 toString 方法，返回对象的字符串表示，方便调试和日志记录
@Override
public String toString() {
return "News{" +

36
src/main/java/com/entity/TokenEntity.java
Unescape View File

@ -1,121 +1,155 @@
package com.entity;
// 导入序列化接口，使该类的对象可以进行序列化和反序列化
import java.io.Serializable;
// 导入日期类，用于处理日期相关的操作
import java.util.Date;
// 导入 MyBatis-Plus 用于指定主键的注解
import com.baomidou.mybatisplus.annotations.TableId;
// 导入 MyBatis-Plus 用于指定数据库表名的注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入 MyBatis-Plus 主键生成策略枚举
import com.baomidou.mybatisplus.enums.IdType;
/**
* token表
*/
// 使用 TableName 注解指定该类对应的数据库表名为 "token"
@TableName("token")
//定义 TokenEntity 类，实现 Serializable 接口，以支持对象的序列化和反序列化
public class TokenEntity implements Serializable {
// 定义序列化版本号，用于保证在不同版本的类之间进行序列化和反序列化时的兼容性
private static final long serialVersionUID = 1L;
// 使用 TableId 注解指定该字段为主键，主键生成策略为自动增长（AUTO）
@TableId(type = IdType.AUTO)
// 存储记录的主键值，用于唯一标识一条 token 记录
private Integer id;
/**
* 用户id
*/
// 存储与该 token 相关联的用户 ID
private Integer userid;
/**
* 用户名
*/
// 存储与该 token 相关联的用户名
private String username;
/**
* 表名
*/
// 存储与该 token 相关的表名（具体用途可能根据业务需求而定）
private String tablename;
/**
* 角色
*/
// 存储用户的角色信息，用于权限控制等
private String role;
/**
* token
*/
// 存储具体的 token 值，用于身份验证和授权
private String token;
/**
* 过期时间
*/
// 存储该 token 的过期时间，用于判断 token 是否有效
private Date expiratedtime;
/**
* 新增时间
*/
// 存储该 token 记录的创建时间，用于记录数据的生成时间戳
private Date addtime;
// 获取主键值的方法
public Integer getId() {
return id;
}
// 设置主键值的方法
public void setId(Integer id) {
this.id = id;
}
// 获取用户 ID 的方法
public Integer getUserid() {
return userid;
}
// 设置用户 ID 的方法
public void setUserid(Integer userid) {
this.userid = userid;
}
// 获取角色信息的方法
public String getRole() {
return role;
}
// 设置角色信息的方法
public void setRole(String role) {
this.role = role;
}
// 获取 token 值的方法
public String getToken() {
return token;
}
// 获取表名的方法
public String getTablename() {
return tablename;
}
// 设置表名的方法
public void setTablename(String tablename) {
this.tablename = tablename;
}
// 设置 token 值的方法
public void setToken(String token) {
this.token = token;
}
// 获取过期时间的方法
public Date getExpiratedtime() {
return expiratedtime;
}
// 设置过期时间的方法
public void setExpiratedtime(Date expiratedtime) {
this.expiratedtime = expiratedtime;
}
// 获取新增时间的方法
public Date getAddtime() {
return addtime;
}
// 设置新增时间的方法
public void setAddtime(Date addtime) {
this.addtime = addtime;
}
// 获取用户名的方法
public String getUsername() {
return username;
}
// 设置用户名的方法
public void setUsername(String username) {
this.username = username;
}
// 带参数的构造函数，用于初始化 TokenEntity 对象的部分属性
public TokenEntity(Integer userid, String username, String tablename, String role, String token, Date expiratedtime) {
super();
this.userid = userid;
@ -126,7 +160,7 @@ public class TokenEntity implements Serializable {
this.expiratedtime = expiratedtime;
}
// 无参构造函数，用于创建 TokenEntity 对象的实例
public TokenEntity() {
}
}

25
src/main/java/com/entity/UsersEntity.java
Unescape View File

@ -1,77 +1,100 @@
package com.entity;
// 导入序列化接口，使该类的对象可以进行序列化和反序列化操作
import java.io.Serializable;
// 导入日期类，用于处理与日期相关的操作
import java.util.Date;
// 导入 MyBatis-Plus 用于指定主键的注解
import com.baomidou.mybatisplus.annotations.TableId;
// 导入 MyBatis-Plus 用于指定数据库表名的注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入 MyBatis-Plus 主键生成策略枚举
import com.baomidou.mybatisplus.enums.IdType;
/**
* 用户
*/
// 使用 TableName 注解指定该类对应的数据库表名为 "users"
@TableName("users")
// 定义 UsersEntity 类，实现 Serializable 接口，以支持对象的序列化和反序列化
public class UsersEntity implements Serializable {
// 定义序列化版本号，用于保证在不同版本的类之间进行序列化和反序列化时的兼容性
private static final long serialVersionUID = 1L;
// 使用 TableId 注解指定该字段为主键，主键生成策略为自动增长（AUTO）
@TableId(type = IdType.AUTO)
// 存储用户记录的主键值，用于唯一标识一条用户记录
private Integer id;
/**
* 用户账号
*/
// 存储用户的账号信息，用于登录等操作
private String username;
/**
* 密码
*/
// 存储用户的密码信息，用于验证用户身份
private String password;
/**
* 用户类型
*/
// 存储用户的类型信息，例如普通用户、管理员等，用于权限控制等
private String role;
// 存储用户记录的创建时间，用于记录数据的生成时间戳
private Date addtime;
// 获取用户账号的方法
public String getUsername() {
return username;
}
// 设置用户账号的方法
public void setUsername(String username) {
this.username = username;
}
// 获取用户密码的方法
public String getPassword() {
return password;
}
// 设置用户密码的方法
public void setPassword(String password) {
this.password = password;
}
// 获取用户类型的方法
public String getRole() {
return role;
}
// 设置用户类型的方法
public void setRole(String role) {
this.role = role;
}
// 获取用户记录创建时间的方法
public Date getAddtime() {
return addtime;
}
// 设置用户记录创建时间的方法
public void setAddtime(Date addtime) {
this.addtime = addtime;
}
// 获取用户记录主键的方法
public Integer getId() {
return id;
}
// 设置用户记录主键的方法
public void setId(Integer id) {
this.id = id;
}
}

248
src/main/java/com/entity/YishengEntity.java
Unescape View File

@ -1,445 +1,393 @@
package com.entity;
// 导入 MyBatis-Plus 用于指定主键的注解
import com.baomidou.mybatisplus.annotations.TableId;
// 导入 MyBatis-Plus 用于指定数据库表名的注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入 JSR 303 验证注解（在当前代码中未实际使用）
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
// 导入 Jackson 注解（在当前代码中未实际使用）
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 导入反射调用可能抛出的异常类
import java.lang.reflect.InvocationTargetException;
// 导入序列化接口
import java.io.Serializable;
// 导入日期类
import java.util.Date;
// 导入列表集合类（在当前代码中未实际使用）
import java.util.List;
// 导入 Spring 框架用于日期格式化的注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入 Jackson 用于 JSON 序列化时日期格式化的注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入 Apache Commons BeanUtils 工具类，用于对象属性复制
import org.apache.commons.beanutils.BeanUtils;
// 导入 MyBatis-Plus 用于指定字段的注解
import com.baomidou.mybatisplus.annotations.TableField;
// 导入 MyBatis-Plus 字段填充策略枚举
import com.baomidou.mybatisplus.enums.FieldFill;
// 导入 MyBatis-Plus 主键生成策略枚举
import com.baomidou.mybatisplus.enums.IdType;
/**
* 医生实体类，用于映射数据库中的医生信息表
* 实现了 Serializable 接口，方便对象的序列化和反序列化
* 医生
*
* @author 此处应填写作者姓名
* @email 此处应填写作者邮箱
* @author
* @email
*/
@TableName("yisheng") // 表明该实体类对应数据库中的表名为 "yisheng"
@TableName("yisheng")
public class YishengEntity<T> implements Serializable {
// 序列化版本号，用于保证序列化和反序列化过程中对象版本的一致性
private static final long serialVersionUID = 1L;
/**
* 无参构造函数
* 用于创建一个空的 YishengEntity 对象
*/
public YishengEntity() {
}
/**
* 带参构造函数
* 接收一个泛型对象 t，将其属性复制到当前 YishengEntity 对象中
*
* @param t 泛型对象，其属性将被复制到当前对象
*/
public YishengEntity(T t) {
try {
// 使用 BeanUtils 工具类将对象 t 的属性复制到当前对象
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// 若复制属性过程中出现异常，打印异常堆栈信息
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 主键
* 数据库表中的唯一标识字段
*/
@TableId(type = IdType.AUTO) // 表示该字段为主键，且采用自增方式生成
@TableField(value = "id") // 表明该属性对应数据库表中的字段名为 "id"
@TableId(type = IdType.AUTO)
@TableField(value = "id")
private Integer id;
/**
* 医生工号
* 用于唯一标识医生的编号
*/
@TableField(value = "yisheng_uuid_number") // 表明该属性对应数据库表中的字段名为 "yisheng_uuid_number"
@TableField(value = "yisheng_uuid_number")
private String yishengUuidNumber;
/**
* 账户
* 医生登录系统使用的账户名
*/
@TableField(value = "username") // 表明该属性对应数据库表中的字段名为 "username"
@TableField(value = "username")
private String username;
/**
* 密码
* 医生登录系统使用的密码
*/
@TableField(value = "password") // 表明该属性对应数据库表中的字段名为 "password"
@TableField(value = "password")
private String password;
/**
* 医生名称
* 医生的真实姓名
*/
@TableField(value = "yisheng_name") // 表明该属性对应数据库表中的字段名为 "yisheng_name"
@TableField(value = "yisheng_name")
private String yishengName;
/**
* 科室
* 医生所属的科室，用整数表示科室编号
*/
@TableField(value = "yisheng_types") // 表明该属性对应数据库表中的字段名为 "yisheng_types"
@TableField(value = "yisheng_types")
private Integer yishengTypes;
/**
* 职位
* 医生的职位，用整数表示职位编号
*/
@TableField(value = "zhiwei_types") // 表明该属性对应数据库表中的字段名为 "zhiwei_types"
@TableField(value = "zhiwei_types")
private Integer zhiweiTypes;
/**
* 职称
* 医生的职称信息
*/
@TableField(value = "yisheng_zhichneg") // 表明该属性对应数据库表中的字段名为 "yisheng_zhichneg"
@TableField(value = "yisheng_zhichneg")
private String yishengZhichneg;
/**
* 医生头像
* 医生头像的存储路径或链接
*/
@TableField(value = "yisheng_photo") // 表明该属性对应数据库表中的字段名为 "yisheng_photo"
@TableField(value = "yisheng_photo")
private String yishengPhoto;
/**
* 联系方式
* 医生的联系电话号码
*/
@TableField(value = "yisheng_phone") // 表明该属性对应数据库表中的字段名为 "yisheng_phone"
@TableField(value = "yisheng_phone")
private String yishengPhone;
/**
* 挂号须知
* 关于该医生挂号的相关注意事项
*/
@TableField(value = "yisheng_guahao") // 表明该属性对应数据库表中的字段名为 "yisheng_guahao"
@TableField(value = "yisheng_guahao")
private String yishengGuahao;
/**
* 邮箱
* 医生的电子邮箱地址
*/
@TableField(value = "yisheng_email") // 表明该属性对应数据库表中的字段名为 "yisheng_email"
@TableField(value = "yisheng_email")
private String yishengEmail;
/**
* 挂号价格
* 患者挂该医生号所需支付的费用
*/
@TableField(value = "yisheng_new_money") // 表明该属性对应数据库表中的字段名为 "yisheng_new_money"
@TableField(value = "yisheng_new_money")
private Double yishengNewMoney;
/**
* 履历介绍
* 医生的工作履历、专业技能等相关介绍信息
*/
@TableField(value = "yisheng_content") // 表明该属性对应数据库表中的字段名为 "yisheng_content"
@TableField(value = "yisheng_content")
private String yishengContent;
/**
* 创建时间
* 该医生信息在数据库中创建的时间
*/
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") // 用于将日期格式化为指定格式，方便前端展示
@DateTimeFormat // 用于将前端传递的日期字符串解析为 Date 类型
@TableField(value = "create_time",fill = FieldFill.INSERT) // 表明该属性对应数据库表中的字段名为 "create_time"，且在插入数据时自动填充
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "create_time",fill = FieldFill.INSERT)
private Date createTime;
/**
* 获取主键
*
* @return 主键的值
* 设置：主键
*/
public Integer getId() {
return id;
}
/**
* 设置主键
*
* @param id 要设置的主键值
* 获取：主键
*/
public void setId(Integer id) {
this.id = id;
}
/**
* 获取医生工号
*
* @return 医生工号的值
* 设置：医生工号
*/
public String getYishengUuidNumber() {
return yishengUuidNumber;
}
/**
* 设置医生工号
*
* @param yishengUuidNumber 要设置的医生工号值
* 获取：医生工号
*/
public void setYishengUuidNumber(String yishengUuidNumber) {
this.yishengUuidNumber = yishengUuidNumber;
}
/**
* 获取账户
*
* @return 账户的值
* 设置：账户
*/
public String getUsername() {
return username;
}
/**
* 设置账户
*
* @param username 要设置的账户值
* 获取：账户
*/
public void setUsername(String username) {
this.username = username;
}
/**
* 获取密码
*
* @return 密码的值
* 设置：密码
*/
public String getPassword() {
return password;
}
/**
* 设置密码
*
* @param password 要设置的密码值
* 获取：密码
*/
public void setPassword(String password) {
this.password = password;
}
/**
* 获取医生名称
*
* @return 医生名称的值
* 设置：医生名称
*/
public String getYishengName() {
return yishengName;
}
/**
* 设置医生名称
*
* @param yishengName 要设置的医生名称值
* 获取：医生名称
*/
public void setYishengName(String yishengName) {
this.yishengName = yishengName;
}
/**
* 获取科室
*
* @return 科室的值
* 设置：科室
*/
public Integer getYishengTypes() {
return yishengTypes;
}
/**
* 设置科室
*
* @param yishengTypes 要设置的科室值
* 获取：科室
*/
public void setYishengTypes(Integer yishengTypes) {
this.yishengTypes = yishengTypes;
}
/**
* 获取职位
*
* @return 职位的值
* 设置：职位
*/
public Integer getZhiweiTypes() {
return zhiweiTypes;
}
/**
* 设置职位
*
* @param zhiweiTypes 要设置的职位值
* 获取：职位
*/
public void setZhiweiTypes(Integer zhiweiTypes) {
this.zhiweiTypes = zhiweiTypes;
}
/**
* 获取职称
*
* @return 职称的值
* 设置：职称
*/
public String getYishengZhichneg() {
return yishengZhichneg;
}
/**
* 设置职称
*
* @param yishengZhichneg 要设置的职称值
* 获取：职称
*/
public void setYishengZhichneg(String yishengZhichneg) {
this.yishengZhichneg = yishengZhichneg;
}
/**
* 获取医生头像
*
* @return 医生头像的值
* 设置：医生头像
*/
public String getYishengPhoto() {
return yishengPhoto;
}
/**
* 设置医生头像
*
* @param yishengPhoto 要设置的医生头像值
* 获取：医生头像
*/
public void setYishengPhoto(String yishengPhoto) {
this.yishengPhoto = yishengPhoto;
}
/**
* 获取联系方式
*
* @return 联系方式的值
* 设置：联系方式
*/
public String getYishengPhone() {
return yishengPhone;
}
/**
* 设置联系方式
*
* @param yishengPhone 要设置的联系方式值
* 获取：联系方式
*/
public void setYishengPhone(String yishengPhone) {
this.yishengPhone = yishengPhone;
}
/**
* 获取挂号须知
*
* @return 挂号须知的值
* 设置：挂号须知
*/
public String getYishengGuahao() {
return yishengGuahao;
}
/**
* 设置挂号须知
*
* @param yishengGuahao 要设置的挂号须知值
* 获取：挂号须知
*/
public void setYishengGuahao(String yishengGuahao) {
this.yishengGuahao = yishengGuahao;
}
/**
* 获取邮箱
*
* @return 邮箱的值
* 设置：邮箱
*/
public String getYishengEmail() {
return yishengEmail;
}
/**
* 设置邮箱
*
* @param yishengEmail 要设置的邮箱值
* 获取：邮箱
*/
public void setYishengEmail(String yishengEmail) {
this.yishengEmail = yishengEmail;
}
/**
* 获取挂号价格
*
* @return 挂号价格的值
* 设置：挂号价格
*/
public Double getYishengNewMoney() {
return yishengNewMoney;
}
/**
* 设置挂号价格
*
* @param yishengNewMoney 要设置的挂号价格值
* 获取：挂号价格
*/
public void setYishengNewMoney(Double yishengNewMoney) {
this.yishengNewMoney = yishengNewMoney;
}
/**
* 获取履历介绍
*
* @return 履历介绍的值
* 设置：履历介绍
*/
public String getYishengContent() {
return yishengContent;
}
/**
* 设置履历介绍
*
* @param yishengContent 要设置的履历介绍值
* 获取：履历介绍
*/
public void setYishengContent(String yishengContent) {
this.yishengContent = yishengContent;
}
/**
* 获取创建时间
*
* @return 创建时间的值
* 设置：创建时间
*/
public Date getCreateTime() {
return createTime;
}
/**
* 设置创建时间
*
* @param createTime 要设置的创建时间值
* 获取：创建时间
*/
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
/**
* 重写 toString 方法
* 用于将对象的属性以字符串形式输出，方便调试和日志记录
*
* @return 包含对象属性信息的字符串
*/
@Override
public String toString() {
return "Yisheng{" +

148
src/main/java/com/entity/YonghuEntity.java
Unescape View File

@ -27,27 +27,20 @@ import com.baomidou.mybatisplus.enums.IdType;
* @author
* @email
*/
@TableName("yonghu") // 指定对应的数据库表名
@TableName("yonghu")
public class YonghuEntity<T> implements Serializable {
private static final long serialVersionUID = 1L; // 序列化版本UID
private static final long serialVersionUID = 1L;
/**
* 无参构造函数
*/
public YonghuEntity() {
}
/**
* 带参构造函数
* 通过BeanUtils将传入对象的属性拷贝到当前对象
* @param t 源对象
*/
public YonghuEntity(T t) {
try {
BeanUtils.copyProperties(this, t); // 使用BeanUtils进行属性拷贝
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// 打印异常堆栈
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@ -56,282 +49,277 @@ public class YonghuEntity<T> implements Serializable {
* 主键ID
* 自增类型
*/
@TableId(type = IdType.AUTO) // 主键自增
@TableField(value = "id") // 对应数据库字段名
@TableId(type = IdType.AUTO)
@TableField(value = "id")
private Integer id;
/**
* 用户名/账户
* 用于登录系统的唯一标识
*/
@TableField(value = "username") // 对应数据库字段名
@TableField(value = "username")
private String username;
/**
* 密码
* 存储加密后的用户密码
*/
@TableField(value = "password") // 对应数据库字段名
@TableField(value = "password")
private String password;
/**
* 用户真实姓名
*/
@TableField(value = "yonghu_name") // 对应数据库字段名
@TableField(value = "yonghu_name")
private String yonghuName;
/**
* 用户头像
* 存储头像图片路径
*/
@TableField(value = "yonghu_photo") // 对应数据库字段名
@TableField(value = "yonghu_photo")
private String yonghuPhoto;
/**
* 用户手机号
*/
@TableField(value = "yonghu_phone") // 对应数据库字段名
@TableField(value = "yonghu_phone")
private String yonghuPhone;
/**
* 用户身份证号
*/
@TableField(value = "yonghu_id_number") // 对应数据库字段名
@TableField(value = "yonghu_id_number")
private String yonghuIdNumber;
/**
* 用户邮箱
*/
@TableField(value = "yonghu_email") // 对应数据库字段名
@TableField(value = "yonghu_email")
private String yonghuEmail;
/**
* 性别
* 使用数字表示，对应字典表中的性别类型
*/
@TableField(value = "sex_types") // 对应数据库字段名
@TableField(value = "sex_types")
private Integer sexTypes;
/**
* 用户余额
*/
@TableField(value = "new_money") // 对应数据库字段名
@TableField(value = "new_money")
private Double newMoney;
/**
* 逻辑删除标志
* 1-未删除，2-已删除
*/
@TableField(value = "yonghu_delete") // 对应数据库字段名
@TableField(value = "yonghu_delete")
private Integer yonghuDelete;
/**
* 创建时间
* 自动填充，格式化为yyyy-MM-dd HH:mm:ss
*/
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") // 日期格式化
@DateTimeFormat // 日期格式
@TableField(value = "create_time",fill = FieldFill.INSERT) // 插入时自动填充
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "create_time",fill = FieldFill.INSERT)
private Date createTime;
// ================ getter和setter方法 ================
/**
* 获取主键ID
* @return id 主键ID
* 设置：主键
*/
public Integer getId() {
return id;
}
/**
* 设置主键ID
* @param id 主键ID
* 获取：主键
*/
public void setId(Integer id) {
this.id = id;
}
/**
* 获取用户名/账户
* @return username 用户名
* 设置：账户
*/
public String getUsername() {
return username;
}
/**
* 设置用户名/账户
* @param username 用户名
* 获取：账户
*/
public void setUsername(String username) {
this.username = username;
}
/**
* 获取密码
* @return password 密码
* 设置：密码
*/
public String getPassword() {
return password;
}
/**
* 设置密码
* @param password 密码
* 获取：密码
*/
public void setPassword(String password) {
this.password = password;
}
/**
* 获取用户真实姓名
* @return yonghuName 用户姓名
* 设置：用户姓名
*/
public String getYonghuName() {
return yonghuName;
}
/**
* 设置用户真实姓名
* @param yonghuName 用户姓名
* 获取：用户姓名
*/
public void setYonghuName(String yonghuName) {
this.yonghuName = yonghuName;
}
/**
* 获取用户头像路径
* @return yonghuPhoto 头像路径
* 设置：头像
*/
public String getYonghuPhoto() {
return yonghuPhoto;
}
/**
* 设置用户头像路径
* @param yonghuPhoto 头像路径
* 获取：头像
*/
public void setYonghuPhoto(String yonghuPhoto) {
this.yonghuPhoto = yonghuPhoto;
}
/**
* 获取用户手机号
* @return yonghuPhone 手机号
* 设置：用户手机号
*/
public String getYonghuPhone() {
return yonghuPhone;
}
/**
* 设置用户手机号
* @param yonghuPhone 手机号
* 获取：用户手机号
*/
public void setYonghuPhone(String yonghuPhone) {
this.yonghuPhone = yonghuPhone;
}
/**
* 获取用户身份证号
* @return yonghuIdNumber 身份证号
* 设置：用户身份证号
*/
public String getYonghuIdNumber() {
return yonghuIdNumber;
}
/**
* 设置用户身份证号
* @param yonghuIdNumber 身份证号
* 获取：用户身份证号
*/
public void setYonghuIdNumber(String yonghuIdNumber) {
this.yonghuIdNumber = yonghuIdNumber;
}
/**
* 获取用户邮箱
* @return yonghuEmail 邮箱地址
* 设置：邮箱
*/
public String getYonghuEmail() {
return yonghuEmail;
}
/**
* 设置用户邮箱
* @param yonghuEmail 邮箱地址
* 获取：邮箱
*/
public void setYonghuEmail(String yonghuEmail) {
this.yonghuEmail = yonghuEmail;
}
/**
* 获取性别类型
* @return sexTypes 性别类型编码
* 设置：性别
*/
public Integer getSexTypes() {
return sexTypes;
}
/**
* 设置性别类型
* @param sexTypes 性别类型编码
* 获取：性别
*/
public void setSexTypes(Integer sexTypes) {
this.sexTypes = sexTypes;
}
/**
* 获取用户余额
* @return newMoney 余额
* 设置：余额
*/
public Double getNewMoney() {
return newMoney;
}
/**
* 设置用户余额
* @param newMoney 余额
* 获取：余额
*/
public void setNewMoney(Double newMoney) {
this.newMoney = newMoney;
}
/**
* 获取逻辑删除标志
* @return yonghuDelete 删除状态(1-未删除，2-已删除)
* 设置：假删
*/
public Integer getYonghuDelete() {
return yonghuDelete;
}
/**
* 设置逻辑删除标志
* @param yonghuDelete 删除状态(1-未删除，2-已删除)
* 获取：假删
*/
public void setYonghuDelete(Integer yonghuDelete) {
this.yonghuDelete = yonghuDelete;
}
/**
* 获取创建时间
* @return createTime 创建时间
* 设置：创建时间
*/
public Date getCreateTime() {
return createTime;
}
/**
* 设置创建时间
* @param createTime 创建时间
* 获取：创建时间
*/
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
/**
* 重写toString方法
* @return 对象字符串表示
*/
@Override
public String toString() {
return "Yonghu{" +

65
src/main/java/com/entity/model/ChatModel.java
Unescape View File

@ -8,7 +8,6 @@ import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
/**
* 在线咨询
* 接收传参的实体类
@ -16,196 +15,216 @@ import java.io.Serializable;
* 取自ModelAndView 的model名称
*/
public class ChatModel implements Serializable {
// 序列化版本号，用于保证序列化和反序列化的兼容性
private static final long serialVersionUID = 1L;
/**
* 主键
*/
// 用于唯一标识一条在线咨询记录的主键
private Integer id;
/**
* 提问用户
*/
// 发起咨询问题的用户的ID
private Integer yonghuId;
/**
* 问题
*/
// 用户提出的咨询问题内容
private String chatIssue;
/**
* 问题时间
*/
// 设置JSON序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss"
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
// 用于Spring MVC接收表单数据时将日期字符串转换为Date对象
@DateTimeFormat
// 用户提出问题的具体时间
private Date issueTime;
/**
* 回复
*/
// 针对用户咨询问题给出的回复内容
private String chatReply;
/**
* 回复时间
*/
// 设置JSON序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss"
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
// 用于Spring MVC接收表单数据时将日期字符串转换为Date对象
@DateTimeFormat
// 给出回复的具体时间
private Date replyTime;
/**
* 状态
*/
// 表示该在线咨询记录的状态，使用整数类型表示不同状态
private Integer zhuangtaiTypes;
/**
* 数据类型
*/
// 表示该在线咨询记录的数据类型，使用整数类型表示不同类型
private Integer chatTypes;
/**
* 创建时间
*/
// 设置JSON序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss"
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
// 用于Spring MVC接收表单数据时将日期字符串转换为Date对象
@DateTimeFormat
// 该在线咨询记录的创建时间
private Date insertTime;
/**
* 获取：主键
*/
// 获取主键ID的方法
public Integer getId() {
return id;
}
/**
* 设置：主键
*/
// 设置主键ID的方法
public void setId(Integer id) {
this.id = id;
}
/**
* 获取：提问用户
*/
// 获取提问用户ID的方法
public Integer getYonghuId() {
return yonghuId;
}
/**
* 设置：提问用户
*/
// 设置提问用户ID的方法
public void setYonghuId(Integer yonghuId) {
this.yonghuId = yonghuId;
}
/**
* 获取：问题
*/
// 获取咨询问题内容的方法
public String getChatIssue() {
return chatIssue;
}
/**
* 设置：问题
*/
// 设置咨询问题内容的方法
public void setChatIssue(String chatIssue) {
this.chatIssue = chatIssue;
}
/**
* 获取：问题时间
*/
// 获取用户提出问题时间的方法
public Date getIssueTime() {
return issueTime;
}
/**
* 设置：问题时间
*/
// 设置用户提出问题时间的方法
public void setIssueTime(Date issueTime) {
this.issueTime = issueTime;
}
/**
* 获取：回复
*/
// 获取咨询问题回复内容的方法
public String getChatReply() {
return chatReply;
}
/**
* 设置：回复
*/
// 设置咨询问题回复内容的方法
public void setChatReply(String chatReply) {
this.chatReply = chatReply;
}
/**
* 获取：回复时间
*/
// 获取给出回复时间的方法
public Date getReplyTime() {
return replyTime;
}
/**
* 设置：回复时间
*/
// 设置给出回复时间的方法
public void setReplyTime(Date replyTime) {
this.replyTime = replyTime;
}
/**
* 获取：状态
*/
// 获取咨询记录状态的方法
public Integer getZhuangtaiTypes() {
return zhuangtaiTypes;
}
/**
* 设置：状态
*/
// 设置咨询记录状态的方法
public void setZhuangtaiTypes(Integer zhuangtaiTypes) {
this.zhuangtaiTypes = zhuangtaiTypes;
}
/**
* 获取：数据类型
*/
// 获取咨询记录数据类型的方法
public Integer getChatTypes() {
return chatTypes;
}
/**
* 设置：数据类型
*/
// 设置咨询记录数据类型的方法
public void setChatTypes(Integer chatTypes) {
this.chatTypes = chatTypes;
}
/**
* 获取：创建时间
*/
// 获取咨询记录创建时间的方法
public Date getInsertTime() {
return insertTime;
}
/**
* 设置：创建时间
*/
// 设置咨询记录创建时间的方法
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
}

61
src/main/java/com/entity/model/DictionaryModel.java
Unescape View File

@ -1,187 +1,206 @@
package com.entity.model;
// 引入字典表实体类，可能用于与数据库实体交互或类型转换等操作
import com.entity.DictionaryEntity;
// 该注解用于指定实体类对应的数据库表名，不过在当前代码中未实际使用该功能
import com.baomidou.mybatisplus.annotations.TableName;
// 用于在将对象序列化为JSON时，对日期类型的字段进行格式化处理
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
// 用于在Spring MVC中，将前端传递的日期字符串绑定到Java对象的日期字段时进行格式化
import org.springframework.format.annotation.DateTimeFormat;
// 实现该接口意味着这个类的对象可以被序列化和反序列化，方便在网络传输或存储时使用
import java.io.Serializable;
/**
* 字典表
* 接收传参的实体类
*（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
* 取自ModelAndView 的model名称
*/
// 定义一个名为DictionaryModel的类，实现Serializable接口，用于接收字典表相关的参数
public class DictionaryModel implements Serializable {
// 序列化版本号，用于在反序列化时验证版本一致性，避免不同版本类之间反序列化出错
private static final long serialVersionUID = 1L;
/**
* 主键
*/
// 用于唯一标识字典表中的每一条记录，在数据库操作中常作为主键使用
private Integer id;
/**
* 字段
*/
// 表示字典表中的某个字段，可能用于存储特定的数据标识
private String dicCode;
/**
* 字段名
*/
// 该字段的名称，用于更直观地描述dicCode所代表的含义
private String dicName;
/**
* 编码
*/
// 可能是对该字段的一种编码表示，方便数据的分类和查询
private Integer codeIndex;
/**
* 编码名字
*/
// 编码对应的名称，用于更清晰地展示编码的具体含义
private String indexName;
/**
* 父字段id
*/
// 用于关联父字段，可能用于构建字典表的层级结构
private Integer superId;
/**
* 备注
*/
// 对该条字典记录的额外说明信息，可用于记录一些特殊情况或备注
private String beizhu;
/**
* 创建时间
*/
// 对日期进行JSON序列化时，指定日期的格式、语言环境和时区
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
// 用于在Spring MVC中，将前端传递的日期字符串转换为Date类型时指定格式
@DateTimeFormat
// 记录该条字典记录的创建时间
private Date createTime;
/**
* 获取：主键
*/
// 定义一个公共的获取主键的方法，供外部调用获取id的值
public Integer getId() {
return id;
}
/**
* 设置：主键
*/
// 定义一个公共的设置主键的方法，供外部调用设置id的值
public void setId(Integer id) {
this.id = id;
}
/**
* 获取：字段
*/
// 定义一个公共的获取字段标识的方法，供外部调用获取dicCode的值
public String getDicCode() {
return dicCode;
}
/**
* 设置：字段
*/
// 定义一个公共的设置字段标识的方法，供外部调用设置dicCode的值
public void setDicCode(String dicCode) {
this.dicCode = dicCode;
}
/**
* 获取：字段名
*/
// 定义一个公共的获取字段名称的方法，供外部调用获取dicName的值
public String getDicName() {
return dicName;
}
/**
* 设置：字段名
*/
// 定义一个公共的设置字段名称的方法，供外部调用设置dicName的值
public void setDicName(String dicName) {
this.dicName = dicName;
}
/**
* 获取：编码
*/
// 定义一个公共的获取编码的方法，供外部调用获取codeIndex的值
public Integer getCodeIndex() {
return codeIndex;
}
/**
* 设置：编码
*/
// 定义一个公共的设置编码的方法，供外部调用设置codeIndex的值
public void setCodeIndex(Integer codeIndex) {
this.codeIndex = codeIndex;
}
/**
* 获取：编码名字
*/
// 定义一个公共的获取编码名称的方法，供外部调用获取indexName的值
public String getIndexName() {
return indexName;
}
/**
* 设置：编码名字
*/
// 定义一个公共的设置编码名称的方法，供外部调用设置indexName的值
public void setIndexName(String indexName) {
this.indexName = indexName;
}
/**
* 获取：父字段id
*/
// 定义一个公共的获取父字段ID的方法，供外部调用获取superId的值
public Integer getSuperId() {
return superId;
}
/**
* 设置：父字段id
*/
// 定义一个公共的设置父字段ID的方法，供外部调用设置superId的值
public void setSuperId(Integer superId) {
this.superId = superId;
}
/**
* 获取：备注
*/
// 定义一个公共的获取备注信息的方法，供外部调用获取beizhu的值
public String getBeizhu() {
return beizhu;
}
/**
* 设置：备注
*/
// 定义一个公共的设置备注信息的方法，供外部调用设置beizhu的值
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
/**
* 获取：创建时间
*/
// 定义一个公共的获取创建时间的方法，供外部调用获取createTime的值
public Date getCreateTime() {
return createTime;
}
/**
* 设置：创建时间
*/
// 定义一个公共的设置创建时间的方法，供外部调用设置createTime的值
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

74
src/main/java/com/entity/model/GuahaoModel.java
Unescape View File

@ -1,229 +1,253 @@
package com.entity.model;
// 导入GuahaoEntity类，可能用于实体之间的转换或关联操作
import com.entity.GuahaoEntity;
// 导入MyBatis-Plus的TableName注解，这里可能用于指定数据库表名（但代码中未实际使用）
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson的JsonFormat注解，用于在JSON序列化和反序列化时格式化日期类型字段
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
// 导入Spring的DateTimeFormat注解，用于在处理表单数据时格式化日期类型字段
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
/**
* 挂号
* 接收传参的实体类
*（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
* 取自ModelAndView 的model名称
*/
// 定义一个名为GuahaoModel的类，实现Serializable接口，使其对象可序列化
public class GuahaoModel implements Serializable {
// 定义序列化版本号，确保在不同版本的类之间进行序列化和反序列化时的兼容性
private static final long serialVersionUID = 1L;
/**
* 主键
*/
// 用于唯一标识挂号记录的主键，在数据库操作中通常作为唯一标识
private Integer id;
/**
* 医生
*/
// 表示进行挂号的医生的ID，用于关联医生信息
private Integer yishengId;
/**
* 用户
*/
// 表示进行挂号的用户的ID，用于关联用户信息
private Integer yonghuId;
/**
* 就诊识别码
*/
// 可能是用于识别就诊记录的唯一编码，具体用途可能根据业务需求而定
private Integer guahaoUuinNumber;
/**
* 挂号时间
*/
// 设置JSON序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss"
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
// 用于Spring MVC接收表单数据时将日期字符串转换为Date对象
@DateTimeFormat
// 记录挂号操作的具体时间
private Date guahaoTime;
/**
* 时间类型
*/
// 可能用于区分不同类型的挂号时间，例如预约时间、实际挂号时间等
private Integer guahaoTypes;
/**
* 挂号状态
*/
// 用于表示挂号的当前状态，例如已挂号、已取消、已就诊等
private Integer guahaoStatusTypes;
/**
* 挂号审核
*/
// 用于表示挂号是否经过审核，可能是0（未审核）、1（审核通过）、2（审核不通过）等
private Integer guahaoYesnoTypes;
/**
* 审核结果
*/
// 当挂号经过审核后，记录审核的具体结果信息，例如审核不通过的原因等
private String guahaoYesnoText;
/**
* 创建时间
*/
// 设置JSON序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss"
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
// 用于Spring MVC接收表单数据时将日期字符串转换为Date对象
@DateTimeFormat
// 记录该挂号记录的创建时间
private Date createTime;
/**
* 获取：主键
*/
// 获取主键ID的方法，供外部调用以获取该挂号记录的唯一标识
public Integer getId() {
return id;
}
/**
* 设置：主键
*/
// 设置主键ID的方法，供外部调用以设置该挂号记录的唯一标识
public void setId(Integer id) {
this.id = id;
}
/**
* 获取：医生
*/
// 获取进行挂号的医生ID的方法，供外部调用以获取医生的标识
public Integer getYishengId() {
return yishengId;
}
/**
* 设置：医生
*/
// 设置进行挂号的医生ID的方法，供外部调用以设置医生的标识
public void setYishengId(Integer yishengId) {
this.yishengId = yishengId;
}
/**
* 获取：用户
*/
// 获取进行挂号的用户ID的方法，供外部调用以获取用户的标识
public Integer getYonghuId() {
return yonghuId;
}
/**
* 设置：用户
*/
// 设置进行挂号的用户ID的方法，供外部调用以设置用户的标识
public void setYonghuId(Integer yonghuId) {
this.yonghuId = yonghuId;
}
/**
* 获取：就诊识别码
*/
// 获取就诊识别码的方法，供外部调用以获取该挂号记录的识别编码
public Integer getGuahaoUuinNumber() {
return guahaoUuinNumber;
}
/**
* 设置：就诊识别码
*/
// 设置就诊识别码的方法，供外部调用以设置该挂号记录的识别编码
public void setGuahaoUuinNumber(Integer guahaoUuinNumber) {
this.guahaoUuinNumber = guahaoUuinNumber;
}
/**
* 获取：挂号时间
*/
// 获取挂号时间的方法，供外部调用以获取挂号操作的具体时间
public Date getGuahaoTime() {
return guahaoTime;
}
/**
* 设置：挂号时间
*/
// 设置挂号时间的方法，供外部调用以设置挂号操作的具体时间
public void setGuahaoTime(Date guahaoTime) {
this.guahaoTime = guahaoTime;
}
/**
* 获取：时间类型
*/
// 获取时间类型的方法，供外部调用以获取该挂号记录的时间类型
public Integer getGuahaoTypes() {
return guahaoTypes;
}
/**
* 设置：时间类型
*/
// 设置时间类型的方法，供外部调用以设置该挂号记录的时间类型
public void setGuahaoTypes(Integer guahaoTypes) {
this.guahaoTypes = guahaoTypes;
}
/**
* 获取：挂号状态
*/
// 获取挂号状态的方法，供外部调用以获取该挂号记录的当前状态
public Integer getGuahaoStatusTypes() {
return guahaoStatusTypes;
}
/**
* 设置：挂号状态
*/
// 设置挂号状态的方法，供外部调用以设置该挂号记录的当前状态
public void setGuahaoStatusTypes(Integer guahaoStatusTypes) {
this.guahaoStatusTypes = guahaoStatusTypes;
}
/**
* 获取：挂号审核
*/
// 获取挂号审核状态的方法，供外部调用以获取该挂号记录的审核状态
public Integer getGuahaoYesnoTypes() {
return guahaoYesnoTypes;
}
/**
* 设置：挂号审核
*/
// 设置挂号审核状态的方法，供外部调用以设置该挂号记录的审核状态
public void setGuahaoYesnoTypes(Integer guahaoYesnoTypes) {
this.guahaoYesnoTypes = guahaoYesnoTypes;
}
/**
* 获取：审核结果
*/
// 获取审核结果的方法，供外部调用以获取该挂号记录的审核具体结果信息
public String getGuahaoYesnoText() {
return guahaoYesnoText;
}
/**
* 设置：审核结果
*/
// 设置审核结果的方法，供外部调用以设置该挂号记录的审核具体结果信息
public void setGuahaoYesnoText(String guahaoYesnoText) {
this.guahaoYesnoText = guahaoYesnoText;
}
/**
* 获取：创建时间
*/
// 获取创建时间的方法，供外部调用以获取该挂号记录的创建时间
public Date getCreateTime() {
return createTime;
}
/**
* 设置：创建时间
*/
// 设置创建时间的方法，供外部调用以设置该挂号记录的创建时间
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

62
src/main/java/com/entity/model/JiankangjiaoyuModel.java
Unescape View File

@ -1,189 +1,209 @@
package com.entity.model;
// 导入JiankangjiaoyuEntity类，可能用于与数据库实体进行交互或数据转换等操作
import com.entity.JiankangjiaoyuEntity;
// 导入MyBatis-Plus的TableName注解，通常用于指定数据库表名（但在当前代码中未实际使用该注解）
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson的JsonFormat注解，用于在JSON序列化和反序列化时对日期类型字段进行格式化处理
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
// 导入Spring的DateTimeFormat注解，用于在处理表单数据时对日期类型字段进行格式化
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
/**
* 健康教育
* 接收传参的实体类
*（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
* 取自ModelAndView 的model名称
*/
// 定义一个名为JiankangjiaoyuModel的类，实现Serializable接口，使该类的对象可以被序列化和反序列化
public class JiankangjiaoyuModel implements Serializable {
// 定义序列化版本号，用于保证在不同版本的类之间进行序列化和反序列化时的兼容性
private static final long serialVersionUID = 1L;
/**
* 主键
*/
// 用于唯一标识健康教育记录的主键，在数据库操作中通常作为唯一标识字段
private Integer id;
/**
* 健康教育标题
*/
// 存储健康教育内容的标题，用于展示和区分不同的健康教育信息
private String jiankangjiaoyuName;
/**
* 健康教育类型
*/
// 表示健康教育的具体类型，可能是如疾病预防、健康生活方式等不同分类，以整数类型存储
private Integer jiankangjiaoyuTypes;
/**
* 健康教育图片
*/
// 存储健康教育相关的图片路径或标识，用于展示相关的图片内容
private String jiankangjiaoyuPhoto;
/**
* 健康教育时间
*/
// 设置JSON序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss"
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
// 用于Spring MVC接收表单数据时将日期字符串转换为Date对象
@DateTimeFormat
// 记录健康教育内容的插入时间，即该记录创建或添加到系统的时间
private Date insertTime;
/**
* 健康教育详情
*/
// 存储健康教育的详细内容，如具体的健康知识、建议等文本信息
private String jiankangjiaoyuContent;
/**
* 假删
*/
// 用于实现逻辑删除的字段，可能0表示未删除，1表示已删除（假删），以整数类型存储
private Integer jiankangjiaoyuDelete;
/**
* 创建时间 show1 show2 nameShow
*/
// 设置JSON序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss"
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
// 用于Spring MVC接收表单数据时将日期字符串转换为Date对象
@DateTimeFormat
// 记录该健康教育记录的实际创建时间，可能与插入时间有所区别
private Date createTime;
/**
* 获取：主键
*/
// 获取主键ID的方法，供外部调用以获取该健康教育记录的唯一标识
public Integer getId() {
return id;
}
/**
* 设置：主键
*/
// 设置主键ID的方法，供外部调用以设置该健康教育记录的唯一标识
public void setId(Integer id) {
this.id = id;
}
/**
* 获取：健康教育标题
*/
// 获取健康教育标题的方法，供外部调用以获取该记录的标题信息
public String getJiankangjiaoyuName() {
return jiankangjiaoyuName;
}
/**
* 设置：健康教育标题
*/
// 设置健康教育标题的方法，供外部调用以修改该记录的标题信息
public void setJiankangjiaoyuName(String jiankangjiaoyuName) {
this.jiankangjiaoyuName = jiankangjiaoyuName;
}
/**
* 获取：健康教育类型
*/
// 获取健康教育类型的方法，供外部调用以获取该记录的类型信息
public Integer getJiankangjiaoyuTypes() {
return jiankangjiaoyuTypes;
}
/**
* 设置：健康教育类型
*/
// 设置健康教育类型的方法，供外部调用以修改该记录的类型信息
public void setJiankangjiaoyuTypes(Integer jiankangjiaoyuTypes) {
this.jiankangjiaoyuTypes = jiankangjiaoyuTypes;
}
/**
* 获取：健康教育图片
*/
// 获取健康教育图片相关信息的方法，供外部调用以获取图片路径或标识
public String getJiankangjiaoyuPhoto() {
return jiankangjiaoyuPhoto;
}
/**
* 设置：健康教育图片
*/
// 设置健康教育图片相关信息的方法，供外部调用以修改图片路径或标识
public void setJiankangjiaoyuPhoto(String jiankangjiaoyuPhoto) {
this.jiankangjiaoyuPhoto = jiankangjiaoyuPhoto;
}
/**
* 获取：健康教育时间
*/
// 获取健康教育内容插入时间的方法，供外部调用以获取该记录的插入时间
public Date getInsertTime() {
return insertTime;
}
/**
* 设置：健康教育时间
*/
// 设置健康教育内容插入时间的方法，供外部调用以修改该记录的插入时间
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
/**
* 获取：健康教育详情
*/
// 获取健康教育详细内容的方法，供外部调用以获取该记录的详细文本信息
public String getJiankangjiaoyuContent() {
return jiankangjiaoyuContent;
}
/**
* 设置：健康教育详情
*/
// 设置健康教育详细内容的方法，供外部调用以修改该记录的详细文本信息
public void setJiankangjiaoyuContent(String jiankangjiaoyuContent) {
this.jiankangjiaoyuContent = jiankangjiaoyuContent;
}
/**
* 获取：假删
*/
// 获取逻辑删除标识的方法，供外部调用以获取该记录的假删状态
public Integer getJiankangjiaoyuDelete() {
return jiankangjiaoyuDelete;
}
/**
* 设置：假删
*/
// 设置逻辑删除标识的方法，供外部调用以修改该记录的假删状态
public void setJiankangjiaoyuDelete(Integer jiankangjiaoyuDelete) {
this.jiankangjiaoyuDelete = jiankangjiaoyuDelete;
}
/**
* 获取：创建时间 show1 show2 nameShow
*/
// 获取健康教育记录创建时间的方法，供外部调用以获取该记录的实际创建时间
public Date getCreateTime() {
return createTime;
}
/**
* 设置：创建时间 show1 show2 nameShow
*/
// 设置健康教育记录创建时间的方法，供外部调用以修改该记录的实际创建时间
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

57
src/main/java/com/entity/model/NewsModel.java
Unescape View File

@ -1,169 +1,188 @@
package com.entity.model;
// 导入NewsEntity类，可能用于与数据库实体交互或进行数据转换
import com.entity.NewsEntity;
// 导入MyBatis-Plus的TableName注解，通常用于指定实体类对应的数据库表名，但此代码未实际使用
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson的JsonFormat注解，用于在JSON序列化和反序列化时对日期类型字段进行格式化
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
// 导入Spring的DateTimeFormat注解，用于在处理表单数据时对日期类型字段进行格式化
import org.springframework.format.annotation.DateTimeFormat;
// 导入Serializable接口，实现该接口意味着该类的对象可以被序列化和反序列化
import java.io.Serializable;
/**
* 公告信息
* 接收传参的实体类
*（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
* 取自ModelAndView 的model名称
*/
// 定义一个名为NewsModel的类，实现Serializable接口
public class NewsModel implements Serializable {
// 序列化版本号，用于保证序列化和反序列化过程中类的兼容性
private static final long serialVersionUID = 1L;
/**
* 主键
*/
// 用于唯一标识每条公告信息的主键
private Integer id;
/**
* 公告名称
*/
// 存储公告的名称，用于在列表等地方显示公告的标题
private String newsName;
/**
* 公告图片
*/
// 存储公告相关图片的路径或标识
private String newsPhoto;
/**
* 公告类型
*/
// 用整数表示公告的类型，不同的数值可能代表不同的公告分类
private Integer newsTypes;
/**
* 公告发布时间
*/
// 设置JSON序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss"
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
// 用于Spring MVC接收表单数据时将日期字符串转换为Date对象
@DateTimeFormat
// 记录公告发布的具体时间
private Date insertTime;
/**
* 公告详情
*/
// 存储公告的详细内容，如具体的通知信息等
private String newsContent;
/**
* 创建时间 show1 show2 nameShow
*/
// 设置JSON序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss"
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
// 用于Spring MVC接收表单数据时将日期字符串转换为Date对象
@DateTimeFormat
// 记录该公告信息在系统中创建的时间
private Date createTime;
/**
* 获取：主键
*/
// 获取主键ID的公共方法，供外部调用获取公告的唯一标识
public Integer getId() {
return id;
}
/**
* 设置：主键
*/
// 设置主键ID的公共方法，供外部调用设置公告的唯一标识
public void setId(Integer id) {
this.id = id;
}
/**
* 获取：公告名称
*/
// 获取公告名称的公共方法，供外部调用获取公告的标题
public String getNewsName() {
return newsName;
}
/**
* 设置：公告名称
*/
// 设置公告名称的公共方法，供外部调用修改公告的标题
public void setNewsName(String newsName) {
this.newsName = newsName;
}
/**
* 获取：公告图片
*/
// 获取公告图片路径或标识的公共方法，供外部调用获取公告的图片信息
public String getNewsPhoto() {
return newsPhoto;
}
/**
* 设置：公告图片
*/
// 设置公告图片路径或标识的公共方法，供外部调用修改公告的图片信息
public void setNewsPhoto(String newsPhoto) {
this.newsPhoto = newsPhoto;
}
/**
* 获取：公告类型
*/
// 获取公告类型的公共方法，供外部调用获取公告的分类信息
public Integer getNewsTypes() {
return newsTypes;
}
/**
* 设置：公告类型
*/
// 设置公告类型的公共方法，供外部调用修改公告的分类信息
public void setNewsTypes(Integer newsTypes) {
this.newsTypes = newsTypes;
}
/**
* 获取：公告发布时间
*/
// 获取公告发布时间的公共方法，供外部调用获取公告的发布时间
public Date getInsertTime() {
return insertTime;
}
/**
* 设置：公告发布时间
*/
// 设置公告发布时间的公共方法，供外部调用修改公告的发布时间
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
/**
* 获取：公告详情
*/
// 获取公告详细内容的公共方法，供外部调用获取公告的具体信息
public String getNewsContent() {
return newsContent;
}
/**
* 设置：公告详情
*/
// 设置公告详细内容的公共方法，供外部调用修改公告的具体信息
public void setNewsContent(String newsContent) {
this.newsContent = newsContent;
}
/**
* 获取：创建时间 show1 show2 nameShow
*/
// 获取公告创建时间的公共方法，供外部调用获取公告在系统中的创建时间
public Date getCreateTime() {
return createTime;
}
/**
* 设置：创建时间 show1 show2 nameShow
*/
// 设置公告创建时间的公共方法，供外部调用修改公告在系统中的创建时间
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

95
src/main/java/com/entity/model/YishengModel.java
Unescape View File

@ -15,7 +15,10 @@ import java.io.Serializable;
* 取自ModelAndView 的model名称
*/
public class YishengModel implements Serializable {
private static final long serialVersionUID = 1L; // 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
/**
* 主键
@ -101,240 +104,210 @@ public class YishengModel implements Serializable {
private Date createTime;
/**
* 获取主键ID
* @return 主键ID
* 获取：主键
*/
public Integer getId() {
return id;
}
/**
* 设置主键ID
* @param id 主键ID
* 设置：主键
*/
public void setId(Integer id) {
this.id = id;
}
/**
* 获取医生工号
* @return 医生工号
* 获取：医生工号
*/
public String getYishengUuidNumber() {
return yishengUuidNumber;
}
/**
* 设置医生工号
* @param yishengUuidNumber 医生工号
* 设置：医生工号
*/
public void setYishengUuidNumber(String yishengUuidNumber) {
this.yishengUuidNumber = yishengUuidNumber;
}
/**
* 获取账户名
* @return 账户名
* 获取：账户
*/
public String getUsername() {
return username;
}
/**
* 设置账户名
* @param username 账户名
* 设置：账户
*/
public void setUsername(String username) {
this.username = username;
}
/**
* 获取密码
* @return 密码
* 获取：密码
*/
public String getPassword() {
return password;
}
/**
* 设置密码
* @param password 密码
* 设置：密码
*/
public void setPassword(String password) {
this.password = password;
}
/**
* 获取医生姓名
* @return 医生姓名
* 获取：医生名称
*/
public String getYishengName() {
return yishengName;
}
/**
* 设置医生姓名
* @param yishengName 医生姓名
* 设置：医生名称
*/
public void setYishengName(String yishengName) {
this.yishengName = yishengName;
}
/**
* 获取科室类型
* @return 科室类型编码
* 获取：科室
*/
public Integer getYishengTypes() {
return yishengTypes;
}
/**
* 设置科室类型
* @param yishengTypes 科室类型编码
* 设置：科室
*/
public void setYishengTypes(Integer yishengTypes) {
this.yishengTypes = yishengTypes;
}
/**
* 获取职位类型
* @return 职位类型编码
* 获取：职位
*/
public Integer getZhiweiTypes() {
return zhiweiTypes;
}
/**
* 设置职位类型
* @param zhiweiTypes 职位类型编码
* 设置：职位
*/
public void setZhiweiTypes(Integer zhiweiTypes) {
this.zhiweiTypes = zhiweiTypes;
}
/**
* 获取职称
* @return 职称
* 获取：职称
*/
public String getYishengZhichneg() {
return yishengZhichneg;
}
/**
* 设置职称
* @param yishengZhichneg 职称
* 设置：职称
*/
public void setYishengZhichneg(String yishengZhichneg) {
this.yishengZhichneg = yishengZhichneg;
}
/**
* 获取医生头像路径
* @return 头像路径
* 获取：医生头像
*/
public String getYishengPhoto() {
return yishengPhoto;
}
/**
* 设置医生头像路径
* @param yishengPhoto 头像路径
* 设置：医生头像
*/
public void setYishengPhoto(String yishengPhoto) {
this.yishengPhoto = yishengPhoto;
}
/**
* 获取联系方式
* @return 联系方式
* 获取：联系方式
*/
public String getYishengPhone() {
return yishengPhone;
}
/**
* 设置联系方式
* @param yishengPhone 联系方式
* 设置：联系方式
*/
public void setYishengPhone(String yishengPhone) {
this.yishengPhone = yishengPhone;
}
/**
* 获取挂号须知
* @return 挂号须知内容
* 获取：挂号须知
*/
public String getYishengGuahao() {
return yishengGuahao;
}
/**
* 设置挂号须知
* @param yishengGuahao 挂号须知内容
* 设置：挂号须知
*/
public void setYishengGuahao(String yishengGuahao) {
this.yishengGuahao = yishengGuahao;
}
/**
* 获取邮箱
* @return 邮箱地址
* 获取：邮箱
*/
public String getYishengEmail() {
return yishengEmail;
}
/**
* 设置邮箱
* @param yishengEmail 邮箱地址
* 设置：邮箱
*/
public void setYishengEmail(String yishengEmail) {
this.yishengEmail = yishengEmail;
}
/**
* 获取挂号价格
* @return 挂号价格
* 获取：挂号价格
*/
public Double getYishengNewMoney() {
return yishengNewMoney;
}
/**
* 设置挂号价格
* @param yishengNewMoney 挂号价格
* 设置：挂号价格
*/
public void setYishengNewMoney(Double yishengNewMoney) {
this.yishengNewMoney = yishengNewMoney;
}
/**
* 获取履历介绍
* @return 履历介绍内容
* 获取：履历介绍
*/
public String getYishengContent() {
return yishengContent;
}
/**
* 设置履历介绍
* @param yishengContent 履历介绍内容
* 设置：履历介绍
*/
public void setYishengContent(String yishengContent) {
this.yishengContent = yishengContent;
}
/**
* 获取创建时间
* @return 创建时间
* 获取：创建时间 show1 show2 photoShow
*/
public Date getCreateTime() {
return createTime;
}
/**
* 设置创建时间
* @param createTime 创建时间
* 设置：创建时间 show1 show2 photoShow
*/
public void setCreateTime(Date createTime) {
this.createTime = createTime;

7
src/main/java/com/entity/model/YonghuModel.java
Unescape View File

@ -1,14 +1,10 @@
package com.entity.model;
// 导入用户实体类
import com.entity.YonghuEntity;
// 导入MyBatis-Plus的表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson的日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
// 导入Spring的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
@ -20,7 +16,6 @@ import java.io.Serializable;
* 取自ModelAndView 的model名称
*/
public class YonghuModel implements Serializable {
// 序列化版本号，用于保证序列化和反序列化的兼容性
private static final long serialVersionUID = 1L;
/**
@ -82,9 +77,7 @@ public class YonghuModel implements Serializable {
/**
* 创建时间
*/
// 用于JSON序列化时，将日期格式化为指定的格式，这里指定为中国时区，格式为yyyy-MM-dd HH:mm:ss
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
// 用于Spring MVC接收表单数据时，将字符串类型的日期转换为Date类型
@DateTimeFormat
private Date createTime;

79
src/main/java/com/entity/view/ChatView.java
Unescape View File

@ -14,191 +14,226 @@ import java.util.Date;
* 后端返回视图实体辅助类
* （通常后端关联的表或者自定义的字段需要返回使用）
*/
// 使用TableName注解指定该类对应的数据库表名为 "chat"
@TableName("chat")
// ChatView类继承自ChatEntity类，并实现了Serializable接口，以便对象可以被序列化和反序列化
public class ChatView extends ChatEntity implements Serializable {
// 序列化版本号，用于保证在不同版本的类之间进行序列化和反序列化时的兼容性
private static final long serialVersionUID = 1L;
/**
* 状态的值
*/
// 用于存储在线咨询相关的状态值，可能表示咨询的状态（如进行中、已结束等）
private String zhuangtaiValue;
/**
* 数据类型的值
*/
// 用于存储在线咨询的数据类型相关的值，具体含义可能根据业务需求而定
private String chatValue;
// 级联表 yonghu
/**
* 用户姓名
*/
// 存储与在线咨询相关联的用户的姓名信息
private String yonghuName;
/**
* 头像
*/
// 存储与在线咨询相关联的用户的头像路径或标识
private String yonghuPhoto;
/**
* 用户手机号
*/
// 存储与在线咨询相关联的用户的手机号码，用于联系用户
private String yonghuPhone;
/**
* 用户身份证号
*/
// 存储与在线咨询相关联的用户的身份证号码，用于身份验证等业务
private String yonghuIdNumber;
/**
* 邮箱
*/
// 存储与在线咨询相关联的用户的电子邮箱地址，可用于发送通知等
private String yonghuEmail;
/**
* 余额
*/
// 存储与在线咨询相关联的用户的账户余额，可能与咨询费用等相关
private Double newMoney;
/**
* 假删
*/
// 用于标识与在线咨询相关联的用户记录是否被逻辑删除（假删），0表示未删除，1表示已删除
private Integer yonghuDelete;
// 无参构造函数，用于创建ChatView对象
public ChatView() {
}
// 构造函数，接受一个ChatEntity对象作为参数，通过BeanUtils.copyProperties方法
// 将ChatEntity对象的属性值复制到当前ChatView对象中
public ChatView(ChatEntity chatEntity) {
try {
BeanUtils.copyProperties(this, chatEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
// 如果在复制属性过程中出现异常，打印异常堆栈信息
e.printStackTrace();
}
}
/**
* 获取： 状态的值
*/
// 获取状态值的方法，外部可以通过调用该方法获取zhuangtaiValue属性的值
public String getZhuangtaiValue() {
return zhuangtaiValue;
}
/**
* 设置： 状态的值
*/
// 设置状态值的方法，外部可以通过调用该方法设置zhuangtaiValue属性的值
public void setZhuangtaiValue(String zhuangtaiValue) {
this.zhuangtaiValue = zhuangtaiValue;
}
/**
* 获取： 数据类型的值
*/
// 获取数据类型值的方法，外部可以通过调用该方法获取chatValue属性的值
public String getChatValue() {
return chatValue;
}
/**
* 设置： 数据类型的值
*/
// 设置数据类型值的方法，外部可以通过调用该方法设置chatValue属性的值
public void setChatValue(String chatValue) {
this.chatValue = chatValue;
}
// 级联表的get和set yonghu
/**
* 获取： 用户姓名
*/
// 获取用户姓名的方法，外部可以通过调用该方法获取yonghuName属性的值
public String getYonghuName() {
return yonghuName;
}
/**
* 设置： 用户姓名
*/
// 设置用户姓名的方法，外部可以通过调用该方法设置yonghuName属性的值
public void setYonghuName(String yonghuName) {
this.yonghuName = yonghuName;
}
/**
* 获取： 头像
*/
// 获取用户头像的方法，外部可以通过调用该方法获取yonghuPhoto属性的值
public String getYonghuPhoto() {
return yonghuPhoto;
}
/**
* 设置： 头像
*/
// 设置用户头像的方法，外部可以通过调用该方法设置yonghuPhoto属性的值
public void setYonghuPhoto(String yonghuPhoto) {
this.yonghuPhoto = yonghuPhoto;
}
/**
* 获取： 用户手机号
*/
// 获取用户手机号的方法，外部可以通过调用该方法获取yonghuPhone属性的值
public String getYonghuPhone() {
return yonghuPhone;
}
/**
* 设置： 用户手机号
*/
// 设置用户手机号的方法，外部可以通过调用该方法设置yonghuPhone属性的值
public void setYonghuPhone(String yonghuPhone) {
this.yonghuPhone = yonghuPhone;
}
/**
* 获取： 用户身份证号
*/
// 获取用户身份证号的方法，外部可以通过调用该方法获取yonghuIdNumber属性的值
public String getYonghuIdNumber() {
return yonghuIdNumber;
}
/**
* 设置： 用户身份证号
*/
// 设置用户身份证号的方法，外部可以通过调用该方法设置yonghuIdNumber属性的值
public void setYonghuIdNumber(String yonghuIdNumber) {
this.yonghuIdNumber = yonghuIdNumber;
}
/**
* 获取： 邮箱
*/
// 获取用户邮箱的方法，外部可以通过调用该方法获取yonghuEmail属性的值
public String getYonghuEmail() {
return yonghuEmail;
}
/**
* 设置： 邮箱
*/
// 设置用户邮箱的方法，外部可以通过调用该方法设置yonghuEmail属性的值
public void setYonghuEmail(String yonghuEmail) {
this.yonghuEmail = yonghuEmail;
}
/**
* 获取： 余额
*/
// 获取用户余额的方法，外部可以通过调用该方法获取newMoney属性的值
public Double getNewMoney() {
return newMoney;
}
/**
* 设置： 余额
*/
// 设置用户余额的方法，外部可以通过调用该方法设置newMoney属性的值
public void setNewMoney(Double newMoney) {
this.newMoney = newMoney;
}
/**
* 获取： 假删
*/
// 获取用户假删状态的方法，外部可以通过调用该方法获取yonghuDelete属性的值
public Integer getYonghuDelete() {
return yonghuDelete;
}
/**
* 设置： 假删
*/
// 设置用户假删状态的方法，外部可以通过调用该方法设置yonghuDelete属性的值
public void setYonghuDelete(Integer yonghuDelete) {
this.yonghuDelete = yonghuDelete;
}
}

35
src/main/java/com/entity/view/DictionaryView.java
Unescape View File

@ -14,44 +14,29 @@ import java.util.Date;
* 后端返回视图实体辅助类
* （通常后端关联的表或者自定义的字段需要返回使用）
*/
// 使用TableName注解指定该类对应的数据库表名为 "dictionary"
@TableName("dictionary")
// DictionaryView类继承自DictionaryEntity类，并实现了Serializable接口，
// 使得该类的对象可以被序列化和反序列化，方便在网络传输或存储中使用
public class DictionaryView extends DictionaryEntity implements Serializable {
// 序列化版本号，用于确保在不同版本的类之间进行序列化和反序列化时的兼容性
private static final long serialVersionUID = 1L;
// 无参构造函数，用于创建DictionaryView对象，在不需要初始化特定属性时使用
public DictionaryView() {
}
// 构造函数，接受一个DictionaryEntity对象作为参数
// 通过BeanUtils.copyProperties方法将DictionaryEntity对象的属性值复制到当前DictionaryView对象中
// 这样可以方便地从Entity对象转换为View对象，减少手动赋值的工作量
public DictionaryView(DictionaryEntity dictionaryEntity) {
try {
BeanUtils.copyProperties(this, dictionaryEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
// 如果在复制属性过程中发生异常（例如属性访问权限问题或反射调用目标方法失败）
// 打印异常堆栈信息，以便开发人员调试和定位问题
e.printStackTrace();
}
}
}

191
src/main/java/com/entity/view/GuahaoView.java
Unescape View File

@ -14,430 +14,499 @@ import java.util.Date;
* 后端返回视图实体辅助类
* （通常后端关联的表或者自定义的字段需要返回使用）
*/
// 使用TableName注解指定该类对应的数据库表名为 "guahao"
@TableName("guahao")
// GuahaoView类继承自GuahaoEntity类，并实现了Serializable接口，
// 使得该类的对象可以被序列化和反序列化，便于在网络传输或存储中使用
public class GuahaoView extends GuahaoEntity implements Serializable {
// 序列化版本号，用于保证在不同版本的类之间进行序列化和反序列化时的兼容性
private static final long serialVersionUID = 1L;
/**
* 时间类型的值
*/
// 用于存储挂号相关的时间类型的值，可能表示不同的挂号时间分类等
private String guahaoValue;
/**
* 挂号状态的值
*/
// 用于存储挂号状态的具体值，例如已挂号、已取消、已就诊等状态的描述
private String guahaoStatusValue;
/**
* 挂号审核的值
*/
// 用于存储挂号审核结果的具体值，例如审核通过、审核不通过等描述
private String guahaoYesnoValue;
// 级联表 yisheng
/**
* 医生工号
*/
// 存储与该挂号记录关联的医生的工号，用于唯一标识医生
private String yishengUuidNumber;
/**
* 医生名称
*/
// 存储与该挂号记录关联的医生的姓名
private String yishengName;
/**
* 科室
*/
// 用整数表示与该挂号记录关联的医生所属的科室
private Integer yishengTypes;
/**
* 科室的值
*/
// 存储科室的具体描述值，可能是科室的名称等，与yishengTypes配合使用
private String yishengValue;
/**
* 职位
*/
// 用整数表示与该挂号记录关联的医生的职位
private Integer zhiweiTypes;
/**
* 职位的值
*/
// 存储职位的具体描述值，可能是职位的名称等，与zhiweiTypes配合使用
private String zhiweiValue;
/**
* 职称
*/
// 存储与该挂号记录关联的医生的职称信息
private String yishengZhichneg;
/**
* 医生头像
*/
// 存储与该挂号记录关联的医生的头像路径或标识
private String yishengPhoto;
/**
* 联系方式
*/
// 存储与该挂号记录关联的医生的联系电话或其他联系方式
private String yishengPhone;
/**
* 挂号须知
*/
// 存储与该医生相关的挂号注意事项和规定等信息
private String yishengGuahao;
/**
* 邮箱
*/
// 存储与该挂号记录关联的医生的电子邮箱地址
private String yishengEmail;
/**
* 挂号价格
*/
// 存储该医生的挂号费用金额，以Double类型表示
private Double yishengNewMoney;
/**
* 履历介绍
*/
// 存储与该挂号记录关联的医生的个人履历和专业介绍等信息
private String yishengContent;
// 级联表 yonghu
/**
* 用户姓名
*/
// 存储与该挂号记录关联的用户的姓名
private String yonghuName;
/**
* 头像
*/
// 存储与该挂号记录关联的用户的头像路径或标识
private String yonghuPhoto;
/**
* 用户手机号
*/
// 存储与该挂号记录关联的用户的手机号码，用于联系用户
private String yonghuPhone;
/**
* 用户身份证号
*/
// 存储与该挂号记录关联的用户的身份证号码，用于身份验证等业务
private String yonghuIdNumber;
/**
* 邮箱
*/
// 存储与该挂号记录关联的用户的电子邮箱地址，可用于发送通知等
private String yonghuEmail;
/**
* 余额
*/
// 存储与该挂号记录关联的用户的账户余额，可能与挂号费用支付等相关
private Double newMoney;
/**
* 假删
*/
// 用于标识与该挂号记录关联的用户记录是否被逻辑删除（假删），0表示未删除，1表示已删除
private Integer yonghuDelete;
// 无参构造函数，用于创建GuahaoView对象
public GuahaoView() {
}
// 构造函数，接受一个GuahaoEntity对象作为参数，
// 通过BeanUtils.copyProperties方法将GuahaoEntity对象的属性值复制到当前GuahaoView对象中
public GuahaoView(GuahaoEntity guahaoEntity) {
try {
BeanUtils.copyProperties(this, guahaoEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
// 如果在复制属性过程中出现异常，打印异常堆栈信息
e.printStackTrace();
}
}
/**
* 获取： 时间类型的值
*/
// 获取时间类型值的方法，外部可以通过调用该方法获取guahaoValue属性的值
public String getGuahaoValue() {
return guahaoValue;
}
/**
* 设置： 时间类型的值
*/
// 设置时间类型值的方法，外部可以通过调用该方法设置guahaoValue属性的值
public void setGuahaoValue(String guahaoValue) {
this.guahaoValue = guahaoValue;
}
/**
* 获取： 挂号状态的值
*/
// 获取挂号状态值的方法，外部可以通过调用该方法获取guahaoStatusValue属性的值
public String getGuahaoStatusValue() {
return guahaoStatusValue;
}
/**
* 设置： 挂号状态的值
*/
// 设置挂号状态值的方法，外部可以通过调用该方法设置guahaoStatusValue属性的值
public void setGuahaoStatusValue(String guahaoStatusValue) {
this.guahaoStatusValue = guahaoStatusValue;
}
/**
* 获取： 挂号审核的值
*/
// 获取挂号审核值的方法，外部可以通过调用该方法获取guahaoYesnoValue属性的值
public String getGuahaoYesnoValue() {
return guahaoYesnoValue;
}
/**
* 设置： 挂号审核的值
*/
// 设置挂号审核值的方法，外部可以通过调用该方法设置guahaoYesnoValue属性的值
public void setGuahaoYesnoValue(String guahaoYesnoValue) {
this.guahaoYesnoValue = guahaoYesnoValue;
}
// 级联表的get和set yisheng
/**
* 获取： 医生工号
*/
// 获取医生工号的方法，外部可以通过调用该方法获取yishengUuidNumber属性的值
public String getYishengUuidNumber() {
return yishengUuidNumber;
}
/**
* 设置： 医生工号
*/
// 设置医生工号的方法，外部可以通过调用该方法设置yishengUuidNumber属性的值
public void setYishengUuidNumber(String yishengUuidNumber) {
this.yishengUuidNumber = yishengUuidNumber;
}
/**
* 获取： 医生名称
*/
// 获取医生名称的方法，外部可以通过调用该方法获取yishengName属性的值
public String getYishengName() {
return yishengName;
}
/**
* 设置： 医生名称
*/
// 设置医生名称的方法，外部可以通过调用该方法设置yishengName属性的值
public void setYishengName(String yishengName) {
this.yishengName = yishengName;
}
/**
* 获取： 科室
*/
// 获取科室编号的方法，外部可以通过调用该方法获取yishengTypes属性的值
public Integer getYishengTypes() {
return yishengTypes;
}
/**
* 设置： 科室
*/
// 设置科室编号的方法，外部可以通过调用该方法设置yishengTypes属性的值
public void setYishengTypes(Integer yishengTypes) {
this.yishengTypes = yishengTypes;
}
/**
* 获取： 科室的值
*/
// 获取科室描述值的方法，外部可以通过调用该方法获取yishengValue属性的值
public String getYishengValue() {
return yishengValue;
}
/**
* 设置： 科室的值
*/
// 设置科室描述值的方法，外部可以通过调用该方法设置yishengValue属性的值
public void setYishengValue(String yishengValue) {
this.yishengValue = yishengValue;
}
/**
* 获取： 职位
*/
// 获取职位编号的方法，外部可以通过调用该方法获取zhiweiTypes属性的值
public Integer getZhiweiTypes() {
return zhiweiTypes;
}
/**
* 设置： 职位
*/
// 设置职位编号的方法，外部可以通过调用该方法设置zhiweiTypes属性的值
public void setZhiweiTypes(Integer zhiweiTypes) {
this.zhiweiTypes = zhiweiTypes;
}
/**
* 获取： 职位的值
*/
// 获取职位描述值的方法，外部可以通过调用该方法获取zhiweiValue属性的值
public String getZhiweiValue() {
return zhiweiValue;
}
/**
* 设置： 职位的值
*/
// 设置职位描述值的方法，外部可以通过调用该方法设置zhiweiValue属性的值
public void setZhiweiValue(String zhiweiValue) {
this.zhiweiValue = zhiweiValue;
}
/**
* 获取： 职称
*/
// 获取职称信息的方法，外部可以通过调用该方法获取yishengZhichneg属性的值
public String getYishengZhichneg() {
return yishengZhichneg;
}
/**
* 设置： 职称
*/
// 设置职称信息的方法，外部可以通过调用该方法设置yishengZhichneg属性的值
public void setYishengZhichneg(String yishengZhichneg) {
this.yishengZhichneg = yishengZhichneg;
}
/**
* 获取： 医生头像
*/
// 获取医生头像路径或标识的方法，外部可以通过调用该方法获取yishengPhoto属性的值
public String getYishengPhoto() {
return yishengPhoto;
}
/**
* 设置： 医生头像
*/
// 设置医生头像路径或标识的方法，外部可以通过调用该方法设置yishengPhoto属性的值
public void setYishengPhoto(String yishengPhoto) {
this.yishengPhoto = yishengPhoto;
}
/**
* 获取： 联系方式
*/
// 获取医生联系方式的方法，外部可以通过调用该方法获取yishengPhone属性的值
public String getYishengPhone() {
return yishengPhone;
}
/**
* 设置： 联系方式
*/
// 设置医生联系方式的方法，外部可以通过调用该方法设置yishengPhone属性的值
public void setYishengPhone(String yishengPhone) {
this.yishengPhone = yishengPhone;
}
/**
* 获取： 挂号须知
*/
// 获取挂号须知信息的方法，外部可以通过调用该方法获取yishengGuahao属性的值
public String getYishengGuahao() {
return yishengGuahao;
}
/**
* 设置： 挂号须知
*/
// 设置挂号须知信息的方法，外部可以通过调用该方法设置yishengGuahao属性的值
public void setYishengGuahao(String yishengGuahao) {
this.yishengGuahao = yishengGuahao;
}
/**
* 获取： 邮箱
*/
// 获取医生邮箱地址的方法，外部可以通过调用该方法获取yishengEmail属性的值
public String getYishengEmail() {
return yishengEmail;
}
/**
* 设置： 邮箱
*/
// 设置医生邮箱地址的方法，外部可以通过调用该方法设置yishengEmail属性的值
public void setYishengEmail(String yishengEmail) {
this.yishengEmail = yishengEmail;
}
/**
* 获取： 挂号价格
*/
// 获取挂号价格信息的方法，外部可以通过调用该方法获取yishengNewMoney属性的值
public Double getYishengNewMoney() {
return yishengNewMoney;
}
/**
* 设置： 挂号价格
*/
// 设置挂号价格信息的方法，外部可以通过调用该方法设置yishengNewMoney属性的值
public void setYishengNewMoney(Double yishengNewMoney) {
this.yishengNewMoney = yishengNewMoney;
}
/**
* 获取： 履历介绍
*/
// 获取医生履历介绍信息的方法，外部可以通过调用该方法获取yishengContent属性的值
public String getYishengContent() {
return yishengContent;
}
/**
* 设置： 履历介绍
*/
// 设置医生履历介绍信息的方法，外部可以通过调用该方法设置yishengContent属性的值
public void setYishengContent(String yishengContent) {
this.yishengContent = yishengContent;
}
// 级联表的get和set yonghu
/**
* 获取： 用户姓名
*/
// 获取用户姓名的方法，外部可以通过调用该方法获取yonghuName属性的值
public String getYonghuName() {
return yonghuName;
}
/**
* 设置： 用户姓名
*/
// 设置用户姓名的方法，外部可以通过调用该方法设置yonghuName属性的值
public void setYonghuName(String yonghuName) {
this.yonghuName = yonghuName;
}
/**
* 获取： 头像
*/
// 获取用户头像路径或标识的方法，外部可以通过调用该方法获取yonghuPhoto属性的值
public String getYonghuPhoto() {
return yonghuPhoto;
}
/**
* 设置： 头像
*/
// 设置用户头像路径或标识的方法，外部可以通过调用该方法设置yonghuPhoto属性的值
public void setYonghuPhoto(String yonghuPhoto) {
this.yonghuPhoto = yonghuPhoto;
}
/**
* 获取： 用户手机号
*/
// 获取用户手机号的方法，外部可以通过调用该方法获取yonghuPhone属性的值
public String getYonghuPhone() {
return yonghuPhone;
}
/**
* 设置： 用户手机号
*/
// 设置用户手机号的方法，外部可以通过调用该方法设置yonghuPhone属性的值
public void setYonghuPhone(String yonghuPhone) {
this.yonghuPhone = yonghuPhone;
}
/**
* 获取： 用户身份证号
*/
// 获取用户身份证号的方法，外部可以通过调用该方法获取yonghuIdNumber属性的值
public String getYonghuIdNumber() {
return yonghuIdNumber;
}
/**
* 设置： 用户身份证号
*/
// 设置用户身份证号的方法，外部可以通过调用该方法设置yonghuIdNumber属性的值
public void setYonghuIdNumber(String yonghuIdNumber) {
this.yonghuIdNumber = yonghuIdNumber;
}
/**
* 获取： 邮箱
*/
// 获取用户邮箱地址的方法，外部可以通过调用该方法获取yonghuEmail属性的值
public String getYonghuEmail() {
return yonghuEmail;
}
/**
* 设置： 邮箱
*/
public void setYonghuEmail(String yonghuEmail) {
this.yonghuEmail = yonghuEmail;
}
/**
* 获取： 余额
*/
public Double getNewMoney() {
return newMoney;
}
/**
* 设置： 余额
*/
public void setNewMoney(Double newMoney) {
this.newMoney = newMoney;
}
/**
* 获取： 假删
*/
public Integer getYonghuDelete() {
return yonghuDelete;
}
/**
* 设置： 假删
*/
public void setYonghuDelete(Integer yonghuDelete) {
this.yonghuDelete = yonghuDelete;
}
}
/**
*

29
src/main/java/com/entity/view/JiankangjiaoyuView.java
Unescape View File

@ -14,52 +14,51 @@ import java.util.Date;
* 后端返回视图实体辅助类
* （通常后端关联的表或者自定义的字段需要返回使用）
*/
// 使用TableName注解指定该类对应的数据库表名为 "jiankangjiaoyu"
@TableName("jiankangjiaoyu")
// JiankangjiaoyuView类继承自JiankangjiaoyuEntity类，并实现了Serializable接口，
// 使得该类的对象可以被序列化和反序列化，方便在网络传输或存储中使用
public class JiankangjiaoyuView extends JiankangjiaoyuEntity implements Serializable {
// 序列化版本号，用于保证在不同版本的类之间进行序列化和反序列化时的兼容性
private static final long serialVersionUID = 1L;
/**
* 健康教育类型的值
*/
// 用于存储健康教育相关的类型值，可能表示不同的健康教育分类，如疾病预防、健康生活方式等
private String jiankangjiaoyuValue;
// 无参构造函数，用于创建JiankangjiaoyuView对象，在不需要初始化特定属性时使用
public JiankangjiaoyuView() {
}
// 构造函数，接受一个JiankangjiaoyuEntity对象作为参数，
// 通过BeanUtils.copyProperties方法将JiankangjiaoyuEntity对象的属性值复制到当前JiankangjiaoyuView对象中，
// 这样可以方便地从Entity对象转换为View对象，减少手动赋值的工作量
public JiankangjiaoyuView(JiankangjiaoyuEntity jiankangjiaoyuEntity) {
try {
BeanUtils.copyProperties(this, jiankangjiaoyuEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
// 如果在复制属性过程中发生异常（例如属性访问权限问题或反射调用目标方法失败），
// 打印异常堆栈信息，以便开发人员调试和定位问题
e.printStackTrace();
}
}
/**
* 获取： 健康教育类型的值
*/
// 获取健康教育类型值的方法，外部可以通过调用该方法获取jiankangjiaoyuValue属性的值
public String getJiankangjiaoyuValue() {
return jiankangjiaoyuValue;
}
/**
* 设置： 健康教育类型的值
*/
// 设置健康教育类型值的方法，外部可以通过调用该方法设置jiankangjiaoyuValue属性的值
public void setJiankangjiaoyuValue(String jiankangjiaoyuValue) {
this.jiankangjiaoyuValue = jiankangjiaoyuValue;
}
}

34
src/main/java/com/entity/view/NewsView.java
Unescape View File

@ -1,12 +1,20 @@
package com.entity.view;
// 导入公告信息实体类，NewsView 会继承该类
import com.entity.NewsEntity;
// 导入 MyBatis-Plus 用于指定数据库表名的注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入 Apache Commons BeanUtils 工具类，用于对象属性复制
import org.apache.commons.beanutils.BeanUtils;
// 导入反射调用可能抛出的异常类
import java.lang.reflect.InvocationTargetException;
// 导入 Spring 框架用于日期格式化的注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入 Jackson 用于 JSON 序列化时日期格式化的注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入序列化接口
import java.io.Serializable;
// 导入日期类
import java.util.Date;
/**
@ -14,52 +22,48 @@ import java.util.Date;
* 后端返回视图实体辅助类
* （通常后端关联的表或者自定义的字段需要返回使用）
*/
// 指定该类对应数据库中的 news 表
@TableName("news")
// NewsView 类继承自 NewsEntity 类，并实现 Serializable 接口，可进行序列化操作
public class NewsView extends NewsEntity implements Serializable {
// 序列化版本号，确保序列化和反序列化的兼容性
private static final long serialVersionUID = 1L;
/**
* 公告类型的值
*/
// 存储公告类型的具体描述值，例如“紧急通知”“普通公告”等
private String newsValue;
// 无参构造函数，方便创建 NewsView 类的实例
public NewsView() {
}
// 带参构造函数，接收一个 NewsEntity 对象，将其属性复制到当前 NewsView 对象
public NewsView(NewsEntity newsEntity) {
try {
// 使用 BeanUtils 工具类复制属性
BeanUtils.copyProperties(this, newsEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
// 若复制属性过程中出现异常，打印异常堆栈信息
e.printStackTrace();
}
}
/**
* 获取： 公告类型的值
*/
// 获取公告类型值的方法
public String getNewsValue() {
return newsValue;
}
/**
* 设置： 公告类型的值
*/
// 设置公告类型值的方法
public void setNewsValue(String newsValue) {
this.newsValue = newsValue;
}
}

7
src/main/java/com/interceptor/AuthorizationInterceptor.java
Unescape View File

@ -29,15 +29,14 @@ public class AuthorizationInterceptor implements HandlerInterceptor {
public static final String LOGIN_TOKEN_KEY = "Token";
@Autowired
private TokenService tokenService;
private TokenService tokenService; // 注入 TokenService
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
String servletPath = request.getServletPath();
if("/dictionary/page".equals(request.getServletPath()) || "/file/upload".equals(request.getServletPath()) || "/yonghu/register".equals(request.getServletPath()) ){//请求路径是字典表或者文件上传 直接放行
if ("/dictionary/page".equals(request.getServletPath()) || "/file/upload".equals(request.getServletPath()) || "/yonghu/register".equals(request.getServletPath())) {
// 请求路径是字典表或者文件上传 直接放行
return true;
}
// 支持跨域请求

12
src/main/java/com/model/enums/TypeEnum.java
Unescape View File

@ -1,30 +1,38 @@
package com.model.enums;
// 导入序列化接口，使枚举对象可以进行序列化和反序列化操作
import java.io.Serializable;
// 导入 MyBatis-Plus 的枚举接口，用于将枚举值映射到数据库字段
import com.baomidou.mybatisplus.enums.IEnum;
/**
* 必须现在 IEnum 配置 该包扫描自动注入，查看文件 spring-mybatis.xml 参数 typeEnumsPackage
* 这个枚举类用于表示某种状态，包含两种状态：禁用和正常
*/
public enum TypeEnum implements IEnum {
// 定义枚举常量，分别表示禁用状态和正常状态
DISABLED(0, "禁用"),
NORMAL(1, "正常");
// 用于存储枚举值对应的整数值，通常与数据库中的字段值对应
private final int value;
// 用于存储枚举值对应的中文描述，方便在代码中使用和展示
private final String desc;
// 枚举类的构造函数，用于初始化枚举常量的 value 和 desc 属性
TypeEnum(final int value, final String desc) {
this.value = value;
this.desc = desc;
}
// 实现 IEnum 接口的方法，返回枚举值对应的整数值，用于与数据库字段进行映射
@Override
public Serializable getValue() {
return this.value;
}
// Jackson 注解为 JsonValue 返回中文 json 描述
// 该方法用于获取枚举值的中文描述，使用 Jackson 注解时，可将该描述作为 JSON 序列化时的值
// 这样在进行 JSON 序列化时，会返回枚举值的中文描述而不是枚举名称
public String getDesc() {
return this.desc;
}

50
src/main/resources/front/front/js/validate.js
Unescape View File

@ -1,69 +1,85 @@
/**
* 邮箱
* @param {*} s
* 验证输入的字符串是否为有效的邮箱地址
* @param {*} s - 要验证的字符串，预期为邮箱地址
* @returns {boolean} - 如果字符串是有效的邮箱地址，返回 true；否则返回 false。当传入的 s 为 null 或 undefined 时，直接返回 true
*/
function isEmail(s) {
if (s) {
return /^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+((.[a-zA-Z0-9_-]{2,3}){1,2})$/.test(s)
// 使用正则表达式匹配邮箱地址的格式
return /^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+((\.[a-zA-Z0-9_-]{2,3}){1,2})$/.test(s);
}
return true;
}
/**
* 手机号码
* @param {*} s
* 验证输入的字符串是否为有效的手机号码
* @param {*} s - 要验证的字符串，预期为手机号码
* @returns {boolean} - 如果字符串是有效的手机号码，返回 true；否则返回 false。当传入的 s 为 null 或 undefined 时，直接返回 true
*/
function isMobile(s) {
if (s) {
return /^1[0-9]{10}$/.test(s)
// 使用正则表达式匹配手机号码的格式（以 1 开头，后面跟着 10 位数字）
return /^1[0-9]{10}$/.test(s);
}
return true;
}
/**
* 电话号码
* @param {*} s
* 验证输入的字符串是否为有效的电话号码
* @param {*} s - 要验证的字符串，预期为电话号码
* @returns {boolean} - 如果字符串是有效的电话号码，返回 true；否则返回 false。当传入的 s 为 null 或 undefined 时，直接返回 true
*/
function isPhone(s) {
if (s) {
return /^([0-9]{3,4}-)?[0-9]{7,8}$/.test(s)
// 使用正则表达式匹配电话号码的格式（可以有 3 到 4 位区号，后面跟着 7 到 8 位号码，区号和号码之间用 - 分隔）
return /^([0-9]{3,4}-)?[0-9]{7,8}$/.test(s);
}
return true;
}
/**
* URL地址
* @param {*} s
* 验证输入的字符串是否为有效的 URL 地址
* @param {*} s - 要验证的字符串，预期为 URL 地址
* @returns {boolean} - 如果字符串是有效的 URL 地址，返回 true；否则返回 false。当传入的 s 为 null 或 undefined 时，直接返回 true
*/
function isURL(s) {
if (s) {
return /^http[s]?:\/\/.*/.test(s)
// 使用正则表达式匹配 URL 地址的格式（以 http 或 https 开头）
return /^http[s]?:\/\/.*/.test(s);
}
return true;
}
/**
* 匹配数字，可以是小数，不可以是负数,可以为空
* @param {*} s
* 验证输入的字符串是否为有效的数字（可以是小数，不能是负数，可以为空）
* @param {*} s - 要验证的字符串，预期为数字
* @returns {boolean} - 如果字符串是有效的数字（符合指定格式），返回 true；否则返回 false。当传入的 s 为 null 或 undefined 时，直接返回 true
*/
function isNumber(s) {
if (s) {
// 使用正则表达式匹配数字的格式，包括小数和科学计数法形式，不允许负数
return /(^-?[+-]?([0-9]*\.?[0-9]+|[0-9]+\.?[0-9]*)([eE][+-]?[0-9]+)?$)|(^$)/.test(s);
}
return true;
}
/**
* 匹配整数，可以为空
* @param {*} s
* 验证输入的字符串是否为有效的整数（可以为空）
* @param {*} s - 要验证的字符串，预期为整数
* @returns {boolean} - 如果字符串是有效的整数（符合指定格式），返回 true；否则返回 false。当传入的 s 为 null 或 undefined 时，直接返回 true
*/
function isIntNumer(s) {
if (s) {
// 使用正则表达式匹配整数的格式，包括正负整数和空字符串
return /(^-?\d+$)|(^$)/.test(s);
}
return true;
}
/**
* 身份证校验
* 验证输入的字符串是否为有效的身份证号码
* @param {string} idcard - 要验证的字符串，预期为身份证号码
* @returns {boolean} - 如果字符串是有效的身份证号码（符合 15 位、18 位或 17 位加最后一位为 X 或 x 的格式），返回 true；否则返回 false。当传入的 idcard 为 null 或 undefined 时，直接返回 true
*/
function isIdentity(idcard) {
const regIdCard = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/;

Write Preview
Loading…
Cancel
Save