注释代码

wujiamei_branch
wjm 8 months ago
parent 3af043d946
commit d68ef9898b

@ -42,310 +42,214 @@ 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("管理员")) {
if (!request.getSession().getAttribute("role").toString().equals("管理员")) { chat.setUserid((Long)request.getSession().getAttribute("userId"));
}
chat.setUserid((Long) request.getSession().getAttribute("userId"));
}
// 创建一个EntityWrapper对象用于构建MyBatis Plus的查询条件
EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>(); EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
// 调用chatService的queryPage方法进行分页查询传入构建好的查询条件和参数 PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params));
PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params)); request.setAttribute("data", page);
// 将查询结果设置到请求属性中,可能用于在后续的视图渲染中使用
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("管理员")) {
if (!request.getSession().getAttribute("role").toString().equals("管理员")) { chat.setUserid((Long)request.getSession().getAttribute("userId"));
}
chat.setUserid((Long) request.getSession().getAttribute("userId"));
}
// 创建一个EntityWrapper对象用于构建MyBatis Plus的查询条件
EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>(); EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
// 调用chatService的queryPage方法进行分页查询传入构建好的查询条件和参数 PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params));
PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params)); request.setAttribute("data", page);
// 将查询结果设置到请求属性中,可能用于在后续的视图渲染中使用
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对象用于构建MyBatis Plus的查询条件 EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>(); ew.allEq(MPUtil.allEQMapPre( chat, "chat"));
// 根据传入的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对象用于构建MyBatis Plus的查询条件 EntityWrapper< ChatEntity> ew = new EntityWrapper< ChatEntity>();
EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>(); ew.allEq(MPUtil.allEQMapPre( chat, "chat"));
// 根据传入的ChatEntity对象构建等值查询条件 ChatView chatView = chatService.selectView(ew);
ew.allEq(MPUtil.allEQMapPre(chat, "chat")); return R.ok("查询在线咨询成功").put("data", chatView);
// 调用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){
// 设置聊天记录的ID由当前时间戳加上一个随机数生成 chat.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
chat.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); //ValidatorUtils.validateEntity(chat);
// 此处原本可能用于验证ChatEntity对象的合法性但被注释掉了 if(StringUtils.isNotBlank(chat.getAsk())) {
//ValidatorUtils.validateEntity(chat); chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", request.getSession().getAttribute("userId")));
// 如果聊天记录的提问内容不为空 chat.setUserid((Long)request.getSession().getAttribute("userId"));
if (StringUtils.isNotBlank(chat.getAsk())) { chat.setIsreply(1);
// 更新当前用户的未回复状态为0表示有新提问 }
chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", request.getSession().getAttribute("userId"))); if(StringUtils.isNotBlank(chat.getReply())) {
// 设置聊天记录的用户ID为当前用户ID chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", chat.getUserid()));
chat.setUserid((Long) request.getSession().getAttribute("userId")); chat.setAdminid((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){
// 设置聊天记录的ID由当前时间戳加上一个随机数生成 chat.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
chat.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); //ValidatorUtils.validateEntity(chat);
chat.setUserid((Long)request.getSession().getAttribute("userId"));
if(StringUtils.isNotBlank(chat.getAsk())) {
// 设置聊天记录的用户ID为当前用户ID chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", request.getSession().getAttribute("userId")));
chat.setUserid((Long) request.getSession().getAttribute("userId")); 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("/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方法根据ID更新聊天记录 chatService.updateById(chat);//全部更新
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中 map.put("column", columnName);
map.put("column", columnName); map.put("type", type);
map.put("type", type);
if(type.equals("2")) {
// 如果提醒类型为2 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
if (type.equals("2")) { Calendar c = Calendar.getInstance();
// 创建SimpleDateFormat对象用于日期格式化 Date remindStartDate = null;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); Date remindEndDate = null;
// 获取Calendar实例用于日期计算 if(map.get("remindstart")!=null) {
Calendar c = Calendar.getInstance(); Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
Date remindStartDate = null; c.setTime(new Date());
Date remindEndDate = null; c.add(Calendar.DAY_OF_MONTH,remindStart);
// 如果查询条件Map中包含remindstart开始提醒时间 remindStartDate = c.getTime();
if (map.get("remindstart")!= null) { map.put("remindstart", sdf.format(remindStartDate));
// 将remindstart转换为整数表示要添加的天数 }
Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); if(map.get("remindend")!=null) {
// 设置当前日期为基础日期 Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
c.setTime(new Date()); c.setTime(new Date());
// 根据提醒开始天数添加到当前日期上 c.add(Calendar.DAY_OF_MONTH,remindEnd);
c.add(Calendar.DAY_OF_MONTH, remindStart); remindEndDate = c.getTime();
// 获取计算后的提醒开始日期 map.put("remindend", sdf.format(remindEndDate));
remindStartDate = c.getTime(); }
// 将提醒开始日期格式化为指定格式并更新到查询条件Map中 }
map.put("remindstart", sdf.format(remindStartDate));
} Wrapper<ChatEntity> wrapper = new EntityWrapper<ChatEntity>();
// 如果查询条件Map中包含remindend结束提醒时间 if(map.get("remindstart")!=null) {
if (map.get("remindend")!= null) { wrapper.ge(columnName, map.get("remindstart"));
// 将remindend转换为整数表示要添加的天数 }
Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); if(map.get("remindend")!=null) {
// 设置当前日期为基础日期 wrapper.le(columnName, map.get("remindend"));
c.setTime(new Date()); }
// 根据提醒结束天数添加到当前日期上
c.add(Calendar.DAY_OF_MONTH, remindEnd);
// 获取计算后的提醒结束日期 int count = chatService.selectCount(wrapper);
remindEndDate = c.getTime(); return R.ok().put("count", count);
// 将提醒结束日期格式化为指定格式并更新到查询条件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);
}
}

@ -28,286 +28,202 @@ 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;
/** /**
* *
* SpringRestController
*
*/ */
@RestController @RestController
public class CommonController { public class CommonController{
@Autowired
// 自动注入CommonService用于处理通用的业务逻辑 private 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;
/**
/** * tablecolumn()
* tablecolumn * @param table
* * @param column
* * @return
* @param tableName */
* @param columnName @RequestMapping("/option/{tableName}/{columnName}")
* @param conditionColumn @IgnoreAuth
* @param conditionValue 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 level Map<String, Object> params = new HashMap<String, Object>();
* @param parent params.put("table", tableName);
* @return RR params.put("column", columnName);
*/ if(StringUtils.isNotBlank(level)) {
@RequestMapping("/option/{tableName}/{columnName}") params.put("level", level);
@IgnoreAuth }
public R getOption(@PathVariable("tableName") String tableName, @PathVariable("tableName") String columnName, if(StringUtils.isNotBlank(parent)) {
@RequestParam(required = false) String conditionColumn, params.put("parent", parent);
@RequestParam(required = false) String conditionValue, String level, String parent) { }
// 创建一个用于存储参数的Map对象 if(StringUtils.isNotBlank(conditionColumn)) {
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);
// 调用commonService的getOption方法获取数据列表 return R.ok().put("data", data);
List<String> data = commonService.getOption(params); }
// 返回包含数据列表的R对象结果状态为成功 /**
return R.ok().put("data", data); * tablecolumn
} * @param table
* @param column
/** * @return
* tablecolumn */
* @RequestMapping("/follow/{tableName}/{columnName}")
* @IgnoreAuth
* @param tableName public R getFollowByOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, @RequestParam String columnValue) {
* @param columnName Map<String, Object> params = new HashMap<String, Object>();
* @param columnValue params.put("table", tableName);
* @return R params.put("column", columnName);
*/ params.put("columnValue", columnValue);
@RequestMapping("/follow/{tableName}/{columnName}") Map<String, Object> result = commonService.getFollowByOption(params);
@IgnoreAuth return R.ok().put("data", result);
public R getFollowByOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, }
@RequestParam String columnValue) {
// 创建一个用于存储参数的Map对象 /**
Map<String, Object> params = new HashMap<String, Object>(); * tablesfsh
params.put("table", tableName); * @param table
params.put("column", columnName); * @param map
params.put("columnValue", columnValue); * @return
*/
// 调用commonService的getFollowByOption方法获取单条记录数据 @RequestMapping("/sh/{tableName}")
Map<String, Object> result = commonService.getFollowByOption(params); public R sh(@PathVariable("tableName") String tableName, @RequestBody Map<String, Object> map) {
map.put("table", tableName);
// 返回包含单条记录数据的R对象结果状态为成功 commonService.sh(map);
return R.ok().put("data", result); return R.ok();
} }
/** /**
* tablesfsh *
* MapcommonServiceshsfsh * @param tableName
* * @param columnName
* @param tableName * @param type 1: 2:
* @param map Map * @param map
* @return R * @return
*/ */
@RequestMapping("/sh/{tableName}") @RequestMapping("/remind/{tableName}/{columnName}/{type}")
public R sh(@PathVariable("tableName") String tableName, @RequestBody Map<String, Object> map) { @IgnoreAuth
map.put("table", tableName); public R remindCount(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,
commonService.sh(map); @PathVariable("type") String type,@RequestParam Map<String, Object> map) {
return R.ok(); map.put("table", tableName);
} map.put("column", columnName);
map.put("type", type);
/**
* if(type.equals("2")) {
* Map SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
* 2 Calendar c = Calendar.getInstance();
* Date remindStartDate = null;
* @param tableName Date remindEndDate = null;
* @param columnName if(map.get("remindstart")!=null) {
* @param type 12 Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
* @param map Maptype2 c.setTime(new Date());
* @return R c.add(Calendar.DAY_OF_MONTH,remindStart);
*/ remindStartDate = c.getTime();
@RequestMapping("/remind/{tableName}/{columnName}/{type}") map.put("remindstart", sdf.format(remindStartDate));
@IgnoreAuth }
public R remindCount(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, if(map.get("remindend")!=null) {
@PathVariable("type") String type, @RequestParam Map<String, Object> map) { Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
map.put("table", tableName); c.setTime(new Date());
map.put("column", columnName); c.add(Calendar.DAY_OF_MONTH,remindEnd);
map.put("type", type); remindEndDate = c.getTime();
map.put("remindend", sdf.format(remindEndDate));
if (type.equals("2")) { }
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); }
Calendar c = Calendar.getInstance();
Date remindStartDate = null; int count = commonService.remindCount(map);
Date remindEndDate = null; return R.ok().put("count", count);
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)); @RequestMapping("/cal/{tableName}/{columnName}")
} @IgnoreAuth
if (map.get("remindend")!= null) { public R cal(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) {
Integer recommendEnd = Integer.parseInt(map.get("remindend").toString()); Map<String, Object> params = new HashMap<String, Object>();
c.setTime(new Date()); params.put("table", tableName);
c.add(Calendar.DAY_OF_MONTH, recommendEnd); params.put("column", columnName);
remindEndDate = c.getTime(); Map<String, Object> result = commonService.selectCal(params);
map.put("remindend", sdf.format(remindEndDate)); return R.ok().put("data", result);
} }
}
/**
// 调用commonService的remindCount方法获取需要提醒的记录数 *
int count = commonService.remindCount(map); */
@RequestMapping("/group/{tableName}/{columnName}")
// 返回包含记录数的R对象结果状态为成功 @IgnoreAuth
return R.ok().put("count", count); 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);
* commonServiceselectCal SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
* for(Map<String, Object> m : result) {
* @param tableName for(String k : m.keySet()) {
* @param columnName if(m.get(k) instanceof Date) {
* @return R m.put(k, sdf.format((Date)m.get(k)));
*/ }
@RequestMapping("/cal/{tableName}/{columnName}") }
@IgnoreAuth }
public R cal(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) { return R.ok().put("data", result);
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); @RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}")
@IgnoreAuth
// 返回包含求和结果的R对象结果状态为成功 public R value(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName) {
return R.ok().put("data", result); 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);
* commonServiceselectGroup SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
* for(Map<String, Object> m : result) {
* for(String k : m.keySet()) {
* @param tableName if(m.get(k) instanceof Date) {
@param columnName m.put(k, sdf.format((Date)m.get(k)));
* @return R }
*/ }
@RequestMapping("/group/{tableName}/{columnName}") }
@IgnoreAuth return R.ok().put("data", result);
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方法进行分组统计操作并获取结果 @IgnoreAuth
List<Map<String, Object>> result = commonService.selectGroup(params); @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) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); Map<String, Object> params = new HashMap<String, Object>();
for (Map<String, Object> m : result) { params.put("table", tableName);
for (String k : m.keySet()) { params.put("xColumn", xColumnName);
if (m.get(k) instanceof Date) { params.put("yColumn", yColumnName);
m.put(k, sdf.format((Date) m.get(k))); 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()) {
// 返回包含分组统计结果的R对象结果状态为成功 if(m.get(k) instanceof Date) {
return R.ok().put("data", result); m.put(k, sdf.format((Date)m.get(k)));
} }
}
/** }
* return R.ok().put("data", result);
* xycommonServiceselectValue }
*
*
* @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);
}
/**
*
* xycommonServiceselectTimeStatValue
*
*
* @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);
}
}

@ -1,28 +1,36 @@
package com.controller; package com.controller;
import java.math.BigDecimal; import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat; import java.text.SimpleDateFormat;
import java.text.ParseException;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.Calendar; import java.util.Calendar;
import java.util.Date; import java.util.Map;
import java.util.HashMap; import java.util.HashMap;
import java.util.Iterator; import java.util.Iterator;
import java.util.Date;
import java.util.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;
@ -32,7 +40,11 @@ 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")
@ -40,57 +52,66 @@ 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, HttpServletRequest request){ public R page(@RequestParam Map<String, Object> params,WenjuandafuEntity wenjuandafu,
String tableName = request.getSession().getAttribute("tableName").toString(); HttpServletRequest request){
if(tableName.equals("yonghu")) {
wenjuandafu.setZhanghao((String)request.getSession().getAttribute("username")); String tableName = request.getSession().getAttribute("tableName").toString();
} 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));
request.setAttribute("data", page); PageUtils page = wenjuandafuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandafu), params), params));
request.setAttribute("data", page);
return R.ok().put("data", page); 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, HttpServletRequest request){ public R list(@RequestParam Map<String, Object> params,WenjuandafuEntity wenjuandafu,
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));
request.setAttribute("data", page); PageUtils page = wenjuandafuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandafu), params), params));
request.setAttribute("data", page);
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* *
* @param wenjuandafu
* @return
*/ */
@RequestMapping("/lists") @RequestMapping("/lists")
public R lists(WenjuandafuEntity wenjuandafu){ public R list( 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){
@ -99,126 +120,112 @@ 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){
wenjuandafuService.deleteBatchIds(Arrays.asList(ids)); wenjuandafuService.deleteBatchIds(Arrays.asList(ids));
return R.ok(); return R.ok();
} }
/** /**
* *
* @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, @PathVariable("type") String type, HttpServletRequest request, @RequestParam Map<String, Object> map) { public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
map.put("column", columnName); @PathVariable("type") String type,@RequestParam Map<String, Object> map) {
map.put("type", type); map.put("column", columnName);
map.put("type", type);
if(type.equals("2")) { // 如果类型是日期范围
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); if(type.equals("2")) {
Calendar c = Calendar.getInstance(); // 获取当前日期实例 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//初始话开始和结束日期 Calendar c = Calendar.getInstance();
Date remindStartDate = null; Date remindStartDate = null;
Date remindEndDate = null; Date remindEndDate = null;
if(map.get("remindstart")!=null) {
if(map.get("remindstart") != null) { // 如果请求参数中包含开始日期 Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); // 获取开始日期天数差值 c.setTime(new Date());
c.setTime(new Date()); // 设置当前日期时间 c.add(Calendar.DAY_OF_MONTH,remindStart);
c.add(Calendar.DAY_OF_MONTH, remindStart); // 根据天数差值计算开始日期 remindStartDate = c.getTime();
remindStartDate = c.getTime(); map.put("remindstart", sdf.format(remindStartDate));
map.put("remindstart", sdf.format(remindStartDate)); // 将开始日期格式化并放入请求参数中 }
} if(map.get("remindend")!=null) {
Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
if(map.get("remindend") != null) { // 如果请求参数中包含结束日期 c.setTime(new Date());
Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); // 获取结束日期天数差值 c.add(Calendar.DAY_OF_MONTH,remindEnd);
c.setTime(new Date()); // 设置当前日期时间 remindEndDate = c.getTime();
c.add(Calendar.DAY_OF_MONTH, remindEnd); map.put("remindend", sdf.format(remindEndDate));
remindEndDate = c.getTime(); // 获取计算后的结束日期 }
map.put("remindend", sdf.format(remindEndDate)); // 将结束日期格式化并放入请求参数中 }
}
} Wrapper<WenjuandafuEntity> wrapper = new EntityWrapper<WenjuandafuEntity>();
if(map.get("remindstart")!=null) {
String tableName = request.getSession().getAttribute("tableName").toString(); // 获取表名 wrapper.ge(columnName, map.get("remindstart"));
if(tableName.equals("yonghu")) { // 如果表名是用户表 }
map.put("zhanghao", (String)request.getSession().getAttribute("username")); // 添加用户名到请求参数中作为过滤条件 if(map.get("remindend")!=null) {
} wrapper.le(columnName, map.get("remindend"));
}
Wrapper<WenjuandafuEntity> wrapper = new EntityWrapper<WenjuandafuEntity>(); // 创建查询包装器实例
String tableName = request.getSession().getAttribute("tableName").toString();
if(map.get("remindstart") != null) { if(tableName.equals("yonghu")) {
wrapper.ge(columnName, map.get("remindstart")); // 添加大于等于开始日期的条件到查询包装器中 wrapper.eq("zhanghao", (String)request.getSession().getAttribute("username"));
} }
if(map.get("remindend") != null) {
wrapper.le(columnName, map.get("remindend")); int count = wenjuandafuService.selectCount(wrapper);
} return R.ok().put("count", count);
}
int count = wenjuandafuService.selectCount(wrapper); // 根据查询包装器统计符合条件的记录数
return R.ok().put("count", count); // 返回符合条件的记录数响应
}
}
@ -228,136 +235,94 @@ 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>();
Map<String, Object> params = new HashMap<String, Object>(); params.put("xColumn", xColumnName);
params.put("xColumn", xColumnName); params.put("yColumn", yColumnName);
params.put("yColumn", yColumnName); EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>();
String tableName = request.getSession().getAttribute("tableName").toString();
// 创建实体包装器,用于构建查询条件 if(tableName.equals("yonghu")) {
EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>(); ew.eq("zhanghao", (String)request.getSession().getAttribute("username"));
}
// 获取当前会话中的表名 List<Map<String, Object>> result = wenjuandafuService.selectValue(params, ew);
String tableName = request.getSession().getAttribute("tableName").toString(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for(Map<String, Object> m : result) {
// 如果表名为"yonghu",则添加用户账号作为查询条件 for(String k : m.keySet()) {
if (tableName.equals("yonghu")) { if(m.get(k) instanceof Date) {
ew.eq("zhanghao", (String) request.getSession().getAttribute("username")); m.put(k, sdf.format((Date)m.get(k)));
} }
// 调用服务层方法进行数据查询
List<Map<String, Object>> result = wenjuandafuService.selectValue(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("/value/{xColumnName}/{yColumnName}/{timeStatType}")
/** public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType,HttpServletRequest request) {
* Map<String, Object> params = new HashMap<String, Object>();
*/ params.put("xColumn", xColumnName);
@RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}") params.put("yColumn", yColumnName);
public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType, HttpServletRequest request) { params.put("timeStatType", timeStatType);
// 创建参数映射,用于存储请求中的列名和时间统计类型 EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>();
Map<String, Object> params = new HashMap<String, Object>(); String tableName = request.getSession().getAttribute("tableName").toString();
params.put("xColumn", xColumnName); if(tableName.equals("yonghu")) {
params.put("yColumn", yColumnName); ew.eq("zhanghao", (String)request.getSession().getAttribute("username"));
params.put("timeStatType", timeStatType); }
List<Map<String, Object>> result = wenjuandafuService.selectTimeStatValue(params, ew);
// 创建实体包装器,用于构建查询条件 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>(); for(Map<String, Object> m : result) {
for(String k : m.keySet()) {
// 获取当前会话中的表名 if(m.get(k) instanceof Date) {
String tableName = request.getSession().getAttribute("tableName").toString(); m.put(k, sdf.format((Date)m.get(k)));
}
// 如果表名为"yonghu",则添加用户账号作为查询条件 }
if (tableName.equals("yonghu")) { }
ew.eq("zhanghao", (String) request.getSession().getAttribute("username")); return R.ok().put("data", result);
} }
// 调用服务层方法进行数据查询 /**
List<Map<String, Object>> result = wenjuandafuService.selectTimeStatValue(params, ew); *
*/
// 格式化日期对象为字符串 @RequestMapping("/group/{columnName}")
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); public R group(@PathVariable("columnName") String columnName,HttpServletRequest request) {
for (Map<String, Object> m : result) { Map<String, Object> params = new HashMap<String, Object>();
for (String k : m.keySet()) { params.put("column", columnName);
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();
if(tableName.equals("yonghu")) {
ew.eq("zhanghao", (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)));
}
} }
} }
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();
// 如果表名为"yonghu",则添加用户账号作为查询条件
if (tableName.equals("yonghu")) {
ew.eq("zhanghao", (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()) { @RequestMapping("/count")
if (m.get(k) instanceof Date) { public R count(@RequestParam Map<String, Object> params,WenjuandafuEntity wenjuandafu, HttpServletRequest request){
m.put(k, sdf.format((Date) m.get(k))); String tableName = request.getSession().getAttribute("tableName").toString();
} 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);
} }
// 返回封装好的响应结果
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);
} }

