exam/sys/user/service/impl/SysUserRoleServiceImpl.java

package com.yf.exam.modules.sys.user.service.impl;

// 导入阿里巴巴的 FastJSON 库，用于 JSON 数据的序列化和反序列化
import com.alibaba.fastjson.JSON;
// 导入 FastJSON 的 TypeReference 类，用于处理泛型类型的 JSON 反序列化
import com.alibaba.fastjson.TypeReference;
// 导入 MyBatis-Plus 的查询条件构造器类，用于构建数据库查询条件
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
// 导入 MyBatis-Plus 的分页元数据接口，用于表示分页查询的结果
import com.baomidou.mybatisplus.core.metadata.IPage;
// 导入 MyBatis-Plus 的分页实现类，用于创建分页对象
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
// 导入 MyBatis-Plus 的服务实现基类，提供了通用的服务层方法实现
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
// 导入系统用户角色数据传输对象类，用于在不同层之间传输用户角色相关的数据
import com.yf.exam.modules.sys.user.dto.SysUserRoleDTO;
// 导入系统用户角色实体类，用于映射数据库中的用户角色表
import com.yf.exam.modules.sys.user.entity.SysUserRole;
// 导入系统用户角色数据访问接口，用于与数据库进行用户角色数据的交互
import com.yf.exam.modules.sys.user.mapper.SysUserRoleMapper;
// 导入系统用户角色服务接口，定义了用户角色相关的业务方法
import com.yf.exam.modules.sys.user.service.SysUserRoleService;
// 导入分页请求数据传输对象类，用于封装分页查询的请求参数
import com.yf.exam.core.api.dto.PagingReqDTO;
// 导入 Spring 的服务注解，将该类标记为一个服务组件，由 Spring 容器进行管理
import org.springframework.stereotype.Service;
// 导入 Spring 的集合工具类，用于判断集合是否为空
import org.springframework.util.CollectionUtils;
// 导入 Spring 的字符串工具类，用于判断字符串是否为空
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.List;

/**
 * <p>
 * 用户角色 服务实现类，实现了用户角色相关的业务逻辑。
 * 继承自 MyBatis-Plus 的 ServiceImpl 类，使用 SysUserRoleMapper 操作 SysUserRole 实体。
 * </p>
 *
 * @author 聪明笨狗
 * @since 2020-04-13 16:57
 */
@Service
public class SysUserRoleServiceImpl extends ServiceImpl<SysUserRoleMapper, SysUserRole> implements SysUserRoleService {

    /**
     * 分页查询用户角色信息。
     *
     * @param reqDTO 分页请求数据传输对象，包含分页查询的当前页码、每页记录数等信息
     * @return 分页查询结果，包含用户角色数据传输对象列表
     */
    @Override
    public IPage<SysUserRoleDTO> paging(PagingReqDTO<SysUserRoleDTO> reqDTO) {

        // 创建分页对象，根据请求中的当前页码和每页记录数初始化
        IPage<SysUserRole> query = new Page<>(reqDTO.getCurrent(), reqDTO.getSize());

        // 创建查询条件构造器，用于构建数据库查询条件，当前未添加具体查询条件
        QueryWrapper<SysUserRole> wrapper = new QueryWrapper<>();

        // 调用父类的 page 方法进行分页查询，获取包含 SysUserRole 实体的分页结果
        IPage<SysUserRole> page = this.page(query, wrapper);
        // 将包含 SysUserRole 实体的分页结果转换为 JSON 字符串，再反序列化为包含 SysUserRoleDTO 的分页结果
        IPage<SysUserRoleDTO> pageData = JSON.parseObject(JSON.toJSONString(page), new TypeReference<Page<SysUserRoleDTO>>(){});
        return pageData;
    }

    /**
     * 根据用户 ID 查询用户的角色列表。
     *
     * @param userId 用户的唯一标识
     * @return 用户的角色 ID 列表
     */
    @Override
    public List<String> listRoles(String userId) {

        // 创建查询条件构造器，添加用户 ID 作为查询条件
        QueryWrapper<SysUserRole> wrapper = new QueryWrapper<>();
        wrapper.lambda().eq(SysUserRole::getUserId, userId);

        // 调用父类的 list 方法进行查询，获取符合条件的用户角色实体列表
        List<SysUserRole> list = this.list(wrapper);
        // 初始化一个空的角色 ID 列表
        List<String> roles = new ArrayList<>();
        // 判断查询结果列表是否不为空
        if(!CollectionUtils.isEmpty(list)){
            // 遍历用户角色实体列表，将每个实体的角色 ID 添加到角色 ID 列表中
            for(SysUserRole item: list){
                roles.add(item.getRoleId());
            }
        }

        return roles;
    }

