4dkankan-smart-site/src/main/java/com/fdkankan/site/service/impl/ProjectTeamServiceImpl.java

package com.fdkankan.site.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fdkankan.site.common.PageInfo;
import com.fdkankan.site.common.ResultCode;
import com.fdkankan.site.common.util.VUtils;
import com.fdkankan.site.entity.*;
import com.fdkankan.site.entity.dto.ProjectTeamAddDTO;
import com.fdkankan.site.entity.dto.ProjectTeamDTO;
import com.fdkankan.site.entity.vo.TeamUserSelect;
import com.fdkankan.site.exception.BusinessException;
import com.fdkankan.site.httpClient.client.FdKKClient;
import com.fdkankan.site.httpClient.request.FdkkLoginRequest;
import com.fdkankan.site.httpClient.response.FdkkResponse;
import com.fdkankan.site.mapper.IProjectTeamMapper;
import com.fdkankan.site.request.ProjectTeamListParam;
import com.fdkankan.site.service.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.site.util.EscapeUtil;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import cn.hutool.core.util.StrUtil;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 
 * @since 2022-10-10
 */
@Service
public class ProjectTeamServiceImpl extends ServiceImpl<IProjectTeamMapper, ProjectTeam> implements IProjectTeamService {

    @Resource
    FdKKClient fdKKClient;
    @Autowired
    IProjectService projectService;
    @Autowired
    IUserService userService;
    @Autowired
    IUserRoleService userRoleService;
    @Autowired
    IMarkingUserService markingUserService;
    @Autowired
    IMarkingService markingService;
    @Autowired
    IRoleService roleService;