@ -49,334 +49,275 @@ import com.utils.CommonUtil;
@RestController @RestController
@RequestMapping("/yonghu") @RequestMapping("/yonghu")
public class YonghuController { public class YonghuController {
// 自动注入用户服务类,用于处理与用户相关的业务逻辑
@Autowired @Autowired
private YonghuService yonghuService; private YonghuService yonghuService;
// 自动注入令牌服务类,用于生成和管理用户令牌
@Autowired
private TokenService tokenService;
/**
*
* @param username
* @param password
* @param captcha
* @param request Http
* @return R
*/
@IgnoreAuth
@RequestMapping(value = "/login")
public R login(String username, String password, String captcha, HttpServletRequest request) {
// 根据用户名查询用户实体
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", username));
if (u == null ||!u.getMima().equals(password)) {
// 若用户不存在或密码不匹配,返回错误信息
return R.error("账号或密码不正确");
}
// 生成用户令牌
String token = tokenService.generateToken(u.getId(), username, "yonghu", "用户");
return R.ok().put("token", token);
}
/**
* @Autowired
* @param yonghu YonghuEntity private TokenService tokenService;
* @return R
/**
*
*/
@IgnoreAuth
@RequestMapping(value = "/login")
public R login(String username, String password, String captcha, HttpServletRequest request) {
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", username));
if(u==null || !u.getMima().equals(password)) {
return R.error("账号或密码不正确");
}
String token = tokenService.generateToken(u.getId(), username,"yonghu", "用户" );
return R.ok().put("token", token);
}
/**
*
*/ */
@IgnoreAuth @IgnoreAuth
@RequestMapping("/register") @RequestMapping("/register")
public R register(@RequestBody YonghuEntity yonghu) { public R register(@RequestBody YonghuEntity yonghu){
// 此处原本应有对用户实体的验证逻辑,但被注释掉了 //ValidatorUtils.validateEntity(yonghu);
//ValidatorUtils.validateEntity(yonghu); YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao()));
// 根据用户名查询是否已存在该用户 if(u!=null) {
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao())); return R.error("注册用户已存在");
if (u!= null) { }
// 若用户已存在,返回错误信息 Long uId = new Date().getTime();
return R.error("注册用户已存在"); yonghu.setId(uId);
}
// 设置用户ID为当前时间戳
Long uId = new Date().getTime();
yonghu.setId(uId);
// 插入新用户信息到数据库
yonghuService.insert(yonghu); yonghuService.insert(yonghu);
return R.ok(); return R.ok();
} }
/**
* 退 /**
* @param request Http * 退
* @return 退R */
*/ @RequestMapping("/logout")
@RequestMapping("/logout") public R logout(HttpServletRequest request) {
public R logout(HttpServletRequest request) { request.getSession().invalidate();
// 使当前会话失效,实现用户退出 return R.ok("退出成功");
request.getSession().invalidate(); }
return R.ok("退出成功");
} /**
* session
/**
*
* @param request Http
* @return R
*/ */
@RequestMapping("/session") @RequestMapping("/session")
public R getCurrUser(HttpServletRequest request) { public R getCurrUser(HttpServletRequest request){
// 从会话中获取用户ID Long id = (Long)request.getSession().getAttribute("userId");
Long id = (Long) request.getSession().getAttribute("userId");
// 根据用户ID查询用户实体
YonghuEntity u = yonghuService.selectById(id); YonghuEntity u = yonghuService.selectById(id);
return R.ok().put("data", u); return R.ok().put("data", u);
} }
/** /**
* *
* @param username
* @param request Http
* @return R
*/ */
@IgnoreAuth @IgnoreAuth
@RequestMapping(value = "/resetPass") @RequestMapping(value = "/resetPass")
public R resetPass(String username, HttpServletRequest request) { public R resetPass(String username, HttpServletRequest request){
// 根据用户名查询用户实体 YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", username));
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", username)); if(u==null) {
if (u == null) { return R.error("账号不存在");
// 若用户不存在,返回错误信息 }
return R.error("账号不存在");
}
// 将用户密码重置为"123456"
u.setMima("123456"); u.setMima("123456");
// 更新用户信息到数据库
yonghuService.updateById(u); yonghuService.updateById(u);
return R.ok("密码已重置为123456"); return R.ok("密码已重置为123456");
} }
/** /**
* *
* @param params Map
* @param yonghu YonghuEntity
* @param request Http
* @return R
*/ */
@RequestMapping("/page") @RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, YonghuEntity yonghu, public R page(@RequestParam Map<String, Object> params,YonghuEntity yonghu,
HttpServletRequest request) { HttpServletRequest request){
// 创建用于构建查询条件的EntityWrapper对象
EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>(); EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
// 调用服务类的方法进行分页查询,并进行排序、条件筛选等操作 PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params));
PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params)); request.setAttribute("data", page);
request.setAttribute("data", page);
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* *
* page@IgnoreAuth访
* @param params Map
* @param yonghu YonghuEntity
* @param request Http
* @return R
*/ */
@IgnoreAuth @IgnoreAuth
@RequestMapping("/list") @RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, YonghuEntity yonghu, public R list(@RequestParam Map<String, Object> params,YonghuEntity yonghu,
HttpServletRequest request) { HttpServletRequest request){
EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>(); EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params)); PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params));
request.setAttribute("data", page); request.setAttribute("data", page);
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* *
* @param yonghu YonghuEntity
* @return R
*/ */
@RequestMapping("/lists") @RequestMapping("/lists")
public R list(YonghuEntity yonghu) { public R list( YonghuEntity yonghu){
EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>(); EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
ew.allEq(MPUtil.allEQMapPre(yonghu, "yonghu")); ew.allEq(MPUtil.allEQMapPre( yonghu, "yonghu"));
return R.ok().put("data", yonghuService.selectListView(ew)); return R.ok().put("data", yonghuService.selectListView(ew));
} }
/** /**
* *
* @param yonghu YonghuEntity
* @return R
*/ */
@RequestMapping("/query") @RequestMapping("/query")
public R query(YonghuEntity yonghu) { public R query(YonghuEntity yonghu){
EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>(); EntityWrapper< YonghuEntity> ew = new EntityWrapper< YonghuEntity>();
ew.allEq(MPUtil.allEQMapPre(yonghu, "yonghu")); ew.allEq(MPUtil.allEQMapPre( yonghu, "yonghu"));
YonghuView yonghuView = yonghuService.selectView(ew); YonghuView yonghuView = yonghuService.selectView(ew);
return R.ok("查询用户成功").put("data", yonghuView); return R.ok("查询用户成功").put("data", yonghuView);
} }
/** /**
* *
* @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){
YonghuEntity yonghu = yonghuService.selectById(id); YonghuEntity yonghu = yonghuService.selectById(id);
return R.ok().put("data", yonghu); return R.ok().put("data", yonghu);
} }
/** /**
* *
* info@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){
YonghuEntity yonghu = yonghuService.selectById(id); YonghuEntity yonghu = yonghuService.selectById(id);
return R.ok().put("data", yonghu); return R.ok().put("data", yonghu);
} }
/** /**
* *
* @param yonghu YonghuEntity
* @param request Http
* @return R
*/ */
@RequestMapping("/save") @RequestMapping("/save")
public R save(@RequestBody YonghuEntity yonghu, HttpServletRequest request) { public R save(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
// 设置用户ID为当前时间戳加上一个随机数 yonghu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
yonghu.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); //ValidatorUtils.validateEntity(yonghu);
// 此处原本应有对用户实体的验证逻辑,但被注释掉了 YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao()));
//ValidatorUtils.validateEntity(yonghu); if(u!=null) {
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao())); return R.error("用户已存在");
if (u!= null) { }
// 若用户已存在,返回错误信息
return R.error("用户已存在"); yonghu.setId(new Date().getTime());
}
yonghu.setId(new Date().getTime());
yonghuService.insert(yonghu); yonghuService.insert(yonghu);
return R.ok(); return R.ok();
} }
/** /**
* *
* save
* @param yonghu YonghuEntity
* @param request Http
* @return R
*/ */
@RequestMapping("/add") @RequestMapping("/add")
public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request) { public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
yonghu.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); yonghu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
// 此处原本应有对用户实体的验证逻辑,但被注释掉了 //ValidatorUtils.validateEntity(yonghu);
//ValidatorUtils.validateEntity(yonghu); YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao()));
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao())); if(u!=null) {
if (u!= null) { return R.error("用户已存在");
// 若用户已存在,返回错误信息 }
return R.error("用户已存在");
} yonghu.setId(new Date().getTime());
yonghu.setId(new Date().getTime());
yonghuService.insert(yonghu); yonghuService.insert(yonghu);
return R.ok(); return R.ok();
} }
/** /**
* *
* @param yonghu YonghuEntity
* @param request Http
* @return R
*/ */
@RequestMapping("/update") @RequestMapping("/update")
@Transactional @Transactional
public R update(@RequestBody YonghuEntity yonghu, HttpServletRequest request) { public R update(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
// 此处原本应有对用户实体的验证逻辑,但被注释掉了
//ValidatorUtils.validateEntity(yonghu); //ValidatorUtils.validateEntity(yonghu);
yonghuService.updateById(yonghu); // 全部更新 yonghuService.updateById(yonghu);//全部更新
return R.ok(); return R.ok();
} }
/** /**
* *
* @param ids ID
* @return R
*/ */
@RequestMapping("/delete") @RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) { public R delete(@RequestBody Long[] ids){
yonghuService.deleteBatchIds(Arrays.asList(ids)); yonghuService.deleteBatchIds(Arrays.asList(ids));
return R.ok(); return R.ok();
} }
/** /**
* *
* @param columnName
* @param request Http
* @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.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) { if(map.get("remindstart")!=null) {
Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
c.setTime(new Date()); c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH, remindStart); c.add(Calendar.DAY_OF_MONTH,remindStart);
remindStartDate = c.getTime(); remindStartDate = c.getTime();
map.put("remindstart", sdf.format(remindStartDate)); map.put("remindstart", sdf.format(remindStartDate));
} }
if (map.get("remindend")!= null) { if(map.get("remindend")!=null) {
Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
c.setTime(new Date()); c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH, remindEnd); c.add(Calendar.DAY_OF_MONTH,remindEnd);
remindEndDate = c.getTime(); remindEndDate = c.getTime();
map.put("remindend", sdf.format(remindEndDate)); map.put("remindend", sdf.format(remindEndDate));
} }
} }
Wrapper<YonghuEntity> wrapper = new EntityWrapper<YonghuEntity>();
if(map.get("remindstart")!=null) {
wrapper.ge(columnName, map.get("remindstart"));
}
if(map.get("remindend")!=null) {
wrapper.le(columnName, map.get("remindend"));
}
int count = yonghuService.selectCount(wrapper);
return R.ok().put("count", count);
}
Wrapper<YonghuEntity> wrapper = new EntityWrapper<YonghuEntity>();
if (map.get("remindstart")!= null) {
wrapper.ge(columnName, map.get("remindstart"));
}
if (map.get("remindend")!= null) {
wrapper.le(columnName, map.get("remindend"));
}
int count = yonghuService.selectCount(wrapper);
return R.ok().put("count", count);
}
/** /**
* *
* @param yColumnName
* @param xColumnName
* @param request Http
* @return R
*/ */
@RequestMapping("/value/{xColumnName}/{yColumnName}") @RequestMapping("/value/{xColumnName}/{yColumnName}")
public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, HttpServletRequest request) { public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName,HttpServletRequest request) {
Map<String, Object> params = new HashMap<String, Object>(); Map<String, Object> params = new HashMap<String, Object>();
params.put("xColumn", xColumnName); params.put("xColumn", xColumnName);
params.put("yColumn", yColumnName); params.put("yColumn", yColumnName);
EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>(); EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
List<Map<String, Object>> result = yonghuService.selectValue(params, ew); List<Map<String, Object>> result = yonghuService.selectValue(params, ew);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (Map<String, Object> m : result) { for(Map<String, Object> m : result) {
for (String k : m.keySet()) { for(String k : m.keySet()) {
if (m.get(k) instanceof Date) { if(m.get(k) instanceof Date) {
m.put(k, sdf.format((Date) m.get(k))); m.put(k, sdf.format((Date)m.get(k)));
} }
} }
} }
@ -384,18 +325,59 @@ public class YonghuController {
} }
/** /**
* *
* @param yColumnName
* @param xColumnName
* @param timeStatType
* @param request Http
* @return R
*/ */
@RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}") @RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}")
public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType, HttpServletRequest request) { public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType,HttpServletRequest request) {
Map<String, Object> params = new HashMap<String, Object>(); Map<String, Object> params = new HashMap<String, Object>();
params.put("xColumn", xColumnName); params.put("xColumn", xColumnName);
params.put("yColumn", yColumnName); params.put("yColumn", yColumnName);
params.put("timeStatType", timeStatType); params.put("timeStatType", timeStatType);
EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>(); EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
List<Map<String, Object>> result List<Map<String, Object>> result = yonghuService.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);
}
/**
*
*/
@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<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
List<Map<String, Object>> result = yonghuService.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)));
}
}
}
return R.ok().put("data", result);
}
/**
*
*/
@RequestMapping("/count")
public R count(@RequestParam Map<String, Object> params,YonghuEntity yonghu, HttpServletRequest request){
EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
int count = yonghuService.selectCount(MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params));
return R.ok().put("data", count);
}
}

