org.apache.shiro.authz.annotation.RequiresRoles Java Examples

/**
  * 批量删除菜单
 * @param ids
 * @return
 */
@RequiresRoles({ "admin" })
@RequestMapping(value = "/deleteBatch", method = RequestMethod.DELETE)
public Result<SysPermission> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
	Result<SysPermission> result = new Result<>();
	try {
           String[] arr = ids.split(",");
		for (String id : arr) {
			if (oConvertUtils.isNotEmpty(id)) {
				sysPermissionService.deletePermission(id);
			}
		}
		result.success("删除成功!");
	} catch (Exception e) {
		log.error(e.getMessage(), e);
		result.error500("删除成功!");
	}
	return result;
}
 

@RequiresRoles("admin")
@RequestMapping(value = "create", method = RequestMethod.POST)
public String create(@Valid Menu menu, BindingResult result, Model model,
        RedirectAttributes redirectAttributes) {
    if (result.hasErrors()) {
        Menu topMenu = accountService.getTopMenu();
        menu.setParent(topMenu);

        model.addAttribute("menu", menu);
        model.addAttribute("allShows", allShows);
        model.addAttribute("action", "create");

        return "account/menuForm";
    }
    generateMenuParentIds(menu);
    accountService.saveMenu(menu);
    redirectAttributes.addFlashAttribute("message", "创建菜单成功");

    return "redirect:/account/menu";
}
 

/**
 * 暂停定时任务
 * 
 * @param jobClassName
 * @return
 */
@RequiresRoles("admin")
@GetMapping(value = "/pause")
@ApiOperation(value = "暂停定时任务")
public Result<Object> pauseJob(@RequestParam(name = "jobClassName", required = true) String jobClassName) {
	QuartzJob job = null;
	try {
		job = quartzJobService.getOne(new LambdaQueryWrapper<QuartzJob>().eq(QuartzJob::getJobClassName, jobClassName));
		if (job == null) {
			return Result.error("定时任务不存在！");
		}
		scheduler.pauseJob(JobKey.jobKey(jobClassName.trim()));
	} catch (SchedulerException e) {
		throw new JeecgBootException("暂停定时任务失败");
	}
	job.setStatus(CommonConstant.STATUS_DISABLE);
	quartzJobService.updateById(job);
	return Result.ok("暂停定时任务成功");
}
 

/**
 * 编辑用户
 *
 * @param userVo
 * @return
 */
@RequiresRoles("admin")
@PostMapping("/edit")
@ResponseBody
public Object edit(@Valid UserVo userVo) {
    List<User> list = userService.selectByLoginName(userVo);
    if (list != null && !list.isEmpty()) {
        return renderError("登录名已存在!");
    }
    // 更新密码
    if (StringUtils.isNotBlank(userVo.getPassword())) {
        User user = userService.selectById(userVo.getId());
        String salt = user.getSalt();
        String pwd = passwordHash.toHex(userVo.getPassword(), salt);
        userVo.setPassword(pwd);
    }
    userService.updateByVo(userVo);
    return renderSuccess("修改成功！");
}
 

@RequiresRoles("admin")
@RequestMapping(value = "update", method = RequestMethod.POST)
public String update(@Valid Menu menu, BindingResult result, Model model,
        RedirectAttributes redirectAttributes) {
    if (result.hasErrors()) {
        menu.setParent(accountService.getMenu(menu.getParentId()));

        model.addAttribute("menu", menu);
        model.addAttribute("allShows", allShows);
        model.addAttribute("action", "update");

        return "account/menuForm";
    }

    generateMenuParentIds(menu);
    accountService.saveMenu(menu);

    resetUserMenu();
    redirectAttributes.addFlashAttribute("message", "保存菜单成功");

    return "redirect:/account/menu";
}
 

@RequiresRoles("admin")
@RequestMapping(value = "delete/{id}")
public String delete(@PathVariable("id") Long id, RedirectAttributes redirectAttributes) {
    if (id == 0) {//顶级菜单
        redirectAttributes.addFlashAttribute("message", "删除菜单失败，顶级菜单不能删除");
        redirectAttributes.addFlashAttribute("success", false);
    }

    List<Role> roles = accountService.getRoleByMenuID(id);
    if (roles == null || roles.size() == 0) {
        accountService.deleteMenu(id);
        redirectAttributes.addFlashAttribute("message", "删除菜单成功");
        redirectAttributes.addFlashAttribute("success", true);
    } else {
        redirectAttributes.addFlashAttribute("message", "删除菜单失败，请先删除该菜单使用的角色，再删除菜单");
        redirectAttributes.addFlashAttribute("success", false);
    }
    return "redirect:/account/menu";
}
 

