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

Merge pull request '注释代码' (#6) from wujiamei_branch into main

Browse Source
main
meyum3vjr 8 months ago
parent f5115f4838 d9fc767866
commit e709fc57c3
31 changed files with 2287 additions and 1771 deletions
Show Stats Download Patch File Download Diff File

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

@ -42,214 +42,310 @@ import com.utils.CommonUtil;
/** /**
* 在线咨询 * 在线咨询
* 后端接口 * 后端接口
* @author * @author （这里应该填写作者姓名，但代码中未给出具体值）
* @email * @email （这里应该填写作者邮箱，但代码中未给出具体值）
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
@RestController @RestController
@RequestMapping("/chat") @RequestMapping("/chat")
public class ChatController { public class ChatController {
// 自动注入ChatService实例，用于处理与聊天相关的业务逻辑
@Autowired @Autowired
private ChatService chatService; private ChatService chatService;
/** /**
* 后端列表 * 后端列表
* 用于获取聊天记录列表，根据不同用户角色（管理员或普通用户）进行数据筛选
* @param params 包含查询参数的Map，例如分页参数、筛选条件等
* @param chat ChatEntity对象，可能包含一些额外的查询条件
* @param request HttpServletRequest对象，用于获取当前会话信息
* @return R类型的结果，包含查询到的聊天记录列表数据及相关状态信息
*/ */
@RequestMapping("/page") @RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params,ChatEntity chat, public R page(@RequestParam Map<String, Object> params, ChatEntity chat,
HttpServletRequest request){ HttpServletRequest request) {
if(!request.getSession().getAttribute("role").toString().equals("管理员")) { // 如果当前用户不是管理员角色，设置查询条件，只查询当前用户的聊天记录
chat.setUserid((Long)request.getSession().getAttribute("userId")); if (!request.getSession().getAttribute("role").toString().equals("管理员")) {
}
chat.setUserid((Long) request.getSession().getAttribute("userId"));
}
// 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件
EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>(); EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params)); // 调用chatService的queryPage方法进行分页查询，传入构建好的查询条件和参数
request.setAttribute("data", page); PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params));
// 将查询结果设置到请求属性中，可能用于在后续的视图渲染中使用
request.setAttribute("data", page);
// 返回包含查询结果的R对象，通常R对象用于统一封装返回结果的状态和数据
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* 前端列表 * 前端列表
* 功能与后端列表类似，但可能在前端展示时有不同的处理或用途
* @param params 包含查询参数的Map，例如分页参数、筛选条件等
* @param chat ChatEntity对象，可能包含一些额外的查询条件
* @param request HttpServletRequest对象，用于获取当前会话信息
* @return R类型的结果，包含查询到的聊天记录列表数据及相关状态信息
*/ */
@RequestMapping("/list") @RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params,ChatEntity chat, public R list(@RequestParam Map<String, Object> params, ChatEntity chat,
HttpServletRequest request){ HttpServletRequest request) {
if(!request.getSession().getAttribute("role").toString().equals("管理员")) { // 如果当前用户不是管理员角色,设置查询条件，只查询当前用户的聊天记录
chat.setUserid((Long)request.getSession().getAttribute("userId")); if (!request.getSession().getAttribute("role").toString().equals("管理员")) {
}
chat.setUserid((Long) request.getSession().getAttribute("userId"));
}
// 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件
EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>(); EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params)); // 调用chatService的queryPage方法进行分页查询，传入构建好的查询条件和参数
request.setAttribute("data", page); PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params));
// 将查询结果设置到请求属性中，可能用于在后续的视图渲染中使用
request.setAttribute("data", page);
// 返回包含查询结果的R对象，通常R对象用于统一封装返回结果的状态和数据
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* 列表 * 列表
* 用于获取聊天记录列表，根据传入的ChatEntity对象构建查询条件
* @param chat ChatEntity对象，包含查询条件信息
* @return R类型的结果，包含查询到的聊天记录列表数据及相关状态信息
*/ */
@RequestMapping("/lists") @RequestMapping("/lists")
public R list( ChatEntity chat){ public R list(ChatEntity chat) {
EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>(); // 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件
ew.allEq(MPUtil.allEQMapPre( chat, "chat")); EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
// 根据传入的ChatEntity对象构建等值查询条件
ew.allEq(MPUtil.allEQMapPre(chat, "chat"));
// 调用chatService的selectListView方法进行查询，并返回结果
return R.ok().put("data", chatService.selectListView(ew)); return R.ok().put("data", chatService.selectListView(ew));
} }
/** /**
* 查询 * 查询
* 用于查询特定条件的在线咨询记录，并返回详细信息视图
* @param chat ChatEntity对象，包含查询条件信息
* @return R类型的结果，包含查询到的在线咨询详细信息视图及相关状态信息
*/ */
@RequestMapping("/query") @RequestMapping("/query")
public R query(ChatEntity chat){ public R query(ChatEntity chat) {
EntityWrapper< ChatEntity> ew = new EntityWrapper< ChatEntity>(); // 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件
ew.allEq(MPUtil.allEQMapPre( chat, "chat")); EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
ChatView chatView = chatService.selectView(ew); // 根据传入的ChatEntity对象构建等值查询条件
return R.ok("查询在线咨询成功").put("data", chatView); ew.allEq(MPUtil.allEQMapPre(chat, "chat"));
// 调用chatService的selectView方法进行查询，获取ChatView对象（可能是包含详细信息的视图对象）
ChatView chatView = chatService.selectView(ew);
// 返回包含查询结果的R对象，以及提示信息和查询到的详细信息视图
return R.ok("查询在线咨询成功").put("data", chatView);
} }
/** /**
* 后端详情 * 后端详情
* 用于获取指定ID的聊天记录详细信息
* @param id 聊天记录的ID
* @return R类型的结果，包含查询到的聊天记录详细信息及相关状态信息
*/ */
@RequestMapping("/info/{id}") @RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id){ public R info(@PathVariable("id") Long id) {
// 调用chatService的selectById方法，根据ID查询聊天记录
ChatEntity chat = chatService.selectById(id); ChatEntity chat = chatService.selectById(id);
// 返回包含查询结果的R对象
return R.ok().put("data", chat); return R.ok().put("data", chat);
} }
/** /**
* 前端详情 * 前端详情
* 功能与后端详情类似，但可能在前端展示时有不同的处理或用途，且此方法标注了@IgnoreAuth，表示忽略权限验证
* @param id 聊天记录的ID
* @return R类型的结果，包含查询到的聊天记录详细信息及相关状态信息
*/ */
@IgnoreAuth @IgnoreAuth
@RequestMapping("/detail/{id}") @RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id){ public R detail(@PathVariable("id") Long id) {
// 调用chatService的selectById方法，根据ID查询聊天记录
ChatEntity chat = chatService.selectById(id); ChatEntity chat = chatService.selectById(id);
// 返回包含查询结果的R对象
return R.ok().put("data", chat); return R.ok().put("data", chat);
} }
/** /**
* 后端保存 * 后端保存
* 用于保存新的聊天记录，包括设置一些默认值和根据聊天内容更新相关状态
* @param chat 包含聊天记录信息的ChatEntity对象
* @param request HttpServletRequest对象，用于获取当前会话信息
* @return R类型的结果，用于表示保存操作的结果状态
*/ */
@RequestMapping("/save") @RequestMapping("/save")
public R save(@RequestBody ChatEntity chat, HttpServletRequest request){ public R save(@RequestBody ChatEntity chat, HttpServletRequest request) {
chat.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); // 设置聊天记录的ID，由当前时间戳加上一个随机数生成
//ValidatorUtils.validateEntity(chat); chat.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
if(StringUtils.isNotBlank(chat.getAsk())) { // 此处原本可能用于验证ChatEntity对象的合法性，但被注释掉了
chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", request.getSession().getAttribute("userId"))); //ValidatorUtils.validateEntity(chat);
chat.setUserid((Long)request.getSession().getAttribute("userId")); // 如果聊天记录的提问内容不为空
chat.setIsreply(1); if (StringUtils.isNotBlank(chat.getAsk())) {
} // 更新当前用户的未回复状态为0，表示有新提问
if(StringUtils.isNotBlank(chat.getReply())) { chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", request.getSession().getAttribute("userId")));
chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", chat.getUserid())); // 设置聊天记录的用户ID为当前用户ID
chat.setAdminid((Long)request.getSession().getAttribute("userId")); chat.setUserid((Long) request.getSession().getAttribute("userId"));
} // 设置回复状态为1，表示已提问等待回复
chat.setIsreply(1);
}
// 如果聊天记录的回复内容不为空
if (StringUtils.isNotBlank(chat.getReply())) {
// 更新当前用户（提问用户）的未回复状态为0，表示有新回复
chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", chat.getUserid()));
// 设置聊天记录的管理员ID为当前用户ID（可能表示回复的管理员）
chat.setAdminid((Long) request.getSession().getAttribute("userId"));
}
// 调用chatService的insert方法插入新的聊天记录
chatService.insert(chat); chatService.insert(chat);
// 返回表示保存成功的R对象
return R.ok(); return R.ok();
} }
/** /**
* 前端保存 * 前端保存
* 功能与后端保存类似，但可能在前端保存时有不同的处理或用途
* @param chat 包含聊天记录信息的ChatEntity对象
* @param request HttpServletRequest对象，用于获取当前会话信息
* @return R类型的结果，用于表示保存操作的结果状态
*/ */
@RequestMapping("/add") @RequestMapping("/add")
public R add(@RequestBody ChatEntity chat, HttpServletRequest request){ public R add(@RequestBody ChatEntity chat, HttpServletRequest request) {
chat.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); // 设置聊天记录的ID，由当前时间戳加上一个随机数生成
//ValidatorUtils.validateEntity(chat); chat.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
chat.setUserid((Long)request.getSession().getAttribute("userId"));
if(StringUtils.isNotBlank(chat.getAsk())) {
chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", request.getSession().getAttribute("userId"))); // 设置聊天记录的用户ID为当前用户ID
chat.setUserid((Long)request.getSession().getAttribute("userId")); chat.setUserid((Long) request.getSession().getAttribute("userId"));
chat.setIsreply(1); // 如果聊天记录的提问内容不为空
} if (StringUtils.isNotBlank(chat.getAsk())) {
if(StringUtils.isNotBlank(chat.getReply())) { // 更新当前用户的未回复状态为0，表示有新提问
chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", chat.getUserid())); chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", request.getSession().getAttribute("userId")));
chat.setAdminid((Long)request.getSession().getAttribute("userId")); // 设置聊天记录的用户ID为当前用户ID
} chat.setUserid((Long) request.getSession().getAttribute("UserId"));
// 设置回复状态为1，表示已提问等待回复
chat.setIsreply(1);
}
// 如果聊天记录的回复内容不为空
if (StringUtils.isNotBlank(chat.getReply())) {
// 更新当前用户（提问用户）的未回复状态为0，表示有新回复
chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", chat.getUserid()));
// 设置聊天记录的管理员ID为当前用户ID（可能表示回复的管理员）
chat.setAdminid((Long) request.getSession().getAttribute("UserId"));
}
// 调用chatService的insert方法插入新的聊天记录
chatService.insert(chat); chatService.insert(chat);
// 返回表示保存成功的R对象
return R.ok(); return R.ok();
} }
/** /**
* 修改 * 修改
* 用于修改已存在的聊天记录
* @param chat 包含修改后聊天记录信息的ChatEntity对象
* @param request HttpServletRequest对象，可能用于获取一些额外信息（此处未体现具体用途）
* @return R类型的结果，用于表示修改操作的结果状态
*/ */
@RequestMapping("/update") @RequestMapping("/update")
@Transactional @Transactional
public R update(@RequestBody ChatEntity chat, HttpServletRequest request){ public R update(@RequestBody ChatEntity chat, HttpServletRequest request) {
// 此处原本可能用于验证ChatEntity对象的合法性，但被注释掉了
//ValidatorUtils.validateEntity(chat); //ValidatorUtils.validateEntity(chat);
chatService.updateById(chat);//全部更新 // 调用chatService的updateById方法，根据ID更新聊天记录
chatService.updateById(chat); //全部更新
// 返回表示修改成功的R对象
return R.ok(); return R.ok();
} }
/** /**
* 删除 * 删除
* 用于删除指定ID的聊天记录
* @param ids 包含要删除聊天记录ID的数组
* @return R类型的结果，用于表示删除操作的结果状态
*/ */
@RequestMapping("/delete") @RequestMapping("/delete")
public R delete(@RequestBody Long[] ids){ public R delete(@RequestBody Long[] ids) {
// 调用chatService的deleteBatchIds方法，批量删除指定ID的聊天记录
chatService.deleteBatchIds(Arrays.asList(ids)); chatService.deleteBatchIds(Arrays.asList(ids));
// 返回表示删除成功的R对象
return R.ok(); return R.ok();
} }
/** /**
* 提醒接口 * 提醒接口
* 根据指定的列名、类型以及其他查询条件，统计符合条件的聊天记录数量
* @param columnName 要进行条件判断的列名
* @param request HttpServletRequest对象，用于获取当前会话信息等
* @param type 提醒类型，可能用于区分不同的统计逻辑
* @param map 包含其他查询条件的Map，例如时间范围等
* @return R类型的结果，包含统计到的符合条件的聊天记录数量及相关状态信息
*/ */
@RequestMapping("/remind/{columnName}/{type}") @RequestMapping("/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中
map.put("type", type); map.put("column", columnName);
map.put("type", type);
if(type.equals("2")) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // 如果提醒类型为2
Calendar c = Calendar.getInstance(); if (type.equals("2")) {
Date remindStartDate = null; // 创建SimpleDateFormat对象，用于日期格式化
Date remindEndDate = null; SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
if(map.get("remindstart")!=null) { // 获取Calendar实例，用于日期计算
Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); Calendar c = Calendar.getInstance();
c.setTime(new Date()); Date remindStartDate = null;
c.add(Calendar.DAY_OF_MONTH,remindStart); Date remindEndDate = null;
remindStartDate = c.getTime(); // 如果查询条件Map中包含remindstart（开始提醒时间）
map.put("remindstart", sdf.format(remindStartDate)); if (map.get("remindstart")!= null) {
} // 将remindstart转换为整数，表示要添加的天数
if(map.get("remindend")!=null) { Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); // 设置当前日期为基础日期
c.setTime(new Date()); c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH,remindEnd); // 根据提醒开始天数添加到当前日期上
remindEndDate = c.getTime(); c.add(Calendar.DAY_OF_MONTH, remindStart);
map.put("remindend", sdf.format(remindEndDate)); // 获取计算后的提醒开始日期
} remindStartDate = c.getTime();
} // 将提醒开始日期格式化为指定格式，并更新到查询条件Map中
map.put("remindstart", sdf.format(remindStartDate));
Wrapper<ChatEntity> wrapper = new EntityWrapper<ChatEntity>(); }
if(map.get("remindstart")!=null) { // 如果查询条件Map中包含remindend（结束提醒时间）
wrapper.ge(columnName, map.get("remindstart")); if (map.get("remindend")!= null) {
} // 将remindend转换为整数，表示要添加的天数
if(map.get("remindend")!=null) { Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
wrapper.le(columnName, map.get("remindend")); // 设置当前日期为基础日期
} c.setTime(new Date());
// 根据提醒结束天数添加到当前日期上
c.add(Calendar.DAY_OF_MONTH, remindEnd);
int count = chatService.selectCount(wrapper); // 获取计算后的提醒结束日期
return R.ok().put("count", count); remindEndDate = c.getTime();
} // 将提醒结束日期格式化为指定格式，并更新到查询条件Map中
map.put("remindend", sdf.format(remindEndDate));
}
}
// 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件
Wrapper<ChatEntity> wrapper = new EntityWrapper<ChatEntity>();
// 如果查询条件Map中包含remindstart（开始提醒时间），添加大于等于条件到查询条件中
if (map.get("remindstart")!= null) {
wrapper.ge(columnName, map.get("remindstart"));
}
// 如果查询条件Map中包含remindend（结束提醒时间），添加小于等于条件到查询条件中
if (map.get("remindend")!= null) {
wrapper.le(columnName, map.get("remindend"));
}
// 调用chatService的selectCount方法，根据构建好的查询条件统计符合条件的聊天记录数量
int count = chatService.selectCount(wrapper);
// 返回包含统计结果的R对象
return R.ok().put("count", count);
}
} }

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