@ -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);//根据给定的条件包装器Wrapper查询并返回符合条件的ChatVO列表 List<ChatVO> selectListVO(@Param("ew") Wrapper<ChatEntity> wrapper);
ChatVO selectVO(@Param("ew") Wrapper<ChatEntity> wrapper);//根据给定的条件包装器Wrapper查询并返回符合条件的ChatView列表 ChatVO selectVO(@Param("ew") Wrapper<ChatEntity> wrapper);
List<ChatView> selectListView(@Param("ew") Wrapper<ChatEntity> wrapper); List<ChatView> selectListView(@Param("ew") Wrapper<ChatEntity> wrapper);

@ -5,69 +5,24 @@ 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> getFollowByOption2(Map<String, Object> params);
*/
List<String> getOption(Map<String, Object> params); void sh(Map<String, Object> params);
/** int remindCount(Map<String, Object> params);
*
* @param params Map<String, Object> selectCal(Map<String, Object> params);
* @return
*/ List<Map<String, Object>> selectGroup(Map<String, Object> params);
Map<String, Object> getFollowByOption(Map<String, Object> params);
List<Map<String, Object>> selectValue(Map<String, Object> params);
/**
* List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params);
* @param params
* @return
*/
List<String> getFollowByOption2(Map<String, Object> params);
/**
*
* @param params
*/
void sh(Map<String, Object> params);
/**
*
* @param params
* @return
*/
int remindCount(Map<String, Object> params);
/**
*
* @param params
* @return
*/
Map<String, Object> selectCal(Map<String, Object> params);
/**
*
* @param params
* @return
*/
List<Map<String, Object>> selectGroup(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);
} }

