pcjs8mx7g
/
warehouse
1
0
Fork 0
Code Issues Pull Requests 2 Packages Projects Releases Wiki Activity

Update

Browse Source
shaoaoqi_branch
shaoaoqi 9 months ago
parent d9c3691427
commit ecd52163b9
8 changed files with 442 additions and 421 deletions
Show Stats Download Patch File Download Diff File

68
src/main/java/com/yeqifu/sys/controller/CacheController.java
Unescape View File

@ -16,62 +16,70 @@ import java.util.Map;
import java.util.Set;
/**
* 缓存管理控制器
* 缓存管理控制器类
* 该控制器提供了缓存管理的功能，包括查询所有缓存、删除缓存、清空缓存和同步缓存。
*
* @Author: 落亦-
* @Date: 2019/12/20 18:36
*/
@Api(description = "缓存管理")
@RestController
@RequestMapping("cache")
@Api(description = "缓存管理") // Swagger注解，用于描述API功能
@RestController // 标识为Spring MVC的Rest控制器
@RequestMapping("cache") // 定义基础请求路径为 "cache"
public class CacheController {
private static volatile Map<String,Object> CACHE_CONTAINER= CachePool.CACHE_CONTAINER;
/**
* 缓存容器
* 使用CachePool提供的静态缓存容器，存储所有缓存项。
* 使用volatile关键字保证多线程环境下的可见性。
*/
private static volatile Map<String,Object> CACHE_CONTAINER = CachePool.CACHE_CONTAINER;
/**
* 查询所有缓存
* @return
* @return DataGridView 返回所有缓存项的列表，用于前端显示。
*/
@ApiOperation(value = "查询所有缓存",notes = "查询所有缓存")
@RequestMapping(value = "loadAllCache",method = RequestMethod.GET)
public DataGridView loadAllCache(){
List<CacheBean> list = new ArrayList<>();
@ApiOperation(value = "查询所有缓存", notes = "查询所有缓存") // Swagger注解，用于描述接口的功能
@RequestMapping(value = "loadAllCache", method = RequestMethod.GET) // 映射GET请求到该方法
public DataGridView loadAllCache() {
List<CacheBean> list = new ArrayList<>(); // 用于存储缓存项的列表
// 遍历缓存容器的所有键值对
Set<Map.Entry<String, Object>> entrySet = CACHE_CONTAINER.entrySet();
for (Map.Entry<String, Object> entry : entrySet) {
list.add(new CacheBean(entry.getKey(),entry.getValue()));
// 将每个键值对封装为CacheBean对象并添加到列表中
list.add(new CacheBean(entry.getKey(), entry.getValue()));
}
return new DataGridView(list);
return new DataGridView(list); // 将列表封装为DataGridView对象返回
}
/**
* 删除缓存
* @param key
* @return
* 删除指定缓存
* @param key 缓存的键
* @return ResultObj 返回操作结果，表示删除是否成功。
*/
@RequestMapping("deleteCache")
public ResultObj deleteCache(String key){
CachePool.removeCacheByKey(key);
return ResultObj.DELETE_SUCCESS;
@RequestMapping("deleteCache") // 映射请求路径为 "deleteCache"
public ResultObj deleteCache(String key) {
CachePool.removeCacheByKey(key); // 调用CachePool的方法删除指定缓存
return ResultObj.DELETE_SUCCESS; // 返回删除成功的结果
}
/**
* 清空所有缓存
* @return
* @return ResultObj 返回操作结果，表示清空是否成功。
*/
@RequestMapping("removeAllCache")
public ResultObj removeAllCache(){
CachePool.removeAll();
return ResultObj.DELETE_SUCCESS;
@RequestMapping("removeAllCache") // 映射请求路径为 "removeAllCache"
public ResultObj removeAllCache() {
CachePool.removeAll(); // 调用CachePool的方法清空所有缓存
return ResultObj.DELETE_SUCCESS; // 返回清空成功的结果
}
/**
* 同步缓存
* @return
* @return ResultObj 返回操作结果，表示同步是否成功。
*/
@RequestMapping("syncCache")
public ResultObj syncCache(){
CachePool.syncData();
return ResultObj.SYNCCACHE_SUCCESS;
@RequestMapping("syncCache") // 映射请求路径为 "syncCache"
public ResultObj syncCache() {
CachePool.syncData(); // 调用CachePool的方法同步缓存
return ResultObj.SYNCCACHE_SUCCESS; // 返回同步成功的结果
}
}

149
src/main/java/com/yeqifu/sys/controller/DeptController.java
Unescape View File

@ -1,6 +1,5 @@
package com.yeqifu.sys.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
@ -18,148 +17,144 @@ import org.springframework.web.bind.annotation.RestController;
import java.util.*;
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* </p>
* 部门管理控制器
* 提供了部门数据的CRUD（增删改查）以及相关功能，包括树形结构加载、排序码获取等。
*
* @author luoyi-
* @since 2019-11-26
* @Author: 落亦-
* @Since: 2019-11-26
*/
@RestController
@RequestMapping("/dept")
@RestController // 标识为Spring MVC的Rest控制器
@RequestMapping("/dept") // 定义基础请求路径为 "/dept"
public class DeptController {
@Autowired
private IDeptService deptService;
private IDeptService deptService; // 自动注入部门服务接口
/**
* 加载部门左边的菜单树
* @param deptVo
* @return
* 加载部门左侧的菜单树
* 将部门数据组装为树形结构（JSON格式），供前端展示。
* @param deptVo 部门查询条件封装类
* @return DataGridView 包含树形节点的数据
*/
@RequestMapping("loadDeptManagerLeftTreeJson")
public DataGridView loadManagerLeftTreeJson(DeptVo deptVo){
//查询出所有的部门，存放进list中
// QueryWrapper<Dept> queryWrapper = new QueryWrapper<>();
// queryWrapper.eq('1');
public DataGridView loadManagerLeftTreeJson(DeptVo deptVo) {
// 查询所有部门数据
List<Dept> list = deptService.list();
List<TreeNode> treeNodes = new ArrayList<>();
//将部门放入treeNodes中，组装成json
// 遍历部门数据，将每个部门封装为树形节点
for (Dept dept : list) {
Boolean open = dept.getOpen()==1?true:false;
treeNodes.add(new TreeNode(dept.getId(),dept.getPid(),dept.getName(),open));
Boolean open = dept.getOpen() == 1; // 根据部门状态设置节点是否展开
treeNodes.add(new TreeNode(dept.getId(), dept.getPid(), dept.getName(), open));
}
return new DataGridView(treeNodes);
return new DataGridView(treeNodes); // 返回树形节点数据
}
/**
* 查询所有部门数据
* @param deptVo
* @return
* 查询所有部门数据（带分页和模糊查询）
* @param deptVo 部门查询条件封装类
* @return DataGridView 包含分页后的部门数据
*/
@RequestMapping("loadAllDept")
public DataGridView loadAllDept(DeptVo deptVo){
IPage<Dept> page = new Page<>(deptVo.getPage(),deptVo.getLimit());
//进行模糊查询
public DataGridView loadAllDept(DeptVo deptVo) {
IPage<Dept> page = new Page<>(deptVo.getPage(), deptVo.getLimit()); // 创建分页对象
QueryWrapper<Dept> queryWrapper = new QueryWrapper<>();
queryWrapper.like(StringUtils.isNotBlank(deptVo.getName()),"name",deptVo.getName());
queryWrapper.like(StringUtils.isNotBlank(deptVo.getRemark()),"remark",deptVo.getRemark());
queryWrapper.like(StringUtils.isNotBlank(deptVo.getAddress()),"address",deptVo.getAddress());
queryWrapper.eq(deptVo.getId()!=null,"id",deptVo.getId()).or().eq(deptVo.getId()!=null,"pid",deptVo.getId());
queryWrapper.orderByAsc("ordernum");
//进行查询
deptService.page(page,queryWrapper);
//返回DataGridView
return new DataGridView(page.getTotal(),page.getRecords());
// 添加模糊查询条件
queryWrapper.like(StringUtils.isNotBlank(deptVo.getName()), "name", deptVo.getName());
queryWrapper.like(StringUtils.isNotBlank(deptVo.getRemark()), "remark", deptVo.getRemark());
queryWrapper.like(StringUtils.isNotBlank(deptVo.getAddress()), "address", deptVo.getAddress());
queryWrapper.eq(deptVo.getId() != null, "id", deptVo.getId())
.or().eq(deptVo.getId() != null, "pid", deptVo.getId());
queryWrapper.orderByAsc("ordernum"); // 按排序码升序排列
deptService.page(page, queryWrapper); // 执行分页查询
return new DataGridView(page.getTotal(), page.getRecords()); // 返回分页数据
}
/**
* 添加部门
* @param deptVo
* @return
* @param deptVo 部门数据封装类
* @return ResultObj 操作结果（成功或失败）
*/
@RequestMapping("addDept")
public ResultObj addDept(DeptVo deptVo){
public ResultObj addDept(DeptVo deptVo) {
try {
deptVo.setCreatetime(new Date());
deptService.save(deptVo);
return ResultObj.ADD_SUCCESS;
deptVo.setCreatetime(new Date()); // 设置创建时间
deptService.save(deptVo); // 保存部门数据
return ResultObj.ADD_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.ADD_ERROR;
return ResultObj.ADD_ERROR; // 返回失败结果
}
}
/**
* 加载排序码
* @return
* 加载部门排序码（获取最大的排序码加1）
* @return Map 包含新的排序码
*/
@RequestMapping("loadDeptMaxOrderNum")
public Map<String,Object> loadDeptMaxOrderNum(){
Map<String,Object> map = new HashMap<String,Object>();
public Map<String, Object> loadDeptMaxOrderNum() {
Map<String, Object> map = new HashMap<>();
QueryWrapper<Dept> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByDesc("ordernum");
IPage<Dept> page = new Page<>(1,1);
List<Dept> list = deptService.page(page,queryWrapper).getRecords();
if (list.size()>0){
map.put("value",list.get(0).getOrdernum()+1);
}else {
map.put("value",1);
queryWrapper.orderByDesc("ordernum"); // 按排序码降序排列
IPage<Dept> page = new Page<>(1, 1); // 只查询一条记录
List<Dept> list = deptService.page(page, queryWrapper).getRecords();
if (list.size() > 0) {
map.put("value", list.get(0).getOrdernum() + 1); // 获取最大排序码+1
} else {
map.put("value", 1); // 如果无记录，排序码为1
}
return map;
}
/**
* 更新部门
* @param deptVo
* @return
* 更新部门信息
* @param deptVo 部门数据封装类
* @return ResultObj 操作结果（成功或失败）
*/
@RequestMapping("updateDept")
public ResultObj updateDept(DeptVo deptVo){
public ResultObj updateDept(DeptVo deptVo) {
try {
deptService.updateById(deptVo);
return ResultObj.UPDATE_SUCCESS;
deptService.updateById(deptVo); // 根据ID更新部门数据
return ResultObj.UPDATE_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.UPDATE_ERROR;
return ResultObj.UPDATE_ERROR; // 返回失败结果
}
}
/**
* 检查当前部门是否有子部门
* @param deptVo
* @return
* @param deptVo 部门数据封装类
* @return Map 包含布尔值，表示是否有子部门
*/
@RequestMapping("checkDeptHasChildrenNode")
public Map<String,Object> checkDeptHasChildrenNode(DeptVo deptVo){
Map<String,Object> map = new HashMap<String, Object>();
public Map<String, Object> checkDeptHasChildrenNode(DeptVo deptVo) {
Map<String, Object> map = new HashMap<>();
QueryWrapper<Dept> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("pid",deptVo.getId());
queryWrapper.eq("pid", deptVo.getId()); // 根据父ID查询
List<Dept> list = deptService.list(queryWrapper);
if (list.size()>0){
map.put("value",true);
}else {
map.put("value",false);
}
map.put("value", !list.isEmpty()); // 如果有子部门，返回true，否则返回false
return map;
}
/**
* 删除部门
* @param deptVo
* @return
* @param deptVo 部门数据封装类
* @return ResultObj 操作结果（成功或失败）
*/
@RequestMapping("deleteDept")
public ResultObj deleteDept(DeptVo deptVo){
public ResultObj deleteDept(DeptVo deptVo) {
try {
deptService.removeById(deptVo.getId());
return ResultObj.DELETE_SUCCESS;
deptService.removeById(deptVo.getId()); // 根据ID删除部门
return ResultObj.DELETE_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
return ResultObj.DELETE_ERROR; // 返回失败结果
}
}
}

70
src/main/java/com/yeqifu/sys/controller/FileController.java
Unescape View File

@ -14,57 +14,79 @@ import java.util.HashMap;
import java.util.Map;
/**
* 文件控制器
* 提供文件上传和图片下载的功能。
*
* @Author: 落亦-
* @Date: 2019/12/15 23:46
*/
@RestController
@RequestMapping("file")
@RestController // 标识为Spring MVC的Rest控制器
@RequestMapping("file") // 定义基础请求路径为 "/file"
public class FileController {
/**
* 文件上传
* @param mf
* @return
* @param mf 上传的文件（前端传递的MultipartFile对象）
* @return Map 包含文件保存路径的响应信息
*/
@RequestMapping("uploadFile")
public Map<String,Object> uploadFile(MultipartFile mf) {
//1.得到文件名
public Map<String, Object> uploadFile(MultipartFile mf) {
// 1. 获取原始文件名
String oldName = mf.getOriginalFilename();
//2.根据旧的文件名生成新的文件名
String newName=AppFileUtils.createNewFileName(oldName);
//3.得到当前日期的字符串
String dirName= DateUtil.format(new Date(), "yyyy-MM-dd");
//4.构造文件夹
File dirFile=new File(AppFileUtils.UPLOAD_PATH,dirName);
//5.判断当前文件夹是否存在
if(!dirFile.exists()) {
//如果不存在则创建新文件夹
// 2. 生成新的文件名（避免重复文件名）
String newName = AppFileUtils.createNewFileName(oldName);
// 3. 获取当前日期并格式化为 "yyyy-MM-dd" 字符串
String dirName = DateUtil.format(new Date(), "yyyy-MM-dd");
// 4. 构造保存文件的目录
File dirFile = new File(AppFileUtils.UPLOAD_PATH, dirName);
// 5. 检查目录是否存在，若不存在则创建
if (!dirFile.exists()) {
dirFile.mkdirs();
}
//6.构造文件对象
File file=new File(dirFile, newName+"_temp");
//7.把mf里面的图片信息写入file
// 6. 创建目标文件对象，文件名后加 "_temp" 表示临时文件
File file = new File(dirFile, newName + "_temp");
// 7. 将文件内容写入到目标文件中
try {
mf.transferTo(file);
} catch (IllegalStateException | IOException e) {
e.printStackTrace();
e.printStackTrace(); // 打印异常信息
}
Map<String,Object> map=new HashMap<String, Object>();
map.put("path",dirName+"/"+newName+"_temp");
// 8. 返回文件的保存路径（供前端调用）
Map<String, Object> map = new HashMap<>();
map.put("path", dirName + "/" + newName + "_temp");
return map;
}
/**
* 图片下载
* 根据文件路径返回图片的字节数据，供前端显示。
*
* @param path 文件相对路径
* @return ResponseEntity 响应图片数据
*/
@RequestMapping("showImageByPath")
public ResponseEntity<byte[]> showImageByPath(String path) {
// 规范路径，防止路径穿越
// **注意：未完成的功能，以下是解释和可能的逻辑建议**
// 1. 规范路径，防止路径穿越漏洞
Path normalizedPath = Paths.get(AppFileUtils.UPLOAD_PATH, path).normalize();
// 2. 验证路径是否在允许的上传目录内
if (!normalizedPath.startsWith(AppFileUtils.UPLOAD_PATH)) {
// 如果路径越界，则返回错误响应
// 如果路径越界，则返回403（禁止访问）状态响应
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
}
}
// 3. 从路径加载文件（逻辑未完成）
// - 需要检查文件是否存在
// - 需要读取文件的字节内容
// - 使用 `ResponseEntity` 返回字节数据和适当的 Content-Type 头
}
}

86
src/main/java/com/yeqifu/sys/controller/LoginController.java
Unescape View File

@ -24,68 +24,86 @@ import java.io.IOException;
import java.util.Date;
/**
* 登陆前端控制器
* 登录前端控制器
* 负责处理用户登录请求和验证码生成。
*
* @Author: 落亦-
* @Date: 2019/11/21 21:33
*/
@RestController
@RequestMapping("login")
@RestController // 表示该类是一个Rest风格的控制器，直接返回JSON数据
@RequestMapping("login") // 定义基础请求路径为 "/login"
public class LoginController {
@Autowired
private ILoginfoService loginfoService;
private ILoginfoService loginfoService; // 自动注入日志服务，用于记录登录日志
/**
* 用户登录
* @param userVo 用户提交的登录数据
* @param code 用户输入的验证码
* @param session 当前会话，用于获取存储的验证码
* @return ResultObj 包含登录结果的响应信息
*/
@RequestMapping("login")
public ResultObj login(UserVo userVo,String code,HttpSession session){
//获得存储在session中的验证码
public ResultObj login(UserVo userVo, String code, HttpSession session) {
// 从Session中获取之前生成的验证码
String sessionCode = (String) session.getAttribute("code");
if (code!=null&&sessionCode.equals(code)){
Subject subject = SecurityUtils.getSubject();
AuthenticationToken token = new UsernamePasswordToken(userVo.getLoginname(),userVo.getPwd());
// 验证用户输入的验证码是否正确
if (code != null && sessionCode.equals(code)) {
Subject subject = SecurityUtils.getSubject(); // 获取当前用户的Shiro Subject
AuthenticationToken token = new UsernamePasswordToken(userVo.getLoginname(), userVo.getPwd()); // 创建用户认证令牌
try {
//对用户进行认证登陆
// 执行用户认证登录
subject.login(token);
//通过subject获取以认证活动的user
// 通过认证后获取活动用户信息
ActiverUser activerUser = (ActiverUser) subject.getPrincipal();
//将user存储到session中
WebUtils.getSession().setAttribute("user",activerUser.getUser());
//记录登陆日志
// 将用户信息存储到Session中
WebUtils.getSession().setAttribute("user", activerUser.getUser());
// 创建登录日志对象
Loginfo entity = new Loginfo();
entity.setLoginname(activerUser.getUser().getName()+"-"+activerUser.getUser().getLoginname());
entity.setLoginip(WebUtils.getRequest().getRemoteAddr());
entity.setLogintime(new Date());
loginfoService.save(entity);
entity.setLoginname(activerUser.getUser().getName() + "-" + activerUser.getUser().getLoginname()); // 登录名称
entity.setLoginip(WebUtils.getRequest().getRemoteAddr()); // 获取用户IP地址
entity.setLogintime(new Date()); // 设置登录时间
loginfoService.save(entity); // 保存登录日志
return ResultObj.LOGIN_SUCCESS;
return ResultObj.LOGIN_SUCCESS; // 返回登录成功结果
} catch (AuthenticationException e) {
e.printStackTrace();
return ResultObj.LOGIN_ERROR_PASS;
return ResultObj.LOGIN_ERROR_PASS; // 用户名或密码错误
}
}else {
return ResultObj.LOGIN_ERROR_CODE;
} else {
return ResultObj.LOGIN_ERROR_CODE; // 验证码错误
}
}
/**
* 得到登陆验证码
* @param response
* @param session
* 获取登录验证码
* 生成并返回图片验证码，同时将验证码存储到Session中。
*
* @param response Http响应对象，用于返回验证码图片
* @param session 当前会话，用于存储验证码
* @throws IOException
*/
@RequestMapping("getCode")
public void getCode(HttpServletResponse response, HttpSession session) throws IOException{
//定义图形验证码的长和宽
LineCaptcha lineCaptcha = CaptchaUtil.createLineCaptcha(116, 36,4,5);
session.setAttribute("code",lineCaptcha.getCode());
public void getCode(HttpServletResponse response, HttpSession session) throws IOException {
// 创建图形验证码，指定宽、高、字符数和干扰线数
LineCaptcha lineCaptcha = CaptchaUtil.createLineCaptcha(116, 36, 4, 5);
// 将验证码内容存储到Session中
session.setAttribute("code", lineCaptcha.getCode());
try {
// 获取响应输出流，将验证码图片写入响应
ServletOutputStream outputStream = response.getOutputStream();
lineCaptcha.write(outputStream);
outputStream.close();
outputStream.close(); // 关闭输出流
} catch (IOException e) {
e.printStackTrace();
e.printStackTrace(); // 捕获并打印IO异常
}
}
}

93
src/main/java/com/yeqifu/sys/controller/LoginfoController.java
Unescape View File

@ -1,10 +1,8 @@
package com.yeqifu.sys.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.sun.org.apache.regexp.internal.RE;
import com.yeqifu.sys.common.DataGridView;
import com.yeqifu.sys.common.ResultObj;
import com.yeqifu.sys.entity.Loginfo;
@ -13,7 +11,6 @@ import com.yeqifu.sys.vo.LoginfoVo;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.io.Serializable;
@ -21,76 +18,92 @@ import java.util.ArrayList;
import java.util.Collection;
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* </p>
* 日志管理前端控制器
* 提供查询登录日志、删除单条日志以及批量删除日志的接口。
*
* @author luoyi-
* @since 2019-11-23
* @Author: luoyi-
* @Since: 2019-11-23
*/
@RestController
@RequestMapping("loginfo")
@RestController // 标注为Rest风格的控制器，方法直接返回JSON格式数据
@RequestMapping("loginfo") // 定义基础请求路径为 "/loginfo"
public class LoginfoController {
@Autowired
private ILoginfoService loginfoService;
private ILoginfoService loginfoService; // 自动注入日志服务接口，负责日志数据的业务逻辑处理
/**
* 查询所有登陆日志的信息
* @param loginfoVo
* @return
* 查询所有登录日志的信息
* 支持分页、模糊查询和时间范围筛选。
*
* @param loginfoVo 日志查询条件封装类，包含分页参数和查询条件
* @return 包含日志总条数和分页数据的对象
*/
@RequestMapping("loadAllLoginfo")
public DataGridView loadAllLoginfo(LoginfoVo loginfoVo){
IPage<Loginfo> page = new Page<Loginfo>(loginfoVo.getPage(),loginfoVo.getLimit());
QueryWrapper<Loginfo> queryWrapper = new QueryWrapper<Loginfo>();
//进行模糊查询
queryWrapper.like(StringUtils.isNotBlank(loginfoVo.getLoginname()),"loginname",loginfoVo.getLoginname());
queryWrapper.like(StringUtils.isNotBlank(loginfoVo.getLoginip()),"loginip",loginfoVo.getLoginip());
//数据库中登陆时间要大于用户输入的开始时间且小于用户登陆的结束时间
queryWrapper.ge(loginfoVo.getStartTime()!=null,"logintime",loginfoVo.getStartTime());
queryWrapper.le(loginfoVo.getEndTime()!=null,"logintime",loginfoVo.getEndTime());
//根据登陆时间进行降序排序
public DataGridView loadAllLoginfo(LoginfoVo loginfoVo) {
// 创建分页对象，指定当前页和每页条数
IPage<Loginfo> page = new Page<>(loginfoVo.getPage(), loginfoVo.getLimit());
// 构造查询条件
QueryWrapper<Loginfo> queryWrapper = new QueryWrapper<>();
// 根据登录名进行模糊查询，条件为空时忽略
queryWrapper.like(StringUtils.isNotBlank(loginfoVo.getLoginname()), "loginname", loginfoVo.getLoginname());
// 根据登录IP进行模糊查询，条件为空时忽略
queryWrapper.like(StringUtils.isNotBlank(loginfoVo.getLoginip()), "loginip", loginfoVo.getLoginip());
// 筛选登录时间大于等于开始时间
queryWrapper.ge(loginfoVo.getStartTime() != null, "logintime", loginfoVo.getStartTime());
// 筛选登录时间小于等于结束时间
queryWrapper.le(loginfoVo.getEndTime() != null, "logintime", loginfoVo.getEndTime());
// 按登录时间降序排列
queryWrapper.orderByDesc("logintime");
loginfoService.page(page,queryWrapper);
return new DataGridView(page.getTotal(),page.getRecords());
// 分页查询日志数据
loginfoService.page(page, queryWrapper);
// 返回包含总条数和当前页数据的结果
return new DataGridView(page.getTotal(), page.getRecords());
}
/**
* 删除单条日志
* @param id
* @return
* 根据日志ID删除指定的日志记录。
*
* @param id 日志记录的唯一标识
* @return 删除操作的结果信息
*/
@RequestMapping("deleteLoginfo")
public ResultObj deleteLoginfo(Integer id){
public ResultObj deleteLoginfo(Integer id) {
try {
// 根据ID删除日志
loginfoService.removeById(id);
return ResultObj.DELETE_SUCCESS;
return ResultObj.DELETE_SUCCESS; // 返回删除成功的结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
return ResultObj.DELETE_ERROR; // 返回删除失败的结果
}
}
/**
* 批量删除
* @param loginfoVo
* @return
* 批量删除日志
* 根据多个日志ID删除指定的日志记录。
*
* @param loginfoVo 封装了多个日志ID的对象
* @return 删除操作的结果信息
*/
@RequestMapping("batchDeleteLoginfo")
public ResultObj batchDeleteLoginfo(LoginfoVo loginfoVo){
public ResultObj batchDeleteLoginfo(LoginfoVo loginfoVo) {
try {
Collection<Serializable> idList = new ArrayList<Serializable>();
// 创建集合存储需要删除的日志ID
Collection<Serializable> idList = new ArrayList<>();
// 遍历日志ID数组，将其添加到集合中
for (Integer id : loginfoVo.getIds()) {
idList.add(id);
}
// 批量删除日志
this.loginfoService.removeByIds(idList);
return ResultObj.DELETE_SUCCESS;
return ResultObj.DELETE_SUCCESS; // 返回批量删除成功的结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
return ResultObj.DELETE_ERROR; // 返回批量删除失败的结果
}
}
}

171
src/main/java/com/yeqifu/sys/controller/MenuController.java
Unescape View File

@ -21,6 +21,8 @@ import org.springframework.web.bind.annotation.RestController;
import java.util.*;
/**
* 菜单管理控制器
*
* @Author: 落亦-
* @Date: 2019/11/22 15:35
*/
@ -37,119 +39,97 @@ public class MenuController {
@Autowired
private IRoleService roleService;
/**
* 加载首页左侧菜单数据
* @param permissionVo
* @return 返回树形结构的菜单数据
*/
@RequestMapping("loadIndexLeftMenuJson")
public DataGridView loadIndexLeftMenuJson(PermissionVo permissionVo){
//查询所有菜单
QueryWrapper<Permission> queryWrapper = new QueryWrapper<Permission>();
//设置查询条件
//查询的必须是菜单，不能是crud的权限
queryWrapper.eq("type",Constast.TYPE_MENU);
//菜单必须可用
queryWrapper.eq("available", Constast.AVAILABLE_TRUE);
//获得用户 判断用户的类型
public DataGridView loadIndexLeftMenuJson(PermissionVo permissionVo) {
// 查询所有菜单
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("type", Constast.TYPE_MENU); // 只查询菜单
queryWrapper.eq("available", Constast.AVAILABLE_TRUE); // 菜单必须可用
// 获取当前用户信息
User user = (User) WebUtils.getSession().getAttribute("user");
List<Permission> list = null;
if (user.getType().equals(Constast.USER_TYPE_SUPER)){
//用户类型为超级管理员
List<Permission> list;
if (user.getType().equals(Constast.USER_TYPE_SUPER)) {
// 超级管理员查询所有菜单
list = permissionService.list(queryWrapper);
}else {
//用户类型为 普通用户
//根据用户ID+角色+权限去查询
} else {
// 普通用户根据角色和权限查询菜单
Integer userId = user.getId();
//1.根据用户ID查询角色
List<Integer> currentUserRoleIds = roleService.queryUserRoleIdsByUid(userId);
//2.根据角色ID查询菜单ID和权限ID
//使用set去重
List<Integer> currentUserRoleIds = roleService.queryUserRoleIdsByUid(userId); // 获取用户角色ID
Set<Integer> pids = new HashSet<>();
for (Integer rid : currentUserRoleIds) {
//根据角色ID查询菜单ID和权限ID
List<Integer> permissionIds = roleService.queryRolePermissionIdsByRid(rid);
//将菜单ID和权限ID放入Set中去重
pids.addAll(permissionIds);
pids.addAll(roleService.queryRolePermissionIdsByRid(rid)); // 根据角色ID查询权限ID
}
//3.根据角色ID查询权限
if (pids.size()>0){
queryWrapper.in("id",pids);
if (!pids.isEmpty()) {
queryWrapper.in("id", pids); // 根据权限ID查询菜单
list = permissionService.list(queryWrapper);
}else {
list=new ArrayList<>();
} else {
list = new ArrayList<>();
}
}
List<TreeNode> treeNodes = new ArrayList<TreeNode>();
// 构造树节点列表
List<TreeNode> treeNodes = new ArrayList<>();
for (Permission p : list) {
Integer id =p.getId();
Integer pid = p.getPid();
String title = p.getTitle();
String icon = p.getIcon();
String href = p.getHref();
Boolean spread = p.getOpen().equals(Constast.OPEN_TRUE)?true:false;
treeNodes.add(new TreeNode(id,pid,title,icon,href,spread));
Boolean spread = p.getOpen().equals(Constast.OPEN_TRUE);
treeNodes.add(new TreeNode(p.getId(), p.getPid(), p.getTitle(), p.getIcon(), p.getHref(), spread));
}
//构造层级关系
List<TreeNode> list2 = TreeNodeBuilder.build(treeNodes,1);
return new DataGridView(list2);
// 构造层级菜单树
return new DataGridView(TreeNodeBuilder.build(treeNodes, 1));
}
/************************菜单管理*********************************/
/**
* 加载菜单左边的菜单树
* 加载菜单管理左侧菜单树
* @param permissionVo
* @return
* @return 返回树形结构的菜单数据
*/
@RequestMapping("loadMenuManagerLeftTreeJson")
public DataGridView loadMenuManagerLeftTreeJson(PermissionVo permissionVo){
public DataGridView loadMenuManagerLeftTreeJson(PermissionVo permissionVo) {
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("type",Constast.TYPE_MENU);
//查询出所有的菜单，存放进list中
List<Permission> list = permissionService.list(queryWrapper);
queryWrapper.eq("type", Constast.TYPE_MENU); // 只查询菜单
List<Permission> list = permissionService.list(queryWrapper); // 查询所有菜单
List<TreeNode> treeNodes = new ArrayList<>();
//将菜单放入treeNodes中，组装成json
for (Permission menu : list) {
Boolean open = menu.getOpen()==1?true:false;
treeNodes.add(new TreeNode(menu.getId(),menu.getPid(),menu.getTitle(),open));
Boolean open = menu.getOpen() == 1; // 判断是否展开
treeNodes.add(new TreeNode(menu.getId(), menu.getPid(), menu.getTitle(), open));
}
return new DataGridView(treeNodes);
}
/**
* 查询所有菜单数据
* 查询所有菜单
* @param permissionVo
* @return
* @return 返回分页后的菜单数据
*/
@RequestMapping("loadAllMenu")
public DataGridView loadAllMenu(PermissionVo permissionVo){
IPage<Permission> page = new Page<>(permissionVo.getPage(),permissionVo.getLimit());
//进行模糊查询
public DataGridView loadAllMenu(PermissionVo permissionVo) {
IPage<Permission> page = new Page<>(permissionVo.getPage(), permissionVo.getLimit());
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.eq(permissionVo.getId()!=null,"id",permissionVo.getId()).or().eq(permissionVo.getId()!=null,"pid",permissionVo.getId());
//只能查询菜单
queryWrapper.eq("type",Constast.TYPE_MENU);
queryWrapper.like(StringUtils.isNotBlank(permissionVo.getTitle()),"title",permissionVo.getTitle());
queryWrapper.orderByAsc("ordernum");
//进行查询
permissionService.page(page,queryWrapper);
//返回DataGridView
return new DataGridView(page.getTotal(),page.getRecords());
queryWrapper.eq(permissionVo.getId() != null, "id", permissionVo.getId())
.or().eq(permissionVo.getId() != null, "pid", permissionVo.getId());
queryWrapper.eq("type", Constast.TYPE_MENU); // 只查询菜单
queryWrapper.like(StringUtils.isNotBlank(permissionVo.getTitle()), "title", permissionVo.getTitle());
queryWrapper.orderByAsc("ordernum"); // 根据排序码升序排列
permissionService.page(page, queryWrapper); // 分页查询
return new DataGridView(page.getTotal(), page.getRecords());
}
/**
* 添加菜单
* @param permissionVo
* @return
* @return 操作结果
*/
@RequestMapping("addMenu")
public ResultObj addMenu(PermissionVo permissionVo){
public ResultObj addMenu(PermissionVo permissionVo) {
try {
//设置添加类型为 menu
permissionVo.setType(Constast.TYPE_MENU);
permissionVo.setType(Constast.TYPE_MENU); // 设置类型为菜单
permissionService.save(permissionVo);
return ResultObj.ADD_SUCCESS;
} catch (Exception e) {
@ -159,31 +139,27 @@ public class MenuController {
}
/**
* 加载排序码
* @return
* 加载菜单的最大排序码
* @return 返回最大排序码
*/
@RequestMapping("loadMenuMaxOrderNum")
public Map<String,Object> loadMenuMaxOrderNum(){
Map<String,Object> map = new HashMap<String,Object>();
public Map<String, Object> loadMenuMaxOrderNum() {
Map<String, Object> map = new HashMap<>();
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByDesc("ordernum");
IPage<Permission> page = new Page<>(1,1);
List<Permission> list = permissionService.page(page,queryWrapper).getRecords();
if (list.size()>0){
map.put("value",list.get(0).getOrdernum()+1);
}else {
map.put("value",1);
}
IPage<Permission> page = new Page<>(1, 1);
List<Permission> list = permissionService.page(page, queryWrapper).getRecords();
map.put("value", list.isEmpty() ? 1 : list.get(0).getOrdernum() + 1);
return map;
}
/**
* 更新菜单
* @param permissionVo
* @return
* @return 操作结果
*/
@RequestMapping("updateMenu")
public ResultObj updateMenu(PermissionVo permissionVo){
public ResultObj updateMenu(PermissionVo permissionVo) {
try {
permissionService.updateById(permissionVo);
return ResultObj.UPDATE_SUCCESS;
@ -194,31 +170,26 @@ public class MenuController {
}
/**
* 检查当前菜单是否有子菜单
* 检查菜单是否有子菜单
* @param permissionVo
* @return
* @return 返回是否有子菜单
*/
@RequestMapping("checkMenuHasChildrenNode")
public Map<String,Object> checkMenuHasChildrenNode(PermissionVo permissionVo){
Map<String,Object> map = new HashMap<String, Object>();
public Map<String, Object> checkMenuHasChildrenNode(PermissionVo permissionVo) {
Map<String, Object> map = new HashMap<>();
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("pid",permissionVo.getId());
List<Permission> list = permissionService.list(queryWrapper);
if (list.size()>0){
map.put("value",true);
}else {
map.put("value",false);
}
queryWrapper.eq("pid", permissionVo.getId()); // 查询是否有子菜单
map.put("value", !permissionService.list(queryWrapper).isEmpty());
return map;
}
/**
* 删除菜单
* @param permissionVo
* @return
* @return 操作结果
*/
@RequestMapping("deleteMenu")
public ResultObj deleteMenu(PermissionVo permissionVo){
public ResultObj deleteMenu(PermissionVo permissionVo) {
try {
permissionService.removeById(permissionVo.getId());
return ResultObj.DELETE_SUCCESS;
@ -227,6 +198,4 @@ public class MenuController {
return ResultObj.DELETE_ERROR;
}
}
}

81
src/main/java/com/yeqifu/sys/controller/NoticeController.java
Unescape View File

@ -37,48 +37,51 @@ public class NoticeController {
private INoticeService noticeService;
/**
* 公告的查询
* @param noticeVo
* @return
* 查询公告列表
* 根据条件（标题、操作人、创建时间范围）分页查询公告，并按创建时间降序排序。
*
* @param noticeVo 包含查询条件的对象
* @return 包含公告数据和总记录数的DataGridView对象
*/
@RequestMapping("loadAllNotice")
public DataGridView loadAllNotice(NoticeVo noticeVo){
IPage<Notice> page = new Page<Notice>(noticeVo.getPage(),noticeVo.getLimit());
QueryWrapper<Notice> queryWrapper = new QueryWrapper<Notice>();
//进行模糊查询
queryWrapper.like(StringUtils.isNotBlank(noticeVo.getTitle()),"title",noticeVo.getTitle());
queryWrapper.like(StringUtils.isNotBlank(noticeVo.getOpername()),"opername",noticeVo.getOpername());
//公告创建时间应该大于搜索开始时间小于搜索结束时间
queryWrapper.ge(noticeVo.getStartTime()!=null,"createtime",noticeVo.getStartTime());
queryWrapper.le(noticeVo.getEndTime()!=null,"createtime",noticeVo.getEndTime());
//根据公告创建时间进行排序
public DataGridView loadAllNotice(NoticeVo noticeVo) {
// 分页和条件查询
IPage<Notice> page = new Page<>(noticeVo.getPage(), noticeVo.getLimit());
QueryWrapper<Notice> queryWrapper = new QueryWrapper<>();
queryWrapper.like(StringUtils.isNotBlank(noticeVo.getTitle()), "title", noticeVo.getTitle());
queryWrapper.like(StringUtils.isNotBlank(noticeVo.getOpername()), "opername", noticeVo.getOpername());
queryWrapper.ge(noticeVo.getStartTime() != null, "createtime", noticeVo.getStartTime());
queryWrapper.le(noticeVo.getEndTime() != null, "createtime", noticeVo.getEndTime());
queryWrapper.orderByDesc("createtime");
noticeService.page(page,queryWrapper);
return new DataGridView(page.getTotal(),page.getRecords());
noticeService.page(page, queryWrapper);
return new DataGridView(page.getTotal(), page.getRecords());
}
/**
* 根据公告ID查询一条公告
* @param id 公告ID
* @return
* 根据公告ID查询单条公告
*
* @param id 公告ID
* @return 包含公告数据的DataGridView对象
*/
@RequestMapping("loadNoticeById")
public DataGridView loadNoticeById(Integer id){
public DataGridView loadNoticeById(Integer id) {
Notice notice = noticeService.getById(id);
return new DataGridView(notice);
}
/**
* 添加公告
* @param noticeVo
* @return
* 自动填充创建时间和操作人信息。
*
* @param noticeVo 包含公告信息的对象
* @return 操作结果（成功或失败）
*/
@RequestMapping("addNotice")
public ResultObj addNotice(NoticeVo noticeVo){
public ResultObj addNotice(NoticeVo noticeVo) {
try {
noticeVo.setCreatetime(new Date());
noticeVo.setCreatetime(new Date()); // 设置创建时间
User user = (User) WebUtils.getSession().getAttribute("user");
noticeVo.setOpername(user.getName());
noticeVo.setOpername(user.getName()); // 设置操作人
noticeService.save(noticeVo);
return ResultObj.ADD_SUCCESS;
} catch (Exception e) {
@ -89,11 +92,12 @@ public class NoticeController {
/**
* 修改公告
* @param noticeVo
* @return
*
* @param noticeVo 包含修改后公告信息的对象
* @return 操作结果（成功或失败）
*/
@RequestMapping("updateNotice")
public ResultObj updateNotice(NoticeVo noticeVo){
public ResultObj updateNotice(NoticeVo noticeVo) {
try {
noticeService.updateById(noticeVo);
return ResultObj.UPDATE_SUCCESS;
@ -104,12 +108,13 @@ public class NoticeController {
}
/**
* 删除公告
* @param noticeVo
* @return
* 删除单条公告
*
* @param noticeVo 包含要删除公告ID的对象
* @return 操作结果（成功或失败）
*/
@RequestMapping("deleteNotice")
public ResultObj deleteNotice(NoticeVo noticeVo){
public ResultObj deleteNotice(NoticeVo noticeVo) {
try {
noticeService.removeById(noticeVo);
return ResultObj.DELETE_SUCCESS;
@ -121,24 +126,22 @@ public class NoticeController {
/**
* 批量删除公告
* @param noticeVo
* @return
*
* @param noticeVo 包含要删除公告ID集合的对象
* @return 操作结果（成功或失败）
*/
@RequestMapping("batchDeleteNotice")
public ResultObj batchDeleteNotice(NoticeVo noticeVo){
public ResultObj batchDeleteNotice(NoticeVo noticeVo) {
try {
Collection<Serializable> idList = new ArrayList<>();
for (Integer id : noticeVo.getIds()) {
idList.add(id);
idList.add(id); // 将ID加入集合
}
noticeService.removeByIds(idList);
noticeService.removeByIds(idList); // 批量删除
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
}
}
}

145
src/main/java/com/yeqifu/sys/controller/PermissionController.java
Unescape View File

@ -22,74 +22,66 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* </p>
*
* @author luoyi-
* @since 2019-11-22
*/
@RestController
/@RestController
@RequestMapping("permission")
public class PermissionController {
@Autowired
private IPermissionService permissionService;
/**
* 加载权限左边的权限树
* @param permissionVo
* @return
* 加载权限管理左侧的权限树
* 将所有菜单类型的权限以树形结构的形式返回。
*
* @param permissionVo 包含请求参数的对象
* @return 包含树形结构权限数据的DataGridView对象
*/
@RequestMapping("loadPermissionManagerLeftTreeJson")
public DataGridView loadPermissionManagerLeftTreeJson(PermissionVo permissionVo){
QueryWrapper<Permission> queryWrapper = new QueryWrapper<Permission>();
queryWrapper.eq("type", Constast.TYPE_MENU);
//查询出所有的权限，存放进list中
List<Permission> list = permissionService.list(queryWrapper);
List<TreeNode> treeNodes = new ArrayList<TreeNode>();
//将权限放入treeNodes中，组装成json
public DataGridView loadPermissionManagerLeftTreeJson(PermissionVo permissionVo) {
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("type", Constast.TYPE_MENU); // 查询类型为菜单的权限
List<Permission> list = permissionService.list(queryWrapper); // 查询权限列表
List<TreeNode> treeNodes = new ArrayList<>();
for (Permission permission : list) {
Boolean open = permission.getOpen()==1?true:false;
treeNodes.add(new TreeNode(permission.getId(),permission.getPid(),permission.getTitle(),open));
// 创建树节点，设置是否展开
Boolean open = permission.getOpen() == 1 ? true : false;
treeNodes.add(new TreeNode(permission.getId(), permission.getPid(), permission.getTitle(), open));
}
return new DataGridView(treeNodes);
}
/**
* 查询所有权限数据
* @param permissionVo
* @return
* 按条件（权限类型、标题、权限码、父ID）进行模糊查询并排序，支持分页。
*
* @param permissionVo 包含查询条件和分页参数的对象
* @return 包含权限数据和总记录数的DataGridView对象
*/
@RequestMapping("loadAllPermission")
public DataGridView loadAllPermission(PermissionVo permissionVo){
IPage<Permission> page = new Page<>(permissionVo.getPage(),permissionVo.getLimit());
//进行模糊查询
public DataGridView loadAllPermission(PermissionVo permissionVo) {
IPage<Permission> page = new Page<>(permissionVo.getPage(), permissionVo.getLimit());
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
//只能查询权限
queryWrapper.eq("type",Constast.TYPE_PERMISSION);
queryWrapper.like(StringUtils.isNotBlank(permissionVo.getTitle()),"title",permissionVo.getTitle());
queryWrapper.like(StringUtils.isNotBlank(permissionVo.getPercode()),"percode",permissionVo.getPercode());
queryWrapper.eq(permissionVo.getId()!=null,"pid",permissionVo.getId());
queryWrapper.orderByAsc("ordernum");
//进行查询
permissionService.page(page,queryWrapper);
//返回DataGridView
return new DataGridView(page.getTotal(),page.getRecords());
queryWrapper.eq("type", Constast.TYPE_PERMISSION); // 仅查询权限类型
queryWrapper.like(StringUtils.isNotBlank(permissionVo.getTitle()), "title", permissionVo.getTitle());
queryWrapper.like(StringUtils.isNotBlank(permissionVo.getPercode()), "percode", permissionVo.getPercode());
queryWrapper.eq(permissionVo.getId() != null, "pid", permissionVo.getId());
queryWrapper.orderByAsc("ordernum"); // 按排序号升序排序
permissionService.page(page, queryWrapper); // 执行分页查询
return new DataGridView(page.getTotal(), page.getRecords());
}
/**
* 添加权限
* @param permissionVo
* @return
* 将新权限保存到数据库中，并设置其类型为“权限”。
*
* @param permissionVo 包含权限数据的对象
* @return 操作结果（成功或失败）
*/
@RequestMapping("addPermission")
public ResultObj addPermission(PermissionVo permissionVo){
public ResultObj addPermission(PermissionVo permissionVo) {
try {
//设置添加类型为 permission
permissionVo.setType(Constast.TYPE_PERMISSION);
permissionService.save(permissionVo);
permissionVo.setType(Constast.TYPE_PERMISSION); // 设置类型为权限
permissionService.save(permissionVo); // 保存权限
return ResultObj.ADD_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
@ -98,33 +90,37 @@ public class PermissionController {
}
/**
* 加载排序码
* @return
* 加载权限的最大排序号
* 返回当前权限的最大排序号+1，用于新增权限时自动设置排序号。
*
* @return 包含最大排序号的Map对象
*/
@RequestMapping("loadPermissionMaxOrderNum")
public Map<String,Object> loadPermissionMaxOrderNum(){
Map<String,Object> map = new HashMap<String,Object>();
public Map<String, Object> loadPermissionMaxOrderNum() {
Map<String, Object> map = new HashMap<>();
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByDesc("ordernum");
IPage<Permission> page = new Page<>(1,1);
List<Permission> list = permissionService.page(page,queryWrapper).getRecords();
if (list.size()>0){
map.put("value",list.get(0).getOrdernum()+1);
}else {
map.put("value",1);
queryWrapper.orderByDesc("ordernum"); // 按排序号降序查询
IPage<Permission> page = new Page<>(1, 1); // 查询第一页的第一条记录
List<Permission> list = permissionService.page(page, queryWrapper).getRecords();
if (list.size() > 0) {
map.put("value", list.get(0).getOrdernum() + 1); // 最大排序号+1
} else {
map.put("value", 1); // 如果没有记录，设置排序号为1
}
return map;
}
/**
* 更新权限
* @param permissionVo
* @return
* 根据ID更新权限信息。
*
* @param permissionVo 包含更新数据的对象
* @return 操作结果（成功或失败）
*/
@RequestMapping("updatePermission")
public ResultObj updatePermission(PermissionVo permissionVo){
public ResultObj updatePermission(PermissionVo permissionVo) {
try {
permissionService.updateById(permissionVo);
permissionService.updateById(permissionVo); // 根据ID更新权限
return ResultObj.UPDATE_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
@ -133,40 +129,37 @@ public class PermissionController {
}
/**
* 检查当前权限是否有子权限
* @param permissionVo
* @return
* 检查权限是否有子权限
* 根据父ID查询是否存在子权限，返回结果为true或false。
*
* @param permissionVo 包含父ID的对象
* @return 包含检查结果的Map对象
*/
@RequestMapping("checkPermissionHasChildrenNode")
public Map<String,Object> checkPermissionHasChildrenNode(PermissionVo permissionVo){
Map<String,Object> map = new HashMap<String, Object>();
public Map<String, Object> checkPermissionHasChildrenNode(PermissionVo permissionVo) {
Map<String, Object> map = new HashMap<>();
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("pid",permissionVo.getId());
queryWrapper.eq("pid", permissionVo.getId()); // 根据父ID查询
List<Permission> list = permissionService.list(queryWrapper);
if (list.size()>0){
map.put("value",true);
}else {
map.put("value",false);
}
map.put("value", !list.isEmpty()); // 如果有子权限，返回true；否则返回false
return map;
}
/**
* 删除权限
* @param permissionVo
* @return
* 根据ID删除权限。
*
* @param permissionVo 包含要删除权限ID的对象
* @return 操作结果（成功或失败）
*/
@RequestMapping("deletePermission")
public ResultObj deletePermission(PermissionVo permissionVo){
public ResultObj deletePermission(PermissionVo permissionVo) {
try {
permissionService.removeById(permissionVo.getId());
permissionService.removeById(permissionVo.getId()); // 根据ID删除权限
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
}
}
}

Write Preview
Loading…
Cancel
Save