src/main/java/com/example/myproject/service/GroupService.java

//package com.example.myproject.service;
//
//import com.example.myproject.entity.*;
//
//import com.example.myproject.repository.*;
//import jakarta.transaction.Transactional;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.data.domain.Page;
//import org.springframework.data.domain.PageRequest;
//import org.springframework.data.domain.Pageable;
//import org.springframework.data.domain.Sort;
//import org.springframework.http.ResponseEntity;
//import org.springframework.stereotype.Service;
//import org.springframework.web.multipart.MultipartFile;
//import java.io.IOException;
//import java.nio.file.Path;
//import java.nio.file.Files;
//
//import java.util.*;
//
//@Service
//public class GroupService {
//
//    @Autowired
//    private GroupRepository groupRepository;
//
//    @Autowired
//    private GroupMembersRepository groupMembersRepository;
//
//
//    @Autowired
//    private UserRepository userRepository;
//
//    @Autowired
//    private GroupPostRepository groupPostRepository;
//
//    @Autowired
//    private GroupCommentsRepository groupCommentsRepository;
//
//    private static final String IMAGE_DIR = "uploads/groupPost/";
//
//    @Transactional
//    // 创建小组的方法
//    public ResponseEntity<Map<String, Object>> createGroup(Group groupRequest) {
//        try {
//            // 创建新的小组对象
//            Group newGroup = new Group();
//            newGroup.setGroupName(groupRequest.getGroupName());
//            newGroup.setDescription(groupRequest.getDescription());
//            newGroup.setCreateTime(new Date());
//            newGroup.setUserId(groupRequest.getUserId());
//            newGroup.setMemberCount(1);
//            newGroup.setCategory(groupRequest.getCategory());
//            newGroup.setCoverImage(groupRequest.getCoverImage());
//            Group createdGroup = groupRepository.save(newGroup);
//
//            // 返回成功响应
//            Map<String, Object> response = new HashMap<>();
//            response.put("status", "success");
//            response.put("message", "兴趣小组创建成功");
//            response.put("group_id", createdGroup.getGroupId());
//
//            return ResponseEntity.ok(response);
//        } catch (Exception e) {
//            // 返回失败响应
//            Map<String, Object> errorResponse = new HashMap<>();
//            errorResponse.put("status", "error");
//            errorResponse.put("message", "小组创建失败");
//            errorResponse.put("group_id", null);
//
//            return ResponseEntity.status(400).body(errorResponse);
//        }
//    }
//
//
//    // 加入小组
//    @Transactional
//    public ResponseEntity<Map<String, Object>> joinGroup(Long groupId, Long userId) {
//        // 查找小组
//        Optional<Group> groupOptional = groupRepository.findById(groupId);
//        if (!groupOptional.isPresent()) {
//            return ResponseEntity.status(400).body(
//                    Map.of("status", "failure", "message", "小组不存在")
//            );
//        }
//
//        Group group = groupOptional.get();
//
//        // 检查用户是否已经是该小组成员
//        if (groupMembersRepository.existsByGroupIdAndUserId(groupId, userId)) {
//            return ResponseEntity.status(400).body(
//                    Map.of("status", "failure", "message", "用户已经是该小组的成员")
//            );
//        }
//
//        // 插入用户和小组的关联记录
//        GroupMembers groupMembers = new GroupMembers();
//        groupMembers.setGroupId(groupId);
//        groupMembers.setUserId(userId);
//        groupMembersRepository.save(groupMembers);
//
//        // 更新小组的成员数
//        group.setMemberCount(group.getMemberCount() + 1);
//        groupRepository.save(group);
//
//        return ResponseEntity.ok().body(
//                Map.of("status", "success", "message", "成功加入小组")
//        );
//    }
//
//    // 退出小组
//    @Transactional
//    public ResponseEntity<Map<String, Object>> leaveGroup(Long groupId, Long userId) {
//        // 查找小组
//        Optional<Group> groupOptional = groupRepository.findById(groupId);
//        if (!groupOptional.isPresent()) {
//            return ResponseEntity.status(400).body(
//                    Map.of("status", "failure", "message", "小组不存在")
//            );
//        }
//
//        Group group = groupOptional.get();
//
//        // 检查用户是否是该小组成员
//        if (!groupMembersRepository.existsByGroupIdAndUserId(groupId, userId)) {
//            return ResponseEntity.status(400).body(
//                    Map.of("status", "failure", "message", "用户不是该小组的成员")
//            );
//        }
//
//        // 删除用户和小组的关联记录
//        groupMembersRepository.deleteByGroupIdAndUserId(groupId, userId);
//
//        // 更新小组的成员数
//        group.setMemberCount(group.getMemberCount() - 1);
//        groupRepository.save(group);
//
//        return ResponseEntity.ok().body(
//                Map.of("status", "success", "message", "成功退出小组")
//        );
//    }
//
//    // 获取所有成员
//    @Transactional
//    public ResponseEntity<Map<String, Object>> getGroupMembers(Long groupId) {
//        // 查找小组
//        Optional<Group> groupOptional = groupRepository.findById(groupId);
//        if (!groupOptional.isPresent()) {
//            return ResponseEntity.status(400).body(
//                    Map.of("status", "failure", "message", "小组不存在")
//            );
//        }
//
//        Group group = groupOptional.get();
//
//        // 获取所有小组成员
//        List<GroupMembers> groupMembersList = groupMembersRepository.findByGroupId(groupId);
//
//        // 创建成员返回列表
//        List<Map<String, Object>> members = new ArrayList<>();
//        for (GroupMembers groupMember : groupMembersList) {
//            Optional<Users> userOptional = userRepository.findById(groupMember.getUserId());
//            if (userOptional.isPresent()) {
//                Users user = userOptional.get();
//                members.add(Map.of(
//                        "user_id", user.getUserId(),
//                        "username", user.getUsername(),
//                        "avatar_url", user.getAvatarUrl()
//                ));
//            }
//        }
//
//        return ResponseEntity.ok().body(
//                Map.of("status", "success", "members", members)
//        );
//    }
//
//
//    //发布帖子
//    public Map<String, Object> createPost(Long groupId, Long userId, String postContent, String title, MultipartFile[] imageFiles) {
//        // 创建一个新的帖子对象
//        GroupPost post = new GroupPost();
//        post.setGroupId(groupId);
//        post.setUserId(userId);
//        post.setContent(postContent);
//        post.setTitle(title);
//        post.setTime(new Date());
//        post.setLikeCount(0);
//        post.setCommentCount(0);
//
//        // 处理图片上传，如果没有图片，返回空字符串
//        String imageUrls = handleImages(imageFiles);
//        post.setImage(imageUrls);
//
//        // 保存帖子到数据库
//        GroupPost savedPost = groupPostRepository.save(post);
//
//        // 返回结果
//        Map<String, Object> response = new LinkedHashMap<>();
//        response.put("post_id", savedPost.getGroupPostId());
//        response.put("message", "帖子创建成功");
//        return response;
//    }
//
//    // 处理图片上传的方法，返回图片的 URL 字符串
//    private String handleImages(MultipartFile[] imageFiles) {
//        if (imageFiles == null || imageFiles.length == 0) {
//            return "";
//        }
//
//        StringBuilder imageUrlsBuilder = new StringBuilder();
//
//        for (int i = 0; i < imageFiles.length; i++) {
//            if (i > 0) {
//                imageUrlsBuilder.append(",");
//            }
//            try {
//                String imageUrl = saveImage(imageFiles[i]);
//                imageUrlsBuilder.append(imageUrl);
//            } catch (IOException e) {
//                throw new RuntimeException("图片上传失败: " + e.getMessage());
//            }
//        }
//        return imageUrlsBuilder.toString();
//    }
//
//    // 保存图片并返回图片的 URL
//    private String saveImage(MultipartFile imageFile) throws IOException {
//        if (imageFile == null) {
//            throw new IOException("图片文件为空");
//        }
//
//        String fileName = imageFile.getOriginalFilename();
//        Path path = Path.of(IMAGE_DIR + fileName);
//        Files.createDirectories(path.getParent());
//        Files.write(path, imageFile.getBytes());
//        return "/images/" + fileName;
//    }
//
//    // 获取小组内的所有帖子
//    public Map<String, Object> getAllPosts(Long groupId) {
//        List<GroupPost> posts = groupPostRepository.findByGroupId(groupId);
//
//        List<Map<String, Object>> postList = new ArrayList<>();
//
//        for (GroupPost post : posts) {
//            Map<String, Object> postData = new HashMap<>();
//            Users user = userRepository.findById(post.getUserId()).orElseThrow(() -> new RuntimeException("User not found"));
//            postData.put("group_post_id", post.getGroupPostId());
//            postData.put("user_id", post.getUserId());
//            postData.put("username", user.getUsername());
//            postData.put("title", post.getTitle());
//            postData.put("content", post.getContent());
//            postData.put("time", post.getTime());
//
//            postList.add(postData);
//        }
//
//        // 返回响应数据
//        Map<String, Object> response = new LinkedHashMap<>();
//        response.put("status", "success");
//        response.put("posts", postList);
//        return response;
//    }
//
//
//    // 获取小组列表接口
//    public Map<String, Object> searchGroups(Map<String, Object> params) {
//        String name = (String) params.get("name");
//        String category = (String) params.get("category");
//        Integer page = (Integer) params.getOrDefault("page", 1);
//        Integer size = (Integer) params.getOrDefault("size", 10);
//        String sortBy = (String) params.getOrDefault("sort_by", "memberCount");
//
//        // 构建分页对象
//        Pageable pageable;
//
//        // 根据 `sortBy` 判断排序方式
//        if ("createTime".equals(sortBy)) {
//            pageable = PageRequest.of(page - 1, size, Sort.by(Sort.Order.asc("createTime")));
//        } else if ("groupName".equals(sortBy)) {
//            pageable = PageRequest.of(page - 1, size, Sort.by(Sort.Order.asc("groupName")));
//        } else {
//            pageable = PageRequest.of(page - 1, size, Sort.by(Sort.Order.desc("memberCount")));
//        }
//
//        Page<Group> groups;
//        if (name != null && !name.isEmpty()) {
//            // 小组名称模糊查询
//            groups = groupRepository.searchGroups(name, category, pageable);
//        } else {
//            groups = groupRepository.searchWithFilters(category, pageable);
//        }
//
//        return buildResponse(groups);
//    }
//
//    // 构建返回的响应数据
//    private Map<String, Object> buildResponse(Page<Group> groups) {
//        Map<String, Object> response = new LinkedHashMap<>();
//        response.put("status", "success");
//        response.put("total", groups.getTotalElements());
//        response.put("total_pages", groups.getTotalPages());
//        response.put("current_page", groups.getNumber() + 1);
//        response.put("items", groups.getContent());
//
//        return response;
//    }
//
//    // 点赞帖子
//    public Map<String, Object> likePost(Long GroupPostId) {
//        // 查找帖子
//        Optional<GroupPost> postOpt = groupPostRepository.findById(GroupPostId);
//        if (!postOpt.isPresent()) {
//            throw new RuntimeException("Post not found");
//        }
//
//        GroupPost post = postOpt.get();
//
//        // 更新点赞数
//        post.setLikeCount(post.getLikeCount() + 1);
//        groupPostRepository.save(post);
//
//        // 返回成功信息
//        Map<String, Object> response = new HashMap<>();
//        response.put("status", "success");
//        response.put("message", "点赞成功");
//        return response;
//    }
//
//    // 取消点赞
//    public Map<String, Object> unlikePost(Long GroupPostId) {
//        // 查找帖子
//        Optional<GroupPost> postOpt = groupPostRepository.findById(GroupPostId);
//        if (!postOpt.isPresent()) {
//            throw new RuntimeException("Post not found");
//        }
//
//        GroupPost post = postOpt.get();
//
//        // 更新点赞数
//        if (post.getLikeCount() > 0) {
//            post.setLikeCount(post.getLikeCount() - 1);
//            groupPostRepository.save(post);
//
//            // 返回成功信息
//            Map<String, Object> response = new HashMap<>();
//            response.put("status", "success");
//            response.put("message", "取消点赞成功");
//            return response;
//        } else {
//            // 如果点赞数已经是0，则返回相应消息
//            Map<String, Object> response = new HashMap<>();
//            response.put("status", "failure");
//            response.put("message", "无法取消点赞，点赞数已经为0");
//            return response;
//        }
//    }
//
//    // 添加评论并更新帖子的评论数
//    public Map<String, Object> addComment(Long postId, GroupComments comment) {
//        // 查找帖子
//        Optional<GroupPost> postOpt = groupPostRepository.findById(postId);
//        if (!postOpt.isPresent()) {
//            throw new RuntimeException("Post not found");
//        }
//
//        GroupPost post = postOpt.get();
//
//        comment.setGroupPostId(postId);
//        comment.setTime(new java.util.Date());
//        groupCommentsRepository.save(comment);
//        post.setCommentCount(post.getCommentCount() + 1);
//        groupPostRepository.save(post);
//        Map<String, Object> response = new HashMap<>();
//        response.put("status", "success");
//        response.put("message", "评论成功");
//        return response;
//    }
//
//
//}

