605 lines
25 KiB
C#
605 lines
25 KiB
C#
using FreeSql;
|
||
|
||
using LiveForum.Code.Base;
|
||
using LiveForum.Code.JwtInfrastructure;
|
||
using LiveForum.Code.SensitiveWord.Interfaces;
|
||
using LiveForum.IService.Messages;
|
||
using LiveForum.IService.Posts;
|
||
using LiveForum.IService.Others;
|
||
using LiveForum.IService.Users;
|
||
using LiveForum.Model;
|
||
using LiveForum.Model.Dto.Base;
|
||
using LiveForum.Model.Dto.Messages;
|
||
using LiveForum.Model.Dto.PostComments;
|
||
using LiveForum.Model.Dto.Users;
|
||
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Linq;
|
||
using System.Text;
|
||
using System.Threading.Tasks;
|
||
|
||
namespace LiveForum.Service.Posts
|
||
{
|
||
public class PostCommentsService : IPostCommentsService
|
||
{
|
||
private readonly JwtUserInfoModel _userInfoModel;
|
||
private readonly IBaseRepository<T_Comments> _commentsRepository;
|
||
private readonly IBaseRepository<T_Posts> _postsRepository;
|
||
private readonly IBaseRepository<T_Users> _usersRepository;
|
||
private readonly IBaseRepository<T_Likes> _likesRepository;
|
||
private readonly ISensitiveWordService _sensitiveWordService;
|
||
private readonly IUserInfoService _userInfoService;
|
||
private readonly IMessagePublisher _messagePublisher;
|
||
private readonly ILikeService _likeService;
|
||
private readonly IPostReplyIntervalService _postReplyIntervalService;
|
||
private readonly IAntiAddictionService _antiAddictionService;
|
||
/// <summary>
|
||
/// 构造函数
|
||
/// </summary>
|
||
/// <param name="userInfoModel">JWT用户信息模型</param>
|
||
/// <param name="commentsRepository">评论仓储</param>
|
||
/// <param name="postsRepository">帖子仓储</param>
|
||
/// <param name="usersRepository">用户仓储</param>
|
||
/// <param name="likesRepository">点赞仓储</param>
|
||
/// <param name="sensitiveWordService">敏感词服务</param>
|
||
/// <param name="userInfoService">用户信息转换服务</param>
|
||
/// <param name="messagePublisher">消息发布器</param>
|
||
/// <param name="likeService">点赞服务</param>
|
||
/// <param name="postReplyIntervalService">发帖/回复间隔校验服务</param>
|
||
/// <param name="antiAddictionService">防沉迷校验服务</param>
|
||
public PostCommentsService(
|
||
JwtUserInfoModel userInfoModel,
|
||
IBaseRepository<T_Comments> commentsRepository,
|
||
IBaseRepository<T_Posts> postsRepository,
|
||
IBaseRepository<T_Users> usersRepository,
|
||
IBaseRepository<T_Likes> likesRepository,
|
||
ISensitiveWordService sensitiveWordService,
|
||
IUserInfoService userInfoService,
|
||
IMessagePublisher messagePublisher,
|
||
ILikeService likeService,
|
||
IPostReplyIntervalService postReplyIntervalService,
|
||
IAntiAddictionService antiAddictionService)
|
||
{
|
||
_userInfoModel = userInfoModel;
|
||
_commentsRepository = commentsRepository;
|
||
_postsRepository = postsRepository;
|
||
_usersRepository = usersRepository;
|
||
_likesRepository = likesRepository;
|
||
_sensitiveWordService = sensitiveWordService;
|
||
_userInfoService = userInfoService;
|
||
_messagePublisher = messagePublisher;
|
||
_likeService = likeService;
|
||
_postReplyIntervalService = postReplyIntervalService;
|
||
_antiAddictionService = antiAddictionService;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取评论列表
|
||
/// </summary>
|
||
/// <param name="request">请求参数</param>
|
||
/// <returns></returns>
|
||
public async Task<BaseResponse<GetPostCommentsRespDto>> GetPostComments(GetPostCommentsReq request)
|
||
{
|
||
var currentUserId = (long)_userInfoModel.UserId;
|
||
|
||
// 1. 验证帖子是否存在
|
||
var post = await _postsRepository.Select
|
||
.Where(x => x.Id == request.PostId && !x.IsDeleted)
|
||
.FirstAsync();
|
||
|
||
if (post == null)
|
||
{
|
||
return new BaseResponse<GetPostCommentsRespDto>(ResponseCode.Error, "帖子不存在");
|
||
}
|
||
|
||
// 2. 构建查询条件 - 只获取顶级评论（ParentCommentId为null）
|
||
var query = _commentsRepository.Select
|
||
.Where(x => x.PostId == request.PostId && x.ParentCommentId == null && !x.IsDeleted);
|
||
|
||
// 3. 排序
|
||
if (request.SortType == 1) // 正序
|
||
{
|
||
query = query.OrderBy(x => x.CreatedAt);
|
||
}
|
||
else // 倒序
|
||
{
|
||
query = query.OrderByDescending(x => x.CreatedAt);
|
||
}
|
||
|
||
// 4. 分页
|
||
var total = await query.CountAsync();
|
||
var comments = await query
|
||
.Skip((request.PageIndex - 1) * request.PageSize)
|
||
.Take(request.PageSize)
|
||
.ToListAsync();
|
||
|
||
if (!comments.Any())
|
||
{
|
||
var res = new GetPostCommentsRespDto
|
||
{
|
||
PageIndex = request.PageIndex,
|
||
PageSize = request.PageSize,
|
||
Total = (int)total,
|
||
TotalPages = (int)Math.Ceiling((double)total / request.PageSize),
|
||
Items = new List<CommentListItemDto>()
|
||
};
|
||
return new BaseResponse<GetPostCommentsRespDto>(res);
|
||
}
|
||
|
||
// 5. 获取相关数据
|
||
var commentIds = comments.Select(x => x.Id).ToList();
|
||
var userIds = comments.Select(x => x.UserId).Distinct().ToList();
|
||
|
||
// 获取用户信息
|
||
//var users = await _usersRepository.Select
|
||
// .Where(x => userIds.Contains(x.Id))
|
||
// .ToListAsync();
|
||
|
||
// 获取回复数量
|
||
var replyCounts = await _commentsRepository.Select
|
||
.Where(x => commentIds.Contains(x.ParentCommentId!.Value) && !x.IsDeleted)
|
||
.GroupBy(x => x.ParentCommentId)
|
||
.ToListAsync(g => new { ParentCommentId = g.Key, Count = g.Count() });
|
||
|
||
var replyCountDict = replyCounts.ToDictionary(x => x.ParentCommentId!.Value, x => x.Count);
|
||
|
||
// 获取每个顶级评论的前5条回复
|
||
var replies = await _commentsRepository.Select
|
||
.Where(x => commentIds.Contains(x.ParentCommentId!.Value) && !x.IsDeleted)
|
||
.OrderBy(x => x.CreatedAt)
|
||
.ToListAsync();
|
||
|
||
// 按父评论ID分组，每组取前5条
|
||
var replyDict = replies
|
||
.GroupBy(x => x.ParentCommentId!.Value)
|
||
.ToDictionary(
|
||
g => g.Key,
|
||
g => g.Take(5).ToList()
|
||
);
|
||
|
||
// 收集所有相关的用户ID（包括回复者和被回复用户）
|
||
var replyUserIds = replies.Select(x => x.UserId).Distinct().ToList();
|
||
var replyToUserIds = replies.Where(x => x.ReplyToUserId.HasValue)
|
||
.Select(x => x.ReplyToUserId!.Value).Distinct().ToList();
|
||
var allUserIds = userIds.Union(replyUserIds).Union(replyToUserIds).Distinct().ToList();
|
||
|
||
// 重新获取所有用户信息
|
||
var users = await _usersRepository.Select
|
||
.Where(x => allUserIds.Contains(x.Id))
|
||
.ToListAsync();
|
||
|
||
// 获取所有评论和回复的ID，用于查询点赞状态
|
||
var allCommentIds = commentIds.Union(replies.Select(x => x.Id)).ToList();
|
||
|
||
// 批量查询点赞状态和点赞数（包括顶级评论和回复）
|
||
var likedStatusDict = await _likeService.BatchIsLikedAsync(currentUserId, 2, allCommentIds);
|
||
var likeCountDict = await _likeService.BatchGetLikeCountAsync(2, allCommentIds);
|
||
|
||
// 6. 批量转换用户信息（自动获取认证类型数据）
|
||
var usersDict = await _userInfoService.ToUserInfoDtoDictionaryAsync(users);
|
||
|
||
// 7. 构建评论列表
|
||
var items = comments.Select(comment =>
|
||
{
|
||
var user = users.FirstOrDefault(x => x.Id == comment.UserId);
|
||
var replyCount = replyCountDict.GetValueOrDefault(comment.Id, 0);
|
||
|
||
// 获取该评论的前5条回复
|
||
var commentReplies = replyDict.GetValueOrDefault(comment.Id, new List<T_Comments>());
|
||
var replyDtos = commentReplies.Select(reply =>
|
||
{
|
||
var replyUser = users.FirstOrDefault(x => x.Id == reply.UserId);
|
||
var replyToUser = reply.ReplyToUserId.HasValue
|
||
? users.FirstOrDefault(x => x.Id == reply.ReplyToUserId.Value)
|
||
: null;
|
||
|
||
return new CommentReplyDto
|
||
{
|
||
CommentId = reply.Id,
|
||
ParentCommentId = reply.ParentCommentId!.Value,
|
||
Content = reply.Content,
|
||
LikeCount = likeCountDict.ContainsKey(reply.Id) ? likeCountDict[reply.Id] : 0,
|
||
CreatedAt = reply.CreatedAt,
|
||
ReplyToUserId = reply.ReplyToUserId,
|
||
ReplyToUserName = replyToUser?.NickName ?? "",
|
||
User = replyUser != null && usersDict.ContainsKey(replyUser.Id) ? usersDict[replyUser.Id] : new UserInfoDto(),
|
||
IsLiked = likedStatusDict.ContainsKey(reply.Id) && likedStatusDict[reply.Id]
|
||
};
|
||
}).ToList();
|
||
|
||
return new CommentListItemDto
|
||
{
|
||
CommentId = comment.Id,
|
||
PostId = comment.PostId,
|
||
Content = comment.Content,
|
||
LikeCount = likeCountDict.ContainsKey(comment.Id) ? likeCountDict[comment.Id] : 0,
|
||
ReplyCount = replyCount,
|
||
CreatedAt = comment.CreatedAt,
|
||
User = user != null && usersDict.ContainsKey(user.Id) ? usersDict[user.Id] : new UserInfoDto(),
|
||
IsLiked = likedStatusDict.ContainsKey(comment.Id) && likedStatusDict[comment.Id],
|
||
Replies = replyDtos // 显示前5条回复
|
||
};
|
||
}).ToList();
|
||
|
||
var result = new GetPostCommentsRespDto
|
||
{
|
||
PageIndex = request.PageIndex,
|
||
PageSize = request.PageSize,
|
||
Total = (int)total,
|
||
TotalPages = (int)Math.Ceiling((double)total / request.PageSize),
|
||
Items = items
|
||
};
|
||
|
||
return new BaseResponse<GetPostCommentsRespDto>(result);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取评论回复列表
|
||
/// </summary>
|
||
/// <param name="request">请求参数</param>
|
||
/// <returns></returns>
|
||
public async Task<BaseResponse<GetCommentsRepliesRespDto>> GetCommentsReplies(GetCommentsRepliesReq request)
|
||
{
|
||
var currentUserId = (long)_userInfoModel.UserId;
|
||
|
||
// 1. 验证父评论是否存在
|
||
var parentComment = await _commentsRepository.Select
|
||
.Where(x => x.Id == request.CommentId && !x.IsDeleted)
|
||
.FirstAsync();
|
||
|
||
if (parentComment == null)
|
||
{
|
||
return new BaseResponse<GetCommentsRepliesRespDto>(ResponseCode.Error, "评论不存在");
|
||
}
|
||
|
||
// 2. 构建查询条件 - 获取该评论的所有回复
|
||
var query = _commentsRepository.Select
|
||
.Where(x => x.ParentCommentId == request.CommentId && !x.IsDeleted)
|
||
.OrderBy(x => x.CreatedAt);
|
||
|
||
// 3. 分页
|
||
var total = await query.CountAsync();
|
||
var replies = await query
|
||
.Skip((request.PageIndex - 1) * request.PageSize)
|
||
.Take(request.PageSize)
|
||
.ToListAsync();
|
||
|
||
if (!replies.Any())
|
||
{
|
||
var res = new GetCommentsRepliesRespDto
|
||
{
|
||
PageIndex = request.PageIndex,
|
||
PageSize = request.PageSize,
|
||
Total = (int)total,
|
||
TotalPages = (int)Math.Ceiling((double)total / request.PageSize),
|
||
Items = new List<CommentReplyDto>()
|
||
};
|
||
return new BaseResponse<GetCommentsRepliesRespDto>(res);
|
||
}
|
||
|
||
// 4. 获取相关数据
|
||
var replyIds = replies.Select(x => x.Id).ToList();
|
||
var userIds = replies.Select(x => x.UserId).Distinct().ToList();
|
||
|
||
// 获取用户信息
|
||
var users = await _usersRepository.Select
|
||
.Where(x => userIds.Contains(x.Id))
|
||
.ToListAsync();
|
||
|
||
// 批量查询点赞状态和点赞数
|
||
var likedStatusDict = await _likeService.BatchIsLikedAsync(currentUserId, 2, replyIds);
|
||
var likeCountDict = await _likeService.BatchGetLikeCountAsync(2, replyIds);
|
||
|
||
// 5. 批量转换用户信息（自动获取认证类型数据）
|
||
var usersDict = await _userInfoService.ToUserInfoDtoDictionaryAsync(users);
|
||
|
||
// 6. 构建回复列表
|
||
var items = replies.Select(reply =>
|
||
{
|
||
var user = users.FirstOrDefault(x => x.Id == reply.UserId);
|
||
var replyToUser = reply.ReplyToUserId.HasValue ?
|
||
users.FirstOrDefault(x => x.Id == reply.ReplyToUserId.Value) : null;
|
||
|
||
return new CommentReplyDto
|
||
{
|
||
CommentId = reply.Id,
|
||
ParentCommentId = reply.ParentCommentId,
|
||
ReplyToUserId = reply.ReplyToUserId,
|
||
ReplyToUserName = replyToUser?.NickName ?? "",
|
||
Content = reply.Content,
|
||
LikeCount = likeCountDict.ContainsKey(reply.Id) ? likeCountDict[reply.Id] : 0,
|
||
CreatedAt = reply.CreatedAt,
|
||
User = user != null && usersDict.ContainsKey(user.Id) ? usersDict[user.Id] : new UserInfoDto(),
|
||
IsLiked = likedStatusDict.ContainsKey(reply.Id) && likedStatusDict[reply.Id]
|
||
};
|
||
}).ToList();
|
||
|
||
var result = new GetCommentsRepliesRespDto
|
||
{
|
||
PageIndex = request.PageIndex,
|
||
PageSize = request.PageSize,
|
||
Total = (int)total,
|
||
TotalPages = (int)Math.Ceiling((double)total / request.PageSize),
|
||
Items = items
|
||
};
|
||
|
||
return new BaseResponse<GetCommentsRepliesRespDto>(result);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 发表评论
|
||
/// </summary>
|
||
/// <param name="request">请求参数</param>
|
||
/// <returns></returns>
|
||
public async Task<BaseResponse<PublishPostCommentsRespDto>> PublishPostComments(PublishPostCommentsReq request)
|
||
{
|
||
var currentUserId = (long)_userInfoModel.UserId;
|
||
var now = DateTime.Now;
|
||
if (string.IsNullOrEmpty(request.Content))
|
||
{
|
||
return new BaseResponse<PublishPostCommentsRespDto>(ResponseCode.Error, "评论内容不能为空");
|
||
}
|
||
// 0. 过滤敏感词
|
||
request.Content = _sensitiveWordService.Filter(request.Content);
|
||
if (string.IsNullOrEmpty(request.Content.Replace("*", "")))
|
||
{
|
||
return new BaseResponse<PublishPostCommentsRespDto>(ResponseCode.Error, "评论内容包含敏感词");
|
||
}
|
||
// 1. 验证帖子是否存在
|
||
var post = await _postsRepository.Select
|
||
.Where(x => x.Id == request.PostId)
|
||
.FirstAsync();
|
||
|
||
if (post == null)
|
||
{
|
||
return new BaseResponse<PublishPostCommentsRespDto>(ResponseCode.Error, "帖子不存在");
|
||
}
|
||
|
||
if (post.IsDeleted)
|
||
{
|
||
return new BaseResponse<PublishPostCommentsRespDto>(ResponseCode.PostDeleted, "帖子已删除");
|
||
}
|
||
|
||
// 1.1 检查帖子是否允许回复
|
||
if (!post.AllowReply)
|
||
{
|
||
return new BaseResponse<PublishPostCommentsRespDto>(ResponseCode.Error, "该帖子不允许回复");
|
||
}
|
||
|
||
// 1.2 回复间隔校验
|
||
var remainingSeconds = await _postReplyIntervalService.CheckReplyIntervalAsync(currentUserId);
|
||
if (remainingSeconds.HasValue)
|
||
{
|
||
return new BaseResponse<PublishPostCommentsRespDto>(
|
||
ResponseCode.Error,
|
||
$"回复过于频繁，请等待 {remainingSeconds.Value} 秒后再试");
|
||
}
|
||
|
||
// 1.3 防沉迷校验
|
||
if (await _antiAddictionService.IsRestrictedAsync("Reply"))
|
||
{
|
||
return new BaseResponse<PublishPostCommentsRespDto>(ResponseCode.Error, "防沉迷时间内无法操作");
|
||
}
|
||
|
||
// 2. 如果是回复评论，验证父评论是否存在
|
||
if (request.ParentCommentId.HasValue && request.ParentCommentId > 0)
|
||
{
|
||
var parentComment = await _commentsRepository.Select
|
||
.Where(x => x.Id == request.ParentCommentId.Value && !x.IsDeleted)
|
||
.FirstAsync();
|
||
|
||
if (parentComment == null)
|
||
{
|
||
return new BaseResponse<PublishPostCommentsRespDto>(ResponseCode.Error, "父评论不存在");
|
||
}
|
||
|
||
// 验证父评论是否属于同一个帖子
|
||
if (parentComment.PostId != request.PostId)
|
||
{
|
||
return new BaseResponse<PublishPostCommentsRespDto>(ResponseCode.Error, "评论帖子不匹配");
|
||
}
|
||
if (request.ReplyToUserId == null || request.ReplyToUserId == 0)
|
||
{
|
||
request.ReplyToUserId = parentComment.UserId;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
// 4. 创建评论
|
||
var comment = new T_Comments
|
||
{
|
||
PostId = request.PostId,
|
||
UserId = currentUserId,
|
||
ParentCommentId = request.ParentCommentId,
|
||
ReplyToUserId = request.ReplyToUserId,
|
||
Content = request.Content,
|
||
LikeCount = 0,
|
||
CreatedAt = now,
|
||
UpdatedAt = now
|
||
};
|
||
|
||
await _commentsRepository.InsertAsync(comment);
|
||
var commentCount = await _commentsRepository.Where(it => !it.IsDeleted && it.PostId == request.PostId).CountAsync();
|
||
// 5. 更新帖子的评论数
|
||
post.CommentCount = (int)commentCount;
|
||
await _postsRepository.UpdateAsync(post);
|
||
|
||
// 6. 发送回复消息
|
||
try
|
||
{
|
||
if (request.ParentCommentId.HasValue && request.ParentCommentId.Value > 0)
|
||
{
|
||
// 回复评论场景
|
||
var parentComment = await _commentsRepository.Select
|
||
.Where(x => x.Id == request.ParentCommentId.Value)
|
||
.FirstAsync();
|
||
|
||
if (parentComment != null && parentComment.UserId != currentUserId)
|
||
{
|
||
await _messagePublisher.SendReplyMessageAsync(
|
||
triggerId: currentUserId,
|
||
receiverId: parentComment.UserId,
|
||
commentId: comment.Id,
|
||
commentContent: comment.Content,
|
||
postId: post.Id,
|
||
postTitle: post.Title,
|
||
parentCommentId: parentComment.Id,
|
||
myCommentContent: parentComment.Content // 传入被回复的评论内容
|
||
);
|
||
}
|
||
}
|
||
else if (post.UserId != currentUserId)
|
||
{
|
||
// 直接评论帖子场景
|
||
await _messagePublisher.SendReplyMessageAsync(
|
||
triggerId: currentUserId,
|
||
receiverId: post.UserId,
|
||
commentId: comment.Id,
|
||
commentContent: comment.Content,
|
||
postId: post.Id,
|
||
postTitle: post.Title,
|
||
parentCommentId: null,
|
||
myCommentContent: null
|
||
);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
// 记录日志但不影响评论发布
|
||
Console.WriteLine($"发送回复消息失败: {ex.Message}");
|
||
}
|
||
// 7. 构建返回数据
|
||
var replyInterval = await _postReplyIntervalService.GetReplyIntervalAsync(currentUserId);
|
||
var result = new PublishPostCommentsRespDto
|
||
{
|
||
CommentId = comment.Id,
|
||
PostId = comment.PostId,
|
||
Content = comment.Content,
|
||
CreatedAt = comment.CreatedAt,
|
||
ReplyInterval = replyInterval
|
||
};
|
||
|
||
return new BaseResponse<PublishPostCommentsRespDto>("发送评论成功！", result);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 删除评论
|
||
/// </summary>
|
||
/// <param name="request">请求参数</param>
|
||
/// <returns></returns>
|
||
public async Task<BaseResponseBool> DeletePostComments(DeletePostCommentsReq request)
|
||
{
|
||
var currentUserId = (long)_userInfoModel.UserId;
|
||
|
||
// 1. 获取评论信息
|
||
var comment = await _commentsRepository.Select
|
||
.Where(x => x.Id == request.CommentId && x.UserId == currentUserId && !x.IsDeleted)
|
||
.FirstAsync();
|
||
|
||
if (comment == null)
|
||
{
|
||
return new BaseResponseBool { Code = ResponseCode.Error, Message = "评论不存在或无权限删除" };
|
||
}
|
||
|
||
// 2. 软删除评论
|
||
comment.IsDeleted = true;
|
||
comment.DeletedAt = DateTime.Now;
|
||
await _commentsRepository.UpdateAsync(comment);
|
||
|
||
// 3. 更新帖子的评论数
|
||
var post = await _postsRepository.Select
|
||
.Where(x => x.Id == comment.PostId)
|
||
.FirstAsync();
|
||
|
||
if (post != null)
|
||
{
|
||
post.CommentCount = Math.Max(0, post.CommentCount - 1);
|
||
await _postsRepository.UpdateAsync(post);
|
||
}
|
||
|
||
return new BaseResponseBool { Code = ResponseCode.Success, Data = true, Message = "删除帖子成功！" };
|
||
}
|
||
|
||
/// <summary>
|
||
/// 点赞/取消点赞评论
|
||
/// </summary>
|
||
/// <param name="request">请求参数</param>
|
||
/// <returns></returns>
|
||
public async Task<BaseResponse<LikeCommentRespDto>> LikeComment(LikeCommentReq request)
|
||
{
|
||
var currentUserId = (long)_userInfoModel.UserId;
|
||
|
||
// 1. 检查评论是否存在
|
||
var comment = await _commentsRepository.Select
|
||
.Where(x => x.Id == request.CommentId && !x.IsDeleted)
|
||
.FirstAsync();
|
||
|
||
if (comment == null)
|
||
{
|
||
return new BaseResponse<LikeCommentRespDto>(ResponseCode.Error, "评论不存在");
|
||
}
|
||
|
||
// 2. 查询当前点赞状态
|
||
var isCurrentlyLiked = await _likeService.IsLikedAsync(currentUserId, 2, request.CommentId);
|
||
|
||
bool isLiked;
|
||
if (isCurrentlyLiked)
|
||
{
|
||
// 取消点赞
|
||
await _likeService.UnlikeAsync(currentUserId, 2, request.CommentId);
|
||
isLiked = false;
|
||
}
|
||
else
|
||
{
|
||
// 添加点赞
|
||
await _likeService.LikeAsync(currentUserId, 2, request.CommentId, comment.UserId);
|
||
isLiked = true;
|
||
}
|
||
|
||
// 3. 获取最新点赞数
|
||
var likeCount = await _likeService.GetLikeCountAsync(2, request.CommentId);
|
||
|
||
// 4. 发送点赞消息（如果是点赞且不是自己的评论）
|
||
if (isLiked && comment.UserId != currentUserId)
|
||
{
|
||
try
|
||
{
|
||
// 获取帖子信息
|
||
var post = await _postsRepository.Select
|
||
.Where(x => x.Id == comment.PostId)
|
||
.FirstAsync();
|
||
|
||
if (post != null)
|
||
{
|
||
await _messagePublisher.SendLikeMessageAsync(
|
||
triggerId: currentUserId,
|
||
receiverId: comment.UserId,
|
||
contentType: 2, // 评论类型
|
||
contentId: comment.Id,
|
||
postTitle: post.Title,
|
||
commentContent: comment.Content
|
||
);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
// 记录日志但不影响点赞操作
|
||
Console.WriteLine($"发送评论点赞消息失败: {ex.Message}");
|
||
}
|
||
}
|
||
|
||
// 5. 构建返回数据
|
||
var result = new LikeCommentRespDto
|
||
{
|
||
CommentId = comment.Id,
|
||
IsLiked = isLiked,
|
||
LikeCount = likeCount
|
||
};
|
||
|
||
return new BaseResponse<LikeCommentRespDto>(isLiked ? "点赞成功！" : "取消点赞成功！", result);
|
||
}
|
||
}
|
||
}
|