@ -28,202 +28,286 @@ import com.baidu.aip.face.MatchRequest;
import com.baidu.aip.util.Base64Util; import com.baidu.aip.util.Base64Util;
import com.baomidou.mybatisplus.mapper.EntityWrapper; import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.entity.ConfigEntity; import com.entity.ConfigEntity;
// 导入相关的服务类和工具类
import com.service.CommonService; import com.service.CommonService;
import com.service.ConfigService; import com.service.ConfigService;
import com.utils.BaiduUtil; import com.utils.BaiduUtil;
import com.utils.FileUtil; import com.utils.FileUtil;
import com.utils.R; import com.utils.R;
import com.utils.CommonUtil; import com.utils.CommonUtil;
/** /**
* 通用接口 * 通用接口
* 该类作为一个Spring的RestController，提供了一系列通用的接口方法，用于处理不同类型的业务逻辑，
* 如获取数据选项、根据条件获取记录、修改数据状态、统计数据等操作。
*/ */
@RestController @RestController
public class CommonController{ public class CommonController {
@Autowired
private CommonService commonService; // 自动注入CommonService，用于处理通用的业务逻辑
@Autowired
private CommonService commonService;
// 定义百度AI人脸识别客户端对象，初始化为null
private static AipFace client = null; private static AipFace client = null;
// 自动注入ConfigService，可能用于获取配置相关信息
@Autowired @Autowired
private ConfigService configService; private ConfigService configService;
/**
* 获取table表中的column列表(联动接口) /**
* @param table * 获取table表中的column列表（联动接口）
* @param column * 根据传入的表名、列名以及一些可选的条件参数，获取指定表中指定列的列表数据，可能用于下拉框等联动选择场景。
* @return *
*/ * @param tableName 表名
@RequestMapping("/option/{tableName}/{columnName}") * @param columnName 列名
@IgnoreAuth * @param conditionColumn 可选的条件列名，用于进一步筛选数据
public R getOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,@RequestParam(required = false) String conditionColumn,@RequestParam(required = false) String conditionValue,String level,String parent) { * @param conditionValue 可选的条件值，与conditionColumn配合使用来筛选数据
Map<String, Object> params = new HashMap<String, Object>(); * @param level 可选的层级参数，可能用于表示数据的层次结构相关的筛选
params.put("table", tableName); * @param parent 可选的父级参数，可能用于表示数据的父子关系相关的筛选
params.put("column", columnName); * @return 返回包含获取到的列列表数据的R对象，R对象通常用于封装返回结果信息
if(StringUtils.isNotBlank(level)) { */
params.put("level", level); @RequestMapping("/option/{tableName}/{columnName}")
} @IgnoreAuth
if(StringUtils.isNotBlank(parent)) { public R getOption(@PathVariable("tableName") String tableName, @PathVariable("tableName") String columnName,
params.put("parent", parent); @RequestParam(required = false) String conditionColumn,
} @RequestParam(required = false) String conditionValue, String level, String parent) {
if(StringUtils.isNotBlank(conditionColumn)) { // 创建一个用于存储参数的Map对象
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("column", columnName);
if (StringUtils.isNotBlank(level)) {
params.put("level", level);
}
if (StringUtils.isNotBlank(parent)) {
params.put("parent", parent);
}
if (StringUtils.isNotBlank(conditionColumn)) {
params.put("conditionColumn", conditionColumn); params.put("conditionColumn", conditionColumn);
} }
if(StringUtils.isNotBlank(conditionValue)) { if (StringUtils.isNotBlank(conditionValue)) {
params.put("conditionValue", conditionValue); params.put("conditionValue", conditionValue);
} }
List<String> data = commonService.getOption(params);
return R.ok().put("data", data);
}
/**
* 根据table中的column获取单条记录
* @param table
* @param column
* @return
*/
@RequestMapping("/follow/{tableName}/{columnName}")
@IgnoreAuth
public R getFollowByOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, @RequestParam String columnValue) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("column", columnName);
params.put("columnValue", columnValue);
Map<String, Object> result = commonService.getFollowByOption(params);
return R.ok().put("data", result);
}
/**
* 修改table表的sfsh状态
* @param table
* @param map
* @return
*/
@RequestMapping("/sh/{tableName}")
public R sh(@PathVariable("tableName") String tableName, @RequestBody Map<String, Object> map) {
map.put("table", tableName);
commonService.sh(map);
return R.ok();
}
/**
* 获取需要提醒的记录数
* @param tableName
* @param columnName
* @param type 1:数字 2:日期
* @param map
* @return
*/
@RequestMapping("/remind/{tableName}/{columnName}/{type}")
@IgnoreAuth
public R remindCount(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,
@PathVariable("type") String type,@RequestParam Map<String, Object> map) {
map.put("table", tableName);
map.put("column", columnName);
map.put("type", type);
if(type.equals("2")) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Calendar c = Calendar.getInstance();
Date remindStartDate = null;
Date remindEndDate = null;
if(map.get("remindstart")!=null) {
Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH,remindStart);
remindStartDate = c.getTime();
map.put("remindstart", sdf.format(remindStartDate));
}
if(map.get("remindend")!=null) {
Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH,remindEnd);
remindEndDate = c.getTime();
map.put("remindend", sdf.format(remindEndDate));
}
}
int count = commonService.remindCount(map);
return R.ok().put("count", count);
}
/**
* 单列求和
*/
@RequestMapping("/cal/{tableName}/{columnName}")
@IgnoreAuth
public R cal(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("column", columnName);
Map<String, Object> result = commonService.selectCal(params);
return R.ok().put("data", result);
}
/**
* 分组统计
*/
@RequestMapping("/group/{tableName}/{columnName}")
@IgnoreAuth
public R group(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("column", columnName);
List<Map<String, Object>> result = commonService.selectGroup(params);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for(Map<String, Object> m : result) {
for(String k : m.keySet()) {
if(m.get(k) instanceof Date) {
m.put(k, sdf.format((Date)m.get(k)));
}
}
}
return R.ok().put("data", result);
}
/**
* （按值统计）
*/
@RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}")
@IgnoreAuth
public R value(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("xColumn", xColumnName);
params.put("yColumn", yColumnName);
List<Map<String, Object>> result = commonService.selectValue(params);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for(Map<String, Object> m : result) {
for(String k : m.keySet()) {
if(m.get(k) instanceof Date) {
m.put(k, sdf.format((Date)m.get(k)));
}
}
}
return R.ok().put("data", result);
}
/**
* （按值统计）时间统计类型
*/
@IgnoreAuth
@RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}/{timeStatType}")
public R valueDay(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("xColumn", xColumnName);
params.put("yColumn", yColumnName);
params.put("timeStatType", timeStatType);
List<Map<String, Object>> result = commonService.selectTimeStatValue(params);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for(Map<String, Object> m : result) {
for(String k : m.keySet()) {
if(m.get(k) instanceof Date) {
m.put(k, sdf.format((Date)m.get(k)));
}
}
}
return R.ok().put("data", result);
}
// 调用commonService的getOption方法获取数据列表
List<String> data = commonService.getOption(params);
// 返回包含数据列表的R对象，结果状态为成功
return R.ok().put("data", data);
}
/**
* 根据table中的column获取单条记录
* 根据传入的表名、列名以及指定的列值，从指定表中获取满足条件的单条记录数据。
*
* @param tableName 表名
* @param columnName 列名
* @param columnValue 用于筛选的列值，根据该值在指定列中查找匹配的记录
* @return 返回包含获取到的单条记录数据的R对象
*/
@RequestMapping("/follow/{tableName}/{columnName}")
@IgnoreAuth
public R getFollowByOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,
@RequestParam String columnValue) {
// 创建一个用于存储参数的Map对象
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("column", columnName);
params.put("columnValue", columnValue);
// 调用commonService的getFollowByOption方法获取单条记录数据
Map<String, Object> result = commonService.getFollowByOption(params);
// 返回包含单条记录数据的R对象，结果状态为成功
return R.ok().put("data", result);
}
/**
* 修改table表的sfsh状态
* 根据传入的表名和一个包含修改信息的Map对象，调用commonService的sh方法来修改指定表的sfsh状态。
*
* @param tableName 表名
* @param map 包含修改信息的Map对象，具体内容由调用方确定，通常包含要修改的字段和对应的值等信息
* @return 返回表示修改操作成功的R对象
*/
@RequestMapping("/sh/{tableName}")
public R sh(@PathVariable("tableName") String tableName, @RequestBody Map<String, Object> map) {
map.put("table", tableName);
commonService.sh(map);
return R.ok();
}
/**
* 获取需要提醒的记录数
* 根据传入的表名、列名、类型以及一个包含其他条件的Map对象，计算并获取满足条件的需要提醒的记录数量。
* 当类型为2时，会根据传入的提醒开始时间和结束时间进行日期范围的计算和筛选。
*
* @param tableName 表名
* @param columnName 列名
* @param type 类型参数，1表示数字类型的提醒条件，2表示日期类型的提醒条件
* @param map 包含其他条件的Map对象，如提醒开始时间、提醒结束时间等（当type为2时相关）
* @return 返回包含需要提醒的记录数的R对象
*/
@RequestMapping("/remind/{tableName}/{columnName}/{type}")
@IgnoreAuth
public R remindCount(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,
@PathVariable("type") String type, @RequestParam Map<String, Object> map) {
map.put("table", tableName);
map.put("column", columnName);
map.put("type", type);
if (type.equals("2")) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Calendar c = Calendar.getInstance();
Date remindStartDate = null;
Date remindEndDate = null;
if (map.get("remindstart")!= null) {
Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH, remindStart);
remindStartDate = c.getTime();
map.put("remindstart", sdf.format(remindStartDate));
}
if (map.get("remindend")!= null) {
Integer recommendEnd = Integer.parseInt(map.get("remindend").toString());
c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH, recommendEnd);
remindEndDate = c.getTime();
map.put("remindend", sdf.format(remindEndDate));
}
}
// 调用commonService的remindCount方法获取需要提醒的记录数
int count = commonService.remindCount(map);
// 返回包含记录数的R对象，结果状态为成功
return R.ok().put("count", count);
}
/**
* 单列求和
* 根据传入的表名和列名，调用commonService的selectCal方法对指定表中的指定列进行求和操作，并返回结果。
*
* @param tableName 表名
* @param columnName 列名
* @return 返回包含求和结果的R对象
*/
@RequestMapping("/cal/{tableName}/{columnName}")
@IgnoreAuth
public R cal(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("column", columnName);
// 调用commonService的selectCal方法进行求和操作并获取结果
Map<String, Object> result = commonService.selectCal(params);
// 返回包含求和结果的R对象，结果状态为成功
return R.ok().put("data", result);
}
/**
* 分组统计
* 根据传入的表名和列名，调用commonService的selectGroup方法对指定表中的指定列进行分组统计操作，
* 并对结果中的日期类型数据进行格式化处理后返回。
*
* @param tableName 表名
， @param columnName 列名
* @return 返回包含分组统计结果的R对象
*/
@RequestMapping("/group/{tableName}/{columnName}")
@IgnoreAuth
public R group(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("column", columnName);
// 调用commonService的selectGroup方法进行分组统计操作并获取结果
List<Map<String, Object>> result = commonService.selectGroup(params);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (Map<String, Object> m : result) {
for (String k : m.keySet()) {
if (m.get(k) instanceof Date) {
m.put(k, sdf.format((Date) m.get(k)));
}
}
}
// 返回包含分组统计结果的R对象，结果状态为成功
return R.ok().put("data", result);
}
/**
* （按值统计）
* 根据传入的表名、x列名和y列名，调用commonService的selectValue方法对指定表中的指定列进行按值统计操作，
* 并对结果中的日期类型数据进行格式化处理后返回。
*
* @param tableName 表名
* @param yColumnName 用于统计的y列名
* @param xColumnName 用于分组的x列名
* @return 返回包含按值统计结果的R对象
*/
@RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}")
@IgnoreAuth
public R value(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName,
@PathVariable("xColumnName") String xColumnName) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("xColumn", xColumnName);
params.put("yColumn", yColumnName);
// 调用commonService的selectValue方法进行按值统计操作并获取结果
List<Map<String, Object> > result = commonService.selectValue(params);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (Map<String, Object> m : result) {
for (String k : m.keySet()) {
if (m.get(k) instanceof Date) {
m.put(k, sdf.format((Date) m.get(k)));
}
}
}
// 返回包含按值统计结果的R对象，结果状态为成功
return R.ok().put("data", result);
}
/**
* （按值统计）时间统计类型
* 根据传入的表名、x列名、y列名和时间统计类型，调用commonService的selectTimeStatValue方法对指定表中的指定列进行按值统计操作，
* 并对结果中的日期类型数据进行格式化处理后返回。
*
* @param tableName 表名
* @param yColumnName 用于统计的y列名
* @param xColumnName 用于分组的x列名
* @param timeStatType 时间统计类型参数
* @return 返回包含按值统计结果的R对象
*/
@RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}/{timeStatType}")
@IgnoreAuth
public R valueDay(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName,
@PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("xColumn", xColumnName);
params.put("yColumn", yColumnName);
params.put("timeStatType", timeStatType);
// 调用commonService的selectTimeStatValue方法进行按值统计操作并获取结果
List<Map<String, Object> > result = commonService.selectTimeStatValue(params);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (Map<String, Object> m : result) {
for (String k : m.keySet()) {
if (m.get(k) instanceof Date) {
m.put(k, sdf.format((Date) m.get(k)));
}
}
}
// 返回包含按值统计结果的R对象，结果状态为成功
return R.ok().put("data", result);
}
} }

419
src/main/java/com/controller/WenjuandafuController.java
Unescape View File

@ -1,36 +1,28 @@
package com.controller; package com.controller;
import java.math.BigDecimal; import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.text.ParseException; import java.text.ParseException;
import java.text.SimpleDateFormat;
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.Date;
import java.util.HashMap; import java.util.HashMap;
import java.util.Iterator; import java.util.Iterator;
import java.util.Date;
import java.util.List; import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import com.utils.ValidatorUtils;
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;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.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.Wrapper;
import com.annotation.IgnoreAuth; import com.annotation.IgnoreAuth;
import com.entity.WenjuandafuEntity; import com.entity.WenjuandafuEntity;
import com.entity.view.WenjuandafuView; import com.entity.view.WenjuandafuView;
import com.service.WenjuandafuService; import com.service.WenjuandafuService;
import com.service.TokenService; import com.service.TokenService;
import com.utils.PageUtils; import com.utils.PageUtils;
@ -40,11 +32,7 @@ import com.utils.MPUtil;
import com.utils.CommonUtil; import com.utils.CommonUtil;
/** /**
* 问卷答复 * 问卷答复控制器，提供问卷答复的增删改查接口。
* 后端接口
* @author
* @email
* @date 2023-02-21 09:46:06
*/ */
@RestController @RestController
@RequestMapping("/wenjuandafu") @RequestMapping("/wenjuandafu")
@ -52,66 +40,57 @@ public class WenjuandafuController {
@Autowired @Autowired
private WenjuandafuService wenjuandafuService; private WenjuandafuService wenjuandafuService;
/** /**
* 后端列表 * 获取问卷答复列表（分页）
* @param params 请求参数
* @param wenjuandafu 查询条件
* @param request HTTP请求对象
* @return 包含问卷答复列表的响应结果
*/ */
@RequestMapping("/page") @RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params,WenjuandafuEntity wenjuandafu, public R page(@RequestParam Map<String, Object> params, WenjuandafuEntity wenjuandafu, HttpServletRequest request){
HttpServletRequest request){ String tableName = request.getSession().getAttribute("tableName").toString();
if(tableName.equals("yonghu")) {
String tableName = request.getSession().getAttribute("tableName").toString(); wenjuandafu.setZhanghao((String)request.getSession().getAttribute("username"));
if(tableName.equals("yonghu")) { }
wenjuandafu.setZhanghao((String)request.getSession().getAttribute("username"));
}
EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>(); EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>();
PageUtils page = wenjuandafuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandafu), params), params));
PageUtils page = wenjuandafuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandafu), 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 wenjuandafu 查询条件
* @param request HTTP请求对象
* @return 包含问卷答复列表的响应结果
*/ */
@IgnoreAuth @IgnoreAuth
@RequestMapping("/list") @RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params,WenjuandafuEntity wenjuandafu, public R list(@RequestParam Map<String, Object> params, WenjuandafuEntity wenjuandafu, HttpServletRequest request){
HttpServletRequest request){
EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>(); EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>();
PageUtils page = wenjuandafuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandafu), params), params));
PageUtils page = wenjuandafuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandafu), params), params)); request.setAttribute("data", page);
request.setAttribute("data", page);
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* 列表 * 获取所有问卷答复列表
* @param wenjuandafu 查询条件
* @return 包含问卷答复列表的响应结果
*/ */
@RequestMapping("/lists") @RequestMapping("/lists")
public R list( WenjuandafuEntity wenjuandafu){ public R lists(WenjuandafuEntity wenjuandafu){
EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>(); EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>();
ew.allEq(MPUtil.allEQMapPre( wenjuandafu, "wenjuandafu")); ew.allEq(MPUtil.allEQMapPre( wenjuandafu, "wenjuandafu"));
return R.ok().put("data", wenjuandafuService.selectListView(ew)); return R.ok().put("data", wenjuandafuService.selectListView(ew));
} }
/**
* 查询
*/
@RequestMapping("/query")
public R query(WenjuandafuEntity wenjuandafu){
EntityWrapper< WenjuandafuEntity> ew = new EntityWrapper< WenjuandafuEntity>();
ew.allEq(MPUtil.allEQMapPre( wenjuandafu, "wenjuandafu"));
WenjuandafuView wenjuandafuView = wenjuandafuService.selectView(ew);
return R.ok("查询问卷答复成功").put("data", wenjuandafuView);
}
/** /**
* 后端详情 * 查询单个问卷答复信息
* @param id 问卷答复ID
* @return 包含问卷答复信息的响应结果
*/ */
@RequestMapping("/info/{id}") @RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id){ public R info(@PathVariable("id") Long id){
@ -120,58 +99,63 @@ public class WenjuandafuController {
} }
/** /**
* 前端详情 * 前端详情页面显示问卷答复信息
* @param id 问卷答复ID
* @return 包含问卷答复信息的响应结果
*/ */
@IgnoreAuth @IgnoreAuth
@RequestMapping("/detail/{id}") @RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id){ public R detail(@PathVariable("id") Long id){
WenjuandafuEntity wenjuandafu = wenjuandafuService.selectById(id); WenjuandafuEntity wenjuandafu = wenjuandafuService.selectById(id);
return R.ok().put("data", wenjuandafu); return R.ok().put("data", wenjuandafu);
} }
/** /**
* 后端保存 * 保存问卷答复信息
* @param wenjuandafu 问卷答复实体对象
* @param request HTTP请求对象
* @return 操作结果响应
*/ */
@RequestMapping("/save") @RequestMapping("/save")
public R save(@RequestBody WenjuandafuEntity wenjuandafu, HttpServletRequest request){ public R save(@RequestBody WenjuandafuEntity wenjuandafu, HttpServletRequest request){
wenjuandafu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); wenjuandafu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
//ValidatorUtils.validateEntity(wenjuandafu); //ValidatorUtils.validateEntity(wenjuandafu); // 验证实体对象（注释掉）
wenjuandafuService.insert(wenjuandafu); wenjuandafuService.insert(wenjuandafu);
return R.ok(); return R.ok();
} }
/** /**
* 前端保存 * 前端保存问卷答复信息
* @param wenjuandafu 问卷答复实体对象
* @param request HTTP请求对象
* @return 操作结果响应
*/ */
@RequestMapping("/add") @RequestMapping("/add")
public R add(@RequestBody WenjuandafuEntity wenjuandafu, HttpServletRequest request){ public R add(@RequestBody WenjuandafuEntity wenjuandafu, HttpServletRequest request){
wenjuandafu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); wenjuandafu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
//ValidatorUtils.validateEntity(wenjuandafu); //ValidatorUtils.validateEntity(wenjuandafu); // 验证实体对象（注释掉）
wenjuandafuService.insert(wenjuandafu); wenjuandafuService.insert(wenjuandafu);
return R.ok(); return R.ok();
} }
/** /**
* 修改 * 修改问卷答复信息
* @param wenjuandafu 问卷答复实体对象
* @param request HTTP请求对象
* @return 操作结果响应
*/ */
@RequestMapping("/update") @RequestMapping("/update")
@Transactional @Transactional
public R update(@RequestBody WenjuandafuEntity wenjuandafu, HttpServletRequest request){ public R update(@RequestBody WenjuandafuEntity wenjuandafu, HttpServletRequest request){
//ValidatorUtils.validateEntity(wenjuandafu); //ValidatorUtils.validateEntity(wenjuandafu); // 验证实体对象（注释掉）
wenjuandafuService.updateById(wenjuandafu);//全部更新 wenjuandafuService.updateById(wenjuandafu); //更新全部字段
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){
@ -181,50 +165,59 @@ public class WenjuandafuController {
/** /**
* 提醒接口 * 提醒接口
* @param columnName 列名
* @param type 类型（2：日期范围）
* @param request HTTP请求对象
* @param map 请求参数
* @return 符合条件的记录数响应
*/ */
@RequestMapping("/remind/{columnName}/{type}") @RequestMapping("/remind/{columnName}/{type}")
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, public R remindCount(@PathVariable("columnName") String columnName, @PathVariable("type") String type, HttpServletRequest request, @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")) { // 如果类型是日期范围
if(type.equals("2")) { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); Calendar c = Calendar.getInstance(); // 获取当前日期实例
Calendar c = Calendar.getInstance(); //初始话开始和结束日期
Date remindStartDate = null; Date remindStartDate = null;
Date remindEndDate = null; Date remindEndDate = null;
if(map.get("remindstart")!=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());
c.setTime(new Date()); if(map.get("remindend") != null) { // 如果请求参数中包含结束日期
c.add(Calendar.DAY_OF_MONTH,remindEnd); Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); // 获取结束日期天数差值
remindEndDate = c.getTime(); c.setTime(new Date()); // 设置当前日期时间
map.put("remindend", sdf.format(remindEndDate)); c.add(Calendar.DAY_OF_MONTH, remindEnd);
} remindEndDate = c.getTime(); // 获取计算后的结束日期
} map.put("remindend", sdf.format(remindEndDate)); // 将结束日期格式化并放入请求参数中
}
Wrapper<WenjuandafuEntity> wrapper = new EntityWrapper<WenjuandafuEntity>(); }
if(map.get("remindstart")!=null) {
wrapper.ge(columnName, map.get("remindstart")); String tableName = request.getSession().getAttribute("tableName").toString(); // 获取表名
} if(tableName.equals("yonghu")) { // 如果表名是用户表
if(map.get("remindend")!=null) { map.put("zhanghao", (String)request.getSession().getAttribute("username")); // 添加用户名到请求参数中作为过滤条件
wrapper.le(columnName, map.get("remindend")); }
}
Wrapper<WenjuandafuEntity> wrapper = new EntityWrapper<WenjuandafuEntity>(); // 创建查询包装器实例
String tableName = request.getSession().getAttribute("tableName").toString();
if(tableName.equals("yonghu")) { if(map.get("remindstart") != null) {
wrapper.eq("zhanghao", (String)request.getSession().getAttribute("username")); wrapper.ge(columnName, map.get("remindstart")); // 添加大于等于开始日期的条件到查询包装器中
} }
if(map.get("remindend") != null) {
int count = wenjuandafuService.selectCount(wrapper); wrapper.le(columnName, map.get("remindend"));
return R.ok().put("count", count); }
}
int count = wenjuandafuService.selectCount(wrapper); // 根据查询包装器统计符合条件的记录数
return R.ok().put("count", count); // 返回符合条件的记录数响应
}
}
@ -235,94 +228,136 @@ public class WenjuandafuController {
/** /**
* （按值统计） * （按值统计）
*/ */
@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>(); // 创建参数映射，用于存储请求中的列名
params.put("xColumn", xColumnName); Map<String, Object> params = new HashMap<String, Object>();
params.put("yColumn", yColumnName); params.put("xColumn", xColumnName);
EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>(); params.put("yColumn", yColumnName);
String tableName = request.getSession().getAttribute("tableName").toString();
if(tableName.equals("yonghu")) { // 创建实体包装器，用于构建查询条件
ew.eq("zhanghao", (String)request.getSession().getAttribute("username")); EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>();
}
List<Map<String, Object>> result = wenjuandafuService.selectValue(params, ew); // 获取当前会话中的表名
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); String tableName = request.getSession().getAttribute("tableName").toString();
for(Map<String, Object> m : result) {
for(String k : m.keySet()) { // 如果表名为"yonghu"，则添加用户账号作为查询条件
if(m.get(k) instanceof Date) { if (tableName.equals("yonghu")) {
m.put(k, sdf.format((Date)m.get(k))); ew.eq("zhanghao", (String) request.getSession().getAttribute("username"));
}
}
}
return R.ok().put("data", result);
} }
/** // 调用服务层方法进行数据查询
* （按值统计）时间统计类型 List<Map<String, Object>> result = wenjuandafuService.selectValue(params, ew);
*/
@RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}") // 格式化日期对象为字符串
public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType,HttpServletRequest request) { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Map<String, Object> params = new HashMap<String, Object>(); for (Map<String, Object> m : result) {
params.put("xColumn", xColumnName); for (String k : m.keySet()) {
params.put("yColumn", yColumnName); if (m.get(k) instanceof Date) {
params.put("timeStatType", timeStatType); m.put(k, sdf.format((Date) m.get(k)));
EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>();
String tableName = request.getSession().getAttribute("tableName").toString();
if(tableName.equals("yonghu")) {
ew.eq("zhanghao", (String)request.getSession().getAttribute("username"));
}
List<Map<String, Object>> result = wenjuandafuService.selectTimeStatValue(params, ew);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for(Map<String, Object> m : result) {
for(String k : m.keySet()) {
if(m.get(k) instanceof Date) {
m.put(k, sdf.format((Date)m.get(k)));
}
} }
} }
return R.ok().put("data", result);
} }
/** // 返回封装好的响应结果
* 分组统计 return R.ok().put("data", result);
*/ }
@RequestMapping("/group/{columnName}")
public R group(@PathVariable("columnName") String columnName,HttpServletRequest request) { /**
Map<String, Object> params = new HashMap<String, Object>(); * （按值统计）时间统计类型
params.put("column", columnName); */
EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>(); @RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}")
String tableName = request.getSession().getAttribute("tableName").toString(); public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType, HttpServletRequest request) {
if(tableName.equals("yonghu")) { // 创建参数映射，用于存储请求中的列名和时间统计类型
ew.eq("zhanghao", (String)request.getSession().getAttribute("username")); Map<String, Object> params = new HashMap<String, Object>();
} params.put("xColumn", xColumnName);
List<Map<String, Object>> result = wenjuandafuService.selectGroup(params, ew); params.put("yColumn", yColumnName);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); params.put("timeStatType", timeStatType);
for(Map<String, Object> m : result) {
for(String k : m.keySet()) { // 创建实体包装器，用于构建查询条件
if(m.get(k) instanceof Date) { EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>();
m.put(k, sdf.format((Date)m.get(k)));
} // 获取当前会话中的表名
String tableName = request.getSession().getAttribute("tableName").toString();
// 如果表名为"yonghu"，则添加用户账号作为查询条件
if (tableName.equals("yonghu")) {
ew.eq("zhanghao", (String) request.getSession().getAttribute("username"));
}
// 调用服务层方法进行数据查询
List<Map<String, Object>> result = wenjuandafuService.selectTimeStatValue(params, ew);
// 格式化日期对象为字符串
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (Map<String, Object> m : result) {
for (String k : m.keySet()) {
if (m.get(k) instanceof Date) {
m.put(k, sdf.format((Date) m.get(k)));
} }
} }
return R.ok().put("data", result);
} }
// 返回封装好的响应结果
return R.ok().put("data", result);
}
/**
* 分组统计
*/
@RequestMapping("/group/{columnName}")
public R group(@PathVariable("columnName") String columnName, HttpServletRequest request) {
// 创建参数映射，用于存储请求中的列名
Map<String, Object> params = new HashMap<String, Object>();
params.put("column", columnName);
// 创建实体包装器，用于构建查询条件
EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>();
/** // 获取当前会话中的表名
* 总数量 String tableName = request.getSession().getAttribute("tableName").toString();
*/
@RequestMapping("/count") // 如果表名为"yonghu"，则添加用户账号作为查询条件
public R count(@RequestParam Map<String, Object> params,WenjuandafuEntity wenjuandafu, HttpServletRequest request){ if (tableName.equals("yonghu")) {
String tableName = request.getSession().getAttribute("tableName").toString(); ew.eq("zhanghao", (String) request.getSession().getAttribute("username"));
if(tableName.equals("yonghu")) { }
wenjuandafu.setZhanghao((String)request.getSession().getAttribute("username"));
// 调用服务层方法进行数据查询
List<Map<String, Object>> result = wenjuandafuService.selectGroup(params, ew);
// 格式化日期对象为字符串
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (Map<String, Object> m : result) {
for (String k : m.keySet()) {
if (m.get(k) instanceof Date) {
m.put(k, sdf.format((Date) m.get(k)));
}
} }
EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>();
int count = wenjuandafuService.selectCount(MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandafu), params), params));
return R.ok().put("data", count);
} }
// 返回封装好的响应结果
return R.ok().put("data", result);
}
/**
* 总数量
*/
@RequestMapping("/count")
public R count(@RequestParam Map<String, Object> params, WenjuandafuEntity wenjuandafu, HttpServletRequest request) {
// 获取当前会话中的表名
String tableName = request.getSession().getAttribute("tableName").toString();
// 如果表名为"yonghu"，则添加用户账号作为查询条件
if (tableName.equals("yonghu")) {
wenjuandafu.setZhanghao((String) request.getSession().getAttribute("username"));
}
// 创建实体包装器，用于构建查询条件
EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>();
// 调用服务层方法进行数据查询并计算总数
int count = wenjuandafuService.selectCount(MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandafu), params), params));
// 返回封装好的响应结果
return R.ok().put("data", count);
} }

