4dkankan-center-manage/src/main/java/com/fdkankan/manage/service/impl/UserServiceImpl.java

package com.fdkankan.manage.service.impl;
import java.util.Date;
import java.util.*;

import cn.dev33.satoken.stp.StpUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.common.util.Base64Converter;
import com.fdkankan.common.util.SecurityUtil;
import com.fdkankan.manage.common.*;
import com.fdkankan.manage.entity.*;
import com.fdkankan.manage.exception.BusinessException;
import com.fdkankan.manage.httpClient.service.LaserService;
import com.fdkankan.manage.mapper.IUserMapper;
import com.fdkankan.manage.service.*;
import com.fdkankan.manage.util.AesUtil;
import com.fdkankan.manage.util.Dateutils;
import com.fdkankan.manage.vo.request.SceneParam;
import com.fdkankan.manage.vo.request.UserIncrementParam;
import com.fdkankan.manage.vo.request.UserParam;
import com.fdkankan.manage.vo.response.ManageLoginResponse;
import com.fdkankan.manage.vo.response.UserVo;
import com.fdkankan.redis.util.RedisUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.stream.Collectors;

/**
 * <p>
 * 用户信息表 服务实现类
 * </p>
 *
 * @author 
 * @since 2022-06-16
 */
@Service
public class UserServiceImpl extends ServiceImpl<IUserMapper, User> implements IUserService {

    @Autowired
    private IUserIncrementService userIncrementService;
    @Autowired
    private ICameraDetailService cameraDetailService;
    @Autowired
    private ISceneService sceneService;
    @Autowired
    private ISceneProService sceneProService;
    @Autowired
    private IScenePlusService scenePlusService;
    @Autowired
    private LaserService laserService;
    @Autowired
    private ISysUserService sysUserService;
    @Value("${fyun.host:https://4dkk.4dage.com/}")
    private String host;
    @Autowired
    private IJyUserService jyUserService;
    @Autowired
    private IJySceneUserAuthService jySceneUserAuthService;
    @Autowired
    ManageService manageService;
    @Autowired
    IJyPlatformService jyPlatformService;
    @Autowired
    IJyUserPlatformService jyUserPlatformService;

    @Override
    public PageInfo pageList(UserParam param) {
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        if(StringUtils.isNotBlank(param.getUserName())){
            wrapper.like(User::getUserName,param.getUserName());
        }
        if(StringUtils.isNotBlank(param.getEmail())){
            wrapper.like(User::getEmail,param.getEmail());
        }
        if(StringUtils.isNotBlank(param.getNickName())){
            wrapper.like(User::getNickName,param.getNickName());
        }
        wrapper.orderByDesc(User::getCreateTime);
        Page<User> page = this.page(new Page<>(param.getPageNum(), param.getPageSize()), wrapper);
        List<User> records = page.getRecords();
        List<UserVo> userVo = getUserVo(records);
        Page<UserVo> pageVo = new Page<>(page.getCurrent(),page.getSize());
        pageVo.setTotal(page.getTotal());
        pageVo.setRecords(userVo);
        return PageInfo.PageInfo(pageVo);
    }

    @Override
    public void addDownNum(UserIncrementParam param) {
        User user = this.getById(param.getUserId());
        if(user == null){
            throw new BusinessException(ResultCode.USER_NOT_EXIST);
        }
        Integer totalNum = user.getDownloadNumTotal() == null ? 0 : user.getDownloadNumTotal() + param.getCount();
        user.setDownloadNumTotal(totalNum);
        this.updateById(user);
    }

    @Override
    public List<UserVo>  userDetail(Integer userId) {
        User user = this.getById(userId);
        if(user!=null){
            return getUserVo(Arrays.asList(user));
        }
        return new ArrayList<>();
    }

