p4vkf3rot
/
j2ee
1
0
Fork 2
Code Issues Pull Requests Packages Projects Releases Wiki Activity

注释

Browse Source
hujiali_branch
hjl 8 months ago
parent 8c83b7dcaa
commit 78413865c0
30 changed files with 1560 additions and 1180 deletions
Show Stats Download Patch File Download Diff File

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

@ -1,7 +1,5 @@
package com.controller; package com.controller;
import java.util.Arrays; import java.util.Arrays;
import java.util.Map; import java.util.Map;
@ -13,100 +11,118 @@ import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController;
import com.annotation.IgnoreAuth; import com.annotation.IgnoreAuth;
import com.baomidou.mybatisplus.mapper.EntityWrapper; import com.baomidou.mybatisplus.mapper.EntityWrapper; // MyBatis-Plus的实体包装器
import com.entity.ConfigEntity; import com.entity.ConfigEntity; // 配置实体类
import com.service.ConfigService; import com.service.ConfigService; // 配置服务类
import com.utils.MPUtil; import com.utils.MPUtil; // MyBatis-Plus工具类
import com.utils.PageUtils; import com.utils.PageUtils;
import com.utils.R; import com.utils.R;
import com.utils.ValidatorUtils; import com.utils.ValidatorUtils;
/** /**
* 登录相关 * 登录相关
*/ */
@RequestMapping("config") @RequestMapping("config") // 设置基本请求路径为"/config"
@RestController @RestController // 标记为REST风格的控制器
public class ConfigController{ public class ConfigController {
@Autowired @Autowired // 自动注入ConfigService
private ConfigService configService; private ConfigService configService;
/** /**
* 列表 * 列表
* @param params 查询参数
* @param config 配置信息
* @return 分页后的配置信息
*/ */
@RequestMapping("/page") @RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params,ConfigEntity config){ public R page(@RequestParam Map<String, Object> params, ConfigEntity config) {
EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>(); EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>(); // 创建EntityWrapper用于条件构造
PageUtils page = configService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, config), params), params)); PageUtils page = configService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, config), params), params)); // 查询分页数据
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* 列表 * 列表
* @param params 查询参数
* @param config 配置信息
* @return 所有配置信息的列表
*/ */
@IgnoreAuth @IgnoreAuth // 忽略身份验证
@RequestMapping("/list") @RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params,ConfigEntity config){ public R list(@RequestParam Map<String, Object> params, ConfigEntity config) {
EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>(); EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>(); // 创建EntityWrapper用于条件构造
PageUtils page = configService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, config), params), params)); PageUtils page = configService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, config), params), params)); // 查询分页数据
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* 信息 * 信息
* @param id 配置ID
* @return 指定ID的配置信息
*/ */
@RequestMapping("/info/{id}") @RequestMapping("/info/{id}") // 用于获取指定ID的配置信息
public R info(@PathVariable("id") String id){ public R info(@PathVariable("id") String id) {
ConfigEntity config = configService.selectById(id); ConfigEntity config = configService.selectById(id); // 根据ID查询配置
return R.ok().put("data", config); return R.ok().put("data", config);
} }
/** /**
* 详情 * 详情
* @param id 配置ID
* @return 指定ID的配置信息，忽略身份验证
*/ */
@IgnoreAuth @IgnoreAuth // 忽略身份验证
@RequestMapping("/detail/{id}") @RequestMapping("/detail/{id}") // 用于获取指定ID的配置信息详情
public R detail(@PathVariable("id") String id){ public R detail(@PathVariable("id") String id) {
ConfigEntity config = configService.selectById(id); ConfigEntity config = configService.selectById(id); // 根据ID查询配置
return R.ok().put("data", config); return R.ok().put("data", config);
} }
/** /**
* 根据name获取信息 * 根据name获取信息
* @param name 配置名称
* @return 指定名称的配置信息
*/ */
@RequestMapping("/info") @RequestMapping("/info") // 用于根据名称获取配置信息
public R infoByName(@RequestParam String name){ public R infoByName(@RequestParam String name) {
ConfigEntity config = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile")); ConfigEntity config = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile")); // 根据名称查询配置
return R.ok().put("data", config); return R.ok().put("data", config);
} }
/** /**
* 保存 * 保存
* @param config 配置信息
* @return 保存结果
*/ */
@PostMapping("/save") @PostMapping("/save") // 用于保存配置
public R save(@RequestBody ConfigEntity config){ public R save(@RequestBody ConfigEntity config) {
// ValidatorUtils.validateEntity(config); // ValidatorUtils.validateEntity(config); // 验证配置实体（注释掉此行可以在需要时启用）
configService.insert(config); configService.insert(config); // 保存配置
return R.ok(); return R.ok();
} }
/** /**
* 修改 * 修改
* @param config 配置信息
* @return 修改结果
*/ */
@RequestMapping("/update") @RequestMapping("/update") // 用于修改配置
public R update(@RequestBody ConfigEntity config){ public R update(@RequestBody ConfigEntity config) {
// ValidatorUtils.validateEntity(config); // ValidatorUtils.validateEntity(config); // 验证配置实体（注释掉此行可以在需要时启用）
configService.updateById(config);//全部更新 configService.updateById(config); // 根据ID更新配置
return R.ok(); return R.ok();
} }
/** /**
* 删除 * 删除
* @param ids 配置ID数组
* @return 删除结果
*/ */
@RequestMapping("/delete") @RequestMapping("/delete") // 用于删除配置
public R delete(@RequestBody Long[] ids){ public R delete(@RequestBody Long[] ids) {
configService.deleteBatchIds(Arrays.asList(ids)); configService.deleteBatchIds(Arrays.asList(ids)); // 批量删除配置
return R.ok(); return R.ok();
} }
} }

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

@ -7,84 +7,103 @@ import java.util.Date;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import org.apache.commons.io.FileUtils; import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils; import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的依赖注入注解
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController; // 导入Spring的REST控制器注解
import org.springframework.web.multipart.MultipartFile; import org.springframework.web.multipart.MultipartFile; // 导入Spring的文件上传接口
import com.annotation.IgnoreAuth; import com.annotation.IgnoreAuth; // 导入自定义注解，表示忽略身份验证
import com.baomidou.mybatisplus.mapper.EntityWrapper; import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入MyBatis-Plus的EntityWrapper，用于构建查询条件
import com.entity.ConfigEntity; import com.entity.ConfigEntity;
import com.entity.EIException; import com.entity.EIException;
import com.service.ConfigService; import com.service.ConfigService;
import com.utils.R; import com.utils.R;
/** /**
* 上传文件映射表 * 上传文件映射表
*/ */
@RestController @RestController // 标记该类为REST控制器
@RequestMapping("file") @RequestMapping("file") // 设置基本请求路径为"/file"
@SuppressWarnings({"unchecked","rawtypes"}) @SuppressWarnings({"unchecked","rawtypes"}) // 忽略编译警告
public class FileController{ public class FileController {
@Autowired
@Autowired // 自动注入ConfigService服务
private ConfigService configService; private ConfigService configService;
/**
* 上传文件
*/
@RequestMapping("/upload")
@IgnoreAuth
public R upload(@RequestParam("file") MultipartFile file, String type,HttpServletRequest request) throws Exception {
if (file.isEmpty()) {
throw new EIException("上传文件不能为空");
}
String fileExt = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".")+1);
String fileName = new Date().getTime()+"."+fileExt;
File dest = new File(request.getSession().getServletContext().getRealPath("/upload")+"/"+fileName);
file.transferTo(dest);
/**
* 如果使用idea或者eclipse重启项目，发现之前上传的图片或者文件丢失，将下面一行代码注释打开
* 请将以下的"D:\\ssmpiv99\\src\\main\\webapp\\upload"替换成你本地项目的upload路径，
* 并且项目路径不能存在中文、空格等特殊字符
*/
//FileUtils.copyFile(dest, new File("D:\\ssmpiv99\\src\\main\\webapp\\upload"+"/"+fileName)); /**修改了路径以后请将该行最前面的//注释去掉**/
if(StringUtils.isNotBlank(type) && type.equals("1")) {
ConfigEntity configEntity = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile"));
if(configEntity==null) {
configEntity = new ConfigEntity();
configEntity.setName("faceFile");
configEntity.setValue(fileName);
} else {
configEntity.setValue(fileName);
}
configService.insertOrUpdate(configEntity);
}
return R.ok().put("file", fileName);
}
/**
* 下载文件
*/
@IgnoreAuth
@RequestMapping("/download")
public void download(@RequestParam String fileName, HttpServletRequest request, HttpServletResponse response) {
try {
File file = new File(request.getSession().getServletContext().getRealPath("/upload")+"/"+fileName);
if (file.exists()) {
response.reset();
response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName+"\"");
response.setHeader("Cache-Control", "no-cache");
response.setHeader("Access-Control-Allow-Credentials", "true");
response.setContentType("application/octet-stream; charset=UTF-8");
IOUtils.write(FileUtils.readFileToByteArray(file), response.getOutputStream());
}
} catch (IOException e) { /**
e.printStackTrace(); * 上传文件
} * @param file 上传的文件
} * @param type 文件类型标识
* @param request HttpServletRequest对象
* @return 上传结果
*/
@RequestMapping("/upload") // 映射请求路径为"/upload"
@IgnoreAuth // 忽略身份验证
public R upload(@RequestParam("file") MultipartFile file, String type, HttpServletRequest request) throws Exception {
// 检查上传的文件是否为空
if (file.isEmpty()) {
throw new EIException("上传文件不能为空");
}
// 获取文件扩展名
String fileExt = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".") + 1);
String fileName = new Date().getTime() + "." + fileExt;
// 定义文件保存的目标路径
File dest = new File(request.getSession().getServletContext().getRealPath("/upload") + "/" + fileName);
file.transferTo(dest);
/**
* 如果使用IDEA或者Eclipse重启项目后发现之前上传的文件丢失，
* 请将下面一行代码注释打开
* 并将"D:\\ssmpiv99\\src\\main\\webapp\\upload"替换为你本地项目的upload路径，
* 确保项目路径中不存在中文、空格等特殊字符
*/
// FileUtils.copyFile(dest, new File("D:\\ssmpiv99\\src\\main\\webapp\\upload" + "/" + fileName)); /** 修改了路径后请将该行最前面的//注释去掉 **/
// 如果type不为空且等于"1"，则更新或保存配置信息
if (StringUtils.isNotBlank(type) && type.equals("1")) {
ConfigEntity configEntity = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile"));
if (configEntity == null) {
configEntity = new ConfigEntity(); // 创建新的配置实体
configEntity.setName("faceFile");
configEntity.setValue(fileName);
} else {
configEntity.setValue(fileName);
}
configService.insertOrUpdate(configEntity); // 保存或更新配置
}
return R.ok().put("file", fileName); // 返回上传结果，包含文件名
}
/**
* 下载文件
* @param fileName 文件名
* @param request HttpServletRequest对象
* @param response HttpServletResponse对象
*/
@IgnoreAuth // 忽略身份验证
@RequestMapping("/download") // 映射请求路径为"/download"
public void download(@RequestParam String fileName, HttpServletRequest request, HttpServletResponse response) {
try {
// 定义文件的完整路径
File file = new File(request.getSession().getServletContext().getRealPath("/upload") + "/" + fileName);
// 检查文件是否存在
if (file.exists()) {
response.reset(); // 重置响应
// 设置响应头，指示文件下载
response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");
response.setHeader("Cache-Control", "no-cache");
response.setHeader("Access-Control-Allow-Credentials", "true");
response.setContentType("application/octet-stream; charset=UTF-8"); // 设置内容类型
// 将文件内容写入响应输出流
IOUtils.write(FileUtils.readFileToByteArray(file), response.getOutputStream());
}
} catch (IOException e) {
e.printStackTrace(); // 打印异常信息
}
}
} }

375
src/main/java/com/controller/ForumController.java
Unescape View File