4
src/main/java/com/dao/ChatDao.java
Unescape View File

@ -21,9 +21,9 @@ import com.entity.view.ChatView;
*/ */
public interface ChatDao extends BaseMapper<ChatEntity> { public interface ChatDao extends BaseMapper<ChatEntity> {
List<ChatVO> selectListVO(@Param("ew") Wrapper<ChatEntity> wrapper); List<ChatVO> selectListVO(@Param("ew") Wrapper<ChatEntity> wrapper);//根据给定的条件包装器（Wrapper）查询并返回符合条件的ChatVO列表
ChatVO selectVO(@Param("ew") Wrapper<ChatEntity> wrapper); ChatVO selectVO(@Param("ew") Wrapper<ChatEntity> wrapper);//根据给定的条件包装器（Wrapper）查询并返回符合条件的ChatView列表
List<ChatView> selectListView(@Param("ew") Wrapper<ChatEntity> wrapper); List<ChatView> selectListView(@Param("ew") Wrapper<ChatEntity> wrapper);

67
src/main/java/com/dao/CommonDao.java
Unescape View File

@ -5,24 +5,69 @@ import java.util.List;
import java.util.Map; import java.util.Map;
/** /**
* 通用接口 * 通用接口，定义了一组用于数据库操作的方法。
*/ */
public interface CommonDao{ public interface CommonDao {
List<String> getOption(Map<String, Object> params);
Map<String, Object> getFollowByOption(Map<String, Object> params); /**
* 根据给定的参数获取选项列表。
* @param params 包含查询条件的参数映射
* @return 返回一个字符串列表，表示查询结果
*/
List<String> getOption(Map<String, Object> params);
List<String> getFollowByOption2(Map<String, Object> params); /**
* 根据给定的参数获取关注信息。
* @param params 包含查询条件的参数映射
* @return 返回一个包含关注信息的映射
*/
Map<String, Object> getFollowByOption(Map<String, Object> params);
void sh(Map<String, Object> params); /**
* 根据给定的参数获取另一种形式的关注信息列表。
* @param params 包含查询条件的参数映射
* @return 返回一个字符串列表，表示查询结果
*/
List<String> getFollowByOption2(Map<String, Object> params);
int remindCount(Map<String, Object> params); /**
* 执行某种操作（具体操作未明确）。
* @param params 包含操作所需参数的映射
*/
void sh(Map<String, Object> params);
Map<String, Object> selectCal(Map<String, Object> params); /**
* 计算提醒的数量。
* @param params 包含查询条件的参数映射
* @return 返回提醒的数量
*/
int remindCount(Map<String, Object> params);
List<Map<String, Object>> selectGroup(Map<String, Object> params); /**
* 根据给定的参数进行某种计算。
* @param params 包含计算所需参数的映射
* @return 返回一个包含计算结果的映射
*/
Map<String, Object> selectCal(Map<String, Object> params);
List<Map<String, Object>> selectValue(Map<String, Object> params); /**
* 根据给定的参数分组查询。
* @param params 包含查询条件的参数映射
* @return 返回一个包含分组查询结果的映射列表
*/
List<Map<String, Object>> selectGroup(Map<String, Object> params);
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params); /**
* 根据给定的参数查询值。
* @param params 包含查询条件的参数映射
* @return 返回一个包含查询结果的映射列表
*/
List<Map<String, Object>> selectValue(Map<String, Object> params);
/**
* 根据给定的参数查询时间统计值。
* @param params 包含查询条件的参数映射
* @return 返回一个包含时间统计值的映射列表
*/
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params);
} }

79
src/main/java/com/dao/WenjuandafuDao.java
Unescape View File

