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

Merge remote-tracking branch 'origin/wzj-main' into wzj-main

Browse Source
This commit is contained in:
fxh 2025-06-10 15:40:06 +08:00
commit 8a5397e5f6
25 changed files with 381 additions and 1314 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -27,4 +27,11 @@ public interface CacheConstants {
*/
String PWD_ERR_CNT_KEY = "pwd_err_cnt:";
/**
* 用户
*/
String MEMEBER="MEMEBER:";
String MEMBER_FANS="MEMBER_FANS:";
}

89
ruoyi-common/ruoyi-common-web/src/main/java/org/dromara/common/web/core/Page.java
View File

@ -1,89 +0,0 @@
package org.dromara.common.web.core;
import cn.hutool.http.HttpStatus;
import com.baomidou.mybatisplus.core.metadata.IPage;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
/**
* 表格分页数据对象
*
* @author Lion Li
*/
@Data
@NoArgsConstructor
public class Page<T> implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 总记录数
*/
private long total;
/**
* 列表数据
*/
private List<T> rows;
/**
* 消息状态码
*/
private int code;
/**
* 消息内容
*/
private String msg;
/**
* 分页
*
* @param list 列表数据
* @param total 总记录数
*/
public Page(List<T> list, long total) {
this.rows = list;
this.total = total;
this.code = HttpStatus.HTTP_OK;
this.msg = "查询成功";
}
/**
* 根据分页对象构建表格分页数据对象
*/
public static <T> Page<T> build(IPage<T> page) {
Page<T> rspData = new Page<>();
rspData.setCode(HttpStatus.HTTP_OK);
rspData.setMsg("查询成功");
rspData.setRows(page.getRecords());
rspData.setTotal(page.getTotal());
return rspData;
}
/**
* 根据数据列表构建表格分页数据对象
*/
public static <T> Page<T> build(List<T> list) {
Page<T> rspData = new Page<>();
rspData.setCode(HttpStatus.HTTP_OK);
rspData.setMsg("查询成功");
rspData.setRows(list);
rspData.setTotal(list.size());
return rspData;
}
/**
* 构建表格分页数据对象
*/
public static <T> Page<T> build() {
Page<T> rspData = new Page<>();
rspData.setCode(HttpStatus.HTTP_OK);
rspData.setMsg("查询成功");
return rspData;
}
}

4
ruoyi-modules/ruoyi-content/pom.xml
View File

@ -140,6 +140,10 @@
<groupId>org.dromara</groupId>
<artifactId>ruoyi-common-mongo</artifactId>
</dependency>
<dependency>
<groupId>org.dromara</groupId>
<artifactId>ruoyi-member</artifactId>
</dependency>
<!-- <dependency>-->
<!-- <groupId>com.github.pagehelper</groupId>-->
<!-- <artifactId>pagehelper</artifactId>-->

297
ruoyi-modules/ruoyi-content/src/main/java/com/wzj/soopin/content/controller/FansController.java
View File

@ -1,297 +0,0 @@
package com.wzj.soopin.content.controller;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.wzj.soopin.content.domain.base.BaseInfoProperties;
import com.wzj.soopin.content.domain.po.Users;
import com.wzj.soopin.content.result.GraceJSONResult;
import com.wzj.soopin.content.result.ResponseStatusEnum;
import com.wzj.soopin.content.service.FansService;
import com.wzj.soopin.content.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Slf4j
@RequestMapping("fans")
@RestController
public class FansController extends BaseInfoProperties {
@Autowired
private UserService userService;
@Autowired
private FansService fansService;
@PostMapping("follow")
public GraceJSONResult follow(@RequestParam String myId,
@RequestParam String vlogerId) {
// 从redis中获取拉黑信息
String redisKey = 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(REDIS_MY_FOLLOWS_COUNTS + ":" + myId, 1);
redis.increment(REDIS_MY_FANS_COUNTS + ":" + vlogerId, 1);
// 我和博主的关联关系，依赖redis，不要存储数据库，避免db的性能瓶颈
redis.set(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);
// 博主的粉丝-1，我的关注-1
redis.decrement(REDIS_MY_FOLLOWS_COUNTS + ":" + myId, 1);
redis.decrement(REDIS_MY_FANS_COUNTS + ":" + vlogerId, 1);
// 我和博主的关联关系，依赖redis，不要存储数据库，避免db的性能瓶颈
redis.del(REDIS_FANS_AND_VLOGGER_RELATIONSHIP + ":" + myId + ":" + vlogerId);
return GraceJSONResult.ok();
}
@GetMapping("queryBlockVloger")
public GraceJSONResult queryBlockVloger(@RequestParam String myId,
@RequestParam String vlogerId) {
// 从redis中获取拉黑信息
String redisKey = 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(REDIS_MY_FOLLOWS_COUNTS + ":" + myId, 1);
redis.decrement(REDIS_MY_FANS_COUNTS + ":" + vlogerId, 1);
// 我和博主的关联关系，依赖redis，不要存储数据库，避免db的性能瓶颈
redis.del(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 = 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 = 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 = 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));
}
@GetMapping("queryMyFans")
public GraceJSONResult queryMyFans(@RequestParam String myId,
@RequestParam Integer page,
@RequestParam Integer pageSize) {
return GraceJSONResult.ok(
fansService.queryMyFans(
myId,
page,
pageSize));
}
}

210
ruoyi-modules/ruoyi-content/src/main/java/com/wzj/soopin/content/controller/PassportController.java
View File