@ -1,42 +1,42 @@
package com.controller; package com.controller;
import java.math.BigDecimal; import java.math.BigDecimal;
import java.text.SimpleDateFormat; import java.text.SimpleDateFormat;
import java.text.ParseException; import java.text.ParseException; // 导入解析异常
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays; // 导入Arrays工具类
import java.util.Calendar; import java.util.Calendar;
import java.util.Map; import java.util.Map; // 导入Map接口
import java.util.HashMap; import java.util.HashMap;
import java.util.Iterator; import java.util.Iterator; // 导入迭代器接口
import java.util.Date; import java.util.Date;
import java.util.List; import java.util.List;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest; // 导入Servlet请求类
import java.io.IOException; import java.io.IOException;
import com.utils.ValidatorUtils; import com.utils.ValidatorUtils; // 导入验证工具类
import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.StringUtils; // 导入Apache Commons Lang的StringUtils类，用于字符串操作
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的依赖注入注解
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import org.springframework.format.annotation.DateTimeFormat; import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.PathVariable; // 导入路径变量注解
import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestBody; // 导入请求体注解
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController; // 导入REST控制器注解
import com.baomidou.mybatisplus.mapper.EntityWrapper; import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper; import com.baomidou.mybatisplus.mapper.Wrapper;
import com.annotation.IgnoreAuth; import com.annotation.IgnoreAuth;
import com.entity.ForumEntity; import com.entity.ForumEntity; // 导入论坛实体类
import com.entity.view.ForumView; import com.entity.view.ForumView; // 导入论坛视图类
import com.service.ForumService; import com.service.ForumService; // 导入论坛服务类
import com.service.TokenService; import com.service.TokenService;
import com.utils.PageUtils; import com.utils.PageUtils; // 导入分页工具类
import com.utils.R; import com.utils.R;
import com.utils.MD5Util; import com.utils.MD5Util;
import com.utils.MPUtil; import com.utils.MPUtil; // 导入MyBatis-Plus工具类
import com.utils.CommonUtil; import com.utils.CommonUtil;
/** /**
@ -46,217 +46,238 @@ import com.utils.CommonUtil;
* @email * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
@RestController @RestController // 标记该类为REST控制器
@RequestMapping("/forum") @RequestMapping("/forum")
public class ForumController { public class ForumController {
@Autowired @Autowired
private ForumService forumService; private ForumService forumService; // 注入论坛服务
/** /**
* 后端列表 * 后端列表
* @param params 请求参数
* @param forum 论坛实体
* @param request HttpServletRequest对象
* @return 论坛列表分页数据
*/ */
@RequestMapping("/page") @RequestMapping("/page") // 映射请求路径为"/page"
public R page(@RequestParam Map<String, Object> params,ForumEntity forum, public R page(@RequestParam Map<String, Object> params, ForumEntity forum, HttpServletRequest request) {
HttpServletRequest request){ // 如果当前用户不是管理员，则设置用户ID
if(!request.getSession().getAttribute("role").toString().equals("管理员")) { if (!request.getSession().getAttribute("role").toString().equals("管理员")) {
forum.setUserid((Long)request.getSession().getAttribute("userId")); forum.setUserid((Long) request.getSession().getAttribute("userId"));
} }
EntityWrapper<ForumEntity> ew = new EntityWrapper<ForumEntity>(); EntityWrapper<ForumEntity> ew = new EntityWrapper<ForumEntity>();
// 查询论坛列表分页数据
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));
request.setAttribute("data", page); request.setAttribute("data", page); // 将数据设置到请求属性中
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* 前端列表 * 前端列表
* @param params 请求参数
* @param forum 论坛实体
* @param request HttpServletRequest对象
* @return 论坛列表分页数据
*/ */
@RequestMapping("/list") @RequestMapping("/list") // 映射请求路径为"/list"
public R list(@RequestParam Map<String, Object> params,ForumEntity forum, public R list(@RequestParam Map<String, Object> params, ForumEntity forum, HttpServletRequest request) {
HttpServletRequest request){ // 如果当前用户不是管理员，则设置用户ID
if(!request.getSession().getAttribute("role").toString().equals("管理员")) { if (!request.getSession().getAttribute("role").toString().equals("管理员")) {
forum.setUserid((Long)request.getSession().getAttribute("userId")); forum.setUserid((Long) request.getSession().getAttribute("userId"));
} }
EntityWrapper<ForumEntity> ew = new EntityWrapper<ForumEntity>(); EntityWrapper<ForumEntity> ew = new EntityWrapper<ForumEntity>();
// 查询论坛列表分页数据
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));
request.setAttribute("data", page); request.setAttribute("data", page); // 将数据设置到请求属性中
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* 列表 * 允许匿名访问的列表
* @param params 请求参数
* @param forum 论坛实体
* @param request HttpServletRequest对象
* @return 论坛列表分页数据
*/ */
@IgnoreAuth @IgnoreAuth // 忽略身份验证
@RequestMapping("/flist") @RequestMapping("/flist") // 映射请求路径为"/flist"
public R flist(@RequestParam Map<String, Object> params,ForumEntity forum, HttpServletRequest request){ public R flist(@RequestParam Map<String, Object> params, ForumEntity forum, HttpServletRequest request) {
EntityWrapper<ForumEntity> ew = new EntityWrapper<ForumEntity>(); EntityWrapper<ForumEntity> ew = new EntityWrapper<ForumEntity>();
PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params)); // 查询论坛列表分页数据
return R.ok().put("data", page); PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params));
return R.ok().put("data", page);
} }
/** /**
* 查询 * 查询论坛信息
* @param forum 论坛实体
* @return 论坛信息
*/ */
@RequestMapping("/query") @RequestMapping("/query") // 映射请求路径为"/query"
public R query(ForumEntity forum){ public R query(ForumEntity forum) {
EntityWrapper< ForumEntity> ew = new EntityWrapper< ForumEntity>(); EntityWrapper<ForumEntity> ew = new EntityWrapper<ForumEntity>();
ew.allEq(MPUtil.allEQMapPre( forum, "forum")); ew.allEq(MPUtil.allEQMapPre(forum, "forum")); // 构建查询条件
ForumView forumView = forumService.selectView(ew); ForumView forumView = forumService.selectView(ew); // 查询论坛视图
return R.ok("查询论坛表成功").put("data", forumView); return R.ok("查询论坛表成功").put("data", forumView);
} }
/** /**
* 后端详情 * 获取后端论坛详情
* @param id 论坛ID
* @return 论坛信息
*/ */
@RequestMapping("/info/{id}") @RequestMapping("/info/{id}") // 映射请求路径为"/info/{id}"
public R info(@PathVariable("id") Long id){ public R info(@PathVariable("id") Long id) {
ForumEntity forum = forumService.selectById(id); ForumEntity forum = forumService.selectById(id); // 根据ID查询论坛
return R.ok().put("data", forum); return R.ok().put("data", forum);
} }
/** /**
* 前端详情 * 获取前端论坛详情
* @param id 论坛ID
* @return 论坛信息
*/ */
@IgnoreAuth @IgnoreAuth // 忽略身份验证
@RequestMapping("/detail/{id}") @RequestMapping("/detail/{id}") // 映射请求路径为"/detail/{id}"
public R detail(@PathVariable("id") Long id){ public R detail(@PathVariable("id") Long id) {
ForumEntity forum = forumService.selectById(id); ForumEntity forum = forumService.selectById(id); // 根据ID查询论坛
return R.ok().put("data", forum); return R.ok().put("data", forum);
} }
/** /**
* 论坛详情 * 获取论坛及其子项
* @param id 论坛ID
* @return 论坛信息及子项
*/ */
@IgnoreAuth @IgnoreAuth // 忽略身份验证
@RequestMapping("/list/{id}") @RequestMapping("/list/{id}") // 映射请求路径为"/list/{id}"
public R list(@PathVariable("id") String id){ public R list(@PathVariable("id") String id) {
ForumEntity forum = forumService.selectById(id); ForumEntity forum = forumService.selectById(id); // 根据ID查询论坛
getChilds(forum); getChilds(forum); // 获取子项
return R.ok().put("data", forum); return R.ok().put("data", forum); // 返回论坛信息及子项
} }
private ForumEntity getChilds(ForumEntity forum) { /**
List<ForumEntity> childs = new ArrayList<ForumEntity>(); * 递归获取子项
childs = forumService.selectList(new EntityWrapper<ForumEntity>().eq("parentid", forum.getId())); * @param forum 论坛实体
if(childs == null || childs.size()==0) { * @return 具有子项的论坛
return null; */
} private ForumEntity getChilds(ForumEntity forum) {
forum.setChilds(childs); List<ForumEntity> childs = new ArrayList<ForumEntity>();
for(ForumEntity forumEntity : childs) { childs = forumService.selectList(new EntityWrapper<ForumEntity>().eq("parentid", forum.getId())); // 根据父ID查询子项
getChilds(forumEntity); if (childs == null || childs.size() == 0) {
} return null; // 如果没有子项，则返回null
return forum; }
forum.setChilds(childs); // 设置子项
for (ForumEntity forumEntity : childs) {
getChilds(forumEntity); // 递归获取每个子项的子项
}
return forum; // 返回具有子项的论坛
} }
/** /**
* 后端保存 * 后端保存论坛信息
* @param forum 论坛实体
* @param request HttpServletRequest对象
* @return 保存结果
*/ */
@RequestMapping("/save") @RequestMapping("/save") // 映射请求路径为"/save"
public R save(@RequestBody ForumEntity forum, HttpServletRequest request){ public R save(@RequestBody ForumEntity forum, HttpServletRequest request) {
forum.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); forum.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); // 生成唯一ID
//ValidatorUtils.validateEntity(forum); // ValidatorUtils.validateEntity(forum); // 验证实体（可选择启用）
forum.setUserid((Long)request.getSession().getAttribute("userId")); forum.setUserid((Long) request.getSession().getAttribute("userId")); // 设置用户ID
forumService.insert(forum); // 保存论坛信息
forumService.insert(forum);
return R.ok(); return R.ok();
} }
/** /**
* 前端保存 * 前端保存论坛信息
* @param forum 论坛实体
* @param request HttpServletRequest对象
* @return 保存结果
*/ */
@RequestMapping("/add") @RequestMapping("/add") // 映射请求路径为"/add"
public R add(@RequestBody ForumEntity forum, HttpServletRequest request){ public R add(@RequestBody ForumEntity forum, HttpServletRequest request) {
forum.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); forum.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); // 生成唯一ID
//ValidatorUtils.validateEntity(forum); // ValidatorUtils.validateEntity(forum); // 验证实体（可选择启用）
forum.setUserid((Long)request.getSession().getAttribute("userId")); forum.setUserid((Long) request.getSession().getAttribute("userId")); // 设置用户ID
forumService.insert(forum); // 保存论坛信息
forumService.insert(forum); return R.ok();
return R.ok();
} }
/** /**
* 修改 * 修改论坛信息
* @param forum 论坛实体
* @param request HttpServletRequest对象
* @return 修改结果
*/ */
@RequestMapping("/update") @RequestMapping("/update") // 映射请求路径为"/update"
@Transactional @Transactional // 开启事务
public R update(@RequestBody ForumEntity forum, HttpServletRequest request){ public R update(@RequestBody ForumEntity forum, HttpServletRequest request) {
//ValidatorUtils.validateEntity(forum); // ValidatorUtils.validateEntity(forum); // 验证实体（可选择启用）
forumService.updateById(forum);//全部更新 forumService.updateById(forum); // 更新论坛信息
return R.ok(); return R.ok();
} }
/** /**
* 删除 * 删除论坛
* @param ids 论坛ID数组
* @return 删除结果
*/ */
@RequestMapping("/delete") @RequestMapping("/delete") // 映射请求路径为"/delete"
public R delete(@RequestBody Long[] ids){ public R delete(@RequestBody Long[] ids) {
forumService.deleteBatchIds(Arrays.asList(ids)); forumService.deleteBatchIds(Arrays.asList(ids)); // 批量删除论坛
return R.ok(); return R.ok();
} }
/** /**
* 提醒接口 * 提醒接口
* @param columnName 列名
* @param type 类型
* @param map 查询参数
* @param request HttpServletRequest对象
* @return 提醒数量
*/ */
@RequestMapping("/remind/{columnName}/{type}") @RequestMapping("/remind/{columnName}/{type}") // 映射请求路径为"/remind/{columnName}/{type}"
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@PathVariable("type") String type,@RequestParam Map<String, Object> map) { @PathVariable("type") String type, @RequestParam Map<String, Object> map) {
map.put("column", columnName); map.put("column", columnName); // 将列名放入请求参数
map.put("type", type); map.put("type", type); // 将类型放入请求参数
if(type.equals("2")) { // 如果类型为2，进行日期提醒处理
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); if (type.equals("2")) {
Calendar c = Calendar.getInstance(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date remindStartDate = null; Calendar c = Calendar.getInstance();
Date remindEndDate = null; Date remindStartDate = null;
if(map.get("remindstart")!=null) { Date remindEndDate = null;
Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); if (map.get("remindstart") != null) {
c.setTime(new Date()); Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
c.add(Calendar.DAY_OF_MONTH,remindStart); c.setTime(new Date());
remindStartDate = c.getTime(); c.add(Calendar.DAY_OF_MONTH, remindStart); // 加上提醒天数
map.put("remindstart", sdf.format(remindStartDate)); remindStartDate = c.getTime();
} map.put("remindstart", sdf.format(remindStartDate)); // 格式化日期并放入请求参数
if(map.get("remindend")!=null) { }
Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); if (map.get("remindend") != null) {
c.setTime(new Date()); Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
c.add(Calendar.DAY_OF_MONTH,remindEnd); c.setTime(new Date());
remindEndDate = c.getTime(); c.add(Calendar.DAY_OF_MONTH, remindEnd); // 加上提醒天数
map.put("remindend", sdf.format(remindEndDate)); remindEndDate = c.getTime();
} map.put("remindend", sdf.format(remindEndDate)); // 格式化日期并放入请求参数
} }
}
Wrapper<ForumEntity> wrapper = new EntityWrapper<ForumEntity>();
if(map.get("remindstart")!=null) { // 构建查询条件
wrapper.ge(columnName, map.get("remindstart")); Wrapper<ForumEntity> wrapper = new EntityWrapper<ForumEntity>();
} if (map.get("remindstart") != null) {
if(map.get("remindend")!=null) { wrapper.ge(columnName, map.get("remindstart")); // 大于等于开始日期
wrapper.le(columnName, map.get("remindend")); }
} if (map.get("remindend") != null) {
wrapper.le(columnName, map.get("remindend")); // 小于等于结束日期
}
int count = forumService.selectCount(wrapper);
return R.ok().put("count", count); int count = forumService.selectCount(wrapper); // 查询数量
} return R.ok().put("count", count); // 返回数量
}
} }

330
src/main/java/com/controller/LeixingController.java
Unescape View File