@ -1,4 +1,4 @@
package com.dao; ppackage com.dao;
import com.entity.WenjuandafuEntity; import com.entity.WenjuandafuEntity;
import com.baomidou.mybatisplus.mapper.BaseMapper; import com.baomidou.mybatisplus.mapper.BaseMapper;
@ -11,33 +11,70 @@ import org.apache.ibatis.annotations.Param;
import com.entity.vo.WenjuandafuVO; import com.entity.vo.WenjuandafuVO;
import com.entity.view.WenjuandafuView; import com.entity.view.WenjuandafuView;
/** /**
* 问卷答复 * 问卷答复数据访问对象接口
* * 提供对问卷答复数据的查询功能
* @author * 使用MyBatis-Plus框架进行数据库操作
* @email
* @date 2023-02-21 09:46:06
*/ */
public interface WenjuandafuDao extends BaseMapper<WenjuandafuEntity> { public interface WenjuandafuDao extends BaseMapper<WenjuandafuEntity> {
List<WenjuandafuVO> selectListVO(@Param("ew") Wrapper<WenjuandafuEntity> wrapper); /**
* 根据条件查询问卷答复的VO列表
WenjuandafuVO selectVO(@Param("ew") Wrapper<WenjuandafuEntity> wrapper); * @param wrapper 查询条件封装器
* @return 符合条件的问卷答复VO列表
List<WenjuandafuView> selectListView(@Param("ew") Wrapper<WenjuandafuEntity> wrapper); */
List<WenjuandafuVO> selectListVO(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
List<WenjuandafuView> selectListView(Pagination page,@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
/**
WenjuandafuView selectView(@Param("ew") Wrapper<WenjuandafuEntity> wrapper); * 根据条件查询单个问卷答复的VO
* @param wrapper 查询条件封装器
* @return 符合条件的单个问卷答复VO
*/
WenjuandafuVO selectVO(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
/**
* 根据条件查询问卷答复的视图列表
* @param wrapper 查询条件封装器
* @return 符合条件的问卷答复视图列表
*/
List<WenjuandafuView> selectListView(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
/**
* 根据分页信息和条件查询问卷答复的视图列表
* @param page 分页信息
* @param wrapper 查询条件封装器
* @return 符合条件的问卷答复视图列表（分页）
*/
List<WenjuandafuView> selectListView(Pagination page,@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
/**
* 根据条件查询单个问卷答复的视图
* @param wrapper 查询条件封装器
* @return 符合条件的单个问卷答复视图
*/
WenjuandafuView selectView(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
/**
* 根据参数查询问卷答复的值统计结果
* @param params 查询参数
* @param wrapper 查询条件封装器
* @return 值统计结果列表
*/
List<Map<String, Object>> selectValue(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<WenjuandafuEntity> wrapper); List<Map<String, Object>> selectValue(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
/**
* 根据参数查询问卷答复的时间统计值
* @param params 查询参数
* @param wrapper 查询条件封装器
* @return 时间统计值列表
*/
List<Map<String, Object>> selectTimeStatValue(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<WenjuandafuEntity> wrapper); List<Map<String, Object>> selectTimeStatValue(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
/**
* 根据参数查询问卷答复的分组统计结果
* @param params 查询参数
* @param wrapper 查询条件封装器
* @return 分组统计结果列表
*/
List<Map<String, Object>> selectGroup(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<WenjuandafuEntity> wrapper); List<Map<String, Object>> selectGroup(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
} }

37
src/main/java/com/dao/YonghuDao.java
Unescape View File

@ -6,38 +6,37 @@ 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.YonghuVO; import com.entity.vo.YonghuVO;
import com.entity.view.YonghuView; import com.entity.view.YonghuView;
/** /**
* 用户 * 用户数据访问对象接口，继承自MyBatis-Plus的BaseMapper。
* * 提供对用户实体（YonghuEntity）的数据库操作方法。
* @author
* @email
* @date 2023-02-21 09:46:06
*/ */
public interface YonghuDao extends BaseMapper<YonghuEntity> { public interface YonghuDao extends BaseMapper<YonghuEntity> {
List<YonghuVO> selectListVO(@Param("ew") Wrapper<YonghuEntity> wrapper); // 根据条件查询用户视图对象列表
List<YonghuVO> selectListVO(@Param("ew") Wrapper<YonghuEntity> wrapper);
YonghuVO selectVO(@Param("ew") Wrapper<YonghuEntity> wrapper);
List<YonghuView> selectListView(@Param("ew") Wrapper<YonghuEntity> wrapper);
List<YonghuView> selectListView(Pagination page,@Param("ew") Wrapper<YonghuEntity> wrapper);
YonghuView selectView(@Param("ew") Wrapper<YonghuEntity> wrapper);
// 根据条件查询单个用户视图对象
YonghuVO selectVO(@Param("ew") Wrapper<YonghuEntity> wrapper);
List<Map<String, Object>> selectValue(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<YonghuEntity> wrapper); // 根据条件查询用户视图对象列表
List<YonghuView> selectListView(@Param("ew") Wrapper<YonghuEntity> wrapper);
List<Map<String, Object>> selectTimeStatValue(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<YonghuEntity> wrapper); // 根据分页信息和条件查询用户视图对象列表
List<YonghuView> selectListView(Pagination page, @Param("ew") Wrapper<YonghuEntity> wrapper);
List<Map<String, Object>> selectGroup(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<YonghuEntity> wrapper); // 根据条件查询单个用户视图对象
YonghuView selectView(@Param("ew") Wrapper<YonghuEntity> wrapper);
// 根据参数和条件查询值映射列表
List<Map<String, Object>> selectValue(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<YonghuEntity> wrapper);
// 根据参数和条件查询时间统计值映射列表
List<Map<String, Object>> selectTimeStatValue(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<YonghuEntity> wrapper);
// 根据参数和条件分组查询映射列表
List<Map<String, Object>> selectGroup(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<YonghuEntity> wrapper);
} }

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

@ -12,8 +12,6 @@ import java.io.Serializable;
/** /**
* 在线咨询 * 在线咨询
* 接收传参的实体类 * 接收传参的实体类
*（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
* 取自ModelAndView 的model名称
* @author * @author
* @email * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06

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

@ -12,8 +12,7 @@ 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

47
src/main/java/com/entity/view/WenjuandafuView.java
Unescape View File

@ -1,36 +1,35 @@
package com.entity.view; package com.entity.view;
import com.entity.WenjuandafuEntity; import com.entity.WenjuandafuEntity;
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;
/** /**
* 问卷答复 * 问卷答复视图实体类
* 后端返回视图实体辅助类 * 用于后端返回给前端的问卷答复数据，通常包括关联表的数据或自定义字段。
* （通常后端关联的表或者自定义的字段需要返回使用） * 继承自 WenjuandafuEntity，实现 Serializable 接口以支持序列化。
* @author
* @email
* @date 2023-02-21 09:46:06
*/ */
@TableName("wenjuandafu") @TableName("wenjuandafu")
public class WenjuandafuView extends WenjuandafuEntity implements Serializable { public class WenjuandafuView extends WenjuandafuEntity implements Serializable {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L; // 序列化版本号
public WenjuandafuView(){ // 无参构造函数
} public WenjuandafuView() {
}
public WenjuandafuView(WenjuandafuEntity wenjuandafuEntity){
try { /**
BeanUtils.copyProperties(this, wenjuandafuEntity); * 带参构造函数，通过传入的 WenjuandafuEntity 对象来初始化 WenjuandafuView 对象。
} catch (IllegalAccessException | InvocationTargetException e) { * @param wenjuandafuEntity 需要复制属性的 WenjuandafuEntity 实例
// TODO Auto-generated catch block */
e.printStackTrace(); public WenjuandafuView(WenjuandafuEntity wenjuandafuEntity) {
} try {
// 使用 BeanUtils 工具类将 wenjuandafuEntity 的属性值复制到当前对象中
} BeanUtils.copyProperties(this, wenjuandafuEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// 捕获并打印异常信息
e.printStackTrace();
}
}
} }

54
src/main/java/com/service/ChatService.java
Unescape View File

@ -10,9 +10,9 @@ import com.entity.vo.ChatVO;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import com.entity.view.ChatView; import com.entity.view.ChatView;
/** /**
* 在线咨询 * 在线咨询服务接口，提供对在线咨询相关数据的操作方法。
* 继承自 IService<ChatEntity>，利用 MyBatis-Plus 提供的通用 CRUD 操作。
* *
* @author * @author
* @email * @email
@ -20,18 +20,52 @@ import com.entity.view.ChatView;
*/ */
public interface ChatService extends IService<ChatEntity> { public interface ChatService extends IService<ChatEntity> {
/**
* 根据参数查询分页信息。
*
* @param params 包含查询条件的参数集合。
* @return 返回封装了分页信息的 PageUtils 对象。
*/
PageUtils queryPage(Map<String, Object> params); PageUtils queryPage(Map<String, Object> params);
List<ChatVO> selectListVO(Wrapper<ChatEntity> wrapper); /**
* 根据条件查询视图对象列表。
ChatVO selectVO(@Param("ew") Wrapper<ChatEntity> wrapper); *
* @param wrapper 查询条件包装器。
* @return 返回符合条件的视图对象列表。
*/
List<ChatVO> selectListVO(Wrapper<ChatEntity> wrapper);
List<ChatView> selectListView(Wrapper<ChatEntity> wrapper); /**
* 根据条件查询单个视图对象。
*
* @param wrapper 查询条件包装器。
* @return 返回符合条件的单个视图对象。
*/
ChatVO selectVO(@Param("ew") Wrapper<ChatEntity> wrapper);
ChatView selectView(@Param("ew") Wrapper<ChatEntity> wrapper); /**
* 根据条件查询视图对象列表。
PageUtils queryPage(Map<String, Object> params,Wrapper<ChatEntity> wrapper); *
* @param wrapper 查询条件包装器。
* @return 返回符合条件的视图对象列表。
*/
List<ChatView> selectListView(Wrapper<ChatEntity> wrapper);
/**
* 根据条件查询单个视图对象。
*
* @param wrapper 查询条件包装器。
* @return 返回符合条件的单个视图对象。
*/
ChatView selectView(@Param("ew") Wrapper<ChatEntity> wrapper);
/**
* 根据参数和条件查询分页信息。
*
* @param params 包含查询条件的参数集合。
* @param wrapper 查询条件包装器。
* @return 返回封装了分页信息的 PageUtils 对象。
*/
PageUtils queryPage(Map<String, Object> params, Wrapper<ChatEntity> wrapper);
} }

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

@ -3,20 +3,63 @@ package com.service;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
/**
* CommonService 接口定义了一组通用的服务方法，用于处理各种数据操作。
*/
public interface CommonService { public interface CommonService {
List<String> getOption(Map<String, Object> params);
Map<String, Object> getFollowByOption(Map<String, Object> params); /**
* 根据给定的参数获取选项列表。
* @param params 包含查询条件的参数集合。
* @return 返回一个字符串列表，表示选项。
*/
List<String> getOption(Map<String, Object> params);
void sh(Map<String, Object> params); /**
* 根据给定的参数获取关注信息。
* @param params 包含查询条件的参数集合。
* @return 返回一个包含关注信息的映射。
*/
Map<String, Object> getFollowByOption(Map<String, Object> params);
int remindCount(Map<String, Object> params); /**
* 执行某种操作（具体操作未明确）。
* @param params 包含操作所需参数的映射。
*/
void sh(Map<String, Object> params);
Map<String, Object> selectCal(Map<String, Object> params); /**
* 计算提醒的数量。
* @param params 包含查询条件的参数集合。
* @return 返回提醒的数量。
*/
int remindCount(Map<String, Object> params);
List<Map<String, Object>> selectGroup(Map<String, Object> params); /**
* 根据给定的参数选择并计算某些值。
* @param params 包含查询条件的参数集合。
* @return 返回一个包含计算结果的映射。
*/
Map<String, Object> selectCal(Map<String, Object> params);
List<Map<String, Object>> selectValue(Map<String, Object> params); /**
* 根据给定的参数选择分组信息。
* @param params 包含查询条件的参数集合。
* @return 返回一个包含分组信息的列表，每个元素是一个映射。
*/
List<Map<String, Object>> selectGroup(Map<String, Object> params);
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params); /**
* 根据给定的参数选择值信息。
* @param params 包含查询条件的参数集合。
* @return 返回一个包含值信息的列表，每个元素是一个映射。
*/
List<Map<String, Object>> selectValue(Map<String, Object> params);
/**
* 根据给定的参数选择时间统计值信息。
* @param params 包含查询条件的参数集合。
* @return 返回一个包含时间统计值信息的列表，每个元素是一个映射。
*/
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params);
} }

98
src/main/java/com/service/YonghuService.java
Unescape View File

@ -10,9 +10,10 @@ import com.entity.vo.YonghuVO;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import com.entity.view.YonghuView; import com.entity.view.YonghuView;
/** /**
* 用户 * 用户服务接口，定义了对用户实体进行操作的方法。
* 继承自 IService<YonghuEntity>，提供基本的 CRUD 操作。
* 包含分页查询、条件查询、视图对象查询等方法。
* *
* @author * @author
* @email * @email
@ -20,26 +21,79 @@ import com.entity.view.YonghuView;
*/ */
public interface YonghuService extends IService<YonghuEntity> { public interface YonghuService extends IService<YonghuEntity> {
/**
* 根据参数查询分页信息。
*
* @param params 包含查询条件的参数集合。
* @return 返回封装了分页信息的 PageUtils 对象。
*/
PageUtils queryPage(Map<String, Object> params); PageUtils queryPage(Map<String, Object> params);
List<YonghuVO> selectListVO(Wrapper<YonghuEntity> wrapper); /**
* 根据条件查询视图对象列表。
YonghuVO selectVO(@Param("ew") Wrapper<YonghuEntity> wrapper); *
* @param wrapper 查询条件包装器。
List<YonghuView> selectListView(Wrapper<YonghuEntity> wrapper); * @return 返回符合条件的视图对象列表。
*/
YonghuView selectView(@Param("ew") Wrapper<YonghuEntity> wrapper); List<YonghuVO> selectListVO(Wrapper<YonghuEntity> wrapper);
PageUtils queryPage(Map<String, Object> params,Wrapper<YonghuEntity> wrapper); /**
* 根据条件查询单个视图对象。
*
List<Map<String, Object>> selectValue(Map<String, Object> params,Wrapper<YonghuEntity> wrapper); * @param wrapper 查询条件包装器。
* @return 返回符合条件的单个视图对象。
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params,Wrapper<YonghuEntity> wrapper); */
YonghuVO selectVO(@Param("ew") Wrapper<YonghuEntity> wrapper);
List<Map<String, Object>> selectGroup(Map<String, Object> params,Wrapper<YonghuEntity> wrapper);
/**
* 根据条件查询视图对象列表。
*
* @param wrapper 查询条件包装器。
* @return 返回符合条件的视图对象列表。
*/
List<YonghuView> selectListView(Wrapper<YonghuEntity> wrapper);
/**
* 根据条件查询单个视图对象。
*
* @param wrapper 查询条件包装器。
* @return 返回符合条件的单个视图对象。
*/
YonghuView selectView(@Param("ew") Wrapper<YonghuEntity> wrapper);
/**
* 根据参数和条件查询分页信息。
*
* @param params 包含查询条件的参数集合。
* @param wrapper 查询条件包装器。
* @return 返回封装了分页信息的 PageUtils 对象。
*/
PageUtils queryPage(Map<String, Object> params, Wrapper<YonghuEntity> wrapper);
/**
* 根据参数和条件选择值信息。
*
* @param params 包含查询条件的参数集合。
* @param wrapper 查询条件包装器。
* @return 返回一个包含值信息的列表，每个元素是一个映射。
*/
List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<YonghuEntity> wrapper);
/**
* 根据参数和条件选择时间统计值信息。
*
* @param params 包含查询条件的参数集合。
* @param wrapper 查询条件包装器。
* @return 返回一个包含时间统计值信息的列表，每个元素是一个映射。
*/
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<YonghuEntity> wrapper);
/**
* 根据参数和条件选择分组信息。
*
* @param params 包含查询条件的参数集合。
* @param wrapper 查询条件包装器。
* @return 返回一个包含分组信息的列表，每个元素是一个映射。
*/
List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<YonghuEntity> wrapper);
} }

85
src/main/java/com/service/impl/ChatServiceImpl.java
Unescape View File

@ -11,7 +11,6 @@ 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.ChatDao; import com.dao.ChatDao;
import com.entity.ChatEntity; import com.entity.ChatEntity;
import com.service.ChatService; import com.service.ChatService;
@ -21,43 +20,81 @@ import com.entity.view.ChatView;
@Service("chatService") @Service("chatService")
public class ChatServiceImpl extends ServiceImpl<ChatDao, ChatEntity> implements ChatService { public class ChatServiceImpl extends ServiceImpl<ChatDao, ChatEntity> implements ChatService {
/**
* 分页查询方法，返回分页后的ChatEntity数据。
* @param params 包含分页参数的Map对象
* @return 封装了分页信息的PageUtils对象
*/
@Override @Override
public PageUtils queryPage(Map<String, Object> params) { public PageUtils queryPage(Map<String, Object> params) {
// 使用Query类获取分页信息，并调用selectPage方法进行数据库查询
Page<ChatEntity> page = this.selectPage( Page<ChatEntity> page = this.selectPage(
new Query<ChatEntity>(params).getPage(), new Query<ChatEntity>(params).getPage(),
new EntityWrapper<ChatEntity>() new EntityWrapper<ChatEntity>()
); );
// 将查询结果封装到PageUtils对象中并返回
return new PageUtils(page); return new PageUtils(page);
} }
/**
* 分页查询方法，返回分页后的ChatView数据。
* @param params 包含分页参数的Map对象
* @param wrapper 查询条件包装器
* @return 封装了分页信息的PageUtils对象
*/
// 使用Query类获取分页信息，调用自定义的selectListView方法进行数据库查询，并将结果设置到page对象中
@Override @Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<ChatEntity> wrapper) { public PageUtils queryPage(Map<String, Object> params, Wrapper<ChatEntity> wrapper) {
Page<ChatView> page =new Query<ChatView>(params).getPage();
page.setRecords(baseMapper.selectListView(page,wrapper));
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
@Override Page<ChatView> page = new Query<ChatView>(params).getPage();
public List<ChatVO> selectListVO(Wrapper<ChatEntity> wrapper) {
return baseMapper.selectListVO(wrapper);
}
@Override page.setRecords(baseMapper.selectListView(page, wrapper));
public ChatVO selectVO(Wrapper<ChatEntity> wrapper) { // 将查询结果封装到PageUtils对象中并返回
return baseMapper.selectVO(wrapper); PageUtils pageUtil = new PageUtils(page);
} return pageUtil;
}
@Override /**
public List<ChatView> selectListView(Wrapper<ChatEntity> wrapper) { * 根据条件查询ChatVO列表。
return baseMapper.selectListView(wrapper); * @param wrapper 查询条件包装器
} * @return 符合条件的ChatVO列表
*/
@Override
public List<ChatVO> selectListVO(Wrapper<ChatEntity> wrapper) {
// 调用自定义的selectListVO方法进行数据库查询并返回结果
return baseMapper.selectListVO(wrapper);
}
@Override /**
public ChatView selectView(Wrapper<ChatEntity> wrapper) { * 根据条件查询单个ChatVO对象。
return baseMapper.selectView(wrapper); * @param wrapper 查询条件包装器
} * @return 符合条件的单个ChatVO对象
*/
@Override
public ChatVO selectVO(Wrapper<ChatEntity> wrapper) {
// 调用自定义的selectVO方法进行数据库查询并返回结果
return baseMapper.selectVO(wrapper);
}
/**
* @param wrapper 查询条件包装器
* @return 符合条件的ChatView列表
*/
// 调用自定义的selectListView方法进行数据库查询并返回结果
@Override
public List<ChatView> selectListView(Wrapper<ChatEntity> wrapper) {
return baseMapper.selectListView(wrapper);
}
/**
* 根据条件查询单个ChatView对象。
* @param wrapper 查询条件包装器
* @return 符合条件的单个ChatView对象
*/
@Override
public ChatView selectView(Wrapper<ChatEntity> wrapper) {
// 调用自定义的selectView方法进行数据库查询并返回结果
return baseMapper.selectView(wrapper);
}
} }

23
src/main/java/com/service/impl/CommonServiceImpl.java
Unescape View File

@ -1,7 +1,5 @@
package com.service.impl; package com.service.impl;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@ -11,54 +9,53 @@ import org.springframework.stereotype.Service;
import com.dao.CommonDao; import com.dao.CommonDao;
import com.service.CommonService; import com.service.CommonService;
/** /**
* 系统用户 * 系统用户服务实现类
*/ */
@Service("commonService") @Service("commonService")
public class CommonServiceImpl implements CommonService { public class CommonServiceImpl implements CommonService {
@Autowired @Autowired
private CommonDao commonDao; private CommonDao commonDao; // 自动注入数据访问对象
@Override @Override
public List<String> getOption(Map<String, Object> params) { public List<String> getOption(Map<String, Object> params) {
return commonDao.getOption(params); return commonDao.getOption(params); // 获取选项列表
} }
@Override @Override
public Map<String, Object> getFollowByOption(Map<String, Object> params) { public Map<String, Object> getFollowByOption(Map<String, Object> params) {
return commonDao.getFollowByOption(params); return commonDao.getFollowByOption(params); // 根据选项获取关注信息
} }
@Override @Override
public void sh(Map<String, Object> params) { public void sh(Map<String, Object> params) {
commonDao.sh(params); commonDao.sh(params); // 执行某种操作（具体操作未明）
} }
@Override @Override
public int remindCount(Map<String, Object> params) { public int remindCount(Map<String, Object> params) {
return commonDao.remindCount(params); return commonDao.remindCount(params); // 获取提醒数量
} }
@Override @Override
public Map<String, Object> selectCal(Map<String, Object> params) { public Map<String, Object> selectCal(Map<String, Object> params) {
return commonDao.selectCal(params); return commonDao.selectCal(params); // 选择并计算某些值
} }
@Override @Override
public List<Map<String, Object>> selectGroup(Map<String, Object> params) { public List<Map<String, Object>> selectGroup(Map<String, Object> params) {
return commonDao.selectGroup(params); return commonDao.selectGroup(params); // 按组选择数据
} }
@Override @Override
public List<Map<String, Object>> selectValue(Map<String, Object> params) { public List<Map<String, Object>> selectValue(Map<String, Object> params) {
return commonDao.selectValue(params); return commonDao.selectValue(params); // 选择特定值
} }
@Override @Override
public List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params) { public List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params) {
return commonDao.selectTimeStatValue(params); return commonDao.selectTimeStatValue(params); // 选择并统计时间相关的值
} }
} }

97
src/main/java/com/service/impl/WenjuandafuServiceImpl.java
Unescape View File

@ -11,7 +11,6 @@ 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.WenjuandafuDao; import com.dao.WenjuandafuDao;
import com.entity.WenjuandafuEntity; import com.entity.WenjuandafuEntity;
import com.service.WenjuandafuService; import com.service.WenjuandafuService;
@ -21,7 +20,11 @@ import com.entity.view.WenjuandafuView;
@Service("wenjuandafuService") @Service("wenjuandafuService")
public class WenjuandafuServiceImpl extends ServiceImpl<WenjuandafuDao, WenjuandafuEntity> implements WenjuandafuService { public class WenjuandafuServiceImpl extends ServiceImpl<WenjuandafuDao, WenjuandafuEntity> implements WenjuandafuService {
/**
* 分页查询问卷答复数据
* @param params 查询参数
* @return 分页结果封装在 PageUtils 对象中
*/
@Override @Override
public PageUtils queryPage(Map<String, Object> params) { public PageUtils queryPage(Map<String, Object> params) {
Page<WenjuandafuEntity> page = this.selectPage( Page<WenjuandafuEntity> page = this.selectPage(
@ -31,50 +34,90 @@ public class WenjuandafuServiceImpl extends ServiceImpl<WenjuandafuDao, Wenjuand
return new PageUtils(page); return new PageUtils(page);
} }
/**
* 分页查询问卷答复视图数据，带查询条件封装器
* @param params 查询参数
* @param wrapper 查询条件封装器
* @return 分页结果封装在 PageUtils 对象中
*/
@Override @Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper) { public PageUtils queryPage(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper) {
Page<WenjuandafuView> page =new Query<WenjuandafuView>(params).getPage(); Page<WenjuandafuView> page = new Query<WenjuandafuView>(params).getPage();
page.setRecords(baseMapper.selectListView(page,wrapper)); page.setRecords(baseMapper.selectListView(page, wrapper));
PageUtils pageUtil = new PageUtils(page); PageUtils pageUtil = new PageUtils(page);
return pageUtil; return pageUtil;
} }
/**
* 根据条件查询问卷答复的视图列表
* @param wrapper 查询条件封装器
* @return 符合条件的问卷答复视图列表
*/
@Override @Override
public List<WenjuandafuVO> selectListVO(Wrapper<WenjuandafuEntity> wrapper) { public List<WenjuandafuVO> selectListVO(Wrapper<WenjuandafuEntity> wrapper) {
return baseMapper.selectListVO(wrapper); return baseMapper.selectListVO(wrapper);
} }
@Override /**
public WenjuandafuVO selectVO(Wrapper<WenjuandafuEntity> wrapper) { * 根据条件查询单个问卷答复的视图
return baseMapper.selectVO(wrapper); * @param wrapper 查询条件封装器
} * @return 符合条件的单个问卷答复视图
*/
@Override
public WenjuandafuVO selectVO(Wrapper<WenjuandafuEntity> wrapper) {
return baseMapper.selectVO(wrapper);
}
@Override /**
public List<WenjuandafuView> selectListView(Wrapper<WenjuandafuEntity> wrapper) { * 根据条件查询问卷答复的视图列表（分页）
return baseMapper.selectListView(wrapper); * @param wrapper 查询条件封装器
} * @return 符合条件的问卷答复视图列表（分页）
*/
@Override
public List<WenjuandafuView> selectListView(Wrapper<WenjuandafuEntity> wrapper) {
return baseMapper.selectListView(wrapper);
}
@Override /**
public WenjuandafuView selectView(Wrapper<WenjuandafuEntity> wrapper) { * 根据条件查询单个问卷答复的视图（分页）
return baseMapper.selectView(wrapper); * @param wrapper 查询条件封装器
} * @return 符合条件的单个问卷答复视图（分页）
*/
@Override
public WenjuandafuView selectView(Wrapper<WenjuandafuEntity> wrapper) {
return baseMapper.selectView(wrapper);
}
/**
* 根据查询参数和条件封装器获取值统计结果
* @param params 查询参数
* @param wrapper 查询条件封装器
* @return 值统计结果列表
*/
@Override @Override
public List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper) { public List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<WenjuandafuEntity> 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<WenjuandafuEntity> wrapper) { public List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<WenjuandafuEntity> 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<WenjuandafuEntity> wrapper) { public List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper) {
return baseMapper.selectGroup(params, wrapper); return baseMapper.selectGroup(params, wrapper);
} }
} }

57
src/main/java/com/service/impl/YonghuServiceImpl.java
Unescape View File

@ -11,7 +11,6 @@ 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.YonghuDao; import com.dao.YonghuDao;
import com.entity.YonghuEntity; import com.entity.YonghuEntity;
import com.service.YonghuService; import com.service.YonghuService;
@ -21,7 +20,7 @@ import com.entity.view.YonghuView;
@Service("yonghuService") @Service("yonghuService")
public class YonghuServiceImpl extends ServiceImpl<YonghuDao, YonghuEntity> implements YonghuService { public class YonghuServiceImpl extends ServiceImpl<YonghuDao, YonghuEntity> implements YonghuService {
// 分页查询用户信息
@Override @Override
public PageUtils queryPage(Map<String, Object> params) { public PageUtils queryPage(Map<String, Object> params) {
Page<YonghuEntity> page = this.selectPage( Page<YonghuEntity> page = this.selectPage(
@ -31,50 +30,54 @@ public class YonghuServiceImpl extends ServiceImpl<YonghuDao, YonghuEntity> impl
return new PageUtils(page); return new PageUtils(page);
} }
// 分页查询用户视图信息
@Override @Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<YonghuEntity> wrapper) { public PageUtils queryPage(Map<String, Object> params, Wrapper<YonghuEntity> wrapper) {
Page<YonghuView> page =new Query<YonghuView>(params).getPage(); Page<YonghuView> page = new Query<YonghuView>(params).getPage();
page.setRecords(baseMapper.selectListView(page,wrapper)); page.setRecords(baseMapper.selectListView(page, wrapper));
PageUtils pageUtil = new PageUtils(page); PageUtils pageUtil = new PageUtils(page);
return pageUtil; return pageUtil;
} }
// 查询用户值对象列表
@Override @Override
public List<YonghuVO> selectListVO(Wrapper<YonghuEntity> wrapper) { public List<YonghuVO> selectListVO(Wrapper<YonghuEntity> wrapper) {
return baseMapper.selectListVO(wrapper); return baseMapper.selectListVO(wrapper);
} }
@Override // 查询单个用户值对象
public YonghuVO selectVO(Wrapper<YonghuEntity> wrapper) { @Override
return baseMapper.selectVO(wrapper); public YonghuVO selectVO(Wrapper<YonghuEntity> wrapper) {
} return baseMapper.selectVO(wrapper);
}
@Override // 查询用户视图列表
public List<YonghuView> selectListView(Wrapper<YonghuEntity> wrapper) { @Override
return baseMapper.selectListView(wrapper); public List<YonghuView> selectListView(Wrapper<YonghuEntity> wrapper) {
} return baseMapper.selectListView(wrapper);
}
@Override // 查询单个用户视图
public YonghuView selectView(Wrapper<YonghuEntity> wrapper) { @Override
return baseMapper.selectView(wrapper); public YonghuView selectView(Wrapper<YonghuEntity> wrapper) {
} return baseMapper.selectView(wrapper);
}
// 根据条件查询特定值
@Override @Override
public List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<YonghuEntity> wrapper) { public List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<YonghuEntity> wrapper) {
return baseMapper.selectValue(params, wrapper); return baseMapper.selectValue(params, wrapper);
} }
// 根据条件查询时间统计值
@Override @Override
public List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<YonghuEntity> wrapper) { public List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<YonghuEntity> wrapper) {
return baseMapper.selectTimeStatValue(params, wrapper); return baseMapper.selectTimeStatValue(params, wrapper);
} }
// 根据条件分组查询数据
@Override @Override
public List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<YonghuEntity> wrapper) { public List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<YonghuEntity> wrapper) {
return baseMapper.selectGroup(params, wrapper); return baseMapper.selectGroup(params, wrapper);
} }
} }

