caimei-zplm-admin-api/src/main/java/com/caimei/service/sys/impl/SysUserServiceImpl.java

package com.caimei.service.sys.impl;

import com.caimei.components.RedisService;
import com.caimei.mapper.SystemMapper;
import com.caimei.mapper.VipMapper;
import com.caimei.model.ResponseJson;
import com.caimei.model.po.SysMenu;
import com.caimei.model.po.SysRole;
import com.caimei.model.po.SysUser;
import com.caimei.model.vo.VipInfoVo;
import com.caimei.service.sys.SysUserService;
import com.caimei.utils.CommonUtil;
import com.caimei.utils.Md5Util;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

/**
 * Description
 *
 * @author : Charles
 * @date : 2021/12/10
 */
@Service
public class SysUserServiceImpl implements SysUserService {

    @Resource
    private SystemMapper systemMapper;

    @Resource
    private VipMapper vipMapper;

    @Resource
    private RedisService redisService;

    /**
     * 获取用户信息
     */
    @Override
    public ResponseJson<SysUser> getInfoByUsername(String username) {
        if (StringUtils.hasLength(username)) {
            SysUser sysUser = systemMapper.findByUsername(username);
            if (null != sysUser) {
                List<Integer> roleIds = setUserRoleInfo(sysUser);
                List<SysMenu> menus = null;
                if (!CollectionUtils.isEmpty(roleIds)) {
                    // 根据角色Id获取菜单列表
                    menus = systemMapper.getMenusByRoleIds(roleIds);
                    // 根据角色Id获取按钮权限列表
                    List<String> permissions = systemMapper.getPermissionNames(roleIds);
                    sysUser.setPermissions(permissions);
                }
                sysUser.setMenus(menus);
            }

            return ResponseJson.success(sysUser);
        }
        return ResponseJson.error("用户数据异常", null);
    }

    /**
     * 获取用户信息
     */
    @Override
    public ResponseJson<SysUser> getInfoByUserId(Integer id) {
        if (null == id) {
            return ResponseJson.error("用户id不能为空", null);
        }
        SysUser sysUser = systemMapper.findByUserId(id);
        if (null != sysUser) {
            VipInfoVo vipInfo = vipMapper.getVipInfo(id);
            if (null != vipInfo && vipInfo.getEndDayLeft() <= 0) {
                if (vipInfo.getFreeDayLeft() <= 0) {
                    // 会员到期且已过试用期
                    // 删除用户角色关联
                    systemMapper.deleteUserRoleRelation(id);
                    // 赋予基础供应商角色
                    saveRoleRelation(id, "1");
                } else {
                    // 会员到期但还在试用期内
                    // 删除用户角色关联
                    systemMapper.deleteUserRoleRelation(id);
                    // 赋予基础供应商角色和会员基础角色
                    saveRoleRelation(id, "1,2");
                }
            }
            List<Integer> roleIds = setUserRoleInfo(sysUser);
            List<SysMenu> menus = null;
            if (!CollectionUtils.isEmpty(roleIds)) {
                // 根据角色Id获取菜单列表
                menus = systemMapper.getMenusByRoleIds(roleIds);
                // 根据角色Id获取按钮权限列表
                List<String> permissions = systemMapper.getPermissionNames(roleIds);
                sysUser.setPermissions(permissions);
            }
            sysUser.setMenus(menus);
        }
        return ResponseJson.success(sysUser);
    }

    private List<Integer> setUserRoleInfo(SysUser sysUser) {
        List<Integer> roleIds = new ArrayList<>();
        if (null != sysUser) {
            List<String> roleNames = new ArrayList<>();
            StringBuilder roleDesc = new StringBuilder();
            // 根据用户Id获取用户角色列表
            List<SysRole> roleList = systemMapper.getRoleListByUserId(sysUser.getId());
            if (!CollectionUtils.isEmpty(roleList)) {
                for (SysRole role : roleList) {
                    if (null != role) {
                        roleNames.add(role.getRoleName());
                        roleDesc.append(role.getRoleDesc()).append(" ");
                        roleIds.add(role.getId());
                    }
                }
            }
            sysUser.setRoles(roleNames);
            sysUser.setRoleDesc(roleDesc.toString());
        }
        return roleIds;
    }

    /**
     * 退出登录
     */
    @Override
    public ResponseJson<Void> logout(String token) {
        if (StringUtils.hasLength(token)) {
            redisService.remove(token);
        }
        return ResponseJson.success();
    }

    /**
     * 获取用户列表
     *
     * @param username 用户名
     * @param pageNum  页码
     * @param pageSize 每页大小
     */
    @Override
    public ResponseJson<PageInfo<SysUser>> getUserList(String username, String linkMan, int pageNum, int pageSize) {
        PageHelper.startPage(pageNum, pageSize);
        List<SysUser> userList = systemMapper.getUserList(username, linkMan);
        for (SysUser sysUser : userList) {
            List<Integer> roleIdList = setUserRoleInfo(sysUser);
            String roleIds = CommonUtil.idListToString(roleIdList, ",");
            sysUser.setRoleIds(roleIds);
        }
        PageInfo<SysUser> pageData = new PageInfo<>(userList);
        return ResponseJson.success(pageData);
    }

    /**
     * 根据ID获取用户
     */
    @Override
    public ResponseJson<SysUser> getUser(Integer id) {
        SysUser sysUser = systemMapper.getUser(id);
        sysUser.setPassword("");
        List<Integer> roleIdList = setUserRoleInfo(sysUser);
        String roleIds = CommonUtil.idListToString(roleIdList, ",");
        sysUser.setRoleIds(roleIds);
        return ResponseJson.success(sysUser);
    }

