基于ssm+shiro+activiti的办公自动化系统

最新推荐文章于 2023-04-23 09:17:30 发布

momopeng～

最新推荐文章于 2023-04-23 09:17:30 发布

阅读量376

点赞数

文章标签： java tomcat eclipse spring mybatis

本文链接：https://blog.csdn.net/weixin_56458754/article/details/128104511

版权

welcome.html首页效果图：

效果图展示：

一、报销管理

报销申请：

我的报销单：（分页功能）

2.1查看审核记录：

2.2查看当前流程图：

3、我的代办事务：

3.1办理任务：（按钮会根据不同的岗位有所不同）

（1）普通用户zhang:

（2）部门经理mike:

3.2查看当前流程图：

流程管理

发布流程：

查看流程：

系统管理

用户管理：

1.1查看权限：

1.2新建用户：

角色添加：

2.1保存角色和权限：勾选权限和输入角色即可

2.2新建权限：

角色列表：

3.1编辑：(总经理)

3.2删除：根据roleid修改角色Available为0，然后角色列表只查询Available为1的

项目结构：

一、shiro认证授权：通过认证后才可进入对应的路径

import java.util.ArrayList;

import java.util.List;

import javax.servlet.http.HttpSession;

import org.apache.shiro.authc.AuthenticationException;

import org.apache.shiro.authc.AuthenticationInfo;

import org.apache.shiro.authc.AuthenticationToken;

import org.apache.shiro.authc.SimpleAuthenticationInfo;

import org.apache.shiro.authz.AuthorizationInfo;

import org.apache.shiro.authz.SimpleAuthorizationInfo;

import org.apache.shiro.realm.AuthorizingRealm;

import org.apache.shiro.subject.PrincipalCollection;

import org.apache.shiro.util.ByteSource;

import org.springframework.beans.factory.annotation.Autowired;

import com.web.oa.pojo.ActiveUser;

import com.web.oa.pojo.Employee;

import com.web.oa.pojo.Permission;

import com.web.oa.pojo.TreeMenu;

import com.web.oa.service.EmployeeService;

import com.web.oa.utils.Constants;

