4dkankan-fusion/src/main/java/com/fdkankan/fusion/service/impl/TmUserServiceImpl.java

package com.fdkankan.fusion.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fdkankan.fusion.common.PageInfo;
import com.fdkankan.fusion.common.enums.IdPreEnum;
import com.fdkankan.fusion.common.util.Base64Converter;
import com.fdkankan.fusion.common.util.IdUtils;
import com.fdkankan.fusion.config.SecurityUtil;
import com.fdkankan.fusion.httpClient.response.FdkkLoginVo;


import cn.hutool.core.collection.CollectionUtil;
import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.fdkankan.fusion.common.ResultCode;
import com.fdkankan.fusion.common.util.RedisKeyUtil;
import com.fdkankan.fusion.entity.*;
import com.fdkankan.fusion.exception.BusinessException;
import com.fdkankan.fusion.httpClient.client.FdKKClient;
import com.fdkankan.fusion.httpClient.request.FdkkLoginRequest;
import com.fdkankan.fusion.httpClient.response.FdkkResponse;
import com.fdkankan.fusion.mapper.ITmUserMapper;
import com.fdkankan.fusion.response.UserAddRequest;
import com.fdkankan.fusion.service.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.redis.util.RedisUtil;
import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.annotations.Param;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * <p>
 * 用户信息表 服务实现类
 * </p>
 *
 * @author 
 * @since 2023-07-28
 */
@Service
public class TmUserServiceImpl extends ServiceImpl<ITmUserMapper, TmUser> implements ITmUserService {

    @Autowired
    ITmPermissionService tmPermissionService;
    @Autowired
    ITmUserRoleService tmUserRoleService;
    @Autowired
    ITmRoleService tmRoleService;
    @Autowired
    ITmRolePermissionService tmRolePermissionService;
    @Autowired
    ITmDepartmentService tmDepartmentService;
    @Autowired
    ITmCameraService tmCameraService;
    @Autowired
    FdKKClient fdKKClient;
    @Autowired
    RedisUtil redisUtil;
    @Autowired
    IUserService userService;

    @Override
    public void setRoleAndPermToRedis(TmUser tmUser) {
        String redisKeyMenu = String.format(RedisKeyUtil.MANAGE_PERM_USER, tmUser.getId());
        String redisKeyRole = String.format(RedisKeyUtil.MANAGE_ROLE_USER, tmUser.getId());

        List<TmUserRole> userRoles = tmUserRoleService.getByUserId(tmUser.getId());
        if(CollectionUtil.isEmpty(userRoles)){
            throw new BusinessException(ResultCode.NOT_ROLE);
        }
        List<String> roleIds = userRoles.stream().map(TmUserRole::getRoleId).collect(Collectors.toList());
        List<TmRole> tmRoles = tmRoleService.listByIds(roleIds);
        if(CollectionUtil.isEmpty(tmRoles)){
            throw new BusinessException(ResultCode.NOT_ROLE);
        }
        List<String> roleKeys = tmRoles.stream().map(TmRole::getRoleKey).collect(Collectors.toList());
        List<TmRolePermission> tmRolePermissions = tmRolePermissionService.getByRoleIds(roleIds);
        if(CollectionUtil.isEmpty(tmRolePermissions)){
            throw new BusinessException(ResultCode.NOT_PERMISSION);
        }
        List<String> permIds = tmRolePermissions.stream().map(TmRolePermission::getPermissionId).collect(Collectors.toList());
        List<TmPermission> tmPermissions = tmPermissionService.listByIds(permIds);
        if(CollectionUtil.isEmpty(tmPermissions)){
            throw new BusinessException(ResultCode.NOT_PERMISSION);
        }
        List<String> permsList = tmPermissions.stream().map(TmPermission::getPerms).collect(Collectors.toList());
        tmUser.setPermsList(permsList);
        tmUser.setRoleList(roleKeys);
        tmUser.setRoleIdList(roleIds);

        TmDepartment tmDepartment = tmDepartmentService.getById(tmUser.getDeptId());
        if(tmDepartment !=null){
            tmUser.setDeptName(tmDepartment.getName());
            tmUser.setDeptLevel(tmDepartment.getDeptType());
        }
        redisUtil.set(redisKeyMenu, JSONArray.toJSONString(permsList),RedisKeyUtil.tokenTime);
        redisUtil.set(redisKeyRole,JSONArray.toJSONString(roleKeys),RedisKeyUtil.tokenTime);
    }