@ -1,4 +1,4 @@
ppackage com.dao; package com.dao;
import com.entity.WenjuandafuEntity; import com.entity.WenjuandafuEntity;
import com.baomidou.mybatisplus.mapper.BaseMapper; import com.baomidou.mybatisplus.mapper.BaseMapper;
@ -11,70 +11,33 @@ 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;
/** /**
* 访 *
* *
* 使MyBatis-Plus * @author
* @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
* @param wrapper WenjuandafuVO selectVO(@Param("ew") Wrapper<WenjuandafuEntity> 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);
/**
* VO WenjuandafuView selectView(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
* @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);
} }

@ -6,37 +6,38 @@ 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-PlusBaseMapper *
* 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);
// 根据条件查询单个用户视图对象
YonghuVO selectVO(@Param("ew") Wrapper<YonghuEntity> wrapper); List<YonghuView> selectListView(@Param("ew") Wrapper<YonghuEntity> wrapper);
// 根据条件查询用户视图对象列表
List<YonghuView> selectListView(@Param("ew") Wrapper<YonghuEntity> wrapper);
// 根据分页信息和条件查询用户视图对象列表 List<YonghuView> selectListView(Pagination page,@Param("ew") Wrapper<YonghuEntity> wrapper);
List<YonghuView> selectListView(Pagination page, @Param("ew") Wrapper<YonghuEntity> wrapper);
YonghuView selectView(@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>> 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>> 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);
List<Map<String, Object>> selectGroup(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<YonghuEntity> wrapper);
} }

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

@ -12,7 +12,8 @@ import java.io.Serializable;
/** /**
* *
* *
* ModelAndView model * entity
* ModelAndView model
* @author * @author
* @email * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06

@ -1,35 +1,36 @@
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(){
* WenjuandafuEntity WenjuandafuView }
* @param wenjuandafuEntity WenjuandafuEntity
*/ public WenjuandafuView(WenjuandafuEntity wenjuandafuEntity){
public WenjuandafuView(WenjuandafuEntity wenjuandafuEntity) { try {
try { BeanUtils.copyProperties(this, wenjuandafuEntity);
// 使用 BeanUtils 工具类将 wenjuandafuEntity 的属性值复制到当前对象中 } catch (IllegalAccessException | InvocationTargetException e) {
BeanUtils.copyProperties(this, wenjuandafuEntity); // TODO Auto-generated catch block
} catch (IllegalAccessException | InvocationTargetException e) { e.printStackTrace();
// 捕获并打印异常信息 }
e.printStackTrace();
} }
}
} }

