java/Robotaxi.git

package com.xiaopeng.account.service.impl;
 
import cn.hutool.core.util.DesensitizedUtil;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xiaopeng.account.constant.I18nKeyConstant;
import com.xiaopeng.account.mapper.SysUserMapper;
import com.xiaopeng.account.mapper.SysUserRoleMapper;
import com.xiaopeng.account.model.query.SysUserListQuery;
import com.xiaopeng.account.service.ISysGroupService;
import com.xiaopeng.account.service.ISysUserService;
import com.xiaopeng.api.model.account.SysUser;
import com.xiaopeng.api.model.account.SysUserRole;
import com.xiaopeng.api.vo.account.LoginUser;
import com.xiaopeng.common.core.constant.UserConstants;
import com.xiaopeng.common.core.exception.ServiceException;
import com.xiaopeng.common.core.utils.SensitiveDataCryptoUtil;
import com.xiaopeng.common.core.utils.StringUtils;
import com.xiaopeng.common.core.web.page.PageInfo;
import com.xiaopeng.common.security.service.TokenService;
import org.apache.shardingsphere.transaction.annotation.ShardingSphereTransactionType;
import org.apache.shardingsphere.transaction.core.TransactionType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import javax.annotation.Resource;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
 
/**
 * 用户 业务层处理
 *
 * @author ruoyi
 */