/**

* 自定义realm类

* @author A

public class CustomRealm extends AuthorizingRealm{

@Autowired

private EmployeeService employeeService;

/**

* 认证

* 认证回调函数, 登录时调用

* @param token 其实存的就是用户名

@Override

protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

System.out.println("doGetAuthenticationInfo-认证");

//用户输入账号

String username = (String) token.getPrincipal();

System.out.println("username:"+username);

Employee emp = employeeService.findEmployeeByName(username);

if(emp==null){

return null;// UnknownAccountException

}

//得到菜单权限信息

List<TreeMenu> menuTree = employeeService.getTreeMenu();

//重新封装用户身份信息

ActiveUser activeUser = new ActiveUser();

activeUser.setId(emp.getId());

activeUser.setUserid(emp.getName());//用户id

activeUser.setUsercode(emp.getName());//用户账户

activeUser.setUsername(emp.getName());//用户名称

activeUser.setManagerId(emp.getManagerId());//上级id

//根据用户id查询用户具有的权限信息

List<Permission> permissions = employeeService.findPermissionListByUserId(activeUser.getUsername());

List<String> permisionList = new ArrayList<>();

for (Permission Permission : permissions) {

permisionList.add(Permission.getPercode());//把得到每个procde的值保存在permisionList的集合当中

}

System.out.println("permisionList:"+permisionList);

System.out.println("permissions:"+permissions);

activeUser.setMenuTree(menuTree);//菜单类

activeUser.setMenus(permissions);

//得到数据库密码（密文）

String password = emp.getPassword();

System.out.println("password:"+password);

//加盐

String salt = emp.getSalt();

System.out.println("salt:"+salt);

//参数：需要验证信息，密码，盐，别名

SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(activeUser, password, ByteSource.Util.bytes(salt), "CustomRealm");

return info;

}

/**

* 授权

* 授权查询回调函数, 进行鉴权但缓存中无用户的授权信息时调用

@Override

protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principal) {

System.out.println("doGetAuthorizationInfo-授权");

ActiveUser activeUser = (ActiveUser) principal.getPrimaryPrincipal();

//根据userid查询数据库认证用户拥有的角色和权限信息

List<Permission> permissions = employeeService.findPermissionListByUserId(activeUser.getUsername());

List<String> permisionList = new ArrayList<>();

for (Permission Permission : permissions) {

permisionList.add(Permission.getPercode());//把得到每个procde的值保存在permisionList的集合当中

}

SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();

info.addStringPermissions(permisionList);

return info;

}

二、过滤器：请求到main

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpSession;

import org.apache.shiro.authc.AuthenticationToken;

import org.apache.shiro.subject.Subject;

import org.apache.shiro.web.filter.authc.FormAuthenticationFilter;

import org.apache.shiro.web.util.WebUtils;

/**

* 自定义的表单过滤器，主要是处理验证码功能的

* 解决shiro成功认证后跳转页面

* @author A

public class CustomFormAuthenticationFilter extends FormAuthenticationFilter {

@Override

protected boolean onLoginSuccess(AuthenticationToken token, Subject subject, ServletRequest request,ServletResponse response) throws Exception {

System.out.println("onLoginSuccess");

//清空原来请求地址

WebUtils.getAndClearSavedRequest(request);

//重定向到main

WebUtils.redirectToSavedRequest(request, response, "/main");

return false;

}

三、EmployeeController控制器类：通过请求地址进入main，传输数据

WorkFlowController控制器类：activiti工作流相关流程

package com.web.oa.controller;

import java.io.IOException;

import java.io.InputStream;

import java.util.Date;

import java.util.List;

import java.util.Map;

import javax.servlet.ServletOutputStream;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

import org.activiti.engine.repository.Deployment;

import org.activiti.engine.repository.ProcessDefinition;

import org.activiti.engine.task.Comment;

import org.activiti.engine.task.Task;

import org.apache.shiro.SecurityUtils;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.ui.Model;

import org.springframework.ui.ModelMap;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.multipart.MultipartFile;

import org.springframework.web.servlet.ModelAndView;

import com.github.pagehelper.PageHelper;

import com.github.pagehelper.PageInfo;

import com.web.oa.pojo.ActiveUser;

import com.web.oa.pojo.Baoxiaobill;

import com.web.oa.pojo.Employee;

import com.web.oa.service.BaoxiaoBillService;

import com.web.oa.service.WorkFlowService;

import com.web.oa.utils.Constants;

@Controller

public class WorkFlowController {

private static final Integer PAGESIZE = 3; //每页显示的记录条数

@Autowired

private WorkFlowService workFlowService;

@Autowired

private BaoxiaoBillService baoxiaoBillService;

/**

* 部署流程

* @param processName 流程名称

* @param fileName 文件名称

* @return

* @throws IOException

@RequestMapping("deployProcess")

public String deployProcess(String processName,MultipartFile fileName) throws IOException{

System.out.println("部署流程");

//得到要上传的zip的流对象

InputStream is = fileName.getInputStream();

workFlowService.deployment(is,processName);

//部署完了后，自动跳转到查询流程的页面

return "redirect:processDefinitionList";

}

/**

* 查询所有流程信息

* @param model

* @return

@RequestMapping("processDefinitionList")

public String processDefinitionList(Model model){

//查询部署流程信息

List<Deployment> depList = workFlowService.findDeploymentInfo();

//查询流程定义信息

List<ProcessDefinition> pdList = workFlowService.findProcessDefinitionInfo();

model.addAttribute("depList", depList);

model.addAttribute("pdList", pdList);

return "workflow_list";

}

/**

* 根据流程定义id删除流程定义

* @param deploymentId

* @return

@RequestMapping("delDeployment")

public String delDeployment(String deploymentId){

this.workFlowService.deploymentById(deploymentId);

//删除后自动跳转到查看流程

return "redirect:/processDefinitionList";

}

/**

* 报销申请单

* @param baoxiaobill

* @param session

* @return

@RequestMapping("saveStartBaoxiao")

public String saveStartBaoxiao(Baoxiaobill baoxiaobill,HttpSession session){

System.out.println("saveStartBaoxiao");

//封装日期

baoxiaobill.setCreatdate(new Date());

//封装请假状态

baoxiaobill.setState(1);//1：表示审批当中，2：表示审批结束

//封装用户id

//Employee emp = (Employee)session.getAttribute(Constants.GLOBLE_USER_SESSION);

ActiveUser activeUser = (ActiveUser) SecurityUtils.getSubject().getPrincipal();

String id = activeUser.getId()+"";

Integer userid = Integer.parseInt(id);

baoxiaobill.setUserId(userid);

//1、添加一条请假记录到baoxiaobill表中

baoxiaoBillService.addBaoxiaobill(baoxiaobill);

//2、启动流程顺便设置代办人信息

//插入记录成功后，自增长的值自动封装到Baoxiaobill类中id属性中。

long baoxiaoId = baoxiaobill.getId();

workFlowService.startProcess(baoxiaoId,activeUser.getUsername());

//3、上面完成后自动跳转到我的代办事务请求

return "redirect:/myTaskList";

}

/**

* 获得当前用户的任务列表信息

* @param session

* @param model

* @return

@RequestMapping("myTaskList")

public String getTaskList(HttpSession session,Model model){

System.out.println("myTaskList");

//Employee emp = (Employee) session.getAttribute(Constants.GLOBLE_USER_SESSION);

ActiveUser activeUser = (ActiveUser) SecurityUtils.getSubject().getPrincipal();

String username = activeUser.getUsername();

System.out.println("username:"+username);

List<Task> taskList = workFlowService.findTaskListByName(username);

System.out.println("taskList:"+taskList);

model.addAttribute("taskList", taskList);

return "workflow_task"; //这里的才是jsp页面

}

/**

* 查看流程定义图

* @param deploymentId

* @param imageName

* @param response

* @return

* @throws IOException

@RequestMapping("viewImage")

public String viewImage(String deploymentId,String imageName,HttpServletResponse response) throws IOException{

//得到指定资源的输入流对象

InputStream is = this.workFlowService.getImageInputstream(deploymentId,imageName);

System.out.println("is:"+is);

//得到输出流的对象

ServletOutputStream os = response.getOutputStream();

int len=0;

byte[] arr = new byte[1024];

while((len=is.read(arr))!=-1){//还未读完

os.write(arr,0,len);//读取arr，从0开始，到len结束

}

os.close();

is.close();

return null;

}

/**

* 获得流程图和红色框框的参数信息传入viewimage.jsp（得到红色的框框的座标和高度和宽度）

* @param taskId

* @param model

* @return

@RequestMapping("viewCurrentImage")

public String viewCurrentImage(String taskId,ModelMap model){

//1、获得流程图的相关资源信息

ProcessDefinition pd = workFlowService.findProcessDefinitionByProcessKey(Constants.BAOXIAOBILL_KEY);

//获得流程定义id和资源包名称

String deploymentId = pd.getDeploymentId();

String resourceName = pd.getDiagramResourceName();

model.put("deploymentId",deploymentId);

model.put("imageName", resourceName);

System.out.println("imageName:"+resourceName);

//2、得到红色框框的坐标和高度和宽度

Map<String, Object> map = this.workFlowService.findCoordingByTask(taskId);

model.addAttribute("acs", map);

return "viewimage";

}

/**

* 获得流程图和红色框框的参数信息传入viewimage.jsp（得到红色的框框的座标和高度和宽度）

* @param billId

* @param model

* @return

@RequestMapping("viewCurrentImageByBill")

public String viewCurrentImageByBill(String billId,ModelMap model){

System.out.println("id:"+billId);

System.out.println(Constants.BAOXIAOBILL_KEY);

String BUSSINESS_KEY = Constants.BAOXIAOBILL_KEY + "." + billId;

System.out.println("BUSSINESS_KEY:"+BUSSINESS_KEY);

Task task = this.workFlowService.findTaskByBussinessKey(BUSSINESS_KEY);

System.out.println("task:"+task);

//1、获得流程图的相关资源信息

ProcessDefinition pd = workFlowService.findProcessDefinitionByProcessKey(Constants.BAOXIAOBILL_KEY);

System.out.println("pd:"+pd);

//获得流程定义id和资源包名称

String deploymentId = pd.getDeploymentId();

String resourceName = pd.getDiagramResourceName();

System.out.println("deploymentId"+deploymentId);

model.put("deploymentId",deploymentId);

model.put("imageName", resourceName);

System.out.println("imageName:"+ resourceName);

//2、查看当前活动，获取红色框框的坐标和高度和宽度,即当前活动对应的坐标x,y,width,height，将值存到Map<String,Object>中

Map<String, Object> map = this.workFlowService.findCoordingByTask(task.getId());

model.addAttribute("acs", map);

return "viewimage";

}

/**

* 显示出报销单信息和历史批注列表信息

* @param taskId

* @param model

* @return

@RequestMapping("viewTaskForm")

public ModelAndView viewTaskForm(String taskId) {

ModelAndView mv = new ModelAndView();

//通过任务id获得报销单信息

Baoxiaobill baoxiaoBill = baoxiaoBillService.findbaoxiaoBillByTaskId(taskId);

//通过任务id得到历史批注信息列表

List<Comment> commentList = baoxiaoBillService.findCommentList(taskId);

//通过任务id得到往哪条线走的信息

List<String> outcomeList = this.workFlowService.findOutComeListByTaskId(taskId);

//放置到上下文对象中

mv.addObject("baoxiaoBill", baoxiaoBill);

mv.addObject("commentList", commentList);

mv.addObject("outcomeList", outcomeList);

mv.addObject("taskId", taskId);

mv.setViewName("approve_baoxiao");

return mv;

}

/**

* 提交批注信息

* @param id 报销单id

* @param comment 批注信息

* @param taskId 任务id

* @param session

* @return

@RequestMapping("submitTask")

public String submitTask(Long id,String comment,String taskId,String outcome,HttpSession session){

System.out.println("submitTask");

System.out.println("taskid:"+taskId);

//Employee emp = (Employee) session.getAttribute(Constants.GLOBLE_USER_SESSION);

ActiveUser activeUser = (ActiveUser) SecurityUtils.getSubject().getPrincipal();

String username = activeUser.getUsername();

System.out.println("username:"+username);

baoxiaoBillService.addComment(id, taskId, comment, outcome, username);

//提交批注后再次跳转到任务列表页面，刷新数据

return "redirect:/myTaskList";

}

/**

* 查询用户报销单记录

* required = true不能为空，defaultValue = "1"默认值为1

* @param session

* @param model

* @return

@RequestMapping("myBaoxiaoBill")

public String myBaoxiaoBill(Model model,HttpSession session,@RequestParam(value = "pageNo",required = false,defaultValue = "1") Integer pageNo){

//Employee emp = (Employee) session.getAttribute(Constants.GLOBLE_USER_SESSION);

//Long userid = emp.getId();

ActiveUser activeUser = (ActiveUser) SecurityUtils.getSubject().getPrincipal();

Long userid = activeUser.getId();

//根据用户id查询报销单信息

List<Baoxiaobill> baoxiaoList = baoxiaoBillService.findbaoxiaoBillByUserId(pageNo,PAGESIZE,userid);

//封装了分页相关的所有数据

PageInfo<Baoxiaobill> pageInfo = new PageInfo<Baoxiaobill>(baoxiaoList);

System.out.println("baoxiaoList:"+baoxiaoList);

model.addAttribute("baoxiaoList", baoxiaoList);

System.out.println("pageInfo:"+pageInfo);

model.addAttribute("pageInfo", pageInfo);

return "baoxiaobill";

}

/**

* 根据报销单id删除报销记录

* @param id

* @return

@RequestMapping("baoxiaoBillAction_delete")

public String deleteBaoxiaoBillAction(int id){

baoxiaoBillService.deleteBybaoxiaoBillId(id);

return "redirect:/myBaoxiaoBill";

}

/**

* 查看审核记录

* @param id 报销单id

* @param model

* @return

@RequestMapping("viewHisComment")

public String viewHisComment(Long id,Model model){

//1、根据报销单id，查看报销单对象

Baoxiaobill baoxiaoBill = baoxiaoBillService.fingBaoxiaoBillById(id);

model.addAttribute("baoxiaoBill", baoxiaoBill);

//2、根据报销单id，查看历史批注信息

List<Comment> comments = workFlowService.findCommentByBaoxiaoBillId(id);

model.addAttribute("commentList", comments);

return "workflow_commentlist";

}

五、EmployeeController控制器类方法：实现对应功能

package com.web.oa.controller;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.UUID;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpSession;

import org.apache.log4j.chainsaw.Main;

import org.apache.shiro.SecurityUtils;

import org.apache.shiro.authc.IncorrectCredentialsException;

import org.apache.shiro.authc.UnknownAccountException;

import org.apache.shiro.subject.Subject;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.ui.Model;

import org.springframework.ui.ModelMap;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.ResponseBody;

import org.springframework.web.servlet.ModelAndView;

import com.web.oa.utils.Constants;

import com.web.oa.mapper.EmployeeCustomMapper;

import com.web.oa.mapper.RoleMapper;

import com.web.oa.mapper.SysPermissionCustomMapper;

import com.web.oa.pojo.ActiveUser;

import com.web.oa.pojo.Employee;

import com.web.oa.pojo.EmployeeCustom;

import com.web.oa.pojo.Permission;

import com.web.oa.pojo.Role;

import com.web.oa.pojo.RolePermission;

import com.web.oa.pojo.TreeMenu;

import com.web.oa.pojo.UserRole;

import com.web.oa.service.EmployeeService;

import oracle.net.aso.p;

/**

* 控制器类

* @author A

@Controller

public class EmployeeController {

@Autowired

private SysPermissionCustomMapper sysPermissionCustomMapper;

@Autowired

private EmployeeService employeeService;

@Autowired

private RoleMapper roleMapper;

// /**

// * shiro：123加密2次为1753810a48cf8a8a2e70a9b036fd4c89

// * @param username

// * @param password

// * @param session

// * @param model

// * @return

// */