    /**
     * 根据ID更新用户
     */
    @Transactional(rollbackFor=Exception.class)
    @Override
    public ResponseJson<Void> updateUser(Integer id, SysUser sysUser) {
        sysUser.setId(id);
        if (StringUtils.hasLength(sysUser.getPassword())){
            // 密码加密
            String encodePassword = Md5Util.md5(sysUser.getPassword());
            sysUser.setPassword(encodePassword);
        }
        // 删除原有角色关联
        systemMapper.deleteUserRoleRelation(id);
        // 前端传入角色Ids，用","隔开
        String roleIds = sysUser.getRoleIds();
        // 保存用户角色关系
        saveRoleRelation(sysUser.getId(), roleIds);
        systemMapper.updateSysUser(sysUser);
        return ResponseJson.success();
    }

    /**
     * 添加用户
     */
    /*@Transactional(rollbackFor=Exception.class)
    @Override
    public ResponseJson<Void> addUser(SysUser sysUser) {
        if (StringUtils.hasLength(sysUser.getUsername()) && StringUtils.hasLength(sysUser.getPassword())) {
            // 查询是否存在当前用户名的用户
            SysUser dbUser = systemMapper.findByUsername(sysUser.getUsername());
            if (null == dbUser) {
                // 密码加密
                String encodePassword = bCryptPasswordEncoder.encode(sysUser.getPassword());
                sysUser.setPassword(encodePassword);
                // 新增用户
                systemMapper.insertSysUser(sysUser);
                // 角色Ids，用","隔开
                String roleIds = sysUser.getRoleIds();
                // 保存用户角色关系
                saveRoleRelation(sysUser.getId(), roleIds);
                return ResponseJson.success("添加用户成功", null);
            } else {
                return ResponseJson.error("用户名已存在", null);
            }
        }
        return ResponseJson.error("用户名或密码不能为空", null);
    }*/

    /**
     * 根据ID删除用户
     */
    @Transactional(rollbackFor=Exception.class)
    @Override
    public ResponseJson<Void> deleteUser(Integer id) {
        // 删除用户角色关联
        systemMapper.deleteUserRoleRelation(id);
        // 删除用户
        systemMapper.deleteSysUser(id);
        return ResponseJson.success();
    }

    @Transactional(rollbackFor=Exception.class)
    @Override
    public ResponseJson<Void> addAdmin(SysUser sysUser) {
        if (StringUtils.hasLength(sysUser.getUsername()) && StringUtils.hasLength(sysUser.getPassword())) {
            // 查询是否存在当前用户名的用户
            SysUser dbUser = systemMapper.findByUsername(sysUser.getUsername());
            if (null == dbUser) {
                // 密码加密
                String encodePassword = Md5Util.md5(sysUser.getPassword());
                sysUser.setPassword(encodePassword);
                // 新增用户
                systemMapper.insertAdminUser(sysUser);
                // 角色Ids，用","隔开
                String roleIds = sysUser.getRoleIds();
                // 保存用户角色关系
                saveRoleRelation(sysUser.getId(), roleIds);
                return ResponseJson.success("添加管理员成功", null);
            } else {
                return ResponseJson.error("用户名已存在", null);
            }
        }
        return ResponseJson.error("用户名或密码不能为空", null);
    }

    /**
     * 保存用户角色关系
     */
    @Override
    public ResponseJson<Void> saveRoleRelation(Integer userId, String roleIds) {
        if (StringUtils.hasLength(roleIds)) {
            // 设置用户角色
            String[] split = roleIds.split(",");
            for (String s : split) {
                if (StringUtils.hasLength(s)) {
                    // 保存用户角色关系
                    systemMapper.insertUserRoleRelation(userId, Integer.valueOf(s));
                }
            }
        }
        return ResponseJson.success();
    }
/*
    *//**
     * 用户修改资料
     *//*
    @Override
    public ResponseJson<Void> updateUserProfile(UserProfile profile) {
        SysUser sysUser = systemMapper.getUser(profile.getUserId());
        if (null == sysUser) {
            return ResponseJson.error("用户异常！", null);
        }
        if (StringUtils.hasLength(profile.getUsername())){
            sysUser.setUsername(profile.getUsername());
        }
        if (StringUtils.hasLength(profile.getFullName())){
            sysUser.setFullName(profile.getFullName());
        }
        if (StringUtils.hasLength(profile.getPhone())){
            sysUser.setPhone(profile.getPhone());
        }
        if (StringUtils.hasLength(profile.getAvatar())){
            sysUser.setAvatar(profile.getAvatar());
        }
        systemMapper.updateSysUser(sysUser);
        return ResponseJson.success();
    }

    *//**
     * 用户修改密码
     *//*
    @Override
    public ResponseJson<Void> updateUserPassword(UserProfile profile) {
        SysUser sysUser = systemMapper.getUser(profile.getUserId());
        if (null == sysUser) {
            return ResponseJson.error("用户异常！", null);
        }
        if (!StringUtils.hasLength(profile.getPassword())){
            return ResponseJson.error("新密码不能为空！", null);
        }
        if (!profile.getPassword().equals(profile.getConfirmPassword())){
            return ResponseJson.error("两次密码输入不一致！", null);
        }
        if (!bCryptPasswordEncoder.matches(profile.getOldPassword(), sysUser.getPassword())) {
            return ResponseJson.error("旧密码输入错误！", null);
        }
        // 密码加密
        String encodePassword = bCryptPasswordEncoder.encode(profile.getPassword());
        sysUser.setPassword(encodePassword);
        systemMapper.updateSysUser(sysUser);
        return ResponseJson.success();
    }*/
}