cdss/src/main/java/com/diagbot/facade/SysUserFacade.java

package com.diagbot.facade;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.diagbot.client.AuthServiceClient;
import com.diagbot.dto.HospitalInfoDTO;
import com.diagbot.dto.HospitalLoginDTO;
import com.diagbot.dto.JwtDTO;
import com.diagbot.dto.LoginDTO;
import com.diagbot.dto.UserLoginDTO;
import com.diagbot.entity.*;
import com.diagbot.entity.wrapper.SysMenuWrapper;
import com.diagbot.enums.ConstantEnum;
import com.diagbot.enums.IsDeleteEnum;
import com.diagbot.enums.StatusEnum;
import com.diagbot.exception.CommonErrorCode;
import com.diagbot.exception.CommonException;
import com.diagbot.exception.ServiceErrorCode;
import com.diagbot.service.impl.SysUserServiceImpl;
import com.diagbot.util.*;
import com.diagbot.vo.UserSaveVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.factory.PasswordEncoderFactories;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.oauth2.common.OAuth2AccessToken;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @Description: 用户业务层
 * @author: gaodm
 * @time: 2018/8/6 9:00
 */
@Component
public class SysUserFacade extends SysUserServiceImpl {

    @Autowired
    private TokenFacade tokenFacade;

    @Autowired
    private AuthServiceClient authServiceClient;

    @Autowired
    private SysMenuFacade sysMenuFacade;

    @Autowired
    private HospitalInfoFacade hospitalInfoFacade;

    @Autowired
    private SysUserRoleFacade sysUserRoleFacade;

    @Autowired
    private SysUserHospitalFacade sysUserHospitalFacade;