@ -10,62 +10,28 @@ 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
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
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<ChatView> selectListView(Wrapper<ChatEntity> wrapper);
*/
List<ChatVO> selectListVO(Wrapper<ChatEntity> wrapper); ChatView selectView(@Param("ew") Wrapper<ChatEntity> wrapper);
/** PageUtils queryPage(Map<String, Object> params,Wrapper<ChatEntity> wrapper);
*
*
* @param wrapper
* @return
*/
ChatVO selectVO(@Param("ew") 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);
} }

@ -3,63 +3,20 @@ 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 void sh(Map<String, Object> params);
*/
List<String> getOption(Map<String, Object> params); int remindCount(Map<String, Object> params);
/** Map<String, Object> selectCal(Map<String, Object> params);
*
* @param params List<Map<String, Object>> selectGroup(Map<String, Object> params);
* @return
*/ List<Map<String, Object>> selectValue(Map<String, Object> params);
Map<String, Object> getFollowByOption(Map<String, Object> params);
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params);
/**
*
* @param params
*/
void sh(Map<String, Object> params);
/**
*
* @param params
* @return
*/
int remindCount(Map<String, Object> params);
/**
*
* @param params
* @return
*/
Map<String, Object> selectCal(Map<String, Object> params);
/**
*
* @param params
* @return
*/
List<Map<String, Object>> selectGroup(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);
} }