@ -1,210 +0,0 @@
package com.wzj.soopin.content.controller;
import com.wzj.soopin.content.domain.base.BaseInfoProperties;
import com.wzj.soopin.content.domain.bo.LoginWithPasswordBO;
import com.wzj.soopin.content.domain.bo.RegistLoginBO;
import com.wzj.soopin.content.domain.po.Users;
import com.wzj.soopin.content.domain.vo.UsersVO;
import com.wzj.soopin.content.result.GraceJSONResult;
import com.wzj.soopin.content.result.ResponseStatusEnum;
import com.wzj.soopin.content.service.UserService;
import com.wzj.soopin.content.utils.GsonUtil;
import com.wzj.soopin.content.utils.IPUtil;
import com.wzj.soopin.content.utils.SMSUtils;
import io.swagger.annotations.Api;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.Valid;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Optional;
import java.util.UUID;
/**
* @author vercen
* @version 1.0
* @date 2023/5/25 10:47
*/
@Slf4j
@RestController
@RequestMapping("passport")
public class PassportController extends BaseInfoProperties {
@Autowired
private SMSUtils smsUtils;
@Autowired
private UserService userService;
// @Autowired
// private PasswordEncoder passwordEncoder;
@PostMapping("getSMSCode")
public Object getSMSCode(@RequestParam String mobile, HttpServletRequest request) throws Exception {
if (StringUtils.isBlank(mobile)) {
return GraceJSONResult.ok();
}
// TODO 获得用户ip 限制时间60s只能1次
String userIp = IPUtil.getRequestIp(request);
redis.setnx60s(MOBILE_SMSCODE + ":" + userIp, userIp);
String code = (int) ((Math.random() * 9 + 1) * 100000) + "";
smsUtils.sendSMS(mobile, code);
log.info(code);
redis.set(MOBILE_SMSCODE + ":" + mobile, code, 30 * 60);
// TODO 验证码放入redis
return GraceJSONResult.ok();
}
@PostMapping("login")
public Object login(@Valid @RequestBody RegistLoginBO registLoginBO) {
String rediscode = redis.get(MOBILE_SMSCODE + ":" + registLoginBO.getMobile());
if (StringUtils.isBlank(rediscode) || !rediscode.equalsIgnoreCase(registLoginBO.getSmsCode())) {
System.out.println("rediscode" + rediscode);
System.out.println("registLoginBO.getMobile()" + registLoginBO.getSmsCode());
return GraceJSONResult.errorCustom(ResponseStatusEnum.SMS_CODE_ERROR);
}
Users user = userService.queryMobileIsExist(registLoginBO.getMobile());
if (user == null) {
user = userService.createUser(registLoginBO.getMobile());
}
String uToken = UUID.randomUUID().toString();
log.info(uToken);
redis.set(REDIS_USER_TOKEN + ":" + user.getId(), uToken);
// 清除验证码
redis.del(MOBILE_SMSCODE + ":" + user.getMobile());
// 返回给前端
UsersVO usersVO = new UsersVO();
BeanUtils.copyProperties(user, usersVO);
usersVO.setUserToken(uToken);
return GraceJSONResult.ok(usersVO);
}
/**
* 从商城系统登录
*
* @param mobile
* @return
*/
@PostMapping("loginFromShop")
public String loginFromShop(String mobile, String memberId) {
// 创建短视频系统账号
return Optional.ofNullable(userService.createUserFromShop(mobile, memberId))//
.map(user -> {
String uToken = UUID.randomUUID().toString();
log.info(uToken);
redis.set(REDIS_USER_TOKEN + ":" + user.getId(), uToken);
// 返回给前端
UsersVO usersVO = new UsersVO();
BeanUtils.copyProperties(user, usersVO);
usersVO.setUserToken(uToken);
return GsonUtil.beanToJson(usersVO);
})//
.orElseGet(() -> StringUtils.EMPTY);
}
/**
* 从商城登录获取短视频账户信息
*
* @param memberId
* @return
*/
@PostMapping("getUserFromShop")
public String getUserFromShop(String memberId) {
return userService.getUserInfoFromShop(memberId);
}
/*@PostMapping("login")
public Object login(@Valid @RequestBody RegistLoginBO registLoginBO) {
String rediscode = redis.get(MOBILE_SMSCODE + ":" + registLoginBO.getMobile());
if (StringUtils.isBlank(rediscode) || !rediscode.equalsIgnoreCase(registLoginBO.getSmsCode())) {
System.out.println("rediscode" + rediscode);
System.out.println("registLoginBO.getMobile()" + registLoginBO.getSmsCode());
return GraceJSONResult.errorCustom(ResponseStatusEnum.SMS_CODE_ERROR);
}
// 手机号
String mobile = registLoginBO.getMobile();
Users user = userService.queryMobileIsExist(mobile);
Token shopToken = null;
if (user == null) {
Map<String, Object> result = userService.createUserNew(mobile);
if (CommonUtil.isEmpty(result)) {
return GraceJSONResult.errorCustom(ResponseStatusEnum.FAILED);
}
user = (Users) result.get("user");
shopToken = (Token) result.get("token");
} else {
shopToken = userService.getShopToken(user.getId());
}
String uToken = UUID.randomUUID().toString();
log.info(uToken);
redis.set(REDIS_USER_TOKEN + ":" + user.getId(), uToken);
// 清除验证码
redis.del(MOBILE_SMSCODE + ":" + user.getMobile());
// 返回给前端
UsersVO usersVO = new UsersVO();
BeanUtils.copyProperties(user, usersVO);
usersVO.setUserToken(uToken);
//usersVO.setShopToken(shopToken);
return GraceJSONResult.ok(usersVO);
}*/
@PostMapping("loginWithPassword")
public Object loginWithPassword(@Valid @RequestBody LoginWithPasswordBO loginWithPasswordBO) {
String phone = loginWithPasswordBO.getMobile();
String password = loginWithPasswordBO.getPassword();
log.info(phone);
log.info(password);
Users user = userService.queryMobileIsExist(phone);
if (user == null) {
return GraceJSONResult.errorCustom(ResponseStatusEnum.USER_NOT_EXIST_ERROR);
}
// if (!passwordEncoder.matches(password, user.getPassword())) {
// return GraceJSONResult.errorCustom(ResponseStatusEnum.USER_PASSWORD_ERROR);
// }
String uToken = UUID.randomUUID().toString();
log.info(uToken);
redis.set(REDIS_USER_TOKEN + ":" + user.getId(), uToken);
// 商城token
// Token shopToken = userService.getShopToken(user.getId());
// 返回给前端
UsersVO usersVO = new UsersVO();
BeanUtils.copyProperties(user, usersVO);
usersVO.setUserToken(uToken);
// usersVO.setShopToken(shopToken);
return GraceJSONResult.ok(usersVO);
}
@PostMapping("logout")
public Object logout(@RequestParam String userId) {
redis.del(REDIS_USER_TOKEN + ":" + userId);
return GraceJSONResult.ok();
}
}

145
ruoyi-modules/ruoyi-content/src/main/java/com/wzj/soopin/content/controller/UserInfoController.java
View File

