yunsu/cloud-model/src/main/java/com/hssx/cloudmodel/service/impl/UserServiceImpl.java

package com.hssx.cloudmodel.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.hssx.cloudmodel.constant.Constant;
import com.hssx.cloudmodel.entity.*;
import com.hssx.cloudmodel.entity.vo.UserVO;
import com.hssx.cloudmodel.mapper.*;
import com.hssx.cloudmodel.service.UserService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hssx.cloudmodel.util.HttpRespMsg;
import com.hssx.cloudmodel.util.ListUtil;
import com.hssx.cloudmodel.util.MD5Util;
import com.hssx.cloudmodel.util.PageUtil;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;

/**
 * @author 吴涛涛
 * @since 2019-07-26
 */
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    @Resource
    UserMapper userMapper;
    @Resource
    CompanyMapper companyMapper;
    @Resource
    UserCompanyMapper userCompanyMapper;
    @Resource
    ProjectUserMapper projectUserMapper;
    @Resource
    ProjectMapper projectMapper;
    @Resource
    ProjectApproveMapper projectApproveMapper;
    @Resource
    CustomCompanyMapper customCompanyMapper;

    @Override
    public HttpRespMsg login(UserVO userVO, HttpServletRequest request) {
        System.out.println("user" + userVO);
        HttpRespMsg msg = new HttpRespMsg();
        //验证用户名是否存在
        QueryWrapper<User> qw = new QueryWrapper<>();
        qw.eq("account", userVO.getAccount());
        Integer count = userMapper.selectCount(qw);
        //验证用户名是否正确
        if (count > 0) {
            UserVO newUser = userMapper.getUserByAccount(userVO);
            //验证密码是否正确
            if (MD5Util.getPassword(userVO.getPassword()).equals(newUser.getPassword())) {
                newUser.setPassword("");
                //判断该用户是否为某个项目的项目经理
                if (projectMapper.selectCount(new QueryWrapper<Project>().eq("manager_id", newUser.getId())) > 0) {
                    newUser.setIsManager(1);
                }
                msg.data = newUser;
            } else {
                msg.setError("密码错误");
            }
        } else {
            msg.setError("账号不存在");
        }
        return msg;
    }

    @Override
    public HttpRespMsg pageList(PageUtil page, Integer companyId, Integer flag, String keyName, User user, Integer roleType) {
        HttpRespMsg msg = new HttpRespMsg();
        PageHelper.startPage(page.getPageNum(), page.getPageSize());
        List<UserVO> users = new ArrayList<>();
        List<Integer> uIds = new ArrayList<>();
        if (Constant.SYS_PARENT_ID == user.getParentId()) {
            users = userMapper.selectListByCondition(roleType, companyId, flag, user, keyName);
        } else if (Constant.SYS_ID == user.getParentId()) {
            if (user.getSubordinateType() == 0) {
                QueryWrapper<Project> qwr = new QueryWrapper<>();
                //资产方管理员,看到自己创建的项目下的所有人以及和自己公司建立联系的人
                qwr.select("id").eq("creator_id", user.getId());
                uIds = projectMapper.selectList(qwr).stream().map(Project::getManagerId).collect(Collectors.toList());
                List<Integer> projectIds = projectMapper.selectList(qwr).stream().map(Project::getId).collect(Collectors.toList());
                projectIds.add(-1);
                List<Integer> projectUserIds = projectUserMapper.selectList(new QueryWrapper<ProjectUser>().in("project_id", projectIds)).stream().map(ProjectUser::getUserId).collect(Collectors.toList());
                uIds.addAll(projectUserIds);
                List<Integer> projectApproveIds = projectApproveMapper.selectList(new QueryWrapper<ProjectApprove>().in("project_id", projectIds)).stream().map(ProjectApprove::getApproverId).collect(Collectors.toList());
                uIds.addAll(projectApproveIds);
                //与本公司合作的用户ids
                List<Integer> cooperationUids = userCompanyMapper.selectList(new QueryWrapper<UserCompany>().eq("cooperation_company_id", user.getCompanyId())).stream().map(UserCompany::getUserId).collect(Collectors.toList());
                uIds.addAll(cooperationUids);
                uIds.add(-1);
                users = userMapper.selectUserListByCondition(roleType, companyId, flag, keyName, uIds,user);
            } else if (user.getSubordinateType() == 1) {
//                List<Integer> projectIds = customCompanyMapper.selectList(new QueryWrapper<CustomCompany>().eq("company_id", user.getCompanyId())).stream().map(CustomCompany::getProjectId).collect(Collectors.toList());
//                projectIds.add(-1);
//                uIds = projectMapper.selectList(new QueryWrapper<Project>().in("id", projectIds)).stream().map(Project::getManagerId).collect(Collectors.toList());
//                List<Integer> projectUserIds = projectUserMapper.selectList(new QueryWrapper<ProjectUser>().in("project_id", projectIds)).stream().map(ProjectUser::getUserId).collect(Collectors.toList());
//                uIds.addAll(projectUserIds);
//                List<Integer> projectApproveIds = projectApproveMapper.selectList(new QueryWrapper<ProjectApprove>().in("project_id", projectIds)).stream().map(ProjectApprove::getApproverId).collect(Collectors.toList());
//                uIds.addAll(projectApproveIds);
                uIds = userMapper.selectList(new QueryWrapper<User>().eq("company_id", user.getCompanyId())).stream().map(User::getId).collect(Collectors.toList());
                uIds.add(-1);
                users = userMapper.selectUserListByCondition(roleType, companyId, flag, keyName, uIds,user);
                //去除项目经理自己
            }
        } else {
            List<Integer> pIds = projectMapper.selectList(new QueryWrapper<Project>().eq("manager_id", user.getId())).stream().map(Project::getId).collect(Collectors.toList());
            pIds.add(-1);
            List<Integer> projectUserIds = projectUserMapper.selectList(new QueryWrapper<ProjectUser>().in("project_id", pIds)).stream().map(ProjectUser::getUserId).collect(Collectors.toList());
            uIds.addAll(projectUserIds);
            List<Integer> projectApproveIds = projectApproveMapper.selectList(new QueryWrapper<ProjectApprove>().in("project_id", pIds)).stream().map(ProjectApprove::getApproverId).collect(Collectors.toList());
            uIds.addAll(projectApproveIds);
            uIds.add(-1);
            users = userMapper.selectUserListByCondition(roleType, companyId, flag, keyName, uIds,user);
        }
        List<Project> projects = new ArrayList<>();
        for (UserVO userVO : users) {
            List<Integer> set = new ArrayList<>();
            set.add(-1);
            if (userVO.getId() != null) {
                QueryWrapper<Project> qw = new QueryWrapper<>();
                //当前登录人是什么人
                if (Constant.SYS_PARENT_ID == user.getParentId()) {
                    //超级管理员
                    //看到该人参与的所有项目
                    QueryWrapper<Project> qwPro = new QueryWrapper<>();
                    qwPro.eq("manager_id", userVO.getId());
                    List<Project> projectList = projectMapper.selectList(qwPro);
                    for (Project project : projectList) {
                        set.add(project.getId());
                    }
                    //项目经理或者普通用户
                    List<ProjectUser> projectUsers = projectUserMapper.selectList(new QueryWrapper<ProjectUser>().eq("user_id", userVO.getId()));
                    for (ProjectUser projectUser : projectUsers) {
                        set.add(projectUser.getProjectId());
                    }
                    //作为审批人
                    List<ProjectApprove> projectApproves = projectApproveMapper.selectList(new QueryWrapper<ProjectApprove>().eq("approver_id", userVO.getId()));
                    for (ProjectApprove projectApprove : projectApproves) {
                        set.add(projectApprove.getProjectId());
                    }
                    qw.in("id", set);
                    projects = projectMapper.selectList(qw);
                    userVO.setProjects(projects);
                } else if (Constant.SYS_ID == user.getParentId()) {
                    List<Integer> proIds = projectMapper.selectList(new QueryWrapper<Project>().eq("creator_id", user.getId())).stream().map(Project::getId).collect(Collectors.toList());
                    if (user.getSubordinateType() == 0) {
                        //看到该人参与的所有项目
                        QueryWrapper<Project> qwPro = new QueryWrapper<>();
                        qwPro.eq("manager_id", userVO.getId());
                        List<Project> projectList = projectMapper.selectList(qwPro);
                        for (Project project : projectList) {
                            set.add(project.getId());
                        }
                        //项目经理或者普通用户
                        List<ProjectUser> projectUsers = projectUserMapper.selectList(new QueryWrapper<ProjectUser>().eq("user_id", userVO.getId()));
                        for (ProjectUser projectUser : projectUsers) {
                            set.add(projectUser.getProjectId());
                        }
                        //作为审批人
                        List<ProjectApprove> projectApproves = projectApproveMapper.selectList(new QueryWrapper<ProjectApprove>().eq("approver_id", userVO.getId()));
                        for (ProjectApprove projectApprove : projectApproves) {
                            set.add(projectApprove.getProjectId());
                        }
                        set.retainAll(proIds);
                        set.add(-1);
                        qw.in("id", set);
                        projects = projectMapper.selectList(qw);
                        userVO.setProjects(projects);
                    } else if (user.getSubordinateType() == 1) {
                        List<Integer> projectIds = customCompanyMapper.selectList(new QueryWrapper<CustomCompany>().eq("company_id", user.getCompanyId())).stream().map(CustomCompany::getProjectId).collect(Collectors.toList());
                        projectIds.add(-1);
//                        if (user.getSubordinateType() == 0) {
                            //看到该人参与的所有项目
                            QueryWrapper<Project> qwPro = new QueryWrapper<>();
                            qwPro.eq("manager_id", userVO.getId());
                            List<Project> projectList = projectMapper.selectList(qwPro);
                            for (Project project : projectList) {
                                set.add(project.getId());
                            }
                            //项目经理或者普通用户
                            List<ProjectUser> projectUsers = projectUserMapper.selectList(new QueryWrapper<ProjectUser>().eq("user_id", userVO.getId()));
                            for (ProjectUser projectUser : projectUsers) {
                                set.add(projectUser.getProjectId());
                            }
                            //作为审批人
                            List<ProjectApprove> projectApproves = projectApproveMapper.selectList(new QueryWrapper<ProjectApprove>().eq("approver_id", userVO.getId()));
                            for (ProjectApprove projectApprove : projectApproves) {
                                set.add(projectApprove.getProjectId());
                            }
                            set.retainAll(projectIds);
                            set.add(-1);
                            qw.in("id", set);
                            projects = projectMapper.selectList(qw);
                            userVO.setProjects(projects);
//                        }
                    }
                }else{
                        List<Integer> pIds = projectMapper.selectList(new QueryWrapper<Project>().eq("manager_id", user.getId())).stream().map(Project::getId).collect(Collectors.toList());
                        pIds.add(-1);
//                        if (user.getSubordinateType() == 0) {
                            //看到该人参与的所有项目
                            QueryWrapper<Project> qwPro = new QueryWrapper<>();
                            qwPro.eq("manager_id", userVO.getId());
                            List<Project> projectList = projectMapper.selectList(qwPro);
                            for (Project project : projectList) {
                                set.add(project.getId());
                            }
                            //项目经理或者普通用户
                            List<ProjectUser> projectUsers = projectUserMapper.selectList(new QueryWrapper<ProjectUser>().eq("user_id", userVO.getId()));
                            for (ProjectUser projectUser : projectUsers) {
                                set.add(projectUser.getProjectId());
                            }
                            //作为审批人
                            List<ProjectApprove> projectApproves = projectApproveMapper.selectList(new QueryWrapper<ProjectApprove>().eq("approver_id", userVO.getId()));
                            for (ProjectApprove projectApprove : projectApproves) {
                                set.add(projectApprove.getProjectId());
                            }
                            set.retainAll(pIds);
                            set.add(-1);
                            qw.in("id", set);
                            projects = projectMapper.selectList(qw);
                            userVO.setProjects(projects);
//                        }
                    }
            } else {
                msg.setError("当前用户未登录，或者用户不存在");
            }
        }
        PageInfo<UserVO> pageInfos = new PageInfo<>(users);
        msg.data = pageInfos;
        return msg;
    }

    @Override
    public HttpRespMsg deleteUser(User user) {
        HttpRespMsg msg = new HttpRespMsg();
        QueryWrapper<ProjectUser> qw = new QueryWrapper<>();
        qw.eq("user_id", user.getId());
        //普通用户应用到项目不能删除
        Integer count = projectUserMapper.selectCount(qw);
        if (count > 0) {
            msg.setError("该用户已被应用到项目，暂不提供删除操作");
            return msg;
        }
        //是项目经理不能删除
        Integer countProject = projectMapper.selectCount(new QueryWrapper<Project>().eq("manager_id", user.getId()));
        if (countProject > 0) {
            msg.setError("该用户已被应用到项目，暂不提供删除操作");
            return msg;
        }
        //删除用户
        userMapper.deleteById(user.getId());
        //删除合作的公司
        userCompanyMapper.delete(new QueryWrapper<UserCompany>().eq("user_id", user.getId()));
        return msg;
    }

    @Override
    public HttpRespMsg changeUserInfo(User user) {
        HttpRespMsg msg = new HttpRespMsg();
        User newUser = new User();
        newUser.setId(user.getId());
        if (null != user.getPassword()) {
            newUser.setPassword(MD5Util.getPassword(user.getPassword()));
        }
        if (null != user.getUsername()) {
            newUser.setUsername(user.getUsername());
        }
        userMapper.updateById(newUser);
        return msg;
    }

    @Override
    public HttpRespMsg addAndUpdateUser(User user, Integer flag, Integer addType, String projectIds) {
        //获取该账号的创建者
        User parentUser = userMapper.selectById(user.getParentId());
        HttpRespMsg msg = new HttpRespMsg();
        if (Constant.SYS_PARENT_ID == parentUser.getParentId()) {
            //此时是创建admind,当前创建人是超级管理员,此时没有项目id
            int count = userMapper.selectCount(new QueryWrapper<User>().eq("company_id", user.getCompanyId()).eq("parent_id", parentUser.getId()));
            if (flag == 0) {
                if (count > 0) {
                    //所选公司下的admin已存在
                    msg.setError("该公司下的管理员已存在");
                    return msg;
                }
                //添加用户
                QueryWrapper<User> qw = new QueryWrapper<>();
                qw.eq("account", user.getAccount());
                count = userMapper.selectCount(qw);
                if (count > 0) {
                    User existingUser = userMapper.selectOne(qw);
                    msg.setError("当前账号已存在");
                    return msg;
                } else {
                    //创建账号默认密码"000000"
                    user.setPassword(MD5Util.getPassword(Constant.DEFAULT_PWD));
                    user.setHeadImgurl(UUID.randomUUID().toString().replaceAll("-", ""));
                    //获取角色所属的团体
                    Company company = companyMapper.selectById(user.getCompanyId());
                    if (Constant.ASSETS_COMPANY == company.getCompanyType()) {
                        user.setSubordinateType(Constant.ASSETS_COMPANY);
                        user.setTeamName("资产方");
                    } else if (Constant.PRODUCER_COMPANY == company.getCompanyType()) {
                        user.setSubordinateType(Constant.PRODUCER_COMPANY);
                        user.setTeamName("生产方");
                    }
                    userMapper.insert(user);
                    if (addType != null) {
                        if (addType == 0) {
                            Company com = new Company();
                            com.setId(user.getCompanyId());
                            com.setAdministrator(user.getUsername());
                            com.setAdministratorId(user.getId());
                            companyMapper.updateById(com);
                        }
                    }
                }
            } else if (flag == 1) {
                //更新角色信息
//                Company company = companyMapper.selectById(user.getCompanyId());
//                if (Constant.ASSETS_COMPANY == company.getCompanyType()) {
//                    user.setSubordinateType(Constant.ASSETS_COMPANY);
//                    user.setTeamName("资产方");
//                } else if (Constant.PRODUCER_COMPANY == company.getCompanyType()) {
//                    user.setSubordinateType(Constant.PRODUCER_COMPANY);
//                    user.setTeamName("生产方");
//                }
                userMapper.updateById(user);
            }
        } else if (Constant.SYS_ID == parentUser.getParentId()) {
            //admin创建用户
            if (flag == 0) {
                //添加用户
                QueryWrapper<User> qw = new QueryWrapper<>();
                qw.eq("account", user.getAccount());
                int count = userMapper.selectCount(qw);
                if (count > 0) {
                    User existingUser = userMapper.selectOne(qw);
                    if(user.getCompanyId() != existingUser.getCompanyId() || existingUser.getParentId()==1){
                        msg.setError("创建账号失败");
                        return msg;
                    }
                    List<Integer> pIds  = projectMapper.selectList(new QueryWrapper<Project>().eq("owner_company", parentUser.getCompanyId())).stream().map(Project::getId).collect(Collectors.toList());
                    pIds.add(-1);
                    List<Integer> managerIds = projectMapper.selectList(new QueryWrapper<Project>().eq("owner_company", parentUser.getCompanyId())).stream().map(Project::getManagerId).collect(Collectors.toList());
                    List<Integer> usersIds = projectUserMapper.selectList(new QueryWrapper<ProjectUser>().in("project_id", pIds)).stream().map(ProjectUser::getUserId).collect(Collectors.toList());
                    List<Integer> projectApproveIds = projectApproveMapper.selectList(new QueryWrapper<ProjectApprove>().in("project_id", pIds)).stream().map(ProjectApprove::getApproverId).collect(Collectors.toList());
                    usersIds.add(-1);
                    usersIds.addAll(managerIds);
                    usersIds.addAll(projectApproveIds);
//                    if (usersIds.contains(existingUser.getId())) {
//                        msg.setError("该账号已参与本资产方公司下的其他项目，请前往本项目详情添加即可");
//                        return msg;
//                    }
//                    List<Integer> uids = userMapper.selectList(new QueryWrapper<User>().eq("parent_id", parentUser.getId())).stream().map(User::getId).collect(Collectors.toList());
//                    uids.add(-1);
//                    Integer countUser = userMapper.selectCount(new QueryWrapper<User>().in("parent_id", uids));
                    if (usersIds.contains(existingUser.getId())) {
                        msg.setError("该账号已存在，请勿重新创建");
                        return msg;
                    } else {
                        //此时用户已经有了，则建立一条合作公司的关系
                        UserCompany userCompany = new UserCompany();
                        userCompany.setUserId(existingUser.getId());
                        userCompany.setBelongCompanyId(existingUser.getCompanyId());
                        userCompany.setCooperationCompanyId(parentUser.getCompanyId());
                        QueryWrapper<UserCompany> qWra = new QueryWrapper<>(userCompany);
                        int userCompanyCount = userCompanyMapper.selectCount(qWra);
                        if (userCompanyCount == 0) {
                            userCompanyMapper.insert(userCompany);
                        }
                        //添加项目参与人记录
                        if (projectIds != null) {
                            List<Integer> ids = ListUtil.convertIntegerIdsArrayToList(projectIds);
                            ids.stream().forEach(e -> {
                                ProjectUser projectUser = new ProjectUser();
                                projectUser.setProjectId(e);
                                projectUser.setSubordinate(existingUser.getCompanyId());
                                projectUser.setUserId(existingUser.getId());
                                projectUser.setSubordinateType(existingUser.getSubordinateType());
                                projectUserMapper.insert(projectUser);
                            });
                        }
                    }
                } else {
                    //创建账号默认密码"000000"
                    user.setPassword(MD5Util.getPassword(Constant.DEFAULT_PWD));
                    user.setHeadImgurl(UUID.randomUUID().toString().replaceAll("-", ""));
                    //获取角色所属的团体
                    Company company = companyMapper.selectById(user.getCompanyId());
                    if (Constant.ASSETS_COMPANY == company.getCompanyType()) {
                        user.setSubordinateType(Constant.ASSETS_COMPANY);
                        user.setTeamName("资产方");
                    } else if (Constant.PRODUCER_COMPANY == company.getCompanyType()) {
                        user.setSubordinateType(Constant.PRODUCER_COMPANY);
                        user.setTeamName("生产方");
                    }
                    userMapper.insert(user);
                    UserCompany userCompany = new UserCompany();
                    userCompany.setUserId(user.getId());
                    userCompany.setBelongCompanyId(user.getCompanyId());
                    userCompany.setCooperationCompanyId(parentUser.getCompanyId());
                    QueryWrapper<UserCompany> qWra = new QueryWrapper<>(userCompany);
                    int userCompanyCount = userCompanyMapper.selectCount(qWra);
                    if (userCompanyCount == 0) {
                        userCompanyMapper.insert(userCompany);
                    }
                    //添加项目参与人记录
                    if (projectIds != null) {
                        List<Integer> ids = ListUtil.convertIntegerIdsArrayToList(projectIds);
                        ids.stream().forEach(e -> {
                            ProjectUser projectUser = new ProjectUser();
                            projectUser.setProjectId(e);
                            projectUser.setSubordinate(user.getCompanyId());
                            projectUser.setUserId(user.getId());
                            projectUser.setSubordinateType(user.getSubordinateType());
                            projectUserMapper.insert(projectUser);
                        });
                    }
                }
            } else if (flag == 1) {
                //更新角色信息
//                Company company = companyMapper.selectById(user.getCompanyId());
//                if (Constant.ASSETS_COMPANY == company.getCompanyType()) {
//                    user.setSubordinateType(Constant.ASSETS_COMPANY);
//                    user.setTeamName("资产方");
//                } else if (Constant.PRODUCER_COMPANY == company.getCompanyType()) {
//                    user.setSubordinateType(Constant.PRODUCER_COMPANY);
//                    user.setTeamName("生产方");
//                }
                userMapper.updateById(user);
            }
        } else {
            //此时是项目经理创建人员
            //查询创建该项目经理的人
            User managerParent = userMapper.selectOne(new QueryWrapper<User>().eq("id", parentUser.getParentId()));
            if (flag == 0) {
                //添加用户
                QueryWrapper<User> qw = new QueryWrapper<>();
                qw.eq("account", user.getAccount());
                int count = userMapper.selectCount(qw);
                if (count > 0) {
                    //当前账号已被创建
                    User existingUser = userMapper.selectOne(qw);
                    if(user.getCompanyId() != existingUser.getCompanyId() || existingUser.getParentId()==1){
                        msg.setError("创建账号失败");
                        return msg;
                    }
                    //查询该账号是否已参与创建项目经理的admin公司下的项目
                    //得到admin公司下的所有项目
                    List<Integer> ids  = projectMapper.selectList(new QueryWrapper<Project>().eq("owner_company", managerParent.getCompanyId())).stream().map(Project::getId).collect(Collectors.toList());
                    ids.add(-1);
                    List<ProjectUser> projectUsers = projectUserMapper.selectList(new QueryWrapper<ProjectUser>().in("project_id", ids).eq("user_id", existingUser.getId()));
                    if (projectUsers.size() > 0) {
                        msg.setError("该账号已参与本资产方公司下的其他项目，请前往本项目详情添加即可");
                        return msg;
                    }
                    List<ProjectApprove> projectApproves = projectApproveMapper.selectList(new QueryWrapper<ProjectApprove>().eq("approver_id", existingUser.getId()).in("project_id", ids));
                    if (projectApproves.size() > 0) {
                        msg.setError("该账号已参与本资产方公司下的其他项目，请前往本项目详情添加即可");
                        return msg;
                    }
                    //此时用户已经有了，创建人不是该人之前参与过的项目的公司下的项目经理创建，则建立一条合作公司的关系
                    UserCompany userCompany = new UserCompany();
                    userCompany.setUserId(existingUser.getId());
                    userCompany.setBelongCompanyId(existingUser.getCompanyId());
                    userCompany.setCooperationCompanyId(managerParent.getCompanyId());
                    QueryWrapper<UserCompany> qWra = new QueryWrapper<>(userCompany);
                    int userCompanyCount = userCompanyMapper.selectCount(qWra);
                    if (userCompanyCount == 0) {
                        userCompanyMapper.insert(userCompany);
                    }
                    //添加项目参与人记录
                    if (projectIds != null) {
                        ids = ListUtil.convertIntegerIdsArrayToList(projectIds);
                        ids.stream().forEach(e -> {
                            ProjectUser projectUser = new ProjectUser();
                            projectUser.setProjectId(e);
                            projectUser.setSubordinate(existingUser.getCompanyId());
                            projectUser.setUserId(existingUser.getId());
                            projectUser.setSubordinateType(existingUser.getSubordinateType());
                            projectUserMapper.insert(projectUser);
                        });
                    }
                } else {
                    //创建账号默认密码"000000"
                    user.setPassword(MD5Util.getPassword(Constant.DEFAULT_PWD));
                    user.setHeadImgurl(UUID.randomUUID().toString().replaceAll("-", ""));
                    //获取角色所属的团体
                    Company company = companyMapper.selectById(user.getCompanyId());
                    if (Constant.ASSETS_COMPANY == company.getCompanyType()) {
                        user.setSubordinateType(Constant.ASSETS_COMPANY);
                        user.setTeamName("资产方");
                    } else if (Constant.PRODUCER_COMPANY == company.getCompanyType()) {
                        user.setSubordinateType(Constant.PRODUCER_COMPANY);
                        user.setTeamName("生产方");
                    }
                    userMapper.insert(user);
                    UserCompany userCompany = new UserCompany();
                    userCompany.setUserId(user.getId());
                    userCompany.setBelongCompanyId(user.getCompanyId());
                    userCompany.setCooperationCompanyId(managerParent.getCompanyId());
                    QueryWrapper<UserCompany> qWra = new QueryWrapper<>(userCompany);
                    int userCompanyCount = userCompanyMapper.selectCount(qWra);
                    if (userCompanyCount == 0) {
                        userCompanyMapper.insert(userCompany);
                    }
                    //添加项目参与人记录
                    if (projectIds != null) {
                        List<Integer> ids = ListUtil.convertIntegerIdsArrayToList(projectIds);
                        ids.stream().forEach(e -> {
                            ProjectUser projectUser = new ProjectUser();
                            projectUser.setProjectId(e);
                            projectUser.setSubordinate(user.getCompanyId());
                            projectUser.setUserId(user.getId());
                            projectUser.setSubordinateType(user.getSubordinateType());
                            projectUserMapper.insert(projectUser);
                        });
                    }
                }
            } else if (flag == 1) {
                //更新角色信息
//                Company company = companyMapper.selectById(user.getCompanyId());
//                if (Constant.ASSETS_COMPANY == company.getCompanyType()) {
//                    user.setSubordinateType(Constant.ASSETS_COMPANY);
//                    user.setTeamName("资产方");
//                } else if (Constant.PRODUCER_COMPANY == company.getCompanyType()) {
//                    user.setSubordinateType(Constant.PRODUCER_COMPANY);
//                    user.setTeamName("生产方");
//                }
                userMapper.updateById(user);
            }
        }
        return msg;
    }

}