package com.example.myproject.service;

import com.example.myproject.entity.*;

import com.example.myproject.repository.*;
import jakarta.transaction.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Files;

import java.util.*;

@Service
public class GroupService {

    @Autowired
    private GroupRepository groupRepository;

    @Autowired
    private GroupMembersRepository groupMembersRepository;


    @Autowired
    private UserRepository userRepository;

    @Autowired
    private GroupPostRepository groupPostRepository;

    @Autowired
    private GroupCommentsRepository groupCommentsRepository;

    private static final String IMAGE_DIR = "uploads/groupPost/";


    @Transactional
    // 创建小组的方法
    public ResponseEntity<Map<String, Object>> createGroup(Group groupRequest) {
        try {
            // 创建新的小组对象
            Group newGroup = new Group();
            newGroup.setGroupName(groupRequest.getGroupName());
            newGroup.setDescription(groupRequest.getDescription());
            newGroup.setCreateTime(new Date());
            newGroup.setUserId(groupRequest.getUserId());
            newGroup.setMemberCount(1);
            newGroup.setCategory(groupRequest.getCategory());
            newGroup.setCoverImage(groupRequest.getCoverImage());
            Group createdGroup = groupRepository.save(newGroup);

            // 返回成功响应
            Map<String, Object> response = new HashMap<>();
            response.put("status", "success");
            response.put("message", "兴趣小组创建成功");
            response.put("group_id", createdGroup.getGroupId());

            return ResponseEntity.ok(response);
        } catch (Exception e) {
            // 返回失败响应
            Map<String, Object> errorResponse = new HashMap<>();
            errorResponse.put("status", "error");
            errorResponse.put("message", "小组创建失败");
            errorResponse.put("group_id", null);

            return ResponseEntity.status(400).body(errorResponse);
        }
    }