@ -1,145 +0,0 @@
package com.wzj.soopin.content.controller;
import com.wzj.soopin.content.domain.base.BaseInfoProperties;
import com.wzj.soopin.content.domain.bo.UpdatedUserBO;
import com.wzj.soopin.content.domain.po.Users;
import com.wzj.soopin.content.domain.vo.UsersVO;
import com.wzj.soopin.content.enums.FileTypeEnum;
import com.wzj.soopin.content.enums.UserInfoModifyType;
import com.wzj.soopin.content.result.GraceJSONResult;
import com.wzj.soopin.content.result.ResponseStatusEnum;
import com.wzj.soopin.content.service.UserService;
import com.wzj.soopin.content.utils.MinIOUtils;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
/**
* @author vercen
* @version 1.0
* @date 2023/5/20 14:32
*/
@RestController
@Slf4j
@RequestMapping("userInfo")
public class UserInfoController extends BaseInfoProperties {
@Autowired
UserService userService;
// @ResponseBody
@ApiOperation(value = "根据userId返回个人信息")
@GetMapping("query")
public Object query(@RequestParam String userId){
Users user = userService.getUser(userId);
UsersVO usersVO = new UsersVO();
BeanUtils.copyProperties(user, usersVO);
// 我的关注博主总数量
String myFollowsCountsStr = redis.get(REDIS_MY_FOLLOWS_COUNTS + ":" + userId);
// 我的粉丝总数
String myFansCountsStr = redis.get(REDIS_MY_FANS_COUNTS + ":" + userId);
// 用户获赞总数，视频博主（点赞/喜欢）总和
// String likedVlogCountsStr = redis.get(REDIS_VLOG_BE_LIKED_COUNTS + ":" + userId);
String likedVlogerCountsStr = redis.get(REDIS_VLOGER_BE_LIKED_COUNTS + ":" + userId);
Integer myFollowsCounts = 0;
Integer myFansCounts = 0;
Integer likedVlogCounts = 0;
Integer likedVlogerCounts = 0;
Integer totalLikeMeCounts = 0;
if (StringUtils.isNotBlank(myFollowsCountsStr)) {
myFollowsCounts = Integer.valueOf(myFollowsCountsStr);
}
if (StringUtils.isNotBlank(myFansCountsStr)) {
myFansCounts = Integer.valueOf(myFansCountsStr);
}
// if (StringUtils.isNotBlank(likedVlogCountsStr)) {
// likedVlogCounts = Integer.valueOf(likedVlogCountsStr);
// }
if (StringUtils.isNotBlank(likedVlogerCountsStr)) {
likedVlogerCounts = Integer.valueOf(likedVlogerCountsStr);
}
totalLikeMeCounts = likedVlogCounts + likedVlogerCounts;
usersVO.setMyFollowsCounts(myFollowsCounts);
usersVO.setMyFansCounts(myFansCounts);
usersVO.setTotalLikeMeCounts(totalLikeMeCounts);
//usersVO.setMyFansCounts((Integer) myFansCounts);
return GraceJSONResult.ok(usersVO);
}
@PostMapping("modifyUserInfo")
public GraceJSONResult modifyUserInfo(@RequestBody UpdatedUserBO updatedUserBO, @RequestParam Integer type) throws Exception {
UserInfoModifyType.checkUserInfoTypeIsRight(type);
Users newUserInfo = userService.updateUserInfo(updatedUserBO, type);
return GraceJSONResult.ok(newUserInfo);
}
@PostMapping("modifyImage")
public GraceJSONResult modifyImage(@RequestParam String userId,
@RequestParam Integer type,
MultipartFile file) throws Exception {
if (type != FileTypeEnum.BGIMG.type && type != FileTypeEnum.FACE.type) {
return GraceJSONResult.errorCustom(ResponseStatusEnum.FILE_UPLOAD_FAILD);
}
String fileName = file.getOriginalFilename();
// MinIOUtils.uploadFile(minIOConfig.getBucketName(),
// fileName,
// file.getInputStream());
//
// String imgUrl = minIOConfig.getFileHost()
// + "/"
// + minIOConfig.getBucketName()
// + "/"
// + fileName;
// 修改图片地址到数据库
UpdatedUserBO updatedUserBO = new UpdatedUserBO();
updatedUserBO.setId(userId);
// if (type == FileTypeEnum.BGIMG.type) {
// updatedUserBO.setBgImg(imgUrl);
// } else {
// updatedUserBO.setFace(imgUrl);
// }
Users users = userService.updateUserInfo(updatedUserBO);
return GraceJSONResult.ok(users);
}
@ApiOperation(value = "根据昵称搜索用户")
@GetMapping("searchByNickname")
public GraceJSONResult searchByNickname(@RequestParam String nickname,
@RequestParam(defaultValue = "") String id,
@RequestParam Integer page,
@RequestParam Integer pageSize){
try {
return GraceJSONResult.ok(userService.searchByNickname(nickname, page, pageSize,id));
} catch (Exception e) {
// 记录异常日志
log.error("搜索用户时发生异常，nickname: {}, page: {}, pageSize: {}", nickname, page, pageSize, e);
return GraceJSONResult.errorMsg("搜索用户时发生异常，请稍后重试");
}
}
}

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