@ -10,81 +10,36 @@ import com.entity.vo.WenjuandafuVO;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import com.entity.view.WenjuandafuView; import com.entity.view.WenjuandafuView;
/** /**
* *
* *
* IService<WenjuandafuEntity>使 MyBatis-Plus CRUD
*
* @author * @author
* @email * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
public interface WenjuandafuService extends IService<WenjuandafuEntity> { public interface WenjuandafuService extends IService<WenjuandafuEntity> {
/**
*
* @param params
* @return PageUtils
*/
PageUtils queryPage(Map<String, Object> params); PageUtils queryPage(Map<String, Object> params);
/** List<WenjuandafuVO> selectListVO(Wrapper<WenjuandafuEntity> wrapper);
*
* @param wrapper WenjuandafuVO selectVO(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
* @return
*/ List<WenjuandafuView> selectListView(Wrapper<WenjuandafuEntity> wrapper);
List<WenjuandafuVO> selectListVO(Wrapper<WenjuandafuEntity> wrapper);
WenjuandafuView selectView(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
/**
* PageUtils queryPage(Map<String, Object> params,Wrapper<WenjuandafuEntity> wrapper);
* @param wrapper
* @return
*/ List<Map<String, Object>> selectValue(Map<String, Object> params,Wrapper<WenjuandafuEntity> wrapper);
WenjuandafuVO selectVO(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params,Wrapper<WenjuandafuEntity> wrapper);
/**
*
* @param wrapper
* @return
*/
List<WenjuandafuView> selectListView(Wrapper<WenjuandafuEntity> wrapper);
/**
*
* @param wrapper
* @return
*/
WenjuandafuView selectView(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
/**
*
* @param params
* @param wrapper
* @return PageUtils
*/
PageUtils queryPage(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper);
/**
*
* @param params
* @param wrapper
* @return
*/
List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper);
/**
*
* @param params
* @param wrapper
* @return
*/
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper);
/** List<Map<String, Object>> selectGroup(Map<String, Object> params,Wrapper<WenjuandafuEntity> wrapper);
*
* @param params
* @param wrapper
* @return
*/
List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper);
} }

@ -10,90 +10,36 @@ 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
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
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
* @return List<YonghuView> selectListView(Wrapper<YonghuEntity> wrapper);
*/
List<YonghuVO> selectListVO(Wrapper<YonghuEntity> wrapper); YonghuView selectView(@Param("ew") Wrapper<YonghuEntity> wrapper);
/** PageUtils queryPage(Map<String, Object> params,Wrapper<YonghuEntity> wrapper);
*
*
* @param wrapper List<Map<String, Object>> selectValue(Map<String, Object> params,Wrapper<YonghuEntity> wrapper);
* @return
*/ List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params,Wrapper<YonghuEntity> wrapper);
YonghuVO selectVO(@Param("ew") 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);
/** List<Map<String, Object>> selectGroup(Map<String, Object> params,Wrapper<YonghuEntity> wrapper);
*
*
* @param params
* @param wrapper
* @return
*/
List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<YonghuEntity> wrapper);
} }

@ -11,6 +11,7 @@ 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;
@ -20,81 +21,43 @@ 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
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对象中并返回
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
/**
* ChatVO
* @param wrapper
* @return ChatVO
*/
@Override
public List<ChatVO> selectListVO(Wrapper<ChatEntity> wrapper) {
// 调用自定义的selectListVO方法进行数据库查询并返回结果
return baseMapper.selectListVO(wrapper);
}
/**
* ChatVO
* @param wrapper
* @return ChatVO
*/
@Override @Override
public ChatVO selectVO(Wrapper<ChatEntity> wrapper) { public PageUtils queryPage(Map<String, Object> params, Wrapper<ChatEntity> wrapper) {
// 调用自定义的selectVO方法进行数据库查询并返回结果 Page<ChatView> page =new Query<ChatView>(params).getPage();
return baseMapper.selectVO(wrapper); page.setRecords(baseMapper.selectListView(page,wrapper));
} PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
/**
* @param wrapper
* @return ChatView
*/
// 调用自定义的selectListView方法进行数据库查询并返回结果
@Override @Override
public List<ChatView> selectListView(Wrapper<ChatEntity> wrapper) { public List<ChatVO> selectListVO(Wrapper<ChatEntity> wrapper) {
return baseMapper.selectListVO(wrapper);
return baseMapper.selectListView(wrapper); }
}
@Override
public ChatVO selectVO(Wrapper<ChatEntity> wrapper) {
return baseMapper.selectVO(wrapper);
}
@Override
public List<ChatView> selectListView(Wrapper<ChatEntity> wrapper) {
return baseMapper.selectListView(wrapper);
}
@Override
public ChatView selectView(Wrapper<ChatEntity> wrapper) {
return baseMapper.selectView(wrapper);
}
/**
* ChatView
* @param wrapper
* @return ChatView
*/
@Override
public ChatView selectView(Wrapper<ChatEntity> wrapper) {
// 调用自定义的selectView方法进行数据库查询并返回结果
return baseMapper.selectView(wrapper);
}
} }

@ -1,5 +1,7 @@
package com.service.impl; package com.service.impl;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@ -9,53 +11,54 @@ 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);
} }
} }

