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

注释代码

Browse Source
wujiamei_branch
wjm 8 months ago
parent 2d3fe8c5d3
commit d9fc767866
4 changed files with 285 additions and 353 deletions
Show Stats Download Patch File Download Diff File

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

@ -1,6 +1,7 @@
package com.controller; package com.controller;
import java.util.Arrays; import java.util.Arrays;
import java.util.Map; import java.util.Map;
@ -22,90 +23,90 @@ import com.utils.R;
import com.utils.ValidatorUtils; import com.utils.ValidatorUtils;
/** /**
* 配置管理控制器，处理与配置相关的请求 * 登录相关
*/ */
@RequestMapping("config") @RequestMapping("config")
@RestController @RestController
public class ConfigController { public class ConfigController{
@Autowired @Autowired
private ConfigService configService; // 自动注入配置服务 private ConfigService configService;
/** /**
* 分页查询配置列表 * 列表
*/ */
@RequestMapping("/page") @RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, ConfigEntity config) { public R page(@RequestParam Map<String, Object> params,ConfigEntity config){
EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>(); EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>();
PageUtils page = configService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, config), params), params)); PageUtils page = configService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, config), params), params));
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* 获取配置列表（忽略认证） * 列表
*/ */
@IgnoreAuth @IgnoreAuth
@RequestMapping("/list") @RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, ConfigEntity config) { public R list(@RequestParam Map<String, Object> params,ConfigEntity config){
EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>(); EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>();
PageUtils page = configService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, config), params), params)); PageUtils page = configService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, config), params), params));
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* 根据ID获取配置信息 * 信息
*/ */
@RequestMapping("/info/{id}") @RequestMapping("/info/{id}")
public R info(@PathVariable("id") String id) { public R info(@PathVariable("id") String id){
ConfigEntity config = configService.selectById(id); ConfigEntity config = configService.selectById(id);
return R.ok().put("data", config); return R.ok().put("data", config);
} }
/** /**
* 根据ID获取配置详情（忽略认证） * 详情
*/ */
@IgnoreAuth @IgnoreAuth
@RequestMapping("/detail/{id}") @RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") String id) { public R detail(@PathVariable("id") String id){
ConfigEntity config = configService.selectById(id); ConfigEntity config = configService.selectById(id);
return R.ok().put("data", config); return R.ok().put("data", config);
} }
/** /**
* 根据名称获取配置信息 * 根据name获取信息
*/ */
@RequestMapping("/info") @RequestMapping("/info")
public R infoByName(@RequestParam String name) { public R infoByName(@RequestParam String name){
ConfigEntity config = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile")); ConfigEntity config = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile"));
return R.ok().put("data", config); return R.ok().put("data", config);
} }
/** /**
* 保存配置信息 * 保存
*/ */
@PostMapping("/save") @PostMapping("/save")
public R save(@RequestBody ConfigEntity config) { public R save(@RequestBody ConfigEntity config){
// ValidatorUtils.validateEntity(config); // 验证实体 // ValidatorUtils.validateEntity(config);
configService.insert(config); // 插入新配置 configService.insert(config);
return R.ok(); return R.ok();
} }
/** /**
* 更新配置信息 * 修改
*/ */
@RequestMapping("/update") @RequestMapping("/update")
public R update(@RequestBody ConfigEntity config) { public R update(@RequestBody ConfigEntity config){
// ValidatorUtils.validateEntity(config); // 验证实体 // ValidatorUtils.validateEntity(config);
configService.updateById(config); // 全部更新配置信息 configService.updateById(config);//全部更新
return R.ok(); return R.ok();
} }
/** /**
* 删除配置信息 * 删除
*/ */
@RequestMapping("/delete") @RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) { public R delete(@RequestBody Long[] ids){
configService.deleteBatchIds(Arrays.asList(ids)); // 批量删除配置信息 configService.deleteBatchIds(Arrays.asList(ids));
return R.ok(); return R.ok();
} }
} }

450
src/main/java/com/controller/YonghuController.java
Unescape View File

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

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

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

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

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

Write Preview
Loading…
Cancel
Save