    // 加入小组
    @Transactional
    public ResponseEntity<Map<String, Object>> joinGroup(Long groupId, Long userId) {
        // 查找小组
        Optional<Group> groupOptional = groupRepository.findById(groupId);
        if (!groupOptional.isPresent()) {
            return ResponseEntity.status(400).body(
                    Map.of("status", "failure", "message", "小组不存在")
            );
        }

        Group group = groupOptional.get();

        // 检查用户是否已经是该小组成员
        if (groupMembersRepository.existsByGroupIdAndUserId(groupId, userId)) {
            return ResponseEntity.status(400).body(
                    Map.of("status", "failure", "message", "用户已经是该小组的成员")
            );
        }

        // 插入用户和小组的关联记录
        GroupMembers groupMembers = new GroupMembers();
        groupMembers.setGroupId(groupId);
        groupMembers.setUserId(userId);
        groupMembersRepository.save(groupMembers);

        // 更新小组的成员数
        group.setMemberCount(group.getMemberCount() + 1);
        groupRepository.save(group);

        return ResponseEntity.ok().body(
                Map.of("status", "success", "message", "成功加入小组")
        );
    }

    // 退出小组
    @Transactional
    public ResponseEntity<Map<String, Object>> leaveGroup(Long groupId, Long userId) {
        // 查找小组
        Optional<Group> groupOptional = groupRepository.findById(groupId);
        if (!groupOptional.isPresent()) {
            return ResponseEntity.status(400).body(
                    Map.of("status", "failure", "message", "小组不存在")
            );
        }

        Group group = groupOptional.get();

        // 检查用户是否是该小组成员
        if (!groupMembersRepository.existsByGroupIdAndUserId(groupId, userId)) {
            return ResponseEntity.status(400).body(
                    Map.of("status", "failure", "message", "用户不是该小组的成员")
            );
        }

        // 删除用户和小组的关联记录
        int  leaveCount = groupMembersRepository.deleteByGroupIdAndUserId(groupId, userId);
        System.out.println("删除行数"+leaveCount);
        // 更新小组的成员数
        group.setMemberCount(group.getMemberCount() - 1);
        groupRepository.save(group);

        return ResponseEntity.ok().body(
                Map.of("status", "success", "message", "成功退出小组")
        );
    }

