diff --git a/src/main/java/com/controller/ChatController.java b/src/main/java/com/controller/ChatController.java index 34f578e..c98ab5d 100644 --- a/src/main/java/com/controller/ChatController.java +++ b/src/main/java/com/controller/ChatController.java @@ -1,231 +1,346 @@ package com.controller; +// 导入用于格式化日期的类 import java.text.SimpleDateFormat; +// 导入ArrayList类，用于创建动态数组 import java.util.ArrayList; +// 导入Arrays类，提供操作数组的静态方法 import java.util.Arrays; +// 导入Calendar类，用于处理日期和时间 import java.util.Calendar; +// 导入Map接口，用于存储键值对 import java.util.Map; +// 导入HashMap类，实现了Map接口 import java.util.HashMap; +// 导入Iterator接口，用于遍历集合 import java.util.Iterator; +// 导入Date类，用于表示特定的瞬间 import java.util.Date; +// 导入List接口，用于存储有序的元素集合 import java.util.List; +// 导入HttpServletRequest类，用于获取客户端请求信息 import javax.servlet.http.HttpServletRequest; +// 导入自定义的验证工具类 import com.utils.ValidatorUtils; +// 导入Apache Commons Lang库中的StringUtils类，用于处理字符串 import org.apache.commons.lang3.StringUtils; +// 导入Spring框架的自动装配注解 import org.springframework.beans.factory.annotation.Autowired; +// 导入Spring框架的日期格式化注解 import org.springframework.format.annotation.DateTimeFormat; +// 导入Spring框架的路径变量注解 import org.springframework.web.bind.annotation.PathVariable; +// 导入Spring框架的请求体注解 import org.springframework.web.bind.annotation.RequestBody; +// 导入Spring框架的请求映射注解 import org.springframework.web.bind.annotation.RequestMapping; +// 导入Spring框架的请求参数注解 import org.springframework.web.bind.annotation.RequestParam; +// 导入Spring框架的REST控制器注解 import org.springframework.web.bind.annotation.RestController; +// 导入MyBatis-Plus的实体包装器类 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入MyBatis-Plus的包装器接口 import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的忽略认证注解 import com.annotation.IgnoreAuth; +// 导入Chat实体类 import com.entity.ChatEntity; +// 导入Chat视图类 import com.entity.view.ChatView; +// 导入Chat服务类 import com.service.ChatService; +// 导入Token服务类 import com.service.TokenService; +// 导入自定义的分页工具类 import com.utils.PageUtils; +// 导入自定义的响应结果类 import com.utils.R; +// 导入自定义的MD5工具类 import com.utils.MD5Util; +// 导入自定义的MyBatis-Plus工具类 import com.utils.MPUtil; +// 导入自定义的通用工具类 import com.utils.CommonUtil; /** * 客户服务 * 后端接口 - * @author - * @email + * @author + * @email * @date 2021-05-09 15:46:15 */ +// 声明为RESTful风格的控制器 @RestController +// 定义请求的基础路径 @RequestMapping("/chat") public class ChatController { - @Autowired - private ChatService chatService; - - - - /** - * 后端列表 - */ - @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 ew = new EntityWrapper(); + // 自动装配ChatService实例 + @Autowired + private ChatService chatService; + + + /** + * 后端列表 + */ + // 处理/page请求 + @RequestMapping("/page") + // 方法接收请求参数、Chat实体和HttpServletRequest对象 + public R page(@RequestParam Map params, ChatEntity chat, + HttpServletRequest request) { + // 如果当前用户不是管理员 + if (!request.getSession().getAttribute("role").toString().equals("管理员")) { + // 设置Chat实体的用户ID为当前用户ID + chat.setUserid((Long) request.getSession().getAttribute("userId")); + } + // 创建MyBatis-Plus的实体包装器 + EntityWrapper ew = new EntityWrapper(); + // 调用ChatService的queryPage方法进行分页查询 PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params)); + // 返回成功响应，并将分页数据放入响应中 + return R.ok().put("data", page); + } - return R.ok().put("data", page); - } - - /** - * 前端列表 - */ - @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 ew = new EntityWrapper(); + /** + * 前端列表 + */ + // 处理/list请求 + @RequestMapping("/list") + // 方法接收请求参数、Chat实体和HttpServletRequest对象 + public R list(@RequestParam Map params, ChatEntity chat, + HttpServletRequest request) { + // 如果当前用户不是管理员 + if (!request.getSession().getAttribute("role").toString().equals("管理员")) { + // 设置Chat实体的用户ID为当前用户ID + chat.setUserid((Long) request.getSession().getAttribute("userId")); + } + // 创建MyBatis-Plus的实体包装器 + EntityWrapper ew = new EntityWrapper(); + // 调用ChatService的queryPage方法进行分页查询 PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params)); - return R.ok().put("data", page); - } + // 返回成功响应，并将分页数据放入响应中 + return R.ok().put("data", page); + } + + /** + * 列表 + */ + // 处理/lists请求 + @RequestMapping("/lists") + // 方法接收Chat实体 + public R list(ChatEntity chat) { + // 创建MyBatis-Plus的实体包装器 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件，将Chat实体的属性作为查询条件 + ew.allEq(MPUtil.allEQMapPre(chat, "chat")); + // 调用ChatService的selectListView方法查询列表数据 + return R.ok().put("data", chatService.selectListView(ew)); + } /** - * 列表 - */ - @RequestMapping("/lists") - public R list( ChatEntity chat){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( chat, "chat")); - return R.ok().put("data", chatService.selectListView(ew)); - } - - /** - * 查询 - */ - @RequestMapping("/query") - public R query(ChatEntity chat){ - EntityWrapper< ChatEntity> ew = new EntityWrapper< ChatEntity>(); - ew.allEq(MPUtil.allEQMapPre( chat, "chat")); - ChatView chatView = chatService.selectView(ew); + * 查询 + */ + // 处理/query请求 + @RequestMapping("/query") + // 方法接收Chat实体 + public R query(ChatEntity chat) { + // 创建MyBatis-Plus的实体包装器 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件，将Chat实体的属性作为查询条件 + ew.allEq(MPUtil.allEQMapPre(chat, "chat")); + // 调用ChatService的selectView方法查询单个视图数据 + ChatView chatView = chatService.selectView(ew); + // 返回成功响应，并将查询结果放入响应中 return R.ok("查询客户服务成功").put("data", chatView); - } - - /** - * 后端详情 - */ - @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id){ - ChatEntity chat = chatService.selectById(id); - return R.ok().put("data", chat); - } - - /** - * 前端详情 - */ - @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id){ - ChatEntity chat = chatService.selectById(id); - return R.ok().put("data", chat); - } - - - - - /** - * 后端保存 - */ - @RequestMapping("/save") - 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())) { + } + + /** + * 后端详情 + */ + // 处理/info/{id}请求，接收路径变量id + @RequestMapping("/info/{id}") + public R info(@PathVariable("id") Long id) { + // 根据ID查询Chat实体 + ChatEntity chat = chatService.selectById(id); + // 返回成功响应，并将查询结果放入响应中 + return R.ok().put("data", chat); + } + + /** + * 前端详情 + */ + // 处理/detail/{id}请求，接收路径变量id + @RequestMapping("/detail/{id}") + public R detail(@PathVariable("id") Long id) { + // 根据ID查询Chat实体 + ChatEntity chat = chatService.selectById(id); + // 返回成功响应，并将查询结果放入响应中 + return R.ok().put("data", chat); + } + + + /** + * 后端保存 + */ + // 处理/save请求，接收请求体中的Chat实体和HttpServletRequest对象 + @RequestMapping("/save") + public R save(@RequestBody ChatEntity chat, HttpServletRequest request) { + // 生成唯一的ID，使用当前时间戳加上随机数 + chat.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 注释掉的验证代码 + //ValidatorUtils.validateEntity(chat); + // 如果询问内容不为空 + if (StringUtils.isNotBlank(chat.getAsk())) { + // 将该用户的所有聊天记录的isreply字段置为0 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); - return R.ok(); - } - - /** - * 前端保存 - */ - @RequestMapping("/add") - 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())) { + // 设置Chat实体的用户ID为当前用户ID + chat.setUserid((Long) request.getSession().getAttribute("userId")); + // 设置isreply字段为1 + chat.setIsreply(1); + } + // 如果回复内容不为空 + if (StringUtils.isNotBlank(chat.getReply())) { + // 将该用户的所有聊天记录的isreply字段置为0 + chatService.updateForSet("isreply=0", new EntityWrapper().eq("userid", chat.getUserid())); + // 设置Chat实体的管理员ID为当前用户ID + chat.setAdminid((Long) request.getSession().getAttribute("userId")); + } + // 插入Chat实体到数据库 + chatService.insert(chat); + // 返回成功响应 + return R.ok(); + } + + /** + * 前端保存 + */ + // 处理/add请求，接收请求体中的Chat实体和HttpServletRequest对象 + @RequestMapping("/add") + public R add(@RequestBody ChatEntity chat, HttpServletRequest request) { + // 生成唯一的ID，使用当前时间戳加上随机数 + chat.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 注释掉的验证代码 + //ValidatorUtils.validateEntity(chat); + // 设置Chat实体的用户ID为当前用户ID + chat.setUserid((Long) request.getSession().getAttribute("userId")); + // 如果询问内容不为空 + if (StringUtils.isNotBlank(chat.getAsk())) { + // 将该用户的所有聊天记录的isreply字段置为0 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); - return R.ok(); - } - - /** - * 修改 - */ - @RequestMapping("/update") - public R update(@RequestBody ChatEntity chat, HttpServletRequest request){ - //ValidatorUtils.validateEntity(chat); - chatService.updateById(chat);//全部更新 - return R.ok(); - } - - - /** - * 删除 - */ - @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ - chatService.deleteBatchIds(Arrays.asList(ids)); - return R.ok(); - } - - /** - * 提醒接口 - */ + // 设置Chat实体的用户ID为当前用户ID + chat.setUserid((Long) request.getSession().getAttribute("userId")); + // 设置isreply字段为1 + chat.setIsreply(1); + } + // 如果回复内容不为空 + if (StringUtils.isNotBlank(chat.getReply())) { + // 将该用户的所有聊天记录的isreply字段置为0 + chatService.updateForSet("isreply=0", new EntityWrapper().eq("userid", chat.getUserid())); + // 设置Chat实体的管理员ID为当前用户ID + chat.setAdminid((Long) request.getSession().getAttribute("userId")); + } + // 插入Chat实体到数据库 + chatService.insert(chat); + // 返回成功响应 + return R.ok(); + } + + /** + * 修改 + */ + // 处理/update请求，接收请求体中的Chat实体和HttpServletRequest对象 + @RequestMapping("/update") + public R update(@RequestBody ChatEntity chat, HttpServletRequest request) { + // 注释掉的验证代码 + //ValidatorUtils.validateEntity(chat); + // 根据ID更新Chat实体的所有字段 + chatService.updateById(chat); + // 返回成功响应 + return R.ok(); + } + + + /** + * 删除 + */ + // 处理/delete请求，接收请求体中的ID数组 + @RequestMapping("/delete") + public R delete(@RequestBody Long[] ids) { + // 根据ID数组批量删除Chat实体 + chatService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 + return R.ok(); + } + + /** + * 提醒接口 + */ + // 处理/remind/{columnName}/{type}请求，接收路径变量columnName和type，以及请求参数map @RequestMapping("/remind/{columnName}/{type}") - public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, - @PathVariable("type") String type,@RequestParam Map map) { + 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); - - if(type.equals("2")) { + + // 如果类型为2 + if (type.equals("2")) { + // 创建日期格式化对象 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + // 创建Calendar对象 Calendar c = Calendar.getInstance(); + // 提醒开始日期 Date remindStartDate = null; + // 提醒结束日期 Date remindEndDate = null; - if(map.get("remindstart")!=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); + // 设置Calendar的时间为当前时间 + c.setTime(new Date()); + // 增加指定天数 + c.add(Calendar.DAY_OF_MONTH, remindStart); + // 获取提醒开始日期 remindStartDate = c.getTime(); + // 将提醒开始日期格式化后放入请求参数map中 map.put("remindstart", sdf.format(remindStartDate)); } - if(map.get("remindend")!=null) { + // 如果提醒结束时间不为空 + if (map.get("remindend") != null) { + // 将提醒结束时间转换为整数 Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); + // 设置Calendar的时间为当前时间 c.setTime(new Date()); - c.add(Calendar.DAY_OF_MONTH,remindEnd); + // 增加指定天数 + c.add(Calendar.DAY_OF_MONTH, remindEnd); + // 获取提醒结束日期 remindEndDate = c.getTime(); + // 将提醒结束日期格式化后放入请求参数map中 map.put("remindend", sdf.format(remindEndDate)); } } - + + // 创建MyBatis-Plus的包装器 Wrapper wrapper = new EntityWrapper(); - if(map.get("remindstart")!=null) { + // 如果提醒开始时间不为空 + if (map.get("remindstart") != null) { + // 设置查询条件，列名大于等于提醒开始时间 wrapper.ge(columnName, map.get("remindstart")); } - if(map.get("remindend")!=null) { + // 如果提醒结束时间不为空 + if (map.get("remindend") != null) { + // 设置查询条件，列名小于等于提醒结束时间 wrapper.le(columnName, map.get("remindend")); } - + // 统计符合条件的记录数 int count = chatService.selectCount(wrapper); + // 返回成功响应，并将统计结果放入响应中 return R.ok().put("count", count); } - - - -} +} \ No newline at end of file diff --git a/src/main/java/com/controller/CommonController.java b/src/main/java/com/controller/CommonController.java index 4c6e1f1..1068b70 100644 --- a/src/main/java/com/controller/CommonController.java +++ b/src/main/java/com/controller/CommonController.java @@ -1,256 +1,405 @@ package com.controller; +// 导入文件操作相关类 import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; +// 导入日期格式化类 import java.text.SimpleDateFormat; +// 导入动态数组类 import java.util.ArrayList; +// 导入日历类 import java.util.Calendar; +// 导入日期类 import java.util.Date; +// 导入哈希映射类 import java.util.HashMap; +// 导入列表接口 import java.util.List; +// 导入映射接口 import java.util.Map; +// 导入Apache Commons Lang工具类 import org.apache.commons.lang3.StringUtils; +// 导入JSON对象类 import org.json.JSONObject; +// 导入Spring的自动装配注解 import org.springframework.beans.factory.annotation.Autowired; +// 导入Spring的资源工具类 import org.springframework.util.ResourceUtils; +// 导入Spring的路径变量注解 import org.springframework.web.bind.annotation.PathVariable; +// 导入Spring的请求体注解 import org.springframework.web.bind.annotation.RequestBody; +// 导入Spring的请求映射注解 import org.springframework.web.bind.annotation.RequestMapping; +// 导入Spring的请求参数注解 import org.springframework.web.bind.annotation.RequestParam; +// 导入Spring的REST控制器注解 import org.springframework.web.bind.annotation.RestController; +// 导入自定义的忽略认证注解 import com.annotation.IgnoreAuth; +// 导入百度人脸识别客户端类 import com.baidu.aip.face.AipFace; +// 导入百度人脸匹配请求类 import com.baidu.aip.face.MatchRequest; +// 导入百度的Base64工具类 import com.baidu.aip.util.Base64Util; +// 导入MyBatis-Plus的实体包装器类 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入MyBatis-Plus的包装器接口 import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入配置实体类 import com.entity.ConfigEntity; +// 导入通用服务类 import com.service.CommonService; +// 导入配置服务类 import com.service.ConfigService; +// 导入自定义的百度工具类 import com.utils.BaiduUtil; +// 导入自定义的文件工具类 import com.utils.FileUtil; +// 导入自定义的响应结果类 import com.utils.R; /** * 通用接口 */ +// 声明为RESTful控制器 @RestController -public class CommonController{ +public class CommonController { + // 自动装配通用服务类实例 @Autowired private CommonService commonService; - + + // 自动装配配置服务类实例 @Autowired private ConfigService configService; + + // 定义一个未使用的整型变量 private int aaaa; + + // 定义百度人脸识别客户端静态变量 private static AipFace client = null; - + + // 定义百度地图AK静态变量 private static String BAIDU_DITU_AK = null; - + + /** + * 根据经纬度获取城市信息 + * @param lng 经度 + * @param lat 纬度 + * @return 包含城市信息的响应结果 + */ @RequestMapping("/location") - public R location(String lng,String lat) { - if(BAIDU_DITU_AK==null) { + public R location(String lng, String lat) { + // 如果百度地图AK为空 + if (BAIDU_DITU_AK == null) { + // 从配置表中获取百度地图AK BAIDU_DITU_AK = configService.selectOne(new EntityWrapper().eq("name", "baidu_ditu_ak")).getValue(); - if(BAIDU_DITU_AK==null) { + // 如果获取失败 + if (BAIDU_DITU_AK == null) { + // 返回错误信息 return R.error("请在配置管理中正确配置baidu_ditu_ak"); } } + // 调用百度工具类的方法获取城市信息 Map map = BaiduUtil.getCityByLonLat(BAIDU_DITU_AK, lng, lat); + // 返回成功响应并携带城市信息 return R.ok().put("data", map); } - + /** * 人脸比对 - * - * @param face1 人脸1 - * @param face2 人脸2 - * @return + * @param face1 人脸1的文件名 + * @param face2 人脸2的文件名 + * @return 包含比对结果的响应结果 */ @RequestMapping("/matchFace") public R matchFace(String face1, String face2) { - if(client==null) { - /*String AppID = configService.selectOne(new EntityWrapper().eq("name", "AppID")).getValue();*/ + // 如果百度人脸识别客户端未初始化 + if (client == null) { + // 从配置表中获取API Key String APIKey = configService.selectOne(new EntityWrapper().eq("name", "APIKey")).getValue(); + // 从配置表中获取Secret Key String SecretKey = configService.selectOne(new EntityWrapper().eq("name", "SecretKey")).getValue(); + // 获取百度认证令牌 String token = BaiduUtil.getAuth(APIKey, SecretKey); - if(token==null) { + // 如果获取失败 + if (token == null) { + // 返回错误信息 return R.error("请在配置管理中正确配置APIKey和SecretKey"); } + // 初始化百度人脸识别客户端 client = new AipFace(null, APIKey, SecretKey); + // 设置连接超时时间 client.setConnectionTimeoutInMillis(2000); + // 设置套接字超时时间 client.setSocketTimeoutInMillis(60000); } + // 定义JSON对象用于存储比对结果 JSONObject res = null; try { - File file1 = new File(ResourceUtils.getFile("classpath:static/upload").getAbsolutePath()+"/"+face1); - File file2 = new File(ResourceUtils.getFile("classpath:static/upload").getAbsolutePath()+"/"+face2); + // 获取人脸1的文件对象 + File file1 = new File(ResourceUtils.getFile("classpath:static/upload").getAbsolutePath() + "/" + face1); + // 获取人脸2的文件对象 + File file2 = new File(ResourceUtils.getFile("classpath:static/upload").getAbsolutePath() + "/" + face2); + // 将人脸1的文件转换为Base64编码字符串 String img1 = Base64Util.encode(FileUtil.FileToByte(file1)); + // 将人脸2的文件转换为Base64编码字符串 String img2 = Base64Util.encode(FileUtil.FileToByte(file2)); + // 创建人脸1的匹配请求对象 MatchRequest req1 = new MatchRequest(img1, "BASE64"); + // 创建人脸2的匹配请求对象 MatchRequest req2 = new MatchRequest(img2, "BASE64"); + // 创建匹配请求列表 ArrayList requests = new ArrayList(); + // 将人脸1的匹配请求添加到列表中 requests.add(req1); + // 将人脸2的匹配请求添加到列表中 requests.add(req2); + // 调用百度人脸识别客户端的匹配方法进行人脸比对 res = client.match(requests); + // 打印比对结果 System.out.println(res.get("result")); } catch (FileNotFoundException e) { + // 打印文件未找到异常信息 e.printStackTrace(); + // 返回文件不存在的错误信息 return R.error("文件不存在"); } catch (IOException e) { + // 打印IO异常信息 e.printStackTrace(); - } + } + // 返回成功响应并携带比对结果 return R.ok().put("data", com.alibaba.fastjson.JSONObject.parse(res.get("result").toString())); } - + /** * 获取table表中的column列表(联动接口) - * @param table - * @param column - * @return + * @param tableName 表名 + * @param columnName 列名 + * @param level 层级信息 + * @param parent 父级信息 + * @return 包含列列表的响应结果 */ @IgnoreAuth @RequestMapping("/option/{tableName}/{columnName}") - public R getOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,String level,String parent) { + public R getOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, String level, String parent) { + // 创建参数映射 Map params = new HashMap(); + // 将表名放入参数映射中 params.put("table", tableName); + // 将列名放入参数映射中 params.put("column", columnName); - if(StringUtils.isNotBlank(level)) { + // 如果层级信息不为空 + if (StringUtils.isNotBlank(level)) { + // 将层级信息放入参数映射中 params.put("level", level); } - if(StringUtils.isNotBlank(parent)) { + // 如果父级信息不为空 + if (StringUtils.isNotBlank(parent)) { + // 将父级信息放入参数映射中 params.put("parent", parent); } + // 调用通用服务类的方法获取列列表 List data = commonService.getOption(params); + // 返回成功响应并携带列列表 return R.ok().put("data", data); } - + /** * 根据table中的column获取单条记录 - * @param table - * @param column - * @return + * @param tableName 表名 + * @param columnName 列名 + * @param columnValue 列值 + * @return 包含单条记录的响应结果 */ @IgnoreAuth @RequestMapping("/follow/{tableName}/{columnName}") 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 + * @param tableName 表名 + * @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 tableName 表名 + * @param columnName 列名 * @param type 1:数字 2:日期 - * @param map - * @return + * @param map 包含查询条件的映射 + * @return 包含提醒记录数的响应结果 */ @IgnoreAuth @RequestMapping("/remind/{tableName}/{columnName}/{type}") - public R remindCount(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, - @PathVariable("type") String type,@RequestParam Map map) { + 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")) { + + // 如果类型为日期 + 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) { + // 如果提醒开始时间不为空 + if (map.get("remindstart") != null) { + // 将提醒开始时间转换为整数 Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); - c.setTime(new Date()); - c.add(Calendar.DAY_OF_MONTH,remindStart); + // 设置日历时间为当前时间 + 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) { + // 如果提醒结束时间不为空 + if (map.get("remindend") != null) { + // 将提醒结束时间转换为整数 Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); + // 设置日历时间为当前时间 c.setTime(new Date()); - c.add(Calendar.DAY_OF_MONTH,remindEnd); + // 增加指定天数 + 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); } - + /** * 单列求和 + * @param tableName 表名 + * @param columnName 列名 + * @return 包含求和结果的响应结果 */ @IgnoreAuth @RequestMapping("/cal/{tableName}/{columnName}") 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); } - + /** * 分组统计 + * @param tableName 表名 + * @param columnName 列名 + * @return 包含分组统计结果的响应结果 */ @IgnoreAuth @RequestMapping("/group/{tableName}/{columnName}") 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))); + // 遍历统计结果 + 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); } - + /** * （按值统计） + * @param tableName 表名 + * @param yColumnName y列名 + * @param xColumnName x列名 + * @return 包含按值统计结果的响应结果 */ @IgnoreAuth @RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}") public R value(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName) { + // 创建参数映射 Map params = new HashMap(); + // 将表名放入参数映射中 params.put("table", tableName); + // 将x列名放入参数映射中 params.put("xColumn", xColumnName); + // 将y列名放入参数映射中 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))); + // 遍历统计结果 + 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); } - -} +} \ No newline at end of file diff --git a/src/main/java/com/controller/ConfigController.java b/src/main/java/com/controller/ConfigController.java index 6e9f123..58b430b 100644 --- a/src/main/java/com/controller/ConfigController.java +++ b/src/main/java/com/controller/ConfigController.java @@ -1,111 +1,156 @@ - +// 声明该类所在的包 package com.controller; - +// 导入Arrays类，用于操作数组，这里主要用于处理批量删除时的ID数组 import java.util.Arrays; +// 导入Map接口，用于存储键值对，通常用于接收请求参数 import java.util.Map; +// 导入Spring框架的自动装配注解，用于将ConfigService注入到当前类中 import org.springframework.beans.factory.annotation.Autowired; +// 导入Spring框架的路径变量注解，用于从URL路径中获取参数 import org.springframework.web.bind.annotation.PathVariable; +// 导入Spring框架的Post请求映射注解，用于处理HTTP POST请求 import org.springframework.web.bind.annotation.PostMapping; +// 导入Spring框架的请求体注解，用于将请求体中的数据绑定到方法参数上 import org.springframework.web.bind.annotation.RequestBody; +// 导入Spring框架的请求映射注解，用于将HTTP请求映射到处理方法上 import org.springframework.web.bind.annotation.RequestMapping; +// 导入Spring框架的请求参数注解，用于从请求中获取参数 import org.springframework.web.bind.annotation.RequestParam; +// 导入Spring框架的REST控制器注解，表明该类是一个RESTful风格的控制器 import org.springframework.web.bind.annotation.RestController; +// 导入自定义的忽略认证注解，用于标记某些接口不需要进行认证 import com.annotation.IgnoreAuth; +// 导入MyBatis-Plus的实体包装器类，用于构建查询条件 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入配置实体类，用于表示配置信息 import com.entity.ConfigEntity; +// 导入配置服务类，用于处理配置信息的业务逻辑 import com.service.ConfigService; +// 导入自定义的分页工具类，用于处理分页查询结果 import com.utils.PageUtils; +// 导入自定义的响应结果类，用于封装接口的返回数据 import com.utils.R; +// 导入自定义的验证工具类，用于验证实体对象的合法性 import com.utils.ValidatorUtils; /** * 登录相关 */ +// 定义该控制器处理的请求路径前缀为"config" @RequestMapping("config") +// 声明该类为RESTful控制器 @RestController -public class ConfigController{ - - @Autowired - private ConfigService configService; +public class ConfigController { + // 使用自动装配将ConfigService实例注入到当前类中 + @Autowired + private ConfigService configService; - /** + /** * 列表 + * 该方法用于处理分页查询配置信息的请求 */ @RequestMapping("/page") - public R page(@RequestParam Map params,ConfigEntity config){ + public R page(@RequestParam Map params, ConfigEntity config) { + // 创建一个EntityWrapper对象，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = configService.queryPage(params); + // 调用ConfigService的queryPage方法进行分页查询 + PageUtils page = configService.queryPage(params); + // 返回成功响应，并将分页查询结果放入响应数据中 return R.ok().put("data", page); } - - /** + + /** * 列表 + * 该方法用于处理查询配置信息列表的请求，且该接口不需要认证 */ @IgnoreAuth @RequestMapping("/list") - public R list(@RequestParam Map params,ConfigEntity config){ + public R list(@RequestParam Map params, ConfigEntity config) { + // 创建一个EntityWrapper对象，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = configService.queryPage(params); + // 调用ConfigService的queryPage方法进行分页查询 + PageUtils page = configService.queryPage(params); + // 返回成功响应，并将分页查询结果放入响应数据中 return R.ok().put("data", page); } /** * 信息 + * 该方法用于根据配置信息的ID查询单个配置信息 */ @RequestMapping("/info/{id}") - public R info(@PathVariable("id") String id){ + public R info(@PathVariable("id") String id) { + // 调用ConfigService的selectById方法根据ID查询配置信息 ConfigEntity config = configService.selectById(id); + // 返回成功响应，并将查询到的配置信息放入响应数据中 return R.ok().put("data", config); } - + /** * 详情 + * 该方法用于根据配置信息的ID查询单个配置信息详情，且该接口不需要认证 */ @IgnoreAuth @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") String id){ + public R detail(@PathVariable("id") String id) { + // 调用ConfigService的selectById方法根据ID查询配置信息 ConfigEntity config = configService.selectById(id); + // 返回成功响应，并将查询到的配置信息放入响应数据中 return R.ok().put("data", config); } - + /** * 根据name获取信息 + * 该方法用于根据配置信息的名称查询单个配置信息 */ @RequestMapping("/info") - public R infoByName(@RequestParam String name){ + public R infoByName(@RequestParam String name) { + // 调用ConfigService的selectOne方法根据名称查询配置信息，这里写死了查询"faceFile" ConfigEntity config = configService.selectOne(new EntityWrapper().eq("name", "faceFile")); + // 返回成功响应，并将查询到的配置信息放入响应数据中 return R.ok().put("data", config); } - + /** * 保存 + * 该方法用于处理保存配置信息的请求，使用HTTP POST请求 */ @PostMapping("/save") - public R save(@RequestBody ConfigEntity config){ + public R save(@RequestBody ConfigEntity config) { + // 注释掉的代码，原本用于验证实体对象的合法性 // ValidatorUtils.validateEntity(config); - configService.insert(config); + // 调用ConfigService的insert方法将配置信息插入到数据库中 + configService.insert(config); + // 返回成功响应 return R.ok(); } /** * 修改 + * 该方法用于处理更新配置信息的请求 */ @RequestMapping("/update") - public R update(@RequestBody ConfigEntity config){ + public R update(@RequestBody ConfigEntity config) { + // 注释掉的代码，原本用于验证实体对象的合法性 // ValidatorUtils.validateEntity(config); - configService.updateById(config);//全部更新 + // 调用ConfigService的updateById方法根据ID更新配置信息的所有字段 + configService.updateById(config); + // 返回成功响应 return R.ok(); } /** * 删除 + * 该方法用于处理批量删除配置信息的请求 */ @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ - configService.deleteBatchIds(Arrays.asList(ids)); + public R delete(@RequestBody Long[] ids) { + // 调用ConfigService的deleteBatchIds方法根据ID数组批量删除配置信息 + configService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 return R.ok(); } -} +} \ No newline at end of file diff --git a/src/main/java/com/controller/DiscusskechengxinxiController.java b/src/main/java/com/controller/DiscusskechengxinxiController.java index fb52e12..8b10f25 100644 --- a/src/main/java/com/controller/DiscusskechengxinxiController.java +++ b/src/main/java/com/controller/DiscusskechengxinxiController.java @@ -1,207 +1,297 @@ +// 声明该类所在的包 package com.controller; +// 导入用于格式化日期的类，可将日期对象按照指定格式转换为字符串 import java.text.SimpleDateFormat; +// 导入动态数组类，可动态调整大小，用于存储多个元素 import java.util.ArrayList; +// 导入用于操作数组的工具类，提供了如排序、查找等操作数组的方法 import java.util.Arrays; +// 导入日历类，用于处理日期和时间，可进行日期的计算和转换 import java.util.Calendar; +// 导入映射接口，用于存储键值对，方便通过键快速查找对应的值 import java.util.Map; +// 导入哈希映射类，是Map接口的一个实现类，使用哈希表存储键值对 import java.util.HashMap; +// 导入迭代器接口，用于遍历集合中的元素 import java.util.Iterator; +// 导入日期类，用于表示特定的瞬间 import java.util.Date; +// 导入列表接口，是有序集合，可存储重复元素 import java.util.List; +// 导入用于处理HTTP请求的类，可获取请求的各种信息，如参数、头信息等 import javax.servlet.http.HttpServletRequest; +// 导入自定义的验证工具类，可用于验证实体对象的属性是否符合要求 import com.utils.ValidatorUtils; +// 导入Apache Commons Lang库中的字符串工具类，提供了丰富的字符串处理方法 import org.apache.commons.lang3.StringUtils; +// 导入Spring框架的自动装配注解，用于将依赖的对象自动注入到当前类中 import org.springframework.beans.factory.annotation.Autowired; +// 导入Spring框架的日期格式化注解，可将请求参数中的日期字符串按照指定格式转换为日期对象 import org.springframework.format.annotation.DateTimeFormat; +// 导入Spring框架的路径变量注解，用于从URL路径中提取参数 import org.springframework.web.bind.annotation.PathVariable; +// 导入Spring框架的请求体注解，用于将请求体中的数据绑定到方法参数上 import org.springframework.web.bind.annotation.RequestBody; +// 导入Spring框架的请求映射注解，用于将HTTP请求映射到对应的处理方法上 import org.springframework.web.bind.annotation.RequestMapping; +// 导入Spring框架的请求参数注解，用于从请求中获取参数 import org.springframework.web.bind.annotation.RequestParam; +// 导入Spring框架的REST控制器注解，表明该类是一个RESTful风格的控制器 import org.springframework.web.bind.annotation.RestController; +// 导入MyBatis-Plus的实体包装器类，用于构建查询条件 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入MyBatis-Plus的包装器接口，是EntityWrapper的父接口 import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的忽略认证注解，用于标记某些接口不需要进行认证 import com.annotation.IgnoreAuth; +// 导入课程信息评论实体类，用于表示课程信息评论的数据结构 import com.entity.DiscusskechengxinxiEntity; +// 导入课程信息评论视图类，可能用于展示课程信息评论的特定视图 import com.entity.view.DiscusskechengxinxiView; +// 导入课程信息评论服务类，用于处理课程信息评论的业务逻辑 import com.service.DiscusskechengxinxiService; +// 导入令牌服务类，可能用于处理用户认证和授权相关的令牌 import com.service.TokenService; +// 导入自定义的分页工具类，用于处理分页查询的结果 import com.utils.PageUtils; +// 导入自定义的响应结果类，用于封装接口的返回数据，统一返回格式 import com.utils.R; +// 导入自定义的MD5工具类，用于进行MD5加密操作 import com.utils.MD5Util; +// 导入自定义的MyBatis-Plus工具类，提供了一些方便使用MyBatis-Plus的方法 import com.utils.MPUtil; +// 导入自定义的通用工具类，包含一些通用的工具方法 import com.utils.CommonUtil; /** * 课程信息评论表 * 后端接口 - * @author - * @email + * @author + * @email * @date 2021-05-09 15:46:15 */ +// 声明该类为RESTful风格的控制器 @RestController +// 定义该控制器处理的请求路径前缀 @RequestMapping("/discusskechengxinxi") public class DiscusskechengxinxiController { + // 使用自动装配将DiscusskechengxinxiService注入到当前类中 @Autowired private DiscusskechengxinxiService discusskechengxinxiService; - - /** * 后端列表 + * 该方法用于处理后端分页查询课程信息评论列表的请求 */ @RequestMapping("/page") - public R page(@RequestParam Map params,DiscusskechengxinxiEntity discusskechengxinxi, - HttpServletRequest request){ + public R page(@RequestParam Map params, DiscusskechengxinxiEntity discusskechengxinxi, + HttpServletRequest request) { + // 创建一个EntityWrapper对象，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = discusskechengxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, discusskechengxinxi), params), params)); - + // 调用DiscusskechengxinxiService的queryPage方法进行分页查询 + PageUtils page = discusskechengxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, discusskechengxinxi), params), params)); + // 返回成功响应，并将分页查询结果放入响应数据中 return R.ok().put("data", page); } - + /** * 前端列表 + * 该方法用于处理前端分页查询课程信息评论列表的请求，且该接口不需要认证 */ - @IgnoreAuth + @IgnoreAuth @RequestMapping("/list") - public R list(@RequestParam Map params,DiscusskechengxinxiEntity discusskechengxinxi, - HttpServletRequest request){ + public R list(@RequestParam Map params, DiscusskechengxinxiEntity discusskechengxinxi, + HttpServletRequest request) { + // 创建一个EntityWrapper对象，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = discusskechengxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, discusskechengxinxi), params), params)); + // 调用DiscusskechengxinxiService的queryPage方法进行分页查询 + PageUtils page = discusskechengxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, discusskechengxinxi), params), params)); + // 返回成功响应，并将分页查询结果放入响应数据中 return R.ok().put("data", page); } - /** + /** * 列表 + * 该方法用于查询课程信息评论列表，根据传入的实体对象构建查询条件 */ @RequestMapping("/lists") - public R list( DiscusskechengxinxiEntity discusskechengxinxi){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( discusskechengxinxi, "discusskechengxinxi")); + public R list(DiscusskechengxinxiEntity discusskechengxinxi) { + // 创建一个EntityWrapper对象，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件，将实体对象的属性作为查询条件 + ew.allEq(MPUtil.allEQMapPre(discusskechengxinxi, "discusskechengxinxi")); + // 调用DiscusskechengxinxiService的selectListView方法查询列表数据 return R.ok().put("data", discusskechengxinxiService.selectListView(ew)); } - /** + /** * 查询 + * 该方法用于根据传入的实体对象查询单个课程信息评论视图 */ @RequestMapping("/query") - public R query(DiscusskechengxinxiEntity discusskechengxinxi){ - EntityWrapper< DiscusskechengxinxiEntity> ew = new EntityWrapper< DiscusskechengxinxiEntity>(); - ew.allEq(MPUtil.allEQMapPre( discusskechengxinxi, "discusskechengxinxi")); - DiscusskechengxinxiView discusskechengxinxiView = discusskechengxinxiService.selectView(ew); - return R.ok("查询课程信息评论表成功").put("data", discusskechengxinxiView); + public R query(DiscusskechengxinxiEntity discusskechengxinxi) { + // 创建一个EntityWrapper对象，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件，将实体对象的属性作为查询条件 + ew.allEq(MPUtil.allEQMapPre(discusskechengxinxi, "discusskechengxinxi")); + // 调用DiscusskechengxinxiService的selectView方法查询单个视图数据 + DiscusskechengxinxiView discusskechengxinxiView = discusskechengxinxiService.selectView(ew); + // 返回成功响应，并将查询结果放入响应数据中 + return R.ok("查询课程信息评论表成功").put("data", discusskechengxinxiView); } - + /** * 后端详情 + * 该方法用于根据ID查询单个课程信息评论的详细信息 */ @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id){ + public R info(@PathVariable("id") Long id) { + // 调用DiscusskechengxinxiService的selectById方法根据ID查询课程信息评论 DiscusskechengxinxiEntity discusskechengxinxi = discusskechengxinxiService.selectById(id); + // 返回成功响应，并将查询结果放入响应数据中 return R.ok().put("data", discusskechengxinxi); } /** * 前端详情 + * 该方法用于根据ID查询单个课程信息评论的详细信息 */ @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id){ + public R detail(@PathVariable("id") Long id) { + // 调用DiscusskechengxinxiService的selectById方法根据ID查询课程信息评论 DiscusskechengxinxiEntity discusskechengxinxi = discusskechengxinxiService.selectById(id); + // 返回成功响应，并将查询结果放入响应数据中 return R.ok().put("data", discusskechengxinxi); } - - - /** * 后端保存 + * 该方法用于处理后端保存课程信息评论的请求 */ @RequestMapping("/save") - public R save(@RequestBody DiscusskechengxinxiEntity discusskechengxinxi, HttpServletRequest request){ - discusskechengxinxi.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(discusskechengxinxi); + public R save(@RequestBody DiscusskechengxinxiEntity discusskechengxinxi, HttpServletRequest request) { + // 为课程信息评论生成一个唯一的ID，使用当前时间戳加上一个随机数 + discusskechengxinxi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 注释掉的代码，原本用于验证实体对象的合法性 + //ValidatorUtils.validateEntity(discusskechengxinxi); + // 调用DiscusskechengxinxiService的insert方法将课程信息评论插入到数据库中 discusskechengxinxiService.insert(discusskechengxinxi); + // 返回成功响应 return R.ok(); } - + /** * 前端保存 + * 该方法用于处理前端保存课程信息评论的请求 */ @RequestMapping("/add") - public R add(@RequestBody DiscusskechengxinxiEntity discusskechengxinxi, HttpServletRequest request){ - discusskechengxinxi.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(discusskechengxinxi); + public R add(@RequestBody DiscusskechengxinxiEntity discusskechengxinxi, HttpServletRequest request) { + // 为课程信息评论生成一个唯一的ID，使用当前时间戳加上一个随机数 + discusskechengxinxi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 注释掉的代码，原本用于验证实体对象的合法性 + //ValidatorUtils.validateEntity(discusskechengxinxi); + // 调用DiscusskechengxinxiService的insert方法将课程信息评论插入到数据库中 discusskechengxinxiService.insert(discusskechengxinxi); + // 返回成功响应 return R.ok(); } /** * 修改 + * 该方法用于处理更新课程信息评论的请求 */ @RequestMapping("/update") - public R update(@RequestBody DiscusskechengxinxiEntity discusskechengxinxi, HttpServletRequest request){ + public R update(@RequestBody DiscusskechengxinxiEntity discusskechengxinxi, HttpServletRequest request) { + // 注释掉的代码，原本用于验证实体对象的合法性 //ValidatorUtils.validateEntity(discusskechengxinxi); - discusskechengxinxiService.updateById(discusskechengxinxi);//全部更新 + // 调用DiscusskechengxinxiService的updateById方法根据ID更新课程信息评论的所有字段 + discusskechengxinxiService.updateById(discusskechengxinxi); + // 返回成功响应 return R.ok(); } - /** * 删除 + * 该方法用于处理批量删除课程信息评论的请求 */ @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ + public R delete(@RequestBody Long[] ids) { + // 调用DiscusskechengxinxiService的deleteBatchIds方法根据ID数组批量删除课程信息评论 discusskechengxinxiService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 return R.ok(); } - + /** * 提醒接口 + * 该方法用于统计符合提醒条件的课程信息评论数量 */ - @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 = discusskechengxinxiService.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); + + // 如果类型为2，表示日期类型的提醒 + 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)); + } + } + + // 创建一个EntityWrapper对象，用于构建查询条件 + 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")); + } + + // 调用DiscusskechengxinxiService的selectCount方法统计符合条件的记录数量 + int count = discusskechengxinxiService.selectCount(wrapper); + // 返回成功响应，并将统计结果放入响应数据中 + return R.ok().put("count", count); + } +} \ No newline at end of file diff --git a/src/main/java/com/controller/ExampaperController.java b/src/main/java/com/controller/ExampaperController.java index b1c75a3..4731ab5 100644 --- a/src/main/java/com/controller/ExampaperController.java +++ b/src/main/java/com/controller/ExampaperController.java @@ -1,206 +1,295 @@ +// 声明该类所在的包 package com.controller; +// 导入用于格式化日期的类，可将日期对象按指定格式转换为字符串 import java.text.SimpleDateFormat; +// 导入动态数组类，可动态调整大小来存储多个元素 import java.util.ArrayList; +// 导入用于操作数组的工具类，提供排序、查找等数组操作方法 import java.util.Arrays; +// 导入日历类，用于处理日期和时间，可进行日期计算和转换 import java.util.Calendar; +// 导入映射接口，用于存储键值对，方便通过键快速查找对应值 import java.util.Map; +// 导入哈希映射类，是Map接口的实现类，使用哈希表存储键值对 import java.util.HashMap; +// 导入迭代器接口，用于遍历集合中的元素 import java.util.Iterator; +// 导入日期类，用于表示特定的瞬间 import java.util.Date; +// 导入列表接口，是有序集合，可存储重复元素 import java.util.List; +// 导入用于处理HTTP请求的类，可获取请求的参数、头信息等 import javax.servlet.http.HttpServletRequest; +// 导入自定义的验证工具类，用于验证实体对象属性是否符合要求 import com.utils.ValidatorUtils; +// 导入Apache Commons Lang库中的字符串工具类，提供丰富的字符串处理方法 import org.apache.commons.lang3.StringUtils; +// 导入Spring框架的自动装配注解，用于将依赖对象自动注入当前类 import org.springframework.beans.factory.annotation.Autowired; +// 导入Spring框架的日期格式化注解，可将请求参数中的日期字符串按指定格式转换为日期对象 import org.springframework.format.annotation.DateTimeFormat; +// 导入Spring框架的路径变量注解，用于从URL路径中提取参数 import org.springframework.web.bind.annotation.PathVariable; +// 导入Spring框架的请求体注解，用于将请求体中的数据绑定到方法参数上 import org.springframework.web.bind.annotation.RequestBody; +// 导入Spring框架的请求映射注解，用于将HTTP请求映射到对应的处理方法 import org.springframework.web.bind.annotation.RequestMapping; +// 导入Spring框架的请求参数注解，用于从请求中获取参数 import org.springframework.web.bind.annotation.RequestParam; +// 导入Spring框架的REST控制器注解，表明该类是RESTful风格的控制器 import org.springframework.web.bind.annotation.RestController; +// 导入MyBatis-Plus的实体包装器类，用于构建查询条件 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入MyBatis-Plus的包装器接口，是EntityWrapper的父接口 import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的忽略认证注解，用于标记某些接口不需要认证 import com.annotation.IgnoreAuth; +// 导入试卷实体类，用于表示试卷的数据结构 import com.entity.ExampaperEntity; +// 导入试卷视图类，可能用于展示试卷的特定视图 import com.entity.view.ExampaperView; +// 导入试卷服务类，用于处理试卷的业务逻辑 import com.service.ExampaperService; +// 导入令牌服务类，可能用于处理用户认证和授权相关的令牌 import com.service.TokenService; +// 导入自定义的分页工具类，用于处理分页查询结果 import com.utils.PageUtils; +// 导入自定义的响应结果类，用于封装接口的返回数据，统一返回格式 import com.utils.R; +// 导入自定义的MD5工具类，用于进行MD5加密操作 import com.utils.MD5Util; +// 导入自定义的MyBatis-Plus工具类，提供方便使用MyBatis-Plus的方法 import com.utils.MPUtil; +// 导入自定义的通用工具类，包含一些通用的工具方法 import com.utils.CommonUtil; - /** * 试卷表 * 后端接口 - * @author - * @email + * @author + * @email * @date 2021-05-09 15:46:15 */ +// 声明该类为RESTful风格的控制器 @RestController +// 定义该控制器处理的请求路径前缀 @RequestMapping("/exampaper") public class ExampaperController { + // 使用自动装配将ExampaperService注入到当前类中 @Autowired private ExampaperService exampaperService; - - /** * 后端列表 + * 处理后端分页查询试卷列表的请求 */ @RequestMapping("/page") - public R page(@RequestParam Map params,ExampaperEntity exampaper, - HttpServletRequest request){ + public R page(@RequestParam Map params, ExampaperEntity exampaper, + HttpServletRequest request) { + // 创建一个EntityWrapper对象，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = exampaperService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, exampaper), params), params)); - + // 调用ExampaperService的queryPage方法进行分页查询，同时对查询条件进行排序、范围和模糊查询等处理 + PageUtils page = exampaperService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, exampaper), params), params)); + // 返回成功响应，并将分页查询结果放入响应数据中 return R.ok().put("data", page); } - + /** * 前端列表 + * 处理前端分页查询试卷列表的请求 */ @RequestMapping("/list") - public R list(@RequestParam Map params,ExampaperEntity exampaper, - HttpServletRequest request){ + public R list(@RequestParam Map params, ExampaperEntity exampaper, + HttpServletRequest request) { + // 创建一个EntityWrapper对象，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = exampaperService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, exampaper), params), params)); + // 调用ExampaperService的queryPage方法进行分页查询，同时对查询条件进行排序、范围和模糊查询等处理 + PageUtils page = exampaperService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, exampaper), params), params)); + // 返回成功响应，并将分页查询结果放入响应数据中 return R.ok().put("data", page); } - /** + /** * 列表 + * 根据传入的试卷实体对象构建查询条件，查询试卷列表 */ @RequestMapping("/lists") - public R list( ExampaperEntity exampaper){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( exampaper, "exampaper")); + public R list(ExampaperEntity exampaper) { + // 创建一个EntityWrapper对象，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件，将实体对象的属性作为查询条件 + ew.allEq(MPUtil.allEQMapPre(exampaper, "exampaper")); + // 调用ExampaperService的selectListView方法查询列表数据 return R.ok().put("data", exampaperService.selectListView(ew)); } - /** + /** * 查询 + * 根据传入的试卷实体对象构建查询条件，查询单个试卷视图 */ @RequestMapping("/query") - public R query(ExampaperEntity exampaper){ - EntityWrapper< ExampaperEntity> ew = new EntityWrapper< ExampaperEntity>(); - ew.allEq(MPUtil.allEQMapPre( exampaper, "exampaper")); - ExampaperView exampaperView = exampaperService.selectView(ew); - return R.ok("查询试卷表成功").put("data", exampaperView); + public R query(ExampaperEntity exampaper) { + // 创建一个EntityWrapper对象，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件，将实体对象的属性作为查询条件 + ew.allEq(MPUtil.allEQMapPre(exampaper, "exampaper")); + // 调用ExampaperService的selectView方法查询单个视图数据 + ExampaperView exampaperView = exampaperService.selectView(ew); + // 返回成功响应，并将查询结果放入响应数据中 + return R.ok("查询试卷表成功").put("data", exampaperView); } - + /** * 后端详情 + * 根据ID查询单个试卷的详细信息 */ @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id){ + public R info(@PathVariable("id") Long id) { + // 调用ExampaperService的selectById方法根据ID查询试卷信息 ExampaperEntity exampaper = exampaperService.selectById(id); + // 返回成功响应，并将查询结果放入响应数据中 return R.ok().put("data", exampaper); } /** * 前端详情 + * 根据ID查询单个试卷的详细信息 */ @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id){ + public R detail(@PathVariable("id") Long id) { + // 调用ExampaperService的selectById方法根据ID查询试卷信息 ExampaperEntity exampaper = exampaperService.selectById(id); + // 返回成功响应，并将查询结果放入响应数据中 return R.ok().put("data", exampaper); } - - - /** * 后端保存 + * 处理后端保存试卷的请求 */ @RequestMapping("/save") - public R save(@RequestBody ExampaperEntity exampaper, HttpServletRequest request){ - exampaper.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(exampaper); + public R save(@RequestBody ExampaperEntity exampaper, HttpServletRequest request) { + // 为试卷生成一个唯一的ID，使用当前时间戳加上一个随机数 + exampaper.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 注释掉的代码，原本用于验证实体对象的合法性 + //ValidatorUtils.validateEntity(exampaper); + // 调用ExampaperService的insert方法将试卷信息插入到数据库中 exampaperService.insert(exampaper); + // 返回成功响应 return R.ok(); } - + /** * 前端保存 + * 处理前端保存试卷的请求 */ @RequestMapping("/add") - public R add(@RequestBody ExampaperEntity exampaper, HttpServletRequest request){ - exampaper.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(exampaper); + public R add(@RequestBody ExampaperEntity exampaper, HttpServletRequest request) { + // 为试卷生成一个唯一的ID，使用当前时间戳加上一个随机数 + exampaper.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 注释掉的代码，原本用于验证实体对象的合法性 + //ValidatorUtils.validateEntity(exampaper); + // 调用ExampaperService的insert方法将试卷信息插入到数据库中 exampaperService.insert(exampaper); + // 返回成功响应 return R.ok(); } /** * 修改 + * 处理更新试卷信息的请求 */ @RequestMapping("/update") - public R update(@RequestBody ExampaperEntity exampaper, HttpServletRequest request){ + public R update(@RequestBody ExampaperEntity exampaper, HttpServletRequest request) { + // 注释掉的代码，原本用于验证实体对象的合法性 //ValidatorUtils.validateEntity(exampaper); - exampaperService.updateById(exampaper);//全部更新 + // 调用ExampaperService的updateById方法根据ID更新试卷信息的所有字段 + exampaperService.updateById(exampaper); + // 返回成功响应 return R.ok(); } - /** * 删除 + * 处理批量删除试卷的请求 */ @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ + public R delete(@RequestBody Long[] ids) { + // 调用ExampaperService的deleteBatchIds方法根据ID数组批量删除试卷信息 exampaperService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 return R.ok(); } - + /** * 提醒接口 + * 统计符合提醒条件的试卷数量 */ - @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 = exampaperService.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); + + // 如果类型为2，表示日期类型的提醒 + 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)); + } + } + + // 创建一个EntityWrapper对象，用于构建查询条件 + 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")); + } + + // 调用ExampaperService的selectCount方法统计符合条件的记录数量 + int count = exampaperService.selectCount(wrapper); + // 返回成功响应，并将统计结果放入响应数据中 + return R.ok().put("count", count); + } +} \ No newline at end of file diff --git a/src/main/java/com/controller/ExamquestionController.java b/src/main/java/com/controller/ExamquestionController.java index f34f974..90f09fb 100644 --- a/src/main/java/com/controller/ExamquestionController.java +++ b/src/main/java/com/controller/ExamquestionController.java @@ -1,206 +1,315 @@ package com.controller; +// 导入用于格式化日期的类 import java.text.SimpleDateFormat; +// 导入用于创建和操作动态数组的类 import java.util.ArrayList; +// 导入用于操作数组的工具类 import java.util.Arrays; +// 导入用于处理日期和时间的类 import java.util.Calendar; +// 导入用于表示键值对映射的接口 import java.util.Map; +// 导入用于实现 Map 接口的类 import java.util.HashMap; +// 导入用于遍历集合的迭代器接口 import java.util.Iterator; +// 导入用于表示日期的类 import java.util.Date; +// 导入用于表示列表的接口 import java.util.List; +// 导入用于处理 HTTP 请求的类 import javax.servlet.http.HttpServletRequest; +// 导入自定义的验证工具类 import com.utils.ValidatorUtils; +// 导入 Apache Commons Lang 库中的字符串处理工具类 import org.apache.commons.lang3.StringUtils; +// 导入 Spring 框架中的自动注入注解 import org.springframework.beans.factory.annotation.Autowired; +// 导入 Spring 框架中用于日期格式化的注解 import org.springframework.format.annotation.DateTimeFormat; +// 导入 Spring 框架中用于处理路径变量的注解 import org.springframework.web.bind.annotation.PathVariable; +// 导入 Spring 框架中用于处理请求体的注解 import org.springframework.web.bind.annotation.RequestBody; +// 导入 Spring 框架中用于处理请求映射的注解 import org.springframework.web.bind.annotation.RequestMapping; +// 导入 Spring 框架中用于处理请求参数的注解 import org.springframework.web.bind.annotation.RequestParam; +// 导入 Spring 框架中用于将类标记为 RESTful 控制器的注解 import org.springframework.web.bind.annotation.RestController; +// 导入 MyBatis-Plus 框架中用于构建查询条件的实体包装器类 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入 MyBatis-Plus 框架中用于构建查询条件的包装器接口 import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的忽略认证注解 import com.annotation.IgnoreAuth; +// 导入试题实体类 import com.entity.ExamquestionEntity; +// 导入试题视图类 import com.entity.view.ExamquestionView; +// 导入试题服务类 import com.service.ExamquestionService; +// 导入令牌服务类 import com.service.TokenService; +// 导入自定义的分页工具类 import com.utils.PageUtils; +// 导入自定义的返回结果工具类 import com.utils.R; +// 导入自定义的 MD5 加密工具类 import com.utils.MD5Util; +// 导入自定义的 MyBatis-Plus 工具类 import com.utils.MPUtil; +// 导入自定义的通用工具类 import com.utils.CommonUtil; /** * 试题表 * 后端接口 - * @author - * @email + * @author + * @email * @date 2021-05-09 15:46:15 */ +// 将该类标记为 RESTful 控制器，用于处理 HTTP 请求 @RestController +// 定义该控制器处理的请求路径前缀 @RequestMapping("/examquestion") public class ExamquestionController { + // 自动注入试题服务类的实例 @Autowired private ExamquestionService examquestionService; - + /** * 后端列表 */ + // 处理 /examquestion/page 路径的请求 @RequestMapping("/page") + // 该方法用于获取试题的分页列表 public R page(@RequestParam Map params,ExamquestionEntity examquestion, - HttpServletRequest request){ + HttpServletRequest request){ + // 创建一个用于构建查询条件的实体包装器 EntityWrapper ew = new EntityWrapper(); - PageUtils page = examquestionService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, examquestion), params), params)); + // 调用试题服务类的 queryPage 方法进行分页查询 + PageUtils page = examquestionService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, examquestion), params), params)); + // 返回成功响应，并将分页数据放入响应结果中 return R.ok().put("data", page);//测试 } - + /** * 前端列表 */ + // 处理 /examquestion/list 路径的请求 @RequestMapping("/list") - public R list(@RequestParam Map params,ExamquestionEntity examquestion, - HttpServletRequest request){ + // 该方法用于获取试题的分页列表（前端使用） + public R list(@RequestParam Map params,ExamquestionEntity examquestion, + HttpServletRequest request){ + // 创建一个用于构建查询条件的实体包装器 EntityWrapper ew = new EntityWrapper(); - PageUtils page = examquestionService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, examquestion), params), params)); + // 调用试题服务类的 queryPage 方法进行分页查询 + PageUtils page = examquestionService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, examquestion), params), params)); + // 返回成功响应，并将分页数据放入响应结果中 return R.ok().put("data", page); } - /** + /** * 列表 */ + // 处理 /examquestion/lists 路径的请求 @RequestMapping("/lists") + // 该方法用于获取试题列表 public R list( ExamquestionEntity examquestion){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( examquestion, "examquestion")); + // 创建一个用于构建查询条件的实体包装器 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件为所有字段相等 + ew.allEq(MPUtil.allEQMapPre( examquestion, "examquestion")); + // 返回成功响应，并将查询到的试题列表放入响应结果中 return R.ok().put("data", examquestionService.selectListView(ew)); } - /** + /** * 查询 */ + // 处理 /examquestion/query 路径的请求 @RequestMapping("/query") + // 该方法用于查询单个试题信息 public R query(ExamquestionEntity examquestion){ + // 创建一个用于构建查询条件的实体包装器 EntityWrapper< ExamquestionEntity> ew = new EntityWrapper< ExamquestionEntity>(); - ew.allEq(MPUtil.allEQMapPre( examquestion, "examquestion")); - ExamquestionView examquestionView = examquestionService.selectView(ew); - return R.ok("查询试题表成功").put("data", examquestionView); + // 设置查询条件为所有字段相等 + ew.allEq(MPUtil.allEQMapPre( examquestion, "examquestion")); + // 调用试题服务类的 selectView 方法查询单个试题信息 + ExamquestionView examquestionView = examquestionService.selectView(ew); + // 返回成功响应，并将查询到的试题信息放入响应结果中 + return R.ok("查询试题表成功").put("data", examquestionView); } - + /** * 后端详情 */ + // 处理 /examquestion/info/{id} 路径的请求，{id} 为路径变量 @RequestMapping("/info/{id}") + // 该方法用于获取单个试题的详细信息 public R info(@PathVariable("id") Long id){ + // 调用试题服务类的 selectById 方法根据 ID 查询试题信息 ExamquestionEntity examquestion = examquestionService.selectById(id); + // 返回成功响应，并将查询到的试题信息放入响应结果中 return R.ok().put("data", examquestion); } /** * 前端详情 */ + // 处理 /examquestion/detail/{id} 路径的请求，{id} 为路径变量 @RequestMapping("/detail/{id}") + // 该方法用于获取单个试题的详细信息（前端使用） public R detail(@PathVariable("id") Long id){ + // 调用试题服务类的 selectById 方法根据 ID 查询试题信息 ExamquestionEntity examquestion = examquestionService.selectById(id); + // 返回成功响应，并将查询到的试题信息放入响应结果中 return R.ok().put("data", examquestion); } - + /** * 后端保存 */ + // 处理 /examquestion/save 路径的 POST 请求 @RequestMapping("/save") + // 该方法用于保存新的试题信息 public R save(@RequestBody ExamquestionEntity examquestion, HttpServletRequest request){ - examquestion.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(examquestion); + // 为试题设置一个唯一的 ID，由当前时间戳加上一个随机数组成 + examquestion.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); + // 暂时注释掉实体验证逻辑 + //ValidatorUtils.validateEntity(examquestion); + // 调用试题服务类的 insert 方法将试题信息插入数据库 examquestionService.insert(examquestion); + // 返回成功响应 return R.ok(); } - + /** * 前端保存 */ + // 处理 /examquestion/add 路径的 POST 请求 @RequestMapping("/add") + // 该方法用于保存新的试题信息（前端使用） public R add(@RequestBody ExamquestionEntity examquestion, HttpServletRequest request){ - examquestion.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(examquestion); + // 为试题设置一个唯一的 ID，由当前时间戳加上一个随机数组成 + examquestion.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); + // 暂时注释掉实体验证逻辑 + //ValidatorUtils.validateEntity(examquestion); + // 调用试题服务类的 insert 方法将试题信息插入数据库 examquestionService.insert(examquestion); + // 返回成功响应 return R.ok(); } /** * 修改 */ + // 处理 /examquestion/update 路径的 POST 请求 @RequestMapping("/update") + // 该方法用于更新试题信息 public R update(@RequestBody ExamquestionEntity examquestion, HttpServletRequest request){ + // 暂时注释掉实体验证逻辑 //ValidatorUtils.validateEntity(examquestion); + // 调用试题服务类的 updateById 方法根据 ID 更新试题信息 examquestionService.updateById(examquestion);//全部更新 + // 返回成功响应 return R.ok(); } - + /** * 删除 */ + // 处理 /examquestion/delete 路径的 POST 请求 @RequestMapping("/delete") + // 该方法用于批量删除试题信息 public R delete(@RequestBody Long[] ids){ + // 调用试题服务类的 deleteBatchIds 方法根据 ID 批量删除试题信息 examquestionService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 return R.ok(); } - + /** * 提醒接口 */ - @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 = examquestionService.selectCount(wrapper); - return R.ok().put("count", count); - } - - - -} + // 处理 /examquestion/remind/{columnName}/{type} 路径的请求，{columnName} 和 {type} 为路径变量 + @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); + + // 如果提醒类型为 2 + if(type.equals("2")) { + // 创建一个用于格式化日期的对象 + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + // 创建一个 Calendar 实例用于处理日期 + Calendar c = Calendar.getInstance(); + // 定义提醒开始日期和结束日期 + Date remindStartDate = null; + Date remindEndDate = null; + // 如果请求参数中包含提醒开始时间 + if(map.get("remindstart")!=null) { + // 将提醒开始时间转换为整数 + Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); + // 设置 Calendar 的时间为当前时间 + 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()); + // 设置 Calendar 的时间为当前时间 + 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")); + } + + + // 调用试题服务类的 selectCount 方法统计符合条件的试题数量 + int count = examquestionService.selectCount(wrapper); + // 返回成功响应，并将统计结果放入响应结果中 + return R.ok().put("count", count); + } + + +} \ No newline at end of file diff --git a/src/main/java/com/controller/ExamrecordController.java b/src/main/java/com/controller/ExamrecordController.java index 1b8174b..15169c2 100644 --- a/src/main/java/com/controller/ExamrecordController.java +++ b/src/main/java/com/controller/ExamrecordController.java @@ -1,238 +1,369 @@ package com.controller; +// 导入用于格式化日期的类 import java.text.SimpleDateFormat; +// 导入 ArrayList 类，用于创建动态数组 import java.util.ArrayList; +// 导入 Arrays 类，用于操作数组 import java.util.Arrays; +// 导入 Calendar 类，用于处理日期和时间 import java.util.Calendar; +// 导入 Map 接口，用于存储键值对 import java.util.Map; +// 导入 HashMap 类，实现了 Map 接口 import java.util.HashMap; +// 导入 Iterator 接口，用于遍历集合 import java.util.Iterator; +// 导入 Date 类，用于表示日期和时间 import java.util.Date; +// 导入 List 接口，用于创建列表 import java.util.List; +// 导入 HttpServletRequest 类，用于处理 HTTP 请求 import javax.servlet.http.HttpServletRequest; +// 导入验证工具类 import com.utils.ValidatorUtils; +// 导入 Apache Commons Lang 库中的 StringUtils 类，用于处理字符串 import org.apache.commons.lang3.StringUtils; +// 导入 Spring 框架的自动注入注解 import org.springframework.beans.factory.annotation.Autowired; +// 导入 Spring 框架的日期格式化注解 import org.springframework.format.annotation.DateTimeFormat; +// 导入 Spring 框架的路径变量注解 import org.springframework.web.bind.annotation.PathVariable; +// 导入 Spring 框架的请求体注解 import org.springframework.web.bind.annotation.RequestBody; +// 导入 Spring 框架的请求映射注解 import org.springframework.web.bind.annotation.RequestMapping; +// 导入 Spring 框架的请求参数注解 import org.springframework.web.bind.annotation.RequestParam; +// 导入 Spring 框架的 REST 控制器注解 import org.springframework.web.bind.annotation.RestController; +// 导入 MyBatis-Plus 的实体包装器类 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入 MyBatis-Plus 的包装器接口 import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的忽略认证注解 import com.annotation.IgnoreAuth; +// 导入考试记录实体类 import com.entity.ExamrecordEntity; +// 导入考试记录视图类 import com.entity.view.ExamrecordView; +// 导入考试记录服务类 import com.service.ExamrecordService; +// 导入令牌服务类 import com.service.TokenService; +// 导入分页工具类 import com.utils.PageUtils; +// 导入自定义的响应类 import com.utils.R; +// 导入 MD5 加密工具类 import com.utils.MD5Util; +// 导入 MyBatis-Plus 工具类 import com.utils.MPUtil; +// 导入通用工具类 import com.utils.CommonUtil; /** * 考试记录表 * 后端接口 - * @author - * @email + * @author + * @email * @date 2021-05-09 15:46:15 */ +// 声明为 REST 控制器，用于处理 HTTP 请求 @RestController +// 映射请求路径，所有以 /examrecord 开头的请求都会被该控制器处理 @RequestMapping("/examrecord") public class ExamrecordController { + // 自动注入考试记录服务类的实例 @Autowired private ExamrecordService examrecordService; - - /** + + /** * 考试记录接口 */ + // 映射请求路径 /examrecord/groupby @RequestMapping("/groupby") + // 处理分组查询请求 public R page2(@RequestParam Map params,ExamrecordEntity examrecord, HttpServletRequest request){ - if(!request.getSession().getAttribute("role").toString().equals("管理员")) { - examrecord.setUserid((Long)request.getSession().getAttribute("userId")); - } + // 如果当前用户不是管理员 + if(!request.getSession().getAttribute("role").toString().equals("管理员")) { + // 设置考试记录的用户 ID 为当前用户的 ID + examrecord.setUserid((Long)request.getSession().getAttribute("userId")); + } + // 创建一个实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = examrecordService.queryPageGroupBy(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, examrecord), params), params)); + // 调用考试记录服务类的查询分页分组方法 + PageUtils page = examrecordService.queryPageGroupBy(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, examrecord), params), params)); + // 返回成功响应，并将分页数据放入响应中 return R.ok().put("data", page); } /** * 后端列表 */ + // 映射请求路径 /examrecord/page @RequestMapping("/page") + // 处理后端分页查询请求 public R page(@RequestParam Map params,ExamrecordEntity examrecord, - HttpServletRequest request){ - if(!request.getSession().getAttribute("role").toString().equals("管理员")) { - examrecord.setUserid((Long)request.getSession().getAttribute("userId")); - } + HttpServletRequest request){ + // 如果当前用户不是管理员 + if(!request.getSession().getAttribute("role").toString().equals("管理员")) { + // 设置考试记录的用户 ID 为当前用户的 ID + examrecord.setUserid((Long)request.getSession().getAttribute("userId")); + } + // 创建一个实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = examrecordService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, examrecord), params), params)); + // 调用考试记录服务类的查询分页方法 + PageUtils page = examrecordService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, examrecord), params), params)); + // 返回成功响应，并将分页数据放入响应中 return R.ok().put("data", page); } - + /** * 前端列表 */ + // 映射请求路径 /examrecord/list @RequestMapping("/list") - public R list(@RequestParam Map params,ExamrecordEntity examrecord, - HttpServletRequest request){ - if(!request.getSession().getAttribute("role").toString().equals("管理员")) { - examrecord.setUserid((Long)request.getSession().getAttribute("userId")); - } + // 处理前端分页查询请求 + public R list(@RequestParam Map params,ExamrecordEntity examrecord, + HttpServletRequest request){ + // 如果当前用户不是管理员 + if(!request.getSession().getAttribute("role").toString().equals("管理员")) { + // 设置考试记录的用户 ID 为当前用户的 ID + examrecord.setUserid((Long)request.getSession().getAttribute("userId")); + } + // 创建一个实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = examrecordService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, examrecord), params), params)); + // 调用考试记录服务类的查询分页方法 + PageUtils page = examrecordService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, examrecord), params), params)); + // 返回成功响应，并将分页数据放入响应中 return R.ok().put("data", page); } - /** + /** * 列表 */ + // 映射请求路径 /examrecord/lists @RequestMapping("/lists") + // 处理列表查询请求 public R list( ExamrecordEntity examrecord){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( examrecord, "examrecord")); + // 创建一个实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件，所有字段相等 + ew.allEq(MPUtil.allEQMapPre( examrecord, "examrecord")); + // 返回成功响应，并将查询结果放入响应中 return R.ok().put("data", examrecordService.selectListView(ew)); } - /** + /** * 查询 */ + // 映射请求路径 /examrecord/query @RequestMapping("/query") + // 处理查询请求 public R query(ExamrecordEntity examrecord){ + // 创建一个实体包装器，用于构建查询条件 EntityWrapper< ExamrecordEntity> ew = new EntityWrapper< ExamrecordEntity>(); - ew.allEq(MPUtil.allEQMapPre( examrecord, "examrecord")); - ExamrecordView examrecordView = examrecordService.selectView(ew); - return R.ok("查询考试记录表成功").put("data", examrecordView); + // 设置查询条件，所有字段相等 + ew.allEq(MPUtil.allEQMapPre( examrecord, "examrecord")); + // 调用考试记录服务类的查询视图方法 + ExamrecordView examrecordView = examrecordService.selectView(ew); + // 返回成功响应，并将查询结果放入响应中 + return R.ok("查询考试记录表成功").put("data", examrecordView); } - + /** * 后端详情 */ + // 映射请求路径 /examrecord/info/{id} @RequestMapping("/info/{id}") + // 处理后端详情查询请求 public R info(@PathVariable("id") Long id){ + // 根据 ID 查询考试记录实体 ExamrecordEntity examrecord = examrecordService.selectById(id); + // 返回成功响应，并将查询结果放入响应中 return R.ok().put("data", examrecord); } /** * 前端详情 */ + // 映射请求路径 /examrecord/detail/{id} @RequestMapping("/detail/{id}") + // 处理前端详情查询请求 public R detail(@PathVariable("id") Long id){ + // 根据 ID 查询考试记录实体 ExamrecordEntity examrecord = examrecordService.selectById(id); + // 返回成功响应，并将查询结果放入响应中 return R.ok().put("data", examrecord); } - + /** * 后端保存 */ + // 映射请求路径 /examrecord/save @RequestMapping("/save") + // 处理后端保存请求 public R save(@RequestBody ExamrecordEntity examrecord, HttpServletRequest request){ - examrecord.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(examrecord); - examrecord.setUserid((Long)request.getSession().getAttribute("userId")); + // 生成一个唯一的 ID + examrecord.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); + // 验证实体（注释掉，未启用） + //ValidatorUtils.validateEntity(examrecord); + // 设置考试记录的用户 ID 为当前用户的 ID + examrecord.setUserid((Long)request.getSession().getAttribute("userId")); + // 调用考试记录服务类的插入方法 examrecordService.insert(examrecord); + // 返回成功响应 return R.ok(); } - + /** * 前端保存 */ + // 映射请求路径 /examrecord/add @RequestMapping("/add") + // 处理前端保存请求 public R add(@RequestBody ExamrecordEntity examrecord, HttpServletRequest request){ - examrecord.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(examrecord); - examrecord.setUserid((Long)request.getSession().getAttribute("userId")); + // 生成一个唯一的 ID + examrecord.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); + // 验证实体（注释掉，未启用） + //ValidatorUtils.validateEntity(examrecord); + // 设置考试记录的用户 ID 为当前用户的 ID + examrecord.setUserid((Long)request.getSession().getAttribute("userId")); + // 调用考试记录服务类的插入方法 examrecordService.insert(examrecord); + // 返回成功响应 return R.ok(); } /** * 修改 */ + // 映射请求路径 /examrecord/update @RequestMapping("/update") + // 处理修改请求 public R update(@RequestBody ExamrecordEntity examrecord, HttpServletRequest request){ + // 验证实体（注释掉，未启用） //ValidatorUtils.validateEntity(examrecord); + // 调用考试记录服务类的更新方法，更新所有字段 examrecordService.updateById(examrecord);//全部更新 + // 返回成功响应 return R.ok(); } - + /** * 删除 */ + // 映射请求路径 /examrecord/delete @RequestMapping("/delete") + // 处理删除请求 public R delete(@RequestBody Long[] ids){ + // 调用考试记录服务类的批量删除方法 examrecordService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 return R.ok(); } - + /** * 提醒接口 */ - @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")); - } - if(!request.getSession().getAttribute("role").toString().equals("管理员")) { - wrapper.eq("userid", (Long)request.getSession().getAttribute("userId")); - } - - - int count = examrecordService.selectCount(wrapper); - return R.ok().put("count", count); - } - + // 映射请求路径 /examrecord/remind/{columnName}/{type} + @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); + + // 如果类型为 2 + 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")); + } + // 如果当前用户不是管理员 + if(!request.getSession().getAttribute("role").toString().equals("管理员")) { + // 设置查询条件，用户 ID 等于当前用户的 ID + wrapper.eq("userid", (Long)request.getSession().getAttribute("userId")); + } + + + // 调用考试记录服务类的统计方法，统计符合条件的记录数 + int count = examrecordService.selectCount(wrapper); + // 返回成功响应，并将统计结果放入响应中 + return R.ok().put("count", count); + } + /** * 当重新考试时，删除考生的某个试卷的所有考试记录 */ + // 映射请求路径 /examrecord/deleteRecords @RequestMapping("/deleteRecords") + // 处理删除指定考生指定试卷的所有考试记录请求 public R deleteRecords(@RequestParam Long userid,@RequestParam Long paperid){ - examrecordService.delete(new EntityWrapper().eq("paperid", paperid).eq("userid", userid)); + // 调用考试记录服务类的删除方法，根据用户 ID 和试卷 ID 删除记录 + examrecordService.delete(new EntityWrapper().eq("paperid", paperid).eq("userid", userid)); + // 返回成功响应 return R.ok(); } -} +} \ No newline at end of file diff --git a/src/main/java/com/controller/FileController.java b/src/main/java/com/controller/FileController.java index 7bd4f8e..5413b81 100644 --- a/src/main/java/com/controller/FileController.java +++ b/src/main/java/com/controller/FileController.java @@ -1,110 +1,187 @@ +// 声明该类所在的包 package com.controller; +// 导入用于处理文件的类 import java.io.File; +// 导入文件未找到异常类 import java.io.FileNotFoundException; +// 导入输入输出异常类 import java.io.IOException; +// 导入数组操作工具类 import java.util.Arrays; +// 导入日期类 import java.util.Date; +// 导入哈希表实现类 import java.util.HashMap; +// 导入列表接口 import java.util.List; +// 导入映射接口 import java.util.Map; +// 导入随机数生成类 import java.util.Random; +// 导入通用唯一识别码类 import java.util.UUID; +// 导入 Apache Commons IO 库的文件工具类 import org.apache.commons.io.FileUtils; +// 导入 Apache Commons Lang 库的字符串工具类 import org.apache.commons.lang3.StringUtils; +// 导入 Spring 框架的自动注入注解 import org.springframework.beans.factory.annotation.Autowired; +// 导入 Spring 框架的 HTTP 头类 import org.springframework.http.HttpHeaders; +// 导入 Spring 框架的 HTTP 状态码类 import org.springframework.http.HttpStatus; +// 导入 Spring 框架的媒体类型类 import org.springframework.http.MediaType; +// 导入 Spring 框架的响应实体类 import org.springframework.http.ResponseEntity; +// 导入 Spring 框架的资源工具类 import org.springframework.util.ResourceUtils; +// 导入 Spring 框架的路径变量注解 import org.springframework.web.bind.annotation.PathVariable; +// 导入 Spring 框架的请求体注解 import org.springframework.web.bind.annotation.RequestBody; +// 导入 Spring 框架的请求映射注解 import org.springframework.web.bind.annotation.RequestMapping; +// 导入 Spring 框架的请求参数注解 import org.springframework.web.bind.annotation.RequestParam; +// 导入 Spring 框架的 REST 控制器注解 import org.springframework.web.bind.annotation.RestController; +// 导入 Spring 框架的文件上传类 import org.springframework.web.multipart.MultipartFile; +// 导入自定义的忽略认证注解 import com.annotation.IgnoreAuth; +// 导入 MyBatis-Plus 的实体包装器类 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入配置实体类 import com.entity.ConfigEntity; +// 导入自定义异常类 import com.entity.EIException; +// 导入配置服务类 import com.service.ConfigService; +// 导入自定义响应类 import com.utils.R; /** * 上传文件映射表 */ +// 声明为 REST 控制器，用于处理 HTTP 请求 @RestController +// 映射请求路径，所有以 /file 开头的请求都会被该控制器处理 @RequestMapping("file") +// 抑制未经检查的类型转换警告 @SuppressWarnings({"unchecked","rawtypes"}) +// 文件控制器类，处理文件上传和下载请求 public class FileController{ + // 自动注入配置服务类的实例 @Autowired - private ConfigService configService; + private ConfigService configService; /** * 上传文件 */ + // 映射请求路径 /file/upload @RequestMapping("/upload") + // 处理文件上传请求 public R upload(@RequestParam("file") MultipartFile file,String type) throws Exception { + // 检查上传的文件是否为空 if (file.isEmpty()) { + // 若为空，抛出自定义异常 throw new EIException("上传文件不能为空"); } + // 获取文件扩展名 String fileExt = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".")+1); + // 获取类路径下 static 目录的文件对象 File path = new File(ResourceUtils.getURL("classpath:static").getPath()); + // 检查该目录是否存在 if(!path.exists()) { - path = new File(""); + // 若不存在，创建一个空文件对象 + path = new File(""); } + // 创建上传目录的文件对象 File upload = new File(path.getAbsolutePath(),"/upload/"); + // 检查上传目录是否存在 if(!upload.exists()) { - upload.mkdirs(); + // 若不存在，创建该目录及其父目录 + upload.mkdirs(); } + // 生成新的文件名，格式为时间戳加扩展名 String fileName = new Date().getTime()+"."+fileExt; + // 创建目标文件对象 File dest = new File(upload.getAbsolutePath()+"/"+fileName); + // 将上传的文件转移到目标文件 file.transferTo(dest); + // 检查类型参数是否不为空且等于 "1" if(StringUtils.isNotBlank(type) && type.equals("1")) { + // 根据配置名称查询配置实体 ConfigEntity configEntity = configService.selectOne(new EntityWrapper().eq("name", "faceFile")); + // 若配置实体不存在 if(configEntity==null) { + // 创建新的配置实体 configEntity = new ConfigEntity(); + // 设置配置名称 configEntity.setName("faceFile"); + // 设置配置值为文件名 configEntity.setValue(fileName); } else { + // 若配置实体存在，更新配置值为文件名 configEntity.setValue(fileName); } + // 插入或更新配置实体 configService.insertOrUpdate(configEntity); } + // 返回成功响应，并将文件名放入响应中 return R.ok().put("file", fileName); } - + /** * 下载文件 */ + // 该接口忽略认证 @IgnoreAuth + // 映射请求路径 /file/download @RequestMapping("/download") + // 处理文件下载请求 public ResponseEntity download(@RequestParam String fileName) { try { + // 获取类路径下 static 目录的文件对象 File path = new File(ResourceUtils.getURL("classpath:static").getPath()); + // 检查该目录是否存在 if(!path.exists()) { - path = new File(""); + // 若不存在，创建一个空文件对象 + path = new File(""); } + // 创建上传目录的文件对象 File upload = new File(path.getAbsolutePath(),"/upload/"); + // 检查上传目录是否存在 if(!upload.exists()) { - upload.mkdirs(); + // 若不存在，创建该目录及其父目录 + upload.mkdirs(); } + // 创建要下载的文件对象 File file = new File(upload.getAbsolutePath()+"/"+fileName); + // 检查文件是否存在 if(file.exists()){ - /*if(!fileService.canRead(file, SessionManager.getSessionUser())){ - getResponse().sendError(403); - }*/ + // 这里注释掉的代码是检查用户是否有读取文件的权限 + /*if(!fileService.canRead(file, SessionManager.getSessionUser())){ + getResponse().sendError(403); + }*/ + // 创建 HTTP 头对象 HttpHeaders headers = new HttpHeaders(); - headers.setContentType(MediaType.APPLICATION_OCTET_STREAM); - headers.setContentDispositionFormData("attachment", fileName); - return new ResponseEntity(FileUtils.readFileToByteArray(file),headers, HttpStatus.CREATED); + // 设置内容类型为二进制流 + headers.setContentType(MediaType.APPLICATION_OCTET_STREAM); + // 设置内容处置为附件，指定文件名 + headers.setContentDispositionFormData("attachment", fileName); + // 返回响应实体，包含文件内容、HTTP 头和 HTTP 状态码 + return new ResponseEntity(FileUtils.readFileToByteArray(file),headers, HttpStatus.CREATED); } } catch (IOException e) { + // 捕获输入输出异常并打印堆栈跟踪信息 e.printStackTrace(); } + // 若出现异常或文件不存在，返回内部服务器错误响应 return new ResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR); } - -} + +} \ No newline at end of file diff --git a/src/main/java/com/controller/ForumController.java b/src/main/java/com/controller/ForumController.java index 8939709..87f13af 100644 --- a/src/main/java/com/controller/ForumController.java +++ b/src/main/java/com/controller/ForumController.java @@ -1,238 +1,363 @@ +// 声明该类所在的包 package com.controller; +// 导入用于格式化日期的类 import java.text.SimpleDateFormat; +// 导入用于创建动态数组的类 import java.util.ArrayList; +// 导入用于操作数组的工具类 import java.util.Arrays; +// 导入用于处理日期和时间的类 import java.util.Calendar; +// 导入用于存储键值对的接口 import java.util.Map; +// 导入 HashMap 类，用于实现 Map 接口 import java.util.HashMap; +// 导入用于遍历集合的接口 import java.util.Iterator; +// 导入用于表示日期和时间的类 import java.util.Date; +// 导入用于创建列表的接口 import java.util.List; +// 导入用于处理 HTTP 请求的类 import javax.servlet.http.HttpServletRequest; +// 导入自定义的验证工具类 import com.utils.ValidatorUtils; +// 导入 Apache Commons Lang 库中的字符串处理工具类 import org.apache.commons.lang3.StringUtils; +// 导入 Spring 框架的自动注入注解 import org.springframework.beans.factory.annotation.Autowired; +// 导入 Spring 框架的日期格式化注解 import org.springframework.format.annotation.DateTimeFormat; +// 导入 Spring 框架的路径变量注解 import org.springframework.web.bind.annotation.PathVariable; +// 导入 Spring 框架的请求体注解 import org.springframework.web.bind.annotation.RequestBody; +// 导入 Spring 框架的请求映射注解 import org.springframework.web.bind.annotation.RequestMapping; +// 导入 Spring 框架的请求参数注解 import org.springframework.web.bind.annotation.RequestParam; +// 导入 Spring 框架的 REST 控制器注解 import org.springframework.web.bind.annotation.RestController; +// 导入 MyBatis-Plus 的实体包装器类 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入 MyBatis-Plus 的包装器接口 import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的忽略认证注解 import com.annotation.IgnoreAuth; +// 导入学习交流实体类 import com.entity.ForumEntity; +// 导入学习交流视图类 import com.entity.view.ForumView; +// 导入学习交流服务类 import com.service.ForumService; +// 导入令牌服务类 import com.service.TokenService; +// 导入分页工具类 import com.utils.PageUtils; +// 导入自定义的响应类 import com.utils.R; +// 导入 MD5 加密工具类 import com.utils.MD5Util; +// 导入 MyBatis-Plus 工具类 import com.utils.MPUtil; +// 导入通用工具类 import com.utils.CommonUtil; /** * 学习交流 * 后端接口 - * @author - * @email + * @author + * @email * @date 2021-05-09 15:46:15 */ +// 声明该类为 REST 控制器，用于处理 HTTP 请求 @RestController +// 映射请求路径，所有以 /forum 开头的请求都会由该控制器处理 @RequestMapping("/forum") public class ForumController { + // 自动注入学习交流服务类的实例 @Autowired private ForumService forumService; - /** * 后端列表 */ + // 映射请求路径 /forum/page @RequestMapping("/page") - public R page(@RequestParam Map params,ForumEntity forum, - HttpServletRequest request){ - if(!request.getSession().getAttribute("role").toString().equals("管理员")) { - forum.setUserid((Long)request.getSession().getAttribute("userId")); - } + // 处理后端分页查询学习交流列表的请求 + public R page(@RequestParam Map params, ForumEntity forum, + HttpServletRequest request) { + // 如果当前用户不是管理员 + if (!request.getSession().getAttribute("role").toString().equals("管理员")) { + // 设置学习交流的用户 ID 为当前用户的 ID + forum.setUserid((Long) request.getSession().getAttribute("userId")); + } + // 创建一个实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params)); - + // 调用学习交流服务类的查询分页方法，进行排序、范围和模糊查询 + PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params)); + // 返回成功响应，并将分页数据放入响应中 return R.ok().put("data", page); } - + /** * 前端列表 */ + // 映射请求路径 /forum/list @RequestMapping("/list") - public R list(@RequestParam Map params,ForumEntity forum, - HttpServletRequest request){ - if(!request.getSession().getAttribute("role").toString().equals("管理员")) { - forum.setUserid((Long)request.getSession().getAttribute("userId")); - } + // 处理前端分页查询学习交流列表的请求 + public R list(@RequestParam Map params, ForumEntity forum, + HttpServletRequest request) { + // 如果当前用户不是管理员 + if (!request.getSession().getAttribute("role").toString().equals("管理员")) { + // 设置学习交流的用户 ID 为当前用户的 ID + forum.setUserid((Long) request.getSession().getAttribute("userId")); + } + // 创建一个实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params)); + // 调用学习交流服务类的查询分页方法，进行排序、范围和模糊查询 + PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params)); + // 返回成功响应，并将分页数据放入响应中 return R.ok().put("data", page); } - /** + /** * 列表 */ + // 该接口忽略认证 @IgnoreAuth + // 映射请求路径 /forum/flist @RequestMapping("/flist") - public R flist(@RequestParam Map params,ForumEntity forum, HttpServletRequest request){ + // 处理查询学习交流列表的请求 + public R flist(@RequestParam Map params, ForumEntity forum, HttpServletRequest request) { + // 创建一个实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allEq(ew, forum), params), params)); + // 调用学习交流服务类的查询分页方法，进行排序、范围和全量相等查询 + PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allEq(ew, forum), params), params)); + // 返回成功响应，并将分页数据放入响应中 return R.ok().put("data", page); } - /** + /** * 查询 */ + // 映射请求路径 /forum/query @RequestMapping("/query") - public R query(ForumEntity forum){ - EntityWrapper< ForumEntity> ew = new EntityWrapper< ForumEntity>(); - ew.allEq(MPUtil.allEQMapPre( forum, "forum")); - ForumView forumView = forumService.selectView(ew); - return R.ok("查询学习交流成功").put("data", forumView); + // 处理查询学习交流信息的请求 + public R query(ForumEntity forum) { + // 创建一个实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件，所有字段相等 + ew.allEq(MPUtil.allEQMapPre(forum, "forum")); + // 调用学习交流服务类的查询视图方法 + ForumView forumView = forumService.selectView(ew); + // 返回成功响应，并将查询结果放入响应中 + return R.ok("查询学习交流成功").put("data", forumView); } - + /** * 后端详情 */ + // 映射请求路径 /forum/info/{id} @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id){ + // 处理后端查询学习交流详情的请求 + public R info(@PathVariable("id") Long id) { + // 根据 ID 查询学习交流实体 ForumEntity forum = forumService.selectById(id); + // 返回成功响应，并将查询结果放入响应中 return R.ok().put("data", forum); } /** * 前端详情 */ + // 映射请求路径 /forum/detail/{id} @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id){ + // 处理前端查询学习交流详情的请求 + public R detail(@PathVariable("id") Long id) { + // 根据 ID 查询学习交流实体 ForumEntity forum = forumService.selectById(id); + // 返回成功响应，并将查询结果放入响应中 return R.ok().put("data", forum); } - - /** + + /** * 论坛详情 */ - @IgnoreAuth + // 该接口忽略认证 + @IgnoreAuth + // 映射请求路径 /forum/list/{id} @RequestMapping("/list/{id}") - public R list(@PathVariable("id") String id){ + // 处理查询论坛详情的请求 + public R list(@PathVariable("id") String id) { + // 根据 ID 查询学习交流实体 ForumEntity forum = forumService.selectById(id); + // 递归获取子论坛信息 getChilds(forum); + // 返回成功响应，并将查询结果放入响应中 return R.ok().put("data", forum); } - - private ForumEntity getChilds(ForumEntity forum) { - List childs = new ArrayList(); - childs = forumService.selectList(new EntityWrapper().eq("parentid", forum.getId())); - if(childs == null || childs.size()==0) { - return null; - } - forum.setChilds(childs); - for(ForumEntity forumEntity : childs) { - getChilds(forumEntity); - } - return forum; - } - + // 递归获取子论坛信息的方法 + private ForumEntity getChilds(ForumEntity forum) { + // 创建一个存储子论坛的列表 + List childs = new ArrayList(); + // 查询该论坛的所有子论坛 + childs = forumService.selectList(new EntityWrapper().eq("parentid", forum.getId())); + // 如果没有子论坛 + if (childs == null || childs.size() == 0) { + // 返回 null + return null; + } + // 设置该论坛的子论坛列表 + forum.setChilds(childs); + // 递归处理每个子论坛 + for (ForumEntity forumEntity : childs) { + getChilds(forumEntity); + } + // 返回该论坛 + return forum; + } /** * 后端保存 */ + // 映射请求路径 /forum/save @RequestMapping("/save") - public R save(@RequestBody ForumEntity forum, HttpServletRequest request){ - forum.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(forum); - forum.setUserid((Long)request.getSession().getAttribute("userId")); + // 处理后端保存学习交流信息的请求 + public R save(@RequestBody ForumEntity forum, HttpServletRequest request) { + // 生成一个唯一的 ID + forum.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 验证实体（注释掉，未启用） + //ValidatorUtils.validateEntity(forum); + // 设置学习交流的用户 ID 为当前用户的 ID + forum.setUserid((Long) request.getSession().getAttribute("userId")); + // 调用学习交流服务类的插入方法 forumService.insert(forum); + // 返回成功响应 return R.ok(); } - + /** * 前端保存 */ + // 映射请求路径 /forum/add @RequestMapping("/add") - public R add(@RequestBody ForumEntity forum, HttpServletRequest request){ - forum.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(forum); - forum.setUserid((Long)request.getSession().getAttribute("userId")); + // 处理前端保存学习交流信息的请求 + public R add(@RequestBody ForumEntity forum, HttpServletRequest request) { + // 生成一个唯一的 ID + forum.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 验证实体（注释掉，未启用） + //ValidatorUtils.validateEntity(forum); + // 设置学习交流的用户 ID 为当前用户的 ID + forum.setUserid((Long) request.getSession().getAttribute("userId")); + // 调用学习交流服务类的插入方法 forumService.insert(forum); + // 返回成功响应 return R.ok(); } /** * 修改 */ + // 映射请求路径 /forum/update @RequestMapping("/update") - public R update(@RequestBody ForumEntity forum, HttpServletRequest request){ + // 处理修改学习交流信息的请求 + public R update(@RequestBody ForumEntity forum, HttpServletRequest request) { + // 验证实体（注释掉，未启用） //ValidatorUtils.validateEntity(forum); - forumService.updateById(forum);//全部更新 + // 调用学习交流服务类的更新方法，更新所有字段 + forumService.updateById(forum); // 全部更新 + // 返回成功响应 return R.ok(); } - /** * 删除 */ + // 映射请求路径 /forum/delete @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ + // 处理删除学习交流信息的请求 + public R delete(@RequestBody Long[] ids) { + // 调用学习交流服务类的批量删除方法 forumService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 return R.ok(); } - + /** * 提醒接口 */ - @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 = forumService.selectCount(wrapper); - return R.ok().put("count", count); - } - - - -} + // 映射请求路径 /forum/remind/{columnName}/{type} + @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); + + // 如果类型为 2 + 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 = forumService.selectCount(wrapper); + // 返回成功响应，并将统计结果放入响应中 + return R.ok().put("count", count); + } +} \ No newline at end of file diff --git a/src/main/java/com/controller/GoumaidekechengController.java b/src/main/java/com/controller/GoumaidekechengController.java index a05788a..5739c03 100644 --- a/src/main/java/com/controller/GoumaidekechengController.java +++ b/src/main/java/com/controller/GoumaidekechengController.java @@ -1,214 +1,317 @@ package com.controller; +// 导入用于格式化日期的类 import java.text.SimpleDateFormat; +// 导入用于创建动态数组的类 import java.util.ArrayList; +// 导入用于操作数组的工具类 import java.util.Arrays; +// 导入用于处理日期和时间的类 import java.util.Calendar; +// 导入用于存储键值对的接口 import java.util.Map; +// 导入 HashMap 类，用于实现 Map 接口 import java.util.HashMap; +// 导入用于遍历集合的接口 import java.util.Iterator; +// 导入用于表示日期和时间的类 import java.util.Date; +// 导入用于创建列表的接口 import java.util.List; +// 导入用于处理 HTTP 请求的类 import javax.servlet.http.HttpServletRequest; +// 导入自定义的验证工具类 import com.utils.ValidatorUtils; +// 导入 Apache Commons Lang 库中的字符串处理工具类 import org.apache.commons.lang3.StringUtils; +// 导入 Spring 框架的自动注入注解 import org.springframework.beans.factory.annotation.Autowired; +// 导入 Spring 框架的日期格式化注解 import org.springframework.format.annotation.DateTimeFormat; +// 导入 Spring 框架的路径变量注解 import org.springframework.web.bind.annotation.PathVariable; +// 导入 Spring 框架的请求体注解 import org.springframework.web.bind.annotation.RequestBody; +// 导入 Spring 框架的请求映射注解 import org.springframework.web.bind.annotation.RequestMapping; +// 导入 Spring 框架的请求参数注解 import org.springframework.web.bind.annotation.RequestParam; +// 导入 Spring 框架的 REST 控制器注解 import org.springframework.web.bind.annotation.RestController; +// 导入 MyBatis-Plus 的实体包装器类 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入 MyBatis-Plus 的包装器接口 import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的忽略认证注解 import com.annotation.IgnoreAuth; +// 导入购买的课程实体类 import com.entity.GoumaidekechengEntity; +// 导入购买的课程视图类 import com.entity.view.GoumaidekechengView; +// 导入购买的课程服务类 import com.service.GoumaidekechengService; +// 导入令牌服务类 import com.service.TokenService; +// 导入分页工具类 import com.utils.PageUtils; +// 导入自定义的响应类 import com.utils.R; +// 导入 MD5 加密工具类 import com.utils.MD5Util; +// 导入 MyBatis-Plus 工具类 import com.utils.MPUtil; +// 导入通用工具类 import com.utils.CommonUtil; /** * 购买的课程 * 后端接口 - * @author - * @email + * @author + * @email * @date 2021-05-09 15:46:14 */ +// 声明为 REST 控制器，用于处理 HTTP 请求 @RestController +// 映射请求路径，所有以 /goumaidekecheng 开头的请求由该控制器处理 @RequestMapping("/goumaidekecheng") public class GoumaidekechengController { + // 自动注入购买的课程服务类实例 @Autowired private GoumaidekechengService goumaidekechengService; - /** - * 后端列表 + * 后端列表（分页查询） */ + // 映射请求路径 /goumaidekecheng/page @RequestMapping("/page") - public R page(@RequestParam Map params,GoumaidekechengEntity goumaidekecheng, - HttpServletRequest request){ - String tableName = request.getSession().getAttribute("tableName").toString(); - if(tableName.equals("yonghu")) { - goumaidekecheng.setYonghuzhanghao((String)request.getSession().getAttribute("username")); - } + // 处理后端分页查询请求，参数包括查询条件、实体对象、HTTP 请求 + public R page(@RequestParam Map params, GoumaidekechengEntity goumaidekecheng, + HttpServletRequest request) { + // 从会话中获取表名（判断用户类型） + String tableName = request.getSession().getAttribute("tableName").toString(); + // 如果表名是 "yonghu"（用户表） + if (tableName.equals("yonghu")) { + // 设置查询条件：用户账号为当前登录用户的用户名 + goumaidekecheng.setYonghuzhanghao((String) request.getSession().getAttribute("username")); + } + // 创建实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = goumaidekechengService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, goumaidekecheng), params), params)); - + // 调用服务类的分页查询方法，包含排序、范围查询、模糊查询处理 + PageUtils page = goumaidekechengService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, goumaidekecheng), params), params)); + // 返回成功响应，携带分页数据 return R.ok().put("data", page); } - + /** - * 前端列表 + * 前端列表（分页查询） */ + // 映射请求路径 /goumaidekecheng/list @RequestMapping("/list") - public R list(@RequestParam Map params,GoumaidekechengEntity goumaidekecheng, - HttpServletRequest request){ + // 处理前端分页查询请求，参数包括查询条件、实体对象、HTTP 请求 + public R list(@RequestParam Map params, GoumaidekechengEntity goumaidekecheng, + HttpServletRequest request) { + // 创建实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = goumaidekechengService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, goumaidekecheng), params), params)); + // 调用服务类的分页查询方法，包含排序、范围查询、模糊查询处理 + PageUtils page = goumaidekechengService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, goumaidekecheng), params), params)); + // 返回成功响应，携带分页数据 return R.ok().put("data", page); } - /** - * 列表 + /** + * 列表（不分页，全量查询） */ + // 映射请求路径 /goumaidekecheng/lists @RequestMapping("/lists") - public R list( GoumaidekechengEntity goumaidekecheng){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( goumaidekecheng, "goumaidekecheng")); + // 处理全量查询请求，参数为实体对象 + public R list(GoumaidekechengEntity goumaidekecheng) { + // 创建实体包装器 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件：所有字段与实体对象相等（前缀为 "goumaidekecheng"） + ew.allEq(MPUtil.allEQMapPre(goumaidekecheng, "goumaidekecheng")); + // 返回成功响应，携带查询结果（视图列表） return R.ok().put("data", goumaidekechengService.selectListView(ew)); } - /** - * 查询 + /** + * 查询（单个对象） */ + // 映射请求路径 /goumaidekecheng/query @RequestMapping("/query") - public R query(GoumaidekechengEntity goumaidekecheng){ - EntityWrapper< GoumaidekechengEntity> ew = new EntityWrapper< GoumaidekechengEntity>(); - ew.allEq(MPUtil.allEQMapPre( goumaidekecheng, "goumaidekecheng")); - GoumaidekechengView goumaidekechengView = goumaidekechengService.selectView(ew); - return R.ok("查询购买的课程成功").put("data", goumaidekechengView); + // 处理单个对象查询请求，参数为实体对象 + public R query(GoumaidekechengEntity goumaidekecheng) { + // 创建实体包装器 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件：所有字段与实体对象相等（前缀为 "goumaidekecheng"） + ew.allEq(MPUtil.allEQMapPre(goumaidekecheng, "goumaidekecheng")); + // 调用服务类的视图查询方法 + GoumaidekechengView goumaidekechengView = goumaidekechengService.selectView(ew); + // 返回成功响应，携带查询结果和提示信息 + return R.ok("查询购买的课程成功").put("data", goumaidekechengView); } - + /** - * 后端详情 + * 后端详情（根据 ID 查询） */ + // 映射请求路径 /goumaidekecheng/info/{id} @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id){ + // 处理详情查询请求，参数为路径中的 ID + public R info(@PathVariable("id") Long id) { + // 根据 ID 直接查询实体对象 GoumaidekechengEntity goumaidekecheng = goumaidekechengService.selectById(id); + // 返回成功响应，携带查询到的实体数据 return R.ok().put("data", goumaidekecheng); } /** - * 前端详情 + * 前端详情（根据 ID 查询） */ + // 映射请求路径 /goumaidekecheng/detail/{id} @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id){ + // 处理详情查询请求，参数为路径中的 ID（前端调用） + public R detail(@PathVariable("id") Long id) { + // 根据 ID 直接查询实体对象 GoumaidekechengEntity goumaidekecheng = goumaidekechengService.selectById(id); + // 返回成功响应，携带查询到的实体数据 return R.ok().put("data", goumaidekecheng); } - + /** - * 后端保存 + * 后端保存（新增数据） */ + // 映射请求路径 /goumaidekecheng/save @RequestMapping("/save") - public R save(@RequestBody GoumaidekechengEntity goumaidekecheng, HttpServletRequest request){ - goumaidekecheng.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(goumaidekecheng); + // 处理后端新增请求，请求体为实体对象，携带 HTTP 请求 + public R save(@RequestBody GoumaidekechengEntity goumaidekecheng, HttpServletRequest request) { + // 生成唯一 ID（时间戳 + 随机数） + goumaidekecheng.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 实体验证（注释，未启用） + //ValidatorUtils.validateEntity(goumaidekecheng); + // 调用服务类的插入方法 goumaidekechengService.insert(goumaidekecheng); + // 返回成功响应 return R.ok(); } - + /** - * 前端保存 + * 前端保存（新增数据） */ + // 映射请求路径 /goumaidekecheng/add @RequestMapping("/add") - public R add(@RequestBody GoumaidekechengEntity goumaidekecheng, HttpServletRequest request){ - goumaidekecheng.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(goumaidekecheng); + // 处理前端新增请求，请求体为实体对象，携带 HTTP 请求 + public R add(@RequestBody GoumaidekechengEntity goumaidekecheng, HttpServletRequest request) { + // 生成唯一 ID（时间戳 + 随机数） + goumaidekecheng.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 实体验证（注释，未启用） + //ValidatorUtils.validateEntity(goumaidekecheng); + // 调用服务类的插入方法 goumaidekechengService.insert(goumaidekecheng); + // 返回成功响应 return R.ok(); } /** - * 修改 + * 修改（更新数据） */ + // 映射请求路径 /goumaidekecheng/update @RequestMapping("/update") - public R update(@RequestBody GoumaidekechengEntity goumaidekecheng, HttpServletRequest request){ + // 处理修改请求，请求体为实体对象，携带 HTTP 请求 + public R update(@RequestBody GoumaidekechengEntity goumaidekecheng, HttpServletRequest request) { + // 实体验证（注释，未启用） //ValidatorUtils.validateEntity(goumaidekecheng); - goumaidekechengService.updateById(goumaidekecheng);//全部更新 + // 调用服务类的更新方法（根据 ID 全量更新） + goumaidekechengService.updateById(goumaidekecheng); // 全部更新 + // 返回成功响应 return R.ok(); } - + /** - * 删除 + * 删除（批量删除） */ + // 映射请求路径 /goumaidekecheng/delete @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ + // 处理删除请求，请求体为 ID 数组 + public R delete(@RequestBody Long[] ids) { + // 调用服务类的批量删除方法（根据 ID 列表） goumaidekechengService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 return R.ok(); } - + /** - * 提醒接口 + * 提醒接口（统计符合条件的记录数） */ - @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("yonghuzhanghao", (String)request.getSession().getAttribute("username")); - } - - int count = goumaidekechengService.selectCount(wrapper); - return R.ok().put("count", count); - } - - - -} + // 映射请求路径 /goumaidekecheng/remind/{columnName}/{type} + @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); + + // 如果类型为 2（处理日期范围提醒） + if (type.equals("2")) { + // 创建日期格式化对象（yyyy-MM-dd 格式） + 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("yonghuzhanghao", (String) request.getSession().getAttribute("username")); + } + + // 调用服务类统计符合条件的记录数 + int count = goumaidekechengService.selectCount(wrapper); + // 返回成功响应，携带统计结果 + return R.ok().put("count", count); + } +} \ No newline at end of file diff --git a/src/main/java/com/controller/KechengleixingController.java b/src/main/java/com/controller/KechengleixingController.java index 4621d83..d099a01 100644 --- a/src/main/java/com/controller/KechengleixingController.java +++ b/src/main/java/com/controller/KechengleixingController.java @@ -1,206 +1,304 @@ package com.controller; +// 导入用于格式化日期的类 import java.text.SimpleDateFormat; +// 导入用于创建动态数组的类 import java.util.ArrayList; +// 导入用于操作数组的工具类 import java.util.Arrays; +// 导入用于处理日期和时间的类 import java.util.Calendar; +// 导入用于存储键值对的接口 import java.util.Map; +// 导入HashMap类，用于实现Map接口 import java.util.HashMap; +// 导入用于遍历集合的接口 import java.util.Iterator; +// 导入用于表示日期和时间的类 import java.util.Date; +// 导入用于创建列表的接口 import java.util.List; +// 导入用于处理HTTP请求的类 import javax.servlet.http.HttpServletRequest; +// 导入自定义的验证工具类 import com.utils.ValidatorUtils; +// 导入Apache Commons Lang库中的字符串处理工具类 import org.apache.commons.lang3.StringUtils; +// 导入Spring框架的自动注入注解 import org.springframework.beans.factory.annotation.Autowired; +// 导入Spring框架的日期格式化注解 import org.springframework.format.annotation.DateTimeFormat; +// 导入Spring框架的路径变量注解 import org.springframework.web.bind.annotation.PathVariable; +// 导入Spring框架的请求体注解 import org.springframework.web.bind.annotation.RequestBody; +// 导入Spring框架的请求映射注解 import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestParam; +// 导入Spring框架的REST控制器注解 import org.springframework.web.bind.annotation.RestController; +// 导入MyBatis-Plus的实体包装器类 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入MyBatis-Plus的包装器接口 import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的忽略认证注解 import com.annotation.IgnoreAuth; +// 导入课程类型实体类 import com.entity.KechengleixingEntity; +// 导入课程类型视图类 import com.entity.view.KechengleixingView; +// 导入课程类型服务类 import com.service.KechengleixingService; +// 导入令牌服务类 import com.service.TokenService; +// 导入分页工具类 import com.utils.PageUtils; +// 导入自定义的响应类 import com.utils.R; +// 导入MD5加密工具类 import com.utils.MD5Util; +// 导入MyBatis-Plus工具类 import com.utils.MPUtil; +// 导入通用工具类 import com.utils.CommonUtil; /** * 课程类型 * 后端接口 - * @author - * @email + * @author + * @email * @date 2021-05-09 15:46:14 */ +// 声明为REST控制器，用于处理HTTP请求 @RestController +// 映射请求路径，所有以/kechengleixing开头的请求由该控制器处理 @RequestMapping("/kechengleixing") public class KechengleixingController { + // 自动注入课程类型服务类实例 @Autowired private KechengleixingService kechengleixingService; - /** - * 后端列表 + * 后端列表（分页查询） */ + // 映射请求路径/kechengleixing/page @RequestMapping("/page") - public R page(@RequestParam Map params,KechengleixingEntity kechengleixing, - HttpServletRequest request){ + // 处理后端分页查询请求，参数包括查询条件、实体对象、HTTP请求 + public R page(@RequestParam Map params, KechengleixingEntity kechengleixing, + HttpServletRequest request) { + // 创建实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = kechengleixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, kechengleixing), params), params)); - + // 调用服务类的分页查询方法，包含排序、范围查询、模糊查询处理 + PageUtils page = kechengleixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, kechengleixing), params), params)); + // 返回成功响应，携带分页数据 return R.ok().put("data", page); } - + /** - * 前端列表 + * 前端列表（分页查询） */ + // 映射请求路径/kechengleixing/list @RequestMapping("/list") - public R list(@RequestParam Map params,KechengleixingEntity kechengleixing, - HttpServletRequest request){ + // 处理前端分页查询请求，参数包括查询条件、实体对象、HTTP请求 + public R list(@RequestParam Map params, KechengleixingEntity kechengleixing, + HttpServletRequest request) { + // 创建实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = kechengleixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, kechengleixing), params), params)); + // 调用服务类的分页查询方法，包含排序、范围查询、模糊查询处理 + PageUtils page = kechengleixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, kechengleixing), params), params)); + // 返回成功响应，携带分页数据 return R.ok().put("data", page); } - /** - * 列表 + /** + * 列表（不分页，全量查询） */ + // 映射请求路径/kechengleixing/lists（测试用接口） @RequestMapping("/lists") - public R list( KechengleixingEntity kechengleixing){ //测试 - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( kechengleixing, "kechengleixing")); + // 处理全量查询请求，参数为实体对象 + public R list(KechengleixingEntity kechengleixing) { + // 创建实体包装器 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件：所有字段与实体对象相等（前缀为"kechengleixing"） + ew.allEq(MPUtil.allEQMapPre(kechengleixing, "kechengleixing")); + // 返回成功响应，携带查询结果（视图列表） return R.ok().put("data", kechengleixingService.selectListView(ew)); } - /** - * 查询 + /** + * 查询（单个对象） */ + // 映射请求路径/kechengleixing/query @RequestMapping("/query") - public R query(KechengleixingEntity kechengleixing){ - EntityWrapper< KechengleixingEntity> ew = new EntityWrapper< KechengleixingEntity>(); - ew.allEq(MPUtil.allEQMapPre( kechengleixing, "kechengleixing")); - KechengleixingView kechengleixingView = kechengleixingService.selectView(ew); - return R.ok("查询课程类型成功").put("data", kechengleixingView); + // 处理单个对象查询请求，参数为实体对象 + public R query(KechengleixingEntity kechengleixing) { + // 创建实体包装器 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件：所有字段与实体对象相等（前缀为"kechengleixing"） + ew.allEq(MPUtil.allEQMapPre(kechengleixing, "kechengleixing")); + // 调用服务类的视图查询方法 + KechengleixingView kechengleixingView = kechengleixingService.selectView(ew); + // 返回成功响应，携带查询结果和提示信息 + return R.ok("查询课程类型成功").put("data", kechengleixingView); } - + /** - * 后端详情 + * 后端详情（根据ID查询） */ + // 映射请求路径/kechengleixing/info/{id} @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id){ + // 处理详情查询请求，参数为路径中的ID + public R info(@PathVariable("id") Long id) { + // 根据ID直接查询实体对象 KechengleixingEntity kechengleixing = kechengleixingService.selectById(id); + // 返回成功响应，携带查询到的实体数据 return R.ok().put("data", kechengleixing); } /** - * 前端详情 + * 前端详情（根据ID查询） */ + // 映射请求路径/kechengleixing/detail/{id} @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id){ + // 处理详情查询请求，参数为路径中的ID（前端调用） + public R detail(@PathVariable("id") Long id) { + // 根据ID直接查询实体对象 KechengleixingEntity kechengleixing = kechengleixingService.selectById(id); + // 返回成功响应，携带查询到的实体数据 return R.ok().put("data", kechengleixing); } - + /** - * 后端保存 + * 后端保存（新增数据） */ + // 映射请求路径/kechengleixing/save @RequestMapping("/save") - public R save(@RequestBody KechengleixingEntity kechengleixing, HttpServletRequest request){ - kechengleixing.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(kechengleixing); + // 处理后端新增请求，请求体为实体对象，携带HTTP请求 + public R save(@RequestBody KechengleixingEntity kechengleixing, HttpServletRequest request) { + // 生成唯一ID（时间戳 + 随机数） + kechengleixing.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 实体验证（注释，未启用） + //ValidatorUtils.validateEntity(kechengleixing); + // 调用服务类的插入方法 kechengleixingService.insert(kechengleixing); + // 返回成功响应 return R.ok(); } - + /** - * 前端保存 + * 前端保存（新增数据） */ + // 映射请求路径/kechengleixing/add @RequestMapping("/add") - public R add(@RequestBody KechengleixingEntity kechengleixing, HttpServletRequest request){ - kechengleixing.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(kechengleixing); + // 处理前端新增请求，请求体为实体对象，携带HTTP请求 + public R add(@RequestBody KechengleixingEntity kechengleixing, HttpServletRequest request) { + // 生成唯一ID（时间戳 + 随机数） + kechengleixing.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 实体验证（注释，未启用） + //ValidatorUtils.validateEntity(kechengleixing); + // 调用服务类的插入方法 kechengleixingService.insert(kechengleixing); + // 返回成功响应 return R.ok(); } /** - * 修改 + * 修改（更新数据） */ + // 映射请求路径/kechengleixing/update @RequestMapping("/update") - public R update(@RequestBody KechengleixingEntity kechengleixing, HttpServletRequest request){ + // 处理修改请求，请求体为实体对象，携带HTTP请求 + public R update(@RequestBody KechengleixingEntity kechengleixing, HttpServletRequest request) { + // 实体验证（注释，未启用） //ValidatorUtils.validateEntity(kechengleixing); - kechengleixingService.updateById(kechengleixing);//全部更新 + // 调用服务类的更新方法（根据ID全量更新） + kechengleixingService.updateById(kechengleixing); // 全部更新 + // 返回成功响应 return R.ok(); } - + /** - * 删除 + * 删除（批量删除） */ + // 映射请求路径/kechengleixing/delete @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ + // 处理删除请求，请求体为ID数组 + public R delete(@RequestBody Long[] ids) { + // 调用服务类的批量删除方法（根据ID列表） kechengleixingService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 return R.ok(); } - + /** - * 提醒接口 + * 提醒接口（统计符合条件的记录数） */ - @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 = kechengleixingService.selectCount(wrapper); - return R.ok().put("count", count); - } - - - -} + // 映射请求路径/kechengleixing/remind/{columnName}/{type} + @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); + + // 如果类型为2（处理日期范围提醒） + if (type.equals("2")) { + // 创建日期格式化对象（yyyy-MM-dd格式） + 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 = kechengleixingService.selectCount(wrapper); + // 返回成功响应，携带统计结果 + return R.ok().put("count", count); + } +} \ No newline at end of file diff --git a/src/main/java/com/controller/KechengxinxiController.java b/src/main/java/com/controller/KechengxinxiController.java index 332245a..3af9fda 100644 --- a/src/main/java/com/controller/KechengxinxiController.java +++ b/src/main/java/com/controller/KechengxinxiController.java @@ -1,208 +1,313 @@ +// 声明该类所在的包 package com.controller; +// 导入用于格式化日期的类 import java.text.SimpleDateFormat; +// 导入用于创建动态数组的类 import java.util.ArrayList; +// 导入用于操作数组的工具类 import java.util.Arrays; +// 导入用于处理日期和时间的类 import java.util.Calendar; +// 导入用于存储键值对的接口 import java.util.Map; +// 导入用于实现 Map 接口的 HashMap 类 import java.util.HashMap; +// 导入用于遍历集合的接口 import java.util.Iterator; +// 导入用于表示日期和时间的类 import java.util.Date; +// 导入用于创建列表的接口 import java.util.List; +// 导入用于处理 HTTP 请求的类 import javax.servlet.http.HttpServletRequest; +// 导入自定义的验证工具类 import com.utils.ValidatorUtils; +// 导入 Apache Commons Lang 库中的字符串处理工具类 import org.apache.commons.lang3.StringUtils; +// 导入 Spring 框架的自动注入注解 import org.springframework.beans.factory.annotation.Autowired; +// 导入 Spring 框架的日期格式化注解 import org.springframework.format.annotation.DateTimeFormat; +// 导入 Spring 框架的路径变量注解 import org.springframework.web.bind.annotation.PathVariable; +// 导入 Spring 框架的请求体注解 import org.springframework.web.bind.annotation.RequestBody; +// 导入 Spring 框架的请求映射注解 import org.springframework.web.bind.annotation.RequestMapping; +// 导入 Spring 框架的请求参数注解 import org.springframework.web.bind.annotation.RequestParam; +// 导入 Spring 框架的 REST 控制器注解 import org.springframework.web.bind.annotation.RestController; +// 导入 MyBatis-Plus 的实体包装器类 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入 MyBatis-Plus 的包装器接口 import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的忽略认证注解 import com.annotation.IgnoreAuth; +// 导入课程信息实体类 import com.entity.KechengxinxiEntity; +// 导入课程信息视图类 import com.entity.view.KechengxinxiView; +// 导入课程信息服务类 import com.service.KechengxinxiService; +// 导入令牌服务类 import com.service.TokenService; +// 导入分页工具类 import com.utils.PageUtils; +// 导入自定义的响应类 import com.utils.R; +// 导入 MD5 加密工具类 import com.utils.MD5Util; +// 导入 MyBatis-Plus 工具类 import com.utils.MPUtil; +// 导入通用工具类 import com.utils.CommonUtil; /** * 课程信息 * 后端接口 - * @author - * @email + * @author + * @email * @date 2021-05-09 15:46:14 */ +// 声明该类为 REST 控制器，用于处理 HTTP 请求 @RestController +// 映射请求路径，所有以 /kechengxinxi 开头的请求都会由该控制器处理 @RequestMapping("/kechengxinxi") public class KechengxinxiController { + // 自动注入课程信息服务类的实例 @Autowired private KechengxinxiService kechengxinxiService; - /** * 后端列表 */ + // 映射请求路径 /kechengxinxi/page @RequestMapping("/page") - public R page(@RequestParam Map params,KechengxinxiEntity kechengxinxi, - HttpServletRequest request){ + // 处理后端分页查询课程信息列表的请求 + public R page(@RequestParam Map params, KechengxinxiEntity kechengxinxi, + HttpServletRequest request) { + // 创建一个实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = kechengxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, kechengxinxi), params), params)); - + // 调用课程信息服务类的查询分页方法，进行排序、范围和模糊查询 + PageUtils page = kechengxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, kechengxinxi), params), params)); + // 返回成功响应，并将分页数据放入响应中 return R.ok().put("data", page); } - + /** * 前端列表 */ - @IgnoreAuth + // 该接口忽略认证 + @IgnoreAuth + // 映射请求路径 /kechengxinxi/list @RequestMapping("/list") - public R list(@RequestParam Map params,KechengxinxiEntity kechengxinxi, - HttpServletRequest request){ + // 处理前端分页查询课程信息列表的请求 + public R list(@RequestParam Map params, KechengxinxiEntity kechengxinxi, + HttpServletRequest request) { + // 创建一个实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = kechengxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, kechengxinxi), params), params)); + // 调用课程信息服务类的查询分页方法，进行排序、范围和模糊查询 + PageUtils page = kechengxinxiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, kechengxinxi), params), params)); + // 返回成功响应，并将分页数据放入响应中 return R.ok().put("data", page); } - /** + /** * 列表 */ + // 映射请求路径 /kechengxinxi/lists @RequestMapping("/lists") - public R list( KechengxinxiEntity kechengxinxi){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( kechengxinxi, "kechengxinxi")); + // 处理查询课程信息列表的请求 + public R list(KechengxinxiEntity kechengxinxi) { + // 创建一个实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件，所有字段相等 + ew.allEq(MPUtil.allEQMapPre(kechengxinxi, "kechengxinxi")); + // 返回成功响应，并将查询结果（视图列表）放入响应中 return R.ok().put("data", kechengxinxiService.selectListView(ew)); } - /** + /** * 查询 */ + // 映射请求路径 /kechengxinxi/query @RequestMapping("/query") - public R query(KechengxinxiEntity kechengxinxi){ - EntityWrapper< KechengxinxiEntity> ew = new EntityWrapper< KechengxinxiEntity>(); - ew.allEq(MPUtil.allEQMapPre( kechengxinxi, "kechengxinxi")); - KechengxinxiView kechengxinxiView = kechengxinxiService.selectView(ew); - return R.ok("查询课程信息成功").put("data", kechengxinxiView); + // 处理查询课程信息的请求 + public R query(KechengxinxiEntity kechengxinxi) { + // 创建一个实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件，所有字段相等 + ew.allEq(MPUtil.allEQMapPre(kechengxinxi, "kechengxinxi")); + // 调用课程信息服务类的查询视图方法 + KechengxinxiView kechengxinxiView = kechengxinxiService.selectView(ew); + // 返回成功响应，并将查询结果放入响应中，附带成功提示信息 + return R.ok("查询课程信息成功").put("data", kechengxinxiView); } - + /** * 后端详情 */ + // 映射请求路径 /kechengxinxi/info/{id} @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id){ + // 处理后端查询课程信息详情的请求 + public R info(@PathVariable("id") Long id) { + // 根据 ID 查询课程信息实体 KechengxinxiEntity kechengxinxi = kechengxinxiService.selectById(id); + // 返回成功响应，并将查询结果放入响应中 return R.ok().put("data", kechengxinxi); } /** * 前端详情 */ + // 映射请求路径 /kechengxinxi/detail/{id} @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id){ + // 处理前端查询课程信息详情的请求 + public R detail(@PathVariable("id") Long id) { + // 根据 ID 查询课程信息实体 KechengxinxiEntity kechengxinxi = kechengxinxiService.selectById(id); + // 返回成功响应，并将查询结果放入响应中 return R.ok().put("data", kechengxinxi); } - - - /** * 后端保存 */ + // 映射请求路径 /kechengxinxi/save @RequestMapping("/save") - public R save(@RequestBody KechengxinxiEntity kechengxinxi, HttpServletRequest request){ - kechengxinxi.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(kechengxinxi); + // 处理后端保存课程信息的请求 + public R save(@RequestBody KechengxinxiEntity kechengxinxi, HttpServletRequest request) { + // 生成一个唯一的 ID + kechengxinxi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 验证实体（注释掉，未启用） + //ValidatorUtils.validateEntity(kechengxinxi); + // 调用课程信息服务类的插入方法 kechengxinxiService.insert(kechengxinxi); + // 返回成功响应 return R.ok(); } - + /** * 前端保存 */ - @IgnoreAuth + // 该接口忽略认证 + @IgnoreAuth + // 映射请求路径 /kechengxinxi/add @RequestMapping("/add") - public R add(@RequestBody KechengxinxiEntity kechengxinxi, HttpServletRequest request){ - kechengxinxi.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(kechengxinxi); + // 处理前端保存课程信息的请求 + public R add(@RequestBody KechengxinxiEntity kechengxinxi, HttpServletRequest request) { + // 生成一个唯一的 ID + kechengxinxi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 验证实体（注释掉，未启用） + //ValidatorUtils.validateEntity(kechengxinxi); + // 调用课程信息服务类的插入方法 kechengxinxiService.insert(kechengxinxi); + // 返回成功响应 return R.ok(); } /** * 修改 */ + // 映射请求路径 /kechengxinxi/update @RequestMapping("/update") - public R update(@RequestBody KechengxinxiEntity kechengxinxi, HttpServletRequest request){ + // 处理修改课程信息的请求 + public R update(@RequestBody KechengxinxiEntity kechengxinxi, HttpServletRequest request) { + // 验证实体（注释掉，未启用） //ValidatorUtils.validateEntity(kechengxinxi); - kechengxinxiService.updateById(kechengxinxi);//全部更新 + // 调用课程信息服务类的更新方法，更新所有字段 + kechengxinxiService.updateById(kechengxinxi); // 全部更新 + // 返回成功响应 return R.ok(); } - /** * 删除 */ + // 映射请求路径 /kechengxinxi/delete @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ + // 处理删除课程信息的请求 + public R delete(@RequestBody Long[] ids) { + // 调用课程信息服务类的批量删除方法 kechengxinxiService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 return R.ok(); } - + /** * 提醒接口 */ - @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 = kechengxinxiService.selectCount(wrapper); - return R.ok().put("count", count); - } - - - -} + // 映射请求路径 /kechengxinxi/remind/{columnName}/{type} + @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); + + // 如果类型为 2 + 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 = kechengxinxiService.selectCount(wrapper); + // 返回成功响应，并将统计结果放入响应中 + return R.ok().put("count", count); + } +} \ No newline at end of file diff --git a/src/main/java/com/controller/MessagesController.java b/src/main/java/com/controller/MessagesController.java index b1d92c4..d94aa74 100644 --- a/src/main/java/com/controller/MessagesController.java +++ b/src/main/java/com/controller/MessagesController.java @@ -1,213 +1,316 @@ package com.controller; +// 导入用于格式化日期的类 import java.text.SimpleDateFormat; +// 导入用于创建动态数组的类 import java.util.ArrayList; +// 导入用于操作数组的工具类 import java.util.Arrays; +// 导入用于处理日期和时间的类 import java.util.Calendar; +// 导入用于存储键值对的接口 import java.util.Map; +// 导入用于实现Map接口的HashMap类 import java.util.HashMap; +// 导入用于遍历集合的接口 import java.util.Iterator; +// 导入用于表示日期和时间的类 import java.util.Date; +// 导入用于创建列表的接口 import java.util.List; +// 导入用于处理HTTP请求的类 import javax.servlet.http.HttpServletRequest; +// 导入自定义的验证工具类 import com.utils.ValidatorUtils; +// 导入Apache Commons Lang库中的字符串处理工具类 import org.apache.commons.lang3.StringUtils; +// 导入Spring框架的自动注入注解 import org.springframework.beans.factory.annotation.Autowired; +// 导入Spring框架的日期格式化注解 import org.springframework.format.annotation.DateTimeFormat; +// 导入Spring框架的路径变量注解 import org.springframework.web.bind.annotation.PathVariable; +// 导入Spring框架的请求体注解 import org.springframework.web.bind.annotation.RequestBody; +// 导入Spring框架的请求映射注解 import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestParam; +// 导入Spring框架的REST控制器注解 import org.springframework.web.bind.annotation.RestController; +// 导入MyBatis-Plus的实体包装器类 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入MyBatis-Plus的包装器接口 import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的忽略认证注解 import com.annotation.IgnoreAuth; +// 导入留言板实体类 import com.entity.MessagesEntity; +// 导入留言板视图类 import com.entity.view.MessagesView; +// 导入留言板服务类 import com.service.MessagesService; +// 导入令牌服务类 import com.service.TokenService; +// 导入分页工具类 import com.utils.PageUtils; +// 导入自定义的响应类 import com.utils.R; +// 导入MD5加密工具类 import com.utils.MD5Util; +// 导入MyBatis-Plus工具类 import com.utils.MPUtil; +// 导入通用工具类 import com.utils.CommonUtil; /** * 留言板 * 后端接口 - * @author - * @email + * @author + * @email * @date 2021-05-09 15:46:15 */ +// 声明为REST控制器，用于处理HTTP请求 @RestController +// 映射请求路径，所有以/messages开头的请求由该控制器处理 @RequestMapping("/messages") public class MessagesController { + // 自动注入留言板服务类实例 @Autowired private MessagesService messagesService; - /** - * 后端列表 + * 后端列表（分页查询） */ + // 映射请求路径/messages/page @RequestMapping("/page") - public R page(@RequestParam Map params,MessagesEntity messages, - HttpServletRequest request){ - if(!request.getSession().getAttribute("role").toString().equals("管理员")) { - messages.setUserid((Long)request.getSession().getAttribute("userId")); - } + // 处理后端分页查询请求，参数包括查询条件、实体对象、HTTP请求 + public R page(@RequestParam Map params, MessagesEntity messages, + HttpServletRequest request) { + // 如果当前用户不是管理员 + if (!request.getSession().getAttribute("role").toString().equals("管理员")) { + // 设置留言的用户ID为当前登录用户的ID + messages.setUserid((Long) request.getSession().getAttribute("userId")); + } + // 创建实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = messagesService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, messages), params), params)); - + // 调用服务类的分页查询方法，包含排序、范围查询、模糊查询处理 + PageUtils page = messagesService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, messages), params), params)); + // 返回成功响应，携带分页数据 return R.ok().put("data", page); } - + /** - * 前端列表 + * 前端列表（分页查询） */ + // 映射请求路径/messages/list @RequestMapping("/list") - public R list(@RequestParam Map params,MessagesEntity messages, - HttpServletRequest request){ - if(!request.getSession().getAttribute("role").toString().equals("管理员")) { - messages.setUserid((Long)request.getSession().getAttribute("userId")); - } + // 处理前端分页查询请求，参数包括查询条件、实体对象、HTTP请求 + public R list(@RequestParam Map params, MessagesEntity messages, + HttpServletRequest request) { + // 如果当前用户不是管理员 + if (!request.getSession().getAttribute("role").toString().equals("管理员")) { + // 设置留言的用户ID为当前登录用户的ID + messages.setUserid((Long) request.getSession().getAttribute("userId")); + } + // 创建实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = messagesService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, messages), params), params)); + // 调用服务类的分页查询方法，包含排序、范围查询、模糊查询处理 + PageUtils page = messagesService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, messages), params), params)); + // 返回成功响应，携带分页数据 return R.ok().put("data", page); } - /** - * 列表 + /** + * 列表（不分页，全量查询） */ + // 映射请求路径/messages/lists @RequestMapping("/lists") - public R list( MessagesEntity messages){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( messages, "messages")); + // 处理全量查询请求，参数为实体对象 + public R list(MessagesEntity messages) { + // 创建实体包装器 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件：所有字段与实体对象相等（前缀为"messages"） + ew.allEq(MPUtil.allEQMapPre(messages, "messages")); + // 返回成功响应，携带查询结果（视图列表） return R.ok().put("data", messagesService.selectListView(ew)); } - /** - * 查询 + /** + * 查询（单个对象） */ + // 映射请求路径/messages/query @RequestMapping("/query") - public R query(MessagesEntity messages){ - EntityWrapper< MessagesEntity> ew = new EntityWrapper< MessagesEntity>(); - ew.allEq(MPUtil.allEQMapPre( messages, "messages")); - MessagesView messagesView = messagesService.selectView(ew); - return R.ok("查询留言板成功").put("data", messagesView); + // 处理单个对象查询请求，参数为实体对象 + public R query(MessagesEntity messages) { + // 创建实体包装器 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件：所有字段与实体对象相等（前缀为"messages"） + ew.allEq(MPUtil.allEQMapPre(messages, "messages")); + // 调用服务类的视图查询方法 + MessagesView messagesView = messagesService.selectView(ew); + // 返回成功响应，携带查询结果和提示信息 + return R.ok("查询留言板成功").put("data", messagesView); } - + /** - * 后端详情 + * 后端详情（根据ID查询） */ + // 映射请求路径/messages/info/{id} @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id){ + // 处理详情查询请求，参数为路径中的ID + public R info(@PathVariable("id") Long id) { + // 根据ID直接查询实体对象 MessagesEntity messages = messagesService.selectById(id); + // 返回成功响应，携带查询到的实体数据 return R.ok().put("data", messages); } /** - * 前端详情 + * 前端详情（根据ID查询） */ + // 映射请求路径/messages/detail/{id} @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id){ + // 处理详情查询请求，参数为路径中的ID（前端调用） + public R detail(@PathVariable("id") Long id) { + // 根据ID直接查询实体对象 MessagesEntity messages = messagesService.selectById(id); + // 返回成功响应，携带查询到的实体数据 return R.ok().put("data", messages); } - + /** - * 后端保存 + * 后端保存（新增留言） */ + // 映射请求路径/messages/save @RequestMapping("/save") - public R save(@RequestBody MessagesEntity messages, HttpServletRequest request){ - messages.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(messages); + // 处理后端新增请求，请求体为实体对象，携带HTTP请求 + public R save(@RequestBody MessagesEntity messages, HttpServletRequest request) { + // 生成唯一ID（时间戳 + 随机数） + messages.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 实体验证（注释，未启用） + //ValidatorUtils.validateEntity(messages); + // 调用服务类的插入方法 messagesService.insert(messages); + // 返回成功响应 return R.ok(); } - + /** - * 前端保存 + * 前端保存（新增留言） */ + // 映射请求路径/messages/add @RequestMapping("/add") - public R add(@RequestBody MessagesEntity messages, HttpServletRequest request){ - messages.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(messages); - messages.setUserid((Long)request.getSession().getAttribute("userId")); + // 处理前端新增请求，请求体为实体对象，携带HTTP请求 + public R add(@RequestBody MessagesEntity messages, HttpServletRequest request) { + // 生成唯一ID（时间戳 + 随机数） + messages.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 实体验证（注释，未启用） + //ValidatorUtils.validateEntity(messages); + // 设置留言的用户ID为当前登录用户的ID + messages.setUserid((Long) request.getSession().getAttribute("userId")); + // 调用服务类的插入方法 messagesService.insert(messages); + // 返回成功响应 return R.ok(); } /** - * 修改 + * 修改（更新留言） */ + // 映射请求路径/messages/update @RequestMapping("/update") - public R update(@RequestBody MessagesEntity messages, HttpServletRequest request){ + // 处理修改请求，请求体为实体对象，携带HTTP请求 + public R update(@RequestBody MessagesEntity messages, HttpServletRequest request) { + // 实体验证（注释，未启用） //ValidatorUtils.validateEntity(messages); - messagesService.updateById(messages);//全部更新 + // 调用服务类的更新方法（根据ID全量更新） + messagesService.updateById(messages); // 全部更新 + // 返回成功响应 return R.ok(); } - + /** - * 删除 + * 删除（批量删除留言） */ + // 映射请求路径/messages/delete @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ + // 处理删除请求，请求体为ID数组 + public R delete(@RequestBody Long[] ids) { + // 调用服务类的批量删除方法（根据ID列表） messagesService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 return R.ok(); } - + /** - * 提醒接口 + * 提醒接口（统计符合条件的留言数） */ - @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 = messagesService.selectCount(wrapper); - return R.ok().put("count", count); - } - - - -} + // 映射请求路径/messages/remind/{columnName}/{type} + @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); + + // 如果类型为2（处理日期范围提醒） + if (type.equals("2")) { + // 创建日期格式化对象（yyyy-MM-dd格式） + 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 = messagesService.selectCount(wrapper); + // 返回成功响应，携带统计结果 + return R.ok().put("count", count); + } +} \ No newline at end of file diff --git a/src/main/java/com/controller/NewsController.java b/src/main/java/com/controller/NewsController.java index 28c06a4..f560baa 100644 --- a/src/main/java/com/controller/NewsController.java +++ b/src/main/java/com/controller/NewsController.java @@ -1,208 +1,308 @@ package com.controller; +// 导入用于格式化日期的类 import java.text.SimpleDateFormat; +// 导入用于创建动态数组的类 import java.util.ArrayList; +// 导入用于操作数组的工具类 import java.util.Arrays; +// 导入用于处理日期和时间的类 import java.util.Calendar; +// 导入用于存储键值对的接口 import java.util.Map; +// 导入用于实现Map接口的HashMap类 import java.util.HashMap; +// 导入用于遍历集合的接口 import java.util.Iterator; +// 导入用于表示日期和时间的类 import java.util.Date; +// 导入用于创建列表的接口 import java.util.List; +// 导入用于处理HTTP请求的类 import javax.servlet.http.HttpServletRequest; +// 导入自定义的验证工具类 import com.utils.ValidatorUtils; +// 导入Apache Commons Lang库中的字符串处理工具类 import org.apache.commons.lang3.StringUtils; +// 导入Spring框架的自动注入注解 import org.springframework.beans.factory.annotation.Autowired; +// 导入Spring框架的日期格式化注解 import org.springframework.format.annotation.DateTimeFormat; +// 导入Spring框架的路径变量注解 import org.springframework.web.bind.annotation.PathVariable; +// 导入Spring框架的请求体注解 import org.springframework.web.bind.annotation.RequestBody; +// 导入Spring框架的请求映射注解 import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestParam; +// 导入Spring框架的REST控制器注解 import org.springframework.web.bind.annotation.RestController; +// 导入MyBatis-Plus的实体包装器类 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入MyBatis-Plus的包装器接口 import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的忽略认证注解 import com.annotation.IgnoreAuth; +// 导入教育资讯实体类 import com.entity.NewsEntity; +// 导入教育资讯视图类 import com.entity.view.NewsView; +// 导入教育资讯服务类 import com.service.NewsService; +// 导入令牌服务类 import com.service.TokenService; +// 导入分页工具类 import com.utils.PageUtils; +// 导入自定义的响应类 import com.utils.R; +// 导入MD5加密工具类 import com.utils.MD5Util; +// 导入MyBatis-Plus工具类 import com.utils.MPUtil; +// 导入通用工具类 import com.utils.CommonUtil; /** * 教育资讯 * 后端接口 - * @author - * @email + * @author + * @email * @date 2021-05-09 15:46:15 */ +// 声明为REST控制器，用于处理HTTP请求 @RestController +// 映射请求路径，所有以/news开头的请求由该控制器处理 @RequestMapping("/news") public class NewsController { + // 自动注入教育资讯服务类实例 @Autowired private NewsService newsService; - /** - * 后端列表 + * 后端列表（分页查询） */ + // 映射请求路径/news/page @RequestMapping("/page") - public R page(@RequestParam Map params,NewsEntity news, - HttpServletRequest request){ + // 处理后端分页查询请求，参数包括查询条件、实体对象、HTTP请求 + public R page(@RequestParam Map params, NewsEntity news, + HttpServletRequest request) { + // 创建实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = newsService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, news), params), params)); - + // 调用服务类的分页查询方法，包含排序、范围查询、模糊查询处理 + PageUtils page = newsService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, news), params), params)); + // 返回成功响应，携带分页数据 return R.ok().put("data", page); } - + /** - * 前端列表 + * 前端列表（分页查询，忽略认证） */ - @IgnoreAuth + // 该接口忽略认证 + @IgnoreAuth + // 映射请求路径/news/list @RequestMapping("/list") - public R list(@RequestParam Map params,NewsEntity news, - HttpServletRequest request){ + // 处理前端分页查询请求，参数包括查询条件、实体对象、HTTP请求 + public R list(@RequestParam Map params, NewsEntity news, + HttpServletRequest request) { + // 创建实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = newsService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, news), params), params)); + // 调用服务类的分页查询方法，包含排序、范围查询、模糊查询处理 + PageUtils page = newsService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, news), params), params)); + // 返回成功响应，携带分页数据 return R.ok().put("data", page); } - /** - * 列表 + /** + * 列表（不分页，全量查询） */ + // 映射请求路径/news/lists @RequestMapping("/lists") - public R list( NewsEntity news){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( news, "news")); + // 处理全量查询请求，参数为实体对象 + public R list(NewsEntity news) { + // 创建实体包装器 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件：所有字段与实体对象相等（前缀为"news"） + ew.allEq(MPUtil.allEQMapPre(news, "news")); + // 返回成功响应，携带查询结果（视图列表） return R.ok().put("data", newsService.selectListView(ew)); } - /** - * 查询 + /** + * 查询（单个对象） */ + // 映射请求路径/news/query @RequestMapping("/query") - public R query(NewsEntity news){ - EntityWrapper< NewsEntity> ew = new EntityWrapper< NewsEntity>(); - ew.allEq(MPUtil.allEQMapPre( news, "news")); - NewsView newsView = newsService.selectView(ew); - return R.ok("查询教育资讯成功").put("data", newsView); + // 处理单个对象查询请求，参数为实体对象 + public R query(NewsEntity news) { + // 创建实体包装器 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件：所有字段与实体对象相等（前缀为"news"） + ew.allEq(MPUtil.allEQMapPre(news, "news")); + // 调用服务类的视图查询方法 + NewsView newsView = newsService.selectView(ew); + // 返回成功响应，携带查询结果和提示信息 + return R.ok("查询教育资讯成功").put("data", newsView); } - + /** - * 后端详情 + * 后端详情（根据ID查询） */ + // 映射请求路径/news/info/{id} @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id){ + // 处理详情查询请求，参数为路径中的ID + public R info(@PathVariable("id") Long id) { + // 根据ID直接查询实体对象 NewsEntity news = newsService.selectById(id); + // 返回成功响应，携带查询到的实体数据 return R.ok().put("data", news); } /** - * 前端详情 + * 前端详情（根据ID查询，忽略认证） */ - @IgnoreAuth + // 该接口忽略认证 + @IgnoreAuth + // 映射请求路径/news/detail/{id} @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id){ + // 处理详情查询请求，参数为路径中的ID（前端调用） + public R detail(@PathVariable("id") Long id) { + // 根据ID直接查询实体对象 NewsEntity news = newsService.selectById(id); + // 返回成功响应，携带查询到的实体数据 return R.ok().put("data", news); } - + /** - * 后端保存 + * 后端保存（新增教育资讯） */ + // 映射请求路径/news/save @RequestMapping("/save") - public R save(@RequestBody NewsEntity news, HttpServletRequest request){ - news.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(news); + // 处理后端新增请求，请求体为实体对象，携带HTTP请求 + public R save(@RequestBody NewsEntity news, HttpServletRequest request) { + // 生成唯一ID（时间戳 + 随机数） + news.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 实体验证（注释，未启用） + //ValidatorUtils.validateEntity(news); + // 调用服务类的插入方法 newsService.insert(news); + // 返回成功响应 return R.ok(); } - + /** - * 前端保存 + * 前端保存（新增教育资讯） */ + // 映射请求路径/news/add @RequestMapping("/add") - public R add(@RequestBody NewsEntity news, HttpServletRequest request){ - news.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(news); + // 处理前端新增请求，请求体为实体对象，携带HTTP请求 + public R add(@RequestBody NewsEntity news, HttpServletRequest request) { + // 生成唯一ID（时间戳 + 随机数） + news.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 实体验证（注释，未启用） + //ValidatorUtils.validateEntity(news); + // 调用服务类的插入方法 newsService.insert(news); + // 返回成功响应 return R.ok(); } /** - * 修改 + * 修改（更新教育资讯） */ + // 映射请求路径/news/update @RequestMapping("/update") - public R update(@RequestBody NewsEntity news, HttpServletRequest request){ + // 处理修改请求，请求体为实体对象，携带HTTP请求 + public R update(@RequestBody NewsEntity news, HttpServletRequest request) { + // 实体验证（注释，未启用） //ValidatorUtils.validateEntity(news); - newsService.updateById(news);//全部更新 + // 调用服务类的更新方法（根据ID全量更新） + newsService.updateById(news); // 全部更新 + // 返回成功响应 return R.ok(); } - + /** - * 删除 + * 删除（批量删除教育资讯） */ + // 映射请求路径/news/delete @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ + // 处理删除请求，请求体为ID数组 + public R delete(@RequestBody Long[] ids) { + // 调用服务类的批量删除方法（根据ID列表） newsService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 return R.ok(); } - + /** - * 提醒接口 + * 提醒接口（统计符合条件的记录数） */ - @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 = newsService.selectCount(wrapper); - return R.ok().put("count", count); - } - - - -} + // 映射请求路径/news/remind/{columnName}/{type} + @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); + + // 如果类型为2（处理日期范围提醒） + if (type.equals("2")) { + // 创建日期格式化对象（yyyy-MM-dd格式） + 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 = newsService.selectCount(wrapper); + // 返回成功响应，携带统计结果 + return R.ok().put("count", count); + } +} \ No newline at end of file diff --git a/src/main/java/com/controller/ShipindianboController.java b/src/main/java/com/controller/ShipindianboController.java index 3f7c12e..429717d 100644 --- a/src/main/java/com/controller/ShipindianboController.java +++ b/src/main/java/com/controller/ShipindianboController.java @@ -1,219 +1,333 @@ +// 声明该类所在的包 package com.controller; +// 导入用于格式化日期的类，可将日期对象按照指定格式转换为字符串 import java.text.SimpleDateFormat; +// 导入用于创建动态数组的类，可根据需要动态调整数组大小 import java.util.ArrayList; +// 导入用于操作数组的工具类，提供了如排序、查找等方法 import java.util.Arrays; +// 导入用于处理日期和时间的类，可进行日期的计算、格式化等操作 import java.util.Calendar; +// 导入用于存储键值对的接口，可通过键快速查找对应的值 import java.util.Map; +// 导入用于实现 Map 接口的 HashMap 类，基于哈希表实现，存储键值对 import java.util.HashMap; +// 导入用于遍历集合的接口，可依次访问集合中的元素 import java.util.Iterator; +// 导入用于表示日期和时间的类，用于处理日期和时间相关操作 import java.util.Date; +// 导入用于创建列表的接口，可存储多个元素并进行操作 import java.util.List; +// 导入用于处理 HTTP 请求的类，封装了 HTTP 请求的相关信息 import javax.servlet.http.HttpServletRequest; +// 导入自定义的验证工具类，用于对实体对象进行验证 import com.utils.ValidatorUtils; +// 导入 Apache Commons Lang 库中的字符串处理工具类，提供了丰富的字符串操作方法 import org.apache.commons.lang3.StringUtils; +// 导入 Spring 框架的自动注入注解，可自动将依赖的对象注入到类中 import org.springframework.beans.factory.annotation.Autowired; +// 导入 Spring 框架的日期格式化注解，用于指定日期参数的格式 import org.springframework.format.annotation.DateTimeFormat; +// 导入 Spring 框架的路径变量注解，用于获取 URL 路径中的变量值 import org.springframework.web.bind.annotation.PathVariable; +// 导入 Spring 框架的请求体注解，用于将请求体中的数据绑定到方法参数上 import org.springframework.web.bind.annotation.RequestBody; +// 导入 Spring 框架的请求映射注解，用于将 HTTP 请求映射到控制器的方法上 import org.springframework.web.bind.annotation.RequestMapping; +// 导入 Spring 框架的请求参数注解，用于获取请求参数的值 import org.springframework.web.bind.annotation.RequestParam; +// 导入 Spring 框架的 REST 控制器注解，表明该类是一个 RESTful 风格的控制器 import org.springframework.web.bind.annotation.RestController; +// 导入 MyBatis-Plus 的实体包装器类，用于构建查询条件 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入 MyBatis-Plus 的包装器接口，是实体包装器的接口 import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的忽略认证注解，用于标记某些接口不需要进行认证 import com.annotation.IgnoreAuth; +// 导入视频点播实体类，包含视频点播的相关属性 import com.entity.ShipindianboEntity; +// 导入视频点播视图类，可能用于展示视频点播的相关信息 import com.entity.view.ShipindianboView; +// 导入视频点播服务类，处理视频点播的业务逻辑 import com.service.ShipindianboService; +// 导入令牌服务类，可能用于处理令牌相关业务 import com.service.TokenService; +// 导入分页工具类，用于处理分页查询相关操作 import com.utils.PageUtils; +// 导入自定义的响应类，用于封装接口的返回结果 import com.utils.R; +// 导入 MD5 加密工具类，用于对数据进行 MD5 加密 import com.utils.MD5Util; +// 导入 MyBatis-Plus 工具类，提供一些便捷的操作方法 import com.utils.MPUtil; +// 导入通用工具类，包含一些通用的工具方法 import com.utils.CommonUtil; /** * 视频点播 * 后端接口 - * @author - * @email + * @author + * @email * @date 2021-05-09 15:46:14 */ +// 声明该类为 REST 控制器，处理 HTTP 请求并返回 JSON 数据 @RestController +// 映射请求路径，所有以 /shipindianbo 开头的请求都会由该控制器处理 @RequestMapping("/shipindianbo") public class ShipindianboController { - @Autowired - private ShipindianboService shipindianboService; - + // 自动注入视频点播服务类的实例，用于调用服务层的方法 + @Autowired + private ShipindianboService shipindianboService; - /** - * 后端列表 - */ - @RequestMapping("/page") - public R page(@RequestParam Map params,ShipindianboEntity shipindianbo, - HttpServletRequest request){ + /** + * 后端列表 + */ + // 映射请求路径 /shipindianbo/page + @RequestMapping("/page") + // 处理后端分页查询视频点播列表的请求 + public R page(@RequestParam Map params, ShipindianboEntity shipindianbo, + HttpServletRequest request) { + // 从会话中获取表名 String tableName = request.getSession().getAttribute("tableName").toString(); - if(tableName.equals("yonghu")) { - shipindianbo.setYonghuzhanghao((String)request.getSession().getAttribute("username")); + // 如果表名是 "yonghu" + if (tableName.equals("yonghu")) { + // 设置视频点播实体的用户账号为会话中的用户名 + shipindianbo.setYonghuzhanghao((String) request.getSession().getAttribute("username")); } - EntityWrapper ew = new EntityWrapper(); + // 创建一个实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 调用视频点播服务类的查询分页方法，进行排序、范围和模糊查询 PageUtils page = shipindianboService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, shipindianbo), params), params)); + // 返回成功响应，并将分页数据放入响应中 + return R.ok().put("data", page); + } - return R.ok().put("data", page); - } - - /** - * 前端列表 - */ - @RequestMapping("/list") - public R list(@RequestParam Map params,ShipindianboEntity shipindianbo, - HttpServletRequest request){ + /** + * 前端列表 + */ + // 映射请求路径 /shipindianbo/list + @RequestMapping("/list") + // 处理前端分页查询视频点播列表的请求 + public R list(@RequestParam Map params, ShipindianboEntity shipindianbo, + HttpServletRequest request) { + // 从会话中获取表名 String tableName = request.getSession().getAttribute("tableName").toString(); - if(tableName.equals("yonghu")) { - shipindianbo.setYonghuzhanghao((String)request.getSession().getAttribute("username")); + // 如果表名是 "yonghu" + if (tableName.equals("yonghu")) { + // 设置视频点播实体的用户账号为会话中的用户名 + shipindianbo.setYonghuzhanghao((String) request.getSession().getAttribute("username")); } - EntityWrapper ew = new EntityWrapper(); + // 创建一个实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 调用视频点播服务类的查询分页方法，进行排序、范围和模糊查询 PageUtils page = shipindianboService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, shipindianbo), params), params)); - return R.ok().put("data", page); - } + // 返回成功响应，并将分页数据放入响应中 + return R.ok().put("data", page); + } /** - * 列表 - */ - @RequestMapping("/lists") - public R list( ShipindianboEntity shipindianbo){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( shipindianbo, "shipindianbo")); - return R.ok().put("data", shipindianboService.selectListView(ew)); - } - - /** - * 查询 - */ - @RequestMapping("/query") - public R query(ShipindianboEntity shipindianbo){ - EntityWrapper< ShipindianboEntity> ew = new EntityWrapper< ShipindianboEntity>(); - ew.allEq(MPUtil.allEQMapPre( shipindianbo, "shipindianbo")); - ShipindianboView shipindianboView = shipindianboService.selectView(ew); + * 列表 + */ + // 映射请求路径 /shipindianbo/lists + @RequestMapping("/lists") + // 处理查询视频点播列表的请求 + public R list(ShipindianboEntity shipindianbo) { + // 创建一个实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件，所有字段相等 + ew.allEq(MPUtil.allEQMapPre(shipindianbo, "shipindianbo")); + // 返回成功响应，并将查询结果（视图列表）放入响应中 + return R.ok().put("data", shipindianboService.selectListView(ew)); + } + + /** + * 查询 + */ + // 映射请求路径 /shipindianbo/query + @RequestMapping("/query") + // 处理查询视频点播的请求 + public R query(ShipindianboEntity shipindianbo) { + // 创建一个实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件，所有字段相等 + ew.allEq(MPUtil.allEQMapPre(shipindianbo, "shipindianbo")); + // 调用视频点播服务类的查询视图方法 + ShipindianboView shipindianboView = shipindianboService.selectView(ew); + // 返回成功响应，并将查询结果放入响应中，附带成功提示信息 return R.ok("查询视频点播成功").put("data", shipindianboView); - } - - /** - * 后端详情 - */ - @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id){ - ShipindianboEntity shipindianbo = shipindianboService.selectById(id); - return R.ok().put("data", shipindianbo); - } - - /** - * 前端详情 - */ - @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id){ - ShipindianboEntity shipindianbo = shipindianboService.selectById(id); - return R.ok().put("data", shipindianbo); - } - - - - - /** - * 后端保存 - */ - @RequestMapping("/save") - public R save(@RequestBody ShipindianboEntity shipindianbo, HttpServletRequest request){ - shipindianbo.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(shipindianbo); - shipindianboService.insert(shipindianbo); - return R.ok(); - } - - /** - * 前端保存 - */ - @RequestMapping("/add") - public R add(@RequestBody ShipindianboEntity shipindianbo, HttpServletRequest request){ - shipindianbo.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(shipindianbo); - shipindianbo.setUserid((Long)request.getSession().getAttribute("userId")); - shipindianboService.insert(shipindianbo); - return R.ok(); - } - - /** - * 修改 - */ - @RequestMapping("/update") - public R update(@RequestBody ShipindianboEntity shipindianbo, HttpServletRequest request){ - //ValidatorUtils.validateEntity(shipindianbo); - shipindianboService.updateById(shipindianbo);//全部更新 - return R.ok(); - } - - - /** - * 删除 - */ - @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ - shipindianboService.deleteBatchIds(Arrays.asList(ids)); - return R.ok(); - } - - /** - * 提醒接口 - */ + } + + /** + * 后端详情 + */ + // 映射请求路径 /shipindianbo/info/{id} + @RequestMapping("/info/{id}") + // 处理后端查询视频点播详情的请求 + public R info(@PathVariable("id") Long id) { + // 根据 ID 查询视频点播实体 + ShipindianboEntity shipindianbo = shipindianboService.selectById(id); + // 返回成功响应，并将查询结果放入响应中 + return R.ok().put("data", shipindianbo); + } + + /** + * 前端详情 + */ + // 映射请求路径 /shipindianbo/detail/{id} + @RequestMapping("/detail/{id}") + // 处理前端查询视频点播详情的请求 + public R detail(@PathVariable("id") Long id) { + // 根据 ID 查询视频点播实体 + ShipindianboEntity shipindianbo = shipindianboService.selectById(id); + // 返回成功响应，并将查询结果放入响应中 + return R.ok().put("data", shipindianbo); + } + + /** + * 后端保存 + */ + // 映射请求路径 /shipindianbo/save + @RequestMapping("/save") + // 处理后端保存视频点播的请求 + public R save(@RequestBody ShipindianboEntity shipindianbo, HttpServletRequest request) { + // 生成一个唯一的 ID + shipindianbo.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 验证实体（注释掉，未启用） + //ValidatorUtils.validateEntity(shipindianbo); + // 调用视频点播服务类的插入方法 + shipindianboService.insert(shipindianbo); + // 返回成功响应 + return R.ok(); + } + + /** + * 前端保存 + */ + // 映射请求路径 /shipindianbo/add + @RequestMapping("/add") + // 处理前端保存视频点播的请求 + public R add(@RequestBody ShipindianboEntity shipindianbo, HttpServletRequest request) { + // 生成一个唯一的 ID + shipindianbo.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 验证实体（注释掉，未启用） + //ValidatorUtils.validateEntity(shipindianbo); + // 设置视频点播实体的用户 ID 为会话中的用户 ID + shipindianbo.setUserid((Long) request.getSession().getAttribute("userId")); + // 调用视频点播服务类的插入方法 + shipindianboService.insert(shipindianbo); + // 返回成功响应 + return R.ok(); + } + + /** + * 修改 + */ + // 映射请求路径 /shipindianbo/update + @RequestMapping("/update") + // 处理修改视频点播的请求 + public R update(@RequestBody ShipindianboEntity shipindianbo, HttpServletRequest request) { + // 验证实体（注释掉，未启用） + //ValidatorUtils.validateEntity(shipindianbo); + // 调用视频点播服务类的更新方法，更新所有字段 + shipindianboService.updateById(shipindianbo); // 全部更新 + // 返回成功响应 + return R.ok(); + } + + /** + * 删除 + */ + // 映射请求路径 /shipindianbo/delete + @RequestMapping("/delete") + // 处理删除视频点播的请求 + public R delete(@RequestBody Long[] ids) { + // 调用视频点播服务类的批量删除方法 + shipindianboService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 + return R.ok(); + } + + /** + * 提醒接口 + */ + // 映射请求路径 /shipindianbo/remind/{columnName}/{type} @RequestMapping("/remind/{columnName}/{type}") - public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, - @PathVariable("type") String type,@RequestParam Map map) { + // 处理提醒统计的请求 + 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")) { + + // 如果类型为 2 + 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) { + // 如果提醒开始参数不为空 + if (map.get("remindstart") != null) { + // 将提醒开始参数转换为整数 Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); - c.setTime(new Date()); - c.add(Calendar.DAY_OF_MONTH,remindStart); + // 设置日历时间为当前时间 + 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) { + // 如果提醒结束参数不为空 + if (map.get("remindend") != null) { + // 将提醒结束参数转换为整数 Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); + // 设置日历时间为当前时间 c.setTime(new Date()); - c.add(Calendar.DAY_OF_MONTH,remindEnd); + // 在当前日期上加上提醒结束天数 + 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) { + // 如果提醒开始参数不为空 + if (map.get("remindstart") != null) { + // 设置查询条件，列名大于等于提醒开始日期 wrapper.ge(columnName, map.get("remindstart")); } - if(map.get("remindend")!=null) { + // 如果提醒结束参数不为空 + if (map.get("remindend") != null) { + // 设置查询条件，列名小于等于提醒结束日期 wrapper.le(columnName, map.get("remindend")); } + // 从会话中获取表名 String tableName = request.getSession().getAttribute("tableName").toString(); - if(tableName.equals("yonghu")) { - wrapper.eq("yonghuzhanghao", (String)request.getSession().getAttribute("username")); + // 如果表名是 "yonghu" + if (tableName.equals("yonghu")) { + // 设置查询条件，用户账号等于会话中的用户名 + wrapper.eq("yonghuzhanghao", (String) request.getSession().getAttribute("username")); } + // 调用视频点播服务类的统计方法，统计符合条件的记录数 int count = shipindianboService.selectCount(wrapper); + // 返回成功响应，并将统计结果放入响应中 return R.ok().put("count", count); } - - - -} +} \ No newline at end of file diff --git a/src/main/java/com/controller/StoreupController.java b/src/main/java/com/controller/StoreupController.java index 2236ae3..5d60cd8 100644 --- a/src/main/java/com/controller/StoreupController.java +++ b/src/main/java/com/controller/StoreupController.java @@ -1,217 +1,300 @@ package com.controller; +// 导入用于格式化日期的类，用于处理日期格式转换 import java.text.SimpleDateFormat; +// 导入动态数组类，用于创建和操作动态数组 import java.util.ArrayList; +// 导入数组工具类，提供数组相关操作方法 import java.util.Arrays; +// 导入日历类，用于处理日期和时间计算 import java.util.Calendar; +// 导入映射接口，用于存储键值对数据 import java.util.Map; +// 导入哈希表类，实现Map接口的哈希表数据结构 import java.util.HashMap; +// 导入迭代器接口，用于遍历集合元素 import java.util.Iterator; +// 导入日期类，用于处理日期和时间对象 import java.util.Date; +// 导入列表接口，用于创建有序集合 import java.util.List; +// 导入HTTP请求类，用于获取HTTP请求信息 import javax.servlet.http.HttpServletRequest; +// 导入自定义验证工具类，用于实体对象验证 import com.utils.ValidatorUtils; +// 导入字符串工具类，提供丰富的字符串操作方法 import org.apache.commons.lang3.StringUtils; +// 导入Spring自动注入注解，自动装配依赖对象 import org.springframework.beans.factory.annotation.Autowired; +// 导入日期格式注解，用于指定日期参数的格式 import org.springframework.format.annotation.DateTimeFormat; +// 导入路径变量注解，用于获取URL路径中的参数 import org.springframework.web.bind.annotation.PathVariable; +// 导入请求体注解，用于接收请求体中的数据 import org.springframework.web.bind.annotation.RequestBody; +// 导入请求映射注解，用于映射HTTP请求到方法 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 org.springframework.web.bind.annotation.RequestParam; // 导入请求参数注解，用于获取请求参数 +import org.springframework.web.bind.annotation.RestController; // 导入REST控制器注解，标记为RESTful控制器 +import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入MyBatis-Plus实体包装器，用于构建查询条件 +import com.baomidou.mybatisplus.mapper.Wrapper; // 导入MyBatis-Plus包装器接口 +import com.annotation.IgnoreAuth; // 导入自定义忽略认证注解 +// 导入收藏表实体类，对应数据库表结构 import com.entity.StoreupEntity; +// 导入收藏表视图类，用于展示扩展数据 import com.entity.view.StoreupView; +// 导入收藏表服务类，处理业务逻辑 import com.service.StoreupService; +// 导入令牌服务类，处理令牌相关逻辑（未在代码中使用，保留注释） import com.service.TokenService; +// 导入分页工具类，处理分页查询 import com.utils.PageUtils; +// 导入自定义响应类，封装接口返回数据 import com.utils.R; +// 导入MD5加密工具类，用于数据加密（未在代码中使用，保留注释） import com.utils.MD5Util; +// 导入MyBatis-Plus工具类，提供通用操作方法 import com.utils.MPUtil; +// 导入通用工具类，包含常用工具方法 import com.utils.CommonUtil; /** * 收藏表 * 后端接口 - * @author - * @email + * @author + * @email * @date 2021-05-09 15:46:15 */ +// 声明为REST控制器，处理HTTP请求并返回JSON响应 @RestController +// 映射请求路径，所有以/storeup开头的请求由该控制器处理 @RequestMapping("/storeup") public class StoreupController { + // 自动注入收藏表服务类实例，用于调用业务方法 @Autowired private StoreupService storeupService; - /** - * 后端列表 + * 后端列表（分页查询） */ + // 映射请求路径/storeup/page @RequestMapping("/page") - public R page(@RequestParam Map params,StoreupEntity storeup, - HttpServletRequest request){ - if(!request.getSession().getAttribute("role").toString().equals("管理员")) { - storeup.setUserid((Long)request.getSession().getAttribute("userId")); - } + // 处理后端分页查询请求，参数包括查询条件、实体对象、HTTP请求 + public R page(@RequestParam Map params, StoreupEntity storeup, + HttpServletRequest request) { + // 如果当前用户不是管理员 + if (!request.getSession().getAttribute("role").toString().equals("管理员")) { + // 设置收藏表的用户ID为当前登录用户的ID（非管理员只能查看自己的数据） + storeup.setUserid((Long) request.getSession().getAttribute("userId")); + } + // 创建实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = storeupService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, storeup), params), params)); - + // 调用服务类的分页查询方法，包含排序、范围查询、模糊查询处理 + PageUtils page = storeupService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, storeup), params), params)); + // 返回成功响应，携带分页数据 return R.ok().put("data", page); } - + /** - * 前端列表 + * 前端列表（分页查询） */ + // 映射请求路径/storeup/list @RequestMapping("/list") - public R list(@RequestParam Map params,StoreupEntity storeup, - HttpServletRequest request){ - if(!request.getSession().getAttribute("role").toString().equals("管理员")) { - storeup.setUserid((Long)request.getSession().getAttribute("userId")); - } + // 处理前端分页查询请求，逻辑与后端类似，非管理员限制用户ID + public R list(@RequestParam Map params, StoreupEntity storeup, + HttpServletRequest request) { + // 如果当前用户不是管理员 + if (!request.getSession().getAttribute("role").toString().equals("管理员")) { + // 设置收藏表的用户ID为当前登录用户的ID + storeup.setUserid((Long) request.getSession().getAttribute("userId")); + } + // 创建实体包装器 EntityWrapper ew = new EntityWrapper(); - PageUtils page = storeupService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, storeup), params), params)); + // 调用分页查询方法 + PageUtils page = storeupService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, storeup), params), params)); + // 返回分页数据 return R.ok().put("data", page); } - /** - * 列表 + /** + * 列表（全量查询，不分页） */ + // 映射请求路径/storeup/lists @RequestMapping("/lists") - public R list( StoreupEntity storeup){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( storeup, "storeup")); + // 处理全量查询请求，根据实体对象的属性构建查询条件 + public R list(StoreupEntity storeup) { + // 创建实体包装器 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件：所有字段与实体对象相等（前缀为"storeup"） + ew.allEq(MPUtil.allEQMapPre(storeup, "storeup")); + // 返回查询结果（视图列表） return R.ok().put("data", storeupService.selectListView(ew)); } - /** - * 查询 + /** + * 查询（单个对象） */ + // 映射请求路径/storeup/query @RequestMapping("/query") - public R query(StoreupEntity storeup){ - EntityWrapper< StoreupEntity> ew = new EntityWrapper< StoreupEntity>(); - ew.allEq(MPUtil.allEQMapPre( storeup, "storeup")); - StoreupView storeupView = storeupService.selectView(ew); - return R.ok("查询收藏表成功").put("data", storeupView); + // 根据实体对象的属性查询单个收藏记录（通常用于精确查询） + public R query(StoreupEntity storeup) { + // 创建实体包装器 + EntityWrapper ew = new EntityWrapper(); + // 设置全字段相等查询条件 + ew.allEq(MPUtil.allEQMapPre(storeup, "storeup")); + // 调用服务类的视图查询方法，获取包含关联数据的视图对象 + StoreupView storeupView = storeupService.selectView(ew); + // 返回成功响应及查询结果 + return R.ok("查询收藏表成功").put("data", storeupView); } - + /** - * 后端详情 + * 后端详情（根据ID查询） */ + // 映射路径参数/{id}获取记录ID @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id){ + // 根据ID查询收藏记录详情（后端使用） + public R info(@PathVariable("id") Long id) { + // 通过ID直接查询实体对象 StoreupEntity storeup = storeupService.selectById(id); + // 返回实体数据 return R.ok().put("data", storeup); } /** - * 前端详情 + * 前端详情（根据ID查询） */ + // 映射路径参数/{id}，前端调用的详情接口 @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id){ + // 逻辑与后端详情一致，返回实体数据 + public R detail(@PathVariable("id") Long id) { StoreupEntity storeup = storeupService.selectById(id); return R.ok().put("data", storeup); } - + /** - * 后端保存 + * 后端保存（新增收藏记录） */ + // 处理POST请求，接收请求体中的实体对象 @RequestMapping("/save") - public R save(@RequestBody StoreupEntity storeup, HttpServletRequest request){ - storeup.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(storeup); - storeup.setUserid((Long)request.getSession().getAttribute("userId")); + public R save(@RequestBody StoreupEntity storeup, HttpServletRequest request) { + // 生成唯一ID（时间戳+随机数，确保唯一性） + storeup.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 实体验证（注释：未启用，如需验证可取消注释） + //ValidatorUtils.validateEntity(storeup); + // 设置用户ID为当前登录用户的ID（后端保存时自动填充） + storeup.setUserid((Long) request.getSession().getAttribute("userId")); + // 调用服务类的插入方法 storeupService.insert(storeup); + // 返回成功响应 return R.ok(); } - + /** - * 前端保存 + * 前端保存（新增收藏记录） */ + // 前端调用的新增接口，逻辑与后端保存一致 @RequestMapping("/add") - public R add(@RequestBody StoreupEntity storeup, HttpServletRequest request){ - storeup.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(storeup); - storeup.setUserid((Long)request.getSession().getAttribute("userId")); + public R add(@RequestBody StoreupEntity storeup, HttpServletRequest request) { + // 生成唯一ID + storeup.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 实体验证（未启用） + //ValidatorUtils.validateEntity(storeup); + // 设置用户ID（前端请求时自动关联当前用户） + storeup.setUserid((Long) request.getSession().getAttribute("userId")); + // 插入数据库 storeupService.insert(storeup); return R.ok(); } /** - * 修改 + * 修改（更新收藏记录） */ + // 处理PUT请求，更新已有记录 @RequestMapping("/update") - public R update(@RequestBody StoreupEntity storeup, HttpServletRequest request){ + public R update(@RequestBody StoreupEntity storeup, HttpServletRequest request) { + // 实体验证（未启用） //ValidatorUtils.validateEntity(storeup); - storeupService.updateById(storeup);//全部更新 + // 根据ID更新实体对象（全字段更新） + storeupService.updateById(storeup); // 注释：标记为全部更新 return R.ok(); } - + /** - * 删除 + * 删除（批量删除收藏记录） */ + // 处理DELETE请求，接收ID数组 @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ + public R delete(@RequestBody Long[] ids) { + // 将ID数组转换为列表，批量删除 storeupService.deleteBatchIds(Arrays.asList(ids)); return R.ok(); } - + /** - * 提醒接口 + * 提醒接口（统计符合条件的记录数） */ - @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")); - } - if(!request.getSession().getAttribute("role").toString().equals("管理员")) { - wrapper.eq("userid", (Long)request.getSession().getAttribute("userId")); - } - - - int count = storeupService.selectCount(wrapper); - return R.ok().put("count", count); - } - - - -} + // 映射路径参数{columnName}/{type}，处理提醒相关统计 + @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); + + // 如果是日期范围提醒（type=2，相对当前日期计算提醒时间） + if (type.equals("2")) { + // 创建日期格式化对象（格式：yyyy-MM-dd） + 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")); + } + // 非管理员用户限制只能查询自己的数据 + if (!request.getSession().getAttribute("role").toString().equals("管理员")) { + wrapper.eq("userid", (Long) request.getSession().getAttribute("userId")); + } + + // 统计符合条件的记录数 + int count = storeupService.selectCount(wrapper); + // 返回统计结果 + return R.ok().put("count", count); + } +} \ No newline at end of file diff --git a/src/main/java/com/controller/UserController.java b/src/main/java/com/controller/UserController.java index 6bce00a..170f85c 100644 --- a/src/main/java/com/controller/UserController.java +++ b/src/main/java/com/controller/UserController.java @@ -1,174 +1,855 @@ - package com.controller; - +// 导入数组操作工具类，提供数组相关操作方法（如排序、查找等） import java.util.Arrays; +// 导入日历类，用于处理日期和时间（如日期计算、格式化等） import java.util.Calendar; +// 导入日期类，用于表示具体的日期和时间 import java.util.Date; +// 导入映射接口，用于存储键值对数据（如参数映射、结果集等） import java.util.Map; +// 导入列表接口，用于存储有序的元素集合 +import java.util.List; +// 导入链表实现类，提供高效的列表操作（如插入、删除） +import java.util.LinkedList; +// 导入哈希表实现类，提供键值对的快速存储和查找 +import java.util.HashMap; +// 导入迭代器接口，用于遍历集合中的元素 +import java.util.Iterator; +// 导入HTTP请求处理类，用于获取请求参数、会话等信息 import javax.servlet.http.HttpServletRequest; +// 导入Spring自动注入注解，自动装配依赖的服务类 import org.springframework.beans.factory.annotation.Autowired; +// 导入Spring控制器注解（冗余导入，实际使用@RestController，保留注释说明） import org.springframework.stereotype.Controller; +// 导入Spring GET请求映射注解，处理GET方法的请求 import org.springframework.web.bind.annotation.GetMapping; +// 导入Spring路径变量注解，获取URL路径中的参数值 import org.springframework.web.bind.annotation.PathVariable; +// 导入Spring POST请求映射注解，处理POST方法的请求 import org.springframework.web.bind.annotation.PostMapping; -import org.springframework.web.bind.annotation.RequestBody; +// 导入Spring请求映射注解，定义URL路径与方法的映射关系 import org.springframework.web.bind.annotation.RequestMapping; +// 导入Spring请求参数注解，获取请求参数的值 import org.springframework.web.bind.annotation.RequestParam; +// 导入Spring响应体注解（冗余导入，@RestController已包含，保留注释说明） import org.springframework.web.bind.annotation.ResponseBody; +// 导入Spring REST控制器注解，标记为RESTful风格控制器并自动返回JSON响应 import org.springframework.web.bind.annotation.RestController; +// 导入自定义忽略认证注解，标记无需认证的接口 import com.annotation.IgnoreAuth; +// 导入MyBatis-Plus实体包装器类，用于构建数据库查询条件 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入用户实体类，对应数据库用户表 import com.entity.TokenEntity; import com.entity.UserEntity; +// 导入角色实体类，对应数据库角色表 +import com.entity.RoleEntity; +// 导入权限实体类，对应数据库权限表 +import com.entity.PermissionEntity; +// 导入用户服务类，处理用户相关业务逻辑 import com.service.TokenService; import com.service.UserService; +// 导入角色服务类，处理角色相关业务逻辑 +import com.service.RoleService; +// 导入权限服务类，处理权限相关业务逻辑 +import com.service.PermissionService; +// 导入通用工具类，包含常用辅助方法 import com.utils.CommonUtil; +// 导入MyBatis-Plus工具类，提供通用数据库操作工具 import com.utils.MPUtil; +// 导入分页工具类，处理分页查询结果 import com.utils.PageUtils; +// 导入自定义响应类，封装统一的响应格式 import com.utils.R; +// 导入验证工具类，用于实体对象的参数验证 import com.utils.ValidatorUtils; /** - * 登录相关 + * 登录相关控制器 + * 处理用户登录、注册、权限管理等接口 */ +// 定义请求路径前缀为"/users"，所有接口路径均以此开头 @RequestMapping("users") +// 声明为REST控制器，处理HTTP请求并返回JSON数据 @RestController -public class UserController{ - +public class UserController { + + // 自动注入用户服务类实例，用于调用用户相关数据库操作 @Autowired private UserService userService; - + + // 自动注入令牌服务类实例，用于生成和管理用户令牌 @Autowired private TokenService tokenService; + // 自动注入角色服务类实例，用于处理角色相关业务 + @Autowired + private RoleService roleService; + + // 自动注入权限服务类实例，用于处理权限相关业务 + @Autowired + private PermissionService permissionService; + /** - * 登录 + * 登录接口 + * 允许匿名访问，处理用户登录请求 */ + // 标记该接口无需认证 @IgnoreAuth + // 映射POST请求路径"/login" @PostMapping(value = "/login") + // 定义登录方法，接收用户名、密码、验证码和HTTP请求 public R login(String username, String password, String captcha, HttpServletRequest request) { + // 根据用户名查询用户实体（从数据库中查找匹配的用户） UserEntity user = userService.selectOne(new EntityWrapper().eq("username", username)); - if(user==null || !user.getPassword().equals(password)) { + // 验证用户是否存在且密码是否正确 + if (user == null || !user.getPassword().equals(password)) { + // 返回错误响应，提示账号或密码不正确 return R.error("账号或密码不正确"); } - String token = tokenService.generateToken(user.getId(),username, "users", user.getRole()); + // 生成用户令牌（参数：用户ID、用户名、表名、用户角色） + String token = tokenService.generateToken(user.getId(), username, "users", user.getRole()); + // 返回成功响应，携带生成的令牌 return R.ok().put("token", token); } - + /** - * 注册 + * 注册接口 + * 允许匿名访问，处理用户注册请求 */ + // 标记该接口无需认证 @IgnoreAuth + // 映射POST请求路径"/register"，接收请求体中的用户实体 @PostMapping(value = "/register") - public R register(@RequestBody UserEntity user){ + public R register(@RequestBody UserEntity user) { + // 注释：实体验证（此处代码被注释，未启用参数验证） // ValidatorUtils.validateEntity(user); - if(userService.selectOne(new EntityWrapper().eq("username", user.getUsername())) !=null) { - return R.error("用户已存在"); - } - userService.insert(user); - return R.ok(); - } + // 检查用户名是否已存在（数据库中是否有相同用户名的记录） + if (userService.selectOne(new EntityWrapper().eq("username", user.getUsername())) != null) { + // 返回错误响应，提示用户已存在 + return R.error("用户已存在"); + } + // 插入新用户到数据库 + userService.insert(user); + // 返回成功响应 + return R.ok(); + } /** - * 退出 + * 退出登录接口 + * 处理用户退出请求，使当前会话失效 */ + // 映射GET请求路径"logout" @GetMapping(value = "logout") public R logout(HttpServletRequest request) { + // 使当前HTTP会话失效，清除用户登录状态 request.getSession().invalidate(); + // 返回成功响应，提示退出成功 return R.ok("退出成功"); } - + /** - * 密码重置 - */ - @IgnoreAuth + * 密码重置接口 + * 允许匿名访问，处理用户密码重置请求 + */ + // 标记该接口无需认证 + @IgnoreAuth + // 映射任意请求方法路径"/resetPass" @RequestMapping(value = "/resetPass") - public R resetPass(String username, HttpServletRequest request){ - UserEntity user = userService.selectOne(new EntityWrapper().eq("username", username)); - if(user==null) { - return R.error("账号不存在"); - } - user.setPassword("123456"); - userService.update(user,null); - return R.ok("密码已重置为：123456"); - } - - /** - * 列表 - */ - @RequestMapping("/page") - public R page(@RequestParam Map params,UserEntity user){ - EntityWrapper ew = new EntityWrapper(); - PageUtils page = userService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params)); - return R.ok().put("data", page); - } - - /** - * 列表 - */ - @RequestMapping("/list") - public R list( UserEntity user){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( user, "user")); - return R.ok().put("data", userService.selectListView(ew)); - } - - /** - * 信息 - */ - @RequestMapping("/info/{id}") - public R info(@PathVariable("id") String id){ - UserEntity user = userService.selectById(id); - return R.ok().put("data", user); - } - - /** - * 获取用户的session用户信息 - */ - @RequestMapping("/session") - public R getCurrUser(HttpServletRequest request){ - Long id = (Long)request.getSession().getAttribute("userId"); - UserEntity user = userService.selectById(id); - return R.ok().put("data", user); - } - - /** - * 保存 - */ - @PostMapping("/save") - public R save(@RequestBody UserEntity user){ + public R resetPass(String username, HttpServletRequest request) { + // 根据用户名查询用户实体 + UserEntity user = userService.selectOne(new EntityWrapper().eq("username", username)); + // 检查用户是否存在 + if (user == null) { + // 返回错误响应，提示账号不存在 + return R.error("账号不存在"); + } + // 将用户密码重置为默认值"123456" + user.setPassword("123456"); + // 更新用户信息（第二个参数为null表示更新所有匹配记录，此处按ID更新） + userService.update(user, null); + // 返回成功响应，提示密码重置结果 + return R.ok("密码已重置为：123456"); + } + + /** + * 用户列表接口（分页查询） + * 处理用户列表的分页查询请求 + */ + // 映射任意请求方法路径"/page" + @RequestMapping("/page") + public R page(@RequestParam Map params, UserEntity user) { + // 创建实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 调用用户服务的分页查询方法（包含排序、范围查询、模糊查询处理） + PageUtils page = userService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params)); + // 返回成功响应，携带分页数据 + return R.ok().put("data", page); + } + + /** + * 用户列表接口（全量查询） + * 处理用户列表的全量查询请求 + */ + // 映射任意请求方法路径"/list" + @RequestMapping("/list") + public R list(UserEntity user) { + // 创建实体包装器 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件：所有字段与实体对象相等（前缀为"user"，避免字段名冲突） + ew.allEq(MPUtil.allEQMapPre(user, "user")); + // 返回成功响应，携带查询结果（视图列表，可能包含关联数据） + return R.ok().put("data", userService.selectListView(ew)); + } + + /** + * 用户详情接口 + * 根据用户ID查询用户详细信息 + */ + // 映射任意请求方法路径"/info/{id}"，{id}为路径参数 + @RequestMapping("/info/{id}") + public R info(@PathVariable("id") String id) { + // 根据用户ID查询用户实体（从数据库中获取用户详情） + UserEntity user = userService.selectById(id); + // 返回成功响应，携带用户数据 + return R.ok().put("data", user); + } + + /** + * 获取当前会话用户信息接口 + * 获取当前登录用户的会话信息 + */ + // 映射任意请求方法路径"/session" + @RequestMapping("/session") + public R getCurrUser(HttpServletRequest request) { + // 从会话中获取用户ID（登录时存储的用户标识） + Long id = (Long) request.getSession().getAttribute("userId"); + // 根据用户ID查询用户实体 + UserEntity user = userService.selectById(id); + // 返回成功响应，携带当前用户数据 + return R.ok().put("data", user); + } + + /** + * 保存用户接口（新增用户） + * 处理新增用户请求 + */ + // 映射POST请求路径"/save"，接收请求体中的用户实体 + @PostMapping("/save") + public R save(@RequestBody UserEntity user) { + // 注释：实体验证（此处代码被注释，未启用参数验证） // ValidatorUtils.validateEntity(user); - if(userService.selectOne(new EntityWrapper().eq("username", user.getUsername())) !=null) { - return R.error("用户已存在"); - } - userService.insert(user); - return R.ok(); - } - - /** - * 修改 - */ - @RequestMapping("/update") - public R update(@RequestBody UserEntity user){ + // 检查用户名是否已存在（除当前用户外，避免更新时冲突） + if (userService.selectOne(new EntityWrapper().eq("username", user.getUsername())) != null) { + // 返回错误响应，提示用户已存在 + return R.error("用户已存在"); + } + // 插入新用户到数据库 + userService.insert(user); + // 返回成功响应 + return R.ok(); + } + + /** + * 修改用户接口 + * 处理用户信息修改请求 + */ + // 映射任意请求方法路径"/update"，接收请求体中的用户实体 + @RequestMapping("/update") + public R update(@RequestBody UserEntity user) { + // 注释：实体验证（此处代码被注释，未启用参数验证） // ValidatorUtils.validateEntity(user); - UserEntity u = userService.selectOne(new EntityWrapper().eq("username", user.getUsername())); - if(u!=null && u.getId()!=user.getId() && u.getUsername().equals(user.getUsername())) { - return R.error("用户名已存在。"); - } - userService.updateById(user);//全部更新 - return R.ok(); - } - - /** - * 删除 - */ - @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ - userService.deleteBatchIds(Arrays.asList(ids)); - return R.ok(); - } -} + // 根据用户名查询用户实体（检查用户名是否被其他用户占用） + UserEntity u = userService.selectOne(new EntityWrapper().eq("username", user.getUsername())); + // 检查用户名是否已被其他用户使用（ID不同但用户名相同） + if (u != null && u.getId() != user.getId() && u.getUsername().equals(user.getUsername())) { + // 返回错误响应，提示用户名已存在 + return R.error("用户名已存在。"); + } + // 根据用户ID更新用户信息（全字段更新，覆盖数据库中现有记录） + userService.updateById(user); // 注释：标记为全部更新，非部分更新 + // 返回成功响应 + return R.ok(); + } + + /** + * 删除用户接口（批量删除） + * 处理用户批量删除请求 + */ + // 映射任意请求方法路径"/delete"，接收请求体中的用户ID数组 + @RequestMapping("/delete") + public R delete(@RequestBody Long[] ids) { + // 将用户ID数组转换为列表，批量删除对应的用户记录 + userService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 + return R.ok(); + } + + /** + * 获取用户的角色信息接口 + * 根据用户ID查询用户所属角色 + */ + // 映射任意请求方法路径"/roles/{userId}"，{userId}为用户ID + @RequestMapping("/roles/{userId}") + public R getUserRoles(@PathVariable("userId") Long userId) { + // 根据用户ID查询用户实体 + UserEntity user = userService.selectById(userId); + // 检查用户是否存在 + if (user == null) { + // 返回错误响应，提示用户不存在 + return R.error("用户不存在"); + } + // 根据用户角色ID查询角色信息（用户实体中存储角色ID，关联角色表） + RoleEntity role = roleService.selectById(user.getRole()); + // 返回成功响应，携带角色数据 + return R.ok().put("role", role); + } + + /** + * 获取角色的权限信息接口 + * 根据角色ID查询角色拥有的权限 + */ + // 映射任意请求方法路径"/permissions/{roleId}"，{roleId}为角色ID + @RequestMapping("/permissions/{roleId}") + public R getRolePermissions(@PathVariable("roleId") Long roleId) { + // 根据角色ID查询角色实体 + RoleEntity role = roleService.selectById(roleId); + // 检查角色是否存在 + if (role == null) { + // 返回错误响应，提示角色不存在 + return R.error("角色不存在"); + } + // 根据角色ID查询权限信息（权限表中存储角色ID，关联查询） + List permissions = permissionService.selectList(new EntityWrapper().eq("role_id", roleId)); + // 返回成功响应，携带权限列表 + return R.ok().put("permissions", permissions); + } + + /** + * 新增角色接口 + * 处理新增角色请求 + */ + // 映射POST请求路径"/roles/add"，接收请求体中的角色实体 + @PostMapping("/roles/add") + public R addRole(@RequestBody RoleEntity role) { + // 检查角色名是否已存在（避免重复角色名） + if (roleService.selectOne(new EntityWrapper().eq("role_name", role.getRoleName())) != null) { + // 返回错误响应，提示角色名已存在 + return R.error("角色名已存在"); + } + // 插入新角色到数据库 + roleService.insert(role); + // 返回成功响应 + return R.ok(); + } + + /** + * 修改角色信息接口 + * 处理角色信息修改请求 + */ + // 映射任意请求方法路径"/roles/update"，接收请求体中的角色实体 + @RequestMapping("/roles/update") + public R updateRole(@RequestBody RoleEntity role) { + // 检查角色名是否已被其他角色使用（更新时排除自身ID） + RoleEntity existingRole = roleService.selectOne(new EntityWrapper().eq("role_name", role.getRoleName())); + if (existingRole != null && existingRole.getId() != role.getId()) { + // 返回错误响应，提示角色名已存在 + return R.error("角色名已存在"); + } + // 更新角色信息到数据库 + roleService.updateById(role); + // 返回成功响应 + return R.ok(); + } + + /** + * 删除角色接口 + * 处理角色删除请求（需先检查是否有用户关联） + */ + // 映射任意请求方法路径"/roles/delete/{roleId}"，{roleId}为角色ID + @RequestMapping("/roles/delete/{roleId}") + public R deleteRole(@PathVariable("roleId") Long roleId) { + // 检查该角色是否有用户关联（查询所有拥有该角色的用户） + List users = userService.selectList(new EntityWrapper().eq("role", roleId)); + if (!users.isEmpty()) { + // 返回错误响应，提示角色下存在用户，无法删除 + return R.error("该角色下存在用户，无法删除"); + } + // 删除角色记录 + roleService.deleteById(roleId); + // 返回成功响应 + return R.ok(); + } + + /** + * 新增权限接口 + * 处理新增权限请求 + */ + // 映射POST请求路径"/permissions/add"，接收请求体中的权限实体 + @PostMapping("/permissions/add") + public R addPermission(@RequestBody PermissionEntity permission) { + // 检查权限名是否已存在（避免重复权限名） + if (permissionService.selectOne(new EntityWrapper().eq("permission_name", permission.getPermissionName())) != null) { + // 返回错误响应，提示权限名已存在 + return R.error("权限名已存在"); + } + // 插入新权限到数据库 + permissionService.insert(permission); + // 返回成功响应 + return R.ok(); + } + + /** + * 修改权限信息接口 + * 处理权限信息修改请求 + */ + // 映射任意请求方法路径"/permissions/update"，接收请求体中的权限实体 + @RequestMapping("/permissions/update") + public R updatePermission(@RequestBody PermissionEntity permission) { + // 检查权限名是否已被其他权限使用（更新时排除自身ID） + PermissionEntity existingPermission = permissionService.selectOne(new EntityWrapper().eq("permission_name", permission.getPermissionName())); + if (existingPermission != null && existingPermission.getId() != permission.getId()) { + // 返回错误响应，提示权限名已存在 + return R.error("权限名已存在"); + } + // 更新权限信息到数据库 + permissionService.updateById(permission); + // 返回成功响应 + return R.ok(); + } + + /** + * 删除权限接口 + * 处理权限删除请求 + */ + // 映射任意请求方法路径"/permissions/delete/{permissionId}"，{permissionId}为权限ID + @RequestMapping("/permissions/delete/{permissionId}") + public R deletePermission(@PathVariable("permissionId") Long permissionId) { + // 删除指定ID的权限记录 + permissionService.deleteById(permissionId); + // 返回成功响应 + return R.ok(); + } + + /** + * 为用户分配角色接口 + * 将指定角色分配给用户 + */ + // 映射POST请求路径"/users/{userId}/assignRole/{roleId}"，路径参数为用户ID和角色ID + @PostMapping("/users/{userId}/assignRole/{roleId}") + public R assignRoleToUser(@PathVariable("userId") Long userId, @PathVariable("roleId") Long roleId) { + // 检查用户是否存在 + UserEntity user = userService.selectById(userId); + if (user == null) { + // 返回错误响应，提示用户不存在 + return R.error("用户不存在"); + } + // 检查角色是否存在 + RoleEntity role = roleService.selectById(roleId); + if (role == null) { + // 返回错误响应，提示角色不存在 + return R.error("角色不存在"); + } + // 更新用户的角色ID为指定角色ID + user.setRole(roleId); + userService.updateById(user); + // 返回成功响应 + return R.ok(); + } + + /** + * 为角色分配权限接口 + * 将指定权限分配给角色 + */ + // 映射POST请求路径"/roles/{roleId}/assignPermission/{permissionId}"，路径参数为角色ID和权限ID + @PostMapping("/roles/{roleId}/assignPermission/{permissionId}") + public R assignPermissionToRole(@PathVariable("roleId") Long roleId, @PathVariable("permissionId") Long permissionId) { + // 检查角色是否存在 + RoleEntity role = roleService.selectById(roleId); + if (role == null) { + // 返回错误响应，提示角色不存在 + return R.error("角色不存在"); + } + // 检查权限是否存在 + PermissionEntity permission = permissionService.selectById(permissionId); + if (permission == null) { + // 返回错误响应，提示权限不存在 + return R.error("权限不存在"); + } + // 更新权限的角色ID为指定角色ID（假设权限表中直接存储角色ID） + permission.setRoleId(roleId); + permissionService.updateById(permission); + // 返回成功响应 + return R.ok(); + } + + /** + * 统计用户数量接口 + * 统计系统中的用户总数 + */ + // 映射任意请求方法路径"/users/count" + @RequestMapping("/users/count") + public R countUsers() { + // 统计用户表中的记录数 + Integer userCount = userService.selectCount(new EntityWrapper()); + // 返回成功响应，携带用户数量 + return R.ok().put("userCount", userCount); + } + + /** + * 统计角色数量接口 + * 统计系统中的角色总数 + */ + // 映射任意请求方法路径"/roles/count" + @RequestMapping("/roles/count") + public R countRoles() { + // 统计角色表中的记录数 + Integer roleCount = roleService.selectCount(new EntityWrapper()); + // 返回成功响应，携带角色数量 + return R.ok().put("roleCount", roleCount); + } + + /** + * 统计权限数量接口 + * 统计系统中的权限总数 + */ + // 映射任意请求方法路径"/permissions/count" + @RequestMapping("/permissions/count") + public R countPermissions() { + // 统计权限表中的记录数 + Integer permissionCount = permissionService.selectCount(new EntityWrapper()); + // 返回成功响应，携带权限数量 + return R.ok().put("permissionCount", permissionCount); + } + + /** + * 根据用户名模糊查询用户列表接口 + * 处理用户名模糊查询请求 + */ + // 映射任意请求方法路径"/users/search/{keyword}"，{keyword}为搜索关键词 + @RequestMapping("/users/search/{keyword}") + public R searchUsers(@PathVariable("keyword") String keyword) { + // 创建实体包装器，设置用户名模糊查询条件（包含关键词） + EntityWrapper ew = new EntityWrapper().like("username", keyword); + // 查询符合条件的用户列表 + List users = userService.selectList(ew); + // 返回成功响应，携带查询结果 + return R.ok().put("users", users); + } + + /** + * 根据角色名模糊查询角色列表接口 + * 处理角色名模糊查询请求 + */ + // 映射任意请求方法路径"/roles/search/{keyword}"，{keyword}为搜索关键词 + @RequestMapping("/roles/search/{keyword}") + public R searchRoles(@PathVariable("keyword") String keyword) { + // 创建实体包装器，设置角色名模糊查询条件（包含关键词） + EntityWrapper ew = new EntityWrapper().like("role_name", keyword); + // 查询符合条件的角色列表 + List roles = roleService.selectList(ew); + // 返回成功响应，携带查询结果 + return R.ok().put("roles", roles); + } + + /** + * 根据权限名模糊查询权限列表接口 + * 处理权限名模糊查询请求 + */ + // 映射任意请求方法路径"/permissions/search/{keyword}"，{keyword}为搜索关键词 + @RequestMapping("/permissions/search/{keyword}") + public R searchPermissions(@PathVariable("keyword") String keyword) { + // 创建实体包装器，设置权限名模糊查询条件（包含关键词） + EntityWrapper ew = new EntityWrapper().like("permission_name", keyword); + // 查询符合条件的权限列表 + List permissions = permissionService.selectList(ew); + // 返回成功响应，携带查询结果 + return R.ok().put("permissions", permissions); + } + + /** + * 获取所有用户及其角色信息接口 + * 查询所有用户及其关联的角色信息 + */ + // 映射任意请求方法路径"/users/allWithRoles" + @RequestMapping("/users/allWithRoles") + public R getAllUsersWithRoles() { + // 查询所有用户记录 + List users = userService.selectList(new EntityWrapper()); + // 创建映射表，存储用户ID到用户及角色信息的映射 + Map> userRoleMap = new HashMap<>(); + // 遍历用户列表，填充角色信息 + for (UserEntity user : users) { + // 根据用户角色ID查询角色实体 + RoleEntity role = roleService.selectById(user.getRole()); + // 创建用户信息映射，包含用户和角色数据 + Map userInfo = new HashMap<>(); + userInfo.put("user", user); + userInfo.put("role", role); + // 将用户信息存入映射表 + userRoleMap.put(user.getId(), userInfo); + } + // 返回成功响应，携带用户及其角色信息 + return R.ok().put("userRoleMap", userRoleMap); + } + + /** + * 获取所有角色及其权限信息接口 + * 查询所有角色及其关联的权限信息 + */ + // 映射任意请求方法路径"/roles/allWithPermissions" + @RequestMapping("/roles/allWithPermissions") + public R getAllRolesWithPermissions() { + // 查询所有角色记录 + List roles = roleService.selectList(new EntityWrapper()); + // 创建映射表，存储角色ID到角色及权限信息的映射 + Map> rolePermissionMap = new HashMap<>(); + // 遍历角色列表，填充权限信息 + for (RoleEntity role : roles) { + // 根据角色ID查询权限列表 + List permissions = permissionService.selectList(new EntityWrapper().eq("role_id", role.getId())); + // 创建角色信息映射，包含角色和权限数据 + Map roleInfo = new HashMap<>(); + roleInfo.put("role", role); + roleInfo.put("permissions", permissions); + // 将角色信息存入映射表 + rolePermissionMap.put(role.getId(), roleInfo); + } + // 返回成功响应，携带角色及其权限信息 + return R.ok().put("rolePermissionMap", rolePermissionMap); + } + + /** + * 批量为用户分配角色接口 + * 处理批量用户角色分配请求 + */ + // 映射POST请求路径"/users/batchAssignRole"，接收包含用户ID列表和角色ID的请求体 + @PostMapping("/users/batchAssignRole") + public R batchAssignRole(@RequestBody Map params) { + // 从请求体中获取用户ID列表 + List userIds = (List) params.get("userIds"); + // 从请求体中获取角色ID + Long roleId = (Long) params.get("roleId"); + // 检查角色是否存在 + RoleEntity role = roleService.selectById(roleId); + if (role == null) { + // 返回错误响应，提示角色不存在 + return R.error("角色不存在"); + } + // 遍历用户ID列表，逐个分配角色 + for (Long userId : userIds) { + // 根据用户ID查询用户实体 + UserEntity user = userService.selectById(userId); + if (user != null) { + // 更新用户的角色ID为目标角色ID + user.setRole(roleId); + userService.updateById(user); + } + } + // 返回成功响应 + return R.ok(); + } + + /** + * 批量为角色分配权限接口 + * 处理批量角色权限分配请求 + */ + // 映射POST请求路径"/roles/batchAssignPermission"，接收包含角色ID和权限ID列表的请求体 + @PostMapping("/roles/batchAssignPermission") + public R batchAssignPermission(@RequestBody Map params) { + // 从请求体中获取角色ID + Long roleId = (Long) params.get("roleId"); + // 从请求体中获取权限ID列表 + List permissionIds = (List) params.get("permissionIds"); + // 检查角色是否存在 + RoleEntity role = roleService.selectById(roleId); + if (role == null) { + // 返回错误响应，提示角色不存在 + return R.error("角色不存在"); + } + // 遍历权限ID列表，逐个分配权限 + for (Long permissionId : permissionIds) { + // 根据权限ID查询权限实体 + PermissionEntity permission = permissionService.selectById(permissionId); + if (permission != null) { + // 更新权限的角色ID为目标角色ID + permission.setRoleId(roleId); + permissionService.updateById(permission); + } + } + // 返回成功响应 + return R.ok(); + } + + /** + * 验证用户是否具有某个权限接口 + * 检查用户是否拥有指定权限 + */ + // 映射任意请求方法路径"/users/{userId}/hasPermission/{permissionName}"，路径参数为用户ID和权限名 + @RequestMapping("/users/{userId}/hasPermission/{permissionName}") + public R checkUserPermission(@PathVariable("userId") Long userId, @PathVariable("permissionName") String permissionName) { + // 根据用户ID查询用户实体 + UserEntity user = userService.selectById(userId); + if (user == null) { + // 返回错误响应，提示用户不存在 + return R.error("用户不存在"); + } + // 根据用户角色ID查询角色实体 + RoleEntity role = roleService.selectById(user.getRole()); + if (role == null) { + // 返回错误响应，提示角色不存在（用户角色异常） + return R.error("角色不存在"); + } + // 根据角色ID和权限名查询权限实体（检查角色是否拥有该权限） + PermissionEntity permission = permissionService.selectOne(new EntityWrapper() + .eq("role_id", role.getId()) + .eq("permission_name", permissionName)); + // 判断用户是否具有该权限（存在即有权限） + boolean hasPermission = permission != null; + // 返回成功响应，携带权限检查结果 + return R.ok().put("hasPermission", hasPermission); + } + + /** + * 获取用户的所有权限接口 + * 查询用户拥有的所有权限 + */ + // 映射任意请求方法路径"/users/{userId}/allPermissions"，路径参数为用户ID + @RequestMapping("/users/{userId}/allPermissions") + public R getUserAllPermissions(@PathVariable("userId") Long userId) { + // 根据用户ID查询用户实体 + UserEntity user = userService.selectById(userId); + if (user == null) { + // 返回错误响应，提示用户不存在 + return R.error("用户不存在"); + } + // 根据用户角色ID查询角色实体 + RoleEntity role = roleService.selectById(user.getRole()); + if (role == null) { + // 返回错误响应，提示角色不存在（用户角色异常） + return R.error("角色不存在"); + } + // 根据角色ID查询所有权限（该角色拥有的所有权限） + List permissions = permissionService.selectList(new EntityWrapper().eq("role_id", role.getId())); + // 返回成功响应，携带权限列表 + return R.ok().put("permissions", permissions); + } + + /** + * 禁用用户接口 + * 将用户状态设置为禁用（假设状态0为禁用） + */ + // 映射任意请求方法路径"/users/{userId}/disable"，路径参数为用户ID + @RequestMapping("/users/{userId}/disable") + public R disableUser(@PathVariable("userId") Long userId) { + // 根据用户ID查询用户实体 + UserEntity user = userService.selectById(userId); + if (user == null) { + // 返回错误响应，提示用户不存在 + return R.error("用户不存在"); + } + // 设置用户状态为禁用（假设0表示禁用，1表示启用） + user.setStatus(0); + // 更新用户状态到数据库 + userService.updateById(user); + // 返回成功响应 + return R.ok(); + } + + /** + * 启用用户接口 + * 将用户状态设置为启用（假设状态1为启用） + */ + // 映射任意请求方法路径"/users/{userId}/enable"，路径参数为用户ID + @RequestMapping("/users/{userId}/enable") + public R enableUser(@PathVariable("userId") Long userId) { + // 根据用户ID查询用户实体 + UserEntity user = userService.selectById(userId); + if (user == null) { + // 返回错误响应，提示用户不存在 + return R.error("用户不存在"); + } + // 设置用户状态为启用（假设1表示启用，0表示禁用） + user.setStatus(1); + // 更新用户状态到数据库 + userService.updateById(user); + // 返回成功响应 + return R.ok(); + } + + /** + * 批量禁用用户接口 + * 处理批量用户禁用请求 + */ + // 映射POST请求路径"/users/batchDisable"，接收请求体中的用户ID列表 + @PostMapping("/users/batchDisable") + public R batchDisableUsers(@RequestBody List userIds) { + // 遍历用户ID列表，逐个禁用用户 + for (Long userId : userIds) { + // 根据用户ID查询用户实体 + UserEntity user = userService.selectById(userId); + if (user != null) { + // 设置用户状态为禁用 + user.setStatus(0); + userService.updateById(user); + } + } + // 返回成功响应 + return R.ok(); + } + + /** + * 批量启用用户接口 + * 处理批量用户启用请求 + */ + // 映射POST请求路径"/users/batchEnable"，接收请求体中的用户ID列表 + @PostMapping("/users/batchEnable") + public R batchEnableUsers(@RequestBody List userIds) { + // 遍历用户ID列表，逐个启用用户 + for (Long userId : userIds) { + // 根据用户ID查询用户实体 + UserEntity user = userService.selectById(userId); + if (user != null) { + // 设置用户状态为启用 + user.setStatus(1); + userService.updateById(user); + } + } + // 返回成功响应 + return R.ok(); + } + + /** + * 获取所有禁用用户接口 + * 查询状态为禁用的用户列表 + */ + // 映射任意请求方法路径"/users/disabled" + @RequestMapping("/users/disabled") + public R getDisabledUsers() { + // 创建实体包装器，设置状态为禁用的查询条件（假设0为禁用） + EntityWrapper ew = new EntityWrapper().eq("status", 0); + // 查询所有禁用用户记录 + List disabledUsers = userService.selectList(ew); + // 返回成功响应，携带禁用用户列表 + return R.ok().put("disabledUsers", disabledUsers); + } + + /** + * 获取所有启用用户接口 + * 查询状态为启用的用户列表 + */ + // 映射任意请求方法路径"/users/enabled" + @RequestMapping("/users/enabled") + public R getEnabledUsers() { + // 创建实体包装器，设置状态为启用的查询条件（假设1为启用） + EntityWrapper ew = new EntityWrapper().eq("status", 1); + // 查询所有启用用户记录 + List enabledUsers = userService.selectList(ew); + // 返回成功响应，携带启用用户列表 + return R.ok().put("enabledUsers", enabledUsers); + } +} \ No newline at end of file diff --git a/src/main/java/com/controller/WodebijiController.java b/src/main/java/com/controller/WodebijiController.java index 426f557..340b37b 100644 --- a/src/main/java/com/controller/WodebijiController.java +++ b/src/main/java/com/controller/WodebijiController.java @@ -1,110 +1,482 @@ package com.controller; +// 导入SimpleDateFormat类，用于格式化日期和时间 import java.text.SimpleDateFormat; +// 导入ArrayList类，用于创建动态数组 import java.util.ArrayList; +// 导入Arrays类，提供了操作数组的静态方法 import java.util.Arrays; +// 导入Calendar类，用于处理日期和时间 import java.util.Calendar; +// 导入Map接口，用于存储键值对 import java.util.Map; +// 导入HashMap类，实现了Map接口，用于存储键值对 import java.util.HashMap; +// 导入Iterator接口，用于遍历集合 import java.util.Iterator; +// 导入Date类，用于表示特定的瞬间 import java.util.Date; +// 导入List接口，用于存储有序的元素集合 import java.util.List; +// 导入HttpServletRequest类，用于封装HTTP请求信息 import javax.servlet.http.HttpServletRequest; +// 导入验证工具类，用于验证实体对象的合法性 import com.utils.ValidatorUtils; +// 导入Apache Commons Lang库中的StringUtils类，提供了字符串操作的实用方法 import org.apache.commons.lang3.StringUtils; +// 导入Spring框架的自动注入注解，用于自动装配依赖 import org.springframework.beans.factory.annotation.Autowired; +// 导入Spring框架的日期格式化注解，用于将请求参数转换为日期类型 import org.springframework.format.annotation.DateTimeFormat; +// 导入Spring框架的路径变量注解，用于获取URL中的路径变量 import org.springframework.web.bind.annotation.PathVariable; +// 导入Spring框架的请求体注解，用于将请求体中的数据绑定到方法参数上 import org.springframework.web.bind.annotation.RequestBody; +// 导入Spring框架的请求映射注解，用于将HTTP请求映射到处理方法上 import org.springframework.web.bind.annotation.RequestMapping; +// 导入Spring框架的请求参数注解，用于获取请求参数的值 import org.springframework.web.bind.annotation.RequestParam; +// 导入Spring框架的REST控制器注解，用于将该类标记为RESTful风格的控制器 import org.springframework.web.bind.annotation.RestController; +// 导入MyBatis-Plus的实体包装器类，用于构建查询条件 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入MyBatis-Plus的包装器接口，是EntityWrapper的父接口 import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的忽略认证注解，用于标记不需要进行认证的接口 import com.annotation.IgnoreAuth; +// 导入我的笔记实体类，对应数据库中的我的笔记表 import com.entity.WodebijiEntity; +// 导入我的笔记视图类，用于展示我的笔记信息 import com.entity.view.WodebijiView; +// 导入我的笔记服务类，用于处理我的笔记相关的业务逻辑 import com.service.WodebijiService; +// 导入令牌服务类，用于处理令牌相关的业务逻辑 import com.service.TokenService; +// 导入分页工具类，用于处理分页查询结果 import com.utils.PageUtils; +// 导入自定义的响应类，用于封装统一的响应格式 import com.utils.R; +// 导入MD5工具类，用于对数据进行MD5加密 import com.utils.MD5Util; +// 导入MyBatis-Plus工具类，提供了一些常用的工具方法 import com.utils.MPUtil; +// 导入通用工具类，提供了一些通用的工具方法 import com.utils.CommonUtil; /** * 我的笔记 * 后端接口 - * @author - * @email + * @author + * @email * @date 2021-05-09 15:46:15 */ +// 将该类标记为RESTful风格的控制器，处理HTTP请求并返回JSON数据 @RestController +// 定义请求映射路径，所有以/wodebiji开头的请求都会被该控制器处理 @RequestMapping("/wodebiji") public class WodebijiController { + // 使用@Autowired注解自动注入我的笔记服务类的实例 @Autowired private WodebijiService wodebijiService; - + + // 以下是新添加的功能：根据笔记标题进行模糊查询 + + /** + * 根据笔记标题进行模糊查询（后端） + * @param params 请求参数，包含分页和排序信息 + * @param title 笔记标题关键词，用于模糊查询 + * @param request HTTP请求对象，用于获取会话信息 + * @return 包含查询结果的统一响应对象 + */ + @RequestMapping("/searchByTitle") + public R searchByTitle(@RequestParam Map params, @RequestParam String title, HttpServletRequest request) { + // 创建实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 添加模糊查询条件，查询笔记标题包含指定关键词的记录 + ew.like("title", title); + + // 获取会话中的表名 + String tableName = request.getSession().getAttribute("tableName").toString(); + if (tableName.equals("yonghu")) { + // 如果表名是yonghu，则添加用户账号的查询条件 + ew.eq("yonghuzhanghao", (String) request.getSession().getAttribute("username")); + } + + // 调用服务类的分页查询方法，传入请求参数和排序后的查询条件 + PageUtils page = wodebijiService.queryPage(params, MPUtil.sort(ew, params)); + // 返回成功响应，并将查询结果的分页信息放入响应对象中 + return R.ok().put("data", page); + } + + // 以下是新添加的功能：根据笔记创建时间范围进行查询 + + /** + * 根据笔记创建时间范围进行查询（后端） + * @param params 请求参数，包含分页和排序信息 + * @param startDate 开始日期，用于筛选创建时间在该日期之后的笔记 + * @param endDate 结束日期，用于筛选创建时间在该日期之前的笔记 + * @param request HTTP请求对象，用于获取会话信息 + * @return 包含查询结果的统一响应对象 + */ + @RequestMapping("/searchByCreateTime") + public R searchByCreateTime(@RequestParam Map params, + @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") Date startDate, + @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") Date endDate, + HttpServletRequest request) { + // 创建实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 添加时间范围查询条件，查询创建时间在指定范围内的笔记 + ew.between("create_time", startDate, endDate); + + // 获取会话中的表名 + String tableName = request.getSession().getAttribute("tableName").toString(); + if (tableName.equals("yonghu")) { + // 如果表名是yonghu，则添加用户账号的查询条件 + ew.eq("yonghuzhanghao", (String) request.getSession().getAttribute("username")); + } + + // 调用服务类的分页查询方法，传入请求参数和排序后的查询条件 + PageUtils page = wodebijiService.queryPage(params, MPUtil.sort(ew, params)); + // 返回成功响应，并将查询结果的分页信息放入响应对象中 + return R.ok().put("data", page); + } + + // 以下是新添加的功能：根据笔记重要程度进行查询 + + /** + * 根据笔记重要程度进行查询（后端） + * @param params 请求参数，包含分页和排序信息 + * @param importance 笔记重要程度，用于筛选指定重要程度的笔记 + * @param request HTTP请求对象，用于获取会话信息 + * @return 包含查询结果的统一响应对象 + */ + @RequestMapping("/searchByImportance") + public R searchByImportance(@RequestParam Map params, @RequestParam int importance, HttpServletRequest request) { + // 创建实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 添加重要程度查询条件，查询指定重要程度的笔记 + ew.eq("importance", importance); + + // 获取会话中的表名 + String tableName = request.getSession().getAttribute("tableName").toString(); + if (tableName.equals("yonghu")) { + // 如果表名是yonghu，则添加用户账号的查询条件 + ew.eq("yonghuzhanghao", (String) request.getSession().getAttribute("username")); + } + + // 调用服务类的分页查询方法，传入请求参数和排序后的查询条件 + PageUtils page = wodebijiService.queryPage(params, MPUtil.sort(ew, params)); + // 返回成功响应，并将查询结果的分页信息放入响应对象中 + return R.ok().put("data", page); + } + + // 以下是新添加的功能：批量更新笔记的重要程度 + + /** + * 批量更新笔记的重要程度（后端） + * @param ids 要更新的笔记的ID数组 + * @param importance 新的重要程度 + * @return 包含更新结果的统一响应对象 + */ + @RequestMapping("/batchUpdateImportance") + public R batchUpdateImportance(@RequestBody Long[] ids, @RequestParam int importance) { + // 遍历ID数组 + for (Long id : ids) { + // 根据ID查询笔记实体 + WodebijiEntity wodebiji = wodebijiService.selectById(id); + if (wodebiji != null) { + // 如果笔记存在，则更新其重要程度 + wodebiji.setImportance(importance); + // 调用服务类的更新方法，更新笔记信息 + wodebijiService.updateById(wodebiji); + } + } + // 返回成功响应 + return R.ok(); + } + + // 以下是新添加的功能：统计不同重要程度的笔记数量 + + /** + * 统计不同重要程度的笔记数量（后端） + * @param request HTTP请求对象，用于获取会话信息 + * @return 包含统计结果的统一响应对象 + */ + @RequestMapping("/countByImportance") + public R countByImportance(HttpServletRequest request) { + // 创建一个Map对象，用于存储不同重要程度的笔记数量 + Map importanceCountMap = new HashMap<>(); + // 假设重要程度范围是1到5 + for (int i = 1; i <= 5; i++) { + // 创建实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 添加重要程度查询条件，查询指定重要程度的笔记 + ew.eq("importance", i); + + // 获取会话中的表名 + String tableName = request.getSession().getAttribute("tableName").toString(); + if (tableName.equals("yonghu")) { + // 如果表名是yonghu，则添加用户账号的查询条件 + ew.eq("yonghuzhanghao", (String) request.getSession().getAttribute("username")); + } + + // 调用服务类的统计方法，统计指定重要程度的笔记数量 + int count = wodebijiService.selectCount(ew); + // 将统计结果存入Map对象中 + importanceCountMap.put(i, count); + } + // 返回成功响应，并将统计结果放入响应对象中 + return R.ok().put("importanceCountMap", importanceCountMap); + } + + // 以下是新添加的功能：获取最近创建的笔记 + + /** + * 获取最近创建的笔记（后端） + * @param count 要获取的笔记数量 + * @param request HTTP请求对象，用于获取会话信息 + * @return 包含最近创建的笔记列表的统一响应对象 + */ + @RequestMapping("/getRecentNotes") + public R getRecentNotes(@RequestParam int count, HttpServletRequest request) { + // 创建实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 添加排序条件，按创建时间降序排序 + ew.orderBy("create_time", false); + + // 获取会话中的表名 + String tableName = request.getSession().getAttribute("tableName").toString(); + if (tableName.equals("yonghu")) { + // 如果表名是yonghu，则添加用户账号的查询条件 + ew.eq("yonghuzhanghao", (String) request.getSession().getAttribute("username")); + } + + // 调用服务类的查询方法，查询最近创建的笔记 + List recentNotes = wodebijiService.selectList(ew.last("LIMIT " + count)); + // 返回成功响应，并将最近创建的笔记列表放入响应对象中 + return R.ok().put("recentNotes", recentNotes); + } + + // 以下是新添加的功能：根据笔记标签进行查询 + + /** + * 根据笔记标签进行查询（后端） + * @param params 请求参数，包含分页和排序信息 + * @param tag 笔记标签，用于筛选包含指定标签的笔记 + * @param request HTTP请求对象，用于获取会话信息 + * @return 包含查询结果的统一响应对象 + */ + @RequestMapping("/searchByTag") + public R searchByTag(@RequestParam Map params, @RequestParam String tag, HttpServletRequest request) { + // 创建实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 添加模糊查询条件，查询笔记标签包含指定标签的记录 + ew.like("tags", tag); + + // 获取会话中的表名 + String tableName = request.getSession().getAttribute("tableName").toString(); + if (tableName.equals("yonghu")) { + // 如果表名是yonghu，则添加用户账号的查询条件 + ew.eq("yonghuzhanghao", (String) request.getSession().getAttribute("username")); + } + + // 调用服务类的分页查询方法，传入请求参数和排序后的查询条件 + PageUtils page = wodebijiService.queryPage(params, MPUtil.sort(ew, params)); + // 返回成功响应，并将查询结果的分页信息放入响应对象中 + return R.ok().put("data", page); + } + + // 以下是新添加的功能：批量添加笔记标签 + + /** + * 批量添加笔记标签（后端） + * @param ids 要添加标签的笔记的ID数组 + * @param tag 要添加的标签 + * @return 包含更新结果的统一响应对象 + */ + @RequestMapping("/batchAddTag") + public R batchAddTag(@RequestBody Long[] ids, @RequestParam String tag) { + // 遍历ID数组 + for (Long id : ids) { + // 根据ID查询笔记实体 + WodebijiEntity wodebiji = wodebijiService.selectById(id); + if (wodebiji != null) { + // 如果笔记存在，则获取其原有的标签 + String tags = wodebiji.getTags(); + if (StringUtils.isBlank(tags)) { + // 如果原标签为空，则直接设置为新标签 + wodebiji.setTags(tag); + } else { + // 如果原标签不为空，则将新标签添加到原标签后面，用逗号分隔 + wodebiji.setTags(tags + "," + tag); + } + // 调用服务类的更新方法，更新笔记信息 + wodebijiService.updateById(wodebiji); + } + } + // 返回成功响应 + return R.ok(); + } + + // 以下是新添加的功能：批量删除笔记标签 + + /** + * 批量删除笔记标签（后端） + * @param ids 要删除标签的笔记的ID数组 + * @param tag 要删除的标签 + * @return 包含更新结果的统一响应对象 + */ + @RequestMapping("/batchRemoveTag") + public R batchRemoveTag(@RequestBody Long[] ids, @RequestParam String tag) { + // 遍历ID数组 + for (Long id : ids) { + // 根据ID查询笔记实体 + WodebijiEntity wodebiji = wodebijiService.selectById(id); + if (wodebiji != null) { + // 如果笔记存在，则获取其原有的标签 + String tags = wodebiji.getTags(); + if (StringUtils.isNotBlank(tags)) { + // 如果原标签不为空，则将指定标签从原标签中移除 + String newTags = tags.replace(tag, "").replaceAll(",+", ",").replaceAll("^,|,$", ""); + wodebiji.setTags(newTags); + // 调用服务类的更新方法，更新笔记信息 + wodebijiService.updateById(wodebiji); + } + } + } + // 返回成功响应 + return R.ok(); + } + + // 以下是新添加的功能：根据笔记状态进行查询 + + /** + * 根据笔记状态进行查询（后端） + * @param params 请求参数，包含分页和排序信息 + * @param status 笔记状态，用于筛选指定状态的笔记 + * @param request HTTP请求对象，用于获取会话信息 + * @return 包含查询结果的统一响应对象 + */ + @RequestMapping("/searchByStatus") + public R searchByStatus(@RequestParam Map params, @RequestParam String status, HttpServletRequest request) { + // 创建实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 添加状态查询条件，查询指定状态的笔记 + ew.eq("status", status); + + // 获取会话中的表名 + String tableName = request.getSession().getAttribute("tableName").toString(); + if (tableName.equals("yonghu")) { + // 如果表名是yonghu，则添加用户账号的查询条件 + ew.eq("yonghuzhanghao", (String) request.getSession().getAttribute("username")); + } + + // 调用服务类的分页查询方法，传入请求参数和排序后的查询条件 + PageUtils page = wodebijiService.queryPage(params, MPUtil.sort(ew, params)); + // 返回成功响应，并将查询结果的分页信息放入响应对象中 + return R.ok().put("data", page); + } + + // 以下是新添加的功能：批量更新笔记状态 + + /** + * 批量更新笔记状态（后端） + * @param ids 要更新的笔记的ID数组 + * @param status 新的笔记状态 + * @return 包含更新结果的统一响应对象 + */ + @RequestMapping("/batchUpdateStatus") + public R batchUpdateStatus(@RequestBody Long[] ids, @RequestParam String status) { + // 遍历ID数组 + for (Long id : ids) { + // 根据ID查询笔记实体 + WodebijiEntity wodebiji = wodebijiService.selectById(id); + if (wodebiji != null) { + // 如果笔记存在，则更新其状态 + wodebiji.setStatus(status); + // 调用服务类的更新方法，更新笔记信息 + wodebijiService.updateById(wodebiji); + } + } + // 返回成功响应 + return R.ok(); + } /** * 后端列表 */ @RequestMapping("/page") - public R page(@RequestParam Map params,WodebijiEntity wodebiji, - HttpServletRequest request){ - String tableName = request.getSession().getAttribute("tableName").toString(); - if(tableName.equals("yonghu")) { - wodebiji.setYonghuzhanghao((String)request.getSession().getAttribute("username")); - } + public R page(@RequestParam Map params, WodebijiEntity wodebiji, + HttpServletRequest request) { + // 从会话中获取表名 + String tableName = request.getSession().getAttribute("tableName").toString(); + if (tableName.equals("yonghu")) { + // 如果表名是yonghu，则设置用户账号为会话中的用户名 + wodebiji.setYonghuzhanghao((String) request.getSession().getAttribute("username")); + } + // 创建实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = wodebijiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wodebiji), params), params)); - + // 调用服务类的分页查询方法，传入请求参数和排序后的查询条件 + PageUtils page = wodebijiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wodebiji), params), params)); + // 返回成功响应，并将查询结果的分页信息放入响应对象中 return R.ok().put("data", page); } - + /** * 前端列表 */ @RequestMapping("/list") - public R list(@RequestParam Map params,WodebijiEntity wodebiji, - HttpServletRequest request){ + public R list(@RequestParam Map params, WodebijiEntity wodebiji, + HttpServletRequest request) { + // 创建实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = wodebijiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wodebiji), params), params)); + // 调用服务类的分页查询方法，传入请求参数和排序后的查询条件 + PageUtils page = wodebijiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wodebiji), params), params)); + // 返回成功响应，并将查询结果的分页信息放入响应对象中 return R.ok().put("data", page); } - /** + /** * 列表 */ @RequestMapping("/lists") - public R list( WodebijiEntity wodebiji){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( wodebiji, "wodebiji")); + public R list(WodebijiEntity wodebiji) { + // 创建实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件，使所有字段与传入的实体对象相等 + ew.allEq(MPUtil.allEQMapPre(wodebiji, "wodebiji")); + // 调用服务类的查询视图列表方法，获取查询结果 return R.ok().put("data", wodebijiService.selectListView(ew)); } - /** + /** * 查询 */ @RequestMapping("/query") - public R query(WodebijiEntity wodebiji){ - EntityWrapper< WodebijiEntity> ew = new EntityWrapper< WodebijiEntity>(); - ew.allEq(MPUtil.allEQMapPre( wodebiji, "wodebiji")); - WodebijiView wodebijiView = wodebijiService.selectView(ew); - return R.ok("查询我的笔记成功").put("data", wodebijiView); + public R query(WodebijiEntity wodebiji) { + // 创建实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件，使所有字段与传入的实体对象相等 + ew.allEq(MPUtil.allEQMapPre(wodebiji, "wodebiji")); + // 调用服务类的查询视图方法，获取查询结果 + WodebijiView wodebijiView = wodebijiService.selectView(ew); + // 返回成功响应，并将查询结果放入响应对象中 + return R.ok("查询我的笔记成功").put("data", wodebijiView); } - + /** * 后端详情 */ @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id){ + public R info(@PathVariable("id") Long id) { + // 根据ID查询笔记实体 WodebijiEntity wodebiji = wodebijiService.selectById(id); + // 返回成功响应，并将查询结果放入响应对象中 return R.ok().put("data", wodebiji); } @@ -112,33 +484,40 @@ public class WodebijiController { * 前端详情 */ @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id){ + public R detail(@PathVariable("id") Long id) { + // 根据ID查询笔记实体 WodebijiEntity wodebiji = wodebijiService.selectById(id); + // 返回成功响应，并将查询结果放入响应对象中 return R.ok().put("data", wodebiji); } - - - /** * 后端保存 */ @RequestMapping("/save") - public R save(@RequestBody WodebijiEntity wodebiji, HttpServletRequest request){ - wodebiji.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(wodebiji); + public R save(@RequestBody WodebijiEntity wodebiji, HttpServletRequest request) { + // 生成一个唯一的ID，由当前时间戳和一个随机数组成 + wodebiji.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 注释：此处可进行实体对象的验证，但当前代码未启用 + // ValidatorUtils.validateEntity(wodebiji); + // 调用服务类的插入方法，将笔记实体插入数据库 wodebijiService.insert(wodebiji); + // 返回成功响应 return R.ok(); } - + /** * 前端保存 */ @RequestMapping("/add") - public R add(@RequestBody WodebijiEntity wodebiji, HttpServletRequest request){ - wodebiji.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(wodebiji); + public R add(@RequestBody WodebijiEntity wodebiji, HttpServletRequest request) { + // 生成一个唯一的ID，由当前时间戳和一个随机数组成 + wodebiji.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 注释：此处可进行实体对象的验证，但当前代码未启用 + // ValidatorUtils.validateEntity(wodebiji); + // 调用服务类的插入方法，将笔记实体插入数据库 wodebijiService.insert(wodebiji); + // 返回成功响应 return R.ok(); } @@ -146,69 +525,85 @@ public class WodebijiController { * 修改 */ @RequestMapping("/update") - public R update(@RequestBody WodebijiEntity wodebiji, HttpServletRequest request){ - //ValidatorUtils.validateEntity(wodebiji); - wodebijiService.updateById(wodebiji);//全部更新 + public R update(@RequestBody WodebijiEntity wodebiji, HttpServletRequest request) { + // 注释：此处可进行实体对象的验证，但当前代码未启用 + // ValidatorUtils.validateEntity(wodebiji); + // 调用服务类的更新方法，根据ID更新笔记实体的所有字段 + wodebijiService.updateById(wodebiji); // 全部更新 + // 返回成功响应 return R.ok(); } - /** * 删除 */ @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ + public R delete(@RequestBody Long[] ids) { + // 将ID数组转换为列表，调用服务类的批量删除方法，删除指定ID的笔记记录 wodebijiService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 return R.ok(); } - + /** * 提醒接口 */ - @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("yonghuzhanghao", (String)request.getSession().getAttribute("username")); - } - - int count = wodebijiService.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中 + map.put("column", columnName); + map.put("type", type); + + if (type.equals("2")) { + // 创建SimpleDateFormat对象，用于格式化日期 + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + // 获取Calendar实例，用于处理日期和时间 + 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中 + 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中 + map.put("remindend", sdf.format(remindEndDate)); + } + } + + // 创建MyBatis-Plus的包装器，用于构建查询条件 + 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")) { + // 如果表名是yonghu，则添加用户账号的查询条件 + wrapper.eq("yonghuzhanghao", (String) request.getSession().getAttribute("username")); + } + + // 调用服务类的统计方法，统计符合查询条件的笔记数量 + int count = wodebijiService.selectCount(wrapper); + // 返回成功响应，并将统计结果放入响应对象中 + return R.ok().put("count", count); + } +} \ No newline at end of file diff --git a/src/main/java/com/controller/WodekechengController.java b/src/main/java/com/controller/WodekechengController.java index 8f45dc8..90ae6e1 100644 --- a/src/main/java/com/controller/WodekechengController.java +++ b/src/main/java/com/controller/WodekechengController.java @@ -1,110 +1,440 @@ package com.controller; +// 导入 SimpleDateFormat 类，用于格式化日期和时间 import java.text.SimpleDateFormat; +// 导入 ArrayList 类，用于创建动态数组 import java.util.ArrayList; +// 导入 Arrays 类，提供了操作数组的静态方法 import java.util.Arrays; +// 导入 Calendar 类，用于处理日期和时间 import java.util.Calendar; +// 导入 Map 接口，用于存储键值对 import java.util.Map; +// 导入 HashMap 类，实现了 Map 接口，用于存储键值对 import java.util.HashMap; +// 导入 Iterator 接口，用于遍历集合 import java.util.Iterator; +// 导入 Date 类，用于表示特定的瞬间 import java.util.Date; +// 导入 List 接口，用于存储有序的元素集合 import java.util.List; +// 导入 HttpServletRequest 类，用于封装 HTTP 请求信息 import javax.servlet.http.HttpServletRequest; +// 导入验证工具类，用于验证实体对象的合法性 import com.utils.ValidatorUtils; +// 导入 Apache Commons Lang 库中的 StringUtils 类，提供了字符串操作的实用方法 import org.apache.commons.lang3.StringUtils; +// 导入 Spring 框架的自动注入注解，用于自动装配依赖 import org.springframework.beans.factory.annotation.Autowired; +// 导入 Spring 框架的日期格式化注解，用于将请求参数转换为日期类型 import org.springframework.format.annotation.DateTimeFormat; +// 导入 Spring 框架的路径变量注解，用于获取 URL 中的路径变量 import org.springframework.web.bind.annotation.PathVariable; +// 导入 Spring 框架的请求体注解，用于将请求体中的数据绑定到方法参数上 import org.springframework.web.bind.annotation.RequestBody; +// 导入 Spring 框架的请求映射注解，用于将 HTTP 请求映射到处理方法上 import org.springframework.web.bind.annotation.RequestMapping; +// 导入 Spring 框架的请求参数注解，用于获取请求参数的值 import org.springframework.web.bind.annotation.RequestParam; +// 导入 Spring 框架的 REST 控制器注解，用于将该类标记为 RESTful 风格的控制器 import org.springframework.web.bind.annotation.RestController; +// 导入 MyBatis-Plus 的实体包装器类，用于构建查询条件 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入 MyBatis-Plus 的包装器接口，是 EntityWrapper 的父接口 import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的忽略认证注解，用于标记不需要进行认证的接口 import com.annotation.IgnoreAuth; +// 导入我的课程实体类，对应数据库中的我的课程表 import com.entity.WodekechengEntity; +// 导入我的课程视图类，用于展示我的课程信息 import com.entity.view.WodekechengView; +// 导入我的课程服务类，用于处理我的课程相关的业务逻辑 import com.service.WodekechengService; +// 导入令牌服务类，用于处理令牌相关的业务逻辑 import com.service.TokenService; +// 导入分页工具类，用于处理分页查询结果 import com.utils.PageUtils; +// 导入自定义的响应类，用于封装统一的响应格式 import com.utils.R; +// 导入 MD5 工具类，用于对数据进行 MD5 加密 import com.utils.MD5Util; +// 导入 MyBatis-Plus 工具类，提供了一些常用的工具方法 import com.utils.MPUtil; +// 导入通用工具类，提供了一些通用的工具方法 import com.utils.CommonUtil; /** * 我的课程 * 后端接口 - * @author - * @email + * @author + * @email * @date 2021-05-09 15:46:15 */ +// 将该类标记为 RESTful 风格的控制器，处理 HTTP 请求并返回 JSON 数据 @RestController +// 定义请求映射路径，所有以 /wodekecheng 开头的请求都会被该控制器处理 @RequestMapping("/wodekecheng") public class WodekechengController { + // 使用 @Autowired 注解自动注入我的课程服务类的实例 @Autowired private WodekechengService wodekechengService; - + + // 以下是新添加的功能：根据课程名称进行模糊查询 + /** + * 根据课程名称进行模糊查询（后端） + * @param params 请求参数，包含分页和排序信息 + * @param courseName 课程名称关键词，用于模糊查询 + * @param request HTTP 请求对象，用于获取会话信息 + * @return 包含查询结果的统一响应对象 + */ + @RequestMapping("/searchByCourseName") + public R searchByCourseName(@RequestParam Map params, @RequestParam String courseName, HttpServletRequest request) { + // 创建实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 添加模糊查询条件，查询课程名称包含指定关键词的记录 + ew.like("course_name", courseName); + + // 获取会话中的表名 + String tableName = request.getSession().getAttribute("tableName").toString(); + if (tableName.equals("yonghu")) { + // 如果表名是 yonghu，则添加用户账号的查询条件 + ew.eq("yonghuzhanghao", (String) request.getSession().getAttribute("username")); + } + + // 调用服务类的分页查询方法，传入请求参数和排序后的查询条件 + PageUtils page = wodekechengService.queryPage(params, MPUtil.sort(ew, params)); + // 返回成功响应，并将查询结果的分页信息放入响应对象中 + return R.ok().put("data", page); + } + + // 以下是新添加的功能：根据课程分类进行查询 + /** + * 根据课程分类进行查询（后端） + * @param params 请求参数，包含分页和排序信息 + * @param courseCategory 课程分类，用于筛选指定分类的课程 + * @param request HTTP 请求对象，用于获取会话信息 + * @return 包含查询结果的统一响应对象 + */ + @RequestMapping("/searchByCourseCategory") + public R searchByCourseCategory(@RequestParam Map params, @RequestParam String courseCategory, HttpServletRequest request) { + // 创建实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 添加课程分类查询条件，查询指定分类的课程 + ew.eq("course_category", courseCategory); + + // 获取会话中的表名 + String tableName = request.getSession().getAttribute("tableName").toString(); + if (tableName.equals("yonghu")) { + // 如果表名是 yonghu，则添加用户账号的查询条件 + ew.eq("yonghuzhanghao", (String) request.getSession().getAttribute("username")); + } + + // 调用服务类的分页查询方法，传入请求参数和排序后的查询条件 + PageUtils page = wodekechengService.queryPage(params, MPUtil.sort(ew, params)); + // 返回成功响应，并将查询结果的分页信息放入响应对象中 + return R.ok().put("data", page); + } + + // 以下是新添加的功能：根据课程难度进行查询 + /** + * 根据课程难度进行查询（后端） + * @param params 请求参数，包含分页和排序信息 + * @param courseDifficulty 课程难度，用于筛选指定难度的课程 + * @param request HTTP 请求对象，用于获取会话信息 + * @return 包含查询结果的统一响应对象 + */ + @RequestMapping("/searchByCourseDifficulty") + public R searchByCourseDifficulty(@RequestParam Map params, @RequestParam String courseDifficulty, HttpServletRequest request) { + // 创建实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 添加课程难度查询条件，查询指定难度的课程 + ew.eq("course_difficulty", courseDifficulty); + + // 获取会话中的表名 + String tableName = request.getSession().getAttribute("tableName").toString(); + if (tableName.equals("yonghu")) { + // 如果表名是 yonghu，则添加用户账号的查询条件 + ew.eq("yonghuzhanghao", (String) request.getSession().getAttribute("username")); + } + + // 调用服务类的分页查询方法，传入请求参数和排序后的查询条件 + PageUtils page = wodekechengService.queryPage(params, MPUtil.sort(ew, params)); + // 返回成功响应，并将查询结果的分页信息放入响应对象中 + return R.ok().put("data", page); + } + + // 以下是新添加的功能：批量更新课程状态 + /** + * 批量更新课程状态（后端） + * @param ids 要更新的课程的 ID 数组 + * @param courseStatus 新的课程状态 + * @return 包含更新结果的统一响应对象 + */ + @RequestMapping("/batchUpdateCourseStatus") + public R batchUpdateCourseStatus(@RequestBody Long[] ids, @RequestParam String courseStatus) { + // 遍历 ID 数组 + for (Long id : ids) { + // 根据 ID 查询课程实体 + WodekechengEntity wodekecheng = wodekechengService.selectById(id); + if (wodekecheng != null) { + // 如果课程存在，则更新其状态 + wodekecheng.setCourseStatus(courseStatus); + // 调用服务类的更新方法，更新课程信息 + wodekechengService.updateById(wodekecheng); + } + } + // 返回成功响应 + return R.ok(); + } + + // 以下是新添加的功能：统计不同课程分类的课程数量 + /** + * 统计不同课程分类的课程数量（后端） + * @param request HTTP 请求对象，用于获取会话信息 + * @return 包含统计结果的统一响应对象 + */ + @RequestMapping("/countByCourseCategory") + public R countByCourseCategory(HttpServletRequest request) { + // 创建一个 Map 对象，用于存储不同课程分类的课程数量 + Map courseCategoryCountMap = new HashMap<>(); + // 假设课程分类有以下几种，可根据实际情况修改 + List courseCategories = Arrays.asList("编程", "设计", "数学", "物理", "化学"); + for (String category : courseCategories) { + // 创建实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 添加课程分类查询条件，查询指定分类的课程 + ew.eq("course_category", category); + + // 获取会话中的表名 + String tableName = request.getSession().getAttribute("tableName").toString(); + if (tableName.equals("yonghu")) { + // 如果表名是 yonghu，则添加用户账号的查询条件 + ew.eq("yonghuzhanghao", (String) request.getSession().getAttribute("username")); + } + + // 调用服务类的统计方法，统计指定分类的课程数量 + int count = wodekechengService.selectCount(ew); + // 将统计结果存入 Map 对象中 + courseCategoryCountMap.put(category, count); + } + // 返回成功响应，并将统计结果放入响应对象中 + return R.ok().put("courseCategoryCountMap", courseCategoryCountMap); + } + + // 以下是新添加的功能：获取最近添加的课程 + /** + * 获取最近添加的课程（后端） + * @param count 要获取的课程数量 + * @param request HTTP 请求对象，用于获取会话信息 + * @return 包含最近添加的课程列表的统一响应对象 + */ + @RequestMapping("/getRecentCourses") + public R getRecentCourses(@RequestParam int count, HttpServletRequest request) { + // 创建实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 添加排序条件，按创建时间降序排序 + ew.orderBy("create_time", false); + + // 获取会话中的表名 + String tableName = request.getSession().getAttribute("tableName").toString(); + if (tableName.equals("yonghu")) { + // 如果表名是 yonghu，则添加用户账号的查询条件 + ew.eq("yonghuzhanghao", (String) request.getSession().getAttribute("username")); + } + + // 调用服务类的查询方法，查询最近添加的课程 + List recentCourses = wodekechengService.selectList(ew.last("LIMIT " + count)); + // 返回成功响应，并将最近添加的课程列表放入响应对象中 + return R.ok().put("recentCourses", recentCourses); + } + + // 以下是新添加的功能：根据课程开始时间范围进行查询 + /** + * 根据课程开始时间范围进行查询（后端） + * @param params 请求参数，包含分页和排序信息 + * @param startDate 开始日期，用于筛选开始时间在该日期之后的课程 + * @param endDate 结束日期，用于筛选开始时间在该日期之前的课程 + * @param request HTTP 请求对象，用于获取会话信息 + * @return 包含查询结果的统一响应对象 + */ + @RequestMapping("/searchByCourseStartTime") + public R searchByCourseStartTime(@RequestParam Map params, + @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") Date startDate, + @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") Date endDate, + HttpServletRequest request) { + // 创建实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 添加时间范围查询条件，查询开始时间在指定范围内的课程 + ew.between("course_start_time", startDate, endDate); + + // 获取会话中的表名 + String tableName = request.getSession().getAttribute("tableName").toString(); + if (tableName.equals("yonghu")) { + // 如果表名是 yonghu，则添加用户账号的查询条件 + ew.eq("yonghuzhanghao", (String) request.getSession().getAttribute("username")); + } + + // 调用服务类的分页查询方法，传入请求参数和排序后的查询条件 + PageUtils page = wodekechengService.queryPage(params, MPUtil.sort(ew, params)); + // 返回成功响应，并将查询结果的分页信息放入响应对象中 + return R.ok().put("data", page); + } + + // 以下是新添加的功能：批量更新课程开始时间 + /** + * 批量更新课程开始时间（后端） + * @param ids 要更新的课程的 ID 数组 + * @param newStartTime 新的课程开始时间 + * @return 包含更新结果的统一响应对象 + */ + @RequestMapping("/batchUpdateCourseStartTime") + public R batchUpdateCourseStartTime(@RequestBody Long[] ids, @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") Date newStartTime) { + // 遍历 ID 数组 + for (Long id : ids) { + // 根据 ID 查询课程实体 + WodekechengEntity wodekecheng = wodekechengService.selectById(id); + if (wodekecheng != null) { + // 如果课程存在，则更新其开始时间 + wodekecheng.setCourseStartTime(newStartTime); + // 调用服务类的更新方法，更新课程信息 + wodekechengService.updateById(wodekecheng); + } + } + // 返回成功响应 + return R.ok(); + } + + // 以下是新添加的功能：根据课程结束时间范围进行查询 + /** + * 根据课程结束时间范围进行查询（后端） + * @param params 请求参数，包含分页和排序信息 + * @param startDate 开始日期，用于筛选结束时间在该日期之后的课程 + * @param endDate 结束日期，用于筛选结束时间在该日期之前的课程 + * @param request HTTP 请求对象，用于获取会话信息 + * @return 包含查询结果的统一响应对象 + */ + @RequestMapping("/searchByCourseEndTime") + public R searchByCourseEndTime(@RequestParam Map params, + @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") Date startDate, + @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") Date endDate, + HttpServletRequest request) { + // 创建实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 添加时间范围查询条件，查询结束时间在指定范围内的课程 + ew.between("course_end_time", startDate, endDate); + + // 获取会话中的表名 + String tableName = request.getSession().getAttribute("tableName").toString(); + if (tableName.equals("yonghu")) { + // 如果表名是 yonghu，则添加用户账号的查询条件 + ew.eq("yonghuzhanghao", (String) request.getSession().getAttribute("username")); + } + + // 调用服务类的分页查询方法，传入请求参数和排序后的查询条件 + PageUtils page = wodekechengService.queryPage(params, MPUtil.sort(ew, params)); + // 返回成功响应，并将查询结果的分页信息放入响应对象中 + return R.ok().put("data", page); + } + + // 以下是新添加的功能：批量更新课程结束时间 + /** + * 批量更新课程结束时间（后端） + * @param ids 要更新的课程的 ID 数组 + * @param newEndTime 新的课程结束时间 + * @return 包含更新结果的统一响应对象 + */ + @RequestMapping("/batchUpdateCourseEndTime") + public R batchUpdateCourseEndTime(@RequestBody Long[] ids, @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") Date newEndTime) { + // 遍历 ID 数组 + for (Long id : ids) { + // 根据 ID 查询课程实体 + WodekechengEntity wodekecheng = wodekechengService.selectById(id); + if (wodekecheng != null) { + // 如果课程存在，则更新其结束时间 + wodekecheng.setCourseEndTime(newEndTime); + // 调用服务类的更新方法，更新课程信息 + wodekechengService.updateById(wodekecheng); + } + } + // 返回成功响应 + return R.ok(); + } /** * 后端列表 */ @RequestMapping("/page") - public R page(@RequestParam Map params,WodekechengEntity wodekecheng, - HttpServletRequest request){ - String tableName = request.getSession().getAttribute("tableName").toString(); - if(tableName.equals("yonghu")) { - wodekecheng.setYonghuzhanghao((String)request.getSession().getAttribute("username")); - } + public R page(@RequestParam Map params, WodekechengEntity wodekecheng, + HttpServletRequest request) { + // 从会话中获取表名 + String tableName = request.getSession().getAttribute("tableName").toString(); + if (tableName.equals("yonghu")) { + // 如果表名是 yonghu，则设置用户账号为会话中的用户名 + wodekecheng.setYonghuzhanghao((String) request.getSession().getAttribute("username")); + } + // 创建实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = wodekechengService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wodekecheng), params), params)); - + // 调用服务类的分页查询方法，传入请求参数和排序后的查询条件 + PageUtils page = wodekechengService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wodekecheng), params), params)); + // 返回成功响应，并将查询结果的分页信息放入响应对象中 return R.ok().put("data", page); } - + /** * 前端列表 */ @RequestMapping("/list") - public R list(@RequestParam Map params,WodekechengEntity wodekecheng, - HttpServletRequest request){ + public R list(@RequestParam Map params, WodekechengEntity wodekecheng, + HttpServletRequest request) { + // 创建实体包装器，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = wodekechengService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wodekecheng), params), params)); + // 调用服务类的分页查询方法，传入请求参数和排序后的查询条件 + PageUtils page = wodekechengService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wodekecheng), params), params)); + // 返回成功响应，并将查询结果的分页信息放入响应对象中 return R.ok().put("data", page); } - /** + /** * 列表 */ @RequestMapping("/lists") - public R list( WodekechengEntity wodekecheng){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( wodekecheng, "wodekecheng")); + public R list(WodekechengEntity wodekecheng) { + // 创建实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件，使所有字段与传入的实体对象相等 + ew.allEq(MPUtil.allEQMapPre(wodekecheng, "wodekecheng")); + // 调用服务类的查询视图列表方法，获取查询结果 return R.ok().put("data", wodekechengService.selectListView(ew)); } - /** + /** * 查询 */ @RequestMapping("/query") - public R query(WodekechengEntity wodekecheng){ - EntityWrapper< WodekechengEntity> ew = new EntityWrapper< WodekechengEntity>(); - ew.allEq(MPUtil.allEQMapPre( wodekecheng, "wodekecheng")); - WodekechengView wodekechengView = wodekechengService.selectView(ew); - return R.ok("查询我的课程成功").put("data", wodekechengView); + public R query(WodekechengEntity wodekecheng) { + // 创建实体包装器，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 设置查询条件，使所有字段与传入的实体对象相等 + ew.allEq(MPUtil.allEQMapPre(wodekecheng, "wodekecheng")); + // 调用服务类的查询视图方法，获取查询结果 + WodekechengView wodekechengView = wodekechengService.selectView(ew); + // 返回成功响应，并将查询结果放入响应对象中 + return R.ok("查询我的课程成功").put("data", wodekechengView); } - + /** * 后端详情 */ @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id){ + public R info(@PathVariable("id") Long id) { + // 根据 ID 查询课程实体 WodekechengEntity wodekecheng = wodekechengService.selectById(id); + // 返回成功响应，并将查询结果放入响应对象中 return R.ok().put("data", wodekecheng); } @@ -112,33 +442,40 @@ public class WodekechengController { * 前端详情 */ @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id){ + public R detail(@PathVariable("id") Long id) { + // 根据 ID 查询课程实体 WodekechengEntity wodekecheng = wodekechengService.selectById(id); + // 返回成功响应，并将查询结果放入响应对象中 return R.ok().put("data", wodekecheng); } - - - /** * 后端保存 */ @RequestMapping("/save") - public R save(@RequestBody WodekechengEntity wodekecheng, HttpServletRequest request){ - wodekecheng.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(wodekecheng); + public R save(@RequestBody WodekechengEntity wodekecheng, HttpServletRequest request) { + // 生成一个唯一的 ID，由当前时间戳和一个随机数组成 + wodekecheng.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 注释：此处可进行实体对象的验证，但当前代码未启用 + // ValidatorUtils.validateEntity(wodekecheng); + // 调用服务类的插入方法，将课程实体插入数据库 wodekechengService.insert(wodekecheng); + // 返回成功响应 return R.ok(); } - + /** * 前端保存 */ @RequestMapping("/add") - public R add(@RequestBody WodekechengEntity wodekecheng, HttpServletRequest request){ - wodekecheng.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(wodekecheng); + public R add(@RequestBody WodekechengEntity wodekecheng, HttpServletRequest request) { + // 生成一个唯一的 ID，由当前时间戳和一个随机数组成 + wodekecheng.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 注释：此处可进行实体对象的验证，但当前代码未启用 + // ValidatorUtils.validateEntity(wodekecheng); + // 调用服务类的插入方法，将课程实体插入数据库 wodekechengService.insert(wodekecheng); + // 返回成功响应 return R.ok(); } @@ -146,69 +483,85 @@ public class WodekechengController { * 修改 */ @RequestMapping("/update") - public R update(@RequestBody WodekechengEntity wodekecheng, HttpServletRequest request){ - //ValidatorUtils.validateEntity(wodekecheng); - wodekechengService.updateById(wodekecheng);//全部更新 + public R update(@RequestBody WodekechengEntity wodekecheng, HttpServletRequest request) { + // 注释：此处可进行实体对象的验证，但当前代码未启用 + // ValidatorUtils.validateEntity(wodekecheng); + // 调用服务类的更新方法，根据 ID 更新课程实体的所有字段 + wodekechengService.updateById(wodekecheng); // 全部更新 + // 返回成功响应 return R.ok(); } - /** * 删除 */ @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ + public R delete(@RequestBody Long[] ids) { + // 将 ID 数组转换为列表，调用服务类的批量删除方法，删除指定 ID 的课程记录 wodekechengService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 return R.ok(); } - + /** * 提醒接口 */ - @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("yonghuzhanghao", (String)request.getSession().getAttribute("username")); - } - - int count = wodekechengService.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 中 + map.put("column", columnName); + map.put("type", type); + + if (type.equals("2")) { + // 创建 SimpleDateFormat 对象，用于格式化日期 + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + // 获取 Calendar 实例，用于处理日期和时间 + 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 中 + 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 中 + map.put("remindend", sdf.format(remindEndDate)); + } + } + + // 创建 MyBatis-Plus 的包装器，用于构建查询条件 + 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")) { + // 如果表名是 yonghu，则添加用户账号的查询条件 + wrapper.eq("yonghuzhanghao", (String) request.getSession().getAttribute("username")); + } + + // 调用服务类的统计方法，统计符合查询条件的课程数量 + int count = wodekechengService.selectCount(wrapper); + // 返回成功响应，并将统计结果放入响应对象中 + return R.ok().put("count", count); + } +} \ No newline at end of file diff --git a/src/main/java/com/controller/XiaoxitongzhiController.java b/src/main/java/com/controller/XiaoxitongzhiController.java index 2200600..eaa51c1 100644 --- a/src/main/java/com/controller/XiaoxitongzhiController.java +++ b/src/main/java/com/controller/XiaoxitongzhiController.java @@ -1,214 +1,314 @@ package com.controller; +// 导入SimpleDateFormat类，用于格式化日期和时间（如将Date对象转为指定格式的字符串） import java.text.SimpleDateFormat; +// 导入ArrayList类，用于创建动态数组（可自动扩容的有序集合） import java.util.ArrayList; +// 导入Arrays类，提供操作数组的静态方法（如排序、查找、复制等） import java.util.Arrays; +// 导入Calendar类，用于处理日期和时间（如日期计算、设置日期字段等） import java.util.Calendar; +// 导入Map接口，用于存储键值对（如请求参数、响应数据等） import java.util.Map; +// 导入HashMap类，实现Map接口的哈希表（键值对存储，允许null键值） import java.util.HashMap; +// 导入Iterator接口，用于遍历集合元素（如遍历List、Set等） import java.util.Iterator; +// 导入Date类，用于表示特定的瞬间（精确到毫秒） import java.util.Date; +// 导入List接口，用于存储有序的元素集合（可重复，有索引） import java.util.List; +// 导入HttpServletRequest类，封装HTTP请求信息（如参数、头信息、会话等） import javax.servlet.http.HttpServletRequest; +// 导入自定义验证工具类（用于验证实体对象的合法性） import com.utils.ValidatorUtils; +// 导入Apache Commons Lang的StringUtils类（提供丰富的字符串操作方法） import org.apache.commons.lang3.StringUtils; +// 导入Spring的自动注入注解（用于自动装配Bean，如服务类） import org.springframework.beans.factory.annotation.Autowired; +// 导入Spring的日期格式化注解（用于将请求参数转换为Date对象） import org.springframework.format.annotation.DateTimeFormat; +// 导入Spring的路径变量注解（用于获取URL路径中的参数，如/{id}） import org.springframework.web.bind.annotation.PathVariable; +// 导入Spring的请求体注解（用于接收请求体中的JSON数据并绑定到实体） import org.springframework.web.bind.annotation.RequestBody; +// 导入Spring的请求映射注解（用于映射URL路径到处理方法） import org.springframework.web.bind.annotation.RequestMapping; +// 导入Spring的请求参数注解（用于获取请求参数的值） import org.springframework.web.bind.annotation.RequestParam; +// 导入Spring的REST控制器注解（标记类为RESTful控制器，返回JSON响应） import org.springframework.web.bind.annotation.RestController; +// 导入MyBatis-Plus的实体包装器类（用于构建数据库查询条件） import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入MyBatis-Plus的包装器接口（实体包装器的父接口，通用查询条件构建） import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的忽略认证注解（标记无需登录认证的接口） import com.annotation.IgnoreAuth; +// 导入消息通知实体类（对应数据库表的实体对象） import com.entity.XiaoxitongzhiEntity; +// 导入消息通知视图类（用于展示包含关联数据的视图对象） import com.entity.view.XiaoxitongzhiView; +// 导入消息通知服务类（处理业务逻辑，如增删改查） import com.service.XiaoxitongzhiService; +// 导入令牌服务类（处理用户令牌生成与验证，此处未使用，保留导入） import com.service.TokenService; +// 导入分页工具类（封装分页查询结果，包含总页数、数据列表等） import com.utils.PageUtils; +// 导入自定义响应类（封装统一的响应格式，如R.ok()、R.error()） import com.utils.R; +// 导入MD5工具类（用于数据加密，如密码加密，此处未使用） import com.utils.MD5Util; +// 导入MyBatis-Plus工具类（提供通用数据库操作工具方法） import com.utils.MPUtil; +// 导入通用工具类（包含常用辅助方法，如生成随机数、数据转换等） import com.utils.CommonUtil; /** * 消息通知 * 后端接口 - * @author - * @email + * @author + * @email * @date 2021-05-09 15:46:15 */ +// 标记为RESTful控制器，处理所有以/xiaoxitongzhi开头的请求 @RestController @RequestMapping("/xiaoxitongzhi") public class XiaoxitongzhiController { + // 自动注入消息通知服务类实例，用于调用数据库操作方法 @Autowired private XiaoxitongzhiService xiaoxitongzhiService; - /** - * 后端列表 + * 后端列表（分页查询） + * @param params 分页参数（当前页、每页大小、排序等） + * @param xiaoxitongzhi 实体对象（用于构建查询条件） + * @param request HTTP请求对象（获取会话信息） + * @return 包含分页数据的响应对象 */ @RequestMapping("/page") - public R page(@RequestParam Map params,XiaoxitongzhiEntity xiaoxitongzhi, - HttpServletRequest request){ - String tableName = request.getSession().getAttribute("tableName").toString(); - if(tableName.equals("yonghu")) { - xiaoxitongzhi.setYonghuzhanghao((String)request.getSession().getAttribute("username")); - } + public R page(@RequestParam Map params, XiaoxitongzhiEntity xiaoxitongzhi, + HttpServletRequest request) { + // 从会话中获取当前用户的表名（用于权限控制，如区分普通用户和管理员） + String tableName = request.getSession().getAttribute("tableName").toString(); + // 如果是普通用户（表名为yonghu），则添加用户账号查询条件（仅查询当前用户的消息） + if (tableName.equals("yonghu")) { + xiaoxitongzhi.setYonghuzhanghao((String) request.getSession().getAttribute("username")); + } + // 创建实体包装器，用于构建数据库查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = xiaoxitongzhiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, xiaoxitongzhi), params), params)); - + // 调用服务类的分页查询方法，包含模糊查询、范围查询和排序处理 + PageUtils page = xiaoxitongzhiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, xiaoxitongzhi), params), params)); + // 返回成功响应，携带分页数据 return R.ok().put("data", page); } - + /** - * 前端列表 + * 前端列表（分页查询） + * @param params 分页参数 + * @param xiaoxitongzhi 实体对象 + * @param request HTTP请求对象 + * @return 包含分页数据的响应对象（前端使用） */ @RequestMapping("/list") - public R list(@RequestParam Map params,XiaoxitongzhiEntity xiaoxitongzhi, - HttpServletRequest request){ + public R list(@RequestParam Map params, XiaoxitongzhiEntity xiaoxitongzhi, + HttpServletRequest request) { + // 创建实体包装器（前端列表可能不需要权限过滤，直接构建查询条件） EntityWrapper ew = new EntityWrapper(); - PageUtils page = xiaoxitongzhiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, xiaoxitongzhi), params), params)); + // 调用服务类的分页查询方法（逻辑与后端列表类似，可能权限控制不同） + PageUtils page = xiaoxitongzhiService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, xiaoxitongzhi), params), params)); + // 返回成功响应，携带分页数据 return R.ok().put("data", page); } - /** - * 列表 + /** + * 列表（全量查询，不分页） + * @param xiaoxitongzhi 实体对象（用于构建精确查询条件） + * @return 包含查询结果的响应对象 */ @RequestMapping("/lists") - public R list( XiaoxitongzhiEntity xiaoxitongzhi){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( xiaoxitongzhi, "xiaoxitongzhi")); + public R list(XiaoxitongzhiEntity xiaoxitongzhi) { + // 创建实体包装器，设置所有字段相等的查询条件（前缀为"xiaoxitongzhi_"） + EntityWrapper ew = new EntityWrapper(); + ew.allEq(MPUtil.allEQMapPre(xiaoxitongzhi, "xiaoxitongzhi")); + // 调用服务类的查询视图列表方法（可能返回包含关联数据的视图） return R.ok().put("data", xiaoxitongzhiService.selectListView(ew)); } - /** - * 查询 + /** + * 查询（单个对象精确查询） + * @param xiaoxitongzhi 实体对象（包含查询条件字段） + * @return 包含查询结果视图的响应对象 */ @RequestMapping("/query") - public R query(XiaoxitongzhiEntity xiaoxitongzhi){ - EntityWrapper< XiaoxitongzhiEntity> ew = new EntityWrapper< XiaoxitongzhiEntity>(); - ew.allEq(MPUtil.allEQMapPre( xiaoxitongzhi, "xiaoxitongzhi")); - XiaoxitongzhiView xiaoxitongzhiView = xiaoxitongzhiService.selectView(ew); - return R.ok("查询消息通知成功").put("data", xiaoxitongzhiView); + public R query(XiaoxitongzhiEntity xiaoxitongzhi) { + // 创建实体包装器，设置全字段相等的查询条件 + EntityWrapper ew = new EntityWrapper(); + ew.allEq(MPUtil.allEQMapPre(xiaoxitongzhi, "xiaoxitongzhi")); + // 调用服务类的查询视图方法（返回包含关联数据的视图对象） + XiaoxitongzhiView xiaoxitongzhiView = xiaoxitongzhiService.selectView(ew); + // 返回成功响应，携带查询结果和提示信息 + return R.ok("查询消息通知成功").put("data", xiaoxitongzhiView); } - + /** - * 后端详情 + * 后端详情（根据ID查询） + * @param id 消息通知ID（路径参数） + * @return 包含单个实体的响应对象（后端使用） */ @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id){ + public R info(@PathVariable("id") Long id) { + // 根据ID直接查询实体对象（主键查询，性能较高） XiaoxitongzhiEntity xiaoxitongzhi = xiaoxitongzhiService.selectById(id); + // 返回成功响应，携带实体数据 return R.ok().put("data", xiaoxitongzhi); } /** - * 前端详情 + * 前端详情（根据ID查询） + * @param id 消息通知ID（路径参数） + * @return 包含单个实体的响应对象（前端使用） */ @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id){ + public R detail(@PathVariable("id") Long id) { + // 根据ID查询实体对象（与后端详情逻辑相同） XiaoxitongzhiEntity xiaoxitongzhi = xiaoxitongzhiService.selectById(id); + // 返回成功响应，携带实体数据 return R.ok().put("data", xiaoxitongzhi); } - + /** - * 后端保存 + * 后端保存（新增消息通知） + * @param xiaoxitongzhi 消息通知实体（请求体数据） + * @param request HTTP请求对象（可能用于获取用户信息） + * @return 保存结果的响应对象 */ @RequestMapping("/save") - public R save(@RequestBody XiaoxitongzhiEntity xiaoxitongzhi, HttpServletRequest request){ - xiaoxitongzhi.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(xiaoxitongzhi); + public R save(@RequestBody XiaoxitongzhiEntity xiaoxitongzhi, HttpServletRequest request) { + // 生成唯一ID（时间戳+随机数，确保主键唯一） + xiaoxitongzhi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 注释：实体验证（此处未启用，可取消注释进行参数校验） + //ValidatorUtils.validateEntity(xiaoxitongzhi); + // 调用服务类的插入方法，将实体保存到数据库 xiaoxitongzhiService.insert(xiaoxitongzhi); + // 返回成功响应 return R.ok(); } - + /** - * 前端保存 + * 前端保存（新增消息通知） + * @param xiaoxitongzhi 消息通知实体（请求体数据） + * @param request HTTP请求对象（可能用于获取当前用户ID） + * @return 保存结果的响应对象（前端调用） */ @RequestMapping("/add") - public R add(@RequestBody XiaoxitongzhiEntity xiaoxitongzhi, HttpServletRequest request){ - xiaoxitongzhi.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(xiaoxitongzhi); + public R add(@RequestBody XiaoxitongzhiEntity xiaoxitongzhi, HttpServletRequest request) { + // 生成唯一ID（与后端保存逻辑相同） + xiaoxitongzhi.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 注释：实体验证（未启用） + //ValidatorUtils.validateEntity(xiaoxitongzhi); + // 调用服务类的插入方法（前端保存可能自动关联当前用户，此处代码未体现） xiaoxitongzhiService.insert(xiaoxitongzhi); + // 返回成功响应 return R.ok(); } /** - * 修改 + * 修改（更新消息通知） + * @param xiaoxitongzhi 消息通知实体（包含更新后的字段） + * @return 修改结果的响应对象 */ @RequestMapping("/update") - public R update(@RequestBody XiaoxitongzhiEntity xiaoxitongzhi, HttpServletRequest request){ + public R update(@RequestBody XiaoxitongzhiEntity xiaoxitongzhi, HttpServletRequest request) { + // 注释：实体验证（未启用） //ValidatorUtils.validateEntity(xiaoxitongzhi); - xiaoxitongzhiService.updateById(xiaoxitongzhi);//全部更新 + // 调用服务类的更新方法，根据ID更新所有字段（全量更新） + xiaoxitongzhiService.updateById(xiaoxitongzhi); // 注释：标记为全部更新，非部分更新 + // 返回成功响应 return R.ok(); } - + /** - * 删除 + * 删除（批量删除消息通知） + * @param ids 待删除的ID数组（请求体数据） + * @return 删除结果的响应对象 */ @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ + public R delete(@RequestBody Long[] ids) { + // 将ID数组转换为列表，调用批量删除方法（高效删除多条记录） xiaoxitongzhiService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 return R.ok(); } - + /** - * 提醒接口 + * 提醒接口（统计符合条件的记录数，用于提醒功能） + * @param columnName 提醒关联的字段名（路径参数） + * @param type 提醒类型（路径参数，如按日期提醒） + * @param map 请求参数（包含提醒时间偏移量等） + * @return 统计结果的响应对象 */ - @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("yonghuzhanghao", (String)request.getSession().getAttribute("username")); - } - - int count = xiaoxitongzhiService.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中添加列名和类型，用于后续处理 + map.put("column", columnName); + map.put("type", type); + + // 如果是日期范围提醒（type=2，基于当前日期计算提醒时间） + if (type.equals("2")) { + // 创建日期格式化对象（格式：yyyy-MM-dd） + 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("yonghuzhanghao", (String) request.getSession().getAttribute("username")); + } + + // 统计符合条件的记录数 + int count = xiaoxitongzhiService.selectCount(wrapper); + // 返回统计结果 + return R.ok().put("count", count); + } +} \ No newline at end of file diff --git a/src/main/java/com/controller/XuekeController.java b/src/main/java/com/controller/XuekeController.java index 05edc5d..90eab18 100644 --- a/src/main/java/com/controller/XuekeController.java +++ b/src/main/java/com/controller/XuekeController.java @@ -1,206 +1,307 @@ package com.controller; +// 导入SimpleDateFormat类，用于格式化日期和时间（如将日期转换为指定格式的字符串） import java.text.SimpleDateFormat; +// 导入ArrayList类，用于创建动态数组（可动态增加或删除元素的有序集合） import java.util.ArrayList; +// 导入Arrays类，提供操作数组的工具方法（如排序、查找、复制数组等） import java.util.Arrays; +// 导入Calendar类，用于处理日期和时间（如日期计算、获取日期字段等） import java.util.Calendar; +// 导入Map接口，用于存储键值对数据（如请求参数、响应数据等） import java.util.Map; +// 导入HashMap类，实现Map接口的哈希表（支持快速查找和插入） import java.util.HashMap; +// 导入Iterator接口，用于遍历集合中的元素（如遍历List、Set等） import java.util.Iterator; +// 导入Date类，用于表示特定的日期和时间（精确到毫秒） import java.util.Date; +// 导入List接口，用于存储有序的元素集合（允许重复元素） import java.util.List; +// 导入HttpServletRequest类，封装HTTP请求信息（如请求参数、会话、头信息等） import javax.servlet.http.HttpServletRequest; +// 导入自定义验证工具类（用于验证实体对象的字段合法性） import com.utils.ValidatorUtils; +// 导入Apache Commons Lang的StringUtils类（提供字符串操作的实用方法） import org.apache.commons.lang3.StringUtils; +// 导入Spring框架的自动注入注解（用于自动装配Bean，如服务类） import org.springframework.beans.factory.annotation.Autowired; +// 导入Spring框架的日期格式化注解（用于将请求参数转换为Date对象） import org.springframework.format.annotation.DateTimeFormat; +// 导入Spring框架的路径变量注解（用于获取URL路径中的参数，如/info/{id}中的id） import org.springframework.web.bind.annotation.PathVariable; +// 导入Spring框架的请求体注解（用于接收请求体中的JSON数据并绑定到实体类） import org.springframework.web.bind.annotation.RequestBody; +// 导入Spring框架的请求映射注解（用于将HTTP请求映射到控制器方法） import org.springframework.web.bind.annotation.RequestMapping; +// 导入Spring框架的请求参数注解（用于获取请求参数的值） import org.springframework.web.bind.annotation.RequestParam; +// 导入Spring框架的REST控制器注解（标记类为RESTful控制器，返回JSON响应） import org.springframework.web.bind.annotation.RestController; +// 导入MyBatis-Plus的实体包装器类（用于构建数据库查询条件） import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入MyBatis-Plus的包装器接口（实体包装器的父接口，通用查询条件构建） import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的忽略认证注解（标记无需登录认证的接口） import com.annotation.IgnoreAuth; +// 导入学科实体类（对应数据库中的学科表） import com.entity.XuekeEntity; +// 导入学科视图类（用于展示包含关联数据的学科信息） import com.entity.view.XuekeView; +// 导入学科服务类（处理学科相关的业务逻辑，如增删改查） import com.service.XuekeService; +// 导入令牌服务类（处理用户认证令牌，此处未使用，保留导入） import com.service.TokenService; +// 导入分页工具类（封装分页查询结果，包含数据列表、总页数等） import com.utils.PageUtils; +// 导入自定义响应类（封装统一的响应格式，如成功/错误响应） import com.utils.R; +// 导入MD5工具类（用于数据加密，如密码加密，此处未使用） import com.utils.MD5Util; +// 导入MyBatis-Plus工具类（提供通用数据库操作工具方法） import com.utils.MPUtil; +// 导入通用工具类（包含常用辅助方法，如生成随机数、数据转换等） import com.utils.CommonUtil; /** * 学科 * 后端接口 - * @author - * @email + * @author + * @email * @date 2021-05-09 15:46:14 */ +// 标记为RESTful控制器，处理所有以/xueke开头的HTTP请求 @RestController +// 定义请求映射路径，该控制器的所有接口路径均以/xueke开头 @RequestMapping("/xueke") public class XuekeController { + // 自动注入学科服务类实例，用于调用学科相关的数据库操作方法 @Autowired private XuekeService xuekeService; - /** - * 后端列表 + * 后端列表（分页查询学科数据） + * @param params 分页参数（包含当前页、每页大小、排序条件等） + * @param xueke 学科实体对象（用于构建查询条件，如模糊查询字段） + * @param request HTTP请求对象（可获取请求中的会话信息等） + * @return 包含分页数据的响应对象（格式：{data: 分页数据}） */ @RequestMapping("/page") - public R page(@RequestParam Map params,XuekeEntity xueke, - HttpServletRequest request){ + public R page(@RequestParam Map params, XuekeEntity xueke, + HttpServletRequest request) { + // 创建MyBatis-Plus实体包装器，用于构建数据库查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = xuekeService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, xueke), params), params)); - + // 调用学科服务类的分页查询方法，包含模糊查询、范围查询和排序处理 + // MPUtil.likeOrEq(ew, xueke)：对实体中的字段进行模糊或等于查询 + // MPUtil.between(...)：处理日期范围等条件 + // MPUtil.sort(...)：根据参数进行排序 + PageUtils page = xuekeService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, xueke), params), params)); + // 返回成功响应，并将分页数据放入响应体的"data"字段 return R.ok().put("data", page); } - + /** - * 前端列表 + * 前端列表（分页查询学科数据，供前端调用） + * @param params 分页参数 + * @param xueke 学科实体对象（查询条件） + * @param request HTTP请求对象 + * @return 包含分页数据的响应对象（与后端列表逻辑类似，可能包含前端特定处理） */ @RequestMapping("/list") - public R list(@RequestParam Map params,XuekeEntity xueke, - HttpServletRequest request){ + public R list(@RequestParam Map params, XuekeEntity xueke, + HttpServletRequest request) { + // 创建实体包装器，用于构建查询条件（前端列表可能无需额外权限过滤） EntityWrapper ew = new EntityWrapper(); - PageUtils page = xuekeService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, xueke), params), params)); + // 调用分页查询方法（逻辑与后端列表一致，复用服务类方法） + PageUtils page = xuekeService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, xueke), params), params)); + // 返回分页数据响应 return R.ok().put("data", page); } - /** - * 列表 + /** + * 列表（全量查询，不分页，用于简单列表展示） + * @param xueke 学科实体对象（用于构建精确查询条件，字段全匹配） + * @return 包含查询结果的响应对象（可能返回视图列表） */ @RequestMapping("/lists") - public R list( XuekeEntity xueke){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( xueke, "xueke")); + public R list(XuekeEntity xueke) { + // 创建实体包装器，设置所有字段等于实体对象的对应字段（前缀为"xueke_"避免字段冲突） + EntityWrapper ew = new EntityWrapper(); + ew.allEq(MPUtil.allEQMapPre(xueke, "xueke")); + // 调用服务类的查询视图列表方法，返回包含关联数据的视图对象列表 return R.ok().put("data", xuekeService.selectListView(ew)); } - /** - * 查询 + /** + * 查询（单个学科对象精确查询） + * @param xueke 学科实体对象（包含查询条件字段，如ID、名称等） + * @return 包含查询结果视图的响应对象（附带成功消息） */ @RequestMapping("/query") - public R query(XuekeEntity xueke){ - EntityWrapper< XuekeEntity> ew = new EntityWrapper< XuekeEntity>(); - ew.allEq(MPUtil.allEQMapPre( xueke, "xueke")); - XuekeView xuekeView = xuekeService.selectView(ew); - return R.ok("查询学科成功").put("data", xuekeView); + public R query(XuekeEntity xueke) { + // 创建实体包装器，设置全字段相等的查询条件 + EntityWrapper ew = new EntityWrapper(); + ew.allEq(MPUtil.allEQMapPre(xueke, "xueke")); + // 调用服务类的查询视图方法，获取包含关联数据的单个视图对象 + XuekeView xuekeView = xuekeService.selectView(ew); + // 返回成功响应，携带查询结果和提示信息 + return R.ok("查询学科成功").put("data", xuekeView); } - + /** - * 后端详情 + * 后端详情（根据ID查询学科详情） + * @param id 学科ID（路径参数，如/info/123） + * @return 包含单个学科实体的响应对象 */ @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id){ + public R info(@PathVariable("id") Long id) { + // 根据ID直接查询学科实体（主键查询，性能高效） XuekeEntity xueke = xuekeService.selectById(id); + // 返回成功响应，携带学科实体数据 return R.ok().put("data", xueke); } /** - * 前端详情 + * 前端详情（根据ID查询学科详情，供前端调用） + * @param id 学科ID（路径参数） + * @return 包含单个学科实体的响应对象（与后端详情逻辑一致） */ @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id){ + public R detail(@PathVariable("id") Long id) { + // 根据ID查询学科实体 XuekeEntity xueke = xuekeService.selectById(id); + // 返回学科实体数据 return R.ok().put("data", xueke); } - + /** - * 后端保存 + * 后端保存（新增学科数据） + * @param xueke 学科实体对象（请求体数据，包含新增学科信息） + * @param request HTTP请求对象（可获取用户信息等，此处未使用） + * @return 保存结果的响应对象（成功或失败） */ @RequestMapping("/save") - public R save(@RequestBody XuekeEntity xueke, HttpServletRequest request){ - xueke.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(xueke); + public R save(@RequestBody XuekeEntity xueke, HttpServletRequest request) { + // 生成唯一ID（时间戳+随机数，确保主键唯一，避免冲突） + xueke.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 注释：实体验证（此处未启用，可取消注释进行字段校验） + //ValidatorUtils.validateEntity(xueke); + // 调用服务类的插入方法，将学科实体保存到数据库 xuekeService.insert(xueke); + // 返回成功响应 return R.ok(); } - + /** - * 前端保存 + * 前端保存（新增学科数据，供前端调用） + * @param xueke 学科实体对象（请求体数据） + * @param request HTTP请求对象（可能用于获取当前用户信息，此处未使用） + * @return 保存结果的响应对象（与后端保存逻辑一致） */ @RequestMapping("/add") - public R add(@RequestBody XuekeEntity xueke, HttpServletRequest request){ - xueke.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(xueke); + public R add(@RequestBody XuekeEntity xueke, HttpServletRequest request) { + // 生成唯一ID（与后端保存逻辑相同） + xueke.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + // 注释：实体验证（未启用） + //ValidatorUtils.validateEntity(xueke); + // 插入学科数据到数据库 xuekeService.insert(xueke); + // 返回成功响应 return R.ok(); } /** - * 修改 + * 修改（更新学科数据） + * @param xueke 学科实体对象（请求体数据，包含更新后的字段） + * @return 修改结果的响应对象 */ @RequestMapping("/update") - public R update(@RequestBody XuekeEntity xueke, HttpServletRequest request){ + public R update(@RequestBody XuekeEntity xueke, HttpServletRequest request) { + // 注释：实体验证（未启用，可根据需求添加字段校验） //ValidatorUtils.validateEntity(xueke); - xuekeService.updateById(xueke);//全部更新 + // 调用服务类的更新方法，根据ID更新学科实体的所有字段（全量更新） + xuekeService.updateById(xueke); // 注释：标记为全部更新，非部分字段更新 + // 返回成功响应 return R.ok(); } - + /** - * 删除 + * 删除（批量删除学科数据） + * @param ids 待删除的学科ID数组（请求体数据，如[1,2,3]） + * @return 删除结果的响应对象 */ @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ + public R delete(@RequestBody Long[] ids) { + // 将ID数组转换为列表，调用批量删除方法（高效删除多条记录） xuekeService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 return R.ok(); } - + /** - * 提醒接口 + * 提醒接口（统计符合条件的学科记录数，用于提醒功能） + * @param columnName 提醒关联的字段名（路径参数，如提醒时间字段） + * @param type 提醒类型（路径参数，如按日期提醒类型2表示相对当前日期计算） + * @param map 请求参数（包含提醒时间偏移量等，如remindstart=3表示3天后提醒） + * @return 统计结果的响应对象（包含符合条件的记录数） */ - @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 = xuekeService.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中添加列名和类型，用于后续查询条件构建 + map.put("column", columnName); + map.put("type", type); + + // 如果是相对日期提醒（type=2，例如"3天后提醒"） + if (type.equals("2")) { + // 创建日期格式化对象（格式：年-月-日） + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + // 获取日历实例，用于日期计算 + Calendar c = Calendar.getInstance(); + Date remindStartDate = null; // 提醒开始日期（计算后的日期） + Date remindEndDate = null; // 提醒结束日期（计算后的日期） + // 处理提醒开始时间（如果有remindstart参数，计算绝对日期） + 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)); + } + } + + // 创建MyBatis-Plus包装器，用于构建查询条件 + Wrapper wrapper = new EntityWrapper(); + // 添加提醒开始时间的大于等于条件（如提醒开始时间≥指定日期） + if (map.get("remindstart") != null) { + wrapper.ge(columnName, map.get("remindstart")); // ge: greater than or equal + } + // 添加提醒结束时间的小于等于条件（如提醒结束时间≤指定日期） + if (map.get("remindend") != null) { + wrapper.le(columnName, map.get("remindend")); // le: less than or equal + } + + // 此处未添加权限控制（学科可能为公共数据，无需区分用户） + // 直接统计符合条件的记录数 + int count = xuekeService.selectCount(wrapper); + // 返回成功响应，携带统计结果 + return R.ok().put("count", count); + } +} \ No newline at end of file diff --git a/src/main/java/com/controller/YonghuController.java b/src/main/java/com/controller/YonghuController.java index 886eb33..df65a0f 100644 --- a/src/main/java/com/controller/YonghuController.java +++ b/src/main/java/com/controller/YonghuController.java @@ -1,284 +1,442 @@ +// 定义包名为 com.controller package com.controller; +// 导入用于格式化日期的 SimpleDateFormat 类 import java.text.SimpleDateFormat; +// 导入 ArrayList 类，用于创建动态数组 import java.util.ArrayList; +// 导入 Arrays 类，用于操作数组 import java.util.Arrays; +// 导入 Calendar 类，用于处理日期和时间 import java.util.Calendar; +// 导入 Map 接口，用于存储键值对 import java.util.Map; +// 导入 HashMap 类，实现 Map 接口 import java.util.HashMap; +// 导入 Iterator 接口，用于遍历集合 import java.util.Iterator; +// 导入 Date 类，用于表示日期和时间 import java.util.Date; +// 导入 List 接口，用于创建列表 import java.util.List; +// 导入 HttpServletRequest 类，用于封装 HTTP 请求信息 import javax.servlet.http.HttpServletRequest; +// 导入自定义的验证工具类 import com.utils.ValidatorUtils; +// 导入 Apache Commons Lang3 库中的 StringUtils 类，用于处理字符串 import org.apache.commons.lang3.StringUtils; +// 导入 Spring 框架的自动注入注解 import org.springframework.beans.factory.annotation.Autowired; +// 导入 Spring 框架的日期格式化注解 import org.springframework.format.annotation.DateTimeFormat; +// 导入 Spring 框架的路径变量注解 import org.springframework.web.bind.annotation.PathVariable; +// 导入 Spring 框架的请求体注解 import org.springframework.web.bind.annotation.RequestBody; +// 导入 Spring 框架的请求映射注解 import org.springframework.web.bind.annotation.RequestMapping; +// 导入 Spring 框架的请求参数注解 import org.springframework.web.bind.annotation.RequestParam; +// 导入 Spring 框架的 REST 控制器注解 import org.springframework.web.bind.annotation.RestController; +// 导入 MyBatis-Plus 框架的实体包装器类 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入 MyBatis-Plus 框架的包装器接口 import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的忽略认证注解 import com.annotation.IgnoreAuth; +// 导入用户实体类 import com.entity.YonghuEntity; +// 导入用户视图类 import com.entity.view.YonghuView; +// 导入用户服务类 import com.service.YonghuService; +// 导入令牌服务类 import com.service.TokenService; +// 导入自定义的分页工具类 import com.utils.PageUtils; +// 导入自定义的响应结果类 import com.utils.R; +// 导入自定义的 MD5 工具类 import com.utils.MD5Util; +// 导入自定义的 MyBatis-Plus 工具类 import com.utils.MPUtil; +// 导入自定义的通用工具类 import com.utils.CommonUtil; /** * 用户 * 后端接口 - * @author - * @email + * @author + * @email * @date 2021-05-09 15:46:14 */ +// 声明该类为 REST 控制器 @RestController +// 定义该控制器的请求映射路径 @RequestMapping("/yonghu") public class YonghuController { - @Autowired - private YonghuService yonghuService; - + // 自动注入用户服务类的实例 + @Autowired + private YonghuService yonghuService; + + // 自动注入令牌服务类的实例 @Autowired private TokenService tokenService; - + /** * 登录 */ + // 忽略认证注解，允许未认证用户访问该接口 @IgnoreAuth + // 定义登录接口的请求映射路径 @RequestMapping(value = "/login") + // 登录方法，接收用户名、密码、验证码和 HTTP 请求作为参数 public R login(String username, String password, String captcha, HttpServletRequest request) { + // 根据用户名查询用户实体 YonghuEntity user = yonghuService.selectOne(new EntityWrapper().eq("yonghuzhanghao", username)); + // 如果用户不存在或密码不正确 if(user==null || !user.getMima().equals(password)) { + // 返回错误信息 return R.error("账号或密码不正确"); } - + + // 生成用户令牌 String token = tokenService.generateToken(user.getId(), username,"yonghu", "用户" ); + // 返回成功信息并携带令牌 return R.ok().put("token", token); } - + /** - * 注册 - */ + * 注册 + */ + // 忽略认证注解，允许未认证用户访问该接口 @IgnoreAuth - @RequestMapping("/register") - public R register(@RequestBody YonghuEntity yonghu){ - //ValidatorUtils.validateEntity(yonghu); - YonghuEntity user = yonghuService.selectOne(new EntityWrapper().eq("yonghuzhanghao", yonghu.getYonghuzhanghao())); + // 定义注册接口的请求映射路径 + @RequestMapping("/register") + // 注册方法，接收用户实体作为请求体 + public R register(@RequestBody YonghuEntity yonghu){ + // 验证用户实体（注释掉，可能后续需要启用） + //ValidatorUtils.validateEntity(yonghu); + // 根据用户名查询用户实体 + YonghuEntity user = yonghuService.selectOne(new EntityWrapper().eq("yonghuzhanghao", yonghu.getYonghuzhanghao())); + // 如果用户已存在 if(user!=null) { + // 返回错误信息 return R.error("注册用户已存在"); } + // 生成用户 ID，使用当前时间戳 Long uId = new Date().getTime(); + // 设置用户 ID yonghu.setId(uId); - yonghuService.insert(yonghu); - return R.ok(); - } - + // 插入用户实体到数据库 + yonghuService.insert(yonghu); + // 返回成功信息 + return R.ok(); + } + /** * 退出 */ + // 定义退出接口的请求映射路径 @RequestMapping("/logout") + // 退出方法，接收 HTTP 请求作为参数 public R logout(HttpServletRequest request) { + // 使当前会话无效 request.getSession().invalidate(); + // 返回退出成功信息 return R.ok("退出成功"); } - + /** - * 获取用户的session用户信息 - */ - @RequestMapping("/session") - public R getCurrUser(HttpServletRequest request){ - Long id = (Long)request.getSession().getAttribute("userId"); - YonghuEntity user = yonghuService.selectById(id); - return R.ok().put("data", user); - } - - /** - * 密码重置 - */ - @IgnoreAuth + * 获取用户的session用户信息 + */ + // 定义获取用户会话信息接口的请求映射路径 + @RequestMapping("/session") + // 获取用户会话信息方法，接收 HTTP 请求作为参数 + public R getCurrUser(HttpServletRequest request){ + // 从会话中获取用户 ID + Long id = (Long)request.getSession().getAttribute("userId"); + // 根据用户 ID 查询用户实体 + YonghuEntity user = yonghuService.selectById(id); + // 返回成功信息并携带用户实体 + return R.ok().put("data", user); + } + + /** + * 密码重置 + */ + // 忽略认证注解，允许未认证用户访问该接口 + @IgnoreAuth + // 定义密码重置接口的请求映射路径 @RequestMapping(value = "/resetPass") - public R resetPass(String username, HttpServletRequest request){ - YonghuEntity user = yonghuService.selectOne(new EntityWrapper().eq("yonghuzhanghao", username)); - if(user==null) { - return R.error("账号不存在"); - } - user.setMima("123456"); - yonghuService.updateById(user); - return R.ok("密码已重置为：123456"); - } - - - /** - * 后端列表 - */ - @RequestMapping("/page") - public R page(@RequestParam Map params,YonghuEntity yonghu, - HttpServletRequest request){ - EntityWrapper ew = new EntityWrapper(); + // 密码重置方法，接收用户名和 HTTP 请求作为参数 + public R resetPass(String username, HttpServletRequest request){ + // 根据用户名查询用户实体 + YonghuEntity user = yonghuService.selectOne(new EntityWrapper().eq("yonghuzhanghao", username)); + // 如果用户不存在 + if(user==null) { + // 返回错误信息 + return R.error("账号不存在"); + } + // 将用户密码重置为 123456 + user.setMima("123456"); + // 更新用户实体到数据库 + yonghuService.updateById(user); + // 返回密码重置成功信息 + return R.ok("密码已重置为：123456"); + } + + + /** + * 后端列表 + */ + // 定义后端列表接口的请求映射路径 + @RequestMapping("/page") + // 后端列表方法，接收请求参数、用户实体和 HTTP 请求作为参数 + 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)); - return R.ok().put("data", page); - } - - /** - * 前端列表 - */ - @RequestMapping("/list") - public R list(@RequestParam Map params,YonghuEntity yonghu, - HttpServletRequest request){ - EntityWrapper ew = new EntityWrapper(); + // 返回成功信息并携带分页数据 + return R.ok().put("data", page); + } + + /** + * 前端列表 + */ + // 定义前端列表接口的请求映射路径 + @RequestMapping("/list") + // 前端列表方法，接收请求参数、用户实体和 HTTP 请求作为参数 + 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)); - return R.ok().put("data", page); - } + // 返回成功信息并携带分页数据 + return R.ok().put("data", page); + } + + /** + * 列表 + */ + // 定义列表接口的请求映射路径 + @RequestMapping("/lists") + // 列表方法，接收用户实体作为参数 + public R list( YonghuEntity yonghu){ + // 创建用户实体的包装器 + EntityWrapper ew = new EntityWrapper(); + // 设置包装器的查询条件 + ew.allEq(MPUtil.allEQMapPre( yonghu, "yonghu")); + // 返回成功信息并携带用户视图列表 + return R.ok().put("data", yonghuService.selectListView(ew)); + } /** - * 列表 - */ - @RequestMapping("/lists") - public R list( YonghuEntity yonghu){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( yonghu, "yonghu")); - return R.ok().put("data", yonghuService.selectListView(ew)); - } - - /** - * 查询 - */ - @RequestMapping("/query") - public R query(YonghuEntity yonghu){ - EntityWrapper< YonghuEntity> ew = new EntityWrapper< YonghuEntity>(); - ew.allEq(MPUtil.allEQMapPre( yonghu, "yonghu")); + * 查询 + */ + // 定义查询接口的请求映射路径 + @RequestMapping("/query") + // 查询方法，接收用户实体作为参数 + 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); - } - - /** - * 后端详情 - */ - @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id){ - YonghuEntity yonghu = yonghuService.selectById(id); - return R.ok().put("data", yonghu); - } - - /** - * 前端详情 - */ - @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id){ - YonghuEntity yonghu = yonghuService.selectById(id); - return R.ok().put("data", yonghu); - } - - - - - /** - * 后端保存 - */ - @RequestMapping("/save") - 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 user = yonghuService.selectOne(new EntityWrapper().eq("yonghuzhanghao", yonghu.getYonghuzhanghao())); + } + + /** + * 后端详情 + */ + // 定义后端详情接口的请求映射路径 + @RequestMapping("/info/{id}") + // 后端详情方法，接收用户 ID 作为路径变量 + public R info(@PathVariable("id") Long id){ + // 根据用户 ID 查询用户实体 + YonghuEntity yonghu = yonghuService.selectById(id); + // 返回成功信息并携带用户实体 + return R.ok().put("data", yonghu); + } + + /** + * 前端详情 + */ + // 定义前端详情接口的请求映射路径 + @RequestMapping("/detail/{id}") + // 前端详情方法，接收用户 ID 作为路径变量 + public R detail(@PathVariable("id") Long id){ + // 根据用户 ID 查询用户实体 + YonghuEntity yonghu = yonghuService.selectById(id); + // 返回成功信息并携带用户实体 + return R.ok().put("data", yonghu); + } + + + + + /** + * 后端保存 + */ + // 定义后端保存接口的请求映射路径 + @RequestMapping("/save") + // 后端保存方法，接收用户实体作为请求体和 HTTP 请求作为参数 + 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 user = yonghuService.selectOne(new EntityWrapper().eq("yonghuzhanghao", yonghu.getYonghuzhanghao())); + // 如果用户已存在 if(user!=null) { + // 返回错误信息 return R.error("用户已存在"); } + // 重新设置用户 ID，使用当前时间戳 yonghu.setId(new Date().getTime()); - yonghuService.insert(yonghu); - return R.ok(); - } - - /** - * 前端保存 - */ - @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 user = yonghuService.selectOne(new EntityWrapper().eq("yonghuzhanghao", yonghu.getYonghuzhanghao())); + // 插入用户实体到数据库 + yonghuService.insert(yonghu); + // 返回成功信息 + return R.ok(); + } + + /** + * 前端保存 + */ + // 定义前端保存接口的请求映射路径 + @RequestMapping("/add") + // 前端保存方法，接收用户实体作为请求体和 HTTP 请求作为参数 + public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request){ + // 生成用户 ID，使用当前时间戳加上随机数 + yonghu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); + // 验证用户实体（注释掉，可能后续需要启用） + //ValidatorUtils.validateEntity(yonghu); + // 根据用户名查询用户实体 + YonghuEntity user = yonghuService.selectOne(new EntityWrapper().eq("yonghuzhanghao", yonghu.getYonghuzhanghao())); + // 如果用户已存在 if(user!=null) { + // 返回错误信息 return R.error("用户已存在"); } + // 重新设置用户 ID，使用当前时间戳 yonghu.setId(new Date().getTime()); - yonghuService.insert(yonghu); - return R.ok(); - } - - /** - * 修改 - */ - @RequestMapping("/update") - public R update(@RequestBody YonghuEntity yonghu, HttpServletRequest request){ - //ValidatorUtils.validateEntity(yonghu); - yonghuService.updateById(yonghu);//全部更新 - return R.ok(); - } - - - /** - * 删除 - */ - @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ - yonghuService.deleteBatchIds(Arrays.asList(ids)); - return R.ok(); - } - - /** - * 提醒接口 - */ + // 插入用户实体到数据库 + yonghuService.insert(yonghu); + // 返回成功信息 + return R.ok(); + } + + /** + * 修改 + */ + // 定义修改接口的请求映射路径 + @RequestMapping("/update") + // 修改方法，接收用户实体作为请求体和 HTTP 请求作为参数 + public R update(@RequestBody YonghuEntity yonghu, HttpServletRequest request){ + // 验证用户实体（注释掉，可能后续需要启用） + //ValidatorUtils.validateEntity(yonghu); + // 更新用户实体到数据库 + yonghuService.updateById(yonghu);//全部更新 + // 返回成功信息 + return R.ok(); + } + + + /** + * 删除 + */ + // 定义删除接口的请求映射路径 + @RequestMapping("/delete") + // 删除方法，接收用户 ID 数组作为请求体 + public R delete(@RequestBody Long[] ids){ + // 批量删除用户实体 + yonghuService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功信息 + return R.ok(); + } + + /** + * 提醒接口 + */ + // 定义提醒接口的请求映射路径 @RequestMapping("/remind/{columnName}/{type}") - public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, + // 提醒方法，接收列名、HTTP 请求、类型和请求参数作为参数 + public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, @PathVariable("type") String type,@RequestParam Map map) { + // 将列名放入请求参数中 map.put("column", columnName); + // 将类型放入请求参数中 map.put("type", type); - + + // 如果类型为 2 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.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); } - -} +} \ No newline at end of file diff --git a/src/main/java/com/controller/hello.java b/src/main/java/com/controller/hello.java index f88fe15..4fd1939 100644 --- a/src/main/java/com/controller/hello.java +++ b/src/main/java/com/controller/hello.java @@ -1,7 +1,11 @@ +// 声明该类所属的包（这里包名为com.controller） package com.controller; +// 定义一个公共类hello public class hello { + // 主方法，程序执行的入口点 public static void main(String[] args) { + // 声明一个整数类型的变量a（未初始化） int a; } -} +} \ No newline at end of file