@ -11,6 +11,7 @@ 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;
@ -20,11 +21,7 @@ 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(
@ -34,90 +31,50 @@ public class WenjuandafuServiceImpl extends ServiceImpl<WenjuandafuDao, Wenjuand
return new PageUtils(page); return new PageUtils(page);
} }
/**
*
* @param params
* @param wrapper
* @return PageUtils
*/
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper) {
Page<WenjuandafuView> page = new Query<WenjuandafuView>(params).getPage();
page.setRecords(baseMapper.selectListView(page, wrapper));
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
/**
*
* @param wrapper
* @return
*/
@Override
public List<WenjuandafuVO> selectListVO(Wrapper<WenjuandafuEntity> wrapper) {
return baseMapper.selectListVO(wrapper);
}
/**
*
* @param wrapper
* @return
*/
@Override @Override
public WenjuandafuVO selectVO(Wrapper<WenjuandafuEntity> wrapper) { public PageUtils queryPage(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper) {
return baseMapper.selectVO(wrapper); Page<WenjuandafuView> page =new Query<WenjuandafuView>(params).getPage();
} page.setRecords(baseMapper.selectListView(page,wrapper));
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
/**
*
* @param wrapper
* @return
*/
@Override @Override
public List<WenjuandafuView> selectListView(Wrapper<WenjuandafuEntity> wrapper) { public List<WenjuandafuVO> selectListVO(Wrapper<WenjuandafuEntity> wrapper) {
return baseMapper.selectListView(wrapper); return baseMapper.selectListVO(wrapper);
} }
@Override
public WenjuandafuVO selectVO(Wrapper<WenjuandafuEntity> wrapper) {
return baseMapper.selectVO(wrapper);
}
@Override
public List<WenjuandafuView> selectListView(Wrapper<WenjuandafuEntity> wrapper) {
return baseMapper.selectListView(wrapper);
}
/** @Override
* public WenjuandafuView selectView(Wrapper<WenjuandafuEntity> wrapper) {
* @param wrapper return baseMapper.selectView(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);
} }
}
}

@ -11,6 +11,7 @@ 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;
@ -20,7 +21,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(
@ -30,54 +31,50 @@ public class YonghuServiceImpl extends ServiceImpl<YonghuDao, YonghuEntity> impl
return new PageUtils(page); return new PageUtils(page);
} }
// 分页查询用户视图信息
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<YonghuEntity> wrapper) {
Page<YonghuView> page = new Query<YonghuView>(params).getPage();
page.setRecords(baseMapper.selectListView(page, wrapper));
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
// 查询用户值对象列表
@Override
public List<YonghuVO> selectListVO(Wrapper<YonghuEntity> wrapper) {
return baseMapper.selectListVO(wrapper);
}
// 查询单个用户值对象
@Override @Override
public YonghuVO selectVO(Wrapper<YonghuEntity> wrapper) { public PageUtils queryPage(Map<String, Object> params, Wrapper<YonghuEntity> wrapper) {
return baseMapper.selectVO(wrapper); Page<YonghuView> page =new Query<YonghuView>(params).getPage();
} page.setRecords(baseMapper.selectListView(page,wrapper));
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
// 查询用户视图列表
@Override @Override
public List<YonghuView> selectListView(Wrapper<YonghuEntity> wrapper) { public List<YonghuVO> selectListVO(Wrapper<YonghuEntity> wrapper) {
return baseMapper.selectListView(wrapper); return baseMapper.selectListVO(wrapper);
} }
@Override
public YonghuVO selectVO(Wrapper<YonghuEntity> wrapper) {
return baseMapper.selectVO(wrapper);
}
@Override
public List<YonghuView> selectListView(Wrapper<YonghuEntity> wrapper) {
return baseMapper.selectListView(wrapper);
}
// 查询单个用户视图 @Override
@Override public YonghuView selectView(Wrapper<YonghuEntity> wrapper) {
public YonghuView selectView(Wrapper<YonghuEntity> wrapper) { return baseMapper.selectView(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);
} }
} }

@ -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();

@ -7,27 +7,21 @@ import java.io.IOException;
import java.io.InputStream; import java.io.InputStream;
/** /**
* : FileUtil * :
*/ */
public class FileUtil { public class FileUtil {
/** public static byte[] FileToByte(File file) throws IOException {
* // 将数据转为流
* @param file @SuppressWarnings("resource")
* @return InputStream content = new FileInputStream(file);
* @throws IOException ByteArrayOutputStream swapStream = new ByteArrayOutputStream();
*/ byte[] buff = new byte[100];
public static byte[] FileToByte(File file) throws IOException { int rc = 0;
// 使用 try-with-resources 语句确保 InputStream 被正确关闭 while ((rc = content.read(buff, 0, 100)) > 0) {
try (InputStream content = new FileInputStream(file)) { swapStream.write(buff, 0, rc);
ByteArrayOutputStream swapStream = new ByteArrayOutputStream(); }
byte[] buff = new byte[100]; // 缓冲区大小为100字节 // 获得二进制数组
int rc; // 读取的字节数 return swapStream.toByteArray();
while ((rc = content.read(buff, 0, 100)) > 0) { }
swapStream.write(buff, 0, rc); // 将读取的数据写入 ByteArrayOutputStream
}
// 获得二进制数组
return swapStream.toByteArray();
}
}
} }

