700 lines
26 KiB
Java
700 lines
26 KiB
Java
package com.mcwl.resource.consumer;
|
|
|
|
|
|
import com.mcwl.common.constant.QueueConstants;
|
|
import com.mcwl.common.core.domain.entity.SysUser;
|
|
import com.mcwl.common.exception.ServiceException;
|
|
import com.mcwl.common.utils.SecurityUtils;
|
|
import com.mcwl.common.utils.StringUtils;
|
|
import com.mcwl.resource.domain.*;
|
|
import com.mcwl.resource.mapper.*;
|
|
import com.mcwl.resource.service.ISysAdviceService;
|
|
import com.mcwl.system.domain.enums.AdviceEnum;
|
|
import com.mcwl.system.service.ISysUserService;
|
|
import com.rabbitmq.client.Channel;
|
|
import lombok.RequiredArgsConstructor;
|
|
import lombok.extern.slf4j.Slf4j;
|
|
import org.springframework.amqp.core.Message;
|
|
import org.springframework.amqp.rabbit.annotation.RabbitListener;
|
|
import org.springframework.stereotype.Component;
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
import org.springframework.transaction.support.TransactionSynchronization;
|
|
import org.springframework.transaction.support.TransactionSynchronizationManager;
|
|
|
|
import java.io.IOException;
|
|
import java.util.Map;
|
|
import java.util.Objects;
|
|
|
|
@Slf4j
|
|
@Component
|
|
@RequiredArgsConstructor
|
|
public class LikeConsumer {
|
|
|
|
private final ModelMapper modelMapper;
|
|
|
|
|
|
private final ModelLikeMapper modelLikeMapper;
|
|
|
|
private final ISysAdviceService sysAdviceService;
|
|
|
|
private final ISysUserService sysUserService;
|
|
|
|
private final ModelCommentMapper modelCommentMapper;
|
|
|
|
private final ModelCommentLikeMapper modelCommentLikeMapper;
|
|
|
|
private final ModelImageCommentMapper modelImageCommentMapper;
|
|
|
|
private final ModelImageCommentLikeMapper modelImageCommentLikeMapper;
|
|
|
|
private final ModelImageMapper modelImageMapper;
|
|
|
|
private final ModelImageLikeMapper modelImageLikeMapper;
|
|
|
|
private final WorkFlowMapper workFlowMapper;
|
|
|
|
private final WorkFlowLikeMapper workFlowLikeMapper;
|
|
|
|
private final WorkFlowCommentMapper workFlowCommentMapper;
|
|
|
|
|
|
private final WorkFlowCommentLikeMapper workFlowCommentLikeMapper;
|
|
|
|
|
|
/**
|
|
* 模型点赞消息消费
|
|
*/
|
|
@RabbitListener(queues = QueueConstants.MODEL_LIKE_QUEUE, ackMode = "MANUAL")
|
|
@Transactional(rollbackFor = Exception.class)
|
|
public void modelLikeMsg(Map<String, Long> map, Channel channel, Message message) {
|
|
try {
|
|
Long userId = map.get("userId");
|
|
Long productId = map.get("commentId");
|
|
this.modelLike(userId, productId);
|
|
// 注册事务同步回调
|
|
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
|
|
@Override
|
|
public void afterCommit() {
|
|
try {
|
|
// 事务提交后发送ACK
|
|
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
|
|
} catch (IOException e) {
|
|
log.error("ACK失败: {}", e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void afterCompletion(int status) {
|
|
if (status == STATUS_ROLLED_BACK) {
|
|
try {
|
|
// 事务回滚后发送NACK
|
|
channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
|
|
} catch (IOException e) {
|
|
log.error("NACK失败: {}", e.getMessage());
|
|
}
|
|
}
|
|
}
|
|
});
|
|
} catch (Exception e) {
|
|
log.error("模型点赞消息出错: {}", e.getMessage(), e);
|
|
throw new ServiceException("模型点赞消息出错");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 模型评论点赞消息消费
|
|
*/
|
|
@RabbitListener(queues = QueueConstants.MODEL_COMMENT_LIKE_QUEUE, ackMode = "MANUAL")
|
|
@Transactional(rollbackFor = Exception.class)
|
|
public void modelCommentLikeMsg(Map<String, Long> map, Channel channel, Message message) {
|
|
try {
|
|
Long userId = map.get("userId");
|
|
Long productId = map.get("commentId");
|
|
this.modelCommentLike(userId, productId);
|
|
// 注册事务同步回调
|
|
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
|
|
@Override
|
|
public void afterCommit() {
|
|
try {
|
|
// 事务提交后发送ACK
|
|
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
|
|
} catch (IOException e) {
|
|
log.error("ACK失败: {}", e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void afterCompletion(int status) {
|
|
if (status == STATUS_ROLLED_BACK) {
|
|
try {
|
|
// 事务回滚后发送NACK
|
|
channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
|
|
} catch (IOException e) {
|
|
log.error("NACK失败: {}", e.getMessage());
|
|
}
|
|
}
|
|
}
|
|
});
|
|
} catch (Exception e) {
|
|
log.error("模型评论点赞消息出错: {}", e.getMessage(), e);
|
|
throw new ServiceException("模型评论点赞消息出错");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 图片点赞消息消费
|
|
*/
|
|
@RabbitListener(queues = QueueConstants.IMAGE_LIKE_QUEUE, ackMode = "MANUAL")
|
|
@Transactional(rollbackFor = Exception.class)
|
|
public void imageLikeMsg(Map<String, Long> map, Channel channel, Message message) {
|
|
try {
|
|
Long userId = map.get("userId");
|
|
Long productId = map.get("commentId");
|
|
this.imageLike(userId, productId);
|
|
// 注册事务同步回调
|
|
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
|
|
@Override
|
|
public void afterCommit() {
|
|
try {
|
|
// 事务提交后发送ACK
|
|
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
|
|
} catch (IOException e) {
|
|
log.error("ACK失败: {}", e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void afterCompletion(int status) {
|
|
if (status == STATUS_ROLLED_BACK) {
|
|
try {
|
|
// 事务回滚后发送NACK
|
|
channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
|
|
} catch (IOException e) {
|
|
log.error("NACK失败: {}", e.getMessage());
|
|
}
|
|
}
|
|
}
|
|
});
|
|
} catch (Exception e) {
|
|
log.error("图片点赞消息出错: {}", e.getMessage(), e);
|
|
throw new ServiceException("图片点赞消息出错");
|
|
}
|
|
}
|
|
|
|
/**s
|
|
* 图片评论点赞消息消费
|
|
*/
|
|
@RabbitListener(queues = QueueConstants.IMAGE_COMMENT_LIKE_QUEUE, ackMode = "MANUAL")
|
|
@Transactional(rollbackFor = Exception.class)
|
|
public void imageCommentLikeMsg(Map<String, Long> map, Channel channel, Message message) {
|
|
try {
|
|
Long userId = map.get("userId");
|
|
Long productId = map.get("commentId");
|
|
this.imageCommentLike(userId, productId);
|
|
// 注册事务同步回调
|
|
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
|
|
@Override
|
|
public void afterCommit() {
|
|
try {
|
|
// 事务提交后发送ACK
|
|
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
|
|
} catch (IOException e) {
|
|
log.error("ACK失败: {}", e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void afterCompletion(int status) {
|
|
if (status == STATUS_ROLLED_BACK) {
|
|
try {
|
|
// 事务回滚后发送NACK
|
|
channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
|
|
} catch (IOException e) {
|
|
log.error("NACK失败: {}", e.getMessage());
|
|
}
|
|
}
|
|
}
|
|
});
|
|
} catch (Exception e) {
|
|
log.error("图片评论点赞消息出错: {}", e.getMessage(), e);
|
|
throw new ServiceException("图片评论点赞消息出错");
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* 工作流点赞消息消费
|
|
*/
|
|
@RabbitListener(queues = QueueConstants.WORK_FLOW_LIKE_QUEUE, ackMode = "MANUAL")
|
|
@Transactional(rollbackFor = Exception.class)
|
|
public void workFlowLikeMsg(Map<String, Long> map, Channel channel, Message message) {
|
|
try {
|
|
Long userId = map.get("userId");
|
|
Long productId = map.get("commentId");
|
|
this.workFLowLike(userId, productId);
|
|
// 注册事务同步回调
|
|
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
|
|
@Override
|
|
public void afterCommit() {
|
|
try {
|
|
// 事务提交后发送ACK
|
|
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
|
|
} catch (IOException e) {
|
|
log.error("ACK失败: {}", e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void afterCompletion(int status) {
|
|
if (status == STATUS_ROLLED_BACK) {
|
|
try {
|
|
// 事务回滚后发送NACK
|
|
channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
|
|
} catch (IOException e) {
|
|
log.error("NACK失败: {}", e.getMessage());
|
|
}
|
|
}
|
|
}
|
|
});
|
|
} catch (Exception e) {
|
|
log.error("工作流点赞消息出错: {}", e.getMessage(), e);
|
|
throw new ServiceException("工作流点赞消息出错");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 工作流评论点赞消息消费
|
|
*/
|
|
@RabbitListener(queues = QueueConstants.WORK_FLOW_COMMENT_LIKE_QUEUE, ackMode = "MANUAL")
|
|
@Transactional(rollbackFor = Exception.class)
|
|
public void workFlowCommentLikeMsg(Map<String, Long> map, Channel channel, Message message) {
|
|
try {
|
|
Long userId = map.get("userId");
|
|
Long productId = map.get("commentId");
|
|
this.workFlowCommentLike(userId, productId);
|
|
// 注册事务同步回调
|
|
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
|
|
@Override
|
|
public void afterCommit() {
|
|
try {
|
|
// 事务提交后发送ACK
|
|
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
|
|
} catch (IOException e) {
|
|
log.error("ACK失败: {}", e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void afterCompletion(int status) {
|
|
if (status == STATUS_ROLLED_BACK) {
|
|
try {
|
|
// 事务回滚后发送NACK
|
|
channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
|
|
} catch (IOException e) {
|
|
log.error("NACK失败: {}", e.getMessage());
|
|
}
|
|
}
|
|
}
|
|
});
|
|
} catch (Exception e) {
|
|
log.error("工作流评论点赞消息出错: {}", e.getMessage(), e);
|
|
throw new ServiceException("工作流评论点赞消息出错");
|
|
}
|
|
}
|
|
|
|
|
|
private void modelLike(Long userId, Long modelId) {
|
|
ModelProduct model = modelMapper.selectById(modelId);
|
|
if (Objects.isNull(model)) {
|
|
throw new ServiceException("该模型不存在或已下架");
|
|
}
|
|
ModelLike modelLike = modelLikeMapper.getLike(userId, modelId);
|
|
if (Objects.nonNull(modelLike)) {
|
|
if (Objects.equals(modelLike.getDelFlag(), "0")) {
|
|
modelLike.setDelFlag("2");
|
|
int likeNum = model.getLikeNum() - 1;
|
|
likeNum = Math.max(likeNum, 0);
|
|
model.setLikeNum(likeNum);
|
|
} else {
|
|
modelLike.setDelFlag("0");
|
|
model.setLikeNum(model.getLikeNum() + 1);
|
|
this.addLikeAdvice(model, userId);
|
|
}
|
|
// 更新点赞记录
|
|
modelLikeMapper.updateDelFlagById(modelLike);
|
|
// 更新图片点赞数
|
|
modelMapper.updateById(model);
|
|
return;
|
|
}
|
|
|
|
// 添加点赞记录
|
|
modelLike = new ModelLike();
|
|
modelLike.setUserId(userId);
|
|
modelLike.setModelId(modelId);
|
|
modelLikeMapper.insert(modelLike);
|
|
|
|
// 更新图片点赞数
|
|
model.setNumbers(model.getLikeNum() + 1);
|
|
modelMapper.updateById(model);
|
|
|
|
this.addLikeAdvice(model, userId);
|
|
}
|
|
|
|
|
|
private void addLikeAdvice(ModelProduct model, Long userId) {
|
|
|
|
Long receiverUserId = model.getUserId();
|
|
|
|
if (Objects.equals(userId, receiverUserId)) {
|
|
return;
|
|
}
|
|
|
|
SysUser sysUser = sysUserService.selectUserById(userId);
|
|
|
|
String content = StringUtils.format("恭喜！{}点赞了您的模型：{}",
|
|
sysUser.getNickName(), model.getModelName());
|
|
|
|
SysAdvice sysAdvice = new SysAdvice();
|
|
sysAdvice.setSenderId(userId);
|
|
sysAdvice.setReceiverId(receiverUserId);
|
|
sysAdvice.setContent(content);
|
|
sysAdvice.setProductId(model.getId());
|
|
sysAdvice.setProductType(0);
|
|
sysAdvice.setIsRead(0);
|
|
sysAdvice.setType(AdviceEnum.LIKE_REMIND);
|
|
sysAdviceService.save(sysAdvice);
|
|
|
|
|
|
}
|
|
|
|
|
|
private void modelCommentLike(Long userId, Long commentId) {
|
|
ModelComment modelComment = modelCommentMapper.selectById(commentId);
|
|
if (Objects.isNull(modelComment)) {
|
|
throw new ServiceException("该评论不存在");
|
|
}
|
|
ModelCommentLike modelCommentLike = modelCommentLikeMapper.getLikeComment(userId, commentId);
|
|
if (Objects.nonNull(modelCommentLike)) {
|
|
if (Objects.equals(modelCommentLike.getDelFlag(), "0")) {
|
|
modelCommentLike.setDelFlag("2");
|
|
int likeNum = modelComment.getLikeNum() - 1;
|
|
likeNum = Math.max(likeNum, 0);
|
|
modelComment.setLikeNum(likeNum);
|
|
} else {
|
|
modelCommentLike.setDelFlag("0");
|
|
modelComment.setLikeNum(modelComment.getLikeNum() + 1);
|
|
this.addLikeAdvice(modelComment, userId);
|
|
}
|
|
// 更新点赞记录
|
|
modelCommentLikeMapper.updateDelFlagById(modelCommentLike);
|
|
// 更新图片评论点赞数
|
|
modelCommentMapper.updateById(modelComment);
|
|
return;
|
|
}
|
|
|
|
// 添加点赞记录
|
|
modelCommentLike = new ModelCommentLike();
|
|
modelCommentLike.setUserId(userId);
|
|
modelCommentLike.setModelCommentId(commentId);
|
|
modelCommentLikeMapper.insert(modelCommentLike);
|
|
|
|
// 更新模型点赞数
|
|
modelComment.setLikeNum(modelComment.getLikeNum() + 1);
|
|
modelCommentMapper.updateById(modelComment);
|
|
|
|
this.addLikeAdvice(modelComment, userId);
|
|
}
|
|
|
|
|
|
private void addLikeAdvice(ModelComment modelComment, Long userId) {
|
|
|
|
Long receiverUserId = modelComment.getUserId();
|
|
|
|
if (Objects.equals(userId, receiverUserId)) {
|
|
return;
|
|
}
|
|
|
|
SysUser sysUser = sysUserService.selectUserById(userId);
|
|
|
|
String content = StringUtils.format("恭喜！{}点赞了您的评论",
|
|
sysUser.getNickName());
|
|
|
|
SysAdvice sysAdvice = new SysAdvice();
|
|
sysAdvice.setSenderId(userId);
|
|
sysAdvice.setReceiverId(receiverUserId);
|
|
sysAdvice.setContent(content);
|
|
sysAdvice.setProductId(modelComment.getModelId());
|
|
sysAdvice.setProductType(0);
|
|
sysAdvice.setCommentId(modelComment.getId());
|
|
sysAdvice.setIsRead(0);
|
|
sysAdvice.setType(AdviceEnum.LIKE_REMIND);
|
|
sysAdviceService.save(sysAdvice);
|
|
|
|
|
|
}
|
|
|
|
|
|
private void imageLike(Long userId, Long imageId) {
|
|
ModelImage modelImage = modelImageMapper.selectById(imageId);
|
|
if (Objects.isNull(modelImage)) {
|
|
throw new ServiceException("该图片不存在或已下架");
|
|
}
|
|
ModelImageLike modelImageLike = modelImageLikeMapper.getLikeImage(userId, imageId);
|
|
if (Objects.nonNull(modelImageLike)) {
|
|
if (Objects.equals(modelImageLike.getDelFlag(), "0")) {
|
|
modelImageLike.setDelFlag("2");
|
|
int likeNum = modelImage.getLikeNum() - 1;
|
|
likeNum = Math.max(likeNum, 0);
|
|
modelImage.setLikeNum(likeNum);
|
|
} else {
|
|
modelImageLike.setDelFlag("0");
|
|
modelImage.setLikeNum(modelImage.getLikeNum() + 1);
|
|
this.addLikeAdvice(modelImage, userId);
|
|
}
|
|
// 更新点赞记录
|
|
modelImageLikeMapper.updateDelFlagById(modelImageLike);
|
|
// 更新图片点赞数
|
|
modelImageMapper.updateById(modelImage);
|
|
return;
|
|
}
|
|
|
|
// 添加点赞记录
|
|
modelImageLike = new ModelImageLike();
|
|
modelImageLike.setUserId(userId);
|
|
modelImageLike.setModelImageId(imageId);
|
|
modelImageLikeMapper.insert(modelImageLike);
|
|
|
|
// 更新图片点赞数
|
|
modelImage.setLikeNum(modelImage.getLikeNum() + 1);
|
|
modelImageMapper.updateById(modelImage);
|
|
|
|
this.addLikeAdvice(modelImage, userId);
|
|
}
|
|
|
|
|
|
private void addLikeAdvice(ModelImage modelImage, Long userId) {
|
|
|
|
Long receiverUserId = modelImage.getUserId();
|
|
|
|
if (Objects.equals(userId, receiverUserId)) {
|
|
return;
|
|
}
|
|
|
|
SysUser sysUser = sysUserService.selectUserById(userId);
|
|
|
|
String content = StringUtils.format("恭喜！{}点赞了您的图片：{}",
|
|
sysUser.getNickName(), modelImage.getTitle());
|
|
|
|
SysAdvice sysAdvice = new SysAdvice();
|
|
sysAdvice.setSenderId(userId);
|
|
sysAdvice.setReceiverId(receiverUserId);
|
|
sysAdvice.setContent(content);
|
|
sysAdvice.setProductId(modelImage.getId());
|
|
sysAdvice.setProductType(2);
|
|
sysAdvice.setIsRead(0);
|
|
sysAdvice.setType(AdviceEnum.LIKE_REMIND);
|
|
sysAdviceService.save(sysAdvice);
|
|
|
|
|
|
}
|
|
|
|
|
|
private void imageCommentLike(Long userId, Long commentId) {
|
|
ModelImageComment modelImageComment = modelImageCommentMapper.selectById(commentId);
|
|
if (Objects.isNull(modelImageComment)) {
|
|
throw new ServiceException("该评论不存在");
|
|
}
|
|
ModelImageCommentLike modelImageCommentLike = modelImageCommentLikeMapper.getLikeImageComment(userId, commentId);
|
|
if (Objects.nonNull(modelImageCommentLike)) {
|
|
if (Objects.equals(modelImageCommentLike.getDelFlag(), "0")) {
|
|
modelImageCommentLike.setDelFlag("2");
|
|
int likeNum = modelImageComment.getLikeNum() - 1;
|
|
likeNum = Math.max(likeNum, 0);
|
|
modelImageComment.setLikeNum(likeNum);
|
|
} else {
|
|
modelImageCommentLike.setDelFlag("0");
|
|
modelImageComment.setLikeNum(modelImageComment.getLikeNum() + 1);
|
|
this.addLikeAdvice(modelImageComment, userId);
|
|
}
|
|
// 更新点赞记录
|
|
modelImageCommentLikeMapper.updateDelFlagById(modelImageCommentLike);
|
|
// 更新图片评论点赞数
|
|
modelImageCommentMapper.updateById(modelImageComment);
|
|
return;
|
|
}
|
|
|
|
// 添加点赞记录
|
|
modelImageCommentLike = new ModelImageCommentLike();
|
|
modelImageCommentLike.setUserId(userId);
|
|
modelImageCommentLike.setModelImageCommentId(commentId);
|
|
modelImageCommentLikeMapper.insert(modelImageCommentLike);
|
|
|
|
// 更新图片点赞数
|
|
modelImageComment.setLikeNum(modelImageComment.getLikeNum() + 1);
|
|
modelImageCommentMapper.updateById(modelImageComment);
|
|
|
|
this.addLikeAdvice(modelImageComment, userId);
|
|
}
|
|
|
|
|
|
private void addLikeAdvice(ModelImageComment modelImageComment, Long userId) {
|
|
|
|
Long receiverUserId = modelImageComment.getUserId();
|
|
|
|
if (Objects.equals(userId, receiverUserId)) {
|
|
return;
|
|
}
|
|
|
|
SysUser sysUser = sysUserService.selectUserById(userId);
|
|
|
|
String content = StringUtils.format("恭喜！{}点赞了您的评论",
|
|
sysUser.getNickName());
|
|
|
|
SysAdvice sysAdvice = new SysAdvice();
|
|
sysAdvice.setSenderId(userId);
|
|
sysAdvice.setReceiverId(receiverUserId);
|
|
sysAdvice.setContent(content);
|
|
sysAdvice.setProductId(modelImageComment.getModelImageId());
|
|
sysAdvice.setProductType(2);
|
|
sysAdvice.setCommentId(modelImageComment.getId());
|
|
sysAdvice.setIsRead(0);
|
|
sysAdvice.setType(AdviceEnum.LIKE_REMIND);
|
|
sysAdviceService.save(sysAdvice);
|
|
|
|
|
|
}
|
|
|
|
|
|
private void workFLowLike(Long userId, Long modelId) {
|
|
WorkFlow workFlow = workFlowMapper.selectById(modelId);
|
|
if (Objects.isNull(workFlow)) {
|
|
throw new ServiceException("该工作流不存在或已下架");
|
|
}
|
|
WorkFlowLike workFlowLike = workFlowLikeMapper.getLike(userId, modelId);
|
|
if (Objects.nonNull(workFlowLike)) {
|
|
if (Objects.equals(workFlowLike.getDelFlag(), "0")) {
|
|
workFlowLike.setDelFlag("2");
|
|
int likeCount = workFlow.getLikeNum() - 1;
|
|
likeCount = Math.max(likeCount, 0);
|
|
workFlow.setLikeNum(likeCount);
|
|
} else {
|
|
workFlowLike.setDelFlag("0");
|
|
workFlow.setLikeNum(workFlow.getLikeNum() + 1);
|
|
this.addLikeAdvice(workFlow, userId);
|
|
}
|
|
// 更新点赞记录
|
|
workFlowLikeMapper.updateStatus(workFlowLike);
|
|
// 更新图片点赞数
|
|
workFlowMapper.updateById(workFlow);
|
|
return;
|
|
}
|
|
|
|
// 添加点赞记录
|
|
workFlowLike = new WorkFlowLike();
|
|
workFlowLike.setUserId(userId);
|
|
workFlowLike.setWorkFlowId(modelId);
|
|
workFlowLikeMapper.insert(workFlowLike);
|
|
|
|
// 更新图片点赞数
|
|
workFlow.setLikeNum(workFlow.getLikeNum() + 1);
|
|
workFlowMapper.updateById(workFlow);
|
|
|
|
this.addLikeAdvice(workFlow, userId);
|
|
}
|
|
|
|
|
|
private void addLikeAdvice(WorkFlow workFlow, Long userId) {
|
|
|
|
Long receiverUserId = workFlow.getUserId();
|
|
|
|
if (Objects.equals(userId, receiverUserId)) {
|
|
return;
|
|
}
|
|
|
|
SysUser sysUser = sysUserService.selectUserById(userId);
|
|
|
|
String content = StringUtils.format("恭喜！{}点赞了您的工作流：{}",
|
|
sysUser.getNickName(), workFlow.getWorkflowName());
|
|
|
|
SysAdvice sysAdvice = new SysAdvice();
|
|
sysAdvice.setSenderId(userId);
|
|
sysAdvice.setReceiverId(receiverUserId);
|
|
sysAdvice.setContent(content);
|
|
sysAdvice.setProductId(workFlow.getId());
|
|
sysAdvice.setProductType(1);
|
|
sysAdvice.setIsRead(0);
|
|
sysAdvice.setType(AdviceEnum.LIKE_REMIND);
|
|
sysAdviceService.save(sysAdvice);
|
|
|
|
|
|
}
|
|
|
|
|
|
private void workFlowCommentLike(Long userId, Long commentId) {
|
|
WorkFlowComment workFlowComment = workFlowCommentMapper.selectById(commentId);
|
|
if (Objects.isNull(workFlowComment)) {
|
|
throw new ServiceException("该评论不存在");
|
|
}
|
|
WorkFlowCommentLike workFlowCommentLike = workFlowCommentLikeMapper.getLikeComment(userId, commentId);
|
|
if (Objects.nonNull(workFlowCommentLike)) {
|
|
if (Objects.equals(workFlowCommentLike.getDelFlag(), "0")) {
|
|
workFlowCommentLike.setDelFlag("2");
|
|
int likeNum = workFlowComment.getLikeNum() - 1;
|
|
likeNum = Math.max(likeNum, 0);
|
|
workFlowComment.setLikeNum(likeNum);
|
|
} else {
|
|
workFlowCommentLike.setDelFlag("0");
|
|
workFlowComment.setLikeNum(workFlowComment.getLikeNum() + 1);
|
|
this.addLikeAdvice(workFlowComment, userId);
|
|
}
|
|
// 更新点赞记录
|
|
workFlowCommentLikeMapper.updateDelFlagById(workFlowCommentLike);
|
|
// 更新图片评论点赞数
|
|
workFlowCommentMapper.updateById(workFlowComment);
|
|
return;
|
|
}
|
|
|
|
// 添加点赞记录
|
|
workFlowCommentLike = new WorkFlowCommentLike();
|
|
workFlowCommentLike.setUserId(userId);
|
|
workFlowCommentLike.setWorkFlowCommentId(commentId);
|
|
workFlowCommentLikeMapper.insert(workFlowCommentLike);
|
|
|
|
// 更新模型点赞数
|
|
workFlowComment.setLikeNum(workFlowComment.getLikeNum() + 1);
|
|
workFlowCommentMapper.updateById(workFlowComment);
|
|
|
|
this.addLikeAdvice(workFlowComment, userId);
|
|
}
|
|
|
|
|
|
private void addLikeAdvice(WorkFlowComment workFlowComment, Long userId) {
|
|
|
|
Long receiverUserId = workFlowComment.getUserId();
|
|
|
|
if (Objects.equals(userId, receiverUserId)) {
|
|
return;
|
|
}
|
|
|
|
SysUser sysUser = sysUserService.selectUserById(userId);
|
|
|
|
String content = StringUtils.format("恭喜！{}点赞了您的评论",
|
|
sysUser.getNickName());
|
|
|
|
SysAdvice sysAdvice = new SysAdvice();
|
|
sysAdvice.setSenderId(userId);
|
|
sysAdvice.setReceiverId(receiverUserId);
|
|
sysAdvice.setContent(content);
|
|
sysAdvice.setProductId(workFlowComment.getWorkFlowId());
|
|
sysAdvice.setProductType(1);
|
|
sysAdvice.setCommentId(workFlowComment.getId());
|
|
sysAdvice.setIsRead(0);
|
|
sysAdvice.setType(AdviceEnum.LIKE_REMIND);
|
|
sysAdviceService.save(sysAdvice);
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|