@ -1,14 +1,17 @@
package com.wzj.soopin.content.controller.admin;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.tencentcloudapi.vod.v20180717.models.*;
import com.wzj.soopin.content.domain.base.BaseInfoProperties;
import com.wzj.soopin.content.mapper.FansMapper;
import com.wzj.soopin.content.mapper.FansMapperCustom;
import com.wzj.soopin.content.mapper.MyLikedVlogMapper;
import com.wzj.soopin.content.result.GraceJSONResult;
import com.wzj.soopin.content.service.VlogUploadService;
import com.wzj.soopin.content.utils.RedisOperator;
import com.wzj.soopin.content.utils.TencentCloudUtil;
import com.wzj.soopin.member.domain.vo.FansVO;
import com.wzj.soopin.member.mapper.FansMapper;
import com.wzj.soopin.member.service.IFansService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
@ -23,8 +26,6 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.tencentcloudapi.common.exception.TencentCloudSDKException;
@Slf4j
@Api(tags = "管理端-视频上传接口")
@RequestMapping("admin/vlog/upload")
@ -50,10 +51,9 @@ public class VlogUploadController extends BaseInfoProperties {
private MyLikedVlogMapper myLikedVlogMapper;
@Autowired
private FansMapper fansMapper;
private IFansService fansService;
@Autowired
private FansMapperCustom fansMapperCustom;
@ApiOperation("获取腾讯云点播视频列表")
@GetMapping("/list")
@ -180,7 +180,7 @@ public class VlogUploadController extends BaseInfoProperties {
fansCounts = Integer.valueOf(fansCountsStr);
} else {
// Redis 中没有，从数据库查询
fansCounts = fansMapper.countFansByVlogerId(vlog.getVlogerId());
fansCounts = fansService.countFansByVlogerId(vlog.getVlogerId());
// 可以选择在这里将数据库查询结果写入 Redis，以便下次使用
if (fansCounts != null) {
redis.set(REDIS_MY_FANS_COUNTS + ":" + vlog.getVlogerId(), String.valueOf(fansCounts));
@ -267,10 +267,8 @@ public class VlogUploadController extends BaseInfoProperties {
List<Map<String, Object>> likedUsers = myLikedVlogMapper.selectLikedUsersByVlogId(vlog.getId());
result.put("likedUsers", likedUsers);
// 查询粉丝列表
Map<String, Object> fansQueryMap = new HashMap<>();
fansQueryMap.put("myId", vlog.getVlogerId());
List<com.wzj.soopin.content.domain.vo.FansVO> fansList = fansMapperCustom.queryMyFans(fansQueryMap);
IPage<FansVO> fansList = fansService.queryMyFans(vlog.getVlogerId(),0,10);
result.put("fansList", fansList);
} else {

21
ruoyi-modules/ruoyi-content/src/main/java/com/wzj/soopin/content/mapper/FansMapperCustom.java
View File

@ -1,21 +0,0 @@
package com.wzj.soopin.content.mapper;
import com.wzj.soopin.content.domain.po.Fans;
import com.wzj.soopin.content.domain.po.Vlog;
import com.wzj.soopin.content.domain.vo.FansVO;
import com.wzj.soopin.content.domain.vo.VlogerVO;
import org.apache.ibatis.annotations.Param;
import org.dromara.common.mybatis.core.mapper.BaseMapperPlus;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Map;
@Repository
public interface FansMapperCustom extends BaseMapperPlus<Vlog, VlogerVO> {
public List<VlogerVO> queryMyFollows(@Param("paramMap") Map<String, Object> map);
public List<FansVO> queryMyFans(@Param("paramMap") Map<String, Object> map);
}

41
ruoyi-modules/ruoyi-content/src/main/java/com/wzj/soopin/content/mapper/UsersMapper.java
View File

@ -1,41 +0,0 @@
package com.wzj.soopin.content.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.wzj.soopin.content.domain.bo.UpdatedUserBO;
import com.wzj.soopin.content.domain.po.Users;
import com.wzj.soopin.content.domain.vo.UsersVO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import org.apache.ibatis.annotations.Param;
import org.dromara.common.mybatis.core.mapper.BaseMapperPlus;
import java.util.List;
@Mapper
public interface UsersMapper extends BaseMapper<Users> {
@Select("SELECT * FROM t_users WHERE nickname LIKE CONCAT('%', #{nickname}, '%')")
List<UsersVO> searchByNickname(String nickname);
@Update("UPDATE t_users SET nickname = #{nickname} WHERE id = #{id}")
int updateNickname(UpdatedUserBO user);
@Update("UPDATE t_users SET sex = #{sex} WHERE id = #{id}")
int updateSex(UpdatedUserBO user);
@Update("UPDATE t_users SET birthday = #{birthday} WHERE id = #{id}")
int updateBirthday(UpdatedUserBO user);
@Update("UPDATE t_users SET description = #{description} WHERE id = #{id}")
int updateDescription(UpdatedUserBO user);
@Update("UPDATE t_users SET province = #{province},city = #{city},district = #{district} WHERE id = #{id}")
int updateLocation(UpdatedUserBO user);
@Update("UPDATE t_users SET imooc_num = #{imoocNum},can_imooc_num_be_updated = 0 WHERE id = #{id}")
int updateVnum(UpdatedUserBO user);
@Select("SELECT * FROM t_users WHERE imooc_num = #{imoocNum}")
List<UsersVO> selectByImoocNum(@Param("imoocNum") String imoocNum);
Users selectByPrimaryKey(String userId);
void updateByPrimaryKeySelective(Users users);
int inset(Users user);
}

82
ruoyi-modules/ruoyi-content/src/main/java/com/wzj/soopin/content/service/UserService.java
View File

@ -1,82 +0,0 @@
package com.wzj.soopin.content.service;
import com.wzj.soopin.content.domain.bo.UpdatedUserBO;
import com.wzj.soopin.content.domain.mo.Token;
import com.wzj.soopin.content.domain.po.Users;
import com.wzj.soopin.content.domain.vo.UsersVO;
import java.util.List;
import java.util.Map;
/**
* @author vercen
* @version 1.0
* @date 2023/5/25 21:02
*/
public interface UserService {
/**
* 判断用户是否存在，如果存在则返回用户信息
*/
public Users queryMobileIsExist(String mobile);
/**
* 创建用户信息，并且返回用户对象
*/
public Users createUser(String mobile);
/**
* 根据用户主键查询用户信息
*/
public Users getUser(String userId);
/**
* 用户信息修改
*/
public Users updateUserInfo(UpdatedUserBO updatedUserBO);
/**
* 用户信息修改
*/
public Users updateUserInfo(UpdatedUserBO updatedUserBO, Integer type);
/**
* 创建用户打通短视频和商城系统
*
* @param mobile
* @return
*/
Map<String, Object> createUserNew(String mobile);
/**
* 获取商城token
*
* @param userId
* @return
*/
Token getShopToken(String userId);
/**
* 从商城系统创建账号
*
* @param mobile
* @return
*/
Users createUserFromShop(String mobile, String memberId);
/**
* 从商城系统获取短视频账户信息
* @param memberId
* @return
*/
String getUserInfoFromShop(String memberId);
/**
* 根据昵称搜索用户
* @param nickname
* @param page
* @param pageSize
* @return
*/
List<UsersVO> searchByNickname(String nickname, Integer page, Integer pageSize, String id);
}

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

@ -7,7 +7,10 @@ import com.wzj.soopin.content.domain.po.Users;
import com.wzj.soopin.content.enums.MessageEnum;
import com.wzj.soopin.content.mapper.repository.MessageRepository;
import com.wzj.soopin.content.service.MsgService;
import com.wzj.soopin.content.service.UserService;
import com.wzj.soopin.member.domain.po.Member;
import com.wzj.soopin.member.mapper.MemberMapper;
import com.wzj.soopin.member.service.IMemberService;
import lombok.RequiredArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
@ -21,13 +24,13 @@ import java.util.List;
import java.util.Map;
@Service
@RequiredArgsConstructor
public class MsgServiceImpl extends BaseInfoProperties implements MsgService {
@Autowired
private MessageRepository messageRepository;
@Autowired
private UserService userService;
private final MemberMapper memberMapper;
@Override
public void createMsg(String fromUserId,
@ -35,13 +38,13 @@ public class MsgServiceImpl extends BaseInfoProperties implements MsgService {
Integer type,
Map msgContent) {
Users fromUser = userService.getUser(fromUserId);
Member fromUser = memberMapper.selectById(fromUserId);
MessageMO messageMO = new MessageMO();
messageMO.setFromUserId(fromUserId);
messageMO.setFromNickname(fromUser.getNickname());
messageMO.setFromFace(fromUser.getFace());
messageMO.setFromFace(fromUser.getAvatar());
messageMO.setToUserId(toUserId);

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

@ -1,320 +0,0 @@
package com.wzj.soopin.content.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.google.common.collect.Maps;
import com.wzj.soopin.content.domain.base.BaseInfoProperties;
import com.wzj.soopin.content.domain.bo.UpdatedUserBO;
import com.wzj.soopin.content.domain.exceptions.GraceException;
import com.wzj.soopin.content.domain.mo.Token;
import com.wzj.soopin.content.domain.po.Fans;
import com.wzj.soopin.content.domain.po.UserMember;
import com.wzj.soopin.content.domain.po.Users;
import com.wzj.soopin.content.domain.result.ResponseStatusEnum;
import com.wzj.soopin.content.domain.vo.UsersVO;
import com.wzj.soopin.content.enums.Sex;
import com.wzj.soopin.content.enums.UserInfoModifyType;
import com.wzj.soopin.content.enums.YesOrNo;
import com.wzj.soopin.content.mapper.FansMapper;
import com.wzj.soopin.content.mapper.FansMapperCustom;
import com.wzj.soopin.content.mapper.UserMemberMapper;
import com.wzj.soopin.content.mapper.UsersMapper;
import com.wzj.soopin.content.service.FansService;
import com.wzj.soopin.content.service.UserService;
import com.wzj.soopin.content.utils.*;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author vercen
* @version 1.0
* @date 2023/5/25 21:02
*/
@Slf4j
@Service
public class UserServiceImpl extends BaseInfoProperties implements UserService {
@Autowired
private UsersMapper usersMapper;
@Autowired
private FansMapperCustom fansMapperCustom;
@Autowired
private UserMemberMapper userMemberMapper;
@Autowired
private FansMapper fansMapper;
//@Autowired
//public RedisOperator redis;
@Resource(name = "redisTemplate")
private RedisTemplate<String, Object> redisTemplate;
@Autowired
private Sid sid;
private static final String USER_FACE1 = "http://43.143.227.203:29000/bucket/logo.png";
@Override
public Users queryMobileIsExist(String mobile) {
LambdaQueryWrapper<Users> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(Users::getMobile, mobile);
return usersMapper.selectOne(queryWrapper);
}
@Override
public Users createUser(String mobile) {
String userId = sid.nextShort();
Users user = new Users();
user.setId(userId);
user.setPassword(mobile);
user.setMobile(mobile);
user.setNickname("用户：" + DesensitizationUtil.commonDisplay(mobile));
user.setImoocNum("用户：" + DesensitizationUtil.commonDisplay(mobile));
user.setFace(USER_FACE1);
user.setBirthday(DateUtil.stringToDate("1999-01-01"));
user.setSex(Sex.secret.type);
user.setBgImg(USER_FACE1);
user.setCountry("中国");
user.setProvince("");
user.setCity("");
user.setDistrict("");
user.setDescription("这家伙很懒，什么都没留下~");
user.setCanImoocNumBeUpdated(YesOrNo.YES.type);
usersMapper.insert(user);
return user;
}
@Override
public Users getUser(String userId) {
return usersMapper.selectById(userId);
}
@Transactional
@Override
public Users updateUserInfo(UpdatedUserBO updatedUserBO) {
Users users = new Users();
BeanUtils.copyProperties(updatedUserBO, users);
usersMapper.updateById(users);
return getUser(updatedUserBO.getId());
}
@Transactional
@Override
public Users updateUserInfo(UpdatedUserBO updatedUserBO, Integer type) {
LambdaUpdateWrapper<Users> updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.eq(Users::getId, updatedUserBO.getId());
UserInfoModifyType modifyType = UserInfoModifyType.getTypeByValue(type);
switch (modifyType) {
case NICKNAME:
updateWrapper.set(Users::getNickname, updatedUserBO.getNickname());
break;
case SEX:
updateWrapper.set(Users::getSex, updatedUserBO.getSex());
break;
case BIRTHDAY:
updateWrapper.set(Users::getBirthday, updatedUserBO.getBirthday());
break;
case LOCATION:
updateWrapper.set(Users::getCountry, updatedUserBO.getCountry())
.set(Users::getProvince, updatedUserBO.getProvince())
.set(Users::getCity, updatedUserBO.getCity())
.set(Users::getDistrict, updatedUserBO.getDistrict());
break;
case DESC:
updateWrapper.set(Users::getDescription, updatedUserBO.getDescription());
break;
case IMOOCNUM:
if (updatedUserBO.getCanImoocNumBeUpdated() == YesOrNo.NO.type) {
GraceException.display(ResponseStatusEnum.USER_INFO_CANT_UPDATED_IMOOCNUM_ERROR);
}
// 校验唯一性
LambdaQueryWrapper<Users> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(Users::getImoocNum, updatedUserBO.getImoocNum());
if (usersMapper.selectCount(queryWrapper) > 0) {
GraceException.display(ResponseStatusEnum.USER_INFO_UPDATED_IMOOCNUM_EXIST_ERROR);
}
updateWrapper.set(Users::getImoocNum, updatedUserBO.getImoocNum());
break;
default:
break;
}
usersMapper.update(null, updateWrapper);
return getUser(updatedUserBO.getId());
}
@Transactional(rollbackFor = RuntimeException.class)
@Override
public Map<String, Object> createUserNew(String mobile) {
String userId = sid.nextShort();
Users user = new Users();
user.setId(userId);
// user.setPassword(passwordEncoder.encode(mobile));
user.setMobile(mobile);
user.setNickname("用户：" + DesensitizationUtil.commonDisplay(mobile));
user.setImoocNum("用户：" + DesensitizationUtil.commonDisplay(mobile));
user.setFace(USER_FACE1);
user.setBirthday(DateUtil.stringToDate("1999-01-01"));
user.setSex(Sex.secret.type);
user.setBgImg(USER_FACE1);
user.setCountry("中国");
user.setProvince("");
user.setCity("");
user.setDistrict("");
user.setDescription("这家伙很懒，什么都没留下~");
user.setBgImg("");
user.setCanImoocNumBeUpdated(YesOrNo.YES.type);
int row = usersMapper.insert(user);
if (row > 0) {
Map<String, Object> result = Maps.newHashMap();
result.put("user", user);
String url = "http://localhost:8888/buyer/passport/member/registerFromTik";
MultiValueMap<String, Object> param = new LinkedMultiValueMap<>();
param.add("userName", mobile);
param.add("password", mobile);
param.add("mobilePhone", mobile);
param.add("userId", user.getId());
RestTemplateUtil.post(null, null, null, url, param, String.class, t -> {
if (t.getStatusCode() == HttpStatus.OK) {
String content = t.getBody();
if (StringUtils.isNotBlank(content)) {
Token token = GsonUtil.jsonToBean(content, Token.class);
result.put("token", token);
} else {
throw new RuntimeException("账号注册异常");
}
} else {
throw new RuntimeException("账号注册异常");
}
});
return result;
}
return null;
}
@Override
public Token getShopToken(String userId) {
Token[] tokens = { null };
String url = "http://localhost:8888/buyer/passport/member/getTokenFromTik";
MultiValueMap<String, Object> param = new LinkedMultiValueMap<>();
param.add("userId", userId);
RestTemplateUtil.post(null, null, null, url, param, String.class, t -> {
if (t.getStatusCode() == HttpStatus.OK) {
String content = t.getBody();
if (StringUtils.isNotBlank(content)) {
tokens[0] = GsonUtil.jsonToBean(content, Token.class);
} else {
throw new RuntimeException("账号注册异常");
}
} else {
throw new RuntimeException("账号注册异常");
}
});
return tokens[0];
}
@Transactional(rollbackFor = RuntimeException.class)
@Override
public Users createUserFromShop(String mobile, String memberId) {
String tempMobile = StringUtils.isBlank(mobile) ? "unionID" : mobile;
// 获得全局唯一主键
String userId = sid.nextShort();
Users user = new Users();
user.setId(userId);
user.setPassword(tempMobile);
user.setMobile(tempMobile);
user.setNickname("用户：" + DesensitizationUtil.commonDisplay(tempMobile));
user.setImoocNum("WZJ" + (System.currentTimeMillis() / 1000) + (int)(Math.random() * 1000));
user.setFace(USER_FACE1);
user.setBirthday(DateUtil.stringToDate("1999-01-01"));
user.setSex(Sex.secret.type);
user.setBgImg("https://wuzhongjie.com.cn/download/logo.png"); // 测试用地址
user.setCountry("中国");
user.setProvince("");
user.setCity("");
user.setDistrict("");
user.setDescription("这家伙很懒，什么都没留下~");
user.setCanImoocNumBeUpdated(YesOrNo.YES.type);
// user.setCreatedTime(new Date());
// user.setUpdatedTime(new Date());
// 短视频用户与商城账号关系
UserMember userMember = new UserMember();
userMember.setUserId(user.getId());
userMember.setMemberId(memberId);
if (usersMapper.insert(user) > 0 && userMemberMapper.insert(userMember) > 0) {
return user;
}
return null;
}
@Override
public String getUserInfoFromShop(String memberId) {
return Optional.ofNullable(userMemberMapper.getUserByMemberId(memberId))//
.map(user -> {
String uToken = UUID.randomUUID().toString();
//redis.set(REDIS_USER_TOKEN + ":" + user.getId(), uToken);
redisTemplate.opsForValue().set(REDIS_USER_TOKEN + ":" + user.getId(), uToken);
// 返回给前端
UsersVO usersVO = new UsersVO();
BeanUtils.copyProperties(user, usersVO);
usersVO.setUserToken(uToken);
return GsonUtil.beanToJson(usersVO);
})//
.orElseGet(() -> StringUtils.EMPTY);
}
@Override
public List<UsersVO> searchByNickname(String nickname, Integer page, Integer pageSize, String currentUserId) {
Page<Users> pageParam = new Page<>(page, pageSize);
LambdaQueryWrapper<Users> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(Users::getNickname, nickname);
Page<Users> usersPage = usersMapper.selectPage(pageParam, queryWrapper);
List<Users> usersList = usersPage.getRecords();
List<UsersVO> usersVOList = usersList.stream().map(u -> {
UsersVO userVO = new UsersVO();
BeanUtils.copyProperties(u, userVO);
// 查询当前用户是否关注了该用户
LambdaQueryWrapper<Fans> fansWrapper = new LambdaQueryWrapper<>();
fansWrapper.eq(Fans::getVlogerId, u.getId())
.eq(Fans::getFanId, currentUserId);
Fans fans= fansMapper.selectOne(fansWrapper);
if(fans!=null) {
userVO.setFollowed(true);
}
return userVO;
}).collect(Collectors.toList());
return usersVOList;
}
}

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

@ -15,11 +15,11 @@ import com.wzj.soopin.content.enums.YesOrNo;
import com.wzj.soopin.content.mapper.MyLikedVlogMapper;
import com.wzj.soopin.content.mapper.VlogMapper;
import com.wzj.soopin.content.mapper.VlogMapperCustom;
import com.wzj.soopin.content.service.FansService;
import com.wzj.soopin.content.service.MsgService;
import com.wzj.soopin.content.service.VlogService;
import com.wzj.soopin.content.utils.PagedGridResult;
import com.wzj.soopin.content.utils.Sid;
import com.wzj.soopin.member.service.IFansService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
@ -39,7 +39,7 @@ public class VlogServiceImpl extends BaseInfoProperties implements VlogService {
@Autowired
private MyLikedVlogMapper myLikedVlogMapper;
@Autowired
private FansService fansService;
private IFansService fansService;
@Autowired
private MsgService msgService;
@Autowired

2
ruoyi-modules/ruoyi-content/src/main/resources/mapper/content/FansMapperCustom.xml
View File

@ -24,7 +24,7 @@
</select>
<select id="queryMyFans" resultType="com.wzj.soopin.content.domain.vo.FansVO" parameterType="map">
<select id="queryMyFans" resultType="com.wzj.soopin.member.domain.vo.FansVO" parameterType="map">
SELECT
u.id as fanId,

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

@ -0,0 +1,282 @@
package com.wzj.soopin.member.controller;
import com.wzj.soopin.member.service.IFansService;
import com.wzj.soopin.member.service.IMemberService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@Slf4j
@RequestMapping("/ums/fans")
@RestController
@RequiredArgsConstructor
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);
////
//// // 博主的粉丝-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));
// }
//
// @GetMapping("queryMyFans")
// public GraceJSONResult queryMyFans(@RequestParam String myId,
// @RequestParam Integer page,
// @RequestParam Integer pageSize) {
// return GraceJSONResult.ok(
// fansService.queryMyFans(
// myId,
// page,
// pageSize));
// }
}

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

@ -1,8 +1,9 @@
package com.wzj.soopin.content.domain.po;
package com.wzj.soopin.member.domain.po;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.core.domain.model.BaseAudit;
@ -10,12 +11,14 @@ import org.dromara.common.tenant.core.TenantEntity;
import java.util.Date;
@TableName( "t_fans")
@TableName( "ums_fans")
@Data
@EqualsAndHashCode(callSuper = true)
public class Fans extends BaseAudit {
@TableId
private String id;
@ApiModelProperty("ID")
private Long id;
/**
* 作家用户id
@ -23,7 +26,7 @@ public class Fans extends BaseAudit {
@TableField( "vloger_id")
private String vlogerId;
private Date createdTime;
/**

2
ruoyi-modules/ruoyi-content/src/main/java/com/wzj/soopin/content/domain/vo/FansVO.java → ruoyi-modules/ruoyi-member/src/main/java/com/wzj/soopin/member/domain/vo/FansVO.java
View File

@ -1,4 +1,4 @@
package com.wzj.soopin.content.domain.vo;
package com.wzj.soopin.member.domain.vo;
import lombok.AllArgsConstructor;
import lombok.Data;

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

@ -1,9 +1,8 @@
package com.wzj.soopin.content.mapper;
package com.wzj.soopin.member.mapper;
import com.wzj.soopin.content.domain.po.Fans;
import com.wzj.soopin.content.domain.po.Vlog;
import com.wzj.soopin.content.domain.vo.FansVO;
import com.wzj.soopin.content.domain.vo.VlogerVO;
import com.wzj.soopin.member.domain.po.Fans;
import com.wzj.soopin.member.domain.vo.FansVO;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.dromara.common.mybatis.core.mapper.BaseMapperPlus;

20
ruoyi-modules/ruoyi-content/src/main/java/com/wzj/soopin/content/service/FansService.java → ruoyi-modules/ruoyi-member/src/main/java/com/wzj/soopin/member/service/IFansService.java
View File

@ -1,8 +1,10 @@
package com.wzj.soopin.content.service;
package com.wzj.soopin.member.service;
import com.wzj.soopin.content.utils.PagedGridResult;
public interface FansService {
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.wzj.soopin.member.domain.vo.FansVO;
public interface IFansService {
/**
* 关注
@ -19,17 +21,15 @@ public interface FansService {
*/
public boolean queryDoIFollowVloger(String myId, String vlogerId);
/**
* 查询我关注的博主列表
*/
public PagedGridResult queryMyFollows(String myId,
Integer page,
Integer pageSize);
/**
* 查询我的粉丝列表
*/
public PagedGridResult queryMyFans(String myId,
public IPage<FansVO> queryMyFans(String myId,
Integer page,
Integer pageSize);
Integer countFansByVlogerId(String vlogerId);
}

0
ruoyi-modules/ruoyi-member/src/main/java/com/wzj/soopin/member/service/impl/IMemberLoginInfoService.java → ruoyi-modules/ruoyi-member/src/main/java/com/wzj/soopin/member/service/IMemberLoginInfoService.java
View File

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

@ -1,53 +1,39 @@
package com.wzj.soopin.content.service.impl;
package com.wzj.soopin.member.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.wzj.soopin.content.domain.base.BaseInfoProperties;
import com.wzj.soopin.content.domain.base.RabbitMQConfig;
import com.wzj.soopin.content.domain.mo.MessageMO;
import com.wzj.soopin.content.domain.po.Fans;
import com.wzj.soopin.content.domain.vo.FansVO;
import com.wzj.soopin.content.domain.vo.VlogerVO;
import com.wzj.soopin.content.enums.MessageEnum;
import com.wzj.soopin.content.mapper.FansMapper;
import com.wzj.soopin.content.mapper.FansMapperCustom;
import com.wzj.soopin.content.service.FansService;
import com.wzj.soopin.content.service.MsgService;
import com.wzj.soopin.content.utils.JsonUtils;
import com.wzj.soopin.content.utils.PagedGridResult;
import com.wzj.soopin.content.utils.Sid;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.wzj.soopin.member.domain.po.Fans;
import com.wzj.soopin.member.domain.vo.FansVO;
import com.wzj.soopin.member.mapper.FansMapper;
import com.wzj.soopin.member.service.IFansService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.dromara.common.core.constant.CacheConstants;
import org.dromara.common.core.enums.YesOrNo;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.dromara.common.core.utils.StringUtils;
import org.dromara.common.redis.config.RedisConfig;
import org.dromara.common.redis.redis.RedisCache;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Service
@Slf4j
@RequiredArgsConstructor
public class FansServiceImpl extends BaseInfoProperties implements FansService {
public class FansServiceImpl extends ServiceImpl<FansMapper, Fans> implements IFansService {
private final FansMapper fansMapper;
private final FansMapperCustom fansMapperCustom;
private final MsgService msgService;
private final RabbitTemplate rabbitTemplate;
@Autowired
private Sid sid;
private final RedisCache redisCache;
@Transactional
@Override
public void doFollow(String myId, String vlogerId) {
String fid = sid.nextShort();
Fans fans = new Fans();
fans.setId(fid);
fans.setFanId(myId);
fans.setVlogerId(vlogerId);
@ -56,17 +42,17 @@ public class FansServiceImpl extends BaseInfoProperties implements FansService {
if (vloger != null) {
fans.setIsFanFriendOfMine(YesOrNo.YES.type);
vloger.setIsFanFriendOfMine(YesOrNo.YES.type);
fansMapper.updateById(vloger);
baseMapper.updateById(vloger);
} else {
fans.setIsFanFriendOfMine(YesOrNo.NO.type);
}
fansMapper.insert(fans);
baseMapper.insert(fans);
// 系统消息：关注
MessageMO messageMO = new MessageMO();
messageMO.setFromUserId(myId);
messageMO.setToUserId(vlogerId);
rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_MSG, "sys.msg." + MessageEnum.FOLLOW_YOU.enValue, JsonUtils.objectToJson(messageMO));
// MessageMO messageMO = new MessageMO();
// messageMO.setFromUserId(myId);
// messageMO.setToUserId(vlogerId);
// rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_MSG, "sys.msg." + MessageEnum.FOLLOW_YOU.enValue, JsonUtils.objectToJson(messageMO));
}
public Fans queryFansRelationship(String fanId, String vlogerId) {
@ -74,7 +60,7 @@ public class FansServiceImpl extends BaseInfoProperties implements FansService {
queryWrapper.eq(Fans::getVlogerId, vlogerId)
.eq(Fans::getFanId, fanId);
return fansMapper.selectOne(queryWrapper);
return baseMapper.selectOne(queryWrapper);
}
@Transactional
@ -86,13 +72,13 @@ public class FansServiceImpl extends BaseInfoProperties implements FansService {
// 抹除双方的朋友关系，自己的关系删除即可
Fans pendingFan = queryFansRelationship(vlogerId, myId);
pendingFan.setIsFanFriendOfMine(YesOrNo.NO.type);
fansMapper.updateById(pendingFan);
baseMapper.updateById(pendingFan);
}
// 删除自己的关注关联表记录
LambdaQueryWrapper<Fans> deleteWrapper = new LambdaQueryWrapper<>();
deleteWrapper.eq(Fans::getId, fan.getId());
fansMapper.delete(deleteWrapper);
baseMapper.delete(deleteWrapper);
}
@Override
@ -101,27 +87,19 @@ public class FansServiceImpl extends BaseInfoProperties implements FansService {
return vloger != null;
}
@Override
public PagedGridResult queryMyFollows(String myId, Integer page, Integer pageSize) {
Map<String, Object> map = new HashMap<>();
map.put("myId", myId);
Page<VlogerVO> pageParam = new Page<>(page, pageSize);
List<VlogerVO> list = fansMapperCustom.queryMyFollows(map);
return null;
}
@Override
public PagedGridResult queryMyFans(String myId, Integer page, Integer pageSize) {
public IPage<FansVO> queryMyFans(String myId, Integer pageNo, Integer pageSize) {
Map<String, Object> map = new HashMap<>();
map.put("myId", myId);
Page<FansVO> pageParam = new Page<>(page, pageSize);
List<FansVO> list = fansMapperCustom.queryMyFans(map);
for (FansVO f : list) {
String relationship = redis.get(REDIS_FANS_AND_VLOGGER_RELATIONSHIP + ":" + myId + ":" + f.getFanId());
// 查询粉丝列表
Page<FansVO> page=new Page<>();
page.setCurrent(pageNo);
page.setSize(pageSize);
for (FansVO f : page.getRecords()) {
String relationship = redisCache.getCacheObject(
CacheConstants.MEMBER_FANS + ":" + myId + ":" + f.getFanId());
if (StringUtils.isNotBlank(relationship) && relationship.equalsIgnoreCase("1")) {
f.setFriend(true);
}
@ -129,4 +107,9 @@ public class FansServiceImpl extends BaseInfoProperties implements FansService {
return null;
}
@Override
public Integer countFansByVlogerId(String vlogerId) {
return baseMapper.countFansByVlogerId(vlogerId);
}
}

4
ruoyi-modules/ruoyi-content/src/main/resources/mapper/content/FansMapper.xml → ruoyi-modules/ruoyi-member/src/main/resources/ums/FansMapper.xml
View File

@ -1,11 +1,11 @@
<?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.content.mapper.FansMapper" >
<mapper namespace="com.wzj.soopin.member.mapper.FansMapper" >
<select id="getFollowedVlogerIds" resultType="com.wzj.soopin.content.domain.po.Fans" parameterType="map">
<select id="getFollowedVlogerIds" resultType="com.wzj.soopin.member.domain.po.Fans" parameterType="map">
SELECT vloger_id, is_fan_friend_of_mine FROM t_fans
WHERE fan_id = #{currentUserId}

8
ruoyi-modules/ruoyi-system/src/main/java/org/dromara/system/controller/common/CommonController.java → ruoyi-modules/ruoyi-system/src/main/java/org/dromara/system/controller/SysAddressController.java
View File

@ -1,9 +1,9 @@
package org.dromara.system.controller.common;
package org.dromara.system.controller;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.wzj.soopin.member.domain.po.Address;
import com.wzj.soopin.member.mapper.AddressMapper;
import org.dromara.system.mapper.AddressMapper;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.dromara.common.core.config.RuoYiConfig;
@ -35,9 +35,9 @@ import java.util.stream.Collectors;
* @author ruoyi
*/
@RestController
public class CommonController
public class SysAddressController
{
private static final Logger log = LoggerFactory.getLogger(CommonController.class);
private static final Logger log = LoggerFactory.getLogger(SysAddressController.class);
@Autowired
private ServerConfig serverConfig;

9
ruoyi-modules/ruoyi-member/src/main/java/com/wzj/soopin/member/mapper/AddressMapper.java → ruoyi-modules/ruoyi-system/src/main/java/org/dromara/system/mapper/AddressMapper.java
View File

@ -1,4 +1,4 @@
package com.wzj.soopin.member.mapper;
package org.dromara.system.mapper;
import com.baomidou.mybatisplus.annotation.InterceptorIgnore;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
@ -13,12 +13,5 @@ import java.util.List;
*/
@InterceptorIgnore(tenantLine = "true") // 忽略租户过滤
public interface AddressMapper extends BaseMapper<Address> {
/**
* 查询【请填写功能名称】列表
*
* @param address 【请填写功能名称】
* @return 【请填写功能名称】集合
*/
List<Address> selectByEntity(Address address);
}

2
ruoyi-modules/ruoyi-member/src/main/resources/ums/AddressMapper.xml → ruoyi-modules/ruoyi-system/src/main/resources/mapper/system/AddressMapper.xml
View File

@ -2,7 +2,7 @@
<!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.AddressMapper">
<mapper namespace="org.dromara.system.mapper.AddressMapper">
<resultMap type="Address" id="AddressResult">
<result property="id" column="id"/>