@ -1,43 +1,43 @@
package com.controller; package com.controller;
import java.math.BigDecimal; import java.math.BigDecimal; // 导入BigDecimal以处理高精度数值
import java.text.SimpleDateFormat; import java.text.SimpleDateFormat;
import java.text.ParseException; import java.text.ParseException;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.Calendar; import java.util.Calendar;
import java.util.Map; import java.util.Map;
import java.util.HashMap; import java.util.HashMap;
import java.util.Iterator; import java.util.Iterator; // 导入迭代器接口
import java.util.Date; import java.util.Date;
import java.util.List; import java.util.List; // 导入List接口
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import java.io.IOException; import java.io.IOException;
import com.utils.ValidatorUtils; import com.utils.ValidatorUtils;
import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.StringUtils; // 导入Apache Commons Lang的字符串处理类
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import org.springframework.format.annotation.DateTimeFormat; import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RequestParam; // 导入请求参数注解
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.mapper.EntityWrapper; import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入MyBatis-Plus的EntityWrapper，用于构建查询条件
import com.baomidou.mybatisplus.mapper.Wrapper; import com.baomidou.mybatisplus.mapper.Wrapper; // 导入MyBatis-Plus的Wrapper接口
import com.annotation.IgnoreAuth; import com.annotation.IgnoreAuth;
import com.entity.LeixingEntity; import com.entity.LeixingEntity;
import com.entity.view.LeixingView; import com.entity.view.LeixingView; // 导入类型视图类
import com.service.LeixingService; import com.service.LeixingService; // 导入类型服务类
import com.service.TokenService; import com.service.TokenService;
import com.utils.PageUtils; import com.utils.PageUtils; // 导入分页工具类
import com.utils.R; import com.utils.R; // 导入响应工具类
import com.utils.MD5Util; import com.utils.MD5Util;
import com.utils.MPUtil; import com.utils.MPUtil; // 导入MyBatis-Plus工具类
import com.utils.CommonUtil; import com.utils.CommonUtil;
/** /**
* 类型 * 类型
@ -46,185 +46,201 @@ import com.utils.CommonUtil;
* @email * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
@RestController @RestController // 标记该类为REST控制器
@RequestMapping("/leixing") @RequestMapping("/leixing") // 设置基本请求路径为"/leixing"
public class LeixingController { public class LeixingController {
@Autowired @Autowired
private LeixingService leixingService; private LeixingService leixingService; // 自动注入类型服务
/** /**
* 后端列表 * 后端列表
* @param params 请求参数
* @param leixing 类型实体
* @param request HttpServletRequest对象
* @return 列表数据
*/ */
@RequestMapping("/page") @RequestMapping("/page") // 映射请求路径为"/page"
public R page(@RequestParam Map<String, Object> params,LeixingEntity leixing, public R page(@RequestParam Map<String, Object> params, LeixingEntity leixing,
HttpServletRequest request){ HttpServletRequest request) {
EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>(); EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>(); // 创建查询条件
PageUtils page = leixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, leixing), params), params)); // 查询分页数据
request.setAttribute("data", page); PageUtils page = leixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, leixing), params), params));
return R.ok().put("data", page); request.setAttribute("data", page); // 将数据设置到请求属性中
return R.ok().put("data", page);
} }
/** /**
* 前端列表 * 前端列表
* @param params 请求参数
* @param leixing 类型实体
* @param request HttpServletRequest对象
* @return 列表数据
*/ */
@IgnoreAuth @IgnoreAuth // 忽略身份验证
@RequestMapping("/list") @RequestMapping("/list") // 映射请求路径为"/list"
public R list(@RequestParam Map<String, Object> params,LeixingEntity leixing, public R list(@RequestParam Map<String, Object> params, LeixingEntity leixing,
HttpServletRequest request){ HttpServletRequest request) {
EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>(); EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>(); // 创建查询条件
PageUtils page = leixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, leixing), params), params)); // 查询分页数据
request.setAttribute("data", page); PageUtils page = leixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, leixing), params), params));
return R.ok().put("data", page); request.setAttribute("data", page); // 将数据设置到请求属性中
return R.ok().put("data", page);
} }
/** /**
* 列表 * 查询所有列表
* @param leixing 类型实体
* @return 查询结果
*/ */
@RequestMapping("/lists") @RequestMapping("/lists") // 映射请求路径为"/lists"
public R list( LeixingEntity leixing){ public R list(LeixingEntity leixing) {
EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>(); EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>(); // 创建查询条件
ew.allEq(MPUtil.allEQMapPre( leixing, "leixing")); ew.allEq(MPUtil.allEQMapPre(leixing, "leixing")); // 设置查询条件
return R.ok().put("data", leixingService.selectListView(ew)); return R.ok().put("data", leixingService.selectListView(ew));
} }
/** /**
* 查询 * 查询具体信息
* @param leixing 类型实体
* @return 查询结果
*/ */
@RequestMapping("/query") @RequestMapping("/query") // 映射请求路径为"/query"
public R query(LeixingEntity leixing){ public R query(LeixingEntity leixing) {
EntityWrapper< LeixingEntity> ew = new EntityWrapper< LeixingEntity>(); EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>(); // 创建查询条件
ew.allEq(MPUtil.allEQMapPre( leixing, "leixing")); ew.allEq(MPUtil.allEQMapPre(leixing, "leixing")); // 设置查询条件
LeixingView leixingView = leixingService.selectView(ew); LeixingView leixingView = leixingService.selectView(ew); // 查询类型视图
return R.ok("查询类型成功").put("data", leixingView); return R.ok("查询类型成功").put("data", leixingView);
} }
/** /**
* 后端详情 * 获取后端详情
* @param id 类型ID
* @return 类型信息
*/ */
@RequestMapping("/info/{id}") @RequestMapping("/info/{id}") // 映射请求路径为"/info/{id}"
public R info(@PathVariable("id") Long id){ public R info(@PathVariable("id") Long id) {
LeixingEntity leixing = leixingService.selectById(id); LeixingEntity leixing = leixingService.selectById(id); // 根据ID查询类型
return R.ok().put("data", leixing); return R.ok().put("data", leixing);
} }
/** /**
* 前端详情 * 获取前端详情
* @param id 类型ID
* @return 类型信息
*/ */
@IgnoreAuth @IgnoreAuth // 忽略身份验证
@RequestMapping("/detail/{id}") @RequestMapping("/detail/{id}") // 映射请求路径为"/detail/{id}"
public R detail(@PathVariable("id") Long id){ public R detail(@PathVariable("id") Long id) {
LeixingEntity leixing = leixingService.selectById(id); LeixingEntity leixing = leixingService.selectById(id); // 根据ID查询类型
return R.ok().put("data", leixing); return R.ok().put("data", leixing);
} }
/** /**
* 后端保存 * 后端保存类型信息
* @param leixing 类型实体
* @param request HttpServletRequest对象
* @return 保存结果
*/ */
@RequestMapping("/save") @RequestMapping("/save") // 映射请求路径为"/save"
public R save(@RequestBody LeixingEntity leixing, HttpServletRequest request){ public R save(@RequestBody LeixingEntity leixing, HttpServletRequest request) {
leixing.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); leixing.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); // 生成唯一ID
//ValidatorUtils.validateEntity(leixing); // ValidatorUtils.validateEntity(leixing); // 验证实体（可选择启用）
leixingService.insert(leixing); leixingService.insert(leixing); // 保存类型信息
return R.ok(); return R.ok();
} }
/** /**
* 前端保存 * 前端保存类型信息
* @param leixing 类型实体
* @param request HttpServletRequest对象
* @return 保存结果
*/ */
@RequestMapping("/add") @RequestMapping("/add") // 映射请求路径为"/add"
public R add(@RequestBody LeixingEntity leixing, HttpServletRequest request){ public R add(@RequestBody LeixingEntity leixing, HttpServletRequest request) {
leixing.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); leixing.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); // 生成唯一ID
//ValidatorUtils.validateEntity(leixing); // ValidatorUtils.validateEntity(leixing); // 验证实体（可选择启用）
leixingService.insert(leixing); leixingService.insert(leixing); // 保存类型信息
return R.ok(); return R.ok();
} }
/** /**
* 修改 * 修改类型信息
* @param leixing 类型实体
* @param request HttpServletRequest对象
* @return 修改结果
*/ */
@RequestMapping("/update") @RequestMapping("/update") // 映射请求路径为"/update"
@Transactional @Transactional // 开启事务
public R update(@RequestBody LeixingEntity leixing, HttpServletRequest request){ public R update(@RequestBody LeixingEntity leixing, HttpServletRequest request) {
//ValidatorUtils.validateEntity(leixing); // ValidatorUtils.validateEntity(leixing); // 验证实体（可选择启用）
leixingService.updateById(leixing);//全部更新 leixingService.updateById(leixing); // 更新类型信息
return R.ok(); return R.ok();
} }
/** /**
* 删除 * 删除类型
* @param ids 类型ID数组
* @return 删除结果
*/ */
@RequestMapping("/delete") @RequestMapping("/delete") // 映射请求路径为"/delete"
public R delete(@RequestBody Long[] ids){ public R delete(@RequestBody Long[] ids) {
leixingService.deleteBatchIds(Arrays.asList(ids)); leixingService.deleteBatchIds(Arrays.asList(ids)); // 批量删除类型
return R.ok(); return R.ok();
} }
/** /**
* 提醒接口 * 提醒接口
* @param columnName 列名
* @param type 类型
* @param map 查询参数
* @param request HttpServletRequest对象
* @return 提醒数量
*/ */
@RequestMapping("/remind/{columnName}/{type}") @RequestMapping("/remind/{columnName}/{type}") // 映射请求路径为"/remind/{columnName}/{type}"
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@PathVariable("type") String type,@RequestParam Map<String, Object> map) { @PathVariable("type") String type, @RequestParam Map<String, Object> map) {
map.put("column", columnName); map.put("column", columnName); // 将列名放入请求参数
map.put("type", type); map.put("type", type); // 将类型放入请求参数
if(type.equals("2")) { // 如果类型为2，进行日期提醒处理
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); if (type.equals("2")) {
Calendar c = Calendar.getInstance(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date remindStartDate = null; Calendar c = Calendar.getInstance();
Date remindEndDate = null; Date remindStartDate = null;
if(map.get("remindstart")!=null) { Date remindEndDate = null;
Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); // 处理提醒开始时间
c.setTime(new Date()); if (map.get("remindstart") != null) {
c.add(Calendar.DAY_OF_MONTH,remindStart); Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
remindStartDate = c.getTime(); c.setTime(new Date());
map.put("remindstart", sdf.format(remindStartDate)); c.add(Calendar.DAY_OF_MONTH, remindStart); // 添加提醒天数
} remindStartDate = c.getTime(); // 获取新的开始日期
if(map.get("remindend")!=null) { map.put("remindstart", sdf.format(remindStartDate)); // 格式化并放入请求参数
Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); }
c.setTime(new Date()); // 处理提醒结束时间
c.add(Calendar.DAY_OF_MONTH,remindEnd); if (map.get("remindend") != null) {
remindEndDate = c.getTime(); Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
map.put("remindend", sdf.format(remindEndDate)); c.setTime(new Date());
} c.add(Calendar.DAY_OF_MONTH, remindEnd); // 添加提醒天数
} remindEndDate = c.getTime(); // 获取新的结束日期
map.put("remindend", sdf.format(remindEndDate)); // 格式化并放入请求参数
Wrapper<LeixingEntity> wrapper = new EntityWrapper<LeixingEntity>(); }
if(map.get("remindstart")!=null) { }
wrapper.ge(columnName, map.get("remindstart"));
} // 构建查询条件
if(map.get("remindend")!=null) { Wrapper<LeixingEntity> wrapper = new EntityWrapper<LeixingEntity>();
wrapper.le(columnName, map.get("remindend")); if (map.get("remindstart") != null) {
} wrapper.ge(columnName, map.get("remindstart")); // 大于等于开始日期
}
if (map.get("remindend") != null) {
int count = leixingService.selectCount(wrapper); wrapper.le(columnName, map.get("remindend")); // 小于等于结束日期
return R.ok().put("count", count); }
}
int count = leixingService.selectCount(wrapper); // 查询数量
return R.ok().put("count", count); // 返回数量
}
} }

371
src/main/java/com/controller/WenjuandiaochaController.java
Unescape View File

