xiu_b/src/main/java/com/tailbet/service/impl/GroupServiceImpl.java

package com.tailbet.service.impl;

import com.tailbet.model.entity.Group;
import com.tailbet.model.entity.GroupMember;
import com.tailbet.mapper.GroupMapper;
import com.tailbet.mapper.GroupMemberMapper;
import com.tailbet.mapper.UserMapper;
import com.tailbet.service.IGroupService;
import com.tailbet.service.IAuditService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;

/**
 * 群Service实现
 */
@Slf4j
@RequiredArgsConstructor
@Service
public class GroupServiceImpl implements IGroupService {

    private final GroupMapper groupMapper;
    private final GroupMemberMapper groupMemberMapper;
    private final UserMapper userMapper;
    private final IAuditService auditService;

    /**
     * 获取群信息
     */
    @Override
    public Group getById(Long groupId) {
        return groupMapper.selectById(groupId);
    }

    /**
     * 获取用户的群列表
     */
    @Override
    public List<Group> getUserGroups(Long userId) {
        List<GroupMember> members = groupMemberMapper.selectList(new LambdaQueryWrapper<GroupMember>()
                .eq(GroupMember::getUserId, userId));

        if (members.isEmpty()) {
            return List.of();
        }

        List<Long> groupIds = members.stream()
                .map(GroupMember::getGroupId)
                .toList();

        return groupMapper.selectList(new LambdaQueryWrapper<Group>()
                .in(Group::getId, groupIds)
                .eq(Group::getStatus, 1));
    }

    /**
     * 拉用户入群
     */
    @Override
    @Transactional
    public void pullUser(Long groupId, Long userId, Long operatorId) {
        // 检查是否已在群中
        GroupMember existing = groupMemberMapper.selectOne(new LambdaQueryWrapper<GroupMember>()
                .eq(GroupMember::getGroupId, groupId)
                .eq(GroupMember::getUserId, userId));

        if (existing != null) {
            throw new RuntimeException("用户已在群中");
        }

        GroupMember member = new GroupMember();
        member.setGroupId(groupId);
        member.setUserId(userId);
        member.setRole(ROLE_NORMAL);
        member.setJoinTime(LocalDateTime.now());
        member.setCreateTime(LocalDateTime.now());
        member.setUpdateTime(LocalDateTime.now());
        groupMemberMapper.insert(member);

        // 审计日志
        auditService.log(groupId, null, operatorId, "PULL_USER",
                String.format("{\"userId\":%d}", userId));
    }

    /**
     * 踢出用户
     */
    @Override
    @Transactional
    public void kickUser(Long groupId, Long targetUserId, Long operatorId) {
        Group group = groupMapper.selectById(groupId);

        // 检查权限
        GroupMember operator = groupMemberMapper.selectOne(new LambdaQueryWrapper<GroupMember>()
                .eq(GroupMember::getGroupId, groupId)
                .eq(GroupMember::getUserId, operatorId));

        if (operator == null) {
            throw new RuntimeException("你不是群成员");
        }

        // 只有群主和管理员可以踢人
        if (operator.getRole() != ROLE_OWNER && operator.getRole() != ROLE_ADMIN) {
            throw new RuntimeException("只有群主和管理员可以踢人");
        }

        // 不能踢群主
        if (group.getOwnerUserId().equals(targetUserId)) {
            throw new RuntimeException("不能踢出群主");
        }

        // 删除成员
        groupMemberMapper.delete(new LambdaQueryWrapper<GroupMember>()
                .eq(GroupMember::getGroupId, groupId)
                .eq(GroupMember::getUserId, targetUserId));

        // 审计日志
        auditService.log(groupId, null, operatorId, "KICK_USER",
                String.format("{\"targetUserId\":%d}", targetUserId));
    }

    /**
     * 设置管理员
     */
    @Override
    @Transactional
    public void setAdmin(Long groupId, Long targetUserId, Long operatorId) {
        Group group = groupMapper.selectById(groupId);

        // 只有群主可以设置管理员
        if (!group.getOwnerUserId().equals(operatorId)) {
            throw new RuntimeException("只有群主可以设置管理员");
        }

        GroupMember member = groupMemberMapper.selectOne(new LambdaQueryWrapper<GroupMember>()
                .eq(GroupMember::getGroupId, groupId)
                .eq(GroupMember::getUserId, targetUserId));

        if (member == null) {
            throw new RuntimeException("目标用户不是群成员");
        }

        member.setRole(ROLE_ADMIN);
        member.setUpdateTime(LocalDateTime.now());
        groupMemberMapper.updateById(member);

        // 审计日志
        auditService.log(groupId, null, operatorId, "SET_ADMIN",
                String.format("{\"targetUserId\":%d}", targetUserId));
    }

    /**
     * 取消管理员
     */
    @Override
    @Transactional
    public void removeAdmin(Long groupId, Long targetUserId, Long operatorId) {
        Group group = groupMapper.selectById(groupId);

        if (!group.getOwnerUserId().equals(operatorId)) {
            throw new RuntimeException("只有群主可以取消管理员");
        }

        GroupMember member = groupMemberMapper.selectOne(new LambdaQueryWrapper<GroupMember>()
                .eq(GroupMember::getGroupId, groupId)
                .eq(GroupMember::getUserId, targetUserId));

        if (member == null) {
            throw new RuntimeException("目标用户不是群成员");
        }

        member.setRole(ROLE_NORMAL);
        member.setUpdateTime(LocalDateTime.now());
        groupMemberMapper.updateById(member);

        // 审计日志
        auditService.log(groupId, null, operatorId, "REMOVE_ADMIN",
                String.format("{\"targetUserId\":%d}", targetUserId));
    }

    /**
     * 获取群成员
     */
    @Override
    public List<GroupMember> getMembers(Long groupId) {
        return groupMemberMapper.selectList(new LambdaQueryWrapper<GroupMember>()
                .eq(GroupMember::getGroupId, groupId));
    }

    /**
     * 检查用户是否是群主
     */
    @Override
    public boolean isOwner(Long groupId, Long userId) {
        Group group = groupMapper.selectById(groupId);
        return group != null && group.getOwnerUserId().equals(userId);
    }

    /**
     * 检查用户是否是管理员
     */
    @Override
    public boolean isAdmin(Long groupId, Long userId) {
        GroupMember member = groupMemberMapper.selectOne(new LambdaQueryWrapper<GroupMember>()
                .eq(GroupMember::getGroupId, groupId)
                .eq(GroupMember::getUserId, userId));
        return member != null && (member.getRole() == ROLE_ADMIN || member.getRole() == ROLE_OWNER);
    }

    /**
     * 根据OpenIM群ID获取群信息
     */
    @Override
    public Group getByOpenimGroupId(String openimGroupId) {
        return groupMapper.selectOne(new LambdaQueryWrapper<Group>()
                .eq(Group::getOpenimGroupId, openimGroupId));
    }
}