    @Override
    public List<ProjectTeam> getListByUserId(Integer userId) {
        LambdaQueryWrapper<ProjectTeam> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ProjectTeam::getUserId,userId);
        return this.list(wrapper);
    }

    @Override
    public ProjectTeam findByUserIdAndProjectId(Integer userId, Integer projectId) {
        LambdaQueryWrapper<ProjectTeam> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ProjectTeam::getUserId,userId);
        wrapper.eq(ProjectTeam::getProjectId,projectId);
        return getOne(wrapper);
    }

    @Override
    public List<ProjectTeam> getListByUserIdAndProjectId(Integer userId, Integer projectId) {
        LambdaQueryWrapper<ProjectTeam> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ProjectTeam::getUserId,userId);
        wrapper.eq(ProjectTeam::getProjectId,projectId);
        return this.list(wrapper);
    }

    @Override
    public void addProject(Integer projectId, String token) {
        ProjectTeam team = new ProjectTeam();
        team.setIsCreater(1);
        team.setProjectId(projectId);
        User user = userService.findByTokenCovUserName(token);
        team.setUserId(user.getUserId());
        team.setNickName(user.getUserName());
        team.setBindAccount(user.getUserName());
        this.save(team);
        Role manager = roleService.findByRoleKey("manager");
        UserRole userRole=new UserRole();
        userRole.setRoleId(manager.getRoleId());
        userRole.setUserId(user.getUserId());
        userRole.setProjectId(projectId);
        userRoleService.save(userRole);
    }

    @Override
    public Object pageList(ProjectTeamListParam param) {
        VUtils.isTure(param.getProjectId() == null).throwMessage(ResultCode.PARAM_MISS);
        projectService.checkTokenPer(param.getToken(),param.getProjectId());

        MPJLambdaWrapper<ProjectTeam> wrapper = new MPJLambdaWrapper<ProjectTeam>()
                .selectAll(ProjectTeam.class)
                .select(User::getUserName)
                .selectCollection(Role.class, ProjectTeamDTO::getRoles)
                .leftJoin(User.class, User::getUserId, ProjectTeam::getUserId)
                .leftJoin(UserRole.class,UserRole::getUserId,User::getUserId)
                .leftJoin(Role.class, Role::getRoleId, UserRole::getRoleId)
                .eq(ProjectTeam::getProjectId,param.getProjectId())
                .eq(UserRole::getProjectId,param.getProjectId())
                ;
        if(StringUtils.isNotBlank(param.getUserName())){
            wrapper.like(ProjectTeam::getNickName, param.getUserName());
        }
        IPage<ProjectTeamDTO> projectTeamIPage = baseMapper.selectJoinPage(new Page<>(param.getPageNum(), param.getPageSize()), ProjectTeamDTO.class, wrapper);
        return PageInfo.PageInfo(projectTeamIPage);
    }

    @Override
    public List<ProjectTeamDTO> findByProjectId(Integer projectId) {
        MPJLambdaWrapper<ProjectTeam> wrapper = new MPJLambdaWrapper<ProjectTeam>()
                .selectAll(ProjectTeam.class)
                .select(User::getUserName)
                .selectCollection(Role.class, ProjectTeamDTO::getRoles)
                .leftJoin(User.class, User::getUserId, ProjectTeam::getUserId)
                .leftJoin(UserRole.class,UserRole::getUserId,User::getUserId)
                .leftJoin(Role.class, Role::getRoleId, UserRole::getRoleId)
                .eq(ProjectTeam::getProjectId,projectId)
                .eq(UserRole::getProjectId,projectId)
                ;
        List<ProjectTeamDTO> projectTeamIPage = baseMapper.selectJoinList( ProjectTeamDTO.class, wrapper);
        return projectTeamIPage;

    }

    @Override
    public Object addUser(ProjectTeamAddDTO param, String token) {
        VUtils.isTure(param.getProjectId() == null || StringUtils.isBlank(param.getUserName())).throwMessage(ResultCode.PARAM_MISS);
        VUtils.isTure(!this.checkUserName(param.getUserName())).throwMessage(ResultCode.USER_NOT_EXIST);
        // ProjectTeam projectTeam =  this.getProjectCreater(param.getProjectId());
        //VUtils.isTure(projectTeam == null).throwMessage(ResultCode.PROJECT_CREATER_NOT_EXIST);
        //VUtils.isTure(!projectTeam.getUserName().equals(JwtUtil.getUserName(token))).throwMessage(ResultCode.NOT_PERM);
        MPJLambdaWrapper<ProjectTeam> wrapper = new MPJLambdaWrapper<ProjectTeam>()
                .select(ProjectTeam::getTeamId)
                .leftJoin(User.class, User::getUserId, ProjectTeam::getUserId)
                .eq(User::getUserName,param.getUserName())
                .eq(ProjectTeam::getProjectId,param.getProjectId()) ;
        long count = getBaseMapper().selectJoinCount(wrapper);
        VUtils.isTure(count >0).throwMessage(ResultCode.USER_EXIST);
        User user = userService.findByUserName(param.getUserName());
        ProjectTeam team = new ProjectTeam();
        team.setProjectId(param.getProjectId());
        team.setUserId(user.getUserId());
        team.setRemark(param.getRemark());
        team.setNickName(param.getNickName());
        if (StrUtil.isNotEmpty(param.getBindAccount())){
            team.setBindAccount(param.getBindAccount());
        }
        this.save(team);
        for (Integer roleId : param.getRoles()) {
            UserRole userRole=new UserRole();
            userRole.setRoleId(roleId);
            userRole.setUserId(user.getUserId());
            userRole.setProjectId(param.getProjectId());
            userRoleService.save(userRole);
        }
        return team;
    }

    @Override
    public ProjectTeamDTO getProjectCreater(Integer projectId) {
        MPJLambdaWrapper<ProjectTeam> wrapper = new MPJLambdaWrapper<ProjectTeam>()
                .selectAll(ProjectTeam.class)
                .select(User::getUserName)
                .leftJoin(User.class, User::getUserId, ProjectTeam::getUserId)
                .eq(ProjectTeam::getProjectId,projectId)
                .eq(ProjectTeam::getIsCreater,1);;
        return getBaseMapper().selectJoinOne(ProjectTeamDTO.class,wrapper);
    }

    @Override
    public HashMap<Integer, String> getProjectCreaterMap(Set<Integer> projectIds) {
        HashMap<Integer, String> map = new HashMap<>();
        if(projectIds.size() >0){
            MPJLambdaWrapper<ProjectTeam> wrapper = new MPJLambdaWrapper<ProjectTeam>()
                    .selectAll(ProjectTeam.class)
                    .select(User::getUserName)
                    .leftJoin(User.class, User::getUserId, ProjectTeam::getUserId)
                    .in(ProjectTeam::getProjectId,projectIds)
                    .eq(ProjectTeam::getIsCreater,1);;
            List<ProjectTeamDTO> list = getBaseMapper().selectJoinList(ProjectTeamDTO.class,wrapper);
            list.forEach(entity -> map.put(entity.getProjectId(),entity.getUserName()));
        }
        return map;
    }

    @Override
    public Boolean checkUserName(String userName) {
        FdkkResponse fdkkResponse = fdKKClient.checkUser(new FdkkLoginRequest(userName, ""));
        if(fdkkResponse.getCode() != 0){
            return false;
        }
        return true;
    }

    @Override
    public void deleteUser(ProjectTeam param, String token) {
        VUtils.isTure(param.getTeamId() == null ).throwMessage(ResultCode.PARAM_MISS);
        ProjectTeam team = this.getById(param.getTeamId());
        VUtils.isTure(team.getIsCreater() == 1).throwMessage(ResultCode.PROJECT_CREATER_NOT_DEL);

        ProjectTeam createrTeam =  this.getProjectCreater(team.getProjectId());
        VUtils.isTure(createrTeam == null).throwMessage(ResultCode.PROJECT_CREATER_NOT_EXIST);
        User user = userService.findByTokenCovUserName(token);
        if(!NumberUtil.equals(createrTeam.getUserId(),user.getUserId())){
            if(!NumberUtil.equals(team.getUserId(),user.getUserId())){
                throw new BusinessException(ResultCode.NOT_PERM);
            }else {
                this.removeById(param.getTeamId());
                throw new BusinessException(ResultCode.DEL_MINE); // 提示刷新页面
            }
        }

        this.removeById(param.getTeamId());
        userRoleService.delUserRole(team.getUserId(),team.getProjectId());
        List<Marking> byProjectId = markingService.findByProjectId(team.getProjectId());
        for (Marking marking : byProjectId) {
            markingUserService.delByUserIdAndMarkingId(team.getUserId(),marking.getMarkingId());
        }
    }

    @Override
    public void updateRemark(ProjectTeam param) {
        VUtils.isTure(param.getTeamId() == null ).throwMessage(ResultCode.PARAM_MISS);
        ProjectTeam byId = getById(param.getTeamId());
        LambdaUpdateWrapper<ProjectTeam> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(ProjectTeam::getTeamId,param.getTeamId())
                .set(ProjectTeam::getRemark,param.getRemark());
        this.update(byId,wrapper);

    }

    @Override
    public Set<Integer> getProjectIdByCreater(String projectCreater) {
        MPJLambdaWrapper<ProjectTeam> wrapper = new MPJLambdaWrapper<ProjectTeam>()
                .selectAll(ProjectTeam.class)
                .select(User::getUserName)
                .leftJoin(User.class, User::getUserId, ProjectTeam::getUserId)
                .eq(User::getUserName,projectCreater)
                .eq(ProjectTeam::getIsCreater,1);
        return getBaseMapper().selectList(wrapper).stream().map(ProjectTeam::getProjectId).collect(Collectors.toSet());
    }

    @Override
    public void delByProjectId(Integer projectId) {
        LambdaQueryWrapper<ProjectTeam> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ProjectTeam::getProjectId,projectId);
        this.remove(wrapper);
    }

    @Override
    public List<ProjectTeamDTO> listAll(ProjectTeamListParam param) {
        MPJLambdaWrapper<ProjectTeam> wrapper = new MPJLambdaWrapper<ProjectTeam>()
                .selectAll(ProjectTeam.class)
                .select(User::getUserName)
                .leftJoin(User.class, User::getUserId, ProjectTeam::getUserId)
                .eq(ProjectTeam::getProjectId,param.getProjectId());
            if(StringUtils.isNotBlank(param.getUserName())){
                wrapper.like(User::getUserName,param.getUserName());
            }
        List<ProjectTeamDTO> projectTeamIPage = baseMapper.selectJoinList( ProjectTeamDTO.class, wrapper);
        return projectTeamIPage;
    }

    @Override
    public List<TeamUserSelect> buildTreeSelect(List<ProjectTeamDTO> projectTeamDTOS) {
        return projectTeamDTOS.stream().map(TeamUserSelect::new).collect(Collectors.toList());
    }

    @Override
    public void updateUser(ProjectTeamAddDTO param) {
        VUtils.isTure(param.getTeamId() == null ).throwMessage(ResultCode.PARAM_MISS);
        ProjectTeam projectTeam = getById(param.getTeamId());
        LambdaUpdateWrapper<ProjectTeam> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(ProjectTeam::getTeamId,param.getTeamId());
        boolean updateFlag=false;
        if (StrUtil.isNotEmpty(param.getRemark())){
            wrapper.set(ProjectTeam::getRemark,param.getRemark());
            updateFlag=true;
        }
        if (StrUtil.isNotEmpty(param.getBindAccount())){
            updateFlag=true;
            wrapper.set(ProjectTeam::getBindAccount,param.getBindAccount());
        }
        if (StrUtil.isNotEmpty(param.getNickName())){
            updateFlag=true;
            wrapper.set(ProjectTeam::getNickName,param.getNickName());
        }
        if (updateFlag){
            this.update(wrapper);
        }
        if (CollectionUtil.isNotEmpty(param.getRoles())){
            userRoleService.delUserRole(param.getUserId(),param.getProjectId());
            for (Integer roleId : param.getRoles()) {
                UserRole userRole=new UserRole();
                userRole.setRoleId(roleId);
                userRole.setUserId(param.getUserId());
                userRole.setProjectId(param.getProjectId());
                userRoleService.save(userRole);
            }
        }

    }
}