abu/wzj-boot
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[fix]修改粉丝和关注

Browse Source
This commit is contained in:
王庆祥 2025-06-14 11:44:05 +08:00
parent 7212f67023
commit b075011ce8
16 changed files with 349 additions and 323 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/constant/CacheConstants.java
View File

@ -32,6 +32,17 @@ public interface CacheConstants {
*/
String MEMEBER="MEMEBER:";
/**
* 粉丝
*/
String MEMBER_FANS="MEMBER_FANS:";
/**
* 关注
*/
String MEMBER_FOLLOW="MEMBER_FOLLOW:";
String BLACK_LIST="BLACK_LIST:";
}

9
ruoyi-modules/ruoyi-content/src/main/java/com/wzj/soopin/content/controller/admin/VlogUploadController.java
View File

@ -175,12 +175,12 @@ public class VlogUploadController extends BaseInfoProperties {
// 获取粉丝数量：优先 Redis，无则 MySQL
String fansCountsStr = redis.get(REDIS_MY_FANS_COUNTS + ":" + vlog.getVlogerId());
Integer fansCounts = 0;
Long fansCounts = 0L;
if (StringUtils.isNotBlank(fansCountsStr)) {
fansCounts = Integer.valueOf(fansCountsStr);
fansCounts = Long .valueOf(fansCountsStr);
} else {
// Redis 中没有，从数据库查询
fansCounts = fansService.countFansByVlogerId(vlog.getVlogerId());
fansCounts = fansService.countFansByVloggerId(Long.valueOf(vlog.getVlogerId()));
// 可以选择在这里将数据库查询结果写入 Redis，以便下次使用
if (fansCounts != null) {
redis.set(REDIS_MY_FANS_COUNTS + ":" + vlog.getVlogerId(), String.valueOf(fansCounts));
@ -267,8 +267,7 @@ public class VlogUploadController extends BaseInfoProperties {
List<Map<String, Object>> likedUsers = myLikedVlogMapper.selectLikedUsersByVlogId(vlog.getId());
result.put("likedUsers", likedUsers);
IPage<FansVO> fansList = fansService.queryMyFans(vlog.getVlogerId(),0,10);
IPage<FansVO> fansList = fansService.queryMyFans(Long.valueOf(vlog.getVlogerId()),0,10);
result.put("fansList", fansList);
} else {

2
ruoyi-modules/ruoyi-content/src/main/java/com/wzj/soopin/content/service/impl/VlogServiceImpl.java
View File

@ -150,7 +150,7 @@ public class VlogServiceImpl extends BaseInfoProperties implements VlogService {
BeanUtils.copyProperties(v, vo);
if (StringUtils.isNotBlank(userId)) {
vo.setDoIFollowVloger(fansService.queryDoIFollowVloger(userId, v.getVlogerId()));
vo.setDoIFollowVloger(fansService.queryDoIFollowVloger(Long.valueOf(userId), Long.valueOf(v.getVlogerId())));
vo.setDoILikeThisVlog(doILikeVlog(userId, v.getId()));
}

386
ruoyi-modules/ruoyi-member/src/main/java/com/wzj/soopin/member/controller/FansController.java
View File

@ -1,280 +1,150 @@
package com.wzj.soopin.member.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.wzj.soopin.member.domain.vo.FansVO;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.wzj.soopin.member.domain.po.Member;
import com.wzj.soopin.member.domain.po.MemberBlock;
import com.wzj.soopin.member.service.IFansService;
import com.wzj.soopin.member.service.IMemberBlockService;
import com.wzj.soopin.member.service.IMemberService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.dromara.common.core.constant.CacheConstants;
import org.dromara.common.core.domain.R;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.dromara.common.core.utils.StringUtils;
import org.dromara.common.redis.utils.RedisUtils;
import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.List;
@Slf4j
@RequestMapping("/ums/fans")
@RequestMapping("/ums/fans/")
@RestController
@RequiredArgsConstructor
public class FansController {
public class FansController {
private final IMemberService memberService;
private final IFansService fansService;
// @PostMapping("follow")
// public R<IPage<FansVO>> follow(@RequestParam String myId,
// @RequestParam String vlogerId) {
// // 从redis中获取拉黑信息
// String redisKey = BaseInfoProperties.REDIS_USER_BLOCK + ":" + myId;
// Boolean hasKey = redis.keyIsExist(redisKey);
// if(hasKey){
// List<String> blockUserList = new ArrayList<>();
// ObjectMapper objectMapper = new ObjectMapper();
// List<String> reports = redis.lrange(redisKey, 0, -1); // 查询用户的所有举报记录
//
// for (String report : reports) {
// try {
// Map<String, Object> reportMap = objectMapper.readValue(report, new TypeReference<Map<String, Object>>() {});
// // 处理拉黑信息
// String queryvlogerId = (String) reportMap.get("vlogerId");
// blockUserList.add(queryvlogerId);
// } catch (JsonProcessingException e) {
// e.printStackTrace();
// }
// }
// System.out.println(blockUserList);
// Boolean isBlock = blockUserList.contains(vlogerId);
// if(isBlock){
// return GraceJSONResult.errorCustom(ResponseStatusEnum.ON_BLOCK);
// }
// }
//
// // 判断两个id不能为空
// if (StringUtils.isBlank(myId) || StringUtils.isBlank(vlogerId)) {
// return GraceJSONResult.errorCustom(ResponseStatusEnum.SYSTEM_ERROR);
// }
//
// // 判断当前用户，自己不能关注自己
// if (myId.equalsIgnoreCase(vlogerId)) {
// return GraceJSONResult.errorCustom(ResponseStatusEnum.SYSTEM_RESPONSE_NO_INFO);
// }
//
// // 是否已经存在关系
// Boolean flow = fansService.queryDoIFollowVloger(myId,vlogerId);
// if(flow){
// return GraceJSONResult.errorCustom(ResponseStatusEnum.FANS_INFO_UPDATED_ISFAN_EXIST_ERROR);
// }
//
// // 判断两个id对应的用户是否存在
// Users vloger = userService.getUser(vlogerId);
// Users myInfo = userService.getUser(myId);
//
// // fixme: 两个用户id的数据库查询后的判断，是分开好？还是合并判断好？
// if (myInfo == null || vloger == null) {
// return GraceJSONResult.errorCustom(ResponseStatusEnum.SYSTEM_RESPONSE_NO_INFO);
// }
////
// // 保存粉丝关系到数据库
// fansService.doFollow(myId, vlogerId);
//
// // 博主的粉丝+1，我的关注+1
// redis.increment(BaseInfoProperties.REDIS_MY_FOLLOWS_COUNTS + ":" + myId, 1);
// redis.increment(BaseInfoProperties.REDIS_MY_FANS_COUNTS + ":" + vlogerId, 1);
//
// // 我和博主的关联关系，依赖redis，不要存储数据库，避免db的性能瓶颈
// redis.set(BaseInfoProperties.REDIS_FANS_AND_VLOGGER_RELATIONSHIP + ":" + myId + ":" + vlogerId, "1");
////
// return GraceJSONResult.ok();
// }
// @PostMapping("cancel")
// public GraceJSONResult cancel(@RequestParam String myId,
// @RequestParam String vlogerId) {
// // 判断两个id不能为空
// if (StringUtils.isBlank(myId) || StringUtils.isBlank(vlogerId)) {
// return GraceJSONResult.errorCustom(ResponseStatusEnum.SYSTEM_ERROR);
// }
// // 是否已经存在关系
// Boolean flow = fansService.queryDoIFollowVloger(myId,vlogerId);
// if(!flow){
// return GraceJSONResult.errorCustom(ResponseStatusEnum.FANS_INFO_UPDATED_ISFLOW_EXIST_ERROR);
// }
// // 删除业务的执行
// fansService.doCancel(myId, vlogerId);
private final IMemberBlockService memberBlockService;
@PostMapping("follow")
public R<Object> follow(@RequestParam Long myId,
@RequestParam Long vloggerId) {
// 判断两个id不能为空
if (myId ==null|| vloggerId==null) {
return R.fail("id不能为空");
}
// 获取拉黑数据
boolean hasblock = memberBlockService.hasBlocked(myId, vloggerId);
if (hasblock) {
return R.fail("已经拉黑");
}
// 判断当前用户，自己不能关注自己
if (myId ==vloggerId) {
return R.fail("自己不能关注自己");
}
// 是否已经存在关系
boolean flow = fansService.queryDoIFollowVloger(myId, vloggerId);
if (flow) {
return R.fail("已经在关注列表里了");
}
// 判断两个id对应的用户是否存在
Member vlogger = memberService.getById(vloggerId);
Member myInfo = memberService.getById(myId);
if (myInfo == null || vlogger == null) {
return R.fail("用户不存在");
}
//
// // 博主的粉丝-1，我的关注-1
// redis.decrement(BaseInfoProperties.REDIS_MY_FOLLOWS_COUNTS + ":" + myId, 1);
// redis.decrement(BaseInfoProperties.REDIS_MY_FANS_COUNTS + ":" + vlogerId, 1);
//
// // 我和博主的关联关系，依赖redis，不要存储数据库，避免db的性能瓶颈
// redis.del(BaseInfoProperties.REDIS_FANS_AND_VLOGGER_RELATIONSHIP + ":" + myId + ":" + vlogerId);
//
// return GraceJSONResult.ok();
// }
//
// @GetMapping("queryBlockVloger")
// public GraceJSONResult queryBlockVloger(@RequestParam String myId,
// @RequestParam String vlogerId) {
// // 从redis中获取拉黑信息
// String redisKey = BaseInfoProperties.REDIS_USER_BLOCK + ":" + myId;
// Boolean hasKey = redis.keyIsExist(redisKey);
// if(hasKey){
// List<String> blockUserList = new ArrayList<>();
// ObjectMapper objectMapper = new ObjectMapper();
// List<String> reports = redis.lrange(redisKey, 0, -1); // 查询用户的所有举报记录
//
// for (String report : reports) {
// try {
// Map<String, Object> reportMap = objectMapper.readValue(report, new TypeReference<Map<String, Object>>() {});
// // 处理拉黑信息
// String queryvlogerId = (String) reportMap.get("vlogerId");
// blockUserList.add(queryvlogerId);
// } catch (JsonProcessingException e) {
// e.printStackTrace();
// }
// }
// System.out.println(blockUserList);
// return GraceJSONResult.ok(blockUserList.contains(vlogerId));
// }else{
// return GraceJSONResult.ok(false);
// }
// }
//
// @PostMapping("block")
// public GraceJSONResult block(@RequestParam String myId,
// @RequestParam String vlogerId) {
// // 先执行cancel
// // 判断两个id不能为空
// if (StringUtils.isBlank(myId) || StringUtils.isBlank(vlogerId)) {
// return GraceJSONResult.errorCustom(ResponseStatusEnum.SYSTEM_ERROR);
// }
// // 是否已经存在关系
// Boolean flow = fansService.queryDoIFollowVloger(myId,vlogerId);
// if(flow){
// // 删除业务的执行
// fansService.doCancel(myId, vlogerId);
//
// // 博主的粉丝-1，我的关注-1
// redis.decrement(BaseInfoProperties.REDIS_MY_FOLLOWS_COUNTS + ":" + myId, 1);
// redis.decrement(BaseInfoProperties.REDIS_MY_FANS_COUNTS + ":" + vlogerId, 1);
//
// // 我和博主的关联关系，依赖redis，不要存储数据库，避免db的性能瓶颈
// redis.del(BaseInfoProperties.REDIS_FANS_AND_VLOGGER_RELATIONSHIP + ":" + myId + ":" + vlogerId);
// }
// // 拉黑
// DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
// String blockTime = LocalDateTime.now().format(formatter);
// try{
// Map<String, String> blockInfo = new HashMap<>();
// blockInfo.put("vlogerId", vlogerId);
// blockInfo.put("myId", myId);
// blockInfo.put("time", blockTime);
// // 转成 JSON 字符串
// ObjectMapper objectMapper = new ObjectMapper();
// String blockJson = objectMapper.writeValueAsString(blockInfo);
// String redisKey = BaseInfoProperties.REDIS_USER_BLOCK + ":" + myId ;
// log.info("写入Redis => key: {}, value: {}", redisKey, blockJson);
// redis.rpush(redisKey , blockJson);
//
// return GraceJSONResult.ok();
// }catch (JsonProcessingException e){
// // 打日志，或者抛出业务异常
// e.printStackTrace();
// throw new RuntimeException("JSON序列化失败: " + e.getMessage());
// }
// }
//
// @PostMapping("cancelBlock")
// public GraceJSONResult cancelBlock(@RequestParam String myId,
// @RequestParam String vlogerId) {
// // 判断两个id不能为空
// if (StringUtils.isBlank(myId) || StringUtils.isBlank(vlogerId)) {
// return GraceJSONResult.errorCustom(ResponseStatusEnum.SYSTEM_ERROR);
// }
// // 解除拉黑
// String redisKey = BaseInfoProperties.REDIS_USER_BLOCK + ":" + myId;
// Boolean hasKey = redis.keyIsExist(redisKey);
// if(hasKey){
// List<String> blockList = redis.lrange(redisKey, 0, -1);
// ObjectMapper objectMapper = new ObjectMapper();
// if (blockList != null && !blockList.isEmpty()) {
// for (String item : blockList) {
// try {
// Map<String, String> itemMap = objectMapper.readValue(item, new TypeReference<Map<String, String>>() {});
// String storedVlogerId = itemMap.get("vlogerId");
//
// if (storedVlogerId != null && storedVlogerId.equals(vlogerId)) {
// redis.lrem(redisKey, 1, item); // 删除找到的 JSON 字符串
// break;
// }
// }catch (JsonProcessingException e){
// e.printStackTrace();
// }
// }
// }
// return GraceJSONResult.ok();
// }else{
// return GraceJSONResult.error();
// }
// }
//
// @PostMapping("blockVideo")
// public GraceJSONResult blockVideo(@RequestParam String myId,
// @RequestParam String vlogId,
// @RequestParam String reason,
// @RequestParam(defaultValue = "") String description) {
// // 判断两个id不能为空
// if (StringUtils.isBlank(myId) || StringUtils.isBlank(vlogId)) {
// return GraceJSONResult.errorCustom(ResponseStatusEnum.SYSTEM_ERROR);
// }
// // 拉黑
// DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
// String blockTime = LocalDateTime.now().format(formatter);
// //
// try{
// Map<String, String> blockInfo = new HashMap<>();
// blockInfo.put("vlogId", vlogId);
// blockInfo.put("reporter", myId);
// blockInfo.put("time", blockTime);
// blockInfo.put("reason", reason);
// blockInfo.put("description", description);
// // 转成 JSON 字符串
// ObjectMapper objectMapper = new ObjectMapper();
// String blockJson = objectMapper.writeValueAsString(blockInfo);
//
// String redisKey = BaseInfoProperties.REDIS_VIDEO_BLOCK + ":" + myId ;
// log.info("写入Redis => key: {}, value: {}", redisKey, blockJson);
// redis.rpush(redisKey , blockJson);
//
// return GraceJSONResult.ok();
// }catch (JsonProcessingException e){
// // 打日志，或者抛出业务异常
// e.printStackTrace();
// throw new RuntimeException("JSON序列化失败: " + e.getMessage());
// }
// }
//
//
//
// @GetMapping("queryDoIFollowVloger")
// public GraceJSONResult queryDoIFollowVloger(@RequestParam String myId,
// @RequestParam String vlogerId) {
// return GraceJSONResult.ok(fansService.queryDoIFollowVloger(myId, vlogerId));
// }
//
// @GetMapping("queryMyFollows")
// public GraceJSONResult queryMyFollows(@RequestParam String myId,
// @RequestParam Integer page,
// @RequestParam Integer pageSize) {
// return GraceJSONResult.ok(
// fansService.queryMyFollows(
// myId,
// page,
// pageSize));
// }
// 保存粉丝关系到数据库
fansService.doFollow(myId, vloggerId);
// 博主的粉丝+1，我的关注+1
RedisUtils.incrAtomicValue(CacheConstants.MEMBER_FANS + ":" + vloggerId);
RedisUtils.incrAtomicValue(CacheConstants.MEMBER_FOLLOW + ":" + myId);
return R.ok("关注成功");
}
@PostMapping("cancel")
public R<Object> cancel(@RequestParam Long myId,
@RequestParam Long vloggerId) {
// 判断两个id不能为空
if ( myId==null || vloggerId==null) {
return R.fail("id不能为空");
}
// 是否已经存在关系
boolean flow = fansService.queryDoIFollowVloger(myId, vloggerId);
if (!flow) {
return R.fail("没有关注信息");
}
// 删除业务的执行
fansService.doCancel(myId, vloggerId);
// 博主的粉丝-1，我的关注-1
RedisUtils.decrAtomicValue(CacheConstants.MEMBER_FANS + ":" + vloggerId);
RedisUtils.decrAtomicValue(CacheConstants.MEMBER_FOLLOW + ":" + myId);
return R.ok("取消成功");
}
@GetMapping("block/list")
public R<List<MemberBlock>> queryBlockVloger(@RequestParam Long myId) {
return R.ok(memberBlockService.list(new LambdaQueryWrapper<MemberBlock>().eq(MemberBlock::getMemberId, myId)));
}
/**
* 添加黑名单
*
* @param myId
* @param vloggerId
* @return
*/
@PostMapping("block")
public R block(@RequestParam Long myId,
@RequestParam Long vloggerId) {
// 先执行cancel
// 判断两个id不能为空
if (myId == null || vloggerId==null) {
return R.ok("id不能为空");
}
// 是否已经存在关系
boolean flow = fansService.queryDoIFollowVloger(myId, vloggerId);
if (flow) {
// 删除业务的执行
fansService.doCancel(myId, vloggerId);
// 博主的粉丝-1，我的关注-1
RedisUtils.decrAtomicValue(CacheConstants.MEMBER_FANS + ":" + vloggerId);
RedisUtils.decrAtomicValue(CacheConstants.MEMBER_FOLLOW + ":" + myId);
}
// 拉黑
memberBlockService.addBlock(myId, vloggerId);
return R.ok();
}
@PostMapping("cancelBlock")
public R cancelBlock(@RequestParam Long myId,
@RequestParam Long vloggerId) {
// 判断两个id不能为空
if (myId==null||vloggerId==null) {
R.fail("id不能为空");
}
memberBlockService.removeBlock(myId, vloggerId);
return R.ok();
}
}

59
ruoyi-modules/ruoyi-member/src/main/java/com/wzj/soopin/member/domain/bo/MemberBO.java
View File

@ -16,81 +16,80 @@ import java.time.LocalDateTime;
*
* @author zcc
*/
@Schema(description="会员信息 查询 对象")
@Schema(description = "会员信息 查询 对象")
@Data
public class MemberBO extends BaseBO {
public class MemberBO extends BaseBO {
@Schema(description ="id")
private Long id;
@Schema(description = "id")
private Long id;
@Schema(description ="昵称 精确匹配")
@Schema(description = "昵称 精确匹配")
private String nickname;
@Schema(description ="密码 精确匹配")
@Schema(description = "密码 精确匹配")
private String password;
@Schema(description ="手机号码 精确匹配")
@Schema(description = "手机号码 精确匹配")
private String phone;
@Schema(description ="有无备注 1：有备注 0：无备注")
@Schema(description = "有无备注 1：有备注 0：无备注")
private Integer hasMark;
@Schema(description ="用户备注 精确匹配")
@Schema(description = "用户备注 精确匹配")
private String mark;
@Schema(description ="帐号启用状态:0->禁用；1->启用 精确匹配")
@Schema(description = "帐号启用状态:0->禁用；1->启用 精确匹配")
private Integer status;
@Schema(description ="头像 精确匹配")
@Schema(description = "头像 精确匹配")
private String avatar;
@Schema(description ="性别：0->未知；1->男；2->女 精确匹配")
@Schema(description = "性别：0->未知；1->男；2->女 精确匹配")
private Integer gender;
@Schema(description ="用户所在城市 精确匹配")
@Schema(description = "用户所在城市 精确匹配")
private String city;
@Schema(description ="用户所在省份 精确匹配")
@Schema(description = "用户所在省份 精确匹配")
private String province;
@Schema(description ="用户所在国家 精确匹配")
@Schema(description = "用户所在国家 精确匹配")
private String country;
@Schema(description ="生日 精确匹配")
@Schema(description = "生日 精确匹配")
private LocalDate birthday;
@Schema(description ="推广员id 精确匹配")
@Schema(description = "推广员id 精确匹配")
private Long spreadUid;
@Schema(description ="推广员关联时间 精确匹配")
@Schema(description = "推广员关联时间 精确匹配")
private LocalDateTime spreadTime;
@Schema(description ="等级 精确匹配")
@Schema(description = "等级 精确匹配")
private Integer level;
@Schema(description ="用户剩余积分 精确匹配")
@Schema(description = "用户剩余积分 精确匹配")
private BigDecimal integral;
public QueryWrapper<Member> toWapper(){
public QueryWrapper<Member> toWapper() {
QueryWrapper<Member> qw = new QueryWrapper<>();
qw.lambda()
.like(!StringUtils.isEmpty(this.getNickname()),Member::getNickname, this.getNickname())
.eq(getId() != null,Member::getId, this.getId())
.eq(status != null,Member::getStatus,status)
.eq(!getPhone().isEmpty(), Member::getPhoneEncrypted, phone);
qw.ge(getBeginTime() != null,"create_time", this.getBeginTime());
qw.lt(getEndTime() != null,"create_time", this.getEndTime());
.like(StringUtils.isNotEmpty(this.getNickname()), Member::getNickname, this.getNickname())
.eq(getId() != null, Member::getId, this.getId())
.eq(status != null, Member::getStatus, status)
.eq(StringUtils.isNotEmpty(this.getPhone()), Member::getPhoneEncrypted, phone);
qw.ge(getBeginTime() != null, "create_time", this.getBeginTime());
qw.lt(getEndTime() != null, "create_time", this.getEndTime());
if (this.getHasMark() != null) {
switch (this.getHasMark()) {
case 0:
qw.isNull("mark").or().eq("mark","");
qw.isNull("mark").or().eq("mark", "");
break;
case 1:
qw.isNotNull("mark").ne("mark","");
qw.isNotNull("mark").ne("mark", "");
break;
default:
break;

7
ruoyi-modules/ruoyi-member/src/main/java/com/wzj/soopin/member/domain/po/Fans.java
View File

@ -7,7 +7,6 @@ import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.core.domain.model.BaseAudit;
import org.dromara.common.excel.annotation.Excel;
@TableName( "ums_fans")
@Data
@ -22,8 +21,8 @@ public class Fans extends BaseAudit {
/**
* 作家用户id
*/
@TableField( "vloger_id")
private String vlogerId;
@TableField( "vlogger_id")
private Long vloggerId;
@ -32,7 +31,7 @@ public class Fans extends BaseAudit {
* 粉丝用户id
*/
@Schema(description ="粉丝id")
private String fanId;
private Long fanId;
/**
* 粉丝是否是vloger的朋友，如果成为朋友，则本表的双方此字段都需要设置为1，如果有一人取关，则两边都需要设置为0

30
ruoyi-modules/ruoyi-member/src/main/java/com/wzj/soopin/member/domain/po/MemberBlock.java Normal file
View File

@ -0,0 +1,30 @@
package com.wzj.soopin.member.domain.po;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Builder;
import lombok.Data;
import org.dromara.common.core.domain.model.BaseAudit;
/**
* 黑名单
*
*/
@Schema(description="黑名单")
@Data
@TableName("ums_block")
@Builder(toBuilder = true)
public class MemberBlock extends BaseAudit {
@Schema(description ="ID")
@TableId
private Long id;
@Schema(description ="用户id")
private Long memberId;
@Schema(description ="被拉黑人id")
private Long blockMemberId;
}

27
ruoyi-modules/ruoyi-member/src/main/java/com/wzj/soopin/member/domain/vo/MemberBlockVO.java Normal file
View File

@ -0,0 +1,27 @@
package com.wzj.soopin.member.domain.vo;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import org.dromara.common.core.domain.model.BaseAudit;
/**
* 黑名单
*
*/
@Schema(description="黑名单")
@Data
public class MemberBlockVO extends BaseAudit {
@Schema(description ="ID")
@TableId
private Long id;
@Schema(description ="用户id")
private Long memberId;
@Schema(description ="被拉黑人id")
private Long blockMemberId;
}

4
ruoyi-modules/ruoyi-member/src/main/java/com/wzj/soopin/member/mapper/FansMapper.java
View File

@ -15,8 +15,4 @@ import java.util.Map;
public interface FansMapper extends BaseMapperPlus<Fans, FansVO> {
public List<Map<String, Object>> getFollowedVlogerIds(@Param("currentUserId")String currentUserId,@Param("vlogerIds")List<String> vlogerIds);
/**
* 根据vlogerId统计粉丝数量
*/
int countFansByVlogerId(@Param("vlogerId") String vlogerId);
}

10
ruoyi-modules/ruoyi-member/src/main/java/com/wzj/soopin/member/mapper/MemberBlockMapper.java Normal file
View File

@ -0,0 +1,10 @@
package com.wzj.soopin.member.mapper;
import com.wzj.soopin.member.domain.po.MemberBlock;
import com.wzj.soopin.member.domain.vo.MemberBlockVO;
import org.dromara.common.mybatis.core.mapper.BaseMapperPlus;
public interface MemberBlockMapper extends BaseMapperPlus<MemberBlock, MemberBlockVO> {
}

12
ruoyi-modules/ruoyi-member/src/main/java/com/wzj/soopin/member/service/IFansService.java
View File

@ -9,27 +9,27 @@ public interface IFansService {
/**
* 关注
*/
public void doFollow(String myId, String vlogerId);
public void doFollow(Long myId, Long vloggerId);
/**
* 取关
*/
public void doCancel(String myId, String vlogerId);
public void doCancel(Long myId, Long vloggerId);
/**
* 查询用户是否关注博主
*/
public boolean queryDoIFollowVloger(String myId, String vlogerId);
public boolean queryDoIFollowVloger(Long myId, Long vloggerId);
public boolean queryDoIFollowVloger(String myId, String vloggerId);
/**
* 查询我的粉丝列表
*/
public IPage<FansVO> queryMyFans(String myId,
public IPage<FansVO> queryMyFans(Long myId,
Integer page,
Integer pageSize);
Integer countFansByVlogerId(String vlogerId);
Long countFansByVloggerId(Long vloggerId);
}

15
ruoyi-modules/ruoyi-member/src/main/java/com/wzj/soopin/member/service/IMemberBlockService.java Normal file
View File

@ -0,0 +1,15 @@
package com.wzj.soopin.member.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.wzj.soopin.member.domain.po.MemberBlock;
public interface IMemberBlockService extends IService<MemberBlock> {
boolean hasBlocked(Long myId, Long vloggerId);
boolean addBlock(Long myId, Long vloggerId);
void removeBlock(Long myId, Long vloggerId);
}

34
ruoyi-modules/ruoyi-member/src/main/java/com/wzj/soopin/member/service/impl/FansServiceImpl.java
View File

@ -31,14 +31,14 @@ public class FansServiceImpl extends ServiceImpl<FansMapper, Fans> implements IF
@Transactional
@Override
public void doFollow(String myId, String vlogerId) {
public void doFollow(Long myId, Long vloggerId) {
Fans fans = new Fans();
fans.setFanId(myId);
fans.setVlogerId(vlogerId);
fans.setVloggerId(vloggerId);
// 判断对方是否关注我，如果关注我，那么双方都要互为朋友关系
Fans vloger = queryFansRelationship(vlogerId, myId);
Fans vloger = queryFansRelationship(vloggerId, myId);
if (vloger != null) {
fans.setFriendFlag(YesOrNo.YES.type);
fans.setBothFriend(YesOrNo.YES.type);
@ -57,9 +57,9 @@ public class FansServiceImpl extends ServiceImpl<FansMapper, Fans> implements IF
// rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_MSG, "sys.msg." + MessageEnum.FOLLOW_YOU.enValue, JsonUtils.objectToJson(messageMO));
}
public Fans queryFansRelationship(String fanId, String vlogerId) {
public Fans queryFansRelationship(Long fanId, Long vlogerId) {
LambdaQueryWrapper<Fans> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(Fans::getVlogerId, vlogerId)
queryWrapper.eq(Fans::getVloggerId, vlogerId)
.eq(Fans::getFanId, fanId);
return baseMapper.selectOne(queryWrapper);
@ -67,12 +67,12 @@ public class FansServiceImpl extends ServiceImpl<FansMapper, Fans> implements IF
@Transactional
@Override
public void doCancel(String myId, String vlogerId) {
public void doCancel(Long myId, Long vloggerId) {
// 判断我们是否朋友关系，如果是，则需要取消双方的关系
Fans fan = queryFansRelationship(myId, vlogerId);
Fans fan = queryFansRelationship(myId, vloggerId);
if (fan != null && fan.getFriendFlag() == YesOrNo.YES.type) {
// 抹除双方的朋友关系，自己的关系删除即可
Fans pendingFan = queryFansRelationship(vlogerId, myId);
Fans pendingFan = queryFansRelationship(vloggerId, myId);
pendingFan.setFriendFlag(YesOrNo.NO.type);
baseMapper.updateById(pendingFan);
}
@ -84,15 +84,19 @@ public class FansServiceImpl extends ServiceImpl<FansMapper, Fans> implements IF
}
@Override
public boolean queryDoIFollowVloger(String myId, String vlogerId) {
Fans vloger = queryFansRelationship(myId, vlogerId);
return vloger != null;
public boolean queryDoIFollowVloger(Long myId, Long vloggerId) {
Fans vlogger = queryFansRelationship(myId, vloggerId);
return vlogger != null;
}
@Override
public boolean queryDoIFollowVloger(String myId, String vloggerId) {
Fans vlogger = queryFansRelationship(Long.valueOf(myId), Long.valueOf(vloggerId));
return vlogger != null;
}
@Override
public IPage<FansVO> queryMyFans(String myId, Integer pageNo, Integer pageSize) {
public IPage<FansVO> queryMyFans(Long myId, Integer pageNo, Integer pageSize) {
Map<String, Object> map = new HashMap<>();
map.put("myId", myId);
// 查询粉丝列表
@ -111,7 +115,7 @@ public class FansServiceImpl extends ServiceImpl<FansMapper, Fans> implements IF
}
@Override
public Integer countFansByVlogerId(String vlogerId) {
return baseMapper.countFansByVlogerId(vlogerId);
public Long countFansByVloggerId(Long vloggerId) {
return baseMapper.selectCount(new LambdaQueryWrapper<Fans>().eq(Fans::getVloggerId, vloggerId));
}
}

56
ruoyi-modules/ruoyi-member/src/main/java/com/wzj/soopin/member/service/impl/MemberBlockServiceImpl.java Normal file
View File

@ -0,0 +1,56 @@
package com.wzj.soopin.member.service.impl;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.wzj.soopin.member.convert.FeedbackConvert;
import com.wzj.soopin.member.convert.MemberConvert;
import com.wzj.soopin.member.domain.bo.FeedbackBO;
import com.wzj.soopin.member.domain.po.Feedback;
import com.wzj.soopin.member.domain.po.Member;
import com.wzj.soopin.member.domain.po.MemberBlock;
import com.wzj.soopin.member.domain.vo.FeedbackVO;
import com.wzj.soopin.member.mapper.FeedbackMapper;
import com.wzj.soopin.member.mapper.MemberBlockMapper;
import com.wzj.soopin.member.mapper.MemberMapper;
import com.wzj.soopin.member.service.IFeedbackService;
import com.wzj.soopin.member.service.IMemberBlockService;
import com.wzj.soopin.member.util.MemberCacheHelper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* 意见反馈Service业务层处理
*
* @author zcc
*/
@Service
@Slf4j
@RequiredArgsConstructor
public class MemberBlockServiceImpl extends ServiceImpl<MemberBlockMapper, MemberBlock> implements IMemberBlockService {
@Override
public boolean hasBlocked(Long myId, Long vloggerId) {
return this.count(new UpdateWrapper<MemberBlock>()
.eq("member_id", myId)
.eq("block_member_id", vloggerId)) > 0;
}
@Override
public boolean addBlock(Long myId, Long vloggerId) {
return this.save( MemberBlock.builder().memberId(myId).blockMemberId(vloggerId).build());
}
@Override
public void removeBlock(Long myId, Long vloggerId) {
baseMapper.delete(new UpdateWrapper<MemberBlock>()
.eq("member_id", myId)
.eq("block_member_id", vloggerId));
}
}

5
ruoyi-modules/ruoyi-member/src/main/resources/ums/MemberAccountChangeRecord.xml Normal file
View File

@ -0,0 +1,5 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.wzj.soopin.member.mapper.MemberAccountChangeRecordMapper" >
</mapper>

5
ruoyi-modules/ruoyi-member/src/main/resources/ums/MemberBlockMapper.xml Normal file
View File

@ -0,0 +1,5 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.wzj.soopin.member.mapper.MemberBlockMapper" >
</mapper>