7
src/main/java/com/utils/BaiduUtil.java
Unescape View File

@ -135,11 +135,11 @@ public class BaiduUtil {
if(jsonObject == null){ if(jsonObject == null){
return ""; return "";
} }
// 检查 JSON 对象中是否包含 "words_result" 和 "words_result_num" 键
if(jsonObject.has("words_result") && jsonObject.has("words_result_num")){ if(jsonObject.has("words_result") && jsonObject.has("words_result_num")){
int wordsResultNum = jsonObject.getInt("words_result_num"); int wordsResultNum = jsonObject.getInt("words_result_num");
if(wordsResultNum > 0){ if(wordsResultNum > 0){
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();// 用于拼接字符串
JSONArray jsonArray = jsonObject.getJSONArray("words_result"); JSONArray jsonArray = jsonObject.getJSONArray("words_result");
int len = jsonArray.length(); int len = jsonArray.length();
@ -193,4 +193,7 @@ public class BaiduUtil {
return res; return res;
} }
} }

29
src/main/java/com/utils/HttpClientUtils.java
Unescape View File

@ -5,38 +5,45 @@ import java.io.InputStreamReader;
import java.net.HttpURLConnection; import java.net.HttpURLConnection;
import java.net.URL; import java.net.URL;
/** /**
* HttpClient工具类 * HttpClient工具类
*/ */
public class HttpClientUtils { public class HttpClientUtils {
/** /**
* @param uri * 发送GET请求并返回响应内容
* @return String * @param uri 请求的URL地址
* @description get请求方式 * @return 响应内容的字符串形式
* @description 使用GET方法发送HTTP请求
* @author: long.he01 * @author: long.he01
*/ */
public static String doGet(String uri) { public static String doGet(String uri) {
// 用于存储响应结果的StringBuilder对象
StringBuilder result = new StringBuilder(); StringBuilder result = new StringBuilder();
try { try {
// 初始化一个空字符串用于存储每一行读取的内容
String res = ""; String res = "";
// 创建URL对象
URL url = new URL(uri); URL url = new URL(uri);
// 打开连接
HttpURLConnection conn = (HttpURLConnection) url.openConnection(); HttpURLConnection conn = (HttpURLConnection) url.openConnection();
// 设置请求方法为GET
conn.setRequestMethod("GET");
// 获取输入流并包装成BufferedReader
BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8")); BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"));
String line; String line;
// 逐行读取响应内容
while ((line = in.readLine()) != null) { while ((line = in.readLine()) != null) {
res += line+"\n"; res += line + "\n";
} // 关闭BufferedReader
in.close(); in.close();
// 返回完整的响应内容
return res; return res;
}catch (Exception e) { } catch (Exception e) {
// 捕获异常并打印堆栈信息
e.printStackTrace(); e.printStackTrace();
return null; return null;
} }
} }
} }

116
src/main/java/com/utils/JQPageInfo.java
Unescape View File

@ -1,54 +1,68 @@
package com.utils; package com.utils;
public class JQPageInfo{ public class JQPageInfo {
private Integer page; // 当前页码
private Integer page;
private Integer limit;
// 每页显示的记录数
private String sidx; private Integer limit;
private String order; // 排序字段
private String sidx;
private Integer offset;
// 排序方式（升序或降序）
public Integer getPage() { private String order;
return page;
} // 偏移量，用于计算分页查询时的起始位置
private Integer offset;
public void setPage(Integer page) {
this.page = page; // 获取当前页码
} public Integer getPage() {
return page;
public Integer getLimit() { }
return limit;
} // 设置当前页码
public void setPage(Integer page) {
public void setLimit(Integer limit) { this.page = page;
this.limit = limit; }
}
// 获取每页显示的记录数
public String getSidx() { public Integer getLimit() {
return sidx; return limit;
} }
public void setSidx(String sidx) { // 设置每页显示的记录数
this.sidx = sidx; public void setLimit(Integer limit) {
} this.limit = limit;
}
public String getOrder() {
return order; // 获取排序字段
} public String getSidx() {
return sidx;
public void setOrder(String order) { }
this.order = order;
} // 设置排序字段
public void setSidx(String sidx) {
public Integer getOffset() { this.sidx = sidx;
return offset; }
}
// 获取排序方式
public void setOffset(Integer offset) { public String getOrder() {
this.offset = offset; return order;
} }
// 设置排序方式
public void setOrder(String order) {
this.order = order;
}
// 获取偏移量
public Integer getOffset() {
return offset;
}
// 设置偏移量
public void setOffset(Integer offset) {
this.offset = offset;
}
} }

329
src/main/java/com/utils/MPUtil.java
Unescape View File

@ -15,170 +15,167 @@ import com.baomidou.mybatisplus.mapper.Wrapper;
* Mybatis-Plus工具类 * Mybatis-Plus工具类
*/ */
public class MPUtil { public class MPUtil {
public static final char UNDERLINE = '_'; public static final char UNDERLINE = '_';
// mybatis plus allEQ 表达式转换，带前缀
//mybatis plus allEQ 表达式转换 public static Map allEQMapPre(Object bean, String pre) {
public static Map allEQMapPre(Object bean,String pre) { Map<String, Object> map = BeanUtil.beanToMap(bean);
Map<String, Object> map =BeanUtil.beanToMap(bean); return camelToUnderlineMap(map, pre);
return camelToUnderlineMap(map,pre); }
}
// mybatis plus allEQ 表达式转换，不带前缀
//mybatis plus allEQ 表达式转换 public static Map allEQMap(Object bean) {
public static Map allEQMap(Object bean) { Map<String, Object> map = BeanUtil.beanToMap(bean);
Map<String, Object> map =BeanUtil.beanToMap(bean); return camelToUnderlineMap(map, "");
return camelToUnderlineMap(map,""); }
}
// mybatis plus allLike 表达式转换，带前缀
public static Wrapper allLikePre(Wrapper wrapper,Object bean,String pre) { public static Wrapper allLikePre(Wrapper wrapper, Object bean, String pre) {
Map<String, Object> map =BeanUtil.beanToMap(bean); Map<String, Object> map = BeanUtil.beanToMap(bean);
Map result = camelToUnderlineMap(map,pre); Map result = camelToUnderlineMap(map, pre);
return genLike(wrapper, result);
return genLike(wrapper,result); }
}
// mybatis plus allLike 表达式转换，不带前缀
public static Wrapper allLike(Wrapper wrapper,Object bean) { public static Wrapper allLike(Wrapper wrapper, Object bean) {
Map result = BeanUtil.beanToMap(bean, true, true); Map result = BeanUtil.beanToMap(bean, true, true);
return genLike(wrapper,result); return genLike(wrapper, result);
} }
// 生成LIKE查询条件
public static Wrapper genLike( Wrapper wrapper,Map param) { public static Wrapper genLike(Wrapper wrapper, Map param) {
Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator(); Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
int i=0; int i = 0;
while (it.hasNext()) { while (it.hasNext()) {
if(i>0) wrapper.and(); if (i > 0) wrapper.and();
Map.Entry<String, Object> entry = it.next(); Map.Entry<String, Object> entry = it.next();
String key = entry.getKey(); String key = entry.getKey();
String value = (String) entry.getValue(); String value = (String) entry.getValue();
wrapper.like(key, value); wrapper.like(key, value);
i++; i++;
} }
return wrapper; return wrapper;
} }
public static Wrapper likeOrEq(Wrapper wrapper,Object bean) { // 生成LIKE或EQ查询条件
Map result = BeanUtil.beanToMap(bean, true, true); public static Wrapper likeOrEq(Wrapper wrapper, Object bean) {
return genLikeOrEq(wrapper,result); Map result = BeanUtil.beanToMap(bean, true, true);
} return genLikeOrEq(wrapper, result);
}
public static Wrapper genLikeOrEq( Wrapper wrapper,Map param) {
Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator(); // 生成LIKE或EQ查询条件的具体实现
int i=0; public static Wrapper genLikeOrEq(Wrapper wrapper, Map param) {
while (it.hasNext()) { Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
if(i>0) wrapper.and(); int i = 0;
Map.Entry<String, Object> entry = it.next(); while (it.hasNext()) {
String key = entry.getKey(); if (i > 0) wrapper.and();
if(entry.getValue().toString().contains("%")) { Map.Entry<String, Object> entry = it.next();
wrapper.like(key, entry.getValue().toString().replace("%", "")); String key = entry.getKey();
} else { if (entry.getValue().toString().contains("%")) {
wrapper.eq(key, entry.getValue()); wrapper.like(key, entry.getValue().toString().replace("%", ""));
} } else {
i++; wrapper.eq(key, entry.getValue());
} }
return wrapper; i++;
} }
return wrapper;
public static Wrapper allEq(Wrapper wrapper,Object bean) { }
Map result = BeanUtil.beanToMap(bean, true, true);
return genEq(wrapper,result); // 生成EQ查询条件
} public static Wrapper allEq(Wrapper wrapper, Object bean) {
Map result = BeanUtil.beanToMap(bean, true, true);
return genEq(wrapper, result);
public static Wrapper genEq( Wrapper wrapper,Map param) { }
Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
int i=0; // 生成EQ查询条件的具体实现
while (it.hasNext()) { public static Wrapper genEq(Wrapper wrapper, Map param) {
if(i>0) wrapper.and(); Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
Map.Entry<String, Object> entry = it.next(); int i = 0;
String key = entry.getKey(); while (it.hasNext()) {
wrapper.eq(key, entry.getValue()); if (i > 0) wrapper.and();
i++; Map.Entry<String, Object> entry = it.next();
} String key = entry.getKey();
return wrapper; wrapper.eq(key, entry.getValue());
} i++;
}
return wrapper;
public static Wrapper between(Wrapper wrapper,Map<String, Object> params) { }
for(String key : params.keySet()) {
String columnName = ""; // 生成BETWEEN查询条件
if(key.endsWith("_start")) { public static Wrapper between(Wrapper wrapper, Map<String, Object> params) {
columnName = key.substring(0, key.indexOf("_start")); for (String key : params.keySet()) {
if(StringUtils.isNotBlank(params.get(key).toString())) { String columnName = "";
wrapper.ge(columnName, params.get(key)); if (key.endsWith("_start")) {
} columnName = key.substring(0, key.indexOf("_start"));
} if (StringUtils.isNotBlank(params.get(key).toString())) {
if(key.endsWith("_end")) { wrapper.ge(columnName, params.get(key));
columnName = key.substring(0, key.indexOf("_end")); }
if(StringUtils.isNotBlank(params.get(key).toString())) { }
wrapper.le(columnName, params.get(key)); if (key.endsWith("_end")) {
} columnName = key.substring(0, key.indexOf("_end"));
} if (StringUtils.isNotBlank(params.get(key).toString())) {
} wrapper.le(columnName, params.get(key));
return wrapper; }
} }
}
public static Wrapper sort(Wrapper wrapper,Map<String, Object> params) { return wrapper;
String order = ""; }
if(params.get("order") != null && StringUtils.isNotBlank(params.get("order").toString())) {
order = params.get("order").toString(); // 生成排序查询条件
} public static Wrapper sort(Wrapper wrapper, Map<String, Object> params) {
if(params.get("sort") != null && StringUtils.isNotBlank(params.get("sort").toString())) { String order = "";
if(order.equalsIgnoreCase("desc")) { if (params.get("order") != null && StringUtils.isNotBlank(params.get("order").toString())) {
wrapper.orderDesc(Arrays.asList(params.get("sort"))); order = params.get("order").toString();
} else { }
wrapper.orderAsc(Arrays.asList(params.get("sort"))); if (params.get("sort") != null && StringUtils.isNotBlank(params.get("sort").toString())) {
} if (order.equalsIgnoreCase("desc")) {
} wrapper.orderDesc(Arrays.asList(params.get("sort")));
return wrapper; } else {
} wrapper.orderAsc(Arrays.asList(params.get("sort")));
}
}
/** return wrapper;
* 驼峰格式字符串转换为下划线格式字符串 }
*
* @param param // 驼峰格式字符串转换为下划线格式字符串
* @return public static String camelToUnderline(String param) {
*/ if (param == null || "".equals(param.trim())) {
public static String camelToUnderline(String param) { return "";
if (param == null || "".equals(param.trim())) { }
return ""; int len = param.length();
} StringBuilder sb = new StringBuilder(len);
int len = param.length(); for (int i = 0; i < len; i++) {
StringBuilder sb = new StringBuilder(len); char c = param.charAt(i);
for (int i = 0; i < len; i++) { if (Character.isUpperCase(c)) {
char c = param.charAt(i); sb.append(UNDERLINE);
if (Character.isUpperCase(c)) { sb.append(Character.toLowerCase(c));
sb.append(UNDERLINE); } else {
sb.append(Character.toLowerCase(c)); sb.append(c);
} else { }
sb.append(c); }
} return sb.toString();
} }
return sb.toString();
} public static void main(String[] ages) {
System.out.println(camelToUnderline("ABCddfANM")); // 输出：a_b_cddf_anm
public static void main(String[] ages) { }
System.out.println(camelToUnderline("ABCddfANM"));
} // 将驼峰格式的Map键转换为下划线格式，并添加前缀（如果有）
public static Map camelToUnderlineMap(Map param, String pre) {
public static Map camelToUnderlineMap(Map param, String pre) { Map<String, Object> newMap = new HashMap<>();
Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
Map<String, Object> newMap = new HashMap<String, Object>(); while (it.hasNext()) {
Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator(); Map.Entry<String, Object> entry = it.next();
while (it.hasNext()) { String key = entry.getKey();
Map.Entry<String, Object> entry = it.next(); String newKey = camelToUnderline(key);
String key = entry.getKey(); if (pre.endsWith(".")) {
String newKey = camelToUnderline(key); newMap.put(pre + newKey, entry.getValue());
if (pre.endsWith(".")) { } else if (StringUtils.isEmpty(pre)) {
newMap.put(pre + newKey, entry.getValue()); newMap.put(newKey, entry.getValue());
} else if (StringUtils.isEmpty(pre)) { } else {
newMap.put(newKey, entry.getValue()); newMap.put(pre + "." + newKey, entry.getValue());
} else { }
}
newMap.put(pre + "." + newKey, entry.getValue()); return newMap;
} }
}
return newMap;
}
} }

44
src/main/java/com/utils/PageUtils.java
Unescape View File