@Service
public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser> implements ISysUserService {
    private static final Logger log = LoggerFactory.getLogger(SysUserServiceImpl.class);
    
    @Resource
    private SysUserMapper userMapper;
    
    @Resource
    private SysUserRoleMapper userRoleMapper;
    
    @Resource
    private TokenService tokenService;
    @Autowired
    private ISysGroupService sysGroupService;
 
 
    /**
     * 通过用户名查询用户
     *
     * @param userName 用户名
     * @return 用户对象信息
     */
    @Override
    public SysUser selectUserByUserName(String userName)
    {
        SysUser user = userMapper.selectOne(new LambdaQueryWrapper<SysUser>().eq(SysUser::getUserAccount, userName).last("limit 1"));
        decryptPhone(user);
        return user;
    }
 
    /**
     * 根据条件分页查询已分配用户角色列表
     *
     * @param user 用户信息
     * @return 用户信息集合信息
     */
    @Override
    public List<SysUser> selectAllocatedList(SysUser user) {
        return userMapper.selectAllocatedList(user);
    }
 
    /**
     * 根据条件分页查询未分配用户角色列表
     *
     * @param user 用户信息
     * @return 用户信息集合信息
     */
    @Override
    public List<SysUser> selectUnallocatedList(SysUser user) {
        return userMapper.selectUnallocatedList(user);
    }
 
 
    /**
     * 通过用户ID查询用户
     *
     * @param userId 用户ID
     * @return 用户对象信息
     */
    @Override
    public SysUser selectUserById(Long userId) {
        SysUser user = userMapper.selectUserById(userId);
        decryptPhone(user);
        return user;
    }
 
    /**
     * 校验用户名称是否唯一
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    public boolean checkUserNameUnique(SysUser user) {
        Long userId = StringUtils.isNull(user.getId()) ? -1L : user.getId();
        SysUser info = userMapper.checkUserNameUnique(user.getUserAccount());
        if (StringUtils.isNotNull(info) && info.getId().longValue() != userId.longValue()) {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }
 
    /**
     * 校验手机号码是否唯一
     *
     * @param user 用户信息
     * @return
     */
    @Override
    public boolean checkPhoneUnique(SysUser user) {
        Long userId = StringUtils.isNull(user.getId()) ? -1L : user.getId();
        SysUser info = lambdaQuery()
                .in(SysUser::getPhoneNumber, SensitiveDataCryptoUtil.queryValues(user.getPhoneNumber()))
                .last("limit 1")
                .one();
        if (StringUtils.isNotNull(info)) {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }
 
    /**
     * 校验用户是否允许操作
     *
     * @param user 用户信息
     */
    @Override
    public void checkUserAllowed(SysUser user) {
        Long userid = tokenService.getLoginUser().getUserid();
        if (StringUtils.isNotNull(user.getId()) && !userid.equals(user.getId()) && user.isAdmin()) {
            throw new ServiceException("不允许操作超级管理员用户", I18nKeyConstant.ACCOUNT_NOT_ALLOWED_OPERATE_ADMIN);
        }
    }
 
    /**
     * 校验用户是否有数据权限
     *
     * @param userId 用户id
     */
    @Override
    public void checkUserDataScope(Long userId) {
        if (!SysUser.isAdmin(tokenService.getLoginUser().getUserid())) {
            SysUser user = new SysUser();
            user.setId(userId);
            List<SysUser> users = this.baseMapper.selectUserList(user);
            if (StringUtils.isEmpty(users)) {
                throw new ServiceException("没有权限访问用户数据！");
            }
        }
    }
 
    /**
     * 新增保存用户信息
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    @Transactional
    @ShardingSphereTransactionType(TransactionType.BASE)
    public int insertUser(SysUser user) {
        // 新增用户信息
//        int rows = userMapper.insertUser(user);
//        // 新增用户岗位关联
//        insertUserPost(user);
//        // 新增用户与角色管理
//        insertUserRole(user);
        user.setCreateBy(tokenService.getLoginUser().getUsername());
        user.setUpdateBy(tokenService.getLoginUser().getUsername());
        encryptPhone(user);
        try {
            return userMapper.insert(user);
        } finally {
            decryptPhone(user);
        }
    }
 
    /**
     * 修改保存用户信息
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    @Transactional
    @ShardingSphereTransactionType(TransactionType.BASE)
    public int updateUser(SysUser user) {
        encryptPhone(user);
        try {
            return userMapper.updateUser(user);
        } finally {
            decryptPhone(user);
        }
    }
 
    /**
     * 用户授权角色
     *
     * @param userId  用户ID
     * @param roleIds 角色组
     */
    @Override
    @Transactional
    @ShardingSphereTransactionType(TransactionType.BASE)
    public void insertUserAuth(Long userId, Long[] roleIds) {
        userRoleMapper.deleteUserRoleByUserId(userId);
        insertUserRole(userId, roleIds);
    }
 
    /**
     * 修改用户状态
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    public int updateUserStatus(SysUser user) {
        encryptPhone(user);
        try {
            return userMapper.updateUser(user);
        } finally {
            decryptPhone(user);
        }
    }
 
    /**
     * 重置用户密码
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    public int resetPwd(SysUser user) {
        encryptPhone(user);
        try {
            return userMapper.updateUser(user);
        } finally {
            decryptPhone(user);
        }
    }
 
    /**
     * 新增用户角色信息
     *
     * @param userId  用户ID
     * @param roleIds 角色组
     */
    public void insertUserRole(Long userId, Long[] roleIds) {
        if (StringUtils.isNotEmpty(roleIds)) {
            // 新增用户与角色管理
            List<SysUserRole> list = new ArrayList<SysUserRole>();
            for (Long roleId : roleIds) {
                SysUserRole ur = new SysUserRole();
                ur.setUserId(userId);
                ur.setRoleId(roleId);
                list.add(ur);
            }
            userRoleMapper.batchUserRole(list);
        }
    }
 
    /**
     * 批量删除用户信息
     *
     * @param userIds 需要删除的用户ID
     * @return 结果
     */
    @Override
    @Transactional
    @ShardingSphereTransactionType(TransactionType.BASE)
    public int deleteUserByIds(Long[] userIds) {
        for (Long userId : userIds) {
            SysUser sysUser = new SysUser();
            sysUser.setId(userId);
            checkUserAllowed(sysUser);
        }
        return userMapper.deleteUserByIds(userIds);
    }
 
 
    @Override
    public PageInfo<SysUser> getList(PageInfo<SysUser> pageInfo, SysUserListQuery sysUserListQuery) {
        sysUserListQuery.setPhoneNumberQueryValues(SensitiveDataCryptoUtil.queryValues(sysUserListQuery.getPhoneNumber()));
        PageInfo<SysUser> page = userMapper.getList(pageInfo, sysUserListQuery);
        decryptPhones(page.getRecords());
        return page;
    }
 
    @Override
    public boolean resetUserPwd(Long id, String newPassword) {
        return lambdaUpdate().eq(SysUser::getId, id).set(SysUser::getPassword, newPassword).update();
    }
 
    @Override
    public boolean save(SysUser entity) {
        encryptPhone(entity);
        try {
            return super.save(entity);
        } finally {
            decryptPhone(entity);
        }
    }
 
    @Override
    public boolean updateById(SysUser entity) {
        encryptPhone(entity);
        try {
            return super.updateById(entity);
        } finally {
            decryptPhone(entity);
        }
    }
 
    @Override
    public SysUser getById(Serializable id) {
        SysUser user = super.getById(id);
        decryptPhone(user);
        return user;
    }
 
    @Override
    public SysUser getOne(Wrapper<SysUser> queryWrapper) {
        SysUser user = super.getOne(queryWrapper);
        decryptPhone(user);
        return user;
    }
 
    @Override
    public List<SysUser> list() {
        List<SysUser> list = super.list();
        decryptPhones(list);
        return list;
    }
 
    @Override
    public List<SysUser> list(Wrapper<SysUser> queryWrapper) {
        List<SysUser> list = super.list(queryWrapper);
        decryptPhones(list);
        return list;
    }
 
    @Override
    public List<SysUser> listByIds(Collection<? extends Serializable> idList) {
        List<SysUser> list = super.listByIds(idList);
        decryptPhones(list);
        return list;
    }
 
    private void encryptPhone(SysUser user) {
        if (user != null) {
            user.setPhoneNumber(SensitiveDataCryptoUtil.encrypt(user.getPhoneNumber()));
        }
    }
 
    private void decryptPhone(SysUser user) {
        if (user != null) {
            user.setPhoneNumber(SensitiveDataCryptoUtil.decryptIfPossible(user.getPhoneNumber()));
        }
    }
 
    private void decryptPhones(List<SysUser> users) {
        if (users != null) {
            users.forEach(this::decryptPhone);
        }
    }
}