    /**
     * 获取jwt
     *
     * @param username 用户名
     * @param password 密码
     * @return jwt
     */
    public JwtDTO getJwt(String username, String password) {
        JwtDTO data = new JwtDTO();
        if (StringUtil.isBlank(username)) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
                    "请输入用户名");
        }
        if (StringUtil.isBlank(password)) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
                    "请输入密码");
        }
        QueryWrapper<SysUser> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.eq("username", username)
                .eq("status", StatusEnum.Enable.getKey())
                .eq("is_deleted", IsDeleteEnum.N.getKey());
        SysUser user = this.getOne(userQueryWrapper, false);
        if (null == user) {
            throw new CommonException(ServiceErrorCode.USER_NOT_FOUND);
        }
        PasswordEncoder passwordEncoder = PasswordEncoderFactories.createDelegatingPasswordEncoder();
        if (!passwordEncoder.matches(password, user.getPassword())) {
            throw new CommonException(ServiceErrorCode.USER_PASSWORD_ERROR);
        }
        JWT jwt = authServiceClient.getToken("Basic dWFhLXNlcnZpY2U6MTIzNDU2",
                "password", username, password);
        if (null == jwt) {
            throw new CommonException(ServiceErrorCode.GET_TOKEN_FAIL);
        }
        data.setAccessToken(jwt.getAccess_token());
        data.setRefreshToken(jwt.getRefresh_token());
        data.setType(user.getType());
        data.setTypeCn(ConstantEnum.getName(user.getType()));//返回中文
        //token存入redis
        JwtStore jwtStore = new JwtStore();
        jwtStore.setAccessToken(jwt.getAccess_token());
        jwtStore.setRefreshToken(jwt.getRefresh_token());
        tokenFacade.createToken(jwtStore);
        return data;
    }

    /**
     * 刷新jwt
     *
     * @param refreshToken
     * @return jwt
     */
    public JwtDTO refreshJwt(String refreshToken) {
        JwtDTO data = new JwtDTO();
        if (StringUtil.isBlank(refreshToken)) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
                    "刷新令牌不能为空");
        }

        //验证刷新令牌有效性
        if (!tokenFacade.verifyToken(refreshToken, 2)) {
            throw new CommonException(CommonErrorCode.TOKEN_PAST);
        }

        JWT jwt = authServiceClient.refreshToken("Basic dWFhLXNlcnZpY2U6MTIzNDU2",
                "refresh_token", refreshToken);
        if (null == jwt) {
            throw new CommonException(ServiceErrorCode.GET_TOKEN_FAIL);
        }
        data.setAccessToken(jwt.getAccess_token());
        data.setRefreshToken(jwt.getRefresh_token());
        //token存入redis
        JwtStore jwtStore = new JwtStore();
        jwtStore.setAccessToken(jwt.getAccess_token());
        jwtStore.setRefreshToken(jwt.getRefresh_token());
        tokenFacade.createToken(jwtStore);
        return data;
    }


    /**
     * 验证jwt
     *
     * @param token
     * @return jwt
     */
    public OAuth2AccessToken checkToken(String token) {
        if (StringUtil.isBlank(token)) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
                    "令牌不能为空");
        }

        OAuth2AccessToken jwt
                = authServiceClient.checkToken("Basic dWFhLXNlcnZpY2U6MTIzNDU2", token);
        if (null == jwt) {
            throw new CommonException(ServiceErrorCode.GET_TOKEN_FAIL, "该Token不正确！");
        }
        return jwt;
    }

    /**
     * 修改密码
     *
     * @param password       原密码
     * @param modifyPassword 新密码
     * @return 修改密码是否成功
     */
    public Boolean modifyPassword(String password, String modifyPassword) {
        if (StringUtil.isBlank(password)) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
                    "请输入密码");
        }
        if (StringUtil.isBlank(modifyPassword)) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
                    "请输入新密码");
        }
        if (password.equals(modifyPassword)) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
                    "原密码和新密码不能相同");
        }

        String userId = SysUserUtils.getCurrentPrincipleID();
        SysUser user = this.getOne(new QueryWrapper<SysUser>()
                .eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("status", StatusEnum.Enable.getKey())
                .eq("id", userId), false);
        if (null == user) {
            throw new CommonException(ServiceErrorCode.USER_NOT_FOUND);
        }

        PasswordEncoder passwordEncoder
                = PasswordEncoderFactories.createDelegatingPasswordEncoder();
        if (!passwordEncoder.matches(password, user.getPassword())) {
            throw new CommonException(CommonErrorCode.PARAM_IS_ERROR, "原密码错误");
        }

        String entryPassword = passwordEncoder.encode(modifyPassword);
        user.setPassword(entryPassword);
        user.setGmtModified(DateUtil.now());
        user.setModifier(userId);
        this.updateById(user);
        return true;
    }

    /**
     * 登录
     *
     * @return 登录相关信息
     */
    public LoginDTO getUserOrgMenu() {
        LoginDTO data = new LoginDTO();

        Long userId = Long.parseLong(SysUserUtils.getCurrentPrincipleID());
        SysUser user = this.getOne(new QueryWrapper<SysUser>()
                .eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("status", StatusEnum.Enable.getKey())
                .eq("id", userId), false);
        if (user == null) {
            throw new CommonException(CommonErrorCode.SERVER_IS_ERROR,
                    "用户不存在【" + userId + "】");
        }
        //添加用户
        UserLoginDTO userLoginDTO = new UserLoginDTO();
        BeanUtil.copyProperties(user, userLoginDTO);
        data.setUserLoginDTO(userLoginDTO);

        //添加医院信息
        if (user.getType().equals(ConstantEnum.OUTER_USER.getKey())) {
            QueryWrapper<HospitalInfo> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                    .eq("id", SysUserUtils.getCurrentHospitalID());
            HospitalInfo hospitalInfo = hospitalInfoFacade.getOne(queryWrapper, false);
            HospitalLoginDTO hospitalLoginDTO = new HospitalLoginDTO();
            BeanUtil.copyProperties(hospitalInfo, hospitalLoginDTO);
            data.setHospitalLoginDTO(hospitalLoginDTO);
        }

        //添加菜单信息
        List<SysMenuWrapper> menuList = sysMenuFacade.getByRole(user.getId());
        Map<Long, List<SysMenuWrapper>> menuMap = EntityUtil.makeEntityListMap(menuList, "parentId");
        List<SysMenuWrapper> menuRes = menuMap.get(-1L);
//        if (StringUtil.isNotEmpty(user.getRemark())){
//            menuRes = menuRes.stream().filter(e -> "CDSS-YXSYK".equalsIgnoreCase(e.getCode())).collect(Collectors.toList());
//        }
        if (ListUtil.isNotEmpty(menuRes)){
            for (SysMenuWrapper bean : menuRes) {
                getSonMenu(bean, menuMap);
            }
        }
        data.setMenuWrappers(menuRes);
        return data;
    }


    /**
     * 递归获取菜单结构
     *
     * @param menu    当前菜单
     * @param menuMap 菜单集
     * @return 菜单结构
     */
    public List<SysMenuWrapper> getSonMenu(SysMenuWrapper menu,
                                           Map<Long, List<SysMenuWrapper>> menuMap) {
        List<SysMenuWrapper> res = new ArrayList<>();
        List<SysMenuWrapper> list = menuMap.get(menu.getId());
        if (ListUtil.isNotEmpty(list)) {
            menu.setSubMenuList(list);
            for (SysMenuWrapper bean : list) {
                getSonMenu(bean, menuMap);
            }
        }
        return res;
    }

    /**
     * 根据用户ID列表获取用户数据
     *
     * @param ids 用户ID列表
     * @return 用户名信息列表
     */
    public Map<String, String> getUserInfoByIds(List<String> ids) {
        List<Long> longList
                = ids.stream().map(r -> Long.valueOf(r)).distinct().collect(Collectors.toList());

        Map<String, String> map = new HashMap<>();
        if (ListUtil.isNotEmpty(longList)) {
            List<SysUser> userList = this.getByIds(longList);
            if (ListUtil.isNotEmpty(userList)) {
                map = userList.stream()
                        .collect(Collectors.toMap(k -> k.getId().toString(), v -> v.getLinkman()));
            }
        }
        return map;
    }

    /**
     * 注册
     *
     * @param userSaveVO 参数
     * @return 用户信息
     */
    public JwtDTO createUserAndGetJwt(UserSaveVO userSaveVO) {
        SysUser user = new SysUser();
        BeanUtil.copyProperties(userSaveVO, user);
        QueryWrapper<SysUser> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.eq("username", user.getUsername())
                .eq("status", StatusEnum.Enable.getKey())
                .eq("is_deleted", IsDeleteEnum.N.getKey());
        SysUser bean = this.getOne(userQueryWrapper, false);
        String password = "{bcrypt}$2a$10$qhV.bPLz1xsjQKQc35Ohz.oMU2y.lffnogvLEK69u3Z1rbLpQVFh2";
        if (bean == null) {
            user.setGmtCreate(new Date());
            user.setPassword(password);
            user.setLinkman(user.getUsername());
//            user.setPhone(userSaveVO.getUsername());
            this.save(user);

            SysUserRole userRole = new SysUserRole();
            userRole.setUserId(user.getId());
            userRole.setRoleId(1L);
            userRole.setGmtCreate(new Date());
            userRole.setGmtModified(new Date());
            sysUserRoleFacade.save(userRole);

            SysUserHospital userHospital = new SysUserHospital();
            userHospital.setHospitalId(51L);
            userHospital.setUserId(user.getId());
            sysUserHospitalFacade.save(userHospital);
        }else {
            password = bean.getPassword();
        }
        JwtDTO data = new JwtDTO();
        JWT jwt = authServiceClient.getToken("Basic dWFhLXNlcnZpY2U6MTIzNDU2",
                "password", user.getUsername(), password);
        if (null == jwt) {
            throw new CommonException(ServiceErrorCode.GET_TOKEN_FAIL);
        }
        data.setAccessToken(jwt.getAccess_token());
        data.setRefreshToken(jwt.getRefresh_token());
        data.setType(user.getType());
        data.setTypeCn(ConstantEnum.getName(user.getType()));//返回中文
        //token存入redis
        JwtStore jwtStore = new JwtStore();
        jwtStore.setAccessToken(jwt.getAccess_token());
        jwtStore.setRefreshToken(jwt.getRefresh_token());
        tokenFacade.createToken(jwtStore);
        return data;
    }

}