@ -1,4 +1,3 @@
package com.utils; package com.utils;
import java.io.Serializable; import java.io.Serializable;
@ -8,23 +7,23 @@ import java.util.Map;
import com.baomidou.mybatisplus.plugins.Page; import com.baomidou.mybatisplus.plugins.Page;
/** /**
* 分页工具类 * 分页工具类，用于处理分页相关的数据和操作。
*/ */
public class PageUtils implements Serializable { public class PageUtils implements Serializable {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L; // 序列化版本号
//总记录数 // 总记录数
private long total; private long total;
//每页记录数 // 每页记录数
private int pageSize; private int pageSize;
//总页数 // 总页数
private long totalPage; private long totalPage;
//当前页数 // 当前页数
private int currPage; private int currPage;
//列表数据 // 列表数据
private List<?> list; private List<?> list;
/** /**
* 分页 * 构造函数，通过传入的列表数据、总记录数、每页记录数和当前页数进行初始化。
* @param list 列表数据 * @param list 列表数据
* @param totalCount 总记录数 * @param totalCount 总记录数
* @param pageSize 每页记录数 * @param pageSize 每页记录数
@ -35,29 +34,31 @@ public class PageUtils implements Serializable {
this.total = totalCount; this.total = totalCount;
this.pageSize = pageSize; this.pageSize = pageSize;
this.currPage = currPage; this.currPage = currPage;
this.totalPage = (int)Math.ceil((double)totalCount/pageSize); this.totalPage = (int)Math.ceil((double)totalCount/pageSize); // 计算总页数
} }
/** /**
* 分页 * 构造函数，通过MyBatis Plus的Page对象进行初始化。
* @param page MyBatis Plus的Page对象
*/ */
public PageUtils(Page<?> page) { public PageUtils(Page<?> page) {
this.list = page.getRecords(); this.list = page.getRecords(); // 获取当前页的数据列表
this.total = page.getTotal(); this.total = page.getTotal(); // 获取总记录数
this.pageSize = page.getSize(); this.pageSize = page.getSize(); // 获取每页记录数
this.currPage = page.getCurrent(); this.currPage = page.getCurrent(); // 获取当前页码
this.totalPage = page.getPages(); this.totalPage = page.getPages(); // 获取总页数
} }
/* /**
* 空数据的分页 * 构造函数，通过传入的参数Map进行初始化。
* @param params 包含分页参数的Map对象
*/ */
public PageUtils(Map<String, Object> params) { public PageUtils(Map<String, Object> params) {
Page page =new Query(params).getPage(); Page page =new Query(params).getPage(); // 根据参数创建Page对象
new PageUtils(page); new PageUtils(page); // 调用另一个构造函数进行初始化
} }
// Getter和Setter方法
public int getPageSize() { public int getPageSize() {
return pageSize; return pageSize;
} }
@ -97,5 +98,4 @@ public class PageUtils implements Serializable {
public void setTotal(long total) { public void setTotal(long total) {
this.total = total; this.total = total;
} }
} }

83
src/main/java/com/utils/Query.java
Unescape View File

@ -1,4 +1,3 @@
package com.utils; package com.utils;
import java.util.LinkedHashMap; import java.util.LinkedHashMap;
@ -9,89 +8,103 @@ import org.apache.commons.lang3.StringUtils;
import com.baomidou.mybatisplus.plugins.Page; import com.baomidou.mybatisplus.plugins.Page;
/** /**
* 查询参数 * 查询参数类，用于封装分页和排序信息
*/ */
public class Query<T> extends LinkedHashMap<String, Object> { public class Query<T> extends LinkedHashMap<String, Object> {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
/**
* mybatis-plus分页参数 // mybatis-plus分页参数
*/
private Page<T> page; private Page<T> page;
/**
* 当前页码 // 当前页码
*/
private int currPage = 1; private int currPage = 1;
/**
* 每页条数 // 每页条数
*/
private int limit = 10; private int limit = 10;
/**
* 构造函数，使用JQPageInfo对象初始化查询参数
* @param pageInfo 包含分页和排序信息的JQPageInfo对象
*/
public Query(JQPageInfo pageInfo) { public Query(JQPageInfo pageInfo) {
//分页参数 // 设置分页参数
if(pageInfo.getPage()!= null){ if (pageInfo.getPage() != null) {
currPage = pageInfo.getPage(); currPage = pageInfo.getPage();
} }
if(pageInfo.getLimit()!= null){ if (pageInfo.getLimit() != null) {
limit = pageInfo.getLimit(); limit = pageInfo.getLimit();
} }
// 防止SQL注入（因为sidx、order是通过拼接SQL实现排序的，会有SQL注入风险）
//防止SQL注入（因为sidx、order是通过拼接SQL实现排序的，会有SQL注入风险）
String sidx = SQLFilter.sqlInject(pageInfo.getSidx()); String sidx = SQLFilter.sqlInject(pageInfo.getSidx());
String order = SQLFilter.sqlInject(pageInfo.getOrder()); String order = SQLFilter.sqlInject(pageInfo.getOrder());
// mybatis-plus分页
//mybatis-plus分页
this.page = new Page<>(currPage, limit); this.page = new Page<>(currPage, limit);
//排序 // 设置排序字段和顺序
if(StringUtils.isNotBlank(sidx) && StringUtils.isNotBlank(order)){ if (StringUtils.isNotBlank(sidx) && StringUtils.isNotBlank(order)) {
this.page.setOrderByField(sidx); this.page.setOrderByField(sidx);
this.page.setAsc("ASC".equalsIgnoreCase(order)); this.page.setAsc("ASC".equalsIgnoreCase(order));
} }
} }
/**
public Query(Map<String, Object> params){ * 构造函数，使用Map对象初始化查询参数
* @param params 包含分页和排序信息的Map对象
*/
public Query(Map<String, Object> params) {
this.putAll(params); this.putAll(params);
//分页参数 // 设置分页参数
if(params.get("page") != null){ if (params.get("page") != null) {
currPage = Integer.parseInt((String)params.get("page")); currPage = Integer.parseInt((String) params.get("page"));
} }
if(params.get("limit") != null){ if (params.get("limit") != null) {
limit = Integer.parseInt((String)params.get("limit")); limit = Integer.parseInt((String) params.get("limit"));
} }
// 计算偏移量并放入Map中
this.put("offset", (currPage - 1) * limit); this.put("offset", (currPage - 1) * limit);
this.put("page", currPage); this.put("page", currPage);
this.put("limit", limit); this.put("limit", limit);
//防止SQL注入（因为sidx、order是通过拼接SQL实现排序的，会有SQL注入风险） // 防止SQL注入（因为sidx、order是通过拼接SQL实现排序的，会有SQL注入风险）
String sidx = SQLFilter.sqlInject((String)params.get("sidx")); String sidx = SQLFilter.sqlInject((String) params.get("sidx"));
String order = SQLFilter.sqlInject((String)params.get("order")); String order = SQLFilter.sqlInject((String) params.get("order"));
this.put("sidx", sidx); this.put("sidx", sidx);
this.put("order", order); this.put("order", order);
//mybatis-plus分页 // mybatis-plus分页
this.page = new Page<>(currPage, limit); this.page = new Page<>(currPage, limit);
//排序 // 设置排序字段和顺序
if(StringUtils.isNotBlank(sidx) && StringUtils.isNotBlank(order)){ if (StringUtils.isNotBlank(sidx) && StringUtils.isNotBlank(order)) {
this.page.setOrderByField(sidx); this.page.setOrderByField(sidx);
this.page.setAsc("ASC".equalsIgnoreCase(order)); this.page.setAsc("ASC".equalsIgnoreCase(order));
} }
} }
/**
* 获取mybatis-plus分页对象
* @return mybatis-plus分页对象
*/
public Page<T> getPage() { public Page<T> getPage() {
return page; return page;
} }
/**
* 获取当前页码
* @return 当前页码
*/
public int getCurrPage() { public int getCurrPage() {
return currPage; return currPage;
} }
/**
* 获取每页条数
* @return 每页条数
*/
public int getLimit() { public int getLimit() {
return limit; return limit;
} }

10
src/main/java/com/utils/R.java
Unescape View File

@ -4,23 +4,27 @@ import java.util.HashMap;
import java.util.Map; import java.util.Map;
/** /**
* 返回数据 * 返回数据类，用于封装API响应结果。
*/ */
public class R extends HashMap<String, Object> { public class R extends HashMap<String, Object> {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
// 默认构造函数，初始化code为0表示成功
public R() { public R() {
put("code", 0); put("code", 0);
} }
// 静态方法：返回一个错误响应，默认code为500，msg为"未知异常，请联系管理员"
public static R error() { public static R error() {
return error(500, "未知异常，请联系管理员"); return error(500, "未知异常，请联系管理员");
} }
// 静态方法：返回一个错误响应，code为500，msg为传入的参数msg
public static R error(String msg) { public static R error(String msg) {
return error(500, msg); return error(500, msg);
} }
// 静态方法：返回一个错误响应，code和msg由传入的参数指定
public static R error(int code, String msg) { public static R error(int code, String msg) {
R r = new R(); R r = new R();
r.put("code", code); r.put("code", code);
@ -28,22 +32,26 @@ public class R extends HashMap<String, Object> {
return r; return r;
} }
// 静态方法：返回一个成功响应，msg为传入的参数msg
public static R ok(String msg) { public static R ok(String msg) {
R r = new R(); R r = new R();
r.put("msg", msg); r.put("msg", msg);
return r; return r;
} }
// 静态方法：返回一个成功响应，包含传入的map中的所有键值对
public static R ok(Map<String, Object> map) { public static R ok(Map<String, Object> map) {
R r = new R(); R r = new R();
r.putAll(map); r.putAll(map);
return r; return r;
} }
// 静态方法：返回一个默认的成功响应（仅包含code）
public static R ok() { public static R ok() {
return new R(); return new R();
} }
// 重写put方法，使其返回当前对象以支持链式调用
public R put(String key, Object value) { public R put(String key, Object value) {
super.put(key, value); super.put(key, value);
return this; return this;

77
src/main/java/com/utils/SpringContextUtils.java
Unescape View File

@ -6,38 +6,67 @@ import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware; import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
/** /**
* Spring Context 工具类 * Spring Context 工具类，用于获取Spring容器中的Bean。
*/ */
@Component @Component
public class SpringContextUtils implements ApplicationContextAware { public class SpringContextUtils implements ApplicationContextAware {
public static ApplicationContext applicationContext; // 静态变量，保存Spring应用上下文
public static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext)
throws BeansException {
SpringContextUtils.applicationContext = applicationContext;
}
public static Object getBean(String name) { /**
return applicationContext.getBean(name); * 实现ApplicationContextAware接口的方法，设置Spring应用上下文。
} * @param applicationContext Spring应用上下文
* @throws BeansException 如果设置上下文失败抛出异常
*/
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
SpringContextUtils.applicationContext = applicationContext;
}
public static <T> T getBean(String name, Class<T> requiredType) { /**
return applicationContext.getBean(name, requiredType); * 根据Bean名称获取Bean对象。
} * @param name Bean的名称
* @return 返回对应的Bean对象
*/
public static Object getBean(String name) {
return applicationContext.getBean(name);
}
public static boolean containsBean(String name) { /**
return applicationContext.containsBean(name); * 根据Bean名称和类型获取Bean对象。
} * @param name Bean的名称
* @param requiredType Bean的类型
* @return 返回对应类型的Bean对象
*/
public static <T> T getBean(String name, Class<T> requiredType) {
return applicationContext.getBean(name, requiredType);
}
public static boolean isSingleton(String name) { /**
return applicationContext.isSingleton(name); * 检查Spring容器中是否包含指定名称的Bean。
} * @param name Bean的名称
* @return 如果包含返回true，否则返回false
*/
public static boolean containsBean(String name) {
return applicationContext.containsBean(name);
}
public static Class<? extends Object> getType(String name) { /**
return applicationContext.getType(name); * 检查指定名称的Bean是否是单例模式。
} * @param name Bean的名称
* @return 如果是单例返回true，否则返回false
*/
public static boolean isSingleton(String name) {
return applicationContext.isSingleton(name);
}
/**
* 获取指定名称的Bean的类型。
* @param name Bean的名称
* @return 返回Bean的类型
*/
public static Class<? extends Object> getType(String name) {
return applicationContext.getType(name);
}
} }

17
src/main/java/com/utils/ValidatorUtils.java
Unescape View File

@ -1,21 +1,19 @@
package com.utils; package com.utils;
import java.util.Set; import java.util.Set;
import javax.validation.ConstraintViolation; import javax.validation.ConstraintViolation;
import javax.validation.Validation; import javax.validation.Validation;
import javax.validation.Validator; import javax.validation.Validator;
import com.entity.EIException; import com.entity.EIException;
/** /**
* hibernate-validator校验工具类 * hibernate-validator校验工具类
*/ */
public class ValidatorUtils { public class ValidatorUtils {
// 静态变量，用于存储验证器实例
private static Validator validator; private static Validator validator;
// 在静态块中初始化验证器实例
static { static {
validator = Validation.buildDefaultValidatorFactory().getValidator(); validator = Validation.buildDefaultValidatorFactory().getValidator();
} }
@ -26,14 +24,15 @@ public class ValidatorUtils {
* @param groups 待校验的组 * @param groups 待校验的组
* @throws EIException 校验不通过，则报EIException异常 * @throws EIException 校验不通过，则报EIException异常
*/ */
public static void validateEntity(Object object, Class<?>... groups) public static void validateEntity(Object object, Class<?>... groups) throws EIException {
throws EIException { // 执行校验操作，返回违反约束的集合
Set<ConstraintViolation<Object>> constraintViolations = validator.validate(object, groups); Set<ConstraintViolation<Object>> constraintViolations = validator.validate(object, groups);
// 如果存在违反约束的情况
if (!constraintViolations.isEmpty()) { if (!constraintViolations.isEmpty()) {
ConstraintViolation<Object> constraint = (ConstraintViolation<Object>)constraintViolations.iterator().next(); // 获取第一个违反约束的信息
ConstraintViolation<Object> constraint = (ConstraintViolation<Object>)constraintViolations.iterator().next();
// 抛出自定义异常，并传递错误信息
throw new EIException(constraint.getMessage()); throw new EIException(constraint.getMessage());
} }
} }
} }

196
src/main/webapp/front/pages/chat/chat.jsp
Unescape View File

@ -6,141 +6,143 @@
<head> <head>
<meta charset="utf-8"> <meta charset="utf-8">
<title></title> <title></title>
<!-- 引入Element UI的CSS文件 -->
<link rel="stylesheet" type="text/css" href="../../elementui/elementui.css" /> <link rel="stylesheet" type="text/css" href="../../elementui/elementui.css" />
<style> <style>
/* 设置HTML、body和#app的高度为100% */
html,body,#app { html,body,#app {
height: 100%; height: 100%;
} }
/* 设置body的外边距为0 */
body { body {
margin: 0; margin: 0;
} }
/* 设置聊天表单的样式 */
.chat-form { .chat-form {
height: 100%; height: 100%;
display: flex; display: flex;
flex-direction: column; flex-direction: column;
} }
/* 设置聊天内容的样式 */
.chat-content { .chat-content {
overflow-y: scroll; overflow-y: scroll; /* 垂直滚动条 */
border: 1px solid #eeeeee; border: 1px solid #eeeeee; /* 边框颜色 */
margin: 0; margin: 0; /* 外边距为0 */
padding: 0; padding: 0; /* 内边距为0 */
width: 100%; width: 100%; /* 宽度为100% */
flex: 1; flex: 1; /* 弹性布局，占据剩余空间 */
} }
/* 设置左侧内容的样式 */
.left-content { .left-content {
float: left; float: left; /* 左浮动 */
margin-bottom: 10px; margin-bottom: 10px; /* 底部外边距 */
padding: 10px; padding: 10px; /* 内边距 */
} }
/* 设置右侧内容的样式 */
.right-content { .right-content {
float: right; float: right; /* 右浮动 */
margin-bottom: 10px; margin-bottom: 10px; /* 底部外边距 */
padding: 10px; padding: 10px; /* 内边距 */
} }
/* 清除浮动 */
.clear-float { .clear-float {
clear: both; clear: both;
} }
/* 设置输入按钮区域的样式 */
.btn-input { .btn-input {
margin-left: 0px; margin-left: 0px; /* 左边距为0 */
display: flex; display: flex; /* 弹性布局 */
width: 100%; width: 100%; /* 宽度为100% */
padding: 10px 12px; padding: 10px 12px; /* 内边距 */
box-sizing: border-box; box-sizing: border-box; /* 盒模型 */
} }
</style> </style>
</head> </head>
<body style="overflow-y: hidden;overflow-x: hidden;"> <body style="overflow-y: hidden;overflow-x: hidden;">
<!-- Vue应用的根元素 -->
<div id="app"> <div id="app">
<!-- 使用Element UI的表单组件 -->
<el-form class="detail-form-content chat-form" ref="ruleForm" label-width="0"> <el-form class="detail-form-content chat-form" ref="ruleForm" label-width="0">
<!-- 聊天内容区域 -->
<div class="chat-content"> <div class="chat-content">
<!-- 遍历数据列表 -->
<div v-bind:key="item.id" v-for="item in dataList"> <div v-bind:key="item.id" v-for="item in dataList">
<!-- 如果ask存在，显示右侧内容 -->
<div v-if="item.ask" class="right-content"> <div v-if="item.ask" class="right-content">
<el-alert class="text-content" :title="item.ask" :closable="false" type="success"></el-alert> <!-- 使用Element UI的消息提示组件 -->
<el- class="text-content" :title="item.ask" :closable="false" type="success"></el->
</div> </div>
<!-- 如果reply存在，显示左侧内容 -->
<div v-else class="left-content"> <div v-else class="left-content">
<el-alert class="text-content" :title="item.reply" :closable="false" type="warning"></el-alert> <!-- 使用Element UI的消息提示组件 -->
<el- class="text-content" :title="item.reply" :closable="false" type="warning"></el->
</div> </div>
<!-- 清除浮动 -->
<div class="clear-float"></div> <div class="clear-float"></div>
</div> </div>
</div> </div>
<!-- 输入按钮区域 -->
<div class="btn-input"> <div class="btn-input">
<el-input style="flex: 1;margin-right: 10px;" v-model="ruleForm.ask" placeholder="发布" style="margin-right: 10px;" clearable></el-input> <!-- 使用Element UI的输入框组件 -->
<el-button type="primary" @click="onSubmit">发布</el-button> <el-input style="flex: 1;margin-right: 10px;" v-model="ruleForm.ask" placeholder="发布" style="margin-right: 10px;" clearable></el-input>
</div> <!-- 使用Element UI的按钮组件 -->
</el-form> <el-button type="primary" @click=" new Vue({
</div> el: "#app",
data() {
<!-- layui --> return {
<script src="../../layui/layui.js"></script> id: "", // 用户ID
<!-- vue --> ruleForm: {}, // 表单数据
<script src="../../js/vue.js"></script> dataList: [], // 数据列表
<!-- elementui --> inter: null // 定时器
<script src="../../elementui/elementui.js"></script> }
<!-- 组件配置信息 --> },
<script src="../../js/config.js"></script> methods: {
<!-- 扩展插件配置信息 --> // 初始化方法
<script src="../../modules/config.js"></script> init(id) {
<!-- 工具方法 --> this.getList(); // 获取列表数据
<script src="../../js/utils.js"></script> this.id = id; // 设置用户ID
<script type="text/javascript"> var that = this; // 保存this引用
var app = new Vue({ var inter = setInterval(function() {
el: "#app", that.getList(); // 定时获取列表数据
data() { }, 10000) // 每10秒执行一次
return { this.inter = inter; // 保存定时器引用
id: "", },
ruleForm: {}, // 获取列表数据的方法
dataList: [], getList() {
inter: null layui.http.request('chat/list', 'get', {
} userid: localStorage.getItem('userid'), // 从本地存储中获取用户ID
}, limit : 100, // 限制返回的数据条数
methods: { sort: 'addtime', // 按添加时间排序
// 初始化 order: 'asc' // 升序排列
init(id) { }, (res) => {
this.getList(); this.dataList = res.data.list; // 更新数据列表
this.id = id; })
var that = this; },
var inter = setInterval(function() { // 提交方法（未实现）
that.getList(); submit() {
}, 10000) this.getList(); // 获取列表数据
this.inter = inter; this.ruleForm.ask=""; // 清空输入框内容
}, }
getList() { }
layui.http.request('chat/list', 'get', { })">发送</el-button>
userid: localStorage.getItem('userid'), </div>
limit : 100, </el-form>
sort: 'addtime', </div>
order: 'asc' <!-- 引入layui模块 -->
}, (res) => { <script src="path/to/layui.js"></script>
this.dataList = res.data.list; <script>
}) layui.use(['layer', 'element', 'http', 'jquery'], function() {
}, // 使用layer模块
// 提交
onSubmit() {
if (!this.ruleForm.ask) {
layer.msg('请输入内容', {
time: 2000,
icon: 5
});
return
}
layui.http.requestJson('chat/add', 'post', {
userid: localStorage.getItem('userid'),
ask: this.ruleForm.ask
}, (res) => {
this.getList();
});
this.ruleForm.ask="";
}
}
})
layui.use(['layer', 'element', 'http', 'jquery'], function() {
var layer = layui.layer; var layer = layui.layer;
var element = layui.element; // 使用element模块
var http = layui.http; var element = layui.element;
var jquery = layui.jquery; // 使用http模块
app.init(); var http = layui.http;
}); // 使用jquery模块
</script> var jquery = layui.jquery;
</body>
app.init(); // 初始化应用
});
</script>
</body>
</html> </html>

443
src/main/webapp/front/pages/config/list.jsp
Unescape View File

@ -1,242 +1,207 @@
<%@ page language="java" contentType="text/html; charset=UTF-8" <!DOCTYPE html>
pageEncoding="UTF-8"%> <html lang="en">
<%@ page isELIgnored="true" %> <head>
<meta charset="UTF-8">
<title>轮播图管理</title>
<!-- 样式 -->
<link rel="stylesheet" href="../../layui/css/layui.css">
<!-- 主题（主要颜色设置） -->
<link rel="stylesheet" href="../../css/theme.css">
<!-- 通用的css -->
<link rel="stylesheet" href="../../css/common.css">
</head>
<body>
<div id="app">
<!-- 轮播图 -->
<div id="layui-carousel" class="layui-carousel">
<div carousel-item>
<div class="layui-carousel-item" v-for="(item, index) in swiperList" :key="index">
<img :src="item.img" />
</div>
</div>
</div>
<div id="breadcrumb">
<span class="en">DATA SHOW</span>
<span class="cn">轮播图管理展示</span>
</div>
<!-- 图文列表 -->
<div :style='{"padding":"0","margin":"0px auto","flexWrap":"wrap","background":"none","display":"flex","width":"100%","position":"relative"}' class="recommend">
<form :style='{"alignItems":"center","padding":"30px 20px","borderColor":"#bcdbdf","margin":"20px 7% 0","alignItems":"center","itemsAlign":"center","justifyContent":"center","display":"flex","width":"100%","borderWidth":"1px","borderStyle":"outset","height":"auto"}' class="filter form">
<div :style='{"alignItems":"center","margin":"0 4px 0 0","display":"flex"}' class="item-list">
<div class="lable-input">名称</div>
<input type="text" name="name" :style='{"border":"1px solid #eee","padding":"0 10px","boxShadow":"0px 0px 0px #ccc","margin":"0","color":"#666","fontSize":"14px","lineHeight":"40px","width":"120px","borderRadius":"30px","outline":"none"}' placeholder="名称" autocomplete="off" class="layui-input">
</div>
<button :style='{"cursor":"pointer","padding":"0px 10px","margin":"0 10px 0 0","color":"#fff","minWidth":"90px","outline":"none","borderRadius":"30px","background":"#40a9ff","borderWidth":"0px","width":"auto","fontSize":"14px","lineHeight":"42px","height":"40px"}' @click="search()"><i :style='{"color":"#fff","margin":"0 10px 0 0","fontSize":"14px"}' class="layui-icon layui-icon-search"></i>搜索</button>
<button v-if="isAuth('config','新增')" :style='{"cursor":"pointer","padding":"0px 10px","margin":"0 4px 0 0","color":"#fdaaba","minWidth":"90px","outline":"none","borderRadius":"30px","background":"#f7aa00","borderWidth":"0px","width":"auto","fontSize":"14px","lineHeight":"42px","height":"40px"}' @click="jump('../config/add.jsp')" type="button" class="btn btn-theme">
<i :style='{"color":"#fff","margin":"0 10px 0 0","fontSize":"14px"}' class="layui-icon">&#xe654;</i>新增
</button>
</form>
<div :style='{"padding":"40px 0 20px","margin":"40px 7% 0px 7%","flex":"1","background":"none","display":"flex","width":"100%","minWidth":"885px","borderWidth":"0 0 0 0","borderStyle":"solid","height":"auto","order":4}' class="lists">
<!-- 样式二 -->
<div :style='{"padding":"0","margin":"0 0 100px","flexWrap":"wrap","background":"none","display":"flex","justifyContent":"space-between","alignItems":"center","width":"100%","height":"auto"}' class="list list-2">
<div v-for="(item,index) in dataList" :key="index" @click="jump('../config/detail.jsp?id='+item.id)" :style='{"cursor":"pointer","padding":"10px","margin":"0 0 100px","boxShadow":"0px 0px 0px #eee","borderColor":"#f3d7ca","display":"flex","justifyContent":"space-between","flexWrap":"wrap","width":"49%","borderWidth":"0px","borderStyle":"solid","height":"240px","position":"relative","borderColor":"#f3d7ca"}' class="list-item animation-box">
<img :src="item.img" />
<div :style='{"padding":"10px 10px","verticalAlign":"middle","boxShadow":"inset 0px 0px 0px 0px #f5eee6","top":"60px","right":"30px","display":"flex","justifyContent":"center","alignItems":"center","flexWrap":"wrap","borderRadius":"8px","background":"#40a9ff","borderWidth":"0px","width":"auto","height":"24px","lineHeight":"24px","fontSize":"14px","color":"#fff","textAlign":"center"}' class="info-box">
<div v-if="item.price" :style='{"width":"100%","padding":"0px 4px","lineHeight":"24px","fontSize":"14px","color":"#f00","textAlign":"center"}' class="time">￥{{Number(item.price).toFixed(2)}}</div>
<div v-if="item.vipprice&&item.vipprice>0" :style='{"width":"100%","padding":"0px 4px","lineHeight":"24px","fontSize":"14px","color":"#f00","textAlign":"center"}' class="time">￥{{Number(item.vipprice).toFixed(2)}}} 会员价</div>
<div v-if="item.jf" :style='{"width":"100%","padding":"0px 4px","lineHeight":"24px","fontSize":"14px","color":"#f00","textAlign":"center"}' class="time">{{Number(item.jf).toFixed(0)}}积分</div>
</div>
</div>
</div>
</div>
</div>
<div class="pager" id="pager"></div>
</div>
<!-- layui -->
<!-- vue -->
<!-- 组件配置信息 -->
<!-- 扩展插件配置信息 -->
<!-- 工具方法 -->
<script>
var vue = new Vue({
el: '#app',
data: {
// 轮播图
swiperList: [{
img: '../../img/banner.jpg'
}],
baseurl: '',
dataList: []
},
methods: {
isAuth(tablename, button) {
return isFrontAuth(tablename, button)
},
jump(url) {
jump(url)
}
}
})
</script>
</body>
</html>
<!-- 轮播图管理 -->
<!DOCTYPE html> <!DOCTYPE html>
<html> <html lang="en">
<head> <head>
<meta charset="utf-8"> <meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1"> <title>Layui Example</title>
<title>轮播图管理</title> <!-- 引入layui的CSS文件 -->
<link rel="stylesheet" href="../../layui/css/layui.css"> <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/layui@2.7.6/dist/css/layui.css">
<!-- 样式 --> </head>
<link rel="stylesheet" href="../../css/style.css" /> <body>
<!-- 主题（主要颜色设置） --> <div id="app">
<link rel="stylesheet" href="../../css/theme.css" /> <!-- 轮播图容器 -->
<!-- 通用的css --> <div id="layui-carousel" class="layui-carousel" lay-filter="carousel"></div>
<link rel="stylesheet" href="../../css/common.css" />
</head> <!-- 搜索框和按钮 -->
<style> <div style="margin: 15px;">
.layui-form .layui-form-item .layui-form-select .layui-input { <input type="text" id="name" placeholder="请输入名称" class="layui-input">
border: 1px solid #eee; <button id="btn-search" class="layui-btn">搜索</button>
border-radius: 30px; </div>
padding: 0 30px 0 10px;
box-shadow: 0px 0px 0px #ccc; <!-- 列表容器 -->
margin: 0; <div id="list-container"></div>
outline: none;
color: #666; <!-- 分页容器 -->
width: 120px; <div id="pager"></div>
font-size: 14px; </div>
line-height: 40px;
height: 40px; <!-- 引入layui的JS文件 -->
} <script src="https://cdn.jsdelivr.net/npm/layui@2.7.6/dist/layui.all.js"></script>
<script>
/* lists */ layui.use(['form', 'layer', 'element', 'carousel', 'laypage', 'http', 'jquery','laydate', 'slider'], function() {
.lists .animation-box { var form = layui.form;
transform: rotate(0deg) scale(1) skew(0deg, 0deg) translate3d(0px, 0px, 0px); var layer = layui.layer;
} var element = layui.element;
var carousel = layui.carousel;
.lists .animation-box:hover { var laypage = layui.laypage;
transform: translate3d(0px, 0px, 0px); var http = layui.http;
-webkit-perspective: 1000px; var jquery = layui.jquery;
perspective: 1000px; var laydate = layui.laydate;
transition: 0.3s; var slider = layui.slider;
} var limit = 12;
vue.baseurl = http.baseurl;
.lists img { // 获取轮播图数据
transform: rotate(0deg) scale(1) skew(0deg, 0deg) translate3d(0px, 0px, 0px); http.request('config/list', 'get', {
} page: 1,
limit: 3
.lists img:hover { }, function(res) {
-webkit-perspective: 1000px; if (res.data.list.length > 0) {
perspective: 1000px; let swiperList = [];
transition: 0.3s; res.data.list.forEach(element => {
} if (element.value != null) {
/* lists */ swiperList.push({
</style> img: http.baseurl + element.value
<body> });
<div id="app"> }
<!-- 轮播图 --> });
<div id="layui-carousel" class="layui-carousel"> vue.swiperList = swiperList;
<div carousel-item>
<div class="layui-carousel-item" v-for="(item,index) in swiperList" :key="index"> vue.$nextTick(() => {
<img :src="item.img" /> carousel.render({
</div> elem: '#layui-carousel',
</div> width: '100%',
</div> height: '680px',
<!-- 轮播图 --> anim: 'default',
autoplay: 'true',
<div id="breadcrumb"> interval: '5000',
<span class="en">DATA SHOW</span> arrow: 'none',
<span class="cn">轮播图管理展示</span> indicator: 'inside'
</div> });
})
<!-- 图文列表 --> }
<div class="recommend" :style='{"padding":"0","margin":"0px auto","flexWrap":"wrap","background":"none","display":"flex","width":"100%","position":"relative"}'> });
// 分页列表
<form class="layui-form filter" :style='{"padding":"30px 20px 30px","borderColor":"#bcdbdf","margin":"20px 7% 0","alignItems":"center","background":"#fff","borderWidth":"1px 0px 2px","display":"flex","width":"100%","borderStyle":"outset","justifyContent":"center","height":"auto"}'> pageList();
<div :style='{"alignItems":"center","margin":"0 4px 0 0","display":"flex"}' class="item-list"> // 搜索按钮
<div class="lable" :style='{"width":"auto","padding":"0 10px","lineHeight":"42px"}'>名称</div> jquery('#btn-search').click(function(e) {
<input type="text" :style='{"border":"1px solid #eee","padding":"0 10px","boxShadow":"0px 0px 0px #ccc","margin":"0","outline":"none","color":"#666","borderRadius":"30px","width":"140px","fontSize":"14px","lineHeight":"40px","height":"40px"}' name="name" id="name" placeholder="名称" autocomplete="off" class="layui-input"> pageList();
</div> });
<button :style='{"cursor":"pointer","padding":"0px 10px","margin":"0 10px 0","borderColor":"#feabab","color":"#fff","minWidth":"90px","outline":"none","borderRadius":"30px","background":"#40a8c4","borderWidth":"0px","width":"auto","fontSize":"14px","lineHeight":"42px","borderStyle":"dashed","height":"42px"}' id="btn-search" type="button" class="layui-btn layui-btn-normal"> function pageList() {
<i :style='{"color":"#fff","margin":"0 10px 0 0","fontSize":"14px"}' class="layui-icon layui-icon-search"></i>搜索 var param = {
</button> page: 1,
<button :style='{"cursor":"pointer","padding":"0px 10px","margin":"0 4px 0 0","borderColor":"#fda100","color":"#fff","minWidth":"90px","outline":"none","borderRadius":"30px","background":"#f7aa00","borderWidth":"0px","width":"auto","fontSize":"14px","lineHeight":"42px","borderStyle":"solid","height":"42px"}' v-if="isAuth('config','新增')" @click="jump('../config/add.jsp')" type="button" class="layui-btn btn-theme"> limit: limit
<i :style='{"color":"#fff","margin":"0 10px 0 0","fontSize":"14px"}' class="layui-icon">&#xe654;</i>添加 }
</button>
</form> if (jquery('#name').val()) {
param['name'] = jquery('#name').val() ? '%' + jquery('#name').val() + '%' : '';
<div :style='{"padding":"40px 0 20px","margin":"40px 7% 0px","borderColor":"#f3d7ca","background":"none","flex":"1","borderWidth":"0 0px 0 0","width":"100%","minWidth":"850px","borderStyle":"solid","order":"4"}' class="lists"> }
<!-- 样式二 -->
<div :style='{"padding":"0px","flexWrap":"wrap","background":"none","display":"flex","width":"100%","justifyContent":"space-between","height":"auto"}' class="list list-2"> // 获取列表数据
<div :style='{"cursor":"pointer","padding":"10px","boxShadow":"0px 0px 0px #eee","margin":"0 0 100px","borderColor":"#ddd","display":"flex","justifyContent":"space-between","flexWrap":"wrap","background":"url(http://codegen.caihongy.cn/20230206/de4c50b5282f45f8a59707bce3185db8.png) no-repeat left bottom / 20%,url(http://codegen.caihongy.cn/20230206/5e80378b411c4449a860d66e35c5c969.png) no-repeat right top / 20%","borderWidth":"0px","width":"49%","position":"relative","borderStyle":"solid","height":"240px"}' @click="jump('../config/detail.jsp?id='+item.id)" v-for="(item,index) in dataList" :key="index" class="list-item animation-box"> http.request('config/list', 'get', param, function(res) {
<div :style='{"padding":"10px 10px","verticalAlign":"middle","boxShadow":"inset 0px 0px 0px 0px #f5eee6","borderColor":"#f3d7ca #f3d7ca #f3d7ca","alignItems":"flex-start","display":"flex","right":"30px","justifyContent":"center","top":"60px","borderRadius":"8px","flexWrap":"wrap","borderWidth":"0px 0px 0px","background":"none","width":"44%","position":"absolute","borderStyle":"solid","height":"90%"}' class="item-info"> vue.dataList = res.data.list;
<div v-if="item.price" :style='{"width":"100%","padding":"0px 4px","lineHeight":"24px","fontSize":"14px","color":"#f00","textAlign":"center"}' class="time">￥{{Number(item.price).toFixed(2)}}</div> // 分页
<div v-if="item.vipprice&&item.vipprice>0" :style='{"width":"100%","padding":"0px 4px","lineHeight":"24px","fontSize":"14px","color":"#f00","textAlign":"center"}' class="time">￥{{Number(item.vipprice).toFixed(2)}} 会员价</div> laypage.render({
<div v-if="item.jf" :style='{"width":"100%","padding":"0px 4px","lineHeight":"24px","fontSize":"14px","color":"#f00","textAlign":"center"}' class="time">{{Number(item.jf).toFixed(0)}}积分</div> elem: 'pager',
</div> count: res.data.total,
</div> limit: limit,
</div> groups: 5,
</div> layout: ["count", "prev", "page", "next", "limit", "skip"],
prev: '上一页',
next: '下一页',
<div class="pager" id="pager"></div> jump: function(obj, first) {
param.page = obj.curr;
</div> // 首次不执行
</div> if (!first) {
http.request('config/list', 'get', param, function(res) {
vue.dataList = res.data.list;
<!-- layui --> });
<script src="../../layui/layui.js"></script> }
<!-- vue --> }
<script src="../../js/vue.js"></script> });
<!-- 组件配置信息 --> });
<script src="../../js/config.js"></script> }
<!-- 扩展插件配置信息 --> });
<script src="../../modules/config.js"></script> </script>
<!-- 工具方法 --> </body>
<script src="../../js/utils.js"></script>
<script type="text/javascript" src="../../js/jquery.js"></script>
<script>
var vue = new Vue({
el: '#app',
data: {
// 轮播图
swiperList: [{
img: '../../img/banner.jpg'
}],
baseurl: '',
dataList: []
},
methods: {
isAuth(tablename, button) {
return isFrontAuth(tablename, button)
},
jump(url) {
jump(url)
}
}
})
layui.use(['form', 'layer', 'element', 'carousel', 'laypage', 'http', 'jquery','laydate', 'slider'], function() {
var form = layui.form;
var layer = layui.layer;
var element = layui.element;
var carousel = layui.carousel;
var laypage = layui.laypage;
var http = layui.http;
var jquery = layui.jquery;
var laydate = layui.laydate;
var slider = layui.slider;
var limit = 12;
vue.baseurl = http.baseurl;
// 获取轮播图 数据
http.request('config/list', 'get', {
page: 1,
limit: 3
}, function(res) {
if (res.data.list.length > 0) {
let swiperList = [];
res.data.list.forEach(element => {
if (element.value != null) {
swiperList.push({
img: http.baseurl+element.value
});
}
});
vue.swiperList = swiperList;
vue.$nextTick(() => {
carousel.render({
elem: '#layui-carousel',
width: '100%',
height: '680px',
anim: 'default',
autoplay: 'true',
interval: '5000',
arrow: 'none',
indicator: 'inside'
});
})
}
});
// 分页列表
pageList();
// 搜索按钮
jquery('#btn-search').click(function(e) {
pageList();
});
function pageList() {
var param = {
page: 1,
limit: limit
}
if (jquery('#name').val()) {
param['name'] = jquery('#name').val() ? '%' + jquery('#name').val() + '%' : '';
}
if (jquery('#name').val()) {
param['name'] = jquery('#name').val() ? '%' + jquery('#name').val() + '%' : '';
}
// 获取列表数据
http.request('config/list', 'get', param, function(res) {
vue.dataList = res.data.list
// 分页
laypage.render({
elem: 'pager',
count: res.data.total,
limit: limit,
groups: 5,
layout: ["count","prev","page","next","limit","skip"],
prev: '上一页',
next: '下一页',
jump: function(obj, first) {
param.page = obj.curr;
//首次不执行
if (!first) {
http.request('config/list', 'get', param, function(res) {
vue.dataList = res.data.list
})
}
}
});
})
}
});
</script>
</body>
</html> </html>

244
src/main/webapp/front/pages/forum/list-my.jsp
Unescape View File

@ -1,6 +1,4 @@
<%@ page language="java" contentType="text/html; charset=UTF-8" <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" isELIgnored="true" %>
pageEncoding="UTF-8"%>
<%@ page isELIgnored="true" %>
<!-- 论坛中心 --> <!-- 论坛中心 -->
<!DOCTYPE html> <!DOCTYPE html>
<html> <html>
@ -16,18 +14,10 @@
<!-- 通用的css --> <!-- 通用的css -->
<link rel="stylesheet" href="../../css/common.css" /> <link rel="stylesheet" href="../../css/common.css" />
</head> </head>
<style>
.layui-laypage .layui-laypage-count {
padding: 0 10px;
}
.layui-laypage .layui-laypage-skip {
padding-left: 10px;
}
</style>
<body> <body>
<div id="app"> <div id="app">
<!-- 轮播图 --> <!-- 轮播图 -->
<div id="layui-carousel" class="layui-carousel"> <div id="layui-carousel" class="layui-carousel" lay-filter="carousel">
<div carousel-item> <div carousel-item>
<div class="layui-carousel-item" v-for="(item,index) in swiperList" :key="index"> <div class="layui-carousel-item" v-for="(item,index) in swiperList" :key="index">
<img :src="item.img" /> <img :src="item.img" />
@ -35,17 +25,14 @@
</div> </div>
</div> </div>
<!-- 轮播图 -->
<!-- 标题 --> <!-- 标题 -->
<div id="breadcrumb"> <div id="breadcrumb">
<span class="en">FORUM / INFORMATION</span> <span class="en">FORUM / INFORMATION</span>
<span class="cn">我的发布</span> <span class="cn">我的发布</span>
</div> </div>
<!-- 标题 -->
<div class="forum-container"> <div class="forum-container">
<table class="layui-table" lay-skin="nob"> <table class="layui-table nob" lay-skin="line">
<thead> <thead>
<tr> <tr>
<th>标题</th> <th>标题</th>
@ -54,89 +41,84 @@
</tr> </tr>
</thead> </thead>
<tbody> <tbody>
<tr v-for="(item,index) in dataList" v-bind:key="index"> <tr v-for="(item,index) in dataList" v-key="index">
<td @click="jump('../forum/detail.jsp?id='+item.id);" style="text-align:left">{{item.title}}</td> <td @click="jump('../forum/detail.jsp?id='+item.id);" style="text-align:left">{{item.title}}</td>
<td style="text-align:left">{{item.addtime}}</td> <td style="text-align:left">{{item.addtime}}</td>
<td style="text-align:left"> <td style="text-align:left">
<button @click="jump('../forum/update.jsp?id='+item.id);" type="button" class="layui-btn layui-btn-radius btn-warm"> <button @click="jump('../forum/update.jsp?id='+item.id);" type="button" class="layui-btn layui-btn-radius btn-warm">
修改 修改
</button> </button>
<button @click="deleteClick(item.id)" type="button" class="layui-btn layui-btn-radius btn-theme"> <button @click="deleteClick(item.id)" type="button" class="layui-btn layui-btn-radius btn-theme">
删除 删除
</button> </button>
</td> </td>
</tr> </tr>
</tbody> </tbody>
</table> </table>
<div class="pager" id="pager"></div> <div class="pager" id="pager"></div>
</div> </div>
</div>
</div> <!-- layui -->
<script src="../../layui/layui.js"></script>
<!-- layui --> <!-- vue -->
<script src="../../layui/layui.js"></script> <script src="../../js/vue.js"></script>
<!-- vue --> <!-- 组件配置信息 -->
<script src="../../js/vue.js"></script> <script src="../../js/component.js"></script>
<!-- 组件配置信息 --> <!-- 扩展插件配置信息 -->
<script src="../../js/config.js"></script> <script src="../../js/extend.js"></script>
<!-- 扩展插件配置信息 --> <!-- 工具方法 -->
<script src="../../modules/config.js"></script> <script src="../../js/tool.js"></script>
<!-- 工具方法 --> <script>
<script src="../../js/utils.js"></script> var vue = new Vue({
el: '#app',
<script> // 轮播图
var vue = new Vue({ data: {
el: '#app', // 轮播图
data: { swiperList: [],
// 轮播图 // 列表数据
swiperList: [{ dataList: []
img: '../../img/banner.jpg' },
}], filters: {
dataList: [] newsDesc: function(val) {
}, if (val) {
filters: { if (val.length > 200) {
newsDesc: function(val) { return val.substring(0, 200) + '...';
if (val) { } else {
if (val.length > 200) { return val.replace(/<\/?[^>]+>/g, '').replace(/undefined/g, '');
return val.substring(0, 200).replace(/<[^>]*>/g).replace(/undefined/g, ''); }
} else { }
return val.replace(/<[^>]*>/g).replace(/undefined/g, ''); return '';
} }
} },
return ''; methods: {
} jump(url) {
}, jump(url)
methods: { },
jump(url) { deleteClick(id) {
jump(url) layui.layer.confirm('是否确认删除？', {
}, btn: ['删除', '取消'] //按钮
deleteClick(id) { }, function() {
layui.layer.confirm('是否确认删除？', { layui.http.requestJson(`forum/delete`, 'post', [id], function() {
btn: ['删除', '取消'] //按钮 layer.msg('删除成功', {
}, function() { time: 2000,
layui.http.requestJson(`forum/delete`, 'post', [id], function(res) { icon: 6,
layer.msg('删除成功', { }, function() {
time: 2000, window.location.reload();
icon: 6 });
}, function(res) { })
window.location.reload(); });
}); }
}) }
}); });
} layui.use(['layer', 'element', 'carousel', 'laypage', 'http', 'jquery'], function() {
} var layer = layui.layer;
}) var element = layui.element;
var carousel = layui.carousel;
layui.use(['layer', 'element', 'carousel', 'laypage', 'http', 'jquery'], function() { var laypage = layui.laypage;
var layer = layui.layer; var http = layui.http;
var element = layui.element; var jquery = layui.jquery;
var carousel = layui.carousel;
var laypage = layui.laypage;
var http = layui.http;
var jquery = layui.jquery;
var limit = 10;
var limit = 10;
// 获取轮播图 数据 // 获取轮播图 数据
http.request('config/list', 'get', { http.request('config/list', 'get', {
page: 1, page: 1,
@ -145,11 +127,11 @@
if (res.data.list.length > 0) { if (res.data.list.length > 0) {
let swiperList = []; let swiperList = [];
res.data.list.forEach(element => { res.data.list.forEach(element => {
if (element.value != null) { if (element.value != null) {
swiperList.push({ swiperList.push({
img: http.baseurl+element.value img: httpbaseurl+element.value
}); });
} }
}); });
vue.swiperList = swiperList; vue.swiperList = swiperList;
@ -167,37 +149,35 @@
}) })
} }
}); });
// 获取列表数据
// 获取列表数据 http.request('forum/page?parentid=0&sort=addtime&order=desc', 'get', {
http.request('forum/page?parentid=0&sort=addtime&order=desc', 'get', { page: 1,
page: 1,
limit: limit limit: limit
}, function(res) { }, function(res) {
vue.dataList = res.data.list vue.dataList = res.data.list;
// 分页 // 分页
laypage.render({ laypage.render({
elem: 'pager', elem: 'pager',
count: res.data.total, count: res.data.total,
limit: limit, limit: limit,
groups: 5, groups: 5,
layout: ["count","prev","page","next","limit","skip"], layout: ["count","prev","page","next","limit","skip"],
prev: '上一页', prev: '上一页',
next: '下一页', next: '下一页',
jump: function(obj, first) { jump: function(obj, first) {
//首次不执行 //首次不执行
if (!first) { if (!first) {
http.request('forum/page?parentid=0&sort=addtime&order=desc', 'get', { http.request('forum/page?parentid=0&sort=addtime&order=desc', 'get', {
page: obj.curr, page: obj.curr,
limit: obj.limit limit: obj.limit
}, function(res) { }, function(res) {
vue.dataList = res.data.list vue.dataList = res.data.list;
}) });
} }
} }
}); });
}) });
});
}); </script>
</script> </body>
</body>
</html> </html>