/**
 *  增加配置，需要管理员权限
 * @param blog
 * @return
 */
@RequiresRoles(Roles.ADMIN)
public long add(Blog blog) {
    // 参数校验
    notNull(blog, "param.is.null");
    notEmpty(blog.getTitle(), "name.is.null");
    notEmpty(blog.getBody(), "value.is.null");

    // 校验通过后打印重要的日志
    log.info("add blog:" + blog);

    // 校验重复
    check(null == dao.findByTitle(blog.getTitle()), "name.repeat");

    blog = dao.save(blog);

    // 修改操作需要打印操作结果
    log.info("add blog success, id:" + blog.getId());

    return blog.getId();
}
 

@RequiresRoles("role:root")
@PostMapping("/save")
@BussinessLog("修改系统配置")
public ResponseVO save(@RequestParam Map<String, String> configs,
                       @RequestParam(required = false) MultipartFile wxPraiseCode,
                       @RequestParam(required = false) MultipartFile zfbPraiseCode) {
    try {
        sysConfigService.saveConfig(configs);
        sysConfigService.saveFile("wxPraiseCode", wxPraiseCode);
        sysConfigService.saveFile("zfbPraiseCode", zfbPraiseCode);
    } catch (Exception e) {
        e.printStackTrace();
        return ResultUtil.error("系统配置修改失败");
    }
    return ResultUtil.success("系统配置修改成功");
}
 

/**
 * 保存角色授权
 * 
 * @return
 */
@RequestMapping(value = "/saveRolePermission", method = RequestMethod.POST)
@RequiresRoles({ "admin" })
public Result<String> saveRolePermission(@RequestBody JSONObject json) {
	long start = System.currentTimeMillis();
	Result<String> result = new Result<>();
	try {
		String roleId = json.getString("roleId");
		String permissionIds = json.getString("permissionIds");
		String lastPermissionIds = json.getString("lastpermissionIds");
		this.sysRolePermissionService.saveRolePermission(roleId, permissionIds, lastPermissionIds);
		result.success("保存成功！");
		log.info("======角色授权成功=====耗时:" + (System.currentTimeMillis() - start) + "毫秒");
	} catch (Exception e) {
		result.error500("授权失败！");
		log.error(e.getMessage(), e);
	}
	return result;
}
 

/**
 *  增加配置，需要管理员权限
 * @param config
 * @return
 */
@RequiresRoles(Roles.ADMIN)
public long add(Config config) {
    // 参数校验
    notNull(config, "param.is.null");
    notEmpty(config.getName(), "name.is.null");
    notEmpty(config.getValue(), "value.is.null");

    // 校验通过后打印重要的日志
    log.info("add config:" + config);

    // 校验重复
    check(null == dao.findByName(config.getName()), "name.repeat");

    config = dao.save(config);

    // 修改操作需要打印操作结果
    log.info("add config success, id:" + config.getId());

    return config.getId();
}
 

/**
 * 保存部门授权
 *
 * @return
 */
@RequestMapping(value = "/saveDepartPermission", method = RequestMethod.POST)
@RequiresRoles({ "admin" })
public Result<String> saveDepartPermission(@RequestBody JSONObject json) {
	long start = System.currentTimeMillis();
	Result<String> result = new Result<>();
	try {
		String departId = json.getString("departId");
		String permissionIds = json.getString("permissionIds");
		String lastPermissionIds = json.getString("lastpermissionIds");
		this.sysDepartPermissionService.saveDepartPermission(departId, permissionIds, lastPermissionIds);
		result.success("保存成功！");
		log.info("======部门授权成功=====耗时:" + (System.currentTimeMillis() - start) + "毫秒");
	} catch (Exception e) {
		result.error500("授权失败！");
		log.error(e.getMessage(), e);
	}
	return result;
}
 

/**
 *  修改密码
 * @param id
 * @param password
 */
//FIXME why not work？？！！
@RequiresRoles(Roles.ADMIN)
public void updatePwd(long id, String password) {
       User user = userDao.findOne(id);

       check(user != null , "id.error", id);
       check(checkPwd(password), "password.invalid");

       // FIXME
       log.info("modify password, user id: " + id + ", password:" + password);

       // 生成新密码
       String hash = PasswordUtil.renewPassword(password, user.getSalt());

       user.setPassword(hash);

       userDao.save(user);
   }
 

