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

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

import cn.dev33.satoken.stp.StpUtil;
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.CacheUtil;
import com.fdkankan.manage.common.OssPath;
import com.fdkankan.manage.common.ResultCode;
import com.fdkankan.manage.entity.*;
import com.fdkankan.manage.exception.BusinessException;
import com.fdkankan.manage.common.PageInfo;
import com.fdkankan.manage.httpClient.service.LaserService;
import com.fdkankan.manage.mapper.IUserMapper;
import com.fdkankan.manage.service.*;
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.UserVo;
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 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 ICameraService cameraService;
    @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 IDownloadOrderMgService downloadOrderMgService;


    @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());
        }
        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);
        }

        downloadOrderMgService.addOrder(param);

        LambdaUpdateWrapper<User> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(User::getId,user.getId());
        if(param.getDownType() == 0){
            wrapper.setSql("download_num_total = download_num_total + " + param.getCount());
        }
        if(param.getDownType() == 1){
            wrapper.setSql("ss_download_num_total = ss_download_num_total + " + param.getCount());
        }
        this.update(wrapper);
    }


    @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<>();
        if(userList.size() >0){
            List<Long> userIdList = userList.parallelStream().map(User::getId).collect(Collectors.toList());
            Set<Long> sysUserIds = userList.stream().map(User::getSysUserId).collect(Collectors.toSet());
            HashMap<Long, SysUser> sysMap = sysUserService.getByIds(sysUserIds);

            HashMap<Long,Long> incrementCountMap = userIncrementService.getValidCountGroupByUserId(userIdList);
            HashMap<Long,Long> cameraCountMap = cameraDetailService.getCountGroupByUserId(userIdList);
            HashMap<Long,Long> sceneCountMap = sceneService.getCountGroupByUserId(userIdList);
            HashMap<Long,Long> sceneProCountMap = sceneProService.getCountGroupByUserId(userIdList,0);
            HashMap<Long,Long> scenePlusCountMap = scenePlusService.getCountGroupByUserId(userIdList,0);
           // HashMap<Long,Long> sceneProCountObjMap = sceneProService.getCountGroupByUserId(userIdList,1);
          //  HashMap<Long,Long> scenePlusCountObjMap = scenePlusService.getCountGroupByUserId(userIdList,1);

            for (User user :userList) {
                long incrementCount = incrementCountMap.get(user.getId()) == null ? 0 : incrementCountMap.get(user.getId());
                long cameraCount = cameraCountMap.get(user.getId()) == null ? 0 : cameraCountMap.get(user.getId());
                long sceneCount = sceneCountMap.get(user.getId()) == null ? 0 : sceneCountMap.get(user.getId());
                long sceneProCount = sceneProCountMap.get(user.getId()) == null ? 0 : sceneProCountMap.get(user.getId());
                long scenePlusCount = scenePlusCountMap.get(user.getId()) == null ? 0 : scenePlusCountMap.get(user.getId());
                //  long sceneProObjCount = sceneProCountObjMap.get(user.getId()) == null ? 0 : sceneProCountObjMap.get(user.getId());
                //  long scenePlusObjCount = scenePlusCountObjMap.get(user.getId()) == null ? 0 : scenePlusCountObjMap.get(user.getId());

                Long ssNum = 0L;
                if(!CacheUtil.uploadType.equals("local")){
                    SceneParam param = new SceneParam();
                    param.setUserName(user.getUserName());
                    PageInfo pageInfo = laserService.pageList(param);
                    ssNum =  pageInfo.getTotal();
                }

                UserVo vo = new UserVo();
                BeanUtils.copyProperties(user,vo);
                vo.setVip(incrementCount  > 0 ? 1: 0);
                vo.setIncrementCount(incrementCount);
                vo.setSurDownNum(user.getDownloadNumTotal() - user.getDownloadNum());
                vo.setSurSSDownNum(user.getSsDownloadNumTotal() - user.getSsDownloadNum());
                vo.setCameraCount(cameraCount);
                vo.setSceneNum(sceneCount + sceneProCount + scenePlusCount + ssNum);
                if(user.getSysUserId() != null){
                    SysUser sysUser = sysMap.get(user.getSysUserId());
                    if(sysUser != null){
                        vo.setSysUserName(sysUser.getNickName());
                    }
                }
                voList.add(vo);
            }
        }
        return voList;
    }

    @Override
    public HashMap<Long, User> getByIds(List<Long> userIds) {
        HashMap<Long,User> map = new HashMap<>();
        if(userIds.isEmpty()){
            return map;
        }
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(User::getId,userIds);
        List<User> list = this.list(wrapper);
        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 Boolean checkUserName(String userName) {
        List<User> userList = this.getByUserName(userName);
        if(userList == null || userList.size() <=0){
            return false;
        }
        return true;
    }

    @Override
    public synchronized void addUcenterUser(UserParam param) {
        if(StringUtils.isBlank(param.getUserName()) || StringUtils.isBlank(param.getNickName()) || StringUtils.isBlank(param.getPassword())){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        Boolean ubo = this.checkUserName(param.getUserName());
        if(ubo){
            throw new BusinessException(ResultCode.USER_EXIST);
        }
        try {
            String passwordMd5 = SecurityUtil.MD5(Base64Converter.decode(Base64Converter.subText(param.getPassword())));
            User user = new User();
            user.setHead(host + OssPath.default_head);
            user.setPassword(passwordMd5);
            user.setStatus(1);
            user.setIsNotice(1);
            user.setRegisterTime(DateUtils.getDate(new Date()));
            user.setUserName(param.getUserName());
            user.setNickName(param.getNickName());
            user.setCountry("86");
            user.setDownloadNumTotal(1000);
            user.setDownloadNum(0);
            user.setCreateTime(DateUtils.getDate(new Date()));
            user.setRecStatus("A");
            user.setUpdateTime(DateUtils.getDate(new Date()));
            user.setSysUserId(Long.valueOf((String) StpUtil.getLoginId()));
            this.save(user);

        }catch (Exception e){
            log.error("ReUcenterUserPassword：error",e);
            throw new BusinessException(ResultCode.PASSWORD_ERROR_G);
        }

    }

    @Override
    public void delUcenterUser(UserParam userParam) {
        if(userParam.getId() == null){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        List<CameraDetail> list = cameraDetailService.getByUserId(userParam.getId());
        if(list != null && list.size() >0){
            throw new BusinessException(ResultCode.DEL_UCENTER_ERROR);
        }

        this.removeById(userParam.getId());
    }

    @Override
    public void ReUcenterUserPassword(UserParam userParam) {
        if(userParam.getId() == null || StringUtils.isBlank(userParam.getNewPassword())){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        try {
            String passwordMd5 = SecurityUtil.MD5(Base64Converter.decode(Base64Converter.subText(userParam.getNewPassword())));
            LambdaUpdateWrapper<User> wrapper = new LambdaUpdateWrapper<>();
            wrapper.eq(User::getId,userParam.getId());
            wrapper.set(User::getPassword,passwordMd5);
            this.update(wrapper);
        }catch (Exception e){
            log.error("ReUcenterUserPassword：error",e);
            throw new BusinessException(ResultCode.PASSWORD_ERROR_G);
        }

    }

    @Override
    public void updateUcenterUser(UserParam userParam) {
        if(userParam.getId() == null || StringUtils.isBlank(userParam.getNickName())){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        LambdaUpdateWrapper<User> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(User::getId,userParam.getId());
        wrapper.set(User::getNickName,userParam.getNickName());
        this.update(wrapper);
    }

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

    @Override
    public HashMap<String, User> getUserBySn(Set<String> snCodes) {
        HashMap<Long,User> map = new HashMap<>();
        HashMap<String,User> mapUser = new HashMap<>();
        List<Camera> cameraList = cameraService.getBySnCodes(snCodes);
        List<Long> cameraIds = cameraList.parallelStream().map(Camera::getId).collect(Collectors.toList());
        List<CameraDetail> cameraDetails = cameraDetailService.getByCameraIds(cameraIds);
        List<Long> userIds = cameraDetails.parallelStream().map(CameraDetail::getUserId).collect(Collectors.toList());
        HashMap<Long, User> useMap  = this.getByIds(userIds);

        for (CameraDetail cameraDetail : cameraDetails) {
            if(cameraDetail.getUserId() != null){
                User user = useMap.get(cameraDetail.getUserId());
                if(user != null){
                    map.put(cameraDetail.getCameraId(),user);
                }
            }
        }

        cameraList.forEach(e -> mapUser.put(e.getSnCode(),map.get(e.getId())));

        return mapUser;
    }
}