@ -52,331 +52,240 @@ import com.entity.StoreupEntity;
@RequestMapping("/wenjuandiaocha") @RequestMapping("/wenjuandiaocha")
public class WenjuandiaochaController { public class WenjuandiaochaController {
@Autowired @Autowired
private WenjuandiaochaService wenjuandiaochaService; private WenjuandiaochaService wenjuandiaochaService; // 注入问卷调查服务
@Autowired @Autowired
private StoreupService storeupService; private StoreupService storeupService; // 注入收藏服务
/** /**
* 后端列表 * 提醒接口
*/
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params,WenjuandiaochaEntity wenjuandiaocha,
HttpServletRequest request){
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
PageUtils page = wenjuandiaochaService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params));
request.setAttribute("data", page);
return R.ok().put("data", page);
}
/**
* 前端列表
*/
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params,WenjuandiaochaEntity wenjuandiaocha,
HttpServletRequest request){
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
PageUtils page = wenjuandiaochaService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params));
request.setAttribute("data", page);
return R.ok().put("data", page);
}
/**
* 列表
*/ */
@RequestMapping("/lists") @RequestMapping("/remind/{columnName}/{type}")
public R list( WenjuandiaochaEntity wenjuandiaocha){ public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>(); @PathVariable("type") String type, @RequestParam Map<String, Object> map) {
ew.allEq(MPUtil.allEQMapPre( wenjuandiaocha, "wenjuandiaocha")); // 将列名和类型添加到 map 中
return R.ok().put("data", wenjuandiaochaService.selectListView(ew)); 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;
// 处理 remindstart 参数
if (map.get("remindstart") != null) {
Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); // 将 remindstart 转换为整数
c.setTime(new Date()); // 设置当前时间
c.add(Calendar.DAY_OF_MONTH, remindStart); // 添加 remindStart 天
remindStartDate = c.getTime(); // 获取新的开始日期
map.put("remindstart", sdf.format(remindStartDate)); // 格式化并添加到 map 中
}
// 处理 remindend 参数
if (map.get("remindend") != null) {
Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); // 将 remindend 转换为整数
c.setTime(new Date()); // 设置当前时间
c.add(Calendar.DAY_OF_MONTH, remindEnd); // 添加 remindEnd 天
remindEndDate = c.getTime(); // 获取新的结束日期
map.put("remindend", sdf.format(remindEndDate)); // 格式化并添加到 map 中
}
}
// 创建 EntityWrapper 对象，用于构建查询条件
Wrapper<WenjuandiaochaEntity> wrapper = new EntityWrapper<WenjuandiaochaEntity>();
if (map.get("remindstart") != null) {
wrapper.ge(columnName, map.get("remindstart")); // 大于等于 remindstart
}
if (map.get("remindend") != null) {
wrapper.le(columnName, map.get("remindend")); // 小于等于 remindend
}
/** // 查询符合条件的记录数
* 查询 int count = wenjuandiaochaService.selectCount(wrapper);
*/ return R.ok().put("count", count); // 返回记录数
@RequestMapping("/query")
public R query(WenjuandiaochaEntity wenjuandiaocha){
EntityWrapper< WenjuandiaochaEntity> ew = new EntityWrapper< WenjuandiaochaEntity>();
ew.allEq(MPUtil.allEQMapPre( wenjuandiaocha, "wenjuandiaocha"));
WenjuandiaochaView wenjuandiaochaView = wenjuandiaochaService.selectView(ew);
return R.ok("查询问卷调查成功").put("data", wenjuandiaochaView);
} }
/** /**
* 后端详情
*/
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id){
WenjuandiaochaEntity wenjuandiaocha = wenjuandiaochaService.selectById(id);
wenjuandiaocha.setClicktime(new Date());
wenjuandiaochaService.updateById(wenjuandiaocha);
return R.ok().put("data", wenjuandiaocha);
}
/**
* 前端详情
*/
@IgnoreAuth
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id){
WenjuandiaochaEntity wenjuandiaocha = wenjuandiaochaService.selectById(id);
wenjuandiaocha.setClicktime(new Date());
wenjuandiaochaService.updateById(wenjuandiaocha);
return R.ok().put("data", wenjuandiaocha);
}
/**
* 后端保存
*/
@RequestMapping("/save")
public R save(@RequestBody WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request){
wenjuandiaocha.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
//ValidatorUtils.validateEntity(wenjuandiaocha);
wenjuandiaochaService.insert(wenjuandiaocha);
return R.ok();
}
/**
* 前端保存
*/
@RequestMapping("/add")
public R add(@RequestBody WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request){
wenjuandiaocha.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
//ValidatorUtils.validateEntity(wenjuandiaocha);
wenjuandiaochaService.insert(wenjuandiaocha);
return R.ok();
}
/**
* 修改
*/
@RequestMapping("/update")
@Transactional
public R update(@RequestBody WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request){
//ValidatorUtils.validateEntity(wenjuandiaocha);
wenjuandiaochaService.updateById(wenjuandiaocha);//全部更新
return R.ok();
}
/**
* 删除
*/
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids){
wenjuandiaochaService.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<String, Object> 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<WenjuandiaochaEntity> wrapper = new EntityWrapper<WenjuandiaochaEntity>();
if(map.get("remindstart")!=null) {
wrapper.ge(columnName, map.get("remindstart"));
}
if(map.get("remindend")!=null) {
wrapper.le(columnName, map.get("remindend"));
}
int count = wenjuandiaochaService.selectCount(wrapper);
return R.ok().put("count", count);
}
/**
* 前端智能排序 * 前端智能排序
*/ */
@IgnoreAuth @IgnoreAuth // 忽略认证
@RequestMapping("/autoSort") @RequestMapping("/autoSort")
public R autoSort(@RequestParam Map<String, Object> params,WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request,String pre){ public R autoSort(@RequestParam Map<String, Object> params, WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request, String pre) {
// 创建 EntityWrapper 对象，用于构建查询条件
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>(); EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
Map<String, Object> newMap = new HashMap<String, Object>(); Map<String, Object> newMap = new HashMap<String, Object>();
Map<String, Object> param = new HashMap<String, Object>(); Map<String, Object> param = new HashMap<String, Object>();
Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator(); Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
while (it.hasNext()) { while (it.hasNext()) {
Map.Entry<String, Object> entry = it.next(); Map.Entry<String, Object> entry = it.next();
String key = entry.getKey(); String key = entry.getKey();
String newKey = entry.getKey(); String newKey = entry.getKey();
if (pre.endsWith(".")) {
newMap.put(pre + newKey, entry.getValue()); // 处理 pre 参数
} else if (StringUtils.isEmpty(pre)) { if (pre.endsWith(".")) {
newMap.put(newKey, entry.getValue()); newMap.put(pre + newKey, entry.getValue());
} else { } else if (StringUtils.isEmpty(pre)) {
newMap.put(pre + "." + newKey, entry.getValue()); newMap.put(newKey, entry.getValue());
} } else {
} newMap.put(pre + "." + newKey, entry.getValue());
params.put("sort", "clicktime"); }
}
// 设置排序条件
params.put("sort", "clicktime");
params.put("order", "desc"); params.put("order", "desc");
PageUtils page = wenjuandiaochaService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params));
return R.ok().put("data", page); // 查询分页数据
PageUtils page = wenjuandiaochaService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params));
return R.ok().put("data", page); // 返回分页数据
} }
/** /**
* 协同算法（按收藏推荐） * 协同算法（按收藏推荐）
*/ */
@RequestMapping("/autoSort2") @RequestMapping("/autoSort2")
public R autoSort2(@RequestParam Map<String, Object> params,WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request){ public R autoSort2(@RequestParam Map<String, Object> params, WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request) {
// 获取用户 ID
String userId = request.getSession().getAttribute("userId").toString(); String userId = request.getSession().getAttribute("userId").toString();
String inteltypeColumn = "leixing"; String inteltypeColumn = "leixing"; // 定义智能类型列名
List<StoreupEntity> storeups = storeupService.selectList(new EntityWrapper<StoreupEntity>().eq("type", 1).eq("userid", userId).eq("tablename", "wenjuandiaocha").orderBy("addtime", false)); List<StoreupEntity> storeups = storeupService.selectList(new EntityWrapper<StoreupEntity>().eq("type", 1).eq("userid", userId).eq("tablename", "wenjuandiaocha").orderBy("addtime", false));
List<String> inteltypes = new ArrayList<String>(); List<String> inteltypes = new ArrayList<String>();
Integer limit = params.get("limit")==null?10:Integer.parseInt(params.get("limit").toString()); Integer limit = params.get("limit") == null ? 10 : Integer.parseInt(params.get("limit").toString()); // 设置限制数量，默认为 10
List<WenjuandiaochaEntity> wenjuandiaochaList = new ArrayList<WenjuandiaochaEntity>(); List<WenjuandiaochaEntity> wenjuandiaochaList = new ArrayList<WenjuandiaochaEntity>();
//去重
if(storeups!=null && storeups.size()>0) { // 去重
for(StoreupEntity s : storeups) { if (storeups != null && storeups.size() > 0) {
for (StoreupEntity s : storeups) {
wenjuandiaochaList.addAll(wenjuandiaochaService.selectList(new EntityWrapper<WenjuandiaochaEntity>().eq(inteltypeColumn, s.getInteltype()))); wenjuandiaochaList.addAll(wenjuandiaochaService.selectList(new EntityWrapper<WenjuandiaochaEntity>().eq(inteltypeColumn, s.getInteltype())));
} }
} }
// 创建 EntityWrapper 对象，用于构建查询条件
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>(); EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
params.put("sort", "id"); params.put("sort", "id");
params.put("order", "desc"); params.put("order", "desc");
// 查询分页数据
PageUtils page = wenjuandiaochaService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params)); PageUtils page = wenjuandiaochaService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params));
List<WenjuandiaochaEntity> pageList = (List<WenjuandiaochaEntity>)page.getList(); List<WenjuandiaochaEntity> pageList = (List<WenjuandiaochaEntity>) page.getList();
if(wenjuandiaochaList.size()<limit) {
int toAddNum = (limit-wenjuandiaochaList.size())<=pageList.size()?(limit-wenjuandiaochaList.size()):pageList.size(); // 如果结果数量小于限制数量，则从分页数据中添加
for(WenjuandiaochaEntity o1 : pageList) { if (wenjuandiaochaList.size() < limit) {
int toAddNum = (limit - wenjuandiaochaList.size()) <= pageList.size() ? (limit - wenjuandiaochaList.size()) : pageList.size();
for (WenjuandiaochaEntity o1 : pageList) {
boolean addFlag = true; boolean addFlag = true;
for(WenjuandiaochaEntity o2 : wenjuandiaochaList) { for (WenjuandiaochaEntity o2 : wenjuandiaochaList) {
if(o1.getId().intValue()==o2.getId().intValue()) { if (o1.getId().intValue() == o2.getId().intValue()) {
addFlag = false; addFlag = false;
break; break;
} }
} }
if(addFlag) { if (addFlag) {
wenjuandiaochaList.add(o1); wenjuandiaochaList.add(o1);
if(--toAddNum==0) break; if (--toAddNum == 0) break;
} }
} }
} else if(wenjuandiaochaList.size()>limit) { } else if (wenjuandiaochaList.size() > limit) {
wenjuandiaochaList = wenjuandiaochaList.subList(0, limit); wenjuandiaochaList = wenjuandiaochaList.subList(0, limit); // 如果结果数量大于限制数量，则截取前 limit 个
} }
page.setList(wenjuandiaochaList);
return R.ok().put("data", page); page.setList(wenjuandiaochaList); // 设置新的列表
return R.ok().put("data", page); // 返回分页数据
} }
/** /**
* （按值统计） * （按值统计）
*/ */
@RequestMapping("/value/{xColumnName}/{yColumnName}") @RequestMapping("/value/{xColumnName}/{yColumnName}")
public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName,HttpServletRequest request) { public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, HttpServletRequest request) {
Map<String, Object> params = new HashMap<String, Object>(); Map<String, Object> params = new HashMap<String, Object>();
params.put("xColumn", xColumnName); params.put("xColumn", xColumnName);
params.put("yColumn", yColumnName); params.put("yColumn", yColumnName);
// 创建 EntityWrapper 对象，用于构建查询条件
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>(); EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
// 查询统计结果
List<Map<String, Object>> result = wenjuandiaochaService.selectValue(params, ew); List<Map<String, Object>> result = wenjuandiaochaService.selectValue(params, ew);
// 处理日期格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for(Map<String, Object> m : result) { for (Map<String, Object> m : result) {
for(String k : m.keySet()) { for (String k : m.keySet()) {
if(m.get(k) instanceof Date) { if (m.get(k) instanceof Date) {
m.put(k, sdf.format((Date)m.get(k))); m.put(k, sdf.format((Date) m.get(k)));
} }
} }
} }
return R.ok().put("data", result); return R.ok().put("data", result); // 返回统计结果
} }
/** /**
* （按值统计）时间统计类型 * （按值统计）时间统计类型
*/ */
@RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}") @RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}")
public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType,HttpServletRequest request) { public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType, HttpServletRequest request) {
Map<String, Object> params = new HashMap<String, Object>(); Map<String, Object> params = new HashMap<String, Object>();
params.put("xColumn", xColumnName); params.put("xColumn", xColumnName);
params.put("yColumn", yColumnName); params.put("yColumn", yColumnName);
params.put("timeStatType", timeStatType); params.put("timeStatType", timeStatType);
// 创建 EntityWrapper 对象，用于构建查询条件
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>(); EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
// 查询时间统计结果
List<Map<String, Object>> result = wenjuandiaochaService.selectTimeStatValue(params, ew); List<Map<String, Object>> result = wenjuandiaochaService.selectTimeStatValue(params, ew);
// 处理日期格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for(Map<String, Object> m : result) { for (Map<String, Object> m : result) {
for(String k : m.keySet()) { for (String k : m.keySet()) {
if(m.get(k) instanceof Date) { if (m.get(k) instanceof Date) {
m.put(k, sdf.format((Date)m.get(k))); m.put(k, sdf.format((Date) m.get(k)));
} }
} }
} }
return R.ok().put("data", result); return R.ok().put("data", result); // 返回时间统计结果
} }
/** /**
* 分组统计 * 分组统计
*/ */
@RequestMapping("/group/{columnName}") @RequestMapping("/group/{columnName}")
public R group(@PathVariable("columnName") String columnName,HttpServletRequest request) { public R group(@PathVariable("columnName") String columnName, HttpServletRequest request) {
Map<String, Object> params = new HashMap<String, Object>(); Map<String, Object> params = new HashMap<String, Object>();
params.put("column", columnName); params.put("column", columnName);
// 创建 EntityWrapper 对象，用于构建查询条件
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>(); EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
// 查询分组统计结果
List<Map<String, Object>> result = wenjuandiaochaService.selectGroup(params, ew); List<Map<String, Object>> result = wenjuandiaochaService.selectGroup(params, ew);
// 处理日期格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for(Map<String, Object> m : result) { for (Map<String, Object> m : result) {
for(String k : m.keySet()) { for (String k : m.keySet()) {
if(m.get(k) instanceof Date) { if (m.get(k) instanceof Date) {
m.put(k, sdf.format((Date)m.get(k))); m.put(k, sdf.format((Date) m.get(k)));
} }
} }
} }
return R.ok().put("data", result); return R.ok().put("data", result); // 返回分组统计结果
} }
/** /**
* 总数量 * 总数量
*/ */
@RequestMapping("/count") @RequestMapping("/count")
public R count(@RequestParam Map<String, Object> params,WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request){ public R count(@RequestParam Map<String, Object> params, WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request) {
// 创建 EntityWrapper 对象，用于构建查询条件
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>(); EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
// 查询符合条件的记录数
int count = wenjuandiaochaService.selectCount(MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params)); int count = wenjuandiaochaService.selectCount(MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params));
return R.ok().put("data", count); return R.ok().put("data", count); // 返回记录数
} }
} }

11
src/main/java/com/dao/ConfigDao.java
Unescape View File

@ -1,12 +1,15 @@
package com.dao; package com.dao;
import com.baomidou.mybatisplus.mapper.BaseMapper; import com.baomidou.mybatisplus.mapper.BaseMapper; // 导入MyBatis-Plus的BaseMapper接口
import com.entity.ConfigEntity; import com.entity.ConfigEntity; // 导入配置实体类
/** /**
* 配置 * 配置 DAO 接口
* 该接口用于数据访问层，对ConfigEntity实体的数据库操作
*/ */
public interface ConfigDao extends BaseMapper<ConfigEntity> { public interface ConfigDao extends BaseMapper<ConfigEntity> {
// ConfigDao接口继承了BaseMapper接口，意味着它自动获得了CRUD方法
// 可以根据需要在此处添加自定义的方法
} }

64
src/main/java/com/dao/ForumDao.java
Unescape View File

@ -1,35 +1,59 @@
package com.dao; package com.dao;
import com.entity.ForumEntity; import com.entity.ForumEntity; // 导入论坛实体类
import com.baomidou.mybatisplus.mapper.BaseMapper; import com.baomidou.mybatisplus.mapper.BaseMapper; // 导入MyBatis-Plus的BaseMapper接口
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import com.baomidou.mybatisplus.mapper.Wrapper; import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination; import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import com.entity.vo.ForumVO; import com.entity.vo.ForumVO; // 导入论坛VO类
import com.entity.view.ForumView; import com.entity.view.ForumView; // 导入论坛视图类
/** /**
* 论坛表 * 论坛表 DAO 接口
* 该接口用于数据访问层，对ForumEntity实体的数据库操作
* *
* @author * @author
* @email * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
public interface ForumDao extends BaseMapper<ForumEntity> { public interface ForumDao extends BaseMapper<ForumEntity> {
List<ForumVO> selectListVO(@Param("ew") Wrapper<ForumEntity> wrapper); /**
* 查询论坛列表，返回VO对象列表
ForumVO selectVO(@Param("ew") Wrapper<ForumEntity> wrapper); * @param wrapper 查询条件包装器
* @return 论坛VO对象列表
List<ForumView> selectListView(@Param("ew") Wrapper<ForumEntity> wrapper); */
List<ForumVO> selectListVO(@Param("ew") Wrapper<ForumEntity> wrapper);
List<ForumView> selectListView(Pagination page,@Param("ew") Wrapper<ForumEntity> wrapper);
/**
ForumView selectView(@Param("ew") Wrapper<ForumEntity> wrapper); * 查询单个论坛，返回VO对象
* @param wrapper 查询条件包装器
* @return 论坛VO对象
*/
ForumVO selectVO(@Param("ew") Wrapper<ForumEntity> wrapper);
/**
* 查询论坛列表，返回视图对象列表
* @param wrapper 查询条件包装器
* @return 论坛视图对象列表
*/
List<ForumView> selectListView(@Param("ew") Wrapper<ForumEntity> wrapper);
/**
* 分页查询论坛列表，返回视图对象列表
* @param page 分页对象
* @param wrapper 查询条件包装器
* @return 论坛视图对象列表
*/
List<ForumView> selectListView(Pagination page, @Param("ew") Wrapper<ForumEntity> wrapper);
/**
* 查询单个论坛，返回视图对象
* @param wrapper 查询条件包装器
* @return 论坛视图对象
*/
ForumView selectView(@Param("ew") Wrapper<ForumEntity> wrapper);
} }

66
src/main/java/com/dao/LeixingDao.java
Unescape View File

@ -1,35 +1,59 @@
package com.dao; package com.dao;
import com.entity.LeixingEntity; import com.entity.LeixingEntity;
import com.baomidou.mybatisplus.mapper.BaseMapper; import com.baomidou.mybatisplus.mapper.BaseMapper;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import com.baomidou.mybatisplus.mapper.Wrapper; import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination; import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import com.entity.vo.LeixingVO; import com.entity.vo.LeixingVO; // 导入类型VO类
import com.entity.view.LeixingView; import com.entity.view.LeixingView;
/** /**
* 类型 * 类型 DAO 接口
* 该接口用于与数据库交互，操作LeixingEntity实体
* *
* @author * @author
* @email * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
public interface LeixingDao extends BaseMapper<LeixingEntity> { public interface LeixingDao extends BaseMapper<LeixingEntity> {
List<LeixingVO> selectListVO(@Param("ew") Wrapper<LeixingEntity> wrapper); /**
* 查询类型列表，返回VO对象列表
LeixingVO selectVO(@Param("ew") Wrapper<LeixingEntity> wrapper); * @param wrapper 查询条件包装器
* @return 类型VO对象列表
List<LeixingView> selectListView(@Param("ew") Wrapper<LeixingEntity> wrapper); */
List<LeixingVO> selectListVO(@Param("ew") Wrapper<LeixingEntity> wrapper);
List<LeixingView> selectListView(Pagination page,@Param("ew") Wrapper<LeixingEntity> wrapper);
/**
LeixingView selectView(@Param("ew") Wrapper<LeixingEntity> wrapper); * 查询单个类型，返回VO对象
* @param wrapper 查询条件包装器
* @return 单个类型VO对象
*/
LeixingVO selectVO(@Param("ew") Wrapper<LeixingEntity> wrapper);
/**
* 查询类型列表，返回视图对象列表
* @param wrapper 查询条件包装器
* @return 类型视图对象列表
*/
List<LeixingView> selectListView(@Param("ew") Wrapper<LeixingEntity> wrapper);
/**
* 分页查询类型列表，返回视图对象列表
* @param page 分页对象
* @param wrapper 查询条件包装器
* @return 分页后的类型视图对象列表
*/
List<LeixingView> selectListView(Pagination page, @Param("ew") Wrapper<LeixingEntity> wrapper);
/**
* 查询单个类型，返回视图对象
* @param wrapper 查询条件包装器
* @return 单个类型视图对象
*/
LeixingView selectView(@Param("ew") Wrapper<LeixingEntity> wrapper);
} }