    // 获取所有成员
    @Transactional
    public ResponseEntity<Map<String, Object>> getGroupMembers(Long groupId) {
        // 查找小组
        Optional<Group> groupOptional = groupRepository.findById(groupId);
        if (!groupOptional.isPresent()) {
            return ResponseEntity.status(400).body(
                    Map.of("status", "failure", "message", "小组不存在")
            );
        }

        Group group = groupOptional.get();

        // 获取所有小组成员
        List<GroupMembers> groupMembersList = groupMembersRepository.findByGroupId(groupId);

        // 创建成员返回列表
        List<Map<String, Object>> members = new ArrayList<>();
        for (GroupMembers groupMember : groupMembersList) {
            Optional<Users> userOptional = userRepository.findById(groupMember.getUserId());
            if (userOptional.isPresent()) {
                Users user = userOptional.get();
                members.add(Map.of(
                        "user_id", user.getUserId(),
                        "username", user.getUsername(),
                        "avatar_url", user.getAvatarUrl()
                ));
            }
        }

        return ResponseEntity.ok().body(
                Map.of("status", "success", "members", members)
        );
    }


    //发布帖子
    public Map<String, Object> createPost(Long groupId, Long userId, String postContent, String title, MultipartFile[] imageFiles) {
        // 创建一个新的帖子对象
        GroupPost post = new GroupPost();
        post.setGroupId(groupId);
        post.setUserId(userId);
        post.setContent(postContent);
        post.setTitle(title);
        post.setTime(new Date());
        post.setLikeCount(0);
        post.setCommentCount(0);

        // 处理图片上传，如果没有图片，返回空字符串
        String imageUrls = handleImages(imageFiles);
        post.setImage(imageUrls);

        // 保存帖子到数据库
        GroupPost savedPost = groupPostRepository.save(post);

        // 返回结果
        Map<String, Object> response = new LinkedHashMap<>();
        response.put("post_id", savedPost.getGroupPostId());
        response.put("message", "帖子创建成功");
        return response;
    }