@ -5,45 +5,38 @@ 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 {
/** /**
* GET * @param uri
* @param uri URL * @return String
* @return * @description get
* @description 使GETHTTP
* @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;
} }
} }
} }

@ -1,68 +1,54 @@
package com.utils; package com.utils;
public class JQPageInfo { public class JQPageInfo{
// 当前页码 private Integer page;
private Integer page;
private Integer limit;
// 每页显示的记录数
private Integer limit; private String sidx;
// 排序字段 private String order;
private String sidx;
private Integer offset;
// 排序方式(升序或降序)
private String order; public Integer getPage() {
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) {
this.page = page; public void setLimit(Integer limit) {
} this.limit = limit;
}
// 获取每页显示的记录数
public Integer getLimit() { public String getSidx() {
return limit; return sidx;
} }
// 设置每页显示的记录数 public void setSidx(String sidx) {
public void setLimit(Integer limit) { this.sidx = sidx;
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) {
this.sidx = sidx; public Integer getOffset() {
} return offset;
}
// 获取排序方式
public String getOrder() { public void setOffset(Integer offset) {
return order; this.offset = offset;
} }
// 设置排序方式
public void setOrder(String order) {
this.order = order;
}
// 获取偏移量
public Integer getOffset() {
return offset;
}
// 设置偏移量
public void setOffset(Integer offset) {
this.offset = offset;
}
} }

@ -15,167 +15,170 @@ 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 表达式转换,带前缀
public static Map allEQMapPre(Object bean, String pre) { //mybatis plus allEQ 表达式转换
Map<String, Object> map = BeanUtil.beanToMap(bean); public static Map allEQMapPre(Object bean,String pre) {
return camelToUnderlineMap(map, pre); Map<String, Object> map =BeanUtil.beanToMap(bean);
} return camelToUnderlineMap(map,pre);
}
// mybatis plus allEQ 表达式转换,不带前缀
public static Map allEQMap(Object bean) { //mybatis plus allEQ 表达式转换
Map<String, Object> map = BeanUtil.beanToMap(bean); public static Map allEQMap(Object bean) {
return camelToUnderlineMap(map, ""); Map<String, Object> map =BeanUtil.beanToMap(bean);
} 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;
} }
// 生成LIKE或EQ查询条件 public static Wrapper likeOrEq(Wrapper wrapper,Object bean) {
public static Wrapper likeOrEq(Wrapper wrapper, Object bean) { Map result = BeanUtil.beanToMap(bean, true, true);
Map result = BeanUtil.beanToMap(bean, true, true); return genLikeOrEq(wrapper,result);
return genLikeOrEq(wrapper, result); }
}
public static Wrapper genLikeOrEq( Wrapper wrapper,Map param) {
// 生成LIKE或EQ查询条件的具体实现 Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
public static Wrapper genLikeOrEq(Wrapper wrapper, Map param) { int i=0;
Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator(); while (it.hasNext()) {
int i = 0; if(i>0) wrapper.and();
while (it.hasNext()) { Map.Entry<String, Object> entry = it.next();
if (i > 0) wrapper.and(); String key = entry.getKey();
Map.Entry<String, Object> entry = it.next(); if(entry.getValue().toString().contains("%")) {
String key = entry.getKey(); wrapper.like(key, entry.getValue().toString().replace("%", ""));
if (entry.getValue().toString().contains("%")) { } else {
wrapper.like(key, entry.getValue().toString().replace("%", "")); wrapper.eq(key, entry.getValue());
} else { }
wrapper.eq(key, entry.getValue()); i++;
} }
i++; return wrapper;
} }
return wrapper;
} public static Wrapper allEq(Wrapper wrapper,Object bean) {
Map result = BeanUtil.beanToMap(bean, true, true);
// 生成EQ查询条件 return genEq(wrapper,result);
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();
// 生成EQ查询条件的具体实现 int i=0;
public static Wrapper genEq(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(); wrapper.eq(key, entry.getValue());
Map.Entry<String, Object> entry = it.next(); i++;
String key = entry.getKey(); }
wrapper.eq(key, entry.getValue()); return wrapper;
i++; }
}
return wrapper;
} public static Wrapper between(Wrapper wrapper,Map<String, Object> params) {
for(String key : params.keySet()) {
// 生成BETWEEN查询条件 String columnName = "";
public static Wrapper between(Wrapper wrapper, Map<String, Object> params) { if(key.endsWith("_start")) {
for (String key : params.keySet()) { columnName = key.substring(0, key.indexOf("_start"));
String columnName = ""; if(StringUtils.isNotBlank(params.get(key).toString())) {
if (key.endsWith("_start")) { wrapper.ge(columnName, params.get(key));
columnName = key.substring(0, key.indexOf("_start")); }
if (StringUtils.isNotBlank(params.get(key).toString())) { }
wrapper.ge(columnName, params.get(key)); if(key.endsWith("_end")) {
} columnName = key.substring(0, key.indexOf("_end"));
} if(StringUtils.isNotBlank(params.get(key).toString())) {
if (key.endsWith("_end")) { wrapper.le(columnName, params.get(key));
columnName = key.substring(0, key.indexOf("_end")); }
if (StringUtils.isNotBlank(params.get(key).toString())) { }
wrapper.le(columnName, params.get(key)); }
} return wrapper;
} }
}
return wrapper; public static Wrapper sort(Wrapper wrapper,Map<String, Object> params) {
} 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) { }
String order = ""; if(params.get("sort") != null && StringUtils.isNotBlank(params.get("sort").toString())) {
if (params.get("order") != null && StringUtils.isNotBlank(params.get("order").toString())) { if(order.equalsIgnoreCase("desc")) {
order = params.get("order").toString(); wrapper.orderDesc(Arrays.asList(params.get("sort")));
} } else {
if (params.get("sort") != null && StringUtils.isNotBlank(params.get("sort").toString())) { wrapper.orderAsc(Arrays.asList(params.get("sort")));
if (order.equalsIgnoreCase("desc")) { }
wrapper.orderDesc(Arrays.asList(params.get("sort"))); }
} else { return wrapper;
wrapper.orderAsc(Arrays.asList(params.get("sort"))); }
}
}
return wrapper; /**
} * 线
*
// 驼峰格式字符串转换为下划线格式字符串 * @param param
public static String camelToUnderline(String param) { * @return
if (param == null || "".equals(param.trim())) { */
return ""; public static String camelToUnderline(String param) {
} if (param == null || "".equals(param.trim())) {
int len = param.length(); return "";
StringBuilder sb = new StringBuilder(len); }
for (int i = 0; i < len; i++) { int len = param.length();
char c = param.charAt(i); StringBuilder sb = new StringBuilder(len);
if (Character.isUpperCase(c)) { for (int i = 0; i < len; i++) {
sb.append(UNDERLINE); char c = param.charAt(i);
sb.append(Character.toLowerCase(c)); if (Character.isUpperCase(c)) {
} else { sb.append(UNDERLINE);
sb.append(c); sb.append(Character.toLowerCase(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) {
Map<String, Object> newMap = new HashMap<>(); public static Map camelToUnderlineMap(Map param, String pre) {
Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
while (it.hasNext()) { Map<String, Object> newMap = new HashMap<String, Object>();
Map.Entry<String, Object> entry = it.next(); Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
String key = entry.getKey(); while (it.hasNext()) {
String newKey = camelToUnderline(key); Map.Entry<String, Object> entry = it.next();
if (pre.endsWith(".")) { String key = entry.getKey();
newMap.put(pre + newKey, entry.getValue()); String newKey = camelToUnderline(key);
} else if (StringUtils.isEmpty(pre)) { if (pre.endsWith(".")) {
newMap.put(newKey, entry.getValue()); newMap.put(pre + newKey, entry.getValue());
} else { } else if (StringUtils.isEmpty(pre)) {
newMap.put(pre + "." + newKey, entry.getValue()); newMap.put(newKey, entry.getValue());
} } else {
}
return newMap; newMap.put(pre + "." + newKey, entry.getValue());
} }
}
return newMap;
}
} }

@ -1,3 +1,4 @@
package com.utils; package com.utils;
import java.io.Serializable; import java.io.Serializable;
@ -7,23 +8,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
@ -34,31 +35,29 @@ 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 PlusPage *
* @param page MyBatis PlusPage
*/ */
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 page =new Query(params).getPage();
new PageUtils(page); // 调用另一个构造函数进行初始化 new PageUtils(page);
} }
// Getter和Setter方法
public int getPageSize() { public int getPageSize() {
return pageSize; return pageSize;
} }
@ -98,4 +97,5 @@ public class PageUtils implements Serializable {
public void setTotal(long total) { public void setTotal(long total) {
this.total = total; this.total = total;
} }
} }

@ -1,3 +1,4 @@
package com.utils; package com.utils;
import java.util.LinkedHashMap; import java.util.LinkedHashMap;
@ -8,103 +9,89 @@ 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;
/** /**
* 使JQPageInfo *
* @param pageInfo JQPageInfo
*/ */
private int limit = 10;
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));
} }
} }
/**
* 使Map public Query(Map<String, Object> params){
* @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;
} }

@ -4,27 +4,23 @@ 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为500msg为"未知异常,请联系管理员"
public static R error() { public static R error() {
return error(500, "未知异常,请联系管理员"); return error(500, "未知异常,请联系管理员");
} }
// 静态方法返回一个错误响应code为500msg为传入的参数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);
@ -32,26 +28,22 @@ 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;

@ -6,67 +6,38 @@ 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 SpringBean * Spring Context
*/ */
@Component @Component
public class SpringContextUtils implements ApplicationContextAware { public class SpringContextUtils implements ApplicationContextAware {
// 静态变量保存Spring应用上下文 public static ApplicationContext applicationContext;
public static ApplicationContext applicationContext;
@Override
/** public void setApplicationContext(ApplicationContext applicationContext)
* ApplicationContextAwareSpring throws BeansException {
* @param applicationContext Spring SpringContextUtils.applicationContext = applicationContext;
* @throws BeansException }
*/
@Override public static Object getBean(String name) {
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { return applicationContext.getBean(name);
SpringContextUtils.applicationContext = applicationContext; }
}
public static <T> T getBean(String name, Class<T> requiredType) {
/** return applicationContext.getBean(name, requiredType);
* BeanBean }
* @param name Bean
* @return Bean public static boolean containsBean(String name) {
*/ return applicationContext.containsBean(name);
public static Object getBean(String name) { }
return applicationContext.getBean(name);
} public static boolean isSingleton(String name) {
return applicationContext.isSingleton(name);
/** }
* BeanBean
* @param name Bean public static Class<? extends Object> getType(String name) {
* @param requiredType Bean return applicationContext.getType(name);
* @return Bean }
*/
public static <T> T getBean(String name, Class<T> requiredType) { }
return applicationContext.getBean(name, requiredType);
}
/**
* SpringBean
* @param name Bean
* @return truefalse
*/
public static boolean containsBean(String name) {
return applicationContext.containsBean(name);
}
/**
* Bean
* @param name Bean
* @return truefalse
*/
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);
}
}

@ -1,19 +1,21 @@
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();
} }
@ -24,15 +26,14 @@ public class ValidatorUtils {
* @param groups * @param groups
* @throws EIException EIException * @throws EIException EIException
*/ */
public static void validateEntity(Object object, Class<?>... groups) throws EIException { public static void validateEntity(Object object, Class<?>... groups)
// 执行校验操作,返回违反约束的集合 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());
} }
} }
} }

Loading…
Cancel
Save