78
src/main/java/com/dao/WenjuandiaochaDao.java
Unescape View File

@ -13,31 +13,73 @@ import com.entity.view.WenjuandiaochaView;
/** /**
* 问卷调查 * 问卷调查数据访问对象接口
* * 该接口继承自BaseMapper，提供了基本的CRUD操作方法
* @author * @author 未填写具体作者
* @email * @email 未填写具体邮箱
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
public interface WenjuandiaochaDao extends BaseMapper<WenjuandiaochaEntity> { public interface WenjuandiaochaDao extends BaseMapper<WenjuandiaochaEntity> {
List<WenjuandiaochaVO> selectListVO(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
WenjuandiaochaVO selectVO(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
List<WenjuandiaochaView> selectListView(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
List<WenjuandiaochaView> selectListView(Pagination page,@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper); /**
* 根据条件查询问卷调查列表，并将结果转换为WenjuandiaochaVO对象列表
WenjuandiaochaView selectView(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper); * @param ew 查询条件封装对象
* @return 符合条件的问卷调查VO对象列表
*/
List<WenjuandiaochaVO> selectListVO(@Param("ew") Wrapper<WenjuandiaochaEntity> ew);
List<Map<String, Object>> selectValue(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper); /**
* 根据条件查询单个问卷调查记录，并将其转换为WenjuandiaochaVO对象
* @param ew 查询条件封装对象
* @return 符合条件的问卷调查VO对象
*/
WenjuandiaochaVO selectVO(@Param("ew") Wrapper<WenjuandiaochaEntity> ew);
List<Map<String, Object>> selectTimeStatValue(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper); /**
* 根据条件查询问卷调查列表，并将结果转换为WenjuandiaochaView对象列表
List<Map<String, Object>> selectGroup(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper); * @param ew 查询条件封装对象
* @return 符合条件的问卷调查View对象列表
*/
List<WenjuandiaochaView> selectListView(@Param("ew") Wrapper<WenjuandiaochaEntity> ew);
/**
* 根据条件和分页参数查询问卷调查列表，并将结果转换为WenjuandiaochaView对象列表
* @param page 分页参数对象
* @param ew 查询条件封装对象
* @return 分页后的符合条件的问卷调查View对象列表
*/
List<WenjuandiaochaView> selectListView(Pagination page, @Param("ew") Wrapper<WenjuandiaochaEntity> ew);
/**
* 根据条件查询单个问卷调查记录，并将其转换为WenjuandiaochaView对象
* @param ew 查询条件封装对象
* @return 符合条件的问卷调查View对象
*/
WenjuandiaochaView selectView(@Param("ew") Wrapper<WenjuandiaochaEntity> ew);
/**
* 根据自定义参数和条件查询数据库，并返回Map对象列表
* @param params 自定义查询参数
* @param ew 查询条件封装对象
* @return 符合条件的数据结果集，返回值为Map对象列表
*/
List<Map<String, Object>> selectValue(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<WenjuandiaochaEntity> ew);
/**
* 根据时间统计自定义参数和条件查询数据库，并返回Map对象列表
* @param params 自定义查询参数，可能包含时间范围等信息
* @param ew 查询条件封装对象
* @return 符合条件的时间统计数据结果集，返回值为Map对象列表
*/
List<Map<String, Object>> selectTimeStatValue(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<WenjuandiaochaEntity> ew);
/**
* 根据分组查询自定义参数和条件查询数据库，并返回Map对象列表
* @param params 自定义查询参数，可能包含分组依据等信息
* @param ew 查询条件封装对象
* @return 符合条件的分组数据结果集，返回值为Map对象列表
*/
List<Map<String, Object>> selectGroup(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<WenjuandiaochaEntity> ew);
} }

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

@ -9,25 +9,25 @@ import com.baomidou.mybatisplus.enums.IdType;
/** /**
* 类说明 : * 类说明 :
*/ */
@TableName("config") @TableName("config")// 指定该类对应的数据库表名为"config"
public class ConfigEntity implements Serializable{ public class ConfigEntity implements Serializable{
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
@TableId(type = IdType.AUTO) @TableId(type = IdType.AUTO) // 主键ID，使用自增长方式
private Long id; private Long id;
/** /**
* key * 配置项的名称（键）
*/ */
private String name; private String name;
/** /**
* value * 配置项的值
*/ */
private String value; private String value;
public Long getId() { public Long getId() {
return id; return id; // 返回配置ID
} }
public void setId(Long id) { public void setId(Long id) {
@ -39,7 +39,7 @@ private static final long serialVersionUID = 1L;
} }
public void setName(String name) { public void setName(String name) {
this.name = name; this.name = name;//设置配置名称
} }
public String getValue() { public String getValue() {
@ -47,7 +47,7 @@ private static final long serialVersionUID = 1L;
} }
public void setValue(String value) { public void setValue(String value) {
this.value = value; this.value = value;// 设置配置值
} }
} }

32
src/main/java/com/entity/ForumEntity.java
Unescape View File