    private List<UserVo> getUserVo(List<User> userList){
        List<UserVo> voList = new ArrayList<>();
        Set<Long> collect = userList.stream().map(User::getId).collect(Collectors.toSet());
        HashMap<Long, JyUser> mapByUserIds = jyUserService.getMapByUserIds(collect);
        if(userList.size() >0){
            for (User user :userList) {
                UserVo vo = new UserVo();
                BeanUtils.copyProperties(user,vo);
                JyUser jyUser = mapByUserIds.get(user.getId());
                if(jyUser !=null){
                    vo.setRyId(jyUser.getRyId());
                    SysUser sysUser = sysUserService.getById(jyUser.getSysUserId());
                    if(sysUser !=null){
                        vo.setStatus(sysUser.getStatus());
                    }
                }

                voList.add(vo);
            }
        }
        return voList;
    }

    @Override
    public HashMap<Long, User> getByIds(List<Long> userIds) {
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(User::getId,userIds);
        List<User> list = this.list(wrapper);
        HashMap<Long,User> map = new HashMap<>();
        list.forEach(entity -> map.put(entity.getId(),entity));
        return map;
    }

    @Override
    public List<User> getByUserName(String userName) {
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(User::getUserName,userName);
        return  this.list(wrapper);
    }

    @Override
    public List<User> getLikeUserName(String userName) {
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(User::getUserName,userName);
        return  this.list(wrapper);
    }

