repal-service/src/main/java/com/winhc/repal/service/impl/RepalGroupMemberServiceImpl.java

package com.winhc.repal.service.impl;

import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.winhc.common.base.BeanResponse;
import com.winhc.common.enums.CodeMsg;
import com.winhc.common.exception.CommonException;
import com.winhc.repal.cloud.LoginService;
import com.winhc.repal.cloud.dto.RepalRegUserDTO;
import com.winhc.repal.cloud.dto.RepalRegUserInfoDTO;
import com.winhc.repal.entity.RepalBill;
import com.winhc.repal.entity.RepalGroupMember;
import com.winhc.repal.entity.RepalGroupRole;
import com.winhc.repal.entity.UserInfo;
import com.winhc.repal.enums.DeletedStatusEnum;
import com.winhc.repal.enums.RepalBillTypeEnum;
import com.winhc.repal.enums.RoleTypeEnum;
import com.winhc.repal.model.dto.AddGroupMemberDTO;
import com.winhc.repal.model.dto.UpdateMemberRoleDTO;
import com.winhc.repal.model.vo.GroupRoleMemberVO;
import com.winhc.repal.repository.RepalGroupMemberMapper;
import com.winhc.repal.service.*;
import com.winhc.repal.util.UserContextUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @description RepalGroupMember 接口实现类
 * @author Generator
 * @date 2022-04-08
 */
@Service
public class RepalGroupMemberServiceImpl extends ServiceImpl<RepalGroupMemberMapper, RepalGroupMember> implements RepalGroupMemberService {

    @Autowired
    private UserExtService userExtService;

    @Autowired
    private RepalGroupMemberMapper repalGroupMemberMapper;

    @Autowired
    private RepalGroupMemberService repalGroupMemberService;

    @Autowired
    private RepalGroupRoleService repalGroupRoleService;

    @Autowired
    private LoginService loginService;

    @Autowired
    private UserInfoService userInfoService;

    @Autowired
    private RepalResponsiblePersonService repalResponsiblePersonService;

    @Autowired
    private RepalCustChargeRelService repalCustChargeRelService;

    @Autowired
    private RepalRolePermissionService repalRolePermissionService;

    @Override
    public RepalGroupMember getMemberByUserId(Long userId) {
        return this.getOne(Wrappers.lambdaQuery(RepalGroupMember.class)
                .eq(RepalGroupMember::getUserId, userId)
                .eq(RepalGroupMember::getDeleted, DeletedStatusEnum.NORMAL.getCode()));
    }

    @Override
    public Long getUserGroupId(Long userId) {
        RepalGroupMember repalGroupMember = this.getOne(Wrappers.lambdaQuery(RepalGroupMember.class)
                .eq(RepalGroupMember::getUserId, userId)
                .eq(RepalGroupMember::getDeleted, DeletedStatusEnum.NORMAL.getCode()));
        if (Objects.isNull(repalGroupMember)) {
            throw new CommonException(CodeMsg.FAILED, "组织错误");
        }
        return repalGroupMember.getRepalGroupId();
    }

    @Override
    public Boolean addGroupMember(Long userId, String userName, Long groupId, Long roleId, Integer roleType) {
        RepalGroupMember member = new RepalGroupMember();
        member.setRepalGroupId(groupId);
        member.setMemberUserName(userName);
        member.setUserId(userId);
        member.setRoleId(roleId);
        member.setRoleType(roleType);
        this.save(member);
        return true;
    }

    @Override
    public Boolean updateVisible(Integer type) {
        repalGroupMemberMapper.updateVisible(UserContextUtil.getUser().getUserId(), type);
        return true;
    }

    @Override
    public Boolean getMemberVisible(Integer type) {
        RepalGroupMember member = this.getOne(Wrappers.lambdaQuery(RepalGroupMember.class)
                .eq(RepalGroupMember::getUserId, UserContextUtil.getUser().getUserId())
                .eq(RepalGroupMember::getDeleted, DeletedStatusEnum.NORMAL.getCode()));
        return (RepalBillTypeEnum.RECEIVABLE.getCode().equals(type) ? member.getReceivable() : member.getReceipt()) > 0;
    }