@ -16,6 +16,8 @@ import java.util.List;
import org.springframework.format.annotation.DateTimeFormat; import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.annotation.JsonFormat;
import org.apache.commons.beanutils.BeanUtils; import org.apache.commons.beanutils.BeanUtils;
import org.apache.poi.ss.formula.functions.T;
import com.baomidou.mybatisplus.annotations.TableField; import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.enums.FieldFill; import com.baomidou.mybatisplus.enums.FieldFill;
import com.baomidou.mybatisplus.enums.IdType; import com.baomidou.mybatisplus.enums.IdType;
@ -37,14 +39,15 @@ public class ForumEntity<T> implements Serializable {
} }
public ForumEntity(T t) { // 接收ForumEntity对象的构造函数
try { public ForumEntity(T t) {
BeanUtils.copyProperties(this, t); try {
} catch (IllegalAccessException | InvocationTargetException e) { // 复制属性，将传入对象的属性复制到当前对象
// TODO Auto-generated catch block BeanUtils.copyProperties(this, t);
e.printStackTrace(); } catch (IllegalAccessException | InvocationTargetException e) {
} // 异常处理，打印堆栈信息
} e.printStackTrace();
}
/** /**
* 主键id * 主键id
@ -99,10 +102,10 @@ public class ForumEntity<T> implements Serializable {
private Date addtime; private Date addtime;
public Date getAddtime() { public Date getAddtime() {
return addtime; return addtime;// 返回添加时间
} }
public void setAddtime(Date addtime) { public void setAddtime(Date addtime) {
this.addtime = addtime; this.addtime = addtime;// 设置添加时间
} }
public Long getId() { public Long getId() {
@ -110,9 +113,12 @@ public class ForumEntity<T> implements Serializable {
} }
public void setId(Long id) { public void setId(Long id) {
this.id = id; this.id = id;// 设置帖子ID
} }
@TableField(exist = false) /**
* 存放子帖子的列表
*/
@TableField(exist = false) // 该字段不在数据库表中存在
private List<ForumEntity> childs; private List<ForumEntity> childs;
public List<ForumEntity> getChilds() { public List<ForumEntity> getChilds() {
@ -120,7 +126,7 @@ public class ForumEntity<T> implements Serializable {
} }
public void setChilds(List<ForumEntity> childs) { public void setChilds(List<ForumEntity> childs) {
this.childs = childs; this.childs = childs;// 设置子帖子
} }
/** /**
* 设置：帖子标题 * 设置：帖子标题

16
src/main/java/com/entity/LeixingEntity.java
Unescape View File

@ -16,6 +16,8 @@ import java.util.List;
import org.springframework.format.annotation.DateTimeFormat; import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.annotation.JsonFormat;
import org.apache.commons.beanutils.BeanUtils; import org.apache.commons.beanutils.BeanUtils;
import org.apache.poi.ss.formula.functions.T;
import com.baomidou.mybatisplus.annotations.TableField; import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.enums.FieldFill; import com.baomidou.mybatisplus.enums.FieldFill;
import com.baomidou.mybatisplus.enums.IdType; import com.baomidou.mybatisplus.enums.IdType;
@ -37,11 +39,13 @@ public class LeixingEntity<T> implements Serializable {
} }
// 接收LeixingEntity对象的构造函数
public LeixingEntity(T t) { public LeixingEntity(T t) {
try { try {
// 复制属性，将传入对象的属性复制到当前对象
BeanUtils.copyProperties(this, t); BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block // 异常处理，打印堆栈信息
e.printStackTrace(); e.printStackTrace();
} }
} }
@ -58,15 +62,15 @@ public class LeixingEntity<T> implements Serializable {
private String leixing; private String leixing;
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")// 指定JSON格式化
@DateTimeFormat @DateTimeFormat// 用于Spring格式化
private Date addtime; private Date addtime;// 存放添加时间
public Date getAddtime() { public Date getAddtime() {
return addtime; return addtime;
} }
public void setAddtime(Date addtime) { public void setAddtime(Date addtime) {
this.addtime = addtime; this.addtime = addtime;// 设置添加时间
} }
public Long getId() { public Long getId() {
@ -74,7 +78,7 @@ public class LeixingEntity<T> implements Serializable {
} }
public void setId(Long id) { public void setId(Long id) {
this.id = id; this.id = id;// 设置类型ID
} }
/** /**
* 设置：类型 * 设置：类型

265
src/main/java/com/entity/WenjuandiaochaEntity.java
Unescape View File

@ -3,7 +3,6 @@ package com.entity;
import com.baomidou.mybatisplus.annotations.TableId; import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName; import com.baomidou.mybatisplus.annotations.TableName;
import javax.validation.constraints.NotBlank; import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull; import javax.validation.constraints.NotNull;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
@ -11,37 +10,39 @@ import java.lang.reflect.InvocationTargetException;
import java.io.Serializable; import java.io.Serializable;
import java.util.Date; import java.util.Date;
import java.util.List;
import org.springframework.format.annotation.DateTimeFormat; import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.annotation.JsonFormat;
import org.apache.commons.beanutils.BeanUtils; import org.apache.commons.beanutils.BeanUtils;
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.enums.FieldFill;
import com.baomidou.mybatisplus.enums.IdType;
/** /**
* 问卷调查 * 问卷调查
* 数据库通用操作实体类（普通增删改查） * 数据库通用操作实体类（普通增删改查）
* @author * @author 作者名
* @email * @email 邮箱地址
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
@TableName("wenjuandiaocha") @TableName("wenjuandiaocha") // 指定该实体类对应的数据库表名为“wenjuandiaocha”
public class WenjuandiaochaEntity<T> implements Serializable { @JsonIgnoreProperties(ignoreUnknown = true) // 忽略未知属性，防止反序列化时出现错误
private static final long serialVersionUID = 1L; public class WenjuandiaochaEntity<T> implements Serializable { // 实现Serializable接口以支持序列化
private static final long serialVersionUID = 1L; // 序列化版本号
/**
* 无参构造函数
*/
public WenjuandiaochaEntity() { public WenjuandiaochaEntity() {
} }
/**
* 带泛型参数的构造函数，用于从传入的对象t中复制属性值
* @param t 传入的对象，其属性将被复制到当前实体对象中
*/
public WenjuandiaochaEntity(T t) { public WenjuandiaochaEntity(T t) {
try { try {
BeanUtils.copyProperties(this, t); BeanUtils.copyProperties(this, t); // 使用BeanUtils工具类复制属性
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block // 打印堆栈跟踪信息以便调试
e.printStackTrace(); e.printStackTrace();
} }
} }
@ -49,210 +50,274 @@ public class WenjuandiaochaEntity<T> implements Serializable {
/** /**
* 主键id * 主键id
*/ */
@TableId @TableId // 指定该字段为主键
private Long id; private Long id;
/** /**
* 问卷标题 * 问卷标题
* 使用NotBlank注解确保问卷标题不为空字符串
*/ */
@NotBlank(message = "问卷标题不能为空")
private String wenjuanbiaoti; private String wenjuanbiaoti;
/** /**
* 封面图片 * 封面图片
* 使用NotBlank注解确保封面图片路径不为空字符串
*/ */
@NotBlank(message = "封面图片路径不能为空")
private String fengmiantupian; private String fengmiantupian;
/** /**
* 类型 * 类型
* 使用NotBlank注解确保类型不为空字符串
*/ */
@NotBlank(message = "类型不能为空")
private String leixing; private String leixing;
/** /**
* 问题一 * 问题一
* 使用NotBlank注解确保问题一不为空字符串
*/ */
@NotBlank(message = "问题一不能为空")
private String wentiyi; private String wentiyi;
/** /**
* 问题二 * 问题二
* 使用NotBlank注解确保问题二不为空字符串
*/ */
@NotBlank(message = "问题二不能为空")
private String wentier; private String wentier;
/** /**
* 问题三 * 问题三
* 使用NotBlank注解确保问题三不为空字符串
*/ */
@NotBlank(message = "问题三不能为空")
private String wentisan; private String wentisan;
/** /**
* 问题四 * 问题四
* 使用NotBlank注解确保问题四不为空字符串
*/ */
@NotBlank(message = "问题四不能为空")
private String wentisi; private String wentisi;
/** /**
* 问题五 * 问题五
* 使用NotBlank注解确保问题五不为空字符串
*/ */
@NotBlank(message = "问题五不能为空")
private String wentiwu; private String wentiwu;
/** /**
* 发布日期 * 发布日期
* 使用JsonFormat注解指定日期格式为“yyyy-MM-dd HH:mm:ss”，时区为东八区
* 使用DateTimeFormat注解指定日期格式为“yyyy-MM-dd HH:mm:ss”，用于处理请求参数中的日期格式
* 使用NotNull注解确保发布日期不为null
*/ */
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd") @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat @NotNull(message = "发布日期不能为空")
private Date faburiqi; private Date faburiqi;
/** /**
* 最近点击时间 * 最近点击时间
* 使用JsonFormat注解指定日期格式为“yyyy-MM-dd HH:mm:ss”，时区为东八区
* 使用DateTimeFormat注解指定日期格式为“yyyy-MM-dd HH:mm:ss”，用于处理请求参数中的日期格式
*/ */
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date clicktime; private Date clicktime;
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date addtime;
public Date getAddtime() { /**
return addtime; * 设置：添加时间
} * @param addtime 问卷的添加时间
*/
public void setAddtime(Date addtime) { public void setAddtime(Date addtime) {
this.addtime = addtime; this.addtime = addtime;
} }
public Long getId() { /**
return id; * 获取：添加时间
* @return 问卷的添加时间
*/
public Date getAddtime() {
return addtime;
} }
/**
* 设置：主键id
* @param id 主键id
*/
public void setId(Long id) { public void setId(Long id) {
this.id = id; this.id = id;
} }
/**
* 设置：问卷标题 /**
*/ * 获取：主键id
* @return 主键id
*/
public Long getId() {
return id;
}
/**
* 设置：问卷标题
* @param wenjuanbiaoti 问卷标题
*/
public void setWenjuanbiaoti(String wenjuanbiaoti) { public void setWenjuanbiaoti(String wenjuanbiaoti) {
this.wenjuanbiaoti = wenjuanbiaoti; this.wenjuanbiaoti = wenjuanbiaoti;
} }
/**
* 获取：问卷标题 /**
*/ * 获取：问卷标题
* @return 问卷标题
*/
public String getWenjuanbiaoti() { public String getWenjuanbiaoti() {
return wenjuanbiaoti; return wenjuanbiaoti;
} }
/**
* 设置：封面图片 /**
*/ * 设置：封面图片
* @param fengmiantupian 封面图片路径
*/
public void setFengmiantupian(String fengmiantupian) { public void setFengmiantupian(String fengmiantupian) {
this.fengmiantupian = fengmiantupian; this.fengmiantupian = fengmiantupian;
} }
/**
* 获取：封面图片 /**
*/ * 获取：封面图片
* @return 封面图片路径
*/
public String getFengmiantupian() { public String getFengmiantupian() {
return fengmiantupian; return fengmiantupian;
} }
/**
* 设置：类型 /**
*/ * 设置：类型
* @param leixing 问卷类型
*/
public void setLeixing(String leixing) { public void setLeixing(String leixing) {
this.leixing = leixing; this.leixing = leixing;
} }
/**
* 获取：类型 /**
*/ * 获取：类型
* @return 问卷类型
*/
public String getLeixing() { public String getLeixing() {
return leixing; return leixing;
} }
/**
* 设置：问题一 /**
*/ * 设置：问题一
* @param wentiyi 问题一的内容
*/
public void setWentiyi(String wentiyi) { public void setWentiyi(String wentiyi) {
this.wentiyi = wentiyi; this.wentiyi = wentiyi;
} }
/**
* 获取：问题一 /**
*/ * 获取：问题一
* @return 问题一的内容
*/
public String getWentiyi() { public String getWentiyi() {
return wentiyi; return wentiyi;
} }
/**
* 设置：问题二 /**
*/ * 设置：问题二
* @param wentier 问题二的内容
*/
public void setWentier(String wentier) { public void setWentier(String wentier) {
this.wentier = wentier; this.wentier = wentier;
} }
/**
* 获取：问题二 /**
*/ * 获取：问题二
* @return 问题二的内容
*/
public String getWentier() { public String getWentier() {
return wentier; return wentier;
} }
/**
* 设置：问题三 /**
*/ * 设置：问题三
* @param wentisan 问题三的内容
*/
public void setWentisan(String wentisan) { public void setWentisan(String wentisan) {
this.wentisan = wentisan; this.wentisan = wentisan;
} }
/**
* 获取：问题三 /**
*/ * 获取：问题三
* @return 问题三的内容
*/
public String getWentisan() { public String getWentisan() {
return wentisan; return wentisan;
} }
/**
* 设置：问题四 /**
*/ * 设置：问题四
* @param wentisi 问题四的内容
*/
public void setWentisi(String wentisi) { public void setWentisi(String wentisi) {
this.wentisi = wentisi; this.wentisi = wentisi;
} }
/**
* 获取：问题四 /**
*/ * 获取：问题四
* @return 问题四的内容
*/
public String getWentisi() { public String getWentisi() {
return wentisi; return wentisi;
} }
/**
* 设置：问题五 /**
*/ * 设置：问题五
* @param wentiwu 问题五的内容
*/
public void setWentiwu(String wentiwu) { public void setWentiwu(String wentiwu) {
this.wentiwu = wentiwu; this.wentiwu = wentiwu;
} }
/**
* 获取：问题五 /**
*/ * 获取：问题五
* @return 问题五的内容
*/
public String getWentiwu() { public String getWentiwu() {
return wentiwu; return wentiwu;
} }
/**
* 设置：发布日期 /**
*/ * 设置：发布日期
* @param faburiqi 问卷的发布日期
*/
public void setFaburiqi(Date faburiqi) { public void setFaburiqi(Date faburiqi) {
this.faburiqi = faburiqi; this.faburiqi = faburiqi;
} }
/**
* 获取：发布日期 /**
*/ * 获取：发布日期
* @return 问卷的发布日期
*/
public Date getFaburiqi() { public Date getFaburiqi() {
return faburiqi; return faburiqi;
} }
/**
* 设置：最近点击时间 /**
*/ * 设置：最近点击时间
* @param clicktime 最近点击该问卷的时间
*/
public void setClicktime(Date clicktime) { public void setClicktime(Date clicktime) {
this.clicktime = clicktime; this.clicktime = clicktime;
} }
/**
* 获取：最近点击时间 /**
*/ * 获取：最近点击时间
* @return 最近点击该问卷的时间
*/
public Date getClicktime() { public Date getClicktime() {
return clicktime; return clicktime;
} }
} }

85
src/main/java/com/entity/model/ForumModel.java
Unescape View File

@ -1,157 +1,144 @@
package com.entity.model; package com.entity.model;
import com.entity.ForumEntity; import com.entity.ForumEntity;
import java.io.Serializable; // 导入可序列化接口
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
/** /**
* 论坛表 * 论坛表
* 接收传参的实体类 * 接收传参的实体类
*（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了） * （实际开发中配合移动端接口开发手动去掉些没用的字段，后端一般用entity就够用了）
* 取自ModelAndView 的model名称 * 取自ModelAndView的model名称
*
* @author * @author
* @email * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
public class ForumModel implements Serializable { public class ForumModel implements Serializable {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L; // 版本控制
/** /**
* 帖子内容 * 帖子内容
*/ */
private String content; // 存放帖子内容
private String content;
/** /**
* 父节点id * 父节点id
*/ */
private Long parentid; // 存放父节点ID
private Long parentid;
/** /**
* 用户id * 用户id
*/ */
private Long userid; // 存放用户ID
private Long userid;
/** /**
* 用户名 * 用户名
*/ */
private String username; // 存放用户名
private String username;
/** /**
* 头像 * 头像
*/ */
private String avatarurl; // 存放用户头像URL
private String avatarurl;
/** /**
* 状态 * 状态
*/ */
private String isdone; // 存放帖子状态（例如：已完成/未完成等）
private String isdone;
/** /**
* 设置：帖子内容 * 设置：帖子内容
* @param content 帖子内容
*/ */
public void setContent(String content) { public void setContent(String content) {
this.content = content; this.content = content; // 设置帖子内容
} }
/** /**
* 获取：帖子内容 * 获取：帖子内容
* @return 帖子内容
*/ */
public String getContent() { public String getContent() {
return content; return content;
} }
/** /**
* 设置：父节点id * 设置：父节点id
* @param parentid 父节点ID
*/ */
public void setParentid(Long parentid) { public void setParentid(Long parentid) {
this.parentid = parentid; this.parentid = parentid; // 设置父节点ID
} }
/** /**
* 获取：父节点id * 获取：父节点id
* @return 父节点ID
*/ */
public Long getParentid() { public Long getParentid() {
return parentid; return parentid; // 返回父节点ID
} }
/** /**
* 设置：用户id * 设置：用户id
* @param userid 用户ID
*/ */
public void setUserid(Long userid) { public void setUserid(Long userid) {
this.userid = userid; this.userid = userid; // 设置用户ID
} }
/** /**
* 获取：用户id * 获取：用户id
* @return 用户ID
*/ */
public Long getUserid() { public Long getUserid() {
return userid; return userid;
} }
/** /**
* 设置：用户名 * 设置：用户名
* @param username 用户名
*/ */
public void setUsername(String username) { public void setUsername(String username) {
this.username = username; this.username = username; // 设置用户名
} }
/** /**
* 获取：用户名 * 获取：用户名
* @return 用户名
*/ */
public String getUsername() { public String getUsername() {
return username; return username;
} }
/** /**
* 设置：头像 * 设置：头像
* @param avatarurl 头像URL
*/ */
public void setAvatarurl(String avatarurl) { public void setAvatarurl(String avatarurl) {
this.avatarurl = avatarurl; this.avatarurl = avatarurl; // 设置头像URL
} }
/** /**
* 获取：头像 * 获取：头像
* @return 头像URL
*/ */
public String getAvatarurl() { public String getAvatarurl() {
return avatarurl; return avatarurl;
} }
/** /**
* 设置：状态 * 设置：状态
* @param isdone 帖子状态
*/ */
public void setIsdone(String isdone) { public void setIsdone(String isdone) {
this.isdone = isdone; this.isdone = isdone; // 设置帖子状态
} }
/** /**
* 获取：状态 * 获取：状态
* @return 帖子状态
*/ */
public String getIsdone() { public String getIsdone() {
return isdone; return isdone;
} }
} }

4
src/main/java/com/entity/model/LeixingModel.java
Unescape View File

@ -19,7 +19,7 @@ import java.io.Serializable;
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
public class LeixingModel implements Serializable { public class LeixingModel implements Serializable {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;// 版本控制
// 可以根据需求定义属性，例如类型的名称、描述等
} }

104
src/main/java/com/entity/model/WenjuandiaochaModel.java
Unescape View File

@ -1,227 +1,195 @@
package com.entity.model; package com.entity.model;
import com.entity.WenjuandiaochaEntity; import com.entity.WenjuandiaochaEntity;
import com.baomidou.mybatisplus.annotations.TableName; import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date; import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat; import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable; import java.io.Serializable;
/** /**
* 问卷调查 * 问卷调查模型类
* 接收传参的实体类 * 该类用于接收传参，通常在实际开发中配合移动端接口开发时手动去掉一些不需要的字段
*（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了） * 取自ModelAndView的model名称
* 取自ModelAndView 的model名称 * @author 未填写具体作者
* @author * @email 未填写具体邮箱
* @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
public class WenjuandiaochaModel implements Serializable { public class WenjuandiaochaModel implements Serializable {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
/** /**
* 封面图片 * 封面图片
*/ */
private String fengmiantupian; private String fengmiantupian;
/** /**
* 类型 * 类型
*/ */
private String leixing; private String leixing;
/** /**
* 问题一 * 问题一
*/ */
private String wentiyi; private String wentiyi;
/** /**
* 问题二 * 问题二
*/ */
private String wentier; private String wentier;
/** /**
* 问题三 * 问题三
*/ */
private String wentisan; private String wentisan;
/** /**
* 问题四 * 问题四
*/ */
private String wentisi; private String wentisi;
/** /**
* 问题五 * 问题五
*/ */
private String wentiwu; private String wentiwu;
/** /**
* 发布日期 * 发布日期
*/ */
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") @DateTimeFormat
@DateTimeFormat
private Date faburiqi; private Date faburiqi;
/** /**
* 最近点击时间 * 最近点击时间
*/ */
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") @DateTimeFormat
@DateTimeFormat
private Date clicktime; private Date clicktime;
/** /**
* 设置：封面图片 * 设置：封面图片
*/ */
public void setFengmiantupian(String fengmiantupian) { public void setFengmiantupian(String fengmiantupian) {
this.fengmiantupian = fengmiantupian; this.fengmiantupian = fengmiantupian;
} }
/** /**
* 获取：封面图片 * 获取：封面图片
*/ */
public String getFengmiantupian() { public String getFengmiantupian() {
return fengmiantupian; return fengmiantupian;
} }
/** /**
* 设置：类型 * 设置：类型
*/ */
public void setLeixing(String leixing) { public void setLeixing(String leixing) {
this.leixing = leixing; this.leixing = leixing;
} }
/** /**
* 获取：类型 * 获取：类型
*/ */
public String getLeixing() { public String getLeixing() {
return leixing; return leixing;
} }
/** /**
* 设置：问题一 * 设置：问题一
*/ */
public void setWentiyi(String wentiyi) { public void setWentiyi(String wentiyi) {
this.wentiyi = wentiyi; this.wentiyi = wentiyi;
} }
/** /**
* 获取：问题一 * 获取：问题一
*/ */
public String getWentiyi() { public String getWentiyi() {
return wentiyi; return wentiyi;
} }
/** /**
* 设置：问题二 * 设置：问题二
*/ */
public void setWentier(String wentier) { public void setWentier(String wentier) {
this.wentier = wentier; this.wentier = wentier;
} }
/** /**
* 获取：问题二 * 获取：问题二
*/ */
public String getWentier() { public String getWentier() {
return wentier; return wentier;
} }
/** /**
* 设置：问题三 * 设置：问题三
*/ */
public void setWentisan(String wentisan) { public void setWentisan(String wentisan) {
this.wentisan = wentisan; this.wentisan = wentisan;
} }
/** /**
* 获取：问题三 * 获取：问题三
*/ */
public String getWentisan() { public String getWentisan() {
return wentisan; return wentisan;
} }
/** /**
* 设置：问题四 * 设置：问题四
*/ */
public void setWentisi(String wentisi) { public void setWentisi(String wentisi) {
this.wentisi = wentisi; this.wentisi = wentisi;
} }
/** /**
* 获取：问题四 * 获取：问题四
*/ */
public String getWentisi() { public String getWentisi() {
return wentisi; return wentisi;
} }
/** /**
* 设置：问题五 * 设置：问题五
*/ */
public void setWentiwu(String wentiwu) { public void setWentiwu(String wentiwu) {
this.wentiwu = wentiwu; this.wentiwu = wentiwu;
} }
/** /**
* 获取：问题五 * 获取：问题五
*/ */
public String getWentiwu() { public String getWentiwu() {
return wentiwu; return wentiwu;
} }
/** /**
* 设置：发布日期 * 设置：发布日期
*/ */
public void setFaburiqi(Date faburiqi) { public void setFaburiqi(Date faburiqi) {
this.faburiqi = faburiqi; this.faburiqi = faburiqi;
} }
/** /**
* 获取：发布日期 * 获取：发布日期
*/ */
public Date getFaburiqi() { public Date getFaburiqi() {
return faburiqi; return faburiqi;
} }
/** /**
* 设置：最近点击时间 * 设置：最近点击时间
*/ */
public void setClicktime(Date clicktime) { public void setClicktime(Date clicktime) {
this.clicktime = clicktime; this.clicktime = clicktime;
} }
/** /**
* 获取：最近点击时间 * 获取：最近点击时间
*/ */
public Date getClicktime() { public Date getClicktime() {
return clicktime; return clicktime;
} }
} }