356
src/main/webapp/front/pages/forum/list.jsp
Unescape View File

@ -1,203 +1,191 @@
<%@ page language="java" contentType="text/html; charset=UTF-8" <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" isELIgnored="true" %>
pageEncoding="UTF-8"%>
<%@ page isELIgnored="true" %>
<!-- 论坛中心 --> <!-- 论坛中心 -->
<!DOCTYPE html> <!DOCTYPE html>
<html> <meta charset="utf-8">
<head> <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<meta charset="utf-8"> <title>论坛</title>
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1"> <!-- 样式 -->
<title>论坛</title> <link rel="stylesheet" href="../../layui/css/layui.css">
<link rel="stylesheet" href="../../layui/css/layui.css"> <!-- 主题颜色（主要颜色设置） -->
<!-- 样式 --> <link rel="stylesheet" href="../../css/theme.css" />
<link rel="stylesheet" href="../../css/style.css" /> <!-- 通用的css -->
<!-- 主题（主要颜色设置） --> <link rel="stylesheet" href="../../css/common.css" />
<link rel="stylesheet" href="../../css/theme.css" /> <style>
<!-- 通用的css --> .forum-container .btn-container {
<link rel="stylesheet" href="../../css/common.css" /> display: flex;
</head> align-items: center;
<style> box-sizing: border-box;
.forum-container .btn-container { width: 100%;
display: flex; }
align-items: center;
box-sizing: border-box;
width: 100%;
}
.forum-container .btn-container #title { .forum-container .btn-container #title {
padding: 0 10px; padding: 0 10px;
flex: 1; flex: 1;
margin-right: 10px; margin-right: 10px;
} }
.forum-container .btn-container button { .forum-container .btn-container button {
height: 38px; height: 38px;
line-height: 38px; line-height: 38px;
width: auto; width: auto;
margin: 0 0 0 10px; margin: 0 0 0 10px;
} }
</style> </style>
<body> </head>
<div id="app"> <body>
<!-- 轮播图 --> <div id="app">
<div id="layui-carousel" class="layui-carousel"> <!-- 轮播图 -->
<div carousel-item> <div id="layui-carousel" class="layui-carousel">
<div class="layui-carousel-item" v-for="(item,index) in swiperList" :key="index"> <div carousel-item>
<img :src="item.img" /> <div class="layui-carousel-item" v-for="(item,index) in swiperList" key="index">
</div> <img :src="item.img" />
</div>
</div> </div>
<!-- 轮播图 --> </div>
</div>
<!-- 轮播图 -->
<!-- 标题 --> <!-- 标题 -->
<div id="breadcrumb"> <div id="breadcrumb">
<span class="en">FORUM / INFORMATION</span> <span class="en">FORUM / INFORMATION</span>
<span class="cn">论坛</span> <span class="cn">论坛</span>
</div> </div>
<!-- 标题 --> <!-- 标题 -->
<div class="forum-container"> <div class="forum-container">
<div class="btn-container"> <div class="btn-container">
<input type="text" name="title" id="title" placeholder="标题" autocomplete="off" class="layui-input"> <input type="text" name="title" id="title" placeholder="请输入标题" autocomplete="off" class="layui-input">
<button id="btn-search" type="button" class="layui-btn layui-btn-normal"> <button id="btn-search" type="button" class="layui-btn layui-btn-normal">
<i class="layui-icon layui-icon-search"></i>搜索 <i class="layui-icon layui-icon-search"></i>搜索
</button> </button>
<button @click="jump('../forum/add.jsp')" type="button" class="layui-btn btn-theme"> <button @click="jump('../forum/add.jsp')" type="button" class="layui-btn btn-theme">
<i class="layui-icon">&#xe654;</i> 发布帖子 <i class="layui-icon">&#xe654;</i> 发布帖子
</button> </button>
</div> </div>
<div class="forum-list"> <div class="forum-list">
<div v-for="(item,index) in dataList" v-bind:key="index" href="javascript:void(0);" @click="jump('../forum/detail.jsp?id='+item.id);" class="forum-item"> <div v-for="(item,index) in dataList" v-bind:key="index" href="void(0);" @click="jump('../forum/detail.jsp?id='+item.id)" class="forum-item">
<h2 class="h2">{{item.title}}（发布人：{{item.username}}）</h2> <h2 class="h2">{{item.title}}（发布人：{{item.username}}）</h2>
<div class="create-time"> <div class="create-time">
{{item.addtime}} {{item.addtime}}
</div>
</div>
</div> </div>
<div class="pager" id="pager"></div>
</div> </div>
</div> </div>
<div class="pager" id="pager"></div>
</div>
</div>
<!-- 轮播图 -->
<!-- 标题 -->
<!-- 组件配置信息 -->
<!-- 扩展插件配置信息 -->
<!-- 工具方法 -->
<!-- layui --> <script>
<script src="../../layui/layui.js"></script> var vue = new Vue({
<!-- vue --> el: '#app',
<script src="../../js/vue.js"></script> data: {
<!-- 组件配置信息 --> // 轮播图
<script src="../../js/config.js"></script> swiperList: [{
<!-- 扩展插件配置信息 --> img: '../../img/banner.jpg'
<script src="../../modules/config.js"></script> }],
<!-- 工具方法 --> dataList: []
<script src="../../js/utils.js"></script> },
filters: {
<script> newsDesc: function(val) {
var vue = new Vue({ if (val) {
el: '#app', if (val.length > 200) {
data: { return val.substring(0, 200).replace(/<[^>]*>/g).replace(/undefined/g, '');
// 轮播图 } else {
swiperList: [{ return val.replace(/<[^>]*>/g).replace(/undefined/g, '');
img: '../../img/banner.jpg' }
}], }
dataList: [] return '';
}, }
filters: { },
newsDesc: function(val) { methods: {
if (val) { jump(url) {
if (val.length > 200) { jump(url)
return val.substring(0, 200).replace(/<[^>]*>/g).replace(/undefined/g, ''); }
} else { }
return val.replace(/<[^>]*>/g).replace(/undefined/g, ''); })
}
}
return '';
}
},
methods: {
jump(url) {
jump(url)
}
}
})
layui.use(['layer', 'element', 'carousel', 'laypage', 'http', 'jquery'], function() {
var layer = layui.layer;
var element = layui.element;
var carousel = layui.carousel;
var laypage = layui.laypage;
var http = layui.http;
var jquery = layui.jquery;
var limit = 10; layui.use(['layer', 'element', 'carousel', 'laypage', 'http', 'jquery'], function() {
var layer = layui.layer;
var element = layui.element;
var carousel = layui.carousel;
var laypage = layui.laypage;
var http = layui.http;
var jquery = layui.jquery;
// 获取轮播图 数据 var limit = 10;
http.request('config/list', 'get', {
page: 1,
limit: 3
}, function(res) {
if (res.data.list.length > 0) {
let swiperList = [];
res.data.list.forEach(element => {
if (element.value != null) {
swiperList.push({
img: http.baseurl+element.value
});
}
});
vue.swiperList = swiperList;
vue.$nextTick(() => { // 获取轮播图 数据
carousel.render({ http.request('config/list', 'get', {
elem: '#layui-carousel', page: 1,
width: '100%', limit: 3
height: '680px', }, function(res) {
anim: 'default', if (res.data.list.length > 0) {
autoplay: 'true', let swiperList = [];
interval: '5000', res.data.list.forEach(element => {
arrow: 'none', if (element.value != null) {
indicator: 'inside' swiperList.push({
}); img: http.baseurl+element.value
}) });
} }
}); });
vue.swiperList = swiperList;
pageList(); vue.$nextTick(() => {
carousel.render({
elem: '#layui-carousel',
width: '100%',
height: '680px',
anim: 'default',
autoplay: 'true',
interval: '5000',
arrow: 'none',
indicator: 'inside'
});
})
}
});
// 搜索按钮 pageList();
jquery('#btn-search').click(function(e) {
pageList();
});
function pageList() {
// 获取列表数据
http.request('forum/flist?isdone=开放&sort=addtime&order=desc', 'get', {
page: 1,
limit: limit,
title: '%' + jquery('#title').val() + '%',
}, function(res) {
vue.dataList = res.data.list
// 分页
laypage.render({
elem: 'pager',
count: res.data.total,
limit: limit,
groups: 5,
layout: ["count","prev","page","next","limit","skip"],
prev: '上一页',
next: '下一页',
jump: function(obj, first) {
//首次不执行
if (!first) {
http.request('forum/flist?isdone=开放&sort=addtime&order=desc', 'get', {
page: obj.curr,
limit: obj.limit
}, function(res) {
vue.dataList = res.data.list
})
}
}
});
})
}
}); // 搜索按钮
</script> jquery('#btn-search').click(function(e) {
</body> pageList();
});
function pageList() {
// 获取列表数据
http.request('forum/flist?isdone=开放&sort=addtime&order=desc', 'get', {
page: 1,
limit: limit,
title: '%' + jquery('#title').val() + '%',
}, function(res) {
vue.dataList = res.data.list
// 分页
laypage.render({
elem: 'pager',
count: res.data.total,
limit: limit,
groups: 5,
layout: ["count","prev","page","next","limit","skip"],
prev: '上一页',
next: '下一页',
jump: function(obj, first) {
//首次不执行
if (!first) {
http.request('forum/flist?isdone=开放&sort=addtime&order=desc', 'get', {
page: obj.curr,
limit: obj.limit
}, function(res) {
vue.dataList = res.data.list
})
}
}
});
})
}
});
</script>
</body>
</html> </html>