    /**
     * 保存用户的角色信息，先删除用户原有的所有角色，再添加新的角色。
     *
     * @param userId 用户的唯一标识
     * @param ids 新的角色 ID 列表
     * @return 保存的角色 ID 以逗号连接的字符串
     */
    @Override
    public String saveRoles(String userId, List<String> ids) {

        // 创建查询条件构造器，添加用户 ID 作为查询条件，用于删除用户原有的所有角色
        QueryWrapper<SysUserRole> wrapper = new QueryWrapper<>();
        wrapper.lambda().eq(SysUserRole::getUserId, userId);
        // 调用父类的 remove 方法删除符合条件的用户角色记录
        this.remove(wrapper);

        // 判断新的角色 ID 列表是否不为空
        if(!CollectionUtils.isEmpty(ids)){

            // 初始化一个空的用户角色实体列表
            List<SysUserRole> list = new ArrayList<>();
            // 用于存储以逗号连接的角色 ID 字符串
            String roleIds = null;

            // 遍历新的角色 ID 列表
            for(String item: ids){
                // 创建一个新的用户角色实体对象
                SysUserRole role = new SysUserRole();
                // 设置角色 ID
                role.setRoleId(item);
                // 设置用户 ID
                role.setUserId(userId);
                // 将用户角色实体对象添加到列表中
                list.add(role);
                // 判断 roleIds 是否为空
                if(StringUtils.isEmpty(roleIds)){
                    // 若为空，则直接赋值为当前角色 ID
                    roleIds = item;
                }else{
                    // 若不为空，则将当前角色 ID 追加到 roleIds 后面，用逗号分隔
                    roleIds+=","+item;
                }
            }

            // 调用父类的 saveBatch 方法批量保存用户角色实体列表
            this.saveBatch(list);
            return roleIds;
        }

        return "";
    }

    /**
     * 判断用户是否具有学生角色。
     *
     * @param userId 用户的唯一标识
     * @return 若用户具有学生角色返回 true，否则返回 false
     */
    @Override
    public boolean isStudent(String userId) {

        // 创建查询条件构造器，添加用户 ID 和角色 ID（student）作为查询条件
        QueryWrapper<SysUserRole> wrapper = new QueryWrapper<>();
        wrapper.lambda().eq(SysUserRole::getUserId, userId)
                .eq(SysUserRole::getRoleId, "student");

        // 调用父类的 count 方法统计符合条件的记录数，若大于 0 则表示用户具有学生角色
        return this.count(wrapper) > 0;
    }

    /**
     * 判断用户是否具有教师角色。
     *
     * @param userId 用户的唯一标识
     * @return 若用户具有教师角色返回 true，否则返回 false
     */
    @Override
    public boolean isTeacher(String userId) {
        // 创建查询条件构造器，添加用户 ID 和角色 ID（teacher）作为查询条件
        QueryWrapper<SysUserRole> wrapper = new QueryWrapper<>();
        wrapper.lambda().eq(SysUserRole::getUserId, userId)
                .eq(SysUserRole::getRoleId, "teacher");

        // 调用父类的 count 方法统计符合条件的记录数，若大于 0 则表示用户具有教师角色
        return this.count(wrapper) > 0;
    }

    /**
     * 判断用户是否具有管理员角色。
     *
     * @param userId 用户的唯一标识
     * @return 若用户具有管理员角色返回 true，否则返回 false
     */
    @Override
    public boolean isAdmin(String userId) {
        // 创建查询条件构造器，添加用户 ID 和角色 ID（sa）作为查询条件
        QueryWrapper<SysUserRole> wrapper = new QueryWrapper<>();
        wrapper.lambda().eq(SysUserRole::getUserId, userId)
                .eq(SysUserRole::getRoleId, "sa");

        // 调用父类的 count 方法统计符合条件的记录数，若大于 0 则表示用户具有管理员角色
        return this.count(wrapper) > 0;
    }
}