10
src/main/java/com/entity/view/ForumView.java
Unescape View File

@ -24,13 +24,15 @@ public class ForumView extends ForumEntity implements Serializable {
public ForumView(){ public ForumView(){
} }
public ForumView(ForumEntity forumEntity){ // 接收 ForumEntity 对象的构造函数
try { public ForumView(ForumEntity forumEntity) {
try {
// 将ForumEntity的属性复制到当前ForumView对象
BeanUtils.copyProperties(this, forumEntity); BeanUtils.copyProperties(this, forumEntity);
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block // 异常处理，打印堆栈信息
e.printStackTrace(); e.printStackTrace();
} }
} }
} }

9
src/main/java/com/entity/view/LeixingView.java
Unescape View File

@ -24,13 +24,14 @@ public class LeixingView extends LeixingEntity implements Serializable {
public LeixingView(){ public LeixingView(){
} }
public LeixingView(LeixingEntity leixingEntity){ // 接收 LeixingEntity 对象的构造函数
try { public LeixingView(LeixingEntity leixingEntity) {
try {
// 将LeixingEntity的属性复制到当前LeixingView对象
BeanUtils.copyProperties(this, leixingEntity); BeanUtils.copyProperties(this, leixingEntity);
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block // 异常处理，打印堆栈信息
e.printStackTrace(); e.printStackTrace();
} }
} }
} }

46
src/main/java/com/entity/view/WenjuandiaochaView.java
Unescape View File

@ -1,36 +1,40 @@
package com.entity.view; package com.entity.view;
import com.entity.WenjuandiaochaEntity; import com.entity.WenjuandiaochaEntity;
import com.baomidou.mybatisplus.annotations.TableName; import com.baomidou.mybatisplus.annotations.TableName;
import org.apache.commons.beanutils.BeanUtils; import org.apache.commons.beanutils.BeanUtils;
import java.lang.reflect.InvocationTargetException; import java.lang.reflect.InvocationTargetException;
import java.io.Serializable; import java.io.Serializable;
/** /**
* 问卷调查 * 问卷调查视图实体类
* 后端返回视图实体辅助类 * 该类用于在后端返回视图时使用的辅助实体类。
* （通常后端关联的表或者自定义的字段需要返回使用） * 通常在后端需要关联其他表或自定义字段时，会使用此类来封装返回的数据。
* @author * @author 未填写具体作者
* @email * @email 未填写具体邮箱
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
@TableName("wenjuandiaocha") @TableName("wenjuandiaocha")
public class WenjuandiaochaView extends WenjuandiaochaEntity implements Serializable { public class WenjuandiaochaView extends WenjuandiaochaEntity implements Serializable {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
/**
* 无参构造函数
*/
public WenjuandiaochaView() {
}
public WenjuandiaochaView(){ /**
} * 带参数的构造函数，用于将WenjuandiaochaEntity对象的属性复制到WenjuandiaochaView对象中
* @param wenjuandiaochaEntity 问卷调查实体对象
public WenjuandiaochaView(WenjuandiaochaEntity wenjuandiaochaEntity){ */
try { public WenjuandiaochaView(WenjuandiaochaEntity wenjuandiaochaEntity) {
BeanUtils.copyProperties(this, wenjuandiaochaEntity); try {
} catch (IllegalAccessException | InvocationTargetException e) { BeanUtils.copyProperties(this, wenjuandiaochaEntity);
// TODO Auto-generated catch block } catch (IllegalAccessException | InvocationTargetException e) {
e.printStackTrace(); // 打印堆栈跟踪信息以便调试
} e.printStackTrace();
}
} }
} }

2
src/main/java/com/entity/vo/LeixingVO.java
Unescape View File

@ -19,7 +19,7 @@ import java.io.Serializable;
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
public class LeixingVO implements Serializable { public class LeixingVO implements Serializable {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;// 版本控制，用于序列化
} }

13
src/main/java/com/service/ConfigService.java
Unescape View File

@ -3,8 +3,8 @@ package com.service;
import java.util.Map; import java.util.Map;
import com.baomidou.mybatisplus.mapper.Wrapper; import com.baomidou.mybatisplus.mapper.Wrapper;// 导入MyBatis-Plus的Wrapper接口，用于构建查询条件
import com.baomidou.mybatisplus.service.IService; import com.baomidou.mybatisplus.service.IService;// 导入MyBatis-Plus的服务接口
import com.entity.ConfigEntity; import com.entity.ConfigEntity;
import com.utils.PageUtils; import com.utils.PageUtils;
@ -13,5 +13,12 @@ import com.utils.PageUtils;
* 系统用户 * 系统用户
*/ */
public interface ConfigService extends IService<ConfigEntity> { public interface ConfigService extends IService<ConfigEntity> {
PageUtils queryPage(Map<String, Object> params,Wrapper<ConfigEntity> wrapper);
/**
* 查询分页数据
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 封装好的分页结果
*/
PageUtils queryPage(Map<String, Object> params, Wrapper<ConfigEntity> wrapper);
} }

59
src/main/java/com/service/ForumService.java
Unescape View File

@ -3,14 +3,12 @@ package com.service;
import com.baomidou.mybatisplus.mapper.Wrapper; import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.IService; import com.baomidou.mybatisplus.service.IService;
import com.utils.PageUtils; import com.utils.PageUtils;
import com.entity.ForumEntity; import com.entity.ForumEntity; // 导入论坛实体类
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import com.entity.vo.ForumVO; import com.entity.vo.ForumVO;// 导入论坛VO类
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import com.entity.view.ForumView; import com.entity.view.ForumView;v// 导入论坛视图类
/** /**
* 论坛表 * 论坛表
* *
@ -20,18 +18,47 @@ import com.entity.view.ForumView;
*/ */
public interface ForumService extends IService<ForumEntity> { public interface ForumService extends IService<ForumEntity> {
/**
* 查询分页数据
* @param params 查询参数
* @return 分页结果
*/
PageUtils queryPage(Map<String, Object> params); PageUtils queryPage(Map<String, Object> params);
List<ForumVO> selectListVO(Wrapper<ForumEntity> wrapper); /**
* 查询VO列表
ForumVO selectVO(@Param("ew") Wrapper<ForumEntity> wrapper); * @param wrapper 查询条件包装器
* @return ForumVO对象列表
List<ForumView> selectListView(Wrapper<ForumEntity> wrapper); */
List<ForumVO> selectListVO(Wrapper<ForumEntity> wrapper);
ForumView selectView(@Param("ew") Wrapper<ForumEntity> wrapper);
/**
PageUtils queryPage(Map<String, Object> params,Wrapper<ForumEntity> wrapper); * 查询单个VO对象
* @param wrapper 查询条件包装器
* @return 单个ForumVO对象
*/
ForumVO selectVO(@Param("ew") Wrapper<ForumEntity> wrapper);
/**
* 查询视图列表
* @param wrapper 查询条件包装器
* @return ForumView对象列表
*/
List<ForumView> selectListView(Wrapper<ForumEntity> wrapper);
/**
* 查询单个视图对象
* @param wrapper 查询条件包装器
* @return 单个ForumView对象
*/
ForumView selectView(@Param("ew") Wrapper<ForumEntity> wrapper);
/**
* 带条件的查询分页数据
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 分页结果
*/
PageUtils queryPage(Map<String, Object> params, Wrapper<ForumEntity> wrapper);
} }

55
src/main/java/com/service/LeixingService.java
Unescape View File

@ -3,12 +3,12 @@ package com.service;
import com.baomidou.mybatisplus.mapper.Wrapper; import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.IService; import com.baomidou.mybatisplus.service.IService;
import com.utils.PageUtils; import com.utils.PageUtils;
import com.entity.LeixingEntity; import com.entity.LeixingEntity; // 导入类型实体类
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import com.entity.vo.LeixingVO; import com.entity.vo.LeixingVO;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import com.entity.view.LeixingView; import com.entity.view.LeixingView;// 导入类型视图类
/** /**
@ -20,18 +20,47 @@ import com.entity.view.LeixingView;
*/ */
public interface LeixingService extends IService<LeixingEntity> { public interface LeixingService extends IService<LeixingEntity> {
/**
* 查询分页数据
* @param params 查询参数
* @return 分页结果
*/
PageUtils queryPage(Map<String, Object> params); PageUtils queryPage(Map<String, Object> params);
List<LeixingVO> selectListVO(Wrapper<LeixingEntity> wrapper); /**
* 查询类型列表，返回VO对象列表
LeixingVO selectVO(@Param("ew") Wrapper<LeixingEntity> wrapper); * @param wrapper 查询条件包装器
* @return LeixingVO对象列表
List<LeixingView> selectListView(Wrapper<LeixingEntity> wrapper); */
List<LeixingVO> selectListVO(Wrapper<LeixingEntity> wrapper);
LeixingView selectView(@Param("ew") Wrapper<LeixingEntity> wrapper);
/**
PageUtils queryPage(Map<String, Object> params,Wrapper<LeixingEntity> wrapper); * 查询单个类型，返回VO对象
* @param wrapper 查询条件包装器
* @return 单个LeixingVO对象
*/
LeixingVO selectVO(@Param("ew") Wrapper<LeixingEntity> wrapper);
/**
* 查询类型列表，返回视图对象列表
* @param wrapper 查询条件包装器
* @return LeixingView对象列表
*/
List<LeixingView> selectListView(Wrapper<LeixingEntity> wrapper);
/**
* 查询单个类型，返回视图对象
* @param wrapper 查询条件包装器
* @return 单个LeixingView对象
*/
LeixingView selectView(@Param("ew") Wrapper<LeixingEntity> wrapper);
/**
* 带条件的查询分页数据
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 分页结果
*/
PageUtils queryPage(Map<String, Object> params, Wrapper<LeixingEntity> wrapper);
} }

78
src/main/java/com/service/WenjuandafuService.java
Unescape View File

@ -20,26 +20,70 @@ import com.entity.view.WenjuandafuView;
*/ */
public interface WenjuandafuService extends IService<WenjuandafuEntity> { public interface WenjuandafuService extends IService<WenjuandafuEntity> {
/**
* 查询分页数据
* @param params 查询参数
* @return 分页结果
*/
PageUtils queryPage(Map<String, Object> params); PageUtils queryPage(Map<String, Object> params);
List<WenjuandafuVO> selectListVO(Wrapper<WenjuandafuEntity> wrapper); /**
* 查询问卷答复列表，返回VO对象列表
WenjuandafuVO selectVO(@Param("ew") Wrapper<WenjuandafuEntity> wrapper); * @param wrapper 查询条件包装器
* @return 问卷答复VO对象列表
List<WenjuandafuView> selectListView(Wrapper<WenjuandafuEntity> wrapper); */
List<WenjuandafuVO> selectListVO(Wrapper<WenjuandafuEntity> wrapper);
WenjuandafuView selectView(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
PageUtils queryPage(Map<String, Object> params,Wrapper<WenjuandafuEntity> wrapper);
List<Map<String, Object>> selectValue(Map<String, Object> params,Wrapper<WenjuandafuEntity> wrapper);
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params,Wrapper<WenjuandafuEntity> wrapper);
List<Map<String, Object>> selectGroup(Map<String, Object> params,Wrapper<WenjuandafuEntity> wrapper); /**
* 查询单个问卷答复，返回VO对象
* @param wrapper 查询条件包装器
* @return 问卷答复VO对象
*/
WenjuandafuVO selectVO(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
/**
* 查询问卷答复列表，返回视图对象列表
* @param wrapper 查询条件包装器
* @return 问卷答复视图对象列表
*/
List<WenjuandafuView> selectListView(Wrapper<WenjuandafuEntity> wrapper);
/**
* 查询单个问卷答复，返回视图对象
* @param wrapper 查询条件包装器
* @return 问卷答复视图对象
*/
WenjuandafuView selectView(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
/**
* 查询分页数据
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 分页结果
*/
PageUtils queryPage(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper);
/**
* 查询问卷答复的值，以Map形式返回
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 值的Map列表
*/
List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper);
} /**
* 根据时间统计查询问卷答复的值
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 时间统计值的Map列表
*/
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper);
/**
* 查询分组统计数据
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 分组统计的Map列表
*/
List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper);

76
src/main/java/com/service/WenjuandiaochaService.java
Unescape View File

@ -10,36 +10,80 @@ import com.entity.vo.WenjuandiaochaVO;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import com.entity.view.WenjuandiaochaView; import com.entity.view.WenjuandiaochaView;
/** /**
* 问卷调查 * 问卷调查服务接口
* *
* @author * @author 作者名
* @email * @email 邮箱地址
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
public interface WenjuandiaochaService extends IService<WenjuandiaochaEntity> { public interface WenjuandiaochaService extends IService<WenjuandiaochaEntity> {
/**
* 分页查询问卷调查数据
* @param params 查询参数
* @return 分页结果
*/
PageUtils queryPage(Map<String, Object> params); PageUtils queryPage(Map<String, Object> params);
List<WenjuandiaochaVO> selectListVO(Wrapper<WenjuandiaochaEntity> wrapper); /**
* 查询问卷调查列表（带条件）
* @param wrapper 查询条件包装器
* @return 问卷调查列表
*/
List<WenjuandiaochaVO> selectListVO(Wrapper<WenjuandiaochaEntity> wrapper);
WenjuandiaochaVO selectVO(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper); /**
* 查询单个问卷调查（带条件）
* @param wrapper 查询条件包装器
* @return 单个问卷调查
*/
WenjuandiaochaVO selectVO(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
List<WenjuandiaochaView> selectListView(Wrapper<WenjuandiaochaEntity> wrapper); /**
* 查询问卷调查视图列表（带条件）
* @param wrapper 查询条件包装器
* @return 问卷调查视图列表
*/
List<WenjuandiaochaView> selectListView(Wrapper<WenjuandiaochaEntity> wrapper);
WenjuandiaochaView selectView(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper); /**
* 查询单个问卷调查视图（带条件）
* @param wrapper 查询条件包装器
* @return 单个问卷调查视图
*/
WenjuandiaochaView selectView(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
PageUtils queryPage(Map<String, Object> params,Wrapper<WenjuandiaochaEntity> wrapper); /**
* 分页查询问卷调查数据（带条件）
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 分页结果
*/
PageUtils queryPage(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper);
List<Map<String, Object>> selectValue(Map<String, Object> params,Wrapper<WenjuandiaochaEntity> wrapper); /**
* 查询问卷调查的统计值（带条件）
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 统计值列表
*/
List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper);
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params,Wrapper<WenjuandiaochaEntity> wrapper); /**
* 查询问卷调查的时间统计值（带条件）
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 时间统计值列表
*/
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper);
List<Map<String, Object>> selectGroup(Map<String, Object> params,Wrapper<WenjuandiaochaEntity> wrapper); /**
* 查询问卷调查的分组统计值（带条件）
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 分组统计值列表
*/
List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper);
} }