    @Override
    public List<GroupRoleMemberVO> getGroupRoleMemberList() {
        long userId = UserContextUtil.getUser().getUserId();
        long groupId = repalGroupMemberService.getUserGroupId(userId);
        List<RepalGroupMember> memberList = this.list(Wrappers.lambdaQuery(RepalGroupMember.class)
            .eq(RepalGroupMember::getRepalGroupId, groupId)
            .eq(RepalGroupMember::getDeleted, DeletedStatusEnum.NORMAL.getCode()));
        if (CollUtil.isEmpty(memberList)) {
            return new ArrayList<>();
        }
        List<RepalGroupRole> roleList = repalGroupRoleService.getRoleByIdList(memberList.stream().map(RepalGroupMember::getRoleId).distinct().collect(Collectors.toList()));
        List<UserInfo> userInfoList = userInfoService.list(Wrappers.lambdaQuery(UserInfo.class).in(UserInfo::getUserId,
                memberList.stream().map(RepalGroupMember::getUserId).collect(Collectors.toList())));
        Map<Long, String> roleNameMap = roleList.stream().collect(Collectors.toMap(RepalGroupRole::getId, RepalGroupRole::getRoleName));
        Map<Long, List<RepalGroupMember>> memberMap = memberList.stream().collect(Collectors.groupingBy(RepalGroupMember::getRoleId, Collectors.toList()));
        Map<Long, String> avatarMap = new HashMap<>();
        if (CollUtil.isNotEmpty(userInfoList)) {
            avatarMap = userInfoList.stream().collect(HashMap::new, (k, v) -> k.put(v.getUserId(), v.getAvatar()), HashMap::putAll);
        }
        List<GroupRoleMemberVO> resultList = new ArrayList<>();
        for (Map.Entry<Long, List<RepalGroupMember>> entry : memberMap.entrySet()) {
            GroupRoleMemberVO vo = new GroupRoleMemberVO();
            vo.setRoleId(entry.getKey());
            vo.setRoleName(roleNameMap.get(entry.getKey()));
            Map<Long, String> finalAvatarMap = avatarMap;
            vo.setRoleMemberList(entry.getValue().stream().map(t -> {
                GroupRoleMemberVO.RoleMemberVO roleMemberVO = new GroupRoleMemberVO.RoleMemberVO();
                roleMemberVO.setMemberId(t.getId());
                roleMemberVO.setMemberName(t.getMemberUserName());
                roleMemberVO.setUserId(t.getUserId());
                roleMemberVO.setAvatar(finalAvatarMap.get(t.getUserId()));
                return roleMemberVO;
            }).sorted(Comparator.comparing(GroupRoleMemberVO.RoleMemberVO::getMemberId).reversed()).collect(Collectors.toList()));
            resultList.add(vo);
        }
        return resultList.stream().sorted(Comparator.comparing(GroupRoleMemberVO::getRoleId)).collect(Collectors.toList());
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean updateMemberRole(UpdateMemberRoleDTO dto) {
        long groupId = this.getUserGroupId(UserContextUtil.getUser().getUserId());
        RepalGroupRole role = repalGroupRoleService.getById(dto.getRoleId());
        if (Objects.isNull(role)) {
            throw new CommonException(CodeMsg.FAILED, "角色错误");
        }
        if (RoleTypeEnum.CUSTOMER.getCode().equals(role.getRoleType()) && !role.getRepalGroupId().equals(groupId)) {
            throw new CommonException(CodeMsg.FAILED, "组织角色错误");
        }
        this.update(Wrappers.lambdaUpdate(RepalGroupMember.class)
                .eq(RepalGroupMember::getRepalGroupId, groupId)
                .eq(RepalGroupMember::getUserId, dto.getUserId())
                .set(RepalGroupMember::getRoleId, dto.getRoleId()));
        return true;
    }


    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean addGroupMember(AddGroupMemberDTO dto) {
        RepalGroupRole role = repalGroupRoleService.getById(dto.getRoleId());
        if (Objects.isNull(role)) {
            throw new CommonException(CodeMsg.FAILED, "角色错误");
        }
        long userId = UserContextUtil.getUser().getUserId();
        long groupId = this.getUserGroupId(userId);
        RepalRegUserInfoDTO regUserInfoDTO = new RepalRegUserInfoDTO();
        regUserInfoDTO.setUserId(userId);
        regUserInfoDTO.setThirdPartyType(dto.getThirdPartyType());
        regUserInfoDTO.setRegUserList(dto.getRegList().stream().map(t -> {
            RepalRegUserDTO userDTO = new RepalRegUserDTO();
            userDTO.setAvatar(t.getAvatar());
            userDTO.setOpenId(t.getOpenId());
            userDTO.setUserName(t.getUserName());
            return userDTO;
        }).collect(Collectors.toList()));
        BeanResponse<List<RepalRegUserDTO>> beanResponse = loginService.repalRegUser(regUserInfoDTO);
        if (Objects.isNull(beanResponse) || CollUtil.isEmpty(beanResponse.getBody())) {
            throw new CommonException(CodeMsg.FAILED, "添加用户失败");
        }
        List<RepalGroupMember> memberList = this.list(Wrappers.lambdaQuery(RepalGroupMember.class)
                .in(RepalGroupMember::getUserId, beanResponse.getBody().stream().map(RepalRegUserDTO::getUserId).collect(Collectors.toList()))
                .eq(RepalGroupMember::getDeleted, DeletedStatusEnum.NORMAL.getCode()));
        Set<Long> userIdSet = memberList.stream().map(RepalGroupMember::getUserId).collect(Collectors.toSet());
        for (RepalRegUserDTO regUserDTO : beanResponse.getBody()) {
            if (!userIdSet.contains(regUserDTO.getUserId())) {
                RepalGroupMember repalGroupMember = new RepalGroupMember();
                repalGroupMember.setUserId(regUserDTO.getUserId());
                repalGroupMember.setRepalGroupId(groupId);
                repalGroupMember.setMemberUserName(regUserDTO.getUserName());
                repalGroupMember.setRoleType(role.getRoleType());
                repalGroupMember.setRoleId(role.getId());
                this.save(repalGroupMember);
            }
        }
        return true;
    }

    @Override
    public Boolean delGroupMember(Long userId) {
        if (repalResponsiblePersonService.getUserResponsibleBillCount(userId) > 1) {
            throw new CommonException(CodeMsg.FAILED, "当前成员有负责的账款未转移，无法删除");
        }
        if (repalCustChargeRelService.getUserCustCount(userId) > 1) {
            throw new CommonException(CodeMsg.FAILED, "当前成员有负责的客户未转移，无法删除");
        }
        if (UserContextUtil.getUser().getUserId().equals(userId)) {
            throw new CommonException(CodeMsg.FAILED, "无法删除自己");
        }
        this.update(Wrappers.lambdaUpdate(RepalGroupMember.class)
                .eq(RepalGroupMember::getUserId, userId)
                .set(RepalGroupMember::getDeleted, DeletedStatusEnum.DELETE.getCode()));
        return true;
    }

    @Override
    public List<String> getMemberPermissionList() {
        long userId = UserContextUtil.getUser().getUserId();
        if (this.count(Wrappers.lambdaQuery(RepalGroupMember.class)
                .eq(RepalGroupMember::getUserId, userId)
                .eq(RepalGroupMember::getDeleted, DeletedStatusEnum.NORMAL.getCode())) < 1) {
            throw new CommonException(CodeMsg.FAILED, "10001001");
        }
        return new ArrayList<>(repalRolePermissionService.getUserPermissionCodeSet(userId));
    }
}