From d68ef9898bd2f39624d36f23c825070934afb1d7 Mon Sep 17 00:00:00 2001 From: wjm <484440634@qq.com> Date: Thu, 12 Dec 2024 21:01:58 +0800 Subject: [PATCH] =?UTF-8?q?=E6=B3=A8=E9=87=8A=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/controller/ChatController.java | 348 +++++--------- .../java/com/controller/CommonController.java | 448 +++++++---------- .../com/controller/WenjuandafuController.java | 429 ++++++++--------- .../java/com/controller/YonghuController.java | 450 +++++++++--------- src/main/java/com/dao/ChatDao.java | 4 +- src/main/java/com/dao/CommonDao.java | 83 +--- src/main/java/com/dao/WenjuandafuDao.java | 79 +-- src/main/java/com/dao/YonghuDao.java | 47 +- src/main/java/com/entity/model/ChatModel.java | 2 + .../java/com/entity/model/YonghuModel.java | 3 +- .../java/com/entity/view/WenjuandafuView.java | 45 +- src/main/java/com/service/ChatService.java | 64 +-- src/main/java/com/service/CommonService.java | 73 +-- .../java/com/service/WenjuandafuService.java | 89 +--- src/main/java/com/service/YonghuService.java | 98 +--- .../com/service/impl/ChatServiceImpl.java | 91 ++-- .../com/service/impl/CommonServiceImpl.java | 23 +- .../service/impl/WenjuandafuServiceImpl.java | 103 ++-- .../com/service/impl/YonghuServiceImpl.java | 61 ++- src/main/java/com/utils/BaiduUtil.java | 4 +- src/main/java/com/utils/FileUtil.java | 38 +- src/main/java/com/utils/HttpClientUtils.java | 29 +- src/main/java/com/utils/JQPageInfo.java | 116 ++--- src/main/java/com/utils/MPUtil.java | 329 ++++++------- src/main/java/com/utils/PageUtils.java | 44 +- src/main/java/com/utils/Query.java | 83 ++-- src/main/java/com/utils/R.java | 10 +- .../java/com/utils/SpringContextUtils.java | 91 ++-- src/main/java/com/utils/ValidatorUtils.java | 17 +- 29 files changed, 1331 insertions(+), 1970 deletions(-) diff --git a/src/main/java/com/controller/ChatController.java b/src/main/java/com/controller/ChatController.java index 868b983..ca964db 100644 --- a/src/main/java/com/controller/ChatController.java +++ b/src/main/java/com/controller/ChatController.java @@ -42,310 +42,214 @@ import com.utils.CommonUtil; /** * 在线咨询 * 后端接口 - * @author （这里应该填写作者姓名，但代码中未给出具体值） - * @email （这里应该填写作者邮箱，但代码中未给出具体值） + * @author + * @email * @date 2023-02-21 09:46:06 */ @RestController @RequestMapping("/chat") public class ChatController { - - // 自动注入ChatService实例，用于处理与聊天相关的业务逻辑 @Autowired private ChatService chatService; + + + + + /** * 后端列表 - * 用于获取聊天记录列表，根据不同用户角色（管理员或普通用户）进行数据筛选 - * @param params 包含查询参数的Map，例如分页参数、筛选条件等 - * @param chat ChatEntity对象，可能包含一些额外的查询条件 - * @param request HttpServletRequest对象，用于获取当前会话信息 - * @return R类型的结果，包含查询到的聊天记录列表数据及相关状态信息 */ @RequestMapping("/page") - public R page(@RequestParam Map params, ChatEntity chat, - HttpServletRequest request) { - // 如果当前用户不是管理员角色，设置查询条件，只查询当前用户的聊天记录 - if (!request.getSession().getAttribute("role").toString().equals("管理员")) { - - chat.setUserid((Long) request.getSession().getAttribute("userId")); - } - - // 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件 + public R page(@RequestParam Map params,ChatEntity chat, + HttpServletRequest request){ + if(!request.getSession().getAttribute("role").toString().equals("管理员")) { + chat.setUserid((Long)request.getSession().getAttribute("userId")); + } + EntityWrapper ew = new EntityWrapper(); - // 调用chatService的queryPage方法进行分页查询，传入构建好的查询条件和参数 - PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params)); - // 将查询结果设置到请求属性中，可能用于在后续的视图渲染中使用 - request.setAttribute("data", page); - // 返回包含查询结果的R对象，通常R对象用于统一封装返回结果的状态和数据 + PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params)); + request.setAttribute("data", page); return R.ok().put("data", page); } - + /** * 前端列表 - * 功能与后端列表类似，但可能在前端展示时有不同的处理或用途 - * @param params 包含查询参数的Map，例如分页参数、筛选条件等 - * @param chat ChatEntity对象，可能包含一些额外的查询条件 - * @param request HttpServletRequest对象，用于获取当前会话信息 - * @return R类型的结果，包含查询到的聊天记录列表数据及相关状态信息 */ @RequestMapping("/list") - public R list(@RequestParam Map params, ChatEntity chat, - HttpServletRequest request) { - // 如果当前用户不是管理员角色,设置查询条件，只查询当前用户的聊天记录 - if (!request.getSession().getAttribute("role").toString().equals("管理员")) { - - chat.setUserid((Long) request.getSession().getAttribute("userId")); - } - - // 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件 + public R list(@RequestParam Map params,ChatEntity chat, + HttpServletRequest request){ + if(!request.getSession().getAttribute("role").toString().equals("管理员")) { + chat.setUserid((Long)request.getSession().getAttribute("userId")); + } + EntityWrapper ew = new EntityWrapper(); - // 调用chatService的queryPage方法进行分页查询，传入构建好的查询条件和参数 - PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params)); - // 将查询结果设置到请求属性中，可能用于在后续的视图渲染中使用 - request.setAttribute("data", page); - // 返回包含查询结果的R对象，通常R对象用于统一封装返回结果的状态和数据 + PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params)); + request.setAttribute("data", page); return R.ok().put("data", page); } - /** + /** * 列表 - * 用于获取聊天记录列表，根据传入的ChatEntity对象构建查询条件 - * @param chat ChatEntity对象，包含查询条件信息 - * @return R类型的结果，包含查询到的聊天记录列表数据及相关状态信息 */ @RequestMapping("/lists") - public R list(ChatEntity chat) { - // 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件 - EntityWrapper ew = new EntityWrapper(); - // 根据传入的ChatEntity对象构建等值查询条件 - ew.allEq(MPUtil.allEQMapPre(chat, "chat")); - // 调用chatService的selectListView方法进行查询，并返回结果 + public R list( ChatEntity chat){ + EntityWrapper ew = new EntityWrapper(); + ew.allEq(MPUtil.allEQMapPre( chat, "chat")); return R.ok().put("data", chatService.selectListView(ew)); } - /** + /** * 查询 - * 用于查询特定条件的在线咨询记录，并返回详细信息视图 - * @param chat ChatEntity对象，包含查询条件信息 - * @return R类型的结果，包含查询到的在线咨询详细信息视图及相关状态信息 */ @RequestMapping("/query") - public R query(ChatEntity chat) { - // 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件 - EntityWrapper ew = new EntityWrapper(); - // 根据传入的ChatEntity对象构建等值查询条件 - ew.allEq(MPUtil.allEQMapPre(chat, "chat")); - // 调用chatService的selectView方法进行查询，获取ChatView对象（可能是包含详细信息的视图对象） - ChatView chatView = chatService.selectView(ew); - // 返回包含查询结果的R对象，以及提示信息和查询到的详细信息视图 - return R.ok("查询在线咨询成功").put("data", chatView); + public R query(ChatEntity chat){ + EntityWrapper< ChatEntity> ew = new EntityWrapper< ChatEntity>(); + ew.allEq(MPUtil.allEQMapPre( chat, "chat")); + ChatView chatView = chatService.selectView(ew); + return R.ok("查询在线咨询成功").put("data", chatView); } - + /** * 后端详情 - * 用于获取指定ID的聊天记录详细信息 - * @param id 聊天记录的ID - * @return R类型的结果，包含查询到的聊天记录详细信息及相关状态信息 */ @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id) { - // 调用chatService的selectById方法，根据ID查询聊天记录 + public R info(@PathVariable("id") Long id){ ChatEntity chat = chatService.selectById(id); - // 返回包含查询结果的R对象 return R.ok().put("data", chat); } /** * 前端详情 - * 功能与后端详情类似，但可能在前端展示时有不同的处理或用途，且此方法标注了@IgnoreAuth，表示忽略权限验证 - * @param id 聊天记录的ID - * @return R类型的结果，包含查询到的聊天记录详细信息及相关状态信息 */ - @IgnoreAuth + @IgnoreAuth @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id) { - // 调用chatService的selectById方法，根据ID查询聊天记录 + public R detail(@PathVariable("id") Long id){ ChatEntity chat = chatService.selectById(id); - // 返回包含查询结果的R对象 return R.ok().put("data", chat); } + + + /** * 后端保存 - * 用于保存新的聊天记录，包括设置一些默认值和根据聊天内容更新相关状态 - * @param chat 包含聊天记录信息的ChatEntity对象 - * @param request HttpServletRequest对象，用于获取当前会话信息 - * @return R类型的结果，用于表示保存操作的结果状态 */ @RequestMapping("/save") - public R save(@RequestBody ChatEntity chat, HttpServletRequest request) { - // 设置聊天记录的ID，由当前时间戳加上一个随机数生成 - chat.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); - // 此处原本可能用于验证ChatEntity对象的合法性，但被注释掉了 - //ValidatorUtils.validateEntity(chat); - // 如果聊天记录的提问内容不为空 - if (StringUtils.isNotBlank(chat.getAsk())) { - // 更新当前用户的未回复状态为0，表示有新提问 - chatService.updateForSet("isreply=0", new EntityWrapper().eq("userid", request.getSession().getAttribute("userId"))); - // 设置聊天记录的用户ID为当前用户ID - chat.setUserid((Long) request.getSession().getAttribute("userId")); - // 设置回复状态为1，表示已提问等待回复 - chat.setIsreply(1); - } - // 如果聊天记录的回复内容不为空 - if (StringUtils.isNotBlank(chat.getReply())) { - // 更新当前用户（提问用户）的未回复状态为0，表示有新回复 - chatService.updateForSet("isreply=0", new EntityWrapper().eq("userid", chat.getUserid())); - // 设置聊天记录的管理员ID为当前用户ID（可能表示回复的管理员） - chat.setAdminid((Long) request.getSession().getAttribute("userId")); - } - - // 调用chatService的insert方法插入新的聊天记录 + public R save(@RequestBody ChatEntity chat, HttpServletRequest request){ + chat.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); + //ValidatorUtils.validateEntity(chat); + if(StringUtils.isNotBlank(chat.getAsk())) { + chatService.updateForSet("isreply=0", new EntityWrapper().eq("userid", request.getSession().getAttribute("userId"))); + chat.setUserid((Long)request.getSession().getAttribute("userId")); + chat.setIsreply(1); + } + if(StringUtils.isNotBlank(chat.getReply())) { + chatService.updateForSet("isreply=0", new EntityWrapper().eq("userid", chat.getUserid())); + chat.setAdminid((Long)request.getSession().getAttribute("userId")); + } + chatService.insert(chat); - // 返回表示保存成功的R对象 return R.ok(); } - + /** * 前端保存 - * 功能与后端保存类似，但可能在前端保存时有不同的处理或用途 - * @param chat 包含聊天记录信息的ChatEntity对象 - * @param request HttpServletRequest对象，用于获取当前会话信息 - * @return R类型的结果，用于表示保存操作的结果状态 */ @RequestMapping("/add") - public R add(@RequestBody ChatEntity chat, HttpServletRequest request) { - // 设置聊天记录的ID，由当前时间戳加上一个随机数生成 - chat.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); - - - // 设置聊天记录的用户ID为当前用户ID - chat.setUserid((Long) request.getSession().getAttribute("userId")); - // 如果聊天记录的提问内容不为空 - if (StringUtils.isNotBlank(chat.getAsk())) { - // 更新当前用户的未回复状态为0，表示有新提问 - chatService.updateForSet("isreply=0", new EntityWrapper().eq("userid", request.getSession().getAttribute("userId"))); - // 设置聊天记录的用户ID为当前用户ID - chat.setUserid((Long) request.getSession().getAttribute("UserId")); - // 设置回复状态为1，表示已提问等待回复 - chat.setIsreply(1); - } - // 如果聊天记录的回复内容不为空 - if (StringUtils.isNotBlank(chat.getReply())) { - // 更新当前用户（提问用户）的未回复状态为0，表示有新回复 - chatService.updateForSet("isreply=0", new EntityWrapper().eq("userid", chat.getUserid())); - // 设置聊天记录的管理员ID为当前用户ID（可能表示回复的管理员） - chat.setAdminid((Long) request.getSession().getAttribute("UserId")); - } - - // 调用chatService的insert方法插入新的聊天记录 + public R add(@RequestBody ChatEntity chat, HttpServletRequest request){ + chat.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); + //ValidatorUtils.validateEntity(chat); + chat.setUserid((Long)request.getSession().getAttribute("userId")); + if(StringUtils.isNotBlank(chat.getAsk())) { + chatService.updateForSet("isreply=0", new EntityWrapper().eq("userid", request.getSession().getAttribute("userId"))); + chat.setUserid((Long)request.getSession().getAttribute("userId")); + chat.setIsreply(1); + } + if(StringUtils.isNotBlank(chat.getReply())) { + chatService.updateForSet("isreply=0", new EntityWrapper().eq("userid", chat.getUserid())); + chat.setAdminid((Long)request.getSession().getAttribute("userId")); + } + chatService.insert(chat); - // 返回表示保存成功的R对象 return R.ok(); } + /** * 修改 - * 用于修改已存在的聊天记录 - * @param chat 包含修改后聊天记录信息的ChatEntity对象 - * @param request HttpServletRequest对象，可能用于获取一些额外信息（此处未体现具体用途） - * @return R类型的结果，用于表示修改操作的结果状态 */ @RequestMapping("/update") @Transactional - public R update(@RequestBody ChatEntity chat, HttpServletRequest request) { - // 此处原本可能用于验证ChatEntity对象的合法性，但被注释掉了 + public R update(@RequestBody ChatEntity chat, HttpServletRequest request){ //ValidatorUtils.validateEntity(chat); - // 调用chatService的updateById方法，根据ID更新聊天记录 - chatService.updateById(chat); //全部更新 - // 返回表示修改成功的R对象 + chatService.updateById(chat);//全部更新 return R.ok(); } + + /** * 删除 - * 用于删除指定ID的聊天记录 - * @param ids 包含要删除聊天记录ID的数组 - * @return R类型的结果，用于表示删除操作的结果状态 */ @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids) { - // 调用chatService的deleteBatchIds方法，批量删除指定ID的聊天记录 + public R delete(@RequestBody Long[] ids){ chatService.deleteBatchIds(Arrays.asList(ids)); - // 返回表示删除成功的R对象 return R.ok(); } - + /** * 提醒接口 - * 根据指定的列名、类型以及其他查询条件，统计符合条件的聊天记录数量 - * @param columnName 要进行条件判断的列名 - * @param request HttpServletRequest对象，用于获取当前会话信息等 - * @param type 提醒类型，可能用于区分不同的统计逻辑 - * @param map 包含其他查询条件的Map，例如时间范围等 - * @return R类型的结果，包含统计到的符合条件的聊天记录数量及相关状态信息 */ - @RequestMapping("/remind/{columnName}/{type}") - public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, - @PathVariable("type") String type, @RequestParam Map map) { - // 将列名和类型添加到查询条件Map中 - map.put("column", columnName); - map.put("type", type); - - // 如果提醒类型为2 - if (type.equals("2")) { - // 创建SimpleDateFormat对象，用于日期格式化 - SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); - // 获取Calendar实例，用于日期计算 - Calendar c = Calendar.getInstance(); - Date remindStartDate = null; - Date remindEndDate = null; - // 如果查询条件Map中包含remindstart（开始提醒时间） - if (map.get("remindstart")!= null) { - // 将remindstart转换为整数，表示要添加的天数 - Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); - // 设置当前日期为基础日期 - c.setTime(new Date()); - // 根据提醒开始天数添加到当前日期上 - c.add(Calendar.DAY_OF_MONTH, remindStart); - // 获取计算后的提醒开始日期 - remindStartDate = c.getTime(); - // 将提醒开始日期格式化为指定格式，并更新到查询条件Map中 - map.put("remindstart", sdf.format(remindStartDate)); - } - // 如果查询条件Map中包含remindend（结束提醒时间） - if (map.get("remindend")!= null) { - // 将remindend转换为整数，表示要添加的天数 - Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); - // 设置当前日期为基础日期 - c.setTime(new Date()); - // 根据提醒结束天数添加到当前日期上 - c.add(Calendar.DAY_OF_MONTH, remindEnd); - // 获取计算后的提醒结束日期 - remindEndDate = c.getTime(); - // 将提醒结束日期格式化为指定格式，并更新到查询条件Map中 - map.put("remindend", sdf.format(remindEndDate)); - } - } - - // 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件 - Wrapper wrapper = new EntityWrapper(); - // 如果查询条件Map中包含remindstart（开始提醒时间），添加大于等于条件到查询条件中 - if (map.get("remindstart")!= null) { - wrapper.ge(columnName, map.get("remindstart")); - } - // 如果查询条件Map中包含remindend（结束提醒时间），添加小于等于条件到查询条件中 - if (map.get("remindend")!= null) { - wrapper.le(columnName, map.get("remindend")); - } - - // 调用chatService的selectCount方法，根据构建好的查询条件统计符合条件的聊天记录数量 - int count = chatService.selectCount(wrapper); - // 返回包含统计结果的R对象 - return R.ok().put("count", count); - } - -} \ No newline at end of file + @RequestMapping("/remind/{columnName}/{type}") + public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, + @PathVariable("type") String type,@RequestParam Map map) { + map.put("column", columnName); + map.put("type", type); + + if(type.equals("2")) { + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + Calendar c = Calendar.getInstance(); + Date remindStartDate = null; + Date remindEndDate = null; + 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.put("remindstart", sdf.format(remindStartDate)); + } + if(map.get("remindend")!=null) { + Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); + c.setTime(new Date()); + c.add(Calendar.DAY_OF_MONTH,remindEnd); + remindEndDate = c.getTime(); + map.put("remindend", sdf.format(remindEndDate)); + } + } + + Wrapper wrapper = new EntityWrapper(); + if(map.get("remindstart")!=null) { + wrapper.ge(columnName, map.get("remindstart")); + } + if(map.get("remindend")!=null) { + wrapper.le(columnName, map.get("remindend")); + } + + + int count = chatService.selectCount(wrapper); + return R.ok().put("count", count); + } + + + + + + + + + + +} diff --git a/src/main/java/com/controller/CommonController.java b/src/main/java/com/controller/CommonController.java index 8bd3be9..3d954b2 100644 --- a/src/main/java/com/controller/CommonController.java +++ b/src/main/java/com/controller/CommonController.java @@ -28,286 +28,202 @@ import com.baidu.aip.face.MatchRequest; import com.baidu.aip.util.Base64Util; import com.baomidou.mybatisplus.mapper.EntityWrapper; import com.entity.ConfigEntity; -// 导入相关的服务类和工具类 import com.service.CommonService; import com.service.ConfigService; import com.utils.BaiduUtil; import com.utils.FileUtil; import com.utils.R; import com.utils.CommonUtil; - /** * 通用接口 - * 该类作为一个Spring的RestController，提供了一系列通用的接口方法，用于处理不同类型的业务逻辑， - * 如获取数据选项、根据条件获取记录、修改数据状态、统计数据等操作。 */ @RestController -public class CommonController { - - // 自动注入CommonService，用于处理通用的业务逻辑 - @Autowired - private CommonService commonService; +public class CommonController{ + @Autowired + private CommonService commonService; - // 定义百度AI人脸识别客户端对象，初始化为null private static AipFace client = null; - - // 自动注入ConfigService，可能用于获取配置相关信息 + @Autowired - private ConfigService configService; - - /** - * 获取table表中的column列表（联动接口） - * 根据传入的表名、列名以及一些可选的条件参数，获取指定表中指定列的列表数据，可能用于下拉框等联动选择场景。 - * - * @param tableName 表名 - * @param columnName 列名 - * @param conditionColumn 可选的条件列名，用于进一步筛选数据 - * @param conditionValue 可选的条件值，与conditionColumn配合使用来筛选数据 - * @param level 可选的层级参数，可能用于表示数据的层次结构相关的筛选 - * @param parent 可选的父级参数，可能用于表示数据的父子关系相关的筛选 - * @return 返回包含获取到的列列表数据的R对象，R对象通常用于封装返回结果信息 - */ - @RequestMapping("/option/{tableName}/{columnName}") - @IgnoreAuth - public R getOption(@PathVariable("tableName") String tableName, @PathVariable("tableName") String columnName, - @RequestParam(required = false) String conditionColumn, - @RequestParam(required = false) String conditionValue, String level, String parent) { - // 创建一个用于存储参数的Map对象 - Map params = new HashMap(); - params.put("table", tableName); - params.put("column", columnName); - if (StringUtils.isNotBlank(level)) { - params.put("level", level); - } - if (StringUtils.isNotBlank(parent)) { - params.put("parent", parent); - } - if (StringUtils.isNotBlank(conditionColumn)) { + private ConfigService configService; + /** + * 获取table表中的column列表(联动接口) + * @param table + * @param column + * @return + */ + @RequestMapping("/option/{tableName}/{columnName}") + @IgnoreAuth + public R getOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,@RequestParam(required = false) String conditionColumn,@RequestParam(required = false) String conditionValue,String level,String parent) { + Map params = new HashMap(); + params.put("table", tableName); + params.put("column", columnName); + if(StringUtils.isNotBlank(level)) { + params.put("level", level); + } + if(StringUtils.isNotBlank(parent)) { + params.put("parent", parent); + } + if(StringUtils.isNotBlank(conditionColumn)) { params.put("conditionColumn", conditionColumn); } - if (StringUtils.isNotBlank(conditionValue)) { + if(StringUtils.isNotBlank(conditionValue)) { params.put("conditionValue", conditionValue); } - - // 调用commonService的getOption方法获取数据列表 - List data = commonService.getOption(params); - - // 返回包含数据列表的R对象，结果状态为成功 - return R.ok().put("data", data); - } - - /** - * 根据table中的column获取单条记录 - * 根据传入的表名、列名以及指定的列值，从指定表中获取满足条件的单条记录数据。 - * - * @param tableName 表名 - * @param columnName 列名 - * @param columnValue 用于筛选的列值，根据该值在指定列中查找匹配的记录 - * @return 返回包含获取到的单条记录数据的R对象 - */ - @RequestMapping("/follow/{tableName}/{columnName}") - @IgnoreAuth - public R getFollowByOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, - @RequestParam String columnValue) { - // 创建一个用于存储参数的Map对象 - Map params = new HashMap(); - params.put("table", tableName); - params.put("column", columnName); - params.put("columnValue", columnValue); - - // 调用commonService的getFollowByOption方法获取单条记录数据 - Map result = commonService.getFollowByOption(params); - - // 返回包含单条记录数据的R对象，结果状态为成功 - return R.ok().put("data", result); - } - - /** - * 修改table表的sfsh状态 - * 根据传入的表名和一个包含修改信息的Map对象，调用commonService的sh方法来修改指定表的sfsh状态。 - * - * @param tableName 表名 - * @param map 包含修改信息的Map对象，具体内容由调用方确定，通常包含要修改的字段和对应的值等信息 - * @return 返回表示修改操作成功的R对象 - */ - @RequestMapping("/sh/{tableName}") - public R sh(@PathVariable("tableName") String tableName, @RequestBody Map map) { - map.put("table", tableName); - commonService.sh(map); - return R.ok(); - } - - /** - * 获取需要提醒的记录数 - * 根据传入的表名、列名、类型以及一个包含其他条件的Map对象，计算并获取满足条件的需要提醒的记录数量。 - * 当类型为2时，会根据传入的提醒开始时间和结束时间进行日期范围的计算和筛选。 - * - * @param tableName 表名 - * @param columnName 列名 - * @param type 类型参数，1表示数字类型的提醒条件，2表示日期类型的提醒条件 - * @param map 包含其他条件的Map对象，如提醒开始时间、提醒结束时间等（当type为2时相关） - * @return 返回包含需要提醒的记录数的R对象 - */ - @RequestMapping("/remind/{tableName}/{columnName}/{type}") - @IgnoreAuth - public R remindCount(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, - @PathVariable("type") String type, @RequestParam 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(); - Date remindStartDate = null; - Date remindEndDate = null; - 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.put("remindstart", sdf.format(remindStartDate)); - } - if (map.get("remindend")!= null) { - Integer recommendEnd = Integer.parseInt(map.get("remindend").toString()); - c.setTime(new Date()); - c.add(Calendar.DAY_OF_MONTH, recommendEnd); - remindEndDate = c.getTime(); - map.put("remindend", sdf.format(remindEndDate)); - } - } - - // 调用commonService的remindCount方法获取需要提醒的记录数 - int count = commonService.remindCount(map); - - // 返回包含记录数的R对象，结果状态为成功 - return R.ok().put("count", count); - } - - /** - * 单列求和 - * 根据传入的表名和列名，调用commonService的selectCal方法对指定表中的指定列进行求和操作，并返回结果。 - * - * @param tableName 表名 - * @param columnName 列名 - * @return 返回包含求和结果的R对象 - */ - @RequestMapping("/cal/{tableName}/{columnName}") - @IgnoreAuth - public R cal(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) { - Map params = new HashMap(); - params.put("table", tableName); - params.put("column", columnName); - - // 调用commonService的selectCal方法进行求和操作并获取结果 - Map result = commonService.selectCal(params); - - // 返回包含求和结果的R对象，结果状态为成功 - return R.ok().put("data", result); - } - - /** - * 分组统计 - * 根据传入的表名和列名，调用commonService的selectGroup方法对指定表中的指定列进行分组统计操作， - * 并对结果中的日期类型数据进行格式化处理后返回。 - * - * @param tableName 表名 - ， @param columnName 列名 - * @return 返回包含分组统计结果的R对象 - */ - @RequestMapping("/group/{tableName}/{columnName}") - @IgnoreAuth - public R group(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) { - Map params = new HashMap(); - params.put("table", tableName); - params.put("column", columnName); - - // 调用commonService的selectGroup方法进行分组统计操作并获取结果 - List> result = commonService.selectGroup(params); - - SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); - for (Map m : result) { - for (String k : m.keySet()) { - if (m.get(k) instanceof Date) { - m.put(k, sdf.format((Date) m.get(k))); - } - } - } - - // 返回包含分组统计结果的R对象，结果状态为成功 - return R.ok().put("data", result); - } - - /** - * （按值统计） - * 根据传入的表名、x列名和y列名，调用commonService的selectValue方法对指定表中的指定列进行按值统计操作， - * 并对结果中的日期类型数据进行格式化处理后返回。 - * - * @param tableName 表名 - * @param yColumnName 用于统计的y列名 - * @param xColumnName 用于分组的x列名 - * @return 返回包含按值统计结果的R对象 - */ - @RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}") - @IgnoreAuth - public R value(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName, - @PathVariable("xColumnName") String xColumnName) { - Map params = new HashMap(); - params.put("table", tableName); - params.put("xColumn", xColumnName); - params.put("yColumn", yColumnName); - - // 调用commonService的selectValue方法进行按值统计操作并获取结果 - List > result = commonService.selectValue(params); - - SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); - for (Map m : result) { - for (String k : m.keySet()) { - if (m.get(k) instanceof Date) { - m.put(k, sdf.format((Date) m.get(k))); - } - } - } - - // 返回包含按值统计结果的R对象，结果状态为成功 - return R.ok().put("data", result); - } - - /** - * （按值统计）时间统计类型 - * 根据传入的表名、x列名、y列名和时间统计类型，调用commonService的selectTimeStatValue方法对指定表中的指定列进行按值统计操作， - * 并对结果中的日期类型数据进行格式化处理后返回。 - * - * @param tableName 表名 - * @param yColumnName 用于统计的y列名 - * @param xColumnName 用于分组的x列名 - * @param timeStatType 时间统计类型参数 - * @return 返回包含按值统计结果的R对象 - */ - @RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}/{timeStatType}") - @IgnoreAuth - public R valueDay(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName, - @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType) { - Map params = new HashMap(); - params.put("table", tableName); - params.put("xColumn", xColumnName); - params.put("yColumn", yColumnName); - params.put("timeStatType", timeStatType); - - // 调用commonService的selectTimeStatValue方法进行按值统计操作并获取结果 - List > result = commonService.selectTimeStatValue(params); - - SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); - for (Map m : result) { - for (String k : m.keySet()) { - if (m.get(k) instanceof Date) { - m.put(k, sdf.format((Date) m.get(k))); - } - } - } - - // 返回包含按值统计结果的R对象，结果状态为成功 - return R.ok().put("data", result); - } - -} \ No newline at end of file + List data = commonService.getOption(params); + return R.ok().put("data", data); + } + + /** + * 根据table中的column获取单条记录 + * @param table + * @param column + * @return + */ + @RequestMapping("/follow/{tableName}/{columnName}") + @IgnoreAuth + public R getFollowByOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, @RequestParam String columnValue) { + Map params = new HashMap(); + params.put("table", tableName); + params.put("column", columnName); + params.put("columnValue", columnValue); + Map result = commonService.getFollowByOption(params); + return R.ok().put("data", result); + } + + /** + * 修改table表的sfsh状态 + * @param table + * @param map + * @return + */ + @RequestMapping("/sh/{tableName}") + public R sh(@PathVariable("tableName") String tableName, @RequestBody Map map) { + map.put("table", tableName); + commonService.sh(map); + return R.ok(); + } + + /** + * 获取需要提醒的记录数 + * @param tableName + * @param columnName + * @param type 1:数字 2:日期 + * @param map + * @return + */ + @RequestMapping("/remind/{tableName}/{columnName}/{type}") + @IgnoreAuth + public R remindCount(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, + @PathVariable("type") String type,@RequestParam 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(); + Date remindStartDate = null; + Date remindEndDate = null; + 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.put("remindstart", sdf.format(remindStartDate)); + } + if(map.get("remindend")!=null) { + Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); + c.setTime(new Date()); + c.add(Calendar.DAY_OF_MONTH,remindEnd); + remindEndDate = c.getTime(); + map.put("remindend", sdf.format(remindEndDate)); + } + } + + int count = commonService.remindCount(map); + return R.ok().put("count", count); + } + + /** + * 单列求和 + */ + @RequestMapping("/cal/{tableName}/{columnName}") + @IgnoreAuth + public R cal(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) { + Map params = new HashMap(); + params.put("table", tableName); + params.put("column", columnName); + Map result = commonService.selectCal(params); + return R.ok().put("data", result); + } + + /** + * 分组统计 + */ + @RequestMapping("/group/{tableName}/{columnName}") + @IgnoreAuth + public R group(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) { + Map params = new HashMap(); + params.put("table", tableName); + params.put("column", columnName); + List> result = commonService.selectGroup(params); + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + for(Map m : result) { + for(String k : m.keySet()) { + if(m.get(k) instanceof Date) { + m.put(k, sdf.format((Date)m.get(k))); + } + } + } + return R.ok().put("data", result); + } + + /** + * （按值统计） + */ + @RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}") + @IgnoreAuth + public R value(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName) { + Map params = new HashMap(); + params.put("table", tableName); + params.put("xColumn", xColumnName); + params.put("yColumn", yColumnName); + List> result = commonService.selectValue(params); + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + for(Map m : result) { + for(String k : m.keySet()) { + if(m.get(k) instanceof Date) { + m.put(k, sdf.format((Date)m.get(k))); + } + } + } + return R.ok().put("data", result); + } + + /** + * （按值统计）时间统计类型 + */ + @IgnoreAuth + @RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}/{timeStatType}") + public R valueDay(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType) { + Map params = new HashMap(); + params.put("table", tableName); + params.put("xColumn", xColumnName); + params.put("yColumn", yColumnName); + params.put("timeStatType", timeStatType); + List> result = commonService.selectTimeStatValue(params); + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + for(Map m : result) { + for(String k : m.keySet()) { + if(m.get(k) instanceof Date) { + m.put(k, sdf.format((Date)m.get(k))); + } + } + } + return R.ok().put("data", result); + } + + + +} diff --git a/src/main/java/com/controller/WenjuandafuController.java b/src/main/java/com/controller/WenjuandafuController.java index dd38f12..18877c7 100644 --- a/src/main/java/com/controller/WenjuandafuController.java +++ b/src/main/java/com/controller/WenjuandafuController.java @@ -1,28 +1,36 @@ package com.controller; import java.math.BigDecimal; -import java.text.ParseException; import java.text.SimpleDateFormat; +import java.text.ParseException; import java.util.ArrayList; import java.util.Arrays; import java.util.Calendar; -import java.util.Date; +import java.util.Map; import java.util.HashMap; import java.util.Iterator; +import java.util.Date; import java.util.List; -import java.util.Map; import javax.servlet.http.HttpServletRequest; +import java.io.IOException; + +import com.utils.ValidatorUtils; import org.apache.commons.lang3.StringUtils; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.transaction.annotation.Transactional; +import org.springframework.format.annotation.DateTimeFormat; 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 com.baomidou.mybatisplus.mapper.EntityWrapper; +import com.baomidou.mybatisplus.mapper.Wrapper; import com.annotation.IgnoreAuth; + import com.entity.WenjuandafuEntity; import com.entity.view.WenjuandafuView; + import com.service.WenjuandafuService; import com.service.TokenService; import com.utils.PageUtils; @@ -32,7 +40,11 @@ import com.utils.MPUtil; import com.utils.CommonUtil; /** - * 问卷答复控制器，提供问卷答复的增删改查接口。 + * 问卷答复 + * 后端接口 + * @author + * @email + * @date 2023-02-21 09:46:06 */ @RestController @RequestMapping("/wenjuandafu") @@ -40,57 +52,66 @@ public class WenjuandafuController { @Autowired private WenjuandafuService wenjuandafuService; + + + + + /** - * 获取问卷答复列表（分页） - * @param params 请求参数 - * @param wenjuandafu 查询条件 - * @param request HTTP请求对象 - * @return 包含问卷答复列表的响应结果 + * 后端列表 */ @RequestMapping("/page") - public R page(@RequestParam Map params, WenjuandafuEntity wenjuandafu, HttpServletRequest request){ - String tableName = request.getSession().getAttribute("tableName").toString(); - if(tableName.equals("yonghu")) { - wenjuandafu.setZhanghao((String)request.getSession().getAttribute("username")); - } + public R page(@RequestParam Map params,WenjuandafuEntity wenjuandafu, + HttpServletRequest request){ + + String tableName = request.getSession().getAttribute("tableName").toString(); + if(tableName.equals("yonghu")) { + wenjuandafu.setZhanghao((String)request.getSession().getAttribute("username")); + } EntityWrapper ew = new EntityWrapper(); - PageUtils page = wenjuandafuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandafu), params), params)); - request.setAttribute("data", page); + + PageUtils page = wenjuandafuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandafu), params), params)); + request.setAttribute("data", page); return R.ok().put("data", page); } - + /** - * 获取问卷答复列表（不分页） - * @param params 请求参数 - * @param wenjuandafu 查询条件 - * @param request HTTP请求对象 - * @return 包含问卷答复列表的响应结果 + * 前端列表 */ - @IgnoreAuth + @IgnoreAuth @RequestMapping("/list") - public R list(@RequestParam Map params, WenjuandafuEntity wenjuandafu, HttpServletRequest request){ + public R list(@RequestParam Map params,WenjuandafuEntity wenjuandafu, + HttpServletRequest request){ EntityWrapper ew = new EntityWrapper(); - PageUtils page = wenjuandafuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandafu), params), params)); - request.setAttribute("data", page); + + PageUtils page = wenjuandafuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandafu), params), params)); + request.setAttribute("data", page); return R.ok().put("data", page); } - /** - * 获取所有问卷答复列表 - * @param wenjuandafu 查询条件 - * @return 包含问卷答复列表的响应结果 + /** + * 列表 */ @RequestMapping("/lists") - public R lists(WenjuandafuEntity wenjuandafu){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( wenjuandafu, "wenjuandafu")); + public R list( WenjuandafuEntity wenjuandafu){ + EntityWrapper ew = new EntityWrapper(); + ew.allEq(MPUtil.allEQMapPre( wenjuandafu, "wenjuandafu")); return R.ok().put("data", wenjuandafuService.selectListView(ew)); } + /** + * 查询 + */ + @RequestMapping("/query") + public R query(WenjuandafuEntity wenjuandafu){ + EntityWrapper< WenjuandafuEntity> ew = new EntityWrapper< WenjuandafuEntity>(); + ew.allEq(MPUtil.allEQMapPre( wenjuandafu, "wenjuandafu")); + WenjuandafuView wenjuandafuView = wenjuandafuService.selectView(ew); + return R.ok("查询问卷答复成功").put("data", wenjuandafuView); + } + /** - * 查询单个问卷答复信息 - * @param id 问卷答复ID - * @return 包含问卷答复信息的响应结果 + * 后端详情 */ @RequestMapping("/info/{id}") public R info(@PathVariable("id") Long id){ @@ -99,126 +120,112 @@ public class WenjuandafuController { } /** - * 前端详情页面显示问卷答复信息 - * @param id 问卷答复ID - * @return 包含问卷答复信息的响应结果 + * 前端详情 */ - @IgnoreAuth + @IgnoreAuth @RequestMapping("/detail/{id}") public R detail(@PathVariable("id") Long id){ WenjuandafuEntity wenjuandafu = wenjuandafuService.selectById(id); return R.ok().put("data", wenjuandafu); } + + + /** - * 保存问卷答复信息 - * @param wenjuandafu 问卷答复实体对象 - * @param request HTTP请求对象 - * @return 操作结果响应 + * 后端保存 */ @RequestMapping("/save") public R save(@RequestBody WenjuandafuEntity wenjuandafu, HttpServletRequest request){ - wenjuandafu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(wenjuandafu); // 验证实体对象（注释掉） + wenjuandafu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); + //ValidatorUtils.validateEntity(wenjuandafu); + wenjuandafuService.insert(wenjuandafu); return R.ok(); } - + /** - * 前端保存问卷答复信息 - * @param wenjuandafu 问卷答复实体对象 - * @param request HTTP请求对象 - * @return 操作结果响应 + * 前端保存 */ @RequestMapping("/add") public R add(@RequestBody WenjuandafuEntity wenjuandafu, HttpServletRequest request){ - wenjuandafu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(wenjuandafu); // 验证实体对象（注释掉） + wenjuandafu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); + //ValidatorUtils.validateEntity(wenjuandafu); + wenjuandafuService.insert(wenjuandafu); return R.ok(); } + /** - * 修改问卷答复信息 - * @param wenjuandafu 问卷答复实体对象 - * @param request HTTP请求对象 - * @return 操作结果响应 + * 修改 */ @RequestMapping("/update") @Transactional public R update(@RequestBody WenjuandafuEntity wenjuandafu, HttpServletRequest request){ - //ValidatorUtils.validateEntity(wenjuandafu); // 验证实体对象（注释掉） - wenjuandafuService.updateById(wenjuandafu); //更新全部字段 + //ValidatorUtils.validateEntity(wenjuandafu); + wenjuandafuService.updateById(wenjuandafu);//全部更新 return R.ok(); } + + /** - * 删除问卷答复信息 - * @param ids 要删除的问卷答复ID数组 - * @return 操作结果响应 + * 删除 */ @RequestMapping("/delete") public R delete(@RequestBody Long[] ids){ wenjuandafuService.deleteBatchIds(Arrays.asList(ids)); return R.ok(); } - + /** * 提醒接口 - * @param columnName 列名 - * @param type 类型（2：日期范围） - * @param request HTTP请求对象 - * @param map 请求参数 - * @return 符合条件的记录数响应 */ - @RequestMapping("/remind/{columnName}/{type}") - public R remindCount(@PathVariable("columnName") String columnName, @PathVariable("type") String type, HttpServletRequest request, @RequestParam Map map) { - map.put("column", columnName); - map.put("type", type); - - if(type.equals("2")) { // 如果类型是日期范围 - SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); - Calendar c = Calendar.getInstance(); // 获取当前日期实例 - //初始话开始和结束日期 - Date remindStartDate = null; - Date remindEndDate = null; - - 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.put("remindstart", sdf.format(remindStartDate)); // 将开始日期格式化并放入请求参数中 - } - - if(map.get("remindend") != null) { // 如果请求参数中包含结束日期 - Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); // 获取结束日期天数差值 - c.setTime(new Date()); // 设置当前日期时间 - c.add(Calendar.DAY_OF_MONTH, remindEnd); - remindEndDate = c.getTime(); // 获取计算后的结束日期 - map.put("remindend", sdf.format(remindEndDate)); // 将结束日期格式化并放入请求参数中 - } - } - - String tableName = request.getSession().getAttribute("tableName").toString(); // 获取表名 - if(tableName.equals("yonghu")) { // 如果表名是用户表 - map.put("zhanghao", (String)request.getSession().getAttribute("username")); // 添加用户名到请求参数中作为过滤条件 - } - - Wrapper wrapper = new EntityWrapper(); // 创建查询包装器实例 - - if(map.get("remindstart") != null) { - wrapper.ge(columnName, map.get("remindstart")); // 添加大于等于开始日期的条件到查询包装器中 - } - if(map.get("remindend") != null) { - wrapper.le(columnName, map.get("remindend")); - } - - int count = wenjuandafuService.selectCount(wrapper); // 根据查询包装器统计符合条件的记录数 - return R.ok().put("count", count); // 返回符合条件的记录数响应 - } -} - + @RequestMapping("/remind/{columnName}/{type}") + public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, + @PathVariable("type") String type,@RequestParam Map map) { + map.put("column", columnName); + map.put("type", type); + + if(type.equals("2")) { + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + Calendar c = Calendar.getInstance(); + Date remindStartDate = null; + Date remindEndDate = null; + 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.put("remindstart", sdf.format(remindStartDate)); + } + if(map.get("remindend")!=null) { + Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); + c.setTime(new Date()); + c.add(Calendar.DAY_OF_MONTH,remindEnd); + remindEndDate = c.getTime(); + map.put("remindend", sdf.format(remindEndDate)); + } + } + + Wrapper wrapper = new EntityWrapper(); + if(map.get("remindstart")!=null) { + wrapper.ge(columnName, map.get("remindstart")); + } + if(map.get("remindend")!=null) { + wrapper.le(columnName, map.get("remindend")); + } + + String tableName = request.getSession().getAttribute("tableName").toString(); + if(tableName.equals("yonghu")) { + wrapper.eq("zhanghao", (String)request.getSession().getAttribute("username")); + } + + int count = wenjuandafuService.selectCount(wrapper); + return R.ok().put("count", count); + } + @@ -228,136 +235,94 @@ public class WenjuandafuController { /** * （按值统计） */ - @RequestMapping("/value/{xColumnName}/{yColumnName}") -public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, HttpServletRequest request) { - // 创建参数映射，用于存储请求中的列名 - Map params = new HashMap(); - params.put("xColumn", xColumnName); - params.put("yColumn", yColumnName); - - // 创建实体包装器，用于构建查询条件 - EntityWrapper ew = new EntityWrapper(); - - // 获取当前会话中的表名 - String tableName = request.getSession().getAttribute("tableName").toString(); - - // 如果表名为"yonghu"，则添加用户账号作为查询条件 - if (tableName.equals("yonghu")) { - ew.eq("zhanghao", (String) request.getSession().getAttribute("username")); - } - - // 调用服务层方法进行数据查询 - List> result = wenjuandafuService.selectValue(params, ew); - - // 格式化日期对象为字符串 - SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); - for (Map m : result) { - for (String k : m.keySet()) { - if (m.get(k) instanceof Date) { - m.put(k, sdf.format((Date) m.get(k))); + @RequestMapping("/value/{xColumnName}/{yColumnName}") + public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName,HttpServletRequest request) { + Map params = new HashMap(); + params.put("xColumn", xColumnName); + params.put("yColumn", yColumnName); + EntityWrapper ew = new EntityWrapper(); + String tableName = request.getSession().getAttribute("tableName").toString(); + if(tableName.equals("yonghu")) { + ew.eq("zhanghao", (String)request.getSession().getAttribute("username")); + } + List> result = wenjuandafuService.selectValue(params, ew); + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + for(Map m : result) { + for(String k : m.keySet()) { + if(m.get(k) instanceof Date) { + m.put(k, sdf.format((Date)m.get(k))); + } } } + return R.ok().put("data", result); } - // 返回封装好的响应结果 - return R.ok().put("data", result); -} - -/** - * （按值统计）时间统计类型 - */ -@RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}") -public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType, HttpServletRequest request) { - // 创建参数映射，用于存储请求中的列名和时间统计类型 - Map params = new HashMap(); - params.put("xColumn", xColumnName); - params.put("yColumn", yColumnName); - params.put("timeStatType", timeStatType); - - // 创建实体包装器，用于构建查询条件 - EntityWrapper ew = new EntityWrapper(); - - // 获取当前会话中的表名 - String tableName = request.getSession().getAttribute("tableName").toString(); - - // 如果表名为"yonghu"，则添加用户账号作为查询条件 - if (tableName.equals("yonghu")) { - ew.eq("zhanghao", (String) request.getSession().getAttribute("username")); + /** + * （按值统计）时间统计类型 + */ + @RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}") + public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType,HttpServletRequest request) { + Map params = new HashMap(); + params.put("xColumn", xColumnName); + params.put("yColumn", yColumnName); + params.put("timeStatType", timeStatType); + EntityWrapper ew = new EntityWrapper(); + String tableName = request.getSession().getAttribute("tableName").toString(); + if(tableName.equals("yonghu")) { + ew.eq("zhanghao", (String)request.getSession().getAttribute("username")); + } + List> result = wenjuandafuService.selectTimeStatValue(params, ew); + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + for(Map m : result) { + for(String k : m.keySet()) { + if(m.get(k) instanceof Date) { + m.put(k, sdf.format((Date)m.get(k))); + } + } + } + return R.ok().put("data", result); } - - // 调用服务层方法进行数据查询 - List> result = wenjuandafuService.selectTimeStatValue(params, ew); - - // 格式化日期对象为字符串 - SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); - for (Map m : result) { - for (String k : m.keySet()) { - if (m.get(k) instanceof Date) { - m.put(k, sdf.format((Date) m.get(k))); + + /** + * 分组统计 + */ + @RequestMapping("/group/{columnName}") + public R group(@PathVariable("columnName") String columnName,HttpServletRequest request) { + Map params = new HashMap(); + params.put("column", columnName); + EntityWrapper ew = new EntityWrapper(); + String tableName = request.getSession().getAttribute("tableName").toString(); + if(tableName.equals("yonghu")) { + ew.eq("zhanghao", (String)request.getSession().getAttribute("username")); + } + List> result = wenjuandafuService.selectGroup(params, ew); + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + for(Map m : result) { + for(String k : m.keySet()) { + if(m.get(k) instanceof Date) { + m.put(k, sdf.format((Date)m.get(k))); + } } } + return R.ok().put("data", result); } - // 返回封装好的响应结果 - return R.ok().put("data", result); -} - -/** - * 分组统计 - */ -@RequestMapping("/group/{columnName}") -public R group(@PathVariable("columnName") String columnName, HttpServletRequest request) { - // 创建参数映射，用于存储请求中的列名 - Map params = new HashMap(); - params.put("column", columnName); - - // 创建实体包装器，用于构建查询条件 - EntityWrapper ew = new EntityWrapper(); - - // 获取当前会话中的表名 - String tableName = request.getSession().getAttribute("tableName").toString(); - // 如果表名为"yonghu"，则添加用户账号作为查询条件 - if (tableName.equals("yonghu")) { - ew.eq("zhanghao", (String) request.getSession().getAttribute("username")); - } - // 调用服务层方法进行数据查询 - List> result = wenjuandafuService.selectGroup(params, ew); - // 格式化日期对象为字符串 - SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); - for (Map m : result) { - for (String k : m.keySet()) { - if (m.get(k) instanceof Date) { - m.put(k, sdf.format((Date) m.get(k))); - } + /** + * 总数量 + */ + @RequestMapping("/count") + public R count(@RequestParam Map params,WenjuandafuEntity wenjuandafu, HttpServletRequest request){ + String tableName = request.getSession().getAttribute("tableName").toString(); + if(tableName.equals("yonghu")) { + wenjuandafu.setZhanghao((String)request.getSession().getAttribute("username")); } + EntityWrapper ew = new EntityWrapper(); + int count = wenjuandafuService.selectCount(MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandafu), params), params)); + return R.ok().put("data", count); } - // 返回封装好的响应结果 - return R.ok().put("data", result); -} - -/** - * 总数量 - */ -@RequestMapping("/count") -public R count(@RequestParam Map params, WenjuandafuEntity wenjuandafu, HttpServletRequest request) { - // 获取当前会话中的表名 - String tableName = request.getSession().getAttribute("tableName").toString(); - - // 如果表名为"yonghu"，则添加用户账号作为查询条件 - if (tableName.equals("yonghu")) { - wenjuandafu.setZhanghao((String) request.getSession().getAttribute("username")); - } - - // 创建实体包装器，用于构建查询条件 - EntityWrapper ew = new EntityWrapper(); - - // 调用服务层方法进行数据查询并计算总数 - int count = wenjuandafuService.selectCount(MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandafu), params), params)); - // 返回封装好的响应结果 - return R.ok().put("data", count); } diff --git a/src/main/java/com/controller/YonghuController.java b/src/main/java/com/controller/YonghuController.java index 1fb24a2..7fd259b 100644 --- a/src/main/java/com/controller/YonghuController.java +++ b/src/main/java/com/controller/YonghuController.java @@ -49,334 +49,275 @@ import com.utils.CommonUtil; @RestController @RequestMapping("/yonghu") public class YonghuController { - - // 自动注入用户服务类，用于处理与用户相关的业务逻辑 @Autowired private YonghuService yonghuService; - // 自动注入令牌服务类，用于生成和管理用户令牌 - @Autowired - private TokenService tokenService; - /** - * 用户登录方法 - * @param username 用户名 - * @param password 密码 - * @param captcha 验证码（此处未在代码中看到对验证码的实际验证逻辑） - * @param request Http请求对象 - * @return 返回包含登录结果信息的R对象，若登录成功则包含生成的令牌 - */ - @IgnoreAuth - @RequestMapping(value = "/login") - public R login(String username, String password, String captcha, HttpServletRequest request) { - // 根据用户名查询用户实体 - YonghuEntity u = yonghuService.selectOne(new EntityWrapper().eq("zhanghao", username)); - if (u == null ||!u.getMima().equals(password)) { - // 若用户不存在或密码不匹配，返回错误信息 - return R.error("账号或密码不正确"); - } - // 生成用户令牌 - String token = tokenService.generateToken(u.getId(), username, "yonghu", "用户"); - return R.ok().put("token", token); - } - /** - * 用户注册方法 - * @param yonghu 包含用户注册信息的YonghuEntity对象 - * @return 返回包含注册结果信息的R对象 + + @Autowired + private TokenService tokenService; + + /** + * 登录 + */ + @IgnoreAuth + @RequestMapping(value = "/login") + public R login(String username, String password, String captcha, HttpServletRequest request) { + YonghuEntity u = yonghuService.selectOne(new EntityWrapper().eq("zhanghao", username)); + if(u==null || !u.getMima().equals(password)) { + return R.error("账号或密码不正确"); + } + String token = tokenService.generateToken(u.getId(), username,"yonghu", "用户" ); + return R.ok().put("token", token); + } + + + /** + * 注册 */ - @IgnoreAuth + @IgnoreAuth @RequestMapping("/register") - public R register(@RequestBody YonghuEntity yonghu) { - // 此处原本应有对用户实体的验证逻辑，但被注释掉了 - //ValidatorUtils.validateEntity(yonghu); - // 根据用户名查询是否已存在该用户 - YonghuEntity u = yonghuService.selectOne(new EntityWrapper().eq("zhanghao", yonghu.getZhanghao())); - if (u!= null) { - // 若用户已存在，返回错误信息 - return R.error("注册用户已存在"); - } - // 设置用户ID为当前时间戳 - Long uId = new Date().getTime(); - yonghu.setId(uId); - // 插入新用户信息到数据库 + public R register(@RequestBody YonghuEntity yonghu){ + //ValidatorUtils.validateEntity(yonghu); + YonghuEntity u = yonghuService.selectOne(new EntityWrapper().eq("zhanghao", yonghu.getZhanghao())); + if(u!=null) { + return R.error("注册用户已存在"); + } + Long uId = new Date().getTime(); + yonghu.setId(uId); yonghuService.insert(yonghu); return R.ok(); } - /** - * 用户退出方法 - * @param request Http请求对象 - * @return 返回包含退出成功信息的R对象 - */ - @RequestMapping("/logout") - public R logout(HttpServletRequest request) { - // 使当前会话失效，实现用户退出 - request.getSession().invalidate(); - return R.ok("退出成功"); - } - - /** - * 获取当前用户的会话信息方法 - * @param request Http请求对象 - * @return 返回包含当前用户信息的R对象 + + /** + * 退出 + */ + @RequestMapping("/logout") + public R logout(HttpServletRequest request) { + request.getSession().invalidate(); + return R.ok("退出成功"); + } + + /** + * 获取用户的session用户信息 */ @RequestMapping("/session") - public R getCurrUser(HttpServletRequest request) { - // 从会话中获取用户ID - Long id = (Long) request.getSession().getAttribute("userId"); - // 根据用户ID查询用户实体 + public R getCurrUser(HttpServletRequest request){ + Long id = (Long)request.getSession().getAttribute("userId"); YonghuEntity u = yonghuService.selectById(id); return R.ok().put("data", u); } - + /** - * 用户密码重置方法 - * @param username 用户名 - * @param request Http请求对象 - * @return 返回包含密码重置结果信息的R对象 + * 密码重置 */ @IgnoreAuth - @RequestMapping(value = "/resetPass") - public R resetPass(String username, HttpServletRequest request) { - // 根据用户名查询用户实体 - YonghuEntity u = yonghuService.selectOne(new EntityWrapper().eq("zhanghao", username)); - if (u == null) { - // 若用户不存在，返回错误信息 - return R.error("账号不存在"); - } - // 将用户密码重置为"123456" + @RequestMapping(value = "/resetPass") + public R resetPass(String username, HttpServletRequest request){ + YonghuEntity u = yonghuService.selectOne(new EntityWrapper().eq("zhanghao", username)); + if(u==null) { + return R.error("账号不存在"); + } u.setMima("123456"); - // 更新用户信息到数据库 yonghuService.updateById(u); return R.ok("密码已重置为：123456"); } + /** - * 获取用户列表（后端）方法 - * @param params 查询参数的Map对象 - * @param yonghu YonghuEntity对象，可能用于条件筛选等 - * @param request Http请求对象 - * @return 返回包含用户列表分页信息的R对象 + * 后端列表 */ @RequestMapping("/page") - public R page(@RequestParam Map params, YonghuEntity yonghu, - HttpServletRequest request) { - // 创建用于构建查询条件的EntityWrapper对象 + public R page(@RequestParam Map params,YonghuEntity yonghu, + HttpServletRequest request){ + EntityWrapper ew = new EntityWrapper(); - // 调用服务类的方法进行分页查询，并进行排序、条件筛选等操作 - PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params)); - request.setAttribute("data", page); + PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params)); + request.setAttribute("data", page); return R.ok().put("data", page); } - + /** - * 获取用户列表（前端）方法 - * 与page方法类似，只是多了@IgnoreAuth注解，可能表示前端访问此接口无需认证 - * @param params 查询参数的Map对象 - * @param yonghu YonghuEntity对象，可能用于条件筛选等 - * @param request Http请求对象 - * @return 返回包含用户列表分页信息的R对象 + * 前端列表 */ - @IgnoreAuth + @IgnoreAuth @RequestMapping("/list") - public R list(@RequestParam Map params, YonghuEntity yonghu, - HttpServletRequest request) { + public R list(@RequestParam Map params,YonghuEntity yonghu, + HttpServletRequest request){ EntityWrapper ew = new EntityWrapper(); - PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params)); - request.setAttribute("data", page); + PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params)); + request.setAttribute("data", page); return R.ok().put("data", page); } - /** - * 获取用户列表方法（另一种实现方式，可能用于特定场景） - * @param yonghu YonghuEntity对象，用于构建查询条件 - * @return 返回包含用户列表信息的R对象 + /** + * 列表 */ @RequestMapping("/lists") - public R list(YonghuEntity yonghu) { - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre(yonghu, "yonghu")); + public R list( YonghuEntity yonghu){ + EntityWrapper ew = new EntityWrapper(); + ew.allEq(MPUtil.allEQMapPre( yonghu, "yonghu")); return R.ok().put("data", yonghuService.selectListView(ew)); } - /** - * 查询单个用户信息方法 - * @param yonghu YonghuEntity对象，用于构建查询条件 - * @return 返回包含查询到的用户视图信息的R对象 + /** + * 查询 */ @RequestMapping("/query") - public R query(YonghuEntity yonghu) { - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre(yonghu, "yonghu")); - YonghuView yonghuView = yonghuService.selectView(ew); - return R.ok("查询用户成功").put("data", yonghuView); + public R query(YonghuEntity yonghu){ + EntityWrapper< YonghuEntity> ew = new EntityWrapper< YonghuEntity>(); + ew.allEq(MPUtil.allEQMapPre( yonghu, "yonghu")); + YonghuView yonghuView = yonghuService.selectView(ew); + return R.ok("查询用户成功").put("data", yonghuView); } - + /** - * 获取用户详细信息（后端）方法 - * @param id 用户ID - * @return 返回包含用户详细信息的R对象 + * 后端详情 */ @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id) { + public R info(@PathVariable("id") Long id){ YonghuEntity yonghu = yonghuService.selectById(id); return R.ok().put("data", yonghu); } /** - * 获取用户详细信息（前端）方法 - * 与info方法类似，多了@IgnoreAuth注解，可能表示前端访问此接口无需认证 - * @param id 用户ID - * @return 返回包含用户详细信息的R对象 + * 前端详情 */ - @IgnoreAuth + @IgnoreAuth @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id) { + public R detail(@PathVariable("id") Long id){ YonghuEntity yonghu = yonghuService.selectById(id); return R.ok().put("data", yonghu); } + + + /** - * 保存用户信息（后端）方法 - * @param yonghu 包含用户信息的YonghuEntity对象 - * @param request Http请求对象 - * @return 返回包含保存结果信息的R对象 + * 后端保存 */ @RequestMapping("/save") - public R save(@RequestBody YonghuEntity yonghu, HttpServletRequest request) { - // 设置用户ID为当前时间戳加上一个随机数 - yonghu.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); - // 此处原本应有对用户实体的验证逻辑，但被注释掉了 - //ValidatorUtils.validateEntity(yonghu); - YonghuEntity u = yonghuService.selectOne(new EntityWrapper().eq("zhanghao", yonghu.getZhanghao())); - if (u!= null) { - // 若用户已存在，返回错误信息 - return R.error("用户已存在"); - } - - yonghu.setId(new Date().getTime()); + public R save(@RequestBody YonghuEntity yonghu, HttpServletRequest request){ + yonghu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); + //ValidatorUtils.validateEntity(yonghu); + YonghuEntity u = yonghuService.selectOne(new EntityWrapper().eq("zhanghao", yonghu.getZhanghao())); + if(u!=null) { + return R.error("用户已存在"); + } + + yonghu.setId(new Date().getTime()); yonghuService.insert(yonghu); return R.ok(); } - + /** - * 保存用户信息（前端）方法 - * 与save方法类似，可能在前端页面操作保存用户信息时调用 - * @param yonghu 包含用户信息的YonghuEntity对象 - * @param request Http请求对象 - * @return 返回包含保存结果信息的R对象 + * 前端保存 */ @RequestMapping("/add") - public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request) { - yonghu.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); - // 此处原本应有对用户实体的验证逻辑，但被注释掉了 - //ValidatorUtils.validateEntity(yonghu); - YonghuEntity u = yonghuService.selectOne(new EntityWrapper().eq("zhanghao", yonghu.getZhanghao())); - if (u!= null) { - // 若用户已存在，返回错误信息 - return R.error("用户已存在"); - } - - yonghu.setId(new Date().getTime()); + public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request){ + yonghu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); + //ValidatorUtils.validateEntity(yonghu); + YonghuEntity u = yonghuService.selectOne(new EntityWrapper().eq("zhanghao", yonghu.getZhanghao())); + if(u!=null) { + return R.error("用户已存在"); + } + + yonghu.setId(new Date().getTime()); yonghuService.insert(yonghu); return R.ok(); } + /** - * 更新用户信息方法 - * @param yonghu 包含更新后用户信息的YonghuEntity对象 - * @param request Http请求对象 - * @return 返回包含更新结果信息的R对象 + * 修改 */ @RequestMapping("/update") @Transactional - public R update(@RequestBody YonghuEntity yonghu, HttpServletRequest request) { - // 此处原本应有对用户实体的验证逻辑，但被注释掉了 + public R update(@RequestBody YonghuEntity yonghu, HttpServletRequest request){ //ValidatorUtils.validateEntity(yonghu); - yonghuService.updateById(yonghu); // 全部更新 + yonghuService.updateById(yonghu);//全部更新 return R.ok(); } + + /** - * 删除用户信息方法 - * @param ids 要删除的用户ID数组 - * @return 返回包含删除结果信息的R对象 + * 删除 */ @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids) { + public R delete(@RequestBody Long[] ids){ yonghuService.deleteBatchIds(Arrays.asList(ids)); return R.ok(); } - + /** - * 提醒接口方法，根据指定条件统计符合要求的用户数量 - * @param columnName 用于筛选的列名 - * @param request Http请求对象 - * @param type 类型参数，可能用于区分不同的提醒逻辑 - * @param map 查询参数的Map对象 - * @return 返回包含符合条件的用户数量的R对象 + * 提醒接口 */ - @RequestMapping("/remind/{columnName}/{type}") - public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, - @PathVariable("type") String type, @RequestParam Map map) { - map.put("column", columnName); - map.put("type", type); - - if (type.equals("2")) { - SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); - Calendar c = Calendar.getInstance(); - Date remindStartDate = null; - Date remindEndDate = null; - 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.put("remindstart", sdf.format(remindStartDate)); - } - if (map.get("remindend")!= null) { - Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); - c.setTime(new Date()); - c.add(Calendar.DAY_OF_MONTH, remindEnd); - remindEndDate = c.getTime(); - map.put("remindend", sdf.format(remindEndDate)); - } - } + @RequestMapping("/remind/{columnName}/{type}") + public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, + @PathVariable("type") String type,@RequestParam Map map) { + map.put("column", columnName); + map.put("type", type); + + if(type.equals("2")) { + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + Calendar c = Calendar.getInstance(); + Date remindStartDate = null; + Date remindEndDate = null; + 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.put("remindstart", sdf.format(remindStartDate)); + } + if(map.get("remindend")!=null) { + Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); + c.setTime(new Date()); + c.add(Calendar.DAY_OF_MONTH,remindEnd); + remindEndDate = c.getTime(); + map.put("remindend", sdf.format(remindEndDate)); + } + } + + Wrapper wrapper = new EntityWrapper(); + if(map.get("remindstart")!=null) { + wrapper.ge(columnName, map.get("remindstart")); + } + if(map.get("remindend")!=null) { + wrapper.le(columnName, map.get("remindend")); + } + + + int count = yonghuService.selectCount(wrapper); + return R.ok().put("count", count); + } + + + + - Wrapper wrapper = new EntityWrapper(); - if (map.get("remindstart")!= null) { - wrapper.ge(columnName, map.get("remindstart")); - } - if (map.get("remindend")!= null) { - wrapper.le(columnName, map.get("remindend")); - } - int count = yonghuService.selectCount(wrapper); - return R.ok().put("count", count); - } /** - * （按值统计）方法，根据指定的列进行统计并返回结果 - * @param yColumnName 用于统计的列名（纵坐标相关） - * @param xColumnName 用于分组的列名（横坐标相关） - * @param request Http请求对象 - * @return 返回包含统计结果的R对象 + * （按值统计） */ @RequestMapping("/value/{xColumnName}/{yColumnName}") - public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, HttpServletRequest request) { + public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName,HttpServletRequest request) { Map params = new HashMap(); params.put("xColumn", xColumnName); params.put("yColumn", yColumnName); EntityWrapper ew = new EntityWrapper(); List> result = yonghuService.selectValue(params, ew); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); - for (Map m : result) { - for (String k : m.keySet()) { - if (m.get(k) instanceof Date) { - m.put(k, sdf.format((Date) m.get(k))); + for(Map m : result) { + for(String k : m.keySet()) { + if(m.get(k) instanceof Date) { + m.put(k, sdf.format((Date)m.get(k))); } } } @@ -384,18 +325,59 @@ public class YonghuController { } /** - * （按值统计）时间统计类型方法，根据指定的列和时间统计类型进行统计并返回结果 - * @param yColumnName 用于统计的列名（纵坐标相关） - * @param xColumnName 用于分组的列名（横坐标相关） - * @param timeStatType 时间统计类型参数 - * @param request Http请求对象 - * @return 返回包含统计结果的R对象 + * （按值统计）时间统计类型 */ @RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}") - public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType, HttpServletRequest request) { + public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType,HttpServletRequest request) { Map params = new HashMap(); params.put("xColumn", xColumnName); params.put("yColumn", yColumnName); params.put("timeStatType", timeStatType); EntityWrapper ew = new EntityWrapper(); - List> result \ No newline at end of file + List> result = yonghuService.selectTimeStatValue(params, ew); + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + for(Map m : result) { + for(String k : m.keySet()) { + if(m.get(k) instanceof Date) { + m.put(k, sdf.format((Date)m.get(k))); + } + } + } + return R.ok().put("data", result); + } + + /** + * 分组统计 + */ + @RequestMapping("/group/{columnName}") + public R group(@PathVariable("columnName") String columnName,HttpServletRequest request) { + Map params = new HashMap(); + params.put("column", columnName); + EntityWrapper ew = new EntityWrapper(); + List> result = yonghuService.selectGroup(params, ew); + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + for(Map m : result) { + for(String k : m.keySet()) { + if(m.get(k) instanceof Date) { + m.put(k, sdf.format((Date)m.get(k))); + } + } + } + return R.ok().put("data", result); + } + + + + + /** + * 总数量 + */ + @RequestMapping("/count") + public R count(@RequestParam Map params,YonghuEntity yonghu, HttpServletRequest request){ + EntityWrapper ew = new EntityWrapper(); + int count = yonghuService.selectCount(MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params)); + return R.ok().put("data", count); + } + + +} diff --git a/src/main/java/com/dao/ChatDao.java b/src/main/java/com/dao/ChatDao.java index 3f059c4..7fb08e4 100644 --- a/src/main/java/com/dao/ChatDao.java +++ b/src/main/java/com/dao/ChatDao.java @@ -21,9 +21,9 @@ import com.entity.view.ChatView; */ public interface ChatDao extends BaseMapper { - List selectListVO(@Param("ew") Wrapper wrapper);//根据给定的条件包装器（Wrapper）查询并返回符合条件的ChatVO列表 + List selectListVO(@Param("ew") Wrapper wrapper); - ChatVO selectVO(@Param("ew") Wrapper wrapper);//根据给定的条件包装器（Wrapper）查询并返回符合条件的ChatView列表 + ChatVO selectVO(@Param("ew") Wrapper wrapper); List selectListView(@Param("ew") Wrapper wrapper); diff --git a/src/main/java/com/dao/CommonDao.java b/src/main/java/com/dao/CommonDao.java index ccdd007..0e67c57 100644 --- a/src/main/java/com/dao/CommonDao.java +++ b/src/main/java/com/dao/CommonDao.java @@ -5,69 +5,24 @@ import java.util.List; import java.util.Map; /** - * 通用接口，定义了一组用于数据库操作的方法。 + * 通用接口 */ -public interface CommonDao { - - /** - * 根据给定的参数获取选项列表。 - * @param params 包含查询条件的参数映射 - * @return 返回一个字符串列表，表示查询结果 - */ - List getOption(Map params); - - /** - * 根据给定的参数获取关注信息。 - * @param params 包含查询条件的参数映射 - * @return 返回一个包含关注信息的映射 - */ - Map getFollowByOption(Map params); - - /** - * 根据给定的参数获取另一种形式的关注信息列表。 - * @param params 包含查询条件的参数映射 - * @return 返回一个字符串列表，表示查询结果 - */ - List getFollowByOption2(Map params); - - /** - * 执行某种操作（具体操作未明确）。 - * @param params 包含操作所需参数的映射 - */ - void sh(Map params); - - /** - * 计算提醒的数量。 - * @param params 包含查询条件的参数映射 - * @return 返回提醒的数量 - */ - int remindCount(Map params); - - /** - * 根据给定的参数进行某种计算。 - * @param params 包含计算所需参数的映射 - * @return 返回一个包含计算结果的映射 - */ - Map selectCal(Map params); - - /** - * 根据给定的参数分组查询。 - * @param params 包含查询条件的参数映射 - * @return 返回一个包含分组查询结果的映射列表 - */ - List> selectGroup(Map params); - - /** - * 根据给定的参数查询值。 - * @param params 包含查询条件的参数映射 - * @return 返回一个包含查询结果的映射列表 - */ - List> selectValue(Map params); - - /** - * 根据给定的参数查询时间统计值。 - * @param params 包含查询条件的参数映射 - * @return 返回一个包含时间统计值的映射列表 - */ - List> selectTimeStatValue(Map params); +public interface CommonDao{ + List getOption(Map params); + + Map getFollowByOption(Map params); + + List getFollowByOption2(Map params); + + void sh(Map params); + + int remindCount(Map params); + + Map selectCal(Map params); + + List> selectGroup(Map params); + + List> selectValue(Map params); + + List> selectTimeStatValue(Map params); } diff --git a/src/main/java/com/dao/WenjuandafuDao.java b/src/main/java/com/dao/WenjuandafuDao.java index 5539dfc..2e43ec5 100644 --- a/src/main/java/com/dao/WenjuandafuDao.java +++ b/src/main/java/com/dao/WenjuandafuDao.java @@ -1,4 +1,4 @@ -ppackage com.dao; +package com.dao; import com.entity.WenjuandafuEntity; import com.baomidou.mybatisplus.mapper.BaseMapper; @@ -11,70 +11,33 @@ import org.apache.ibatis.annotations.Param; import com.entity.vo.WenjuandafuVO; import com.entity.view.WenjuandafuView; + /** - * 问卷答复数据访问对象接口 - * 提供对问卷答复数据的查询功能 - * 使用MyBatis-Plus框架进行数据库操作 + * 问卷答复 + * + * @author + * @email + * @date 2023-02-21 09:46:06 */ public interface WenjuandafuDao extends BaseMapper { - - /** - * 根据条件查询问卷答复的VO列表 - * @param wrapper 查询条件封装器 - * @return 符合条件的问卷答复VO列表 - */ - List selectListVO(@Param("ew") Wrapper wrapper); - - /** - * 根据条件查询单个问卷答复的VO - * @param wrapper 查询条件封装器 - * @return 符合条件的单个问卷答复VO - */ - WenjuandafuVO selectVO(@Param("ew") Wrapper wrapper); - - /** - * 根据条件查询问卷答复的视图列表 - * @param wrapper 查询条件封装器 - * @return 符合条件的问卷答复视图列表 - */ - List selectListView(@Param("ew") Wrapper wrapper); + + List selectListVO(@Param("ew") Wrapper wrapper); + + WenjuandafuVO selectVO(@Param("ew") Wrapper wrapper); + + List selectListView(@Param("ew") Wrapper wrapper); + + List selectListView(Pagination page,@Param("ew") Wrapper wrapper); + + WenjuandafuView selectView(@Param("ew") Wrapper wrapper); + - /** - * 根据分页信息和条件查询问卷答复的视图列表 - * @param page 分页信息 - * @param wrapper 查询条件封装器 - * @return 符合条件的问卷答复视图列表（分页） - */ - List selectListView(Pagination page,@Param("ew") Wrapper wrapper); - - /** - * 根据条件查询单个问卷答复的视图 - * @param wrapper 查询条件封装器 - * @return 符合条件的单个问卷答复视图 - */ - WenjuandafuView selectView(@Param("ew") Wrapper wrapper); - - /** - * 根据参数查询问卷答复的值统计结果 - * @param params 查询参数 - * @param wrapper 查询条件封装器 - * @return 值统计结果列表 - */ List> selectValue(@Param("params") Map params,@Param("ew") Wrapper wrapper); - /** - * 根据参数查询问卷答复的时间统计值 - * @param params 查询参数 - * @param wrapper 查询条件封装器 - * @return 时间统计值列表 - */ List> selectTimeStatValue(@Param("params") Map params,@Param("ew") Wrapper wrapper); - /** - * 根据参数查询问卷答复的分组统计结果 - * @param params 查询参数 - * @param wrapper 查询条件封装器 - * @return 分组统计结果列表 - */ List> selectGroup(@Param("params") Map params,@Param("ew") Wrapper wrapper); + + + } diff --git a/src/main/java/com/dao/YonghuDao.java b/src/main/java/com/dao/YonghuDao.java index 70b60ab..1089fa5 100644 --- a/src/main/java/com/dao/YonghuDao.java +++ b/src/main/java/com/dao/YonghuDao.java @@ -6,37 +6,38 @@ import java.util.List; import java.util.Map; import com.baomidou.mybatisplus.mapper.Wrapper; import com.baomidou.mybatisplus.plugins.pagination.Pagination; + import org.apache.ibatis.annotations.Param; import com.entity.vo.YonghuVO; import com.entity.view.YonghuView; + /** - * 用户数据访问对象接口，继承自MyBatis-Plus的BaseMapper。 - * 提供对用户实体（YonghuEntity）的数据库操作方法。 + * 用户 + * + * @author + * @email + * @date 2023-02-21 09:46:06 */ public interface YonghuDao extends BaseMapper { - - // 根据条件查询用户视图对象列表 - List selectListVO(@Param("ew") Wrapper wrapper); - - // 根据条件查询单个用户视图对象 - YonghuVO selectVO(@Param("ew") Wrapper wrapper); - - // 根据条件查询用户视图对象列表 - List selectListView(@Param("ew") Wrapper wrapper); + + List selectListVO(@Param("ew") Wrapper wrapper); + + YonghuVO selectVO(@Param("ew") Wrapper wrapper); + + List selectListView(@Param("ew") Wrapper wrapper); - // 根据分页信息和条件查询用户视图对象列表 - List selectListView(Pagination page, @Param("ew") Wrapper wrapper); - - // 根据条件查询单个用户视图对象 - YonghuView selectView(@Param("ew") Wrapper wrapper); - - // 根据参数和条件查询值映射列表 - List> selectValue(@Param("params") Map params, @Param("ew") Wrapper wrapper); + List selectListView(Pagination page,@Param("ew") Wrapper wrapper); + + YonghuView selectView(@Param("ew") Wrapper wrapper); + + + List> selectValue(@Param("params") Map params,@Param("ew") Wrapper wrapper); - // 根据参数和条件查询时间统计值映射列表 - List> selectTimeStatValue(@Param("params") Map params, @Param("ew") Wrapper wrapper); + List> selectTimeStatValue(@Param("params") Map params,@Param("ew") Wrapper wrapper); - // 根据参数和条件分组查询映射列表 - List> selectGroup(@Param("params") Map params, @Param("ew") Wrapper wrapper); + List> selectGroup(@Param("params") Map params,@Param("ew") Wrapper wrapper); + + + } diff --git a/src/main/java/com/entity/model/ChatModel.java b/src/main/java/com/entity/model/ChatModel.java index 295d12a..6cb4df9 100644 --- a/src/main/java/com/entity/model/ChatModel.java +++ b/src/main/java/com/entity/model/ChatModel.java @@ -12,6 +12,8 @@ import java.io.Serializable; /** * 在线咨询 * 接收传参的实体类 + *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了） + * 取自ModelAndView 的model名称 * @author * @email * @date 2023-02-21 09:46:06 diff --git a/src/main/java/com/entity/model/YonghuModel.java b/src/main/java/com/entity/model/YonghuModel.java index 54832ec..3acbbc7 100644 --- a/src/main/java/com/entity/model/YonghuModel.java +++ b/src/main/java/com/entity/model/YonghuModel.java @@ -12,7 +12,8 @@ import java.io.Serializable; /** * 用户 * 接收传参的实体类 - * 取自ModelAndView 的model名称 + *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了） + * 取自ModelAndView 的model名称 * @author * @email * @date 2023-02-21 09:46:06 diff --git a/src/main/java/com/entity/view/WenjuandafuView.java b/src/main/java/com/entity/view/WenjuandafuView.java index f856ba7..044b77d 100644 --- a/src/main/java/com/entity/view/WenjuandafuView.java +++ b/src/main/java/com/entity/view/WenjuandafuView.java @@ -1,35 +1,36 @@ package com.entity.view; import com.entity.WenjuandafuEntity; + import com.baomidou.mybatisplus.annotations.TableName; import org.apache.commons.beanutils.BeanUtils; import java.lang.reflect.InvocationTargetException; + import java.io.Serializable; + /** - * 问卷答复视图实体类 - * 用于后端返回给前端的问卷答复数据，通常包括关联表的数据或自定义字段。 - * 继承自 WenjuandafuEntity，实现 Serializable 接口以支持序列化。 + * 问卷答复 + * 后端返回视图实体辅助类 + * （通常后端关联的表或者自定义的字段需要返回使用） + * @author + * @email + * @date 2023-02-21 09:46:06 */ @TableName("wenjuandafu") -public class WenjuandafuView extends WenjuandafuEntity implements Serializable { - private static final long serialVersionUID = 1L; // 序列化版本号 - - // 无参构造函数 - public WenjuandafuView() { - } +public class WenjuandafuView extends WenjuandafuEntity implements Serializable { + private static final long serialVersionUID = 1L; - /** - * 带参构造函数，通过传入的 WenjuandafuEntity 对象来初始化 WenjuandafuView 对象。 - * @param wenjuandafuEntity 需要复制属性的 WenjuandafuEntity 实例 - */ - public WenjuandafuView(WenjuandafuEntity wenjuandafuEntity) { - try { - // 使用 BeanUtils 工具类将 wenjuandafuEntity 的属性值复制到当前对象中 - BeanUtils.copyProperties(this, wenjuandafuEntity); - } catch (IllegalAccessException | InvocationTargetException e) { - // 捕获并打印异常信息 - e.printStackTrace(); - } - } + public WenjuandafuView(){ + } + + public WenjuandafuView(WenjuandafuEntity wenjuandafuEntity){ + try { + BeanUtils.copyProperties(this, wenjuandafuEntity); + } catch (IllegalAccessException | InvocationTargetException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + } } diff --git a/src/main/java/com/service/ChatService.java b/src/main/java/com/service/ChatService.java index 646e9e8..acaa98d 100644 --- a/src/main/java/com/service/ChatService.java +++ b/src/main/java/com/service/ChatService.java @@ -10,62 +10,28 @@ import com.entity.vo.ChatVO; import org.apache.ibatis.annotations.Param; import com.entity.view.ChatView; + /** - * 在线咨询服务接口，提供对在线咨询相关数据的操作方法。 - * 继承自 IService，利用 MyBatis-Plus 提供的通用 CRUD 操作。 - * + * 在线咨询 + * * @author * @email * @date 2023-02-21 09:46:06 */ public interface ChatService extends IService { - /** - * 根据参数查询分页信息。 - * - * @param params 包含查询条件的参数集合。 - * @return 返回封装了分页信息的 PageUtils 对象。 - */ PageUtils queryPage(Map params); - /** - * 根据条件查询视图对象列表。 - * - * @param wrapper 查询条件包装器。 - * @return 返回符合条件的视图对象列表。 - */ - List selectListVO(Wrapper wrapper); - - /** - * 根据条件查询单个视图对象。 - * - * @param wrapper 查询条件包装器。 - * @return 返回符合条件的单个视图对象。 - */ - ChatVO selectVO(@Param("ew") Wrapper wrapper); - - /** - * 根据条件查询视图对象列表。 - * - * @param wrapper 查询条件包装器。 - * @return 返回符合条件的视图对象列表。 - */ - List selectListView(Wrapper wrapper); - - /** - * 根据条件查询单个视图对象。 - * - * @param wrapper 查询条件包装器。 - * @return 返回符合条件的单个视图对象。 - */ - ChatView selectView(@Param("ew") Wrapper wrapper); - - /** - * 根据参数和条件查询分页信息。 - * - * @param params 包含查询条件的参数集合。 - * @param wrapper 查询条件包装器。 - * @return 返回封装了分页信息的 PageUtils 对象。 - */ - PageUtils queryPage(Map params, Wrapper wrapper); + List selectListVO(Wrapper wrapper); + + ChatVO selectVO(@Param("ew") Wrapper wrapper); + + List selectListView(Wrapper wrapper); + + ChatView selectView(@Param("ew") Wrapper wrapper); + + PageUtils queryPage(Map params,Wrapper wrapper); + + } + diff --git a/src/main/java/com/service/CommonService.java b/src/main/java/com/service/CommonService.java index 248e8ac..1201b2a 100644 --- a/src/main/java/com/service/CommonService.java +++ b/src/main/java/com/service/CommonService.java @@ -3,63 +3,20 @@ package com.service; import java.util.List; import java.util.Map; -/** - * CommonService 接口定义了一组通用的服务方法，用于处理各种数据操作。 - */ public interface CommonService { - - /** - * 根据给定的参数获取选项列表。 - * @param params 包含查询条件的参数集合。 - * @return 返回一个字符串列表，表示选项。 - */ - List getOption(Map params); - - /** - * 根据给定的参数获取关注信息。 - * @param params 包含查询条件的参数集合。 - * @return 返回一个包含关注信息的映射。 - */ - Map getFollowByOption(Map params); - - /** - * 执行某种操作（具体操作未明确）。 - * @param params 包含操作所需参数的映射。 - */ - void sh(Map params); - - /** - * 计算提醒的数量。 - * @param params 包含查询条件的参数集合。 - * @return 返回提醒的数量。 - */ - int remindCount(Map params); - - /** - * 根据给定的参数选择并计算某些值。 - * @param params 包含查询条件的参数集合。 - * @return 返回一个包含计算结果的映射。 - */ - Map selectCal(Map params); - - /** - * 根据给定的参数选择分组信息。 - * @param params 包含查询条件的参数集合。 - * @return 返回一个包含分组信息的列表，每个元素是一个映射。 - */ - List> selectGroup(Map params); - - /** - * 根据给定的参数选择值信息。 - * @param params 包含查询条件的参数集合。 - * @return 返回一个包含值信息的列表，每个元素是一个映射。 - */ - List> selectValue(Map params); - - /** - * 根据给定的参数选择时间统计值信息。 - * @param params 包含查询条件的参数集合。 - * @return 返回一个包含时间统计值信息的列表，每个元素是一个映射。 - */ - List> selectTimeStatValue(Map params); + List getOption(Map params); + + Map getFollowByOption(Map params); + + void sh(Map params); + + int remindCount(Map params); + + Map selectCal(Map params); + + List> selectGroup(Map params); + + List> selectValue(Map params); + + List> selectTimeStatValue(Map params); } diff --git a/src/main/java/com/service/WenjuandafuService.java b/src/main/java/com/service/WenjuandafuService.java index 602f147..709265b 100644 --- a/src/main/java/com/service/WenjuandafuService.java +++ b/src/main/java/com/service/WenjuandafuService.java @@ -10,81 +10,36 @@ import com.entity.vo.WenjuandafuVO; import org.apache.ibatis.annotations.Param; import com.entity.view.WenjuandafuView; + /** - * 问卷答复服务接口 - * 提供问卷答复相关的业务逻辑处理 - * 继承自 IService，使用 MyBatis-Plus 框架的通用 CRUD 方法 - * + * 问卷答复 + * * @author * @email * @date 2023-02-21 09:46:06 */ public interface WenjuandafuService extends IService { - /** - * 分页查询问卷答复数据 - * @param params 查询参数 - * @return 分页结果封装在 PageUtils 对象中 - */ PageUtils queryPage(Map params); - /** - * 根据条件查询问卷答复的视图列表 - * @param wrapper 查询条件封装器 - * @return 符合条件的问卷答复视图列表 - */ - List selectListVO(Wrapper wrapper); - - /** - * 根据条件查询单个问卷答复的视图 - * @param wrapper 查询条件封装器 - * @return 符合条件的单个问卷答复视图 - */ - WenjuandafuVO selectVO(@Param("ew") Wrapper wrapper); - - /** - * 根据条件查询问卷答复的视图列表（分页） - * @param wrapper 查询条件封装器 - * @return 符合条件的问卷答复视图列表（分页） - */ - List selectListView(Wrapper wrapper); - - /** - * 根据条件查询单个问卷答复的视图（分页） - * @param wrapper 查询条件封装器 - * @return 符合条件的单个问卷答复视图（分页） - */ - WenjuandafuView selectView(@Param("ew") Wrapper wrapper); - - /** - * 分页查询问卷答复数据，带查询条件封装器 - * @param params 查询参数 - * @param wrapper 查询条件封装器 - * @return 分页结果封装在 PageUtils 对象中 - */ - PageUtils queryPage(Map params, Wrapper wrapper); - - /** - * 根据查询参数和条件封装器获取值统计结果 - * @param params 查询参数 - * @param wrapper 查询条件封装器 - * @return 值统计结果列表 - */ - List> selectValue(Map params, Wrapper wrapper); - - /** - * 根据查询参数和条件封装器获取时间统计值结果 - * @param params 查询参数 - * @param wrapper 查询条件封装器 - * @return 时间统计值结果列表 - */ - List> selectTimeStatValue(Map params, Wrapper wrapper); + List selectListVO(Wrapper wrapper); + + WenjuandafuVO selectVO(@Param("ew") Wrapper wrapper); + + List selectListView(Wrapper wrapper); + + WenjuandafuView selectView(@Param("ew") Wrapper wrapper); + + PageUtils queryPage(Map params,Wrapper wrapper); + + + List> selectValue(Map params,Wrapper wrapper); + + List> selectTimeStatValue(Map params,Wrapper wrapper); - /** - * 根据查询参数和条件封装器获取分组统计结果 - * @param params 查询参数 - * @param wrapper 查询条件封装器 - * @return 分组统计结果列表 - */ - List> selectGroup(Map params, Wrapper wrapper); + List> selectGroup(Map params,Wrapper wrapper); + + + } + diff --git a/src/main/java/com/service/YonghuService.java b/src/main/java/com/service/YonghuService.java index ec6462a..4068afd 100644 --- a/src/main/java/com/service/YonghuService.java +++ b/src/main/java/com/service/YonghuService.java @@ -10,90 +10,36 @@ import com.entity.vo.YonghuVO; import org.apache.ibatis.annotations.Param; import com.entity.view.YonghuView; + /** - * 用户服务接口，定义了对用户实体进行操作的方法。 - * 继承自 IService，提供基本的 CRUD 操作。 - * 包含分页查询、条件查询、视图对象查询等方法。 - * + * 用户 + * * @author * @email * @date 2023-02-21 09:46:06 */ public interface YonghuService extends IService { - /** - * 根据参数查询分页信息。 - * - * @param params 包含查询条件的参数集合。 - * @return 返回封装了分页信息的 PageUtils 对象。 - */ PageUtils queryPage(Map params); - /** - * 根据条件查询视图对象列表。 - * - * @param wrapper 查询条件包装器。 - * @return 返回符合条件的视图对象列表。 - */ - List selectListVO(Wrapper wrapper); - - /** - * 根据条件查询单个视图对象。 - * - * @param wrapper 查询条件包装器。 - * @return 返回符合条件的单个视图对象。 - */ - YonghuVO selectVO(@Param("ew") Wrapper wrapper); - - /** - * 根据条件查询视图对象列表。 - * - * @param wrapper 查询条件包装器。 - * @return 返回符合条件的视图对象列表。 - */ - List selectListView(Wrapper wrapper); - - /** - * 根据条件查询单个视图对象。 - * - * @param wrapper 查询条件包装器。 - * @return 返回符合条件的单个视图对象。 - */ - YonghuView selectView(@Param("ew") Wrapper wrapper); - - /** - * 根据参数和条件查询分页信息。 - * - * @param params 包含查询条件的参数集合。 - * @param wrapper 查询条件包装器。 - * @return 返回封装了分页信息的 PageUtils 对象。 - */ - PageUtils queryPage(Map params, Wrapper wrapper); - - /** - * 根据参数和条件选择值信息。 - * - * @param params 包含查询条件的参数集合。 - * @param wrapper 查询条件包装器。 - * @return 返回一个包含值信息的列表，每个元素是一个映射。 - */ - List> selectValue(Map params, Wrapper wrapper); - - /** - * 根据参数和条件选择时间统计值信息。 - * - * @param params 包含查询条件的参数集合。 - * @param wrapper 查询条件包装器。 - * @return 返回一个包含时间统计值信息的列表，每个元素是一个映射。 - */ - List> selectTimeStatValue(Map params, Wrapper wrapper); + List selectListVO(Wrapper wrapper); + + YonghuVO selectVO(@Param("ew") Wrapper wrapper); + + List selectListView(Wrapper wrapper); + + YonghuView selectView(@Param("ew") Wrapper wrapper); + + PageUtils queryPage(Map params,Wrapper wrapper); + + + List> selectValue(Map params,Wrapper wrapper); + + List> selectTimeStatValue(Map params,Wrapper wrapper); - /** - * 根据参数和条件选择分组信息。 - * - * @param params 包含查询条件的参数集合。 - * @param wrapper 查询条件包装器。 - * @return 返回一个包含分组信息的列表，每个元素是一个映射。 - */ - List> selectGroup(Map params, Wrapper wrapper); + List> selectGroup(Map params,Wrapper wrapper); + + + } + diff --git a/src/main/java/com/service/impl/ChatServiceImpl.java b/src/main/java/com/service/impl/ChatServiceImpl.java index 50c3332..99d0703 100644 --- a/src/main/java/com/service/impl/ChatServiceImpl.java +++ b/src/main/java/com/service/impl/ChatServiceImpl.java @@ -11,6 +11,7 @@ import com.baomidou.mybatisplus.service.impl.ServiceImpl; import com.utils.PageUtils; import com.utils.Query; + import com.dao.ChatDao; import com.entity.ChatEntity; import com.service.ChatService; @@ -20,81 +21,43 @@ import com.entity.view.ChatView; @Service("chatService") public class ChatServiceImpl extends ServiceImpl implements ChatService { - /** - * 分页查询方法，返回分页后的ChatEntity数据。 - * @param params 包含分页参数的Map对象 - * @return 封装了分页信息的PageUtils对象 - */ + @Override public PageUtils queryPage(Map params) { - // 使用Query类获取分页信息，并调用selectPage方法进行数据库查询 Page page = this.selectPage( new Query(params).getPage(), new EntityWrapper() ); - // 将查询结果封装到PageUtils对象中并返回 return new PageUtils(page); } - /** - * 分页查询方法，返回分页后的ChatView数据。 - * @param params 包含分页参数的Map对象 - * @param wrapper 查询条件包装器 - * @return 封装了分页信息的PageUtils对象 - */ - // 使用Query类获取分页信息，调用自定义的selectListView方法进行数据库查询，并将结果设置到page对象中 - @Override - public PageUtils queryPage(Map params, Wrapper wrapper) { - - Page page = new Query(params).getPage(); - - page.setRecords(baseMapper.selectListView(page, wrapper)); - // 将查询结果封装到PageUtils对象中并返回 - PageUtils pageUtil = new PageUtils(page); - return pageUtil; - } - - /** - * 根据条件查询ChatVO列表。 - * @param wrapper 查询条件包装器 - * @return 符合条件的ChatVO列表 - */ - @Override - public List selectListVO(Wrapper wrapper) { - // 调用自定义的selectListVO方法进行数据库查询并返回结果 - return baseMapper.selectListVO(wrapper); - } - - /** - * 根据条件查询单个ChatVO对象。 - * @param wrapper 查询条件包装器 - * @return 符合条件的单个ChatVO对象 - */ @Override - public ChatVO selectVO(Wrapper wrapper) { - // 调用自定义的selectVO方法进行数据库查询并返回结果 - return baseMapper.selectVO(wrapper); - } + public PageUtils queryPage(Map params, Wrapper wrapper) { + Page page =new Query(params).getPage(); + page.setRecords(baseMapper.selectListView(page,wrapper)); + PageUtils pageUtil = new PageUtils(page); + return pageUtil; + } - /** - * @param wrapper 查询条件包装器 - * @return 符合条件的ChatView列表 - */ - // 调用自定义的selectListView方法进行数据库查询并返回结果 @Override - public List selectListView(Wrapper wrapper) { - - return baseMapper.selectListView(wrapper); - } + public List selectListVO(Wrapper wrapper) { + return baseMapper.selectListVO(wrapper); + } + + @Override + public ChatVO selectVO(Wrapper wrapper) { + return baseMapper.selectVO(wrapper); + } + + @Override + public List selectListView(Wrapper wrapper) { + return baseMapper.selectListView(wrapper); + } + + @Override + public ChatView selectView(Wrapper wrapper) { + return baseMapper.selectView(wrapper); + } + - /** - * 根据条件查询单个ChatView对象。 - * @param wrapper 查询条件包装器 - * @return 符合条件的单个ChatView对象 - */ - @Override - public ChatView selectView(Wrapper wrapper) { - // 调用自定义的selectView方法进行数据库查询并返回结果 - return baseMapper.selectView(wrapper); - } } diff --git a/src/main/java/com/service/impl/CommonServiceImpl.java b/src/main/java/com/service/impl/CommonServiceImpl.java index 77a2521..14fb053 100644 --- a/src/main/java/com/service/impl/CommonServiceImpl.java +++ b/src/main/java/com/service/impl/CommonServiceImpl.java @@ -1,5 +1,7 @@ + package com.service.impl; + import java.util.List; import java.util.Map; @@ -9,53 +11,54 @@ import org.springframework.stereotype.Service; import com.dao.CommonDao; import com.service.CommonService; + /** - * 系统用户服务实现类 + * 系统用户 */ @Service("commonService") public class CommonServiceImpl implements CommonService { @Autowired - private CommonDao commonDao; // 自动注入数据访问对象 + private CommonDao commonDao; @Override public List getOption(Map params) { - return commonDao.getOption(params); // 获取选项列表 + return commonDao.getOption(params); } @Override public Map getFollowByOption(Map params) { - return commonDao.getFollowByOption(params); // 根据选项获取关注信息 + return commonDao.getFollowByOption(params); } @Override public void sh(Map params) { - commonDao.sh(params); // 执行某种操作（具体操作未明） + commonDao.sh(params); } @Override public int remindCount(Map params) { - return commonDao.remindCount(params); // 获取提醒数量 + return commonDao.remindCount(params); } @Override public Map selectCal(Map params) { - return commonDao.selectCal(params); // 选择并计算某些值 + return commonDao.selectCal(params); } @Override public List> selectGroup(Map params) { - return commonDao.selectGroup(params); // 按组选择数据 + return commonDao.selectGroup(params); } @Override public List> selectValue(Map params) { - return commonDao.selectValue(params); // 选择特定值 + return commonDao.selectValue(params); } @Override public List> selectTimeStatValue(Map params) { - return commonDao.selectTimeStatValue(params); // 选择并统计时间相关的值 + return commonDao.selectTimeStatValue(params); } } diff --git a/src/main/java/com/service/impl/WenjuandafuServiceImpl.java b/src/main/java/com/service/impl/WenjuandafuServiceImpl.java index 413a3c3..4f9d386 100644 --- a/src/main/java/com/service/impl/WenjuandafuServiceImpl.java +++ b/src/main/java/com/service/impl/WenjuandafuServiceImpl.java @@ -11,6 +11,7 @@ import com.baomidou.mybatisplus.service.impl.ServiceImpl; import com.utils.PageUtils; import com.utils.Query; + import com.dao.WenjuandafuDao; import com.entity.WenjuandafuEntity; import com.service.WenjuandafuService; @@ -20,11 +21,7 @@ import com.entity.view.WenjuandafuView; @Service("wenjuandafuService") public class WenjuandafuServiceImpl extends ServiceImpl implements WenjuandafuService { - /** - * 分页查询问卷答复数据 - * @param params 查询参数 - * @return 分页结果封装在 PageUtils 对象中 - */ + @Override public PageUtils queryPage(Map params) { Page page = this.selectPage( @@ -34,90 +31,50 @@ public class WenjuandafuServiceImpl extends ServiceImpl params, Wrapper wrapper) { - Page page = new Query(params).getPage(); - page.setRecords(baseMapper.selectListView(page, wrapper)); - PageUtils pageUtil = new PageUtils(page); - return pageUtil; - } - - /** - * 根据条件查询问卷答复的视图列表 - * @param wrapper 查询条件封装器 - * @return 符合条件的问卷答复视图列表 - */ - @Override - public List selectListVO(Wrapper wrapper) { - return baseMapper.selectListVO(wrapper); - } - - /** - * 根据条件查询单个问卷答复的视图 - * @param wrapper 查询条件封装器 - * @return 符合条件的单个问卷答复视图 - */ @Override - public WenjuandafuVO selectVO(Wrapper wrapper) { - return baseMapper.selectVO(wrapper); - } + public PageUtils queryPage(Map params, Wrapper wrapper) { + Page page =new Query(params).getPage(); + page.setRecords(baseMapper.selectListView(page,wrapper)); + PageUtils pageUtil = new PageUtils(page); + return pageUtil; + } - /** - * 根据条件查询问卷答复的视图列表（分页） - * @param wrapper 查询条件封装器 - * @return 符合条件的问卷答复视图列表（分页） - */ @Override - public List selectListView(Wrapper wrapper) { - return baseMapper.selectListView(wrapper); - } + public List selectListVO(Wrapper wrapper) { + return baseMapper.selectListVO(wrapper); + } + + @Override + public WenjuandafuVO selectVO(Wrapper wrapper) { + return baseMapper.selectVO(wrapper); + } + + @Override + public List selectListView(Wrapper wrapper) { + return baseMapper.selectListView(wrapper); + } - /** - * 根据条件查询单个问卷答复的视图（分页） - * @param wrapper 查询条件封装器 - * @return 符合条件的单个问卷答复视图（分页） - */ - @Override - public WenjuandafuView selectView(Wrapper wrapper) { - return baseMapper.selectView(wrapper); - } + @Override + public WenjuandafuView selectView(Wrapper wrapper) { + return baseMapper.selectView(wrapper); + } - /** - * 根据查询参数和条件封装器获取值统计结果 - * @param params 查询参数 - * @param wrapper 查询条件封装器 - * @return 值统计结果列表 - */ @Override public List> selectValue(Map params, Wrapper wrapper) { return baseMapper.selectValue(params, wrapper); } - /** - * 根据查询参数和条件封装器获取时间统计值结果 - * @param params 查询参数 - * @param wrapper 查询条件封装器 - * @return 时间统计值结果列表 - */ @Override public List> selectTimeStatValue(Map params, Wrapper wrapper) { return baseMapper.selectTimeStatValue(params, wrapper); } - /** - * 根据查询参数和条件封装器获取分组统计结果 - * @param params 查询参数 - * @param wrapper 查询条件封装器 - * @return 分组统计结果列表 - */ @Override public List> selectGroup(Map params, Wrapper wrapper) { return baseMapper.selectGroup(params, wrapper); } -} \ No newline at end of file + + + + +} diff --git a/src/main/java/com/service/impl/YonghuServiceImpl.java b/src/main/java/com/service/impl/YonghuServiceImpl.java index e2ea8f0..a034d37 100644 --- a/src/main/java/com/service/impl/YonghuServiceImpl.java +++ b/src/main/java/com/service/impl/YonghuServiceImpl.java @@ -11,6 +11,7 @@ import com.baomidou.mybatisplus.service.impl.ServiceImpl; import com.utils.PageUtils; import com.utils.Query; + import com.dao.YonghuDao; import com.entity.YonghuEntity; import com.service.YonghuService; @@ -20,7 +21,7 @@ import com.entity.view.YonghuView; @Service("yonghuService") public class YonghuServiceImpl extends ServiceImpl implements YonghuService { - // 分页查询用户信息 + @Override public PageUtils queryPage(Map params) { Page page = this.selectPage( @@ -30,54 +31,50 @@ public class YonghuServiceImpl extends ServiceImpl impl return new PageUtils(page); } - // 分页查询用户视图信息 - @Override - public PageUtils queryPage(Map params, Wrapper wrapper) { - Page page = new Query(params).getPage(); - page.setRecords(baseMapper.selectListView(page, wrapper)); - PageUtils pageUtil = new PageUtils(page); - return pageUtil; - } - - // 查询用户值对象列表 - @Override - public List selectListVO(Wrapper wrapper) { - return baseMapper.selectListVO(wrapper); - } - - // 查询单个用户值对象 @Override - public YonghuVO selectVO(Wrapper wrapper) { - return baseMapper.selectVO(wrapper); - } + public PageUtils queryPage(Map params, Wrapper wrapper) { + Page page =new Query(params).getPage(); + page.setRecords(baseMapper.selectListView(page,wrapper)); + PageUtils pageUtil = new PageUtils(page); + return pageUtil; + } - // 查询用户视图列表 @Override - public List selectListView(Wrapper wrapper) { - return baseMapper.selectListView(wrapper); - } + public List selectListVO(Wrapper wrapper) { + return baseMapper.selectListVO(wrapper); + } + + @Override + public YonghuVO selectVO(Wrapper wrapper) { + return baseMapper.selectVO(wrapper); + } + + @Override + public List selectListView(Wrapper wrapper) { + return baseMapper.selectListView(wrapper); + } - // 查询单个用户视图 - @Override - public YonghuView selectView(Wrapper wrapper) { - return baseMapper.selectView(wrapper); - } + @Override + public YonghuView selectView(Wrapper wrapper) { + return baseMapper.selectView(wrapper); + } - // 根据条件查询特定值 @Override public List> selectValue(Map params, Wrapper wrapper) { return baseMapper.selectValue(params, wrapper); } - // 根据条件查询时间统计值 @Override public List> selectTimeStatValue(Map params, Wrapper wrapper) { return baseMapper.selectTimeStatValue(params, wrapper); } - // 根据条件分组查询数据 @Override public List> selectGroup(Map params, Wrapper wrapper) { return baseMapper.selectGroup(params, wrapper); } + + + + } diff --git a/src/main/java/com/utils/BaiduUtil.java b/src/main/java/com/utils/BaiduUtil.java index ee0efde..f0f5430 100644 --- a/src/main/java/com/utils/BaiduUtil.java +++ b/src/main/java/com/utils/BaiduUtil.java @@ -135,11 +135,11 @@ public class BaiduUtil { if(jsonObject == null){ return ""; } - // 检查 JSON 对象中是否包含 "words_result" 和 "words_result_num" 键 + if(jsonObject.has("words_result") && jsonObject.has("words_result_num")){ int wordsResultNum = jsonObject.getInt("words_result_num"); if(wordsResultNum > 0){ - StringBuilder sb = new StringBuilder();// 用于拼接字符串 + StringBuilder sb = new StringBuilder(); JSONArray jsonArray = jsonObject.getJSONArray("words_result"); int len = jsonArray.length(); diff --git a/src/main/java/com/utils/FileUtil.java b/src/main/java/com/utils/FileUtil.java index d54b912..d581324 100644 --- a/src/main/java/com/utils/FileUtil.java +++ b/src/main/java/com/utils/FileUtil.java @@ -7,27 +7,21 @@ import java.io.IOException; import java.io.InputStream; /** - * 类说明 : FileUtil 是一个工具类，用于处理文件相关的操作。 - */ +* 类说明 : +*/ + public class FileUtil { - /** - * 将文件转换为字节数组。 - * @param file 要转换的文件对象。 - * @return 返回文件内容的字节数组。 - * @throws IOException 如果读取文件时发生错误。 - */ - public static byte[] FileToByte(File file) throws IOException { - // 使用 try-with-resources 语句确保 InputStream 被正确关闭 - try (InputStream content = new FileInputStream(file)) { - ByteArrayOutputStream swapStream = new ByteArrayOutputStream(); - byte[] buff = new byte[100]; // 缓冲区大小为100字节 - int rc; // 读取的字节数 - while ((rc = content.read(buff, 0, 100)) > 0) { - swapStream.write(buff, 0, rc); // 将读取的数据写入 ByteArrayOutputStream - } - // 获得二进制数组 - return swapStream.toByteArray(); - } - } + public static byte[] FileToByte(File file) throws IOException { + // 将数据转为流 + @SuppressWarnings("resource") + InputStream content = new FileInputStream(file); + ByteArrayOutputStream swapStream = new ByteArrayOutputStream(); + byte[] buff = new byte[100]; + int rc = 0; + while ((rc = content.read(buff, 0, 100)) > 0) { + swapStream.write(buff, 0, rc); + } + // 获得二进制数组 + return swapStream.toByteArray(); + } } - diff --git a/src/main/java/com/utils/HttpClientUtils.java b/src/main/java/com/utils/HttpClientUtils.java index 6200451..fd6aae5 100644 --- a/src/main/java/com/utils/HttpClientUtils.java +++ b/src/main/java/com/utils/HttpClientUtils.java @@ -5,45 +5,38 @@ import java.io.InputStreamReader; import java.net.HttpURLConnection; import java.net.URL; + /** * HttpClient工具类 */ public class HttpClientUtils { /** - * 发送GET请求并返回响应内容 - * @param uri 请求的URL地址 - * @return 响应内容的字符串形式 - * @description 使用GET方法发送HTTP请求 + * @param uri + * @return String + * @description get请求方式 * @author: long.he01 */ public static String doGet(String uri) { - // 用于存储响应结果的StringBuilder对象 + StringBuilder result = new StringBuilder(); try { - // 初始化一个空字符串用于存储每一行读取的内容 String res = ""; - // 创建URL对象 URL url = new URL(uri); - // 打开连接 HttpURLConnection conn = (HttpURLConnection) url.openConnection(); - // 设置请求方法为GET - conn.setRequestMethod("GET"); - // 获取输入流并包装成BufferedReader BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8")); String line; - // 逐行读取响应内容 while ((line = in.readLine()) != null) { - res += line + "\n"; - // 关闭BufferedReader + res += line+"\n"; + } in.close(); - // 返回完整的响应内容 return res; - } catch (Exception e) { - // 捕获异常并打印堆栈信息 + }catch (Exception e) { e.printStackTrace(); - return null; } + } + } + diff --git a/src/main/java/com/utils/JQPageInfo.java b/src/main/java/com/utils/JQPageInfo.java index 05113f3..af075a4 100644 --- a/src/main/java/com/utils/JQPageInfo.java +++ b/src/main/java/com/utils/JQPageInfo.java @@ -1,68 +1,54 @@ package com.utils; -public class JQPageInfo { - // 当前页码 - private Integer page; - - // 每页显示的记录数 - private Integer limit; - - // 排序字段 - private String sidx; - - // 排序方式（升序或降序） - private String order; - - // 偏移量，用于计算分页查询时的起始位置 - private Integer offset; - - // 获取当前页码 - public Integer getPage() { - return page; - } - - // 设置当前页码 - public void setPage(Integer page) { - this.page = page; - } - - // 获取每页显示的记录数 - public Integer getLimit() { - return limit; - } - - // 设置每页显示的记录数 - public void setLimit(Integer limit) { - this.limit = limit; - } - - // 获取排序字段 - public String getSidx() { - return sidx; - } - - // 设置排序字段 - public void setSidx(String sidx) { - this.sidx = sidx; - } - - // 获取排序方式 - public String getOrder() { - return order; - } - - // 设置排序方式 - public void setOrder(String order) { - this.order = order; - } - - // 获取偏移量 - public Integer getOffset() { - return offset; - } - - // 设置偏移量 - public void setOffset(Integer offset) { - this.offset = offset; - } +public class JQPageInfo{ + private Integer page; + + private Integer limit; + + private String sidx; + + private String order; + + private Integer offset; + + public Integer getPage() { + return page; + } + + public void setPage(Integer page) { + this.page = page; + } + + public Integer getLimit() { + return limit; + } + + public void setLimit(Integer limit) { + this.limit = limit; + } + + public String getSidx() { + return sidx; + } + + public void setSidx(String sidx) { + this.sidx = sidx; + } + + public String getOrder() { + return order; + } + + public void setOrder(String order) { + this.order = order; + } + + public Integer getOffset() { + return offset; + } + + public void setOffset(Integer offset) { + this.offset = offset; + } + } diff --git a/src/main/java/com/utils/MPUtil.java b/src/main/java/com/utils/MPUtil.java index 395cf61..e5d3916 100644 --- a/src/main/java/com/utils/MPUtil.java +++ b/src/main/java/com/utils/MPUtil.java @@ -15,167 +15,170 @@ import com.baomidou.mybatisplus.mapper.Wrapper; * Mybatis-Plus工具类 */ public class MPUtil { - public static final char UNDERLINE = '_'; - - // mybatis plus allEQ 表达式转换，带前缀 - public static Map allEQMapPre(Object bean, String pre) { - Map map = BeanUtil.beanToMap(bean); - return camelToUnderlineMap(map, pre); - } - - // mybatis plus allEQ 表达式转换，不带前缀 - public static Map allEQMap(Object bean) { - Map map = BeanUtil.beanToMap(bean); - return camelToUnderlineMap(map, ""); - } - - // mybatis plus allLike 表达式转换，带前缀 - public static Wrapper allLikePre(Wrapper wrapper, Object bean, String pre) { - Map map = BeanUtil.beanToMap(bean); - Map result = camelToUnderlineMap(map, pre); - return genLike(wrapper, result); - } - - // mybatis plus allLike 表达式转换，不带前缀 - public static Wrapper allLike(Wrapper wrapper, Object bean) { - Map result = BeanUtil.beanToMap(bean, true, true); - return genLike(wrapper, result); - } - - // 生成LIKE查询条件 - public static Wrapper genLike(Wrapper wrapper, Map param) { - Iterator> it = param.entrySet().iterator(); - int i = 0; - while (it.hasNext()) { - if (i > 0) wrapper.and(); - Map.Entry entry = it.next(); - String key = entry.getKey(); - String value = (String) entry.getValue(); - wrapper.like(key, value); - i++; - } - return wrapper; - } - - // 生成LIKE或EQ查询条件 - public static Wrapper likeOrEq(Wrapper wrapper, Object bean) { - Map result = BeanUtil.beanToMap(bean, true, true); - return genLikeOrEq(wrapper, result); - } - - // 生成LIKE或EQ查询条件的具体实现 - public static Wrapper genLikeOrEq(Wrapper wrapper, Map param) { - Iterator> it = param.entrySet().iterator(); - int i = 0; - while (it.hasNext()) { - if (i > 0) wrapper.and(); - Map.Entry entry = it.next(); - String key = entry.getKey(); - if (entry.getValue().toString().contains("%")) { - wrapper.like(key, entry.getValue().toString().replace("%", "")); - } else { - wrapper.eq(key, entry.getValue()); - } - i++; - } - return wrapper; - } - - // 生成EQ查询条件 - public static Wrapper allEq(Wrapper wrapper, Object bean) { - Map result = BeanUtil.beanToMap(bean, true, true); - return genEq(wrapper, result); - } - - // 生成EQ查询条件的具体实现 - public static Wrapper genEq(Wrapper wrapper, Map param) { - Iterator> it = param.entrySet().iterator(); - int i = 0; - while (it.hasNext()) { - if (i > 0) wrapper.and(); - Map.Entry entry = it.next(); - String key = entry.getKey(); - wrapper.eq(key, entry.getValue()); - i++; - } - return wrapper; - } - - // 生成BETWEEN查询条件 - public static Wrapper between(Wrapper wrapper, Map params) { - for (String key : params.keySet()) { - String columnName = ""; - if (key.endsWith("_start")) { - columnName = key.substring(0, key.indexOf("_start")); - if (StringUtils.isNotBlank(params.get(key).toString())) { - wrapper.ge(columnName, params.get(key)); - } - } - if (key.endsWith("_end")) { - columnName = key.substring(0, key.indexOf("_end")); - if (StringUtils.isNotBlank(params.get(key).toString())) { - wrapper.le(columnName, params.get(key)); - } - } - } - return wrapper; - } - - // 生成排序查询条件 - public static Wrapper sort(Wrapper wrapper, Map params) { - String order = ""; - if (params.get("order") != null && StringUtils.isNotBlank(params.get("order").toString())) { - order = params.get("order").toString(); - } - if (params.get("sort") != null && StringUtils.isNotBlank(params.get("sort").toString())) { - if (order.equalsIgnoreCase("desc")) { - wrapper.orderDesc(Arrays.asList(params.get("sort"))); - } else { - wrapper.orderAsc(Arrays.asList(params.get("sort"))); - } - } - return wrapper; - } - - // 驼峰格式字符串转换为下划线格式字符串 - public static String camelToUnderline(String param) { - if (param == null || "".equals(param.trim())) { - return ""; - } - int len = param.length(); - StringBuilder sb = new StringBuilder(len); - for (int i = 0; i < len; i++) { - char c = param.charAt(i); - if (Character.isUpperCase(c)) { - sb.append(UNDERLINE); - sb.append(Character.toLowerCase(c)); - } else { - sb.append(c); - } - } - return sb.toString(); - } - - public static void main(String[] ages) { - System.out.println(camelToUnderline("ABCddfANM")); // 输出：a_b_cddf_anm - } - - // 将驼峰格式的Map键转换为下划线格式，并添加前缀（如果有） - public static Map camelToUnderlineMap(Map param, String pre) { - Map newMap = new HashMap<>(); - Iterator> it = param.entrySet().iterator(); - while (it.hasNext()) { - Map.Entry entry = it.next(); - String key = entry.getKey(); - String newKey = camelToUnderline(key); - if (pre.endsWith(".")) { - newMap.put(pre + newKey, entry.getValue()); - } else if (StringUtils.isEmpty(pre)) { - newMap.put(newKey, entry.getValue()); - } else { - newMap.put(pre + "." + newKey, entry.getValue()); - } - } - return newMap; - } + public static final char UNDERLINE = '_'; + + + //mybatis plus allEQ 表达式转换 + public static Map allEQMapPre(Object bean,String pre) { + Map map =BeanUtil.beanToMap(bean); + return camelToUnderlineMap(map,pre); + } + + //mybatis plus allEQ 表达式转换 + public static Map allEQMap(Object bean) { + Map map =BeanUtil.beanToMap(bean); + return camelToUnderlineMap(map,""); + } + + public static Wrapper allLikePre(Wrapper wrapper,Object bean,String pre) { + Map map =BeanUtil.beanToMap(bean); + Map result = camelToUnderlineMap(map,pre); + + return genLike(wrapper,result); + } + + public static Wrapper allLike(Wrapper wrapper,Object bean) { + Map result = BeanUtil.beanToMap(bean, true, true); + return genLike(wrapper,result); + } + + + public static Wrapper genLike( Wrapper wrapper,Map param) { + Iterator> it = param.entrySet().iterator(); + int i=0; + while (it.hasNext()) { + if(i>0) wrapper.and(); + Map.Entry entry = it.next(); + String key = entry.getKey(); + String value = (String) entry.getValue(); + wrapper.like(key, value); + i++; + } + return wrapper; + } + + public static Wrapper likeOrEq(Wrapper wrapper,Object bean) { + Map result = BeanUtil.beanToMap(bean, true, true); + return genLikeOrEq(wrapper,result); + } + + public static Wrapper genLikeOrEq( Wrapper wrapper,Map param) { + Iterator> it = param.entrySet().iterator(); + int i=0; + while (it.hasNext()) { + if(i>0) wrapper.and(); + Map.Entry entry = it.next(); + String key = entry.getKey(); + if(entry.getValue().toString().contains("%")) { + wrapper.like(key, entry.getValue().toString().replace("%", "")); + } else { + wrapper.eq(key, entry.getValue()); + } + i++; + } + return wrapper; + } + + public static Wrapper allEq(Wrapper wrapper,Object bean) { + Map result = BeanUtil.beanToMap(bean, true, true); + return genEq(wrapper,result); + } + + + public static Wrapper genEq( Wrapper wrapper,Map param) { + Iterator> it = param.entrySet().iterator(); + int i=0; + while (it.hasNext()) { + if(i>0) wrapper.and(); + Map.Entry entry = it.next(); + String key = entry.getKey(); + wrapper.eq(key, entry.getValue()); + i++; + } + return wrapper; + } + + + public static Wrapper between(Wrapper wrapper,Map params) { + for(String key : params.keySet()) { + String columnName = ""; + if(key.endsWith("_start")) { + columnName = key.substring(0, key.indexOf("_start")); + if(StringUtils.isNotBlank(params.get(key).toString())) { + wrapper.ge(columnName, params.get(key)); + } + } + if(key.endsWith("_end")) { + columnName = key.substring(0, key.indexOf("_end")); + if(StringUtils.isNotBlank(params.get(key).toString())) { + wrapper.le(columnName, params.get(key)); + } + } + } + return wrapper; + } + + public static Wrapper sort(Wrapper wrapper,Map params) { + String order = ""; + if(params.get("order") != null && StringUtils.isNotBlank(params.get("order").toString())) { + order = params.get("order").toString(); + } + if(params.get("sort") != null && StringUtils.isNotBlank(params.get("sort").toString())) { + if(order.equalsIgnoreCase("desc")) { + wrapper.orderDesc(Arrays.asList(params.get("sort"))); + } else { + wrapper.orderAsc(Arrays.asList(params.get("sort"))); + } + } + return wrapper; + } + + + /** + * 驼峰格式字符串转换为下划线格式字符串 + * + * @param param + * @return + */ + public static String camelToUnderline(String param) { + if (param == null || "".equals(param.trim())) { + return ""; + } + int len = param.length(); + StringBuilder sb = new StringBuilder(len); + for (int i = 0; i < len; i++) { + char c = param.charAt(i); + if (Character.isUpperCase(c)) { + sb.append(UNDERLINE); + sb.append(Character.toLowerCase(c)); + } else { + sb.append(c); + } + } + return sb.toString(); + } + + public static void main(String[] ages) { + System.out.println(camelToUnderline("ABCddfANM")); + } + + public static Map camelToUnderlineMap(Map param, String pre) { + + Map newMap = new HashMap(); + Iterator> it = param.entrySet().iterator(); + while (it.hasNext()) { + Map.Entry entry = it.next(); + String key = entry.getKey(); + String newKey = camelToUnderline(key); + if (pre.endsWith(".")) { + newMap.put(pre + newKey, entry.getValue()); + } else if (StringUtils.isEmpty(pre)) { + newMap.put(newKey, entry.getValue()); + } else { + + newMap.put(pre + "." + newKey, entry.getValue()); + } + } + return newMap; + } } diff --git a/src/main/java/com/utils/PageUtils.java b/src/main/java/com/utils/PageUtils.java index cd4f9d1..f7356bf 100644 --- a/src/main/java/com/utils/PageUtils.java +++ b/src/main/java/com/utils/PageUtils.java @@ -1,3 +1,4 @@ + package com.utils; import java.io.Serializable; @@ -7,23 +8,23 @@ import java.util.Map; import com.baomidou.mybatisplus.plugins.Page; /** - * 分页工具类，用于处理分页相关的数据和操作。 + * 分页工具类 */ public class PageUtils implements Serializable { - private static final long serialVersionUID = 1L; // 序列化版本号 - // 总记录数 + private static final long serialVersionUID = 1L; + //总记录数 private long total; - // 每页记录数 + //每页记录数 private int pageSize; - // 总页数 + //总页数 private long totalPage; - // 当前页数 + //当前页数 private int currPage; - // 列表数据 + //列表数据 private List list; /** - * 构造函数，通过传入的列表数据、总记录数、每页记录数和当前页数进行初始化。 + * 分页 * @param list 列表数据 * @param totalCount 总记录数 * @param pageSize 每页记录数 @@ -34,31 +35,29 @@ public class PageUtils implements Serializable { this.total = totalCount; this.pageSize = pageSize; this.currPage = currPage; - this.totalPage = (int)Math.ceil((double)totalCount/pageSize); // 计算总页数 + this.totalPage = (int)Math.ceil((double)totalCount/pageSize); } /** - * 构造函数，通过MyBatis Plus的Page对象进行初始化。 - * @param page MyBatis Plus的Page对象 + * 分页 */ public PageUtils(Page page) { - this.list = page.getRecords(); // 获取当前页的数据列表 - this.total = page.getTotal(); // 获取总记录数 - this.pageSize = page.getSize(); // 获取每页记录数 - this.currPage = page.getCurrent(); // 获取当前页码 - this.totalPage = page.getPages(); // 获取总页数 + this.list = page.getRecords(); + this.total = page.getTotal(); + this.pageSize = page.getSize(); + this.currPage = page.getCurrent(); + this.totalPage = page.getPages(); } - /** - * 构造函数，通过传入的参数Map进行初始化。 - * @param params 包含分页参数的Map对象 + /* + * 空数据的分页 */ public PageUtils(Map params) { - Page page =new Query(params).getPage(); // 根据参数创建Page对象 - new PageUtils(page); // 调用另一个构造函数进行初始化 + Page page =new Query(params).getPage(); + new PageUtils(page); } - // Getter和Setter方法 + public int getPageSize() { return pageSize; } @@ -98,4 +97,5 @@ public class PageUtils implements Serializable { public void setTotal(long total) { this.total = total; } + } diff --git a/src/main/java/com/utils/Query.java b/src/main/java/com/utils/Query.java index 882e8fb..eb624a7 100644 --- a/src/main/java/com/utils/Query.java +++ b/src/main/java/com/utils/Query.java @@ -1,3 +1,4 @@ + package com.utils; import java.util.LinkedHashMap; @@ -8,103 +9,89 @@ import org.apache.commons.lang3.StringUtils; import com.baomidou.mybatisplus.plugins.Page; /** - * 查询参数类，用于封装分页和排序信息 + * 查询参数 */ public class Query extends LinkedHashMap { - private static final long serialVersionUID = 1L; - - // mybatis-plus分页参数 + private static final long serialVersionUID = 1L; + /** + * mybatis-plus分页参数 + */ private Page page; - - // 当前页码 + /** + * 当前页码 + */ private int currPage = 1; - - // 每页条数 - private int limit = 10; - /** - * 构造函数，使用JQPageInfo对象初始化查询参数 - * @param pageInfo 包含分页和排序信息的JQPageInfo对象 + * 每页条数 */ + private int limit = 10; + public Query(JQPageInfo pageInfo) { - // 设置分页参数 - if (pageInfo.getPage() != null) { + //分页参数 + if(pageInfo.getPage()!= null){ currPage = pageInfo.getPage(); } - if (pageInfo.getLimit() != null) { + if(pageInfo.getLimit()!= null){ limit = pageInfo.getLimit(); } - // 防止SQL注入（因为sidx、order是通过拼接SQL实现排序的，会有SQL注入风险） + + //防止SQL注入（因为sidx、order是通过拼接SQL实现排序的，会有SQL注入风险） String sidx = SQLFilter.sqlInject(pageInfo.getSidx()); String order = SQLFilter.sqlInject(pageInfo.getOrder()); - // mybatis-plus分页 + + //mybatis-plus分页 this.page = new Page<>(currPage, limit); - // 设置排序字段和顺序 - if (StringUtils.isNotBlank(sidx) && StringUtils.isNotBlank(order)) { + //排序 + if(StringUtils.isNotBlank(sidx) && StringUtils.isNotBlank(order)){ this.page.setOrderByField(sidx); this.page.setAsc("ASC".equalsIgnoreCase(order)); } } - /** - * 构造函数，使用Map对象初始化查询参数 - * @param params 包含分页和排序信息的Map对象 - */ - public Query(Map params) { + + public Query(Map params){ this.putAll(params); - // 设置分页参数 - if (params.get("page") != null) { - currPage = Integer.parseInt((String) params.get("page")); + //分页参数 + if(params.get("page") != null){ + currPage = Integer.parseInt((String)params.get("page")); } - if (params.get("limit") != null) { - limit = Integer.parseInt((String) params.get("limit")); + if(params.get("limit") != null){ + limit = Integer.parseInt((String)params.get("limit")); } - // 计算偏移量并放入Map中 this.put("offset", (currPage - 1) * limit); this.put("page", currPage); this.put("limit", limit); - // 防止SQL注入（因为sidx、order是通过拼接SQL实现排序的，会有SQL注入风险） - String sidx = SQLFilter.sqlInject((String) params.get("sidx")); - String order = SQLFilter.sqlInject((String) params.get("order")); + //防止SQL注入（因为sidx、order是通过拼接SQL实现排序的，会有SQL注入风险） + String sidx = SQLFilter.sqlInject((String)params.get("sidx")); + String order = SQLFilter.sqlInject((String)params.get("order")); this.put("sidx", sidx); this.put("order", order); - // mybatis-plus分页 + //mybatis-plus分页 this.page = new Page<>(currPage, limit); - // 设置排序字段和顺序 - if (StringUtils.isNotBlank(sidx) && StringUtils.isNotBlank(order)) { + //排序 + if(StringUtils.isNotBlank(sidx) && StringUtils.isNotBlank(order)){ this.page.setOrderByField(sidx); this.page.setAsc("ASC".equalsIgnoreCase(order)); } + } - /** - * 获取mybatis-plus分页对象 - * @return mybatis-plus分页对象 - */ public Page getPage() { return page; } - /** - * 获取当前页码 - * @return 当前页码 - */ public int getCurrPage() { return currPage; } - /** - * 获取每页条数 - * @return 每页条数 - */ public int getLimit() { return limit; } diff --git a/src/main/java/com/utils/R.java b/src/main/java/com/utils/R.java index 6c87094..680b3f8 100644 --- a/src/main/java/com/utils/R.java +++ b/src/main/java/com/utils/R.java @@ -4,27 +4,23 @@ import java.util.HashMap; import java.util.Map; /** - * 返回数据类，用于封装API响应结果。 + * 返回数据 */ public class R extends HashMap { private static final long serialVersionUID = 1L; - // 默认构造函数，初始化code为0表示成功 public R() { put("code", 0); } - // 静态方法：返回一个错误响应，默认code为500，msg为"未知异常，请联系管理员" public static R error() { return error(500, "未知异常，请联系管理员"); } - // 静态方法：返回一个错误响应，code为500，msg为传入的参数msg public static R error(String msg) { return error(500, msg); } - // 静态方法：返回一个错误响应，code和msg由传入的参数指定 public static R error(int code, String msg) { R r = new R(); r.put("code", code); @@ -32,26 +28,22 @@ public class R extends HashMap { return r; } - // 静态方法：返回一个成功响应，msg为传入的参数msg public static R ok(String msg) { R r = new R(); r.put("msg", msg); return r; } - // 静态方法：返回一个成功响应，包含传入的map中的所有键值对 public static R ok(Map map) { R r = new R(); r.putAll(map); return r; } - // 静态方法：返回一个默认的成功响应（仅包含code） public static R ok() { return new R(); } - // 重写put方法，使其返回当前对象以支持链式调用 public R put(String key, Object value) { super.put(key, value); return this; diff --git a/src/main/java/com/utils/SpringContextUtils.java b/src/main/java/com/utils/SpringContextUtils.java index f55a235..fd3705b 100644 --- a/src/main/java/com/utils/SpringContextUtils.java +++ b/src/main/java/com/utils/SpringContextUtils.java @@ -6,67 +6,38 @@ import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.stereotype.Component; + /** - * Spring Context 工具类，用于获取Spring容器中的Bean。 + * Spring Context 工具类 */ @Component public class SpringContextUtils implements ApplicationContextAware { - // 静态变量，保存Spring应用上下文 - public static ApplicationContext applicationContext; - - /** - * 实现ApplicationContextAware接口的方法，设置Spring应用上下文。 - * @param applicationContext Spring应用上下文 - * @throws BeansException 如果设置上下文失败抛出异常 - */ - @Override - public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { - SpringContextUtils.applicationContext = applicationContext; - } - - /** - * 根据Bean名称获取Bean对象。 - * @param name Bean的名称 - * @return 返回对应的Bean对象 - */ - public static Object getBean(String name) { - return applicationContext.getBean(name); - } - - /** - * 根据Bean名称和类型获取Bean对象。 - * @param name Bean的名称 - * @param requiredType Bean的类型 - * @return 返回对应类型的Bean对象 - */ - public static T getBean(String name, Class requiredType) { - return applicationContext.getBean(name, requiredType); - } - - /** - * 检查Spring容器中是否包含指定名称的Bean。 - * @param name Bean的名称 - * @return 如果包含返回true，否则返回false - */ - public static boolean containsBean(String name) { - return applicationContext.containsBean(name); - } - - /** - * 检查指定名称的Bean是否是单例模式。 - * @param name Bean的名称 - * @return 如果是单例返回true，否则返回false - */ - public static boolean isSingleton(String name) { - return applicationContext.isSingleton(name); - } - - /** - * 获取指定名称的Bean的类型。 - * @param name Bean的名称 - * @return 返回Bean的类型 - */ - public static Class getType(String name) { - return applicationContext.getType(name); - } -} + public static ApplicationContext applicationContext; + + @Override + public void setApplicationContext(ApplicationContext applicationContext) + throws BeansException { + SpringContextUtils.applicationContext = applicationContext; + } + + public static Object getBean(String name) { + return applicationContext.getBean(name); + } + + public static T getBean(String name, Class requiredType) { + return applicationContext.getBean(name, requiredType); + } + + public static boolean containsBean(String name) { + return applicationContext.containsBean(name); + } + + public static boolean isSingleton(String name) { + return applicationContext.isSingleton(name); + } + + public static Class getType(String name) { + return applicationContext.getType(name); + } + +} \ No newline at end of file diff --git a/src/main/java/com/utils/ValidatorUtils.java b/src/main/java/com/utils/ValidatorUtils.java index 64fdeb6..06ed26c 100644 --- a/src/main/java/com/utils/ValidatorUtils.java +++ b/src/main/java/com/utils/ValidatorUtils.java @@ -1,19 +1,21 @@ + package com.utils; + import java.util.Set; + import javax.validation.ConstraintViolation; import javax.validation.Validation; import javax.validation.Validator; + import com.entity.EIException; /** * hibernate-validator校验工具类 */ public class ValidatorUtils { - // 静态变量，用于存储验证器实例 private static Validator validator; - // 在静态块中初始化验证器实例 static { validator = Validation.buildDefaultValidatorFactory().getValidator(); } @@ -24,15 +26,14 @@ public class ValidatorUtils { * @param groups 待校验的组 * @throws EIException 校验不通过，则报EIException异常 */ - public static void validateEntity(Object object, Class... groups) throws EIException { - // 执行校验操作，返回违反约束的集合 + public static void validateEntity(Object object, Class... groups) + throws EIException { Set> constraintViolations = validator.validate(object, groups); - // 如果存在违反约束的情况 if (!constraintViolations.isEmpty()) { - // 获取第一个违反约束的信息 - ConstraintViolation constraint = (ConstraintViolation)constraintViolations.iterator().next(); - // 抛出自定义异常，并传递错误信息 + ConstraintViolation constraint = (ConstraintViolation)constraintViolations.iterator().next(); throw new EIException(constraint.getMessage()); } } + + }