8
src/main/java/com/service/impl/ConfigServiceImpl.java
Unescape View File

@ -24,10 +24,10 @@ import com.utils.Query;
public class ConfigServiceImpl extends ServiceImpl<ConfigDao, ConfigEntity> implements ConfigService { public class ConfigServiceImpl extends ServiceImpl<ConfigDao, ConfigEntity> implements ConfigService {
@Override @Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<ConfigEntity> wrapper) { public PageUtils queryPage(Map<String, Object> params, Wrapper<ConfigEntity> wrapper) {
// 使用MyBatis-Plus的selectPage方法进行分页查询
Page<ConfigEntity> page = this.selectPage( Page<ConfigEntity> page = this.selectPage(
new Query<ConfigEntity>(params).getPage(), new Query<ConfigEntity>(params).getPage(), // 获取分页参数
wrapper wrapper // 查询条件
); );
return new PageUtils(page); return new PageUtils(page); // 返回分页结果
}
} }

90
src/main/java/com/service/impl/ForumServiceImpl.java
Unescape View File

@ -18,46 +18,76 @@ import com.service.ForumService;
import com.entity.vo.ForumVO; import com.entity.vo.ForumVO;
import com.entity.view.ForumView; import com.entity.view.ForumView;
@Service("forumService") @Service("forumService") // 将该类标记为Spring的Service组件
public class ForumServiceImpl extends ServiceImpl<ForumDao, ForumEntity> implements ForumService { public class ForumServiceImpl extends ServiceImpl<ForumDao, ForumEntity> implements ForumService {
/**
* 查询分页数据
* @param params 查询参数
* @return 分页结果
*/
@Override @Override
public PageUtils queryPage(Map<String, Object> params) { public PageUtils queryPage(Map<String, Object> params) {
// 调用selectPage方法进行分页查询
Page<ForumEntity> page = this.selectPage( Page<ForumEntity> page = this.selectPage(
new Query<ForumEntity>(params).getPage(), new Query<ForumEntity>(params).getPage(), // 获取分页信息
new EntityWrapper<ForumEntity>() new EntityWrapper<ForumEntity>() // 创建查询条件
); );
return new PageUtils(page); return new PageUtils(page); // 返回分页结果
} }
/**
* 查询分页数据，带条件
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 分页结果
*/
@Override @Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<ForumEntity> wrapper) { public PageUtils queryPage(Map<String, Object> params, Wrapper<ForumEntity> wrapper) {
Page<ForumView> page =new Query<ForumView>(params).getPage(); // 创建分页对象
page.setRecords(baseMapper.selectListView(page,wrapper)); Page<ForumView> page = new Query<ForumView>(params).getPage();
PageUtils pageUtil = new PageUtils(page); // 设置记录
return pageUtil; page.setRecords(baseMapper.selectListView(page, wrapper));
} return new PageUtils(page); // 返回分页结果
}
/**
* 查询VO列表
* @param wrapper 查询条件包装器
* @return VO对象列表
*/
@Override @Override
public List<ForumVO> selectListVO(Wrapper<ForumEntity> wrapper) { public List<ForumVO> selectListVO(Wrapper<ForumEntity> wrapper) {
return baseMapper.selectListVO(wrapper); return baseMapper.selectListVO(wrapper); // 调用数据访问对象方法，返回VO对象列表
} }
@Override /**
public ForumVO selectVO(Wrapper<ForumEntity> wrapper) { * 查询单个VO对象
return baseMapper.selectVO(wrapper); * @param wrapper 查询条件包装器
} * @return 单个VO对象
*/
@Override @Override
public List<ForumView> selectListView(Wrapper<ForumEntity> wrapper) { public ForumVO selectVO(Wrapper<ForumEntity> wrapper) {
return baseMapper.selectListView(wrapper); return baseMapper.selectVO(wrapper); // 调用数据访问对象方法，返回单个VO对象
} }
@Override /**
public ForumView selectView(Wrapper<ForumEntity> wrapper) { * 查询视图列表
return baseMapper.selectView(wrapper); * @param wrapper 查询条件包装器
} * @return 视图对象列表
*/
@Override
public List<ForumView> selectListView(Wrapper<ForumEntity> wrapper) {
return baseMapper.selectListView(wrapper); // 调用数据访问对象方法，返回视图对象列表
}
/**
* 查询单个视图对象
* @param wrapper 查询条件包装器
* @return 单个视图对象
*/
@Override
public ForumView selectView(Wrapper<ForumEntity> wrapper) {
return baseMapper.selectView(wrapper); // 调用数据访问对象方法，返回单个视图对象
}
} }

92
src/main/java/com/service/impl/LeixingServiceImpl.java
Unescape View File

@ -17,47 +17,75 @@ import com.entity.LeixingEntity;
import com.service.LeixingService; import com.service.LeixingService;
import com.entity.vo.LeixingVO; import com.entity.vo.LeixingVO;
import com.entity.view.LeixingView; import com.entity.view.LeixingView;
@Service("leixingService") // 将该类标记为Spring的Service组件
@Service("leixingService")
public class LeixingServiceImpl extends ServiceImpl<LeixingDao, LeixingEntity> implements LeixingService { public class LeixingServiceImpl extends ServiceImpl<LeixingDao, LeixingEntity> implements LeixingService {
/**
* 查询分页数据
* @param params 查询参数
* @return 分页结果
*/
@Override @Override
public PageUtils queryPage(Map<String, Object> params) { public PageUtils queryPage(Map<String, Object> params) {
// 使用selectPage方法进行分页查询
Page<LeixingEntity> page = this.selectPage( Page<LeixingEntity> page = this.selectPage(
new Query<LeixingEntity>(params).getPage(), new Query<LeixingEntity>(params).getPage(), // 获取分页信息
new EntityWrapper<LeixingEntity>() new EntityWrapper<LeixingEntity>() // 创建查询条件
); );
return new PageUtils(page); return new PageUtils(page); // 返回分页结果
} }
/**
* 查询分页数据，带条件
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 分页结果
*/
@Override @Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<LeixingEntity> wrapper) { public PageUtils queryPage(Map<String, Object> params, Wrapper<LeixingEntity> wrapper) {
Page<LeixingView> page =new Query<LeixingView>(params).getPage(); // 创建分页对象
page.setRecords(baseMapper.selectListView(page,wrapper)); Page<LeixingView> page = new Query<LeixingView>(params).getPage();
PageUtils pageUtil = new PageUtils(page); // 设置记录
return pageUtil; page.setRecords(baseMapper.selectListView(page, wrapper));
} return new PageUtils(page); // 返回分页结果
}
/**
* 查询VO列表
* @param wrapper 查询条件包装器
* @return VO对象列表
*/
@Override @Override
public List<LeixingVO> selectListVO(Wrapper<LeixingEntity> wrapper) { public List<LeixingVO> selectListVO(Wrapper<LeixingEntity> wrapper) {
return baseMapper.selectListVO(wrapper); return baseMapper.selectListVO(wrapper); // 调用数据访问对象方法，返回VO对象列表
} }
@Override /**
public LeixingVO selectVO(Wrapper<LeixingEntity> wrapper) { * 查询单个VO对象
return baseMapper.selectVO(wrapper); * @param wrapper 查询条件包装器
} * @return 单个VO对象
*/
@Override @Override
public List<LeixingView> selectListView(Wrapper<LeixingEntity> wrapper) { public LeixingVO selectVO(Wrapper<LeixingEntity> wrapper) {
return baseMapper.selectListView(wrapper); return baseMapper.selectVO(wrapper); // 调用数据访问对象方法，返回单个VO对象
} }
@Override /**
public LeixingView selectView(Wrapper<LeixingEntity> wrapper) { * 查询视图列表
return baseMapper.selectView(wrapper); * @param wrapper 查询条件包装器
} * @return 视图对象列表
*/
@Override
public List<LeixingView> selectListView(Wrapper<LeixingEntity> wrapper) {
return baseMapper.selectListView(wrapper); // 调用数据访问对象方法，返回视图对象列表
}
} /**
* 查询单个视图对象
* @param wrapper 查询条件包装器
* @return 单个视图对象
*/
@Override
public LeixingView selectView(Wrapper<LeixingEntity> wrapper) {
return baseMapper.selectView(wrapper); // 调用数据访问对象方法，返回单个视图对象
}

73
src/main/java/com/service/impl/WenjuandiaochaServiceImpl.java
Unescape View File

@ -11,19 +11,27 @@ import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils; import com.utils.PageUtils;
import com.utils.Query; import com.utils.Query;
import com.dao.WenjuandiaochaDao; import com.dao.WenjuandiaochaDao;
import com.entity.WenjuandiaochaEntity; import com.entity.WenjuandiaochaEntity;
import com.service.WenjuandiaochaService; import com.service.WenjuandiaochaService;
import com.entity.vo.WenjuandiaochaVO; import com.entity.vo.WenjuandiaochaVO;
import com.entity.view.WenjuandiaochaView; import com.entity.view.Wenjuandiaocha;
/**
* 问卷调查服务实现类
* 继承自MyBatis-Plus的ServiceImpl，并实现WenjuandiaochaService接口
*/
@Service("wenjuandiaochaService") @Service("wenjuandiaochaService")
public class WenjuandiaochaServiceImpl extends ServiceImpl<WenjuandiaochaDao, WenjuandiaochaEntity> implements WenjuandiaochaService { public class WenjuandiaochaServiceImpl extends ServiceImpl<WenjuandiaochaDao, WenjuandiaochaEntity> implements WenjuandiaochaService {
/**
* 分页查询问卷调查数据
* @param params 查询参数
* @return 分页结果
*/
@Override @Override
public PageUtils queryPage(Map<String, Object> params) { public PageUtils queryPage(Map<String, Object> params) {
// 使用MyBatis-Plus的分页插件进行分页查询
Page<WenjuandiaochaEntity> page = this.selectPage( Page<WenjuandiaochaEntity> page = this.selectPage(
new Query<WenjuandiaochaEntity>(params).getPage(), new Query<WenjuandiaochaEntity>(params).getPage(),
new EntityWrapper<WenjuandiaochaEntity>() new EntityWrapper<WenjuandiaochaEntity>()
@ -31,50 +39,93 @@ public class WenjuandiaochaServiceImpl extends ServiceImpl<WenjuandiaochaDao, We
return new PageUtils(page); return new PageUtils(page);
} }
/**
* 分页查询问卷调查数据（带条件）
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 分页结果
*/
@Override @Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper) { public PageUtils queryPage(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper) {
Page<WenjuandiaochaView> page =new Query<WenjuandiaochaView>(params).getPage(); // 创建分页对象
page.setRecords(baseMapper.selectListView(page,wrapper)); Page<WenjuandiaochaView> page = new Query<WenjuandiaochaView>(params).getPage();
PageUtils pageUtil = new PageUtils(page); // 设置分页记录
return pageUtil; page.setRecords(baseMapper.selectListView(page, wrapper));
// 返回分页工具类
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
} }
/**
* 查询问卷调查列表（带条件）
* @param wrapper 查询条件包装器
* @return 问卷调查列表
*/
@Override @Override
public List<WenjuandiaochaVO> selectListVO(Wrapper<WenjuandiaochaEntity> wrapper) { public List<WenjuandiaochaVO> selectListVO(Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectListVO(wrapper); return baseMapper.selectListVO(wrapper);
} }
/**
* 查询单个问卷调查（带条件）
* @param wrapper 查询条件包装器
* @return 单个问卷调查
*/
@Override @Override
public WenjuandiaochaVO selectVO(Wrapper<WenjuandiaochaEntity> wrapper) { public WenjuandiaochaVO selectVO(Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectVO(wrapper); return baseMapper.selectVO(wrapper);
} }
/**
* 查询问卷调查视图列表（带条件）
* @param wrapper 查询条件包装器
* @return 问卷调查视图列表
*/
@Override @Override
public List<WenjuandiaochaView> selectListView(Wrapper<WenjuandiaochaEntity> wrapper) { public List<WenjuandiaochaView> selectListView(Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectListView(wrapper); return baseMapper.selectListView(wrapper);
} }
/**
* 查询单个问卷调查视图（带条件）
* @param wrapper 查询条件包装器
* @return 单个问卷调查视图
*/
@Override @Override
public WenjuandiaochaView selectView(Wrapper<WenjuandiaochaEntity> wrapper) { public WenjuandiaochaView selectView(Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectView(wrapper); return baseMapper.selectView(wrapper);
} }
/**
* 查询问卷调查的统计值（带条件）
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 统计值列表
*/
@Override @Override
public List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper) { public List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectValue(params, wrapper); return baseMapper.selectValue(params, wrapper);
} }
/**
* 查询问卷调查的时间统计值（带条件）
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 时间统计值列表
*/
@Override @Override
public List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper) { public List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectTimeStatValue(params, wrapper); return baseMapper.selectTimeStatValue(params, wrapper);
} }
/**
* 查询问卷调查的分组统计值（带条件）
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 分组统计值列表
*/
@Override @Override
public List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper) { public List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectGroup(params, wrapper); return baseMapper.selectGroup(params, wrapper);
} }
} }

37
src/main/java/com/utils/FileUtil.java
Unescape View File

@ -1,7 +1,7 @@
package com.utils; package com.utils;
import java.io.ByteArrayOutputStream; import java.io.ByteArrayOutputStream;
import java.io.File; import java.io.File;// 导入File类
import java.io.FileInputStream; import java.io.FileInputStream;
import java.io.IOException; import java.io.IOException;
import java.io.InputStream; import java.io.InputStream;
@ -11,17 +11,26 @@ import java.io.InputStream;
*/ */
public class FileUtil { public class FileUtil {
public static byte[] FileToByte(File file) throws IOException {
// 将数据转为流 /**
@SuppressWarnings("resource") * 将文件转换为字节数组
InputStream content = new FileInputStream(file); * @param file
ByteArrayOutputStream swapStream = new ByteArrayOutputStream(); * @return
byte[] buff = new byte[100]; * @throws IOException 可能抛出输入输出异常
int rc = 0; */
while ((rc = content.read(buff, 0, 100)) > 0) { public static byte[] FileToByte(File file) throws IOException {
swapStream.write(buff, 0, rc); // 将文件数据转为输入流
} @SuppressWarnings("resource") // 这个资源在方法末尾会自动关闭，抑制编译警告
// 获得二进制数组 InputStream content = new FileInputStream(file); // 创建FileInputStream对象读取文件
return swapStream.toByteArray(); ByteArrayOutputStream swapStream = new ByteArrayOutputStream(); // 创建字节数组输出流对象
} byte[] buff = new byte[100];
int rc = 0;
// 循环读取文件数据，直到文件结束
while ((rc = content.read(buff, 0, 100)) > 0) {
swapStream.write(buff, 0, rc); // 将读取的数据写入字节数组输出流
}
return swapStream.toByteArray();
}
} }

Write Preview
Loading…
Cancel
Save