    @Override
    public TmUser getByUserName(String phoneNum) {
        LambdaQueryWrapper<TmUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(TmUser::getUserName,phoneNum);
        return this.getOne(wrapper);
    }

    @Override
    public void addUser(UserAddRequest param) {
        if (!StringUtils.isNoneBlank(param.getUserName(), param.getNickName(),
                param.getRoleId(), param.getPassword(),param.getDeptId())) {
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        TmUser tmUser = this.getByUserName(param.getUserName());
        if(tmUser != null){
            throw new BusinessException(ResultCode.USER_EXIST);
        }
        TmRole role = tmRoleService.getById(param.getRoleId());
        if(role == null){
            throw new BusinessException(ResultCode.NOT_ROLE);
        }
        TmDepartment tmDepartment = tmDepartmentService.getById(param.getDeptId());
        if(tmDepartment == null){
            throw new BusinessException(ResultCode.NOT_DEPT);
        }
        FdkkLoginRequest request = new FdkkLoginRequest(param.getUserName(),param.getPassword(),param.getPassword());
        FdkkResponse fdkkResponse = fdKKClient.fdkkRegister(request);
        if(fdkkResponse.getCode() == 0 ){
            this.addNewUser(param,role);
            return;
        }
        if(fdkkResponse.getCode() == 3008 ){
            this.addNewUser(param,role);
            throw new BusinessException(ResultCode.USER_IS_REGISTER);
        }
        throw new BusinessException(fdkkResponse.getCode(),fdkkResponse.getMsg());

    }

    private void addNewUser(UserAddRequest param,TmRole tmRole) {
        TmUser tmUser = new TmUser();
        String id = IdUtils.genId(IdPreEnum.USER_PRE.getPre());
        tmUser.setId(id);
        tmUser.setDeptId(param.getDeptId());
        tmUser.setUserName(param.getUserName());
        tmUser.setNickName(param.getNickName());
        this.save(tmUser);

        tmUserRoleService.add(id,tmRole.getId());

    }

    @Override
    public void editUser(UserAddRequest param) {
        if (!StringUtils.isNoneBlank( param.getId())) {
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }

        TmUser tmUser = this.getById(param.getId());
        if(tmUser == null){
            throw new BusinessException(ResultCode.USER_NOT_EXIST);
        }
        if(param.getDeptId() != null && !tmUser.getDeptId().equals(param.getDeptId())){
            List<TmCamera> cameras = tmCameraService.getByUserId(tmUser.getId());
            if(CollectionUtil.isNotEmpty(cameras)){
                throw new BusinessException(ResultCode.USER_HAVE_CAMERA);
            }
        }

        LambdaUpdateWrapper<TmUser> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(TmUser::getId,param.getId());
        if(StringUtils.isNotBlank(param.getDeptId())){
            wrapper.set(TmUser::getDeptId,param.getDeptId());
        }
        if(StringUtils.isNotBlank(param.getNickName())){
            wrapper.set(TmUser::getNickName,param.getNickName());
        }
        this.update(wrapper);

        if(StringUtils.isNotBlank(param.getRoleId())){
            tmUserRoleService.updateByUserId(param.getId(),param.getRoleId());
            this.setRoleAndPermToRedis(tmUser);
        }
    }

    @Override
    public void changePassword(UserAddRequest param) {
        if(StringUtils.isBlank(param.getUserName()) || StringUtils.isBlank(param.getPassword())
                || StringUtils.isBlank(param.getConfirmPwd()) || StringUtils.isBlank(param.getOldPassword())){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        TmUser tmUser = this.getByUserName(param.getUserName());
        if(tmUser == null){
            throw new BusinessException(ResultCode.USER_NOT_EXIST);
        }
        User user = userService.getByUserName(param.getUserName());
        if(user == null){
            throw new BusinessException(ResultCode.USER_NOT_EXIST);
        }
        if (!StringUtils.equals(param.getPassword(), param.getConfirmPwd())) {
            throw new BusinessException(ResultCode.USER_PASSWORD_ERROR);
        }
        if(StringUtils.isBlank(param.getClear()) || !param.getClear().equals("YES")) {
            String password = Base64Converter.decode(Base64Converter.subText(param.getOldPassword()));
            String passwordCode = SecurityUtil.MD5(password);
            if(!user.getPassword().equals(passwordCode)){
                throw new BusinessException(ResultCode.PROJECT_PASSWORD_ERROR);
            }
        }

        FdkkLoginRequest request = new FdkkLoginRequest(param.getUserName(),param.getPassword(),param.getConfirmPwd());
        request.setClear(param.getClear());
        FdkkResponse fdkkResponse = fdKKClient.fdkkChangePassword(request);
        if(fdkkResponse.getCode() != 0){
            throw new BusinessException(fdkkResponse.getCode(),fdkkResponse.getMsg());
        }
    }

    @Override
    public FdkkResponse getMsgAuthCode(String phoneNum) {
        if(StringUtils.isBlank(phoneNum)){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        TmUser tmUser = this.getByUserName(phoneNum);
        if(tmUser == null){
            throw new BusinessException(ResultCode.USER_NOT_EXIST);
        }
        FdkkLoginRequest request = new FdkkLoginRequest(phoneNum);
        FdkkResponse fdkkResponse = fdKKClient.fdkkGetMsgAuthCode(request);
        if(fdkkResponse.getCode() != 0){
            throw new BusinessException(fdkkResponse.getCode(),fdkkResponse.getMsg());
        }
        return fdkkResponse;
    }

    @Override
    public void changeStatus(UserAddRequest param) {
        if(StringUtils.isBlank(param.getId()) || param.getStatus() == null){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        LambdaUpdateWrapper<TmUser> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(TmUser::getId,param.getId());
        wrapper.set(TmUser::getStatus,param.getStatus());
        this.update(wrapper);

        if(redisUtil.hasKey(String.format(RedisKeyUtil.fusionLoginUser, param.getId()))){
            String value = redisUtil.get(String.format(RedisKeyUtil.fusionLoginUser, param.getId()));
            FdkkLoginVo fdkkLoginVo = JSONObject.parseObject(value,FdkkLoginVo.class);
            fdkkLoginVo.getTmUser().setStatus(param.getStatus());
            redisUtil.set(String.format(RedisKeyUtil.fusionLoginUser, param.getId()),JSONObject.toJSONString(fdkkLoginVo));
        }

    }

    @Override
    public void delUser(UserAddRequest param) {
        if(StringUtils.isBlank(param.getId())){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        List<TmCamera> cameras = tmCameraService.getByUserId(param.getId());
        if(CollectionUtil.isNotEmpty(cameras)){
            tmCameraService.unBind(cameras);
        }
        String redisKey = String.format(RedisKeyUtil.fusionLoginUser,param.getId());
        if(redisUtil.hasKey(redisKey)){
            FdkkLoginVo fdkkLoginVo = JSONObject.parseObject(redisUtil.get(redisKey), FdkkLoginVo.class);
            redisUtil.del(String.format(RedisKeyUtil.fusionLoginToken,fdkkLoginVo.getToken()));
            redisUtil.del(String.format(RedisKeyUtil.fdToken,fdkkLoginVo.getFdToken()));
            redisUtil.del(redisKey);
        }
        this.removeById(param.getId());
    }

    @Override
    public List<TmUser> getByDeptId(String deptId) {
        LambdaQueryWrapper<TmUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(TmUser::getDeptId,deptId);
        return this.list(wrapper);
    }

    @Override
    public TmUser getLoginUser() {
        return null;
    }

    @Override
    public PageInfo pageList(String userName,String nickName, String deptId, Integer status, Long pageNum, Long pageSize) {
        LambdaQueryWrapper<TmUser> wrapper = new LambdaQueryWrapper<>();
        if(StringUtils.isNotBlank(userName)){
            wrapper.like(TmUser::getUserName,userName);
        }
        if(StringUtils.isNotBlank(nickName)){
            wrapper.like(TmUser::getNickName,nickName);
        }

        if(status != null){
            wrapper.eq(TmUser::getStatus,status);
        }
        List<String> deptIds = tmDepartmentService.getDeptIds();
        if(StringUtils.isNotBlank(deptId)){
            deptIds = tmDepartmentService.getSonByDeptIdAndDeptIds(deptIds,deptId);
        }
        wrapper.in(TmUser::getDeptId,deptIds);

        wrapper.orderByDesc(TmUser::getCreateTime);
        Page<TmUser> page = this.page(new Page<>(pageNum, pageSize), wrapper);
        Set<String> deptIdSet = page.getRecords().stream().map(TmUser::getDeptId).collect(Collectors.toSet());
        HashMap<String,TmDepartment> map = tmDepartmentService.getMapByDeptIds(deptIdSet);
        Set<String> userIds = page.getRecords().stream().map(TmUser::getId).collect(Collectors.toSet());
        HashMap<String,TmRole> roleMap = tmRoleService.getMapByUserIds(userIds);

        for (TmUser record : page.getRecords()) {
            TmDepartment tmDepartment = map.get(record.getDeptId());
            if(tmDepartment != null){
                record.setDeptName(tmDepartment.getName());
            }
            TmRole tmRole = roleMap.get(record.getId());
            if(tmRole !=null){
                record.setRoleId(tmRole.getId());
                record.setRoleKey(tmRole.getRoleKey());
                record.setRoleName(tmRole.getRoleName());
            }
        }
        return PageInfo.PageInfo(page);
    }

    @Override
    public Object getUserListSelect(String deptId) {
        LambdaQueryWrapper<TmUser> wrapper = new LambdaQueryWrapper<>();
        if(StringUtils.isNotBlank(deptId)){
            wrapper.eq(TmUser::getDeptId,deptId);
        }
        List<String> deptIds = tmDepartmentService.getDeptIds();
        if(deptIds.size() <=0){
            deptIds.add("not-dept");
        }
        wrapper.in(TmUser::getDeptId,deptIds);
        return this.list(wrapper);
    }

    @Override
    public HashMap<String, TmUser> getByIds(Set<String> createorIds) {
        HashMap<String, TmUser> map = new HashMap<>();
        LambdaQueryWrapper<TmUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(TmUser::getId,createorIds);
        List<TmUser> list = this.list(wrapper);
        for (TmUser tmUser : list) {
            map.put(tmUser.getId(),tmUser);
        }
        return map;
    }

    @Override
    public List<TmUser> getLikeNickName(String searchKey) {
        LambdaQueryWrapper<TmUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(TmUser::getNickName,searchKey);
        return this.list(wrapper);
    }

    @Override
    public HashMap<String, TmUser> getByCamera(List<TmCamera> records) {
        HashMap<String, TmUser> userMap = new HashMap<>();
        HashMap<String, TmUser> map = new HashMap<>();
        List<String> userIds = records.stream().map(TmCamera::getUserId).collect(Collectors.toList());
        if(userIds.size() >0){
            List<TmUser> tmUsers = this.listByIds(userIds);
            tmUsers.forEach(entity ->userMap.put(entity.getId(),entity));
            for (TmCamera record : records) {
                map.put(record.getCameraSn().toUpperCase(),userMap.get(record.getUserId()));
            }
        }
        return map;
    }

    @Override
    public List<TmUser> getByDeptIds(List<String> deptIds) {
        LambdaQueryWrapper<TmUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(TmUser::getDeptId,deptIds);
        return this.list(wrapper);
    }
}