// @RequestMapping(value="login",method = RequestMethod.POST)

// public String login(String username,String password,HttpSession session,Model model){

// Employee employee = employeeService.findEmployeeByName(username);

// if(employee!=null){

// if(employee.getPassword().equals(password)){//账号密码匹配正确，保存当前用户信息在session中

// session.setAttribute(Constants.GLOBLE_USER_SESSION, employee);

// List<TreeMenu> list = sysPermissionCustomMapper.findMenuList();

// ActiveUser activeUser = new ActiveUser();

// activeUser.setMenuTree(list);

// model.addAttribute("activeUser", activeUser);

// return "index";

// }else {

// model.addAttribute("errorMsg", "密码错误");

// return "login";

// }

// }else {

// // 用户名不存在

// model.addAttribute("errorMsg", "用户名不存在");

// return "login";

// }

@RequestMapping("/login")

public String login(HttpServletRequest request,Model model){

//得到错误信息

String exceptionName = (String) request.getAttribute("shiroLoginFailure");

if (exceptionName != null) {

if (UnknownAccountException.class.getName().equals(exceptionName)) {

model.addAttribute("errorMsg", "用户账号不存在");

} else if (IncorrectCredentialsException.class.getName().equals(exceptionName)) {

model.addAttribute("errorMsg", "密码不正确");

} else if("randomcodeError".equals(exceptionName)) {

model.addAttribute("errorMsg", "验证码不正确");

}

else {

model.addAttribute("errorMsg", "未知错误");

}

return "login";

}

@RequestMapping("main")

public String main(ModelMap model){

//认证通过后，取出身份信息（包含了用户和菜单的信息）

// Subject subject = SecurityUtils.getSubject();

// ActiveUser activeUser = (ActiveUser) subject.getPrincipal();

ActiveUser activeUser = (ActiveUser) SecurityUtils.getSubject().getPrincipal();

model.addAttribute("activeUser", activeUser);

return "index";

}

/**

* 注销

* @param session

* @return

//已使用shiro配置

// @RequestMapping("logout")

// public String logout(HttpSession session){

// //清空session缓存的数据

// session.invalidate();

// return "login";

// }

/**

* 新建用户

* @param name

* @param password

* @param email

* @param role

* @param managerId

* @return

@RequestMapping("saveUser")

public String saveUser(String name,String password,String email,int role,Long managerId){

employeeService.saveEmployee(name,password,email,role,managerId);

// Long emId = employeeService.findUserIdByName(name);

// System.out.println("emid:"+emId);

employeeService.saveUserRole(name,role);

return "redirect:/findUserList";

}

/**

* 用户管理页面

* 查询用户信息

* @return

@RequestMapping("findUserList")

public ModelAndView findUserList(String userId) {

ModelAndView mv = new ModelAndView();

List<Role> allRoles = employeeService.findAllRoles();

List<EmployeeCustom> list = employeeService.findUserAndRoleList();

mv.addObject("userList", list);

mv.addObject("allRoles", allRoles);

mv.setViewName("userlist");

return mv;

}

/**

* 添加角色

* @param model

* @return

@RequestMapping("toAddRole")

public String findRoles(Model model){

List<TreeMenu> permissions = employeeService.findAllPermission();

System.out.println("permissions:"+permissions);

model.addAttribute("allPermissions", permissions);

List<Permission> menuTypes = employeeService.findAllMenu();

System.out.println("menuTypes:"+menuTypes);

model.addAttribute("menuTypes", menuTypes);

return "rolelist";

}

/**

* 根据员工级别查找下一级别主管

* 此次直接返回结果，否则会刷新传不过去数据

* @param managerId

* @return

@RequestMapping("findNextManager")

@ResponseBody

public List<Employee> findNextManager(int level){

//普通员工开始查，普通员工为1，则上级为2

level++;

System.out.println("level:"+level);

List<Employee> managerList = employeeService.findNextManager(level);

return managerList;

}

/**

* 根据用户名查看角色和权限

* @param userName

* @return

@RequestMapping(value = "viewPermissionByUser",method = RequestMethod.POST)

@ResponseBody

public Role viewPermissionByUser(String userName){

System.out.println("viewPermissionByUser");

// Map<String,Object> map = new HashMap<>();

// List<Employee> role = employeeService.findRoleByUser(userName);

// System.out.println("role:"+role);

// System.out.println("roleid:"+role.get(0).getRole());

// List<RolePermission> rolePermissionList = employeeService.findRoleAndPermissionByUser(role.get(0).getRole());

// System.out.println("rolePermissionList:"+rolePermissionList);

// System.out.println("permissionid:"+rolePermissionList.get(0).getSysPermissionId());

// Permission permissions = employeeService.findPermissionByPermissionid(rolePermissionList.get(0).getSysPermissionId());

List<Role> role = employeeService.findRoleAndPermissionListByUserId(userName);

System.out.println("userName:"+userName);

System.out.println("role:"+role);

System.out.println(role.get(0).getName()+"," +role.get(0).getPermissionList());

return role.get(0);

}

/**

* 用户列表重新分配权限

* @param roleId

* @param userId

* @return

@RequestMapping("assignRole")

@ResponseBody

public Map<String, String> assignRole(String roleId,String userId){

Map<String, String> map = new HashMap<>();

try{

employeeService.updateEmployeeRole(roleId,userId);

map.put("msg", "分配权限成功");

}catch(Exception e){

e.printStackTrace();

map.put("msg", "分配权限失败");

}

return map;

}

/**

* 保存角色和权限关系

* @param role

* @param permissionIds

* @return

@RequestMapping("saveRoleAndPermissions")

public String saveRoleAndPermissions(Role role,int[] permissionIds){

//设置role主键，使用uuid

String uuid = UUID.randomUUID().toString();

role.setId(uuid);

//默认可用

role.setAvailable("1");

employeeService.addRoleAndPermissions(role,permissionIds);

return "redirect:/toAddRole";

}

/**

* 新建权限

* @param model

* @param name

* @param type

* @param url

* @param percode

* @param parentid

* @param available

* @return

@RequestMapping("saveSubmitPermission")

public String saveSubmitPermission(Permission permission){

System.out.println("saveSubmitPermission");

if (permission.getAvailable() == null) {

permission.setAvailable("0");

}

employeeService.addPermission(permission);

return "redirect:/toAddRole";

}

/**

* 角色列表

@RequestMapping("findRoles")

public String findRole(Model model){

List<Role> allRoles = employeeService.findAllRoles();

model.addAttribute("allRoles", allRoles);

List<TreeMenu> allPermission = employeeService.findAllPermission();

System.out.println("allPermission:"+allPermission);

model.addAttribute("allMenuAndPermissions", allPermission);

return "permissionlist";

}

/**

* 根据角色id查询该角色的权限

* @param roleId

* @return

@RequestMapping("loadMyPermissions")

@ResponseBody

public List<Permission> loadMyPermissions(String roleId){

System.out.println("loadMyPermissions");

List<Permission> permissionList = employeeService.findPermissionListByRoleId(roleId);

System.out.println("permissionList:"+permissionList);

return permissionList;

}

/**

* 修改角色与权限的中间表

* @param roleId

* @param permissionIds

@RequestMapping("updateRoleAndPermission")

public String updateRoleAndPermission(String roleId,int[] permissionIds){

System.out.println("updateRoleAndPermission");

System.out.println("permissionIds:"+permissionIds);

employeeService.updateRoleAndPermission(roleId,permissionIds);

return "redirect:/findRoles";

}

/**

* 删除（修改Available为0）

* @param roleid

* @return

@RequestMapping("deleteRole")

public String deleteRole(String roleid){

System.out.println("roleid:"+roleid);

employeeService.deleteRole(roleid);

return "redirect:/findRoles";

}

momopeng～

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
基于ssm+shiro+activiti的办公自动化系统

基于ssm+shiro+activiti的办公自动化系统的实现效果
复制链接

扫一扫

基于ssm+shiro+activiti的办公自动化系统

“相关推荐”对你有帮助么？