    // 处理图片上传的方法，返回图片的 URL 字符串
    private String handleImages(MultipartFile[] imageFiles) {
        if (imageFiles == null || imageFiles.length == 0) {
            return "";
        }

        StringBuilder imageUrlsBuilder = new StringBuilder();

        for (int i = 0; i < imageFiles.length; i++) {
            if (i > 0) {
                imageUrlsBuilder.append(",");
            }
            try {
                String imageUrl = saveImage(imageFiles[i]);
                imageUrlsBuilder.append(imageUrl);
            } catch (IOException e) {
                throw new RuntimeException("图片上传失败: " + e.getMessage());
            }
        }
        return imageUrlsBuilder.toString();
    }

    // 保存图片并返回图片的 URL
    private String saveImage(MultipartFile imageFile) throws IOException {
        if (imageFile == null) {
            throw new IOException("图片文件为空");
        }

        String fileName = imageFile.getOriginalFilename();
        Path path = Path.of(IMAGE_DIR + fileName);
        Files.createDirectories(path.getParent());
        Files.write(path, imageFile.getBytes());
        return "/images/" + fileName;
    }

    // 获取小组内的所有帖子
    public Map<String, Object> getAllPosts(Long groupId) {
        List<GroupPost> posts = groupPostRepository.findByGroupId(groupId);

        List<Map<String, Object>> postList = new ArrayList<>();

        for (GroupPost post : posts) {
            Map<String, Object> postData = new HashMap<>();
            Users user = userRepository.findById(post.getUserId()).orElseThrow(() -> new RuntimeException("User not found"));
            postData.put("group_post_id", post.getGroupPostId());
            postData.put("user_id", post.getUserId());
            postData.put("username", user.getUsername());
            postData.put("title", post.getTitle());
            postData.put("content", post.getContent());
            postData.put("time", post.getTime());

            postList.add(postData);
        }

        // 返回响应数据
        Map<String, Object> response = new LinkedHashMap<>();
        response.put("status", "success");
        response.put("posts", postList);
        return response;
    }