    @Override
    public Boolean checkUserName(String userName) {
        List<User> userList = this.getByUserName(userName);
        if(userList == null || userList.size() <=0){
            return false;
        }
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public synchronized void addUcenterUser(UserParam param) {
        if( StringUtils.isBlank(param.getNickName()) || StringUtils.isBlank(param.getPassword())
            || StringUtils.isBlank(param.getRyId()) || StringUtils.isBlank(param.getRyNo())){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        String  password = AesUtil.desEncrypt(param.getPassword());
        if(StringUtils.isBlank(password)){
            throw new BusinessException(ResultCode.PASSWORD_ERROR_G);
        }

        String passwordMd5 = SecurityUtil.MD5(password);
        String passwordMd52 = SecurityUtil.MD52(password);

        JyUser jyUser = jyUserService.getByRyId(param.getRyId());

        JyUser jyUser2 = jyUserService.getByRyNo(param.getRyNo());

        if(StringUtils.isNotBlank(param.getIdCard())){
            JyUser byIdCard = jyUserService.getByIdCard(param.getIdCard());
            if(jyUser == null && byIdCard!= null){
                throw new BusinessException(ResultCode.ID_CARD_EXIT);
            }
            if(jyUser != null  && byIdCard != null && !jyUser.getId().equals(byIdCard.getId())){
                throw new BusinessException(ResultCode.ID_CARD_EXIT);
            }
        }

        if(jyUser == null && jyUser2!=null){
            throw new BusinessException(ResultCode.RYNO_EXITS);
        }
        if(jyUser != null && jyUser2 != null && !jyUser2.getId().equals(jyUser.getId())){
            throw new BusinessException(ResultCode.RYNO_EXITS);
        }
        boolean init = false;
        if(jyUser == null){
            jyUser = new JyUser();
            init = true;
        }

        User user = this.addUser(jyUser.getUserId(),passwordMd5, param.getRyNo(), param.getNickName());
        SysUser sysUser = this.addSysUser(jyUser.getSysUserId(),passwordMd52, param.getRyNo(), param.getNickName());
        jyUser.setRyId(param.getRyId());
        jyUser.setRyPassword(passwordMd52);
        jyUser.setRyNo(param.getRyNo());
        jyUser.setRyNickName(param.getNickName());
        jyUser.setUserId(user.getId());
        jyUser.setSysUserId(sysUser.getId());
        jyUser.setUpdateTime(null);
        jyUser.setPhone(param.getPhone());
        jyUser.setIsJm(param.getIsJm());
        jyUser.setIdCard(param.getIdCard());
        jyUserService.saveOrUpdate(jyUser);

        if(init && StringUtils.isNotBlank(param.getIdCard()) && param.getIsJm()!=null && param.getIsJm() != 1){
            JyUserPlatform jyUserPlatform = jyUserPlatformService.getByIdCard(param.getIdCard());
            JyPlatform jyPlatform = jyPlatformService.getById(jyUserPlatform.getPlatformId());
            if(jyPlatform != null){
                jyUserPlatformService.bindJyUserId(jyUserPlatform.getId(),jyUser.getId());
                if(param.getIdCard().equals(jyPlatform.getIdCard())){
                    sysUserService.updateRoleId(sysUser.getId(),48);
                }
            }
        }
    }


    private User addUser(Long userId, String passwordMd5, String userName, String nickName){
        User user = new User();
        user.setId(userId);
        user.setHead(host + OssPath.default_head);
        user.setPassword(passwordMd5);
        user.setStatus(1);
        user.setIsNotice(1);
        user.setUserName(userName);
        user.setNickName(nickName);
        user.setCountry("86");
        user.setDownloadNumTotal(1000);
        user.setDownloadNum(0);
        user.setRecStatus("A");
        if(userId == null){
            user.setRegisterTime(new Date());
        }
        this.saveOrUpdate(user);
        return user;
    }

    private SysUser addSysUser(Long sysUserId,String passwordMd5, String ryNo, String nickName) {
        SysUser sysUser = new SysUser();
        sysUser.setId(sysUserId);
        sysUser.setUserName(ryNo);
        sysUser.setPassword(passwordMd5);
        sysUser.setNickName(nickName);
        if(sysUserId == null){
            sysUser.setRoleId(47L);
        }
        sysUser.setUpdateTime(null);
        sysUserService.saveOrUpdate(sysUser);
        return sysUser;
    }

    @Override
    public void delUcenterUser(UserParam userParam) {
        if(StringUtils.isBlank(userParam.getRyId())){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        JyUser jyuser = jyUserService.getByRyId(userParam.getRyId());
        if(jyuser == null){
            throw new BusinessException(ResultCode.JY_ID_NO_EXIST);
        }

        //将相机和场景归属超管
        cameraDetailService.giveSuperAdmin(jyuser.getUserId());

        this.removeById(jyuser.getUserId());
        sysUserService.removeById(jyuser.getSysUserId());
        jySceneUserAuthService.delByJyUserId(jyuser.getId());
        jyUserService.removeById(jyuser.getId());
    }

    @Override
    public void updateStatus(UserParam userParam) {
        if((StringUtils.isNotBlank(userParam.getRyNo()) &&  StringUtils.isBlank(userParam.getRyNo())) || userParam.getStatus() == null){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        JyUser jyuser = null;
        if(StringUtils.isNotBlank(userParam.getRyId())){
            jyuser = jyUserService.getByRyId(userParam.getRyId());
        }
        if(StringUtils.isNotBlank(userParam.getRyNo())){
            jyuser = jyUserService.getByRyNo(userParam.getRyNo());
        }
        if(StringUtils.isNotBlank(userParam.getRyId()) && StringUtils.isNotBlank(userParam.getRyNo())){
            if(! (jyuser.getRyId().equals(userParam.getRyId()) && jyuser.getRyNo().equals(userParam.getRyNo()))){
                throw new BusinessException(ResultCode.JY_ID_NO_EXIST);
            }
        }
        if(jyuser == null){
            throw new BusinessException(ResultCode.JY_ID_NO_EXIST);
        }

        if(userParam.getStatus() == 0){
            //将相机和场景归属超管
            cameraDetailService.giveSuperAdmin(jyuser.getUserId());
        }
        manageService.updateLoginUserStatus(jyuser.getRyNo(),userParam.getStatus());

        LambdaUpdateWrapper<SysUser> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(SysUser::getId,jyuser.getSysUserId());
        wrapper.set(SysUser::getStatus,userParam.getStatus());
        sysUserService.update(wrapper);

        LambdaUpdateWrapper<JyUser> wrapper2 = new LambdaUpdateWrapper<>();
        wrapper2.eq(JyUser::getId,jyuser.getId());
        wrapper2.set(JyUser::getStatus,userParam.getStatus());
        jyUserService.update(wrapper2);

    }
}