基于 SpringBoot 开发的疫情防控管理系统！

原创

终码一生 2022-01-24 13:21:01 ©著作权

文章标签 用户名分页 ico 文章分类 Java 后端开发

©著作权归作者所有：来自51CTO博客作者终码一生的原创作品，请联系作者获取转载授权，否则将追究法律责任

点击“终码一生”，关注，置顶公众号，每日技术干货，第一时间送达！

项目介绍：通过对依社区为单位进行人群的管理，以及疫苗的情况，包括小区状况，通过RBAC进行角色与用户之间的权限管理。

项目：环境IDEA、Mysql数据库，Tomcat服务器，SpringMVC，SpringBoot，AOP，拦截器，过滤器，全局异常，RBAC权限控制等。

1、主要模块

1、登录模块(注册）

核心代码：service层

@Service

public class UserService extends BaseService<User,Integer> {

@Resource

//引入dao层

private UserMapper userMapper;

@Resource

private UserRoleMapper userRoleMapper;

@Resource

private CommunityMapper communityMapper;

//用户登录

public UserModel userLogin(String userName,String userPwd){

//对输入的账号密ma进行判断，是否符合格式


checkUserLoginParam(userName,userPwd);

//通过对数据库的查询，查看用户是否存在

        User temp =
userMapper.queryUserByUserName(userName);

        AssertUtil.isTrue(temp ==
null,"用户不存在");

//判断用户的密ma是否正确，拿数据库查询到的用户密ma和用户输入的用户密ma进行equest比较


checkUserPwd(userPwd,temp.getUserPwd());

//返回目标对象对密ma进行加密

return builderUserInfo(temp);

    }

/**

     * //对输入的账号密ma进行判断
是否符合格式

     * @param userName 账号

     * @param userPwd 密ma

     */

//对输入的账号密ma进行判断，是否符合格式

private void checkUserLoginParam(String userName, String userPwd) {

//用户非空


AssertUtil.isTrue(StringUtils.isBlank(userName),"用户名不能为空");

//密ma非空


AssertUtil.isTrue(StringUtils.isBlank(userPwd),"密ma不能为空");

    }

/**

     * //判断密ma是否正确

     * @param userPwd 用户输入的密ma

     * @param userPwd1 数据库查出来的密ma

     */

//判断用户的密ma是否正确，拿数据库查询到的用户密ma和用户输入的用户密ma进行equest比较

private void checkUserPwd(String userPwd, String userPwd1) {

//对用户输入的密ma进行加密

        userPwd =
Md5Util.encode(userPwd);


AssertUtil.isTrue(!(userPwd.equals(userPwd1)),"密ma不正确");

    }

/**

     *

     * @param temp 当前登录对象

     * @return

     */

//对密ma进行加密返回目标对象

private UserModel builderUserInfo(User temp) {

        UserModel userModel = new
UserModel();

//为用户密ma进行加密


userModel.setUserIdStr(UserIDBase64.encoderUserID(temp.getId()));


userModel.setUserName(temp.getUserName());


userModel.setTrueName(temp.getTrueName());

return userModel;

    }

/**

     *

     * @param userId 当前Cookie存储的用户dId

     * @param oldPassword 旧密ma

     * @param newPassword 新密ma

     * @param confirmPassword 确认密ma

     */

//修改密ma

@Transactional(propagation = Propagation.REQUIRED)

public void updateUserPassword(Integer userId, String oldPassword, String
newPassword, String confirmPassword) {

//通过Id获取user对象

        User user =
userMapper.selectByPrimaryKey(userId);

//参数校验 (用户，旧密ma，新密ma，确认密ma)


checkPasswordParams(user,oldPassword,newPassword,confirmPassword);

//默认参数设置，把用户输入的新密ma 加密添加进去


user.setUserPwd(Md5Util.encode(newPassword));

//执行更新操作

        AssertUtil.isTrue(userMapper.updateByPrimaryKeySelective(user)<1,"修改密ma失败");

    }

//修改密ma的参数校验

private void checkPasswordParams(User user, String oldPassword, String
newPassword, String confirmPwd) {

//用户不能为空（不存在）

        AssertUtil.isTrue(null ==
user,"用户不存在");

//原始密ma 非空


System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");


AssertUtil.isTrue(StringUtils.isBlank(oldPassword),"原始密ma不能为空");

//原始密ma是否和数据库查询到的密ma一致


AssertUtil.isTrue(!(Md5Util.encode(oldPassword).equals(user.getUserPwd())),"原始密ma不正确");

//新密ma不能为空


AssertUtil.isTrue(StringUtils.isBlank(newPassword),"新密ma不能为空");

//新密ma和原始密ma不能相同


AssertUtil.isTrue(oldPassword.equals(newPassword),"新密ma不能和原始密ma相同");

//确认密ma非空


AssertUtil.isTrue(StringUtils.isBlank(confirmPwd),"确认密ma不能为空");

//确认密ma需要和新密ma一致


AssertUtil.isTrue(!(newPassword.equals(confirmPwd)),"新密ma和确认密ma不一致");

    }

/**

     * 多条件分页查询用户数据

     * @param query

     * @return

     */

public Map<String, Object> queryUserByParams (UserQuery query) {

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


PageHelper.startPage(query.getPage(), query.getLimit());

        PageInfo<User> pageInfo =
new PageInfo<>(userMapper.selectByParams(query));

        map.put("code",0);

        map.put("msg",
"");

        map.put("count",
pageInfo.getTotal());

        map.put("data",
pageInfo.getList());

        System.out.println("执行完毕");

return map;

    }

/**

     * 添加用户

     * @param user

     */

@Transactional(propagation = Propagation.REQUIRED)

public void saveUser(User user){

//参数校验

        checkParams(user.getUserName(),user.getComId(),user.getVc());

//设置默认参数

        user.setCreateDate(new Date());

        user.setUpdateDate(new Date());


user.setUserPwd(Md5Util.encode("123456"));

//执行添加，判断结果


AssertUtil.isTrue(userMapper.insertSelective(user)==null,"用户添加失败！");


relaionUserRole(user.getId(),user.getRoleIds());


AssertUtil.isTrue(communityMapper.addNumByComId(user.getComId())<1,
"社区用户添加失败");

    }

/**

     * 用户更新，修改

     * @param user

     */

@Transactional(propagation = Propagation.REQUIRED)

public void updateUser(User user){

//1.参数校验

//通过用户id获取用户对象

        User
temp=userMapper.selectByPrimaryKey(user.getId());

//判断对象是否存在


AssertUtil.isTrue(temp==null,"待更新记录不存在");

//验证参数

        checkParams1(user.getUserName(),user.getComId(),user.getVc());

//2.设置默认参数

        user.setUpdateDate(new Date());

//3.执行更新，返回结果


AssertUtil.isTrue(userMapper.updateByPrimaryKeySelective(user)<1,"用户更新失败！");


relaionUserRole(user.getId(),user.getRoleIds());

    }

private void checkParams(String userName, Integer comId, Integer vc) {


AssertUtil.isTrue(StringUtils.isBlank(userName),"用户名不能为空");

//验证用户是否存在

        User
temp=userMapper.queryUserByUserName(userName);


AssertUtil.isTrue(temp!=null,"用户名已存在");

        AssertUtil.isTrue(comId==null,"请输入所在社区");

        AssertUtil.isTrue(vc==null,"请选择疫苗接种状况");

    }

private void checkParams1(String userName, Integer comId, Integer vc) {


AssertUtil.isTrue(StringUtils.isBlank(userName),"用户名不能为空");

//验证用户是否存在

        AssertUtil.isTrue(comId==null,"请输入所在社区");

        AssertUtil.isTrue(vc==null,"请选择疫苗接种状况");

    }

@Transactional(propagation = Propagation.REQUIRED)

public void deleteUser(Integer[] ids){


AssertUtil.isTrue(ids==null||ids.length==0,"请选择您要删除的记录");

for (int id:ids){

            User
user=userMapper.selectByPrimaryKey(id);


AssertUtil.isTrue(communityMapper.subNumByComId(user.getComId())!=ids.length,
"社区用户删除失败");

        }


AssertUtil.isTrue(deleteBatch(ids) != ids.length,"用户角色删除失败");

    }

/*SZC*/

/**

     * 用户注册

     * @param userName

     * @param password1

     * @param password2

     * @param icon

     */

public void registerUser(String userName, String password1, String password2,
String icon) {

// 参数校验

        checkRegister(userName,
password1, password2, icon);

// 实例化user

        User user = new User();

//设置默认参数

        user.setUserName(userName);


user.setUserPwd(Md5Util.encode(password1));

        user.setUserPhone(icon);

        user.setCreateDate(new Date());

       user.setUpdateDate(new Date());

// 执行方法


AssertUtil.isTrue(userMapper.insertSelective(user)<1, "用户添加失败");

    }

/**

     * 用户注册的参数校验

     * @param userName

     * @param password1

     * @param password2

     * @param icon

     */

private void checkRegister(String userName, String password1, String password2,
String icon) {

// 用户名不为空


AssertUtil.isTrue(StringUtils.isBlank(userName), "请输入用户名");

// 判断用户名是否存在

        User user1 =
userMapper.selectByName(userName);

        AssertUtil.isTrue(user1!=null,
"该用户已存在");

// 判断手机号是否存在

        User user2 =
userMapper.selectByPhone(icon);

        AssertUtil.isTrue(user2!=null,
"该手机号已注册过账号");

// 密ma不为空


AssertUtil.isTrue(StringUtils.isBlank(password1), "请输入密ma");

// 确认密ma不为空

        AssertUtil.isTrue(StringUtils.isBlank(password2),
"请输入确认密ma");

// 密ma长度校验


AssertUtil.isTrue(password1.length()<6 || password1.length()>12,
"密ma长度为6-12位");

// 密ma和确认密ma相等


AssertUtil.isTrue(!password1.equals(password2), "确认密ma与密ma不一致");

// 手机号合法

        AssertUtil.isTrue(!PhoneUtil.isMobile(icon),
"请输入正确的手机号");

    }

/**

     * 删除用户原先的角色，并重新赋予新的角色

     * @param userId

     * @param roleIds

     */

private void relaionUserRole(int userId, String roleIds) {

// 通过id获取用户的角色数量

        int count =
userRoleMapper.countUserRoleByUserId(userId);

// count>0 说明用户原先有角色先删除所有的角色

if (count>0) {


AssertUtil.isTrue(userRoleMapper.deleteUserRoleByUserId(userId)!=count,
"用户角色删除失败");

        }

// 传入的角色信息不为空添加新的角色

if (StringUtils.isNoneBlank(roleIds)) {

// 将传入的roleIds转成字符串数组

String[] roleStrIds = roleIds.split(",");

// 用来存放用户的角色信息

            List<UserRole> roleList
= new ArrayList<>();

// 遍历roleIds

for (String rid : roleStrIds) {

// 准备对象

                UserRole userRole = new
UserRole();

                userRole.setUserId(userId);


userRole.setRoleId(Integer.parseInt(rid));


userRole.setCreateDate(new Date());


userRole.setUpdateDate(new Date());

                roleList.add(userRole);

            }

            AssertUtil.isTrue(userRoleMapper.insertBatch(roleList)
!= roleList.size(), "用户角色分配失败");

        }

    }

}

2、今日疫情模块图片

核心代码Service

@Service

public class ConfirmedService extends BaseService<Confirmed,Integer> {

@Resource

//引入ConfirmedMapper

private ConfirmedMapper confirmedMapper;

@Resource

//引入user表

private UserMapper userMapper;

@Resource

//引入user表

private CommunityMapper communityMapper;

//角色的条件查询以及分页

public Map<String,Object> findRoleByParam(ConfirmedQuery confirmedQuery){

//实例化对象

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

//实例化分页单位


PageHelper.startPage(confirmedQuery.getPage(),
confirmedQuery.getLimit());

//开始分页

        PageInfo<Confirmed> rlist =
new PageInfo<>(selectByParams(confirmedQuery));

        map.put("code",0);


map.put("msg","success");


map.put("count",rlist.getTotal());


map.put("data",rlist.getList());

//返回Map

return map;

    }

@Transactional(propagation = Propagation.REQUIRED) //涉及到事务就需要此注解

//用户模块的添加

public void addUser(Confirmed user) {

//1、参数校验


checkConfirmed(user.getTrueName(),user.getState());

if (user.getComId().equals("浦东区")){

            user.setComId(1);

        }

if (user.getComId().equals("黄浦区")){

            user.setComId(2);

        }

if (user.getComId().equals("松江区")){

            user.setComId(3);

        }

if (user.getComId().equals("徐汇区")){

            user.setComId(4);

        }

if (user.getComId().equals("虹口区")){

            user.setComId(5);

        }

//查询user表中是否存在此人不存在添加上去设置默认值

        User temp =
userMapper.selectByPhone(user.getTcPhone());

// 手机号查询用户

if (temp != null){

//健康状态改成2 如果user表里面已经有了的情况下


userMapper.updateUserHealthById(temp.getUserPhone());

//默认值确诊表中的userId字段

            user.setUserId(temp.getId());

        }else { //表里没有这个人的时候添加这个用户
新建一个user对象

            User u = new User();

//真实姓名


u.setTrueName(user.getTrueName());

//名字

            u.setUserName(user.getTrueName());

//设置密ma 默认值：123456


u.setUserPwd(Md5Util.encode("123456"));

//设置社区ID

            u.setComId(user.getComId());

//手机号唯一


u.setUserPhone(user.getTcPhone());


u.setEcPhone(user.getTcPhone());

            u.setHealth("2");

//创建时间

            u.setCreateDate(new Date());

//修改时间

            u.setUpdateDate(new Date());

//添加用户是否成功


AssertUtil.isTrue(userMapper.insertSelective(u)<1,"插入用户失败");

//给确诊人员添加其 userId

            Integer userId =
userMapper.selectById(user.getTcPhone());

            user.setUserId(userId);

        }

//2、默认值设置

//确诊日期

        user.setCreateDate(new Date());

//添加是否成功


AssertUtil.isTrue(insertSelective(user)<1,"添加失败");

//relaionUserRole(user.getId(),user.getComId());

    }

@Transactional(propagation = Propagation.REQUIRED) //涉及到事务就需要此注解

//用户模块的修改

public void changeUser(Confirmed user) {

//通过id获取用户信息

        Confirmed temp =
confirmedMapper.selectByPrimaryKey(user.getId());

//判断用户信息是否存在

        AssertUtil.isTrue(temp == null,"当前用户不存在");

//校验参数


changeConfirmed(user.getTrueName(),user.getTcPhone(),user.getState());

//修改是否成功完整版

//AssertUtil.isTrue(updateByPrimaryKeySelective(user)<1,"修改失败了");

//修改是否成功完整版


AssertUtil.isTrue(confirmedMapper.uBPKS(user)<1,"修改失败了");

    }

//修改的参数校验

private void changeConfirmed(String trueName, String tcPhone, Integer state) {

//1、用户名不能为空


AssertUtil.isTrue(StringUtils.isBlank(trueName),"姓名不能为空");

//2、当前状态不能为空


AssertUtil.isTrue(StringUtils.isBlank(tcPhone),"请输入手机号");

//3、当前状态不能为空

        AssertUtil.isTrue(state<1 ||
state>4,"请选择正确的状态码");

    }

//用户模块的添加的参数校验

private void checkConfirmed(String trueName, Integer state) {

//1、用户名不能为空


AssertUtil.isTrue(StringUtils.isBlank(trueName),"姓名不能为空");

//2、当前状态不能为空

        AssertUtil.isTrue(state<1 ||
state>3,"请选择正确的状态码");

    }

//添加社区时的校验

private void relaionUserRole(Integer id, Integer comId) {

//准备集合存储对象

        List<Community> urlist =
new ArrayList<>();

//userId,roleId

//判断是否选择了角色信息

//只能选择一个社区

        AssertUtil.isTrue(comId>1 ||
comId<1,"只能选择一个社区");

//通过社区表的 com_id 查询到社区表的对应社区名


communityMapper.selectaddresComId(comId);

//添加

    }

@Transactional(propagation = Propagation.REQUIRED) //涉及到事务就需要此注解

//确诊人员的批量删除

public void deleteUserByIds(Integer[] ids) {

//要删除记录不能为空

        AssertUtil.isTrue(ids == null ||
ids.length==0,"请选择要删除的记录");

//修改user表的状态码

for(Integer id: ids){

            Confirmed confirmed =
confirmedMapper.selectId(id);

            System.out.println(id+ "
-----------------" );

           System.out.println(confirmed.getTrueName());


AssertUtil.isTrue(userMapper.updateById(confirmed.getUserId())<1,"修改失败");

        }

//删除确诊表的个人信息记录


AssertUtil.isTrue(deleteBatch(ids)!=ids.length,"删除失败");

    }

//查询所有社区

public List<Map<String, Object>> queryComs() {

return confirmedMapper.selectComs();

    }

}

3、防疫管理模块

核心代码Service：

@Service

public class CommunityService extends BaseService<Community,Integer> {

@Resource

private CommunityMapper communityMapper;

/**

     * 多条件分页查询

     * @param query

     * @return

     */

public Map<String,Object> queryComByParams(CommunityQuery query){

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

//初始化分页


PageHelper.startPage(query.getPage(), query.getLimit());

//开始分页

        PageInfo<Community>
pageInfo=new PageInfo<>(communityMapper.selectByParams(query));

//准备数据

        map.put("code",0);


map.put("msg","");

        map.put("count",pageInfo.getTotal());


map.put("data",pageInfo.getList());

return map;

    }

//查询所有角色信息

public List<Map<String, Object>> findRoles(Integer userId) {

return communityMapper.selectRoles(userId);

    }

}

//============================================================

@Service

public class VaccinationService {

@Resource

    VaccinationMapper vaccinationMapper;

/*多条件查询*/

public Map<String,Object> selectAll(VaccinationQuery vaccinationQuery) {

//创建map

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

//查数据并分页


PageHelper.startPage(vaccinationQuery.getPage(),vaccinationQuery.getLimit());

        PageInfo<Vaccination>
pageInfo=new
PageInfo<>(vaccinationMapper.selectByParams(vaccinationQuery));

        map.put("code",0);

        map.put("msg","success");


map.put("data",pageInfo.getList());


map.put("count",pageInfo.getTotal());

return map;

    }

/*通过ID获取对象*/

public Vaccination selectId(Integer id) {

return vaccinationMapper.selectById(id);

    }

/*添加*/

@Transactional(propagation = Propagation.REQUIRED)

public void insertVaccination(Vaccination vaccination) {

//审核

        checkOK(vaccination);

        vaccination.setFirstDate(new
Date());

        vaccination.setSecondDate(new
Date());

//插入

        AssertUtil.isTrue(vaccinationMapper.insertSelective(vaccination)<1,"插入失败");

    }

private void checkOK(Vaccination vaccinatio){


AssertUtil.isTrue(vaccinatio==null,"请输入添加的角色");


AssertUtil.isTrue(StringUtils.isBlank(vaccinatio.getTrueName()),"用户名不能为空");

        AssertUtil.isTrue(StringUtils.isBlank(vaccinatio.getFirst()),"请填写(是/否)");


AssertUtil.isTrue(StringUtils.isBlank(vaccinatio.getSecond()),"请填写(是/否)");

    }

/*删除*/

public void delete(Integer[] ids) {


AssertUtil.isTrue(ids==null||ids.length==0,"请选择要删除的用户");


AssertUtil.isTrue(vaccinationMapper.deleteVa(ids)!=ids.length,"删除失败~~~");

    }

/*编辑*/

public void updateVa(Vaccination vaccination) {

        checkOK(vaccination);

if(vaccination.getFirst()==null||"否".equals(vaccination.getFirst())){

            vaccination.setFirstDate(null);

        }

if(vaccination.getSecond()==null||"否".equals(vaccination.getSecond())){


vaccination.setSecondDate(null);

        }

if("是".equals(vaccination.getFirst())){

            vaccination.setFirstDate(new
Date());

        }

if("是".equals(vaccination.getSecond())){

            vaccination.setSecondDate(new
Date());

        }


AssertUtil.isTrue(vaccinationMapper.updateByPrimaryKeySelective(vaccination)<1,"修改失败~");

    }

}

4、系统管理模块

核心代码：Service：

@Service

public class RoleService extends BaseService<Role,Integer> {

@Autowired(required = false)

    RoleMapper roleMapper;

@Autowired(required = false)

    RoleQuery roleQuery;

@Resource

private ModuleMapper moduleMapper;

@Resource

private PermissionMapper permissionMapper;

/*多条件查询*/

public Map<String,Object> selectRole(RoleQuery roleQuery){

//创建map

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

//查数据并分页


PageHelper.startPage(roleQuery.getPage(),roleQuery.getLimit());

        PageInfo<Role> pageInfo=new
PageInfo<>(roleMapper.selectByParams(roleQuery));

        map.put("code",0);


map.put("msg","success");


map.put("data",pageInfo.getList());


map.put("count",pageInfo.getTotal());

return map;

    }

/*添加角色*/

@Transactional(propagation = Propagation.REQUIRED)

public void insertRole(Role role) {

//审核

        checkRole(role);

//添加

        role.setCreateDate(new Date());

        role.setUpdateDate(new Date());

        System.out.println("就差一点！！！！");


AssertUtil.isTrue(insertSelective(role)<1,"添加失败了呢~");

    }

private void checkRole(Role role) {

//是否为空


AssertUtil.isTrue(role==null,"请输入角色信息~");

//判断是否已经重复

        System.out.println("判断");

        Role role1=
roleMapper.selectByName(role.getRoleName());

        System.out.println("判断结束");

        System.out.println(role1!=null);


AssertUtil.isTrue(role1!=null,"已添加过啦~");

        System.out.println("退出@");

    }

/*编辑角色*/

@Transactional(propagation = Propagation.REQUIRED)

public void updateRole(Role role) {

        role.setUpdateDate(new Date());


AssertUtil.isTrue(updateByPrimaryKeySelective(role)<1,"编辑失败啦~");

    }

/**

     * 删除角色信息

     * @param role

     */

@Transactional(propagation = Propagation.REQUIRED)

public void deleteRole(Role role) {

// 验证

        AssertUtil.isTrue(role.getId()==null
|| selectByPrimaryKey(role.getId())==null, "待删除角色不存在");

// 设定默认值

        role.setUpdateDate(new Date());

// 删除角色绑定的权限资源

        int count =
roleMapper.countPermissionByRoleId(role.getId());

if (count>0) {

            int i = roleMapper.deletePermissionsByRoleId(role.getId());

            AssertUtil.isTrue(i!=count,
"角色绑定的权限资源删除失败");

        }

// 判断是否成功


AssertUtil.isTrue(roleMapper.updateRoleById(role.getId())<1, "角色删除失败");

    }

/**

     * 查询所有角色

     * @return

     */

public List<Map<String, Object>> seleceAllRole(Integer userId) {

return roleMapper.seleceAllRole(userId);

    }

/**

     * 给角色添加权限

     * @param mids

     * @param roleId

     */

@Transactional(propagation = Propagation.REQUIRED)

public void addGrant(Integer[] mids, Integer roleId) {

// 判断roleId是否存在

        AssertUtil.isTrue(roleId==null ||
roleMapper.selectByPrimaryKey(roleId)==null, "待授权的角色不存在");

// 统计当前角色的权限资源数量

        int count =
roleMapper.countPermissionByRoleId(roleId);

if (count>0) {

// 如果角色存在权限资源，就全部删除

            int num =
roleMapper.deletePermissionsByRoleId(roleId);

            AssertUtil.isTrue(count!=num,
"资源删除失败");

        }

        List<Permission> plist =
new ArrayList<>();

if (mids!=null && mids.length!=0) {

// 遍历mids

for (Integer mid : mids) {

// 实例化对象

                Permission permission =
new Permission();

// 设置数据


permission.setRoleId(roleId);


permission.setModuleId(mid);

// 权限码


permission.setAclValue(moduleMapper.selectByPrimaryKey(mid).getOptValue());


permission.setCreateDate(new Date());


permission.setUpdateDate(new Date());

// 添加到list

                plist.add(permission);

            }

        }


AssertUtil.isTrue(permissionMapper.insertBatch(plist)!=plist.size(),
"角色权限更新失败");

    }

}

5、用户模块

核心代码Service：

@Service

public class RoleService extends BaseService<Role,Integer> {

@Autowired(required = false)

    RoleMapper roleMapper;

@Autowired(required = false)

    RoleQuery roleQuery;

@Resource

private ModuleMapper moduleMapper;

@Resource

private PermissionMapper permissionMapper;

/*多条件查询*/

public Map<String,Object> selectRole(RoleQuery roleQuery){

//创建map

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

//查数据并分页


PageHelper.startPage(roleQuery.getPage(),roleQuery.getLimit());

        PageInfo<Role> pageInfo=new
PageInfo<>(roleMapper.selectByParams(roleQuery));

        map.put("code",0);


map.put("msg","success");

       map.put("data",pageInfo.getList());


map.put("count",pageInfo.getTotal());

return map;

    }

/*添加角色*/

@Transactional(propagation = Propagation.REQUIRED)

public void insertRole(Role role) {

//审核

        checkRole(role);

//添加

        role.setCreateDate(new Date());

        role.setUpdateDate(new Date());

        System.out.println("就差一点！！！！");


AssertUtil.isTrue(insertSelective(role)<1,"添加失败了呢~");

    }

private void checkRole(Role role) {

//是否为空


AssertUtil.isTrue(role==null,"请输入角色信息~");

//判断是否已经重复

        System.out.println("判断");

        Role role1=
roleMapper.selectByName(role.getRoleName());

        System.out.println("判断结束");

        System.out.println(role1!=null);


AssertUtil.isTrue(role1!=null,"已添加过啦~");

        System.out.println("退出@");

    }

/*编辑角色*/

@Transactional(propagation = Propagation.REQUIRED)

public void updateRole(Role role) {

        role.setUpdateDate(new Date());


AssertUtil.isTrue(updateByPrimaryKeySelective(role)<1,"编辑失败啦~");

    }

/**

     * 删除角色信息

     * @param role

     */

@Transactional(propagation = Propagation.REQUIRED)

public void deleteRole(Role role) {

// 验证


AssertUtil.isTrue(role.getId()==null ||
selectByPrimaryKey(role.getId())==null, "待删除角色不存在");

// 设定默认值

        role.setUpdateDate(new Date());

// 删除角色绑定的权限资源

        int count =
roleMapper.countPermissionByRoleId(role.getId());

if (count>0) {

            int i =
roleMapper.deletePermissionsByRoleId(role.getId());

            AssertUtil.isTrue(i!=count,
"角色绑定的权限资源删除失败");

        }

// 判断是否成功


AssertUtil.isTrue(roleMapper.updateRoleById(role.getId())<1, "角色删除失败");

    }

/**

     * 查询所有角色

     * @return

     */

public List<Map<String, Object>> seleceAllRole(Integer userId) {

return roleMapper.seleceAllRole(userId);

    }

/**

   * 给角色添加权限

     * @param mids

     * @param roleId

     */

@Transactional(propagation = Propagation.REQUIRED)

public void addGrant(Integer[] mids, Integer roleId) {

// 判断roleId是否存在

        AssertUtil.isTrue(roleId==null ||
roleMapper.selectByPrimaryKey(roleId)==null, "待授权的角色不存在");

// 统计当前角色的权限资源数量

        int count =
roleMapper.countPermissionByRoleId(roleId);

if (count>0) {

// 如果角色存在权限资源，就全部删除

            int num =
roleMapper.deletePermissionsByRoleId(roleId);

            AssertUtil.isTrue(count!=num,
"资源删除失败");

        }

        List<Permission> plist =
new ArrayList<>();

if (mids!=null && mids.length!=0) {

// 遍历mids

for (Integer mid : mids) {

// 实例化对象

                Permission permission =
new Permission();

// 设置数据

                permission.setRoleId(roleId);


permission.setModuleId(mid);

// 权限码


permission.setAclValue(moduleMapper.selectByPrimaryKey(mid).getOptValue());


permission.setCreateDate(new Date());


permission.setUpdateDate(new Date());

// 添加到list

                plist.add(permission);

            }

        }


AssertUtil.isTrue(permissionMapper.insertBatch(plist)!=plist.size(),
"角色权限更新失败");

    }

}