    // 获取小组列表接口
    public Map<String, Object> searchGroups(Map<String, Object> params) {
        String name = (String) params.get("name");
        String category = (String) params.get("category");
        Integer page = (Integer) params.getOrDefault("page", 1);
        Integer size = (Integer) params.getOrDefault("size", 10);
        String sortBy = (String) params.getOrDefault("sort_by", "memberCount");

        // 构建分页对象
        Pageable pageable;

        // 根据 `sortBy` 判断排序方式
        if ("createTime".equals(sortBy)) {
            pageable = PageRequest.of(page - 1, size, Sort.by(Sort.Order.asc("createTime")));
        } else if ("groupName".equals(sortBy)) {
            pageable = PageRequest.of(page - 1, size, Sort.by(Sort.Order.asc("groupName")));
        } else {
            pageable = PageRequest.of(page - 1, size, Sort.by(Sort.Order.desc("memberCount")));
        }

        Page<Group> groups;
        if (name != null && !name.isEmpty()) {
            // 小组名称模糊查询
            groups = groupRepository.searchGroups(name, category, pageable);
        } else {
            groups = groupRepository.searchWithFilters(category, pageable);
        }

        return buildResponse(groups);
    }

    // 构建返回的响应数据
    private Map<String, Object> buildResponse(Page<Group> groups) {
        Map<String, Object> response = new LinkedHashMap<>();
        response.put("status", "success");
        response.put("total", groups.getTotalElements());
        response.put("total_pages", groups.getTotalPages());
        response.put("current_page", groups.getNumber() + 1);
        response.put("items", groups.getContent());

        return response;
    }

    // 点赞帖子
    public Map<String, Object> likePost(Long GroupPostId) {
        // 查找帖子
        Optional<GroupPost> postOpt = groupPostRepository.findById(GroupPostId);
        if (!postOpt.isPresent()) {
            throw new RuntimeException("Post not found");
        }

        GroupPost post = postOpt.get();

        // 更新点赞数
        post.setLikeCount(post.getLikeCount() + 1);
        groupPostRepository.save(post);

        // 返回成功信息
        Map<String, Object> response = new HashMap<>();
        response.put("status", "success");
        response.put("message", "点赞成功");
        return response;
    }

    // 取消点赞
    public Map<String, Object> unlikePost(Long GroupPostId) {
        // 查找帖子
        Optional<GroupPost> postOpt = groupPostRepository.findById(GroupPostId);
        if (!postOpt.isPresent()) {
            throw new RuntimeException("Post not found");
        }

        GroupPost post = postOpt.get();

        // 更新点赞数
        if (post.getLikeCount() > 0) {
            post.setLikeCount(post.getLikeCount() - 1);
            groupPostRepository.save(post);

            // 返回成功信息
            Map<String, Object> response = new HashMap<>();
            response.put("status", "success");
            response.put("message", "取消点赞成功");
            return response;
        } else {
            // 如果点赞数已经是0，则返回相应消息
            Map<String, Object> response = new HashMap<>();
            response.put("status", "failure");
            response.put("message", "无法取消点赞，点赞数已经为0");
            return response;
        }
    }

    // 添加评论并更新帖子的评论数
    public Map<String, Object> addComment(Long postId, GroupComments comment) {
        // 查找帖子
        Optional<GroupPost> postOpt = groupPostRepository.findById(postId);
        if (!postOpt.isPresent()) {
            throw new RuntimeException("Post not found");
        }

        GroupPost post = postOpt.get();

        comment.setGroupPostId(postId);
        comment.setTime(new java.util.Date());
        groupCommentsRepository.save(comment);
        post.setCommentCount(post.getCommentCount() + 1);
        groupPostRepository.save(post);
        Map<String, Object> response = new HashMap<>();
        response.put("status", "success");
        response.put("message", "评论成功");
        return response;
    }


}