@RequiresRoles("admin")
@RequestMapping(value = "create", method = RequestMethod.POST)
public String create(@Valid User user, BindingResult result,
        @RequestParam(value = "roleList") List<Long> checkedRoleList, Model model,
        RedirectAttributes redirectAttributes) {
    if (result.hasErrors()) {
        List<Role> roles = accountService.getAllRole();
        model.addAttribute("action", "create");
        model.addAttribute("allRoles", roles);
        model.addAttribute("allStatus", allStatus);
        return "account/userForm";
    }

    // bind roleList
    user.getRoleList().clear();
    for (Long roleId : checkedRoleList) {
        Role role = new Role(roleId);
        user.getRoleList().add(role);
    }

    accountService.saveUser(user);
    redirectAttributes.addFlashAttribute("message", "创建用户成功");
    return "redirect:/account/user";
}
 

/**
  * 批量删除菜单
 * @param ids
 * @return
 */
@RequiresRoles({ "admin" })
@RequestMapping(value = "/deleteBatch", method = RequestMethod.DELETE)
public Result<SysPermission> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
	Result<SysPermission> result = new Result<>();
	try {
           String[] arr = ids.split(",");
		for (String id : arr) {
			if (oConvertUtils.isNotEmpty(id)) {
				sysPermissionService.deletePermission(id);
			}
		}
		result.success("删除成功!");
	} catch (Exception e) {
		log.error(e.getMessage(), e);
		result.error500("删除成功!");
	}
	return result;
}
 

/**
 * 保存角色授权
 * 
 * @return
 */
@RequestMapping(value = "/saveRolePermission", method = RequestMethod.POST)
@RequiresRoles({ "admin" })
public Result<String> saveRolePermission(@RequestBody JSONObject json) {
	long start = System.currentTimeMillis();
	Result<String> result = new Result<>();
	try {
		String roleId = json.getString("roleId");
		String permissionIds = json.getString("permissionIds");
		String lastPermissionIds = json.getString("lastpermissionIds");
		this.sysRolePermissionService.saveRolePermission(roleId, permissionIds, lastPermissionIds);
		result.success("保存成功！");
		log.info("======角色授权成功=====耗时:" + (System.currentTimeMillis() - start) + "毫秒");
	} catch (Exception e) {
		result.error500("授权失败！");
		log.error(e.getMessage(), e);
	}
	return result;
}
 

private static AuthorizingAnnotationHandler createHandler(Annotation annotation) {
    Class<?> t = annotation.annotationType();
    if (RequiresPermissions.class.equals(t)) return new PermissionAnnotationHandler();
    else if (RequiresRoles.class.equals(t)) return new RoleAnnotationHandler();
    else if (RequiresUser.class.equals(t)) return new UserAnnotationHandler();
    else if (RequiresGuest.class.equals(t)) return new GuestAnnotationHandler();
    else if (RequiresAuthentication.class.equals(t)) return new AuthenticatedAnnotationHandler();
    else throw new IllegalArgumentException("Cannot create a handler for the unknown for annotation " + t);
}
 

@RequiresRoles("admin")
@RequestMapping(value = "create", method = RequestMethod.GET)
public String createForm(Model model) {
    Menu topMenu = accountService.getTopMenu();
    Menu initMenu = new Menu();
    initMenu.setParent(topMenu);

    model.addAttribute("menu", initMenu);
    model.addAttribute("allShows", allShows);
    model.addAttribute("action", "create");

    return "account/menuForm";
}
 

@RequiresRoles("admin")
@RequestMapping(value = "")
public String list(@RequestParam(value = "page", defaultValue = "1") int pageNumber,
        Model model, ServletRequest request) {

    Map<String, Object> searchParams = Servlets.getParametersStartingWith(request, "search_");
    Page<User> users = accountService.searchUser(searchParams, pageNumber, Const.PAGE_SIZE);
    for (User user : users) {
        user.setRoleList(accountService.getRoleByUserID(user.getId()));
    }

    model.addAttribute("users", users);
    model.addAttribute("allStatus", allStatus);
    return "account/userList";
}
 

@GET
@Produces(MediaType.TEXT_PLAIN)
@Path("/admin")
@RequiresRoles("admin")
public String admin() {
    return "Welcome Admin";
}
 

@RequiresRoles("admin")
@RequestMapping(value = "update/{id}", method = RequestMethod.GET)
public String updateForm(@PathVariable("id") Long id, Model model) {
    User user = accountService.getUser(id);
    List<Role> roles = accountService.getRoleByUserID(id);
    user.setRoleList(roles);

    model.addAttribute("action", "update");
    model.addAttribute("user", user);
    model.addAttribute("allStatus", allStatus);

    model.addAttribute("roleList", roles);
    model.addAttribute("allRoles", accountService.getAllRole());
    return "account/userForm";
}
 

@RequiresRoles("admin")
@RequestMapping(value = "delete/{id}")
public String delete(@PathVariable("id") Long id, RedirectAttributes redirectAttributes) {
    if (id == null || id == 1L) {
        redirectAttributes.addFlashAttribute("message", "删除用户失败，管理员不能删除");
    } else {
        accountService.deleteUser(id);
        redirectAttributes.addFlashAttribute("message", "删除用户成功");
    }
    return "redirect:/account/user";
}
 

@RequiresRoles(value={"blogger","administrator"},logical = Logical.OR)
@RequestMapping("/checkUserList")
private String checkUserList(UserQueryVo userQueryVo, Model model) {
    List<UserCustom> userList = userService.getUserList(userQueryVo);
    model.addAttribute("userList", userList);
    return "admin/userList";
}
 

@RequiresRoles("blogger")
@RequestMapping(value = "/submit",method = RequestMethod.POST)
public String submit(Blog blog, Model model) {
    blogService.insertBlog(blog);
    //blogService.getBlogByTitle(blog.getTitle());
    //blogService.updateAlterTime(blog.getId(),blog);
    return "redirect:/";
}
 

@RequiresRoles(value = "admin")
@RequestMapping(value = { "", "list" })
public String list(Model model, ServletRequest request) {
    Map<String, Object> searchParams = Servlets.getParametersStartingWith(request, "search_");

    List<Menu> sortedMenus = Lists.newArrayList();
    List<Menu> allMenus = accountService.searchMenu(searchParams);
    Menu.sortList(sortedMenus, allMenus, 1L);

    model.addAttribute("menus", sortedMenus);
    model.addAttribute("allShows", allShows);
    return "account/menuList";
}
 

/**
 * 授权
 *
 * @param id
 * @param resourceIds
 * @return
 */
@RequiresRoles("admin")
@RequestMapping("/grant")
@ResponseBody
public Object grant(Long id, String resourceIds) {
    roleService.updateRoleResource(id, resourceIds);
    return renderSuccess("授权成功！");
}
 

/**
 * 删除用户
 *
 * @param id
 * @return
 */
@RequiresRoles("admin")
@PostMapping("/delete")
@ResponseBody
public Object delete(Long id) {
    Long currentUserId = getUserId();
    if (id == currentUserId) {
        return renderError("不可以删除自己！");
    }
    userService.deleteUserById(id);
    return renderSuccess("删除成功！");
}
 

@RequiresRoles(value = "admin")
@RequestMapping(value = { "", "list" })
public String list(@RequestParam(value = "page", defaultValue = "1") int pageNumber,
        Model model, ServletRequest request) {

    Map<String, Object> searchParams = Servlets.getParametersStartingWith(request, "search_");

    Page<Role> roles = accountService.searchRoles(searchParams, pageNumber, Const.PAGE_SIZE);

    model.addAttribute("roles", roles);
    model.addAttribute("searchParams",
            Servlets.encodeParameterStringWithPrefix(searchParams, "search_"));
    return "account/roleList";
}
 

@RequiresRoles("admin")
@RequestMapping(value = "create", method = RequestMethod.GET)
public String createForm(Model model) {
    List<Menu> menus = accountService.getAllMenu();
    model.addAttribute("role", new Role());
    model.addAttribute("action", "create");
    model.addAttribute("allMenus", menus);
    return "account/roleForm";
}
 

@RequestMapping(value = "/admin/list")
@RequiresRoles("admin")
public String getUserList(@RequestParam(defaultValue="1")Integer page, @RequestParam(defaultValue="10")Integer rows, String adminname, Model model) {

    Page<Admin> admins = adminService.findAdminList(page, rows, adminname);
    model.addAttribute("page", admins);
    model.addAttribute("adminname", adminname);
    return "adminManage";
}
 

@Override
@RequestMapping("/roleauth")
@RequiresRoles("admin_sys")
@RequiresPermissions(value={"sys:user:roleauth"})
public String roleauth(@RequestBody Map<String, Object> sys) {
    List<SysRole> sysRoles = JSON.parseObject(String.valueOf(JSON.toJSON(sys.get("sysRoles"))), new TypeReference<List<SysRole>>() {});
    String userid= (String) sys.get("userid");
    int result=sysUserService.roleauth(sysRoles,userid);
    if(result>0) {
        return JSON.toJSONString ("true");
    }else{
        return JSON.toJSONString ("false");
    }
}