86
src/main/webapp/resources/ueditor/dialogs/searchreplace/searchreplace.js
Unescape View File

@ -9,6 +9,7 @@
//清空上次查选的痕迹 //清空上次查选的痕迹
editor.firstForSR = 0; editor.firstForSR = 0;
editor.currentRangeForSR = null; editor.currentRangeForSR = null;
//给tab注册切换事件 //给tab注册切换事件
/** /**
* tab点击处理事件 * tab点击处理事件
@ -16,51 +17,53 @@ editor.currentRangeForSR = null;
* @param tabBodys * @param tabBodys
* @param obj * @param obj
*/ */
function clickHandler( tabHeads,tabBodys,obj ) { function clickHandler(tabHeads, tabBodys, obj) {
//head样式更改 //head样式更改
for ( var k = 0, len = tabHeads.length; k < len; k++ ) { for (var k = 0, len = tabHeads.length; k < len; k++) {
tabHeads[k].className = ""; tabHeads[k].className = "";
} }
obj.className = "focus"; obj.className = "focus";
//body显隐 //body显隐
var tabSrc = obj.getAttribute( "tabSrc" ); var tabSrc = obj.getAttribute("tabSrc");
for ( var j = 0, length = tabBodys.length; j < length; j++ ) { for (var j = 0, length = tabBodys.length; j < length; j++) {
var body = tabBodys[j], var body = tabBodys[j],
id = body.getAttribute( "id" ); id = body.getAttribute("id");
if ( id != tabSrc ) { if (id != tabSrc) {
body.style.zIndex = 1; body.style.zIndex = 1;
} else { } else {
body.style.zIndex = 200; body.style.zIndex = 200;
} }
} }
} }
/** /**
* TAB切换 * TAB切换
* @param tabParentId tab的父节点ID或者对象本身 * @param tabParentId tab的父节点ID或者对象本身
*/ */
function switchTab( tabParentId ) { function switchTab(tabParentId) {
var tabElements = $G( tabParentId ).children, var tabElements = $G(tabParentId).children,
tabHeads = tabElements[0].children, tabHeads = tabElements[0].children,
tabBodys = tabElements[1].children; tabBodys = tabElements[1].children;
for ( var i = 0, length = tabHeads.length; i < length; i++ ) { for (var i = 0, length = tabHeads.length; i < length; i++) {
var head = tabHeads[i]; var head = tabHeads[i];
if ( head.className === "focus" )clickHandler(tabHeads,tabBodys, head ); if (head.className === "focus") clickHandler(tabHeads, tabBodys, head);
head.onclick = function () { head.onclick = function () {
clickHandler(tabHeads,tabBodys,this); clickHandler(tabHeads, tabBodys, this);
} };
} }
} }
$G('searchtab').onmousedown = function(){
$G('searchtab').onclick = function () {
$G('search-msg').innerHTML = ''; $G('search-msg').innerHTML = '';
$G('replace-msg').innerHTML = '' $G('replace-msg').innerHTML = '';
} };
//是否区分大小写 //是否区分大小写
function getMatchCase(id) { function getMatchCase(id) {
return $G(id).checked ? true : false; return $G(id).checked ? true : false;
} }
//查找 //查找
$G("nextFindBtn").onclick = function (txt, dir, mcase) { $G("nextFindBtn").onclick = function (txt, dir, mcase) {
var findtxt = $G("findtxt").value, obj; var findtxt = $G("findtxt").value, obj;
@ -68,56 +71,58 @@ $G("nextFindBtn").onclick = function (txt, dir, mcase) {
return false; return false;
} }
obj = { obj = {
searchStr:findtxt, searchStr: findtxt,
dir:1, dir: 1,
casesensitive:getMatchCase("matchCase") casesensitive: getMatchCase("matchCase")
}; };
if (!frCommond(obj)) { if (!frCommond(obj)) {
var bk = editor.selection.getRange().createBookmark(); var bk = editor.selection.getRange().createBookmark();
$G('search-msg').innerHTML = lang.getEnd; $G('search-msg').innerHTML = lang.getEnd;
editor.selection.getRange().moveToBookmark(bk).select(); editor.selection.getRange().moveToBookmark(bk).select();
} }
}; };
$G("nextReplaceBtn").onclick = function (txt, dir, mcase) { $G("nextReplaceBtn").onclick = function (txt, dir, mcase) {
var findtxt = $G("findtxt1").value, obj; var findtxt = $G("findtxt1").value, obj;
if (!findtxt) { if (!findtxt) {
return false; return false;
} }
obj = { obj = {
searchStr:findtxt, searchStr: findtxt,
dir:1, dir: 1,
casesensitive:getMatchCase("matchCase1") casesensitive: getMatchCase("matchCase1")
}; };
frCommond(obj); frCommond(obj);
}; };
$G("preFindBtn").onclick = function (txt, dir, mcase) { $G("preFindBtn").onclick = function (txt, dir, mcase) {
var findtxt = $G("findtxt").value, obj; var findtxt = $G("findtxt").value, obj;
if (!findtxt) { if (!findtxt) {
return false; return false;
} }
obj = { obj = {
searchStr:findtxt, searchStr: findtxt,
dir:-1, dir: -1,
casesensitive:getMatchCase("matchCase") casesensitive: getMatchCase("matchCase")
}; };
if (!frCommond(obj)) { if (!frCommond(obj)) {
$G('search-msg').innerHTML = lang.getStart; $G('search-msg').innerHTML = lang.getStart;
} }
}; };
$G("preReplaceBtn").onclick = function (txt, dir, mcase) { $G("preReplaceBtn").onclick = function (txt, dir, mcase) {
var findtxt = $G("findtxt1").value, obj; var findtxt = $G("findtxt1").value, obj;
if (!findtxt) { if (!findtxt) {
return false; return false;
} }
obj = { obj = {
searchStr:findtxt, searchStr: findtxt,
dir:-1, dir: -1,
casesensitive:getMatchCase("matchCase1") casesensitive: getMatchCase("matchCase1")
}; };
frCommond(obj); frCommond(obj);
}; };
//替换 //替换
$G("repalceBtn").onclick = function () { $G("repalceBtn").onclick = function () {
var findtxt = $G("findtxt1").value.replace(/^\s|\s$/g, ""), obj, var findtxt = $G("findtxt1").value.replace(/^\s|\s$/g, ""), obj,
@ -129,13 +134,14 @@ $G("repalceBtn").onclick = function () {
return false; return false;
} }
obj = { obj = {
searchStr:findtxt, searchStr: findtxt,
dir:1, dir: 1,
casesensitive:getMatchCase("matchCase1"), casesensitive: getMatchCase("matchCase1"),
replaceStr:replacetxt replaceStr: replacetxt
}; };
frCommond(obj); frCommond(obj);
}; };
//全部替换 //全部替换
$G("repalceAllBtn").onclick = function () { $G("repalceAllBtn").onclick = function () {
var findtxt = $G("findtxt1").value.replace(/^\s|\s$/g, ""), obj, var findtxt = $G("findtxt1").value.replace(/^\s|\s$/g, ""), obj,
@ -147,18 +153,20 @@ $G("repalceAllBtn").onclick = function () {
return false; return false;
} }
obj = { obj = {
searchStr:findtxt, searchStr: findtxt,
casesensitive:getMatchCase("matchCase1"), casesensitive: getMatchCase("matchCase1"),
replaceStr:replacetxt, replaceStr: replacetxt,
all:true all: true
}; };
var num = frCommond(obj); var num = frCommond(obj);
if (num) { if (num) {
$G('replace-msg').innerHTML = lang.countMsg.replace("{#count}", num); $G('replace-msg').innerHTML = lang.countMsg.replace("{#count}", num);
} }
}; };
//执行 //执行
var frCommond = function (obj) { var frCommond = function (obj) {
return editor.execCommand("searchreplace", obj); return editor.execCommand("searchreplace", obj);
}; };
switchTab("searchtab");
switchTab("searchtab"); //注释代码
Write Preview
Loading…
Cancel
Save