用户，社交接口
Change-Id: I10d13773cbe4bbcf3b69a2038cdf7aa9ba54b6df
diff --git a/src/main/java/com/example/myproject/service/CommentService.java b/src/main/java/com/example/myproject/service/CommentService.java
new file mode 100644
index 0000000..c102ca2
--- /dev/null
+++ b/src/main/java/com/example/myproject/service/CommentService.java
@@ -0,0 +1,125 @@
+package com.example.myproject.service;
+
+import com.example.myproject.entity.Comments;
+import com.example.myproject.entity.Post;
+import com.example.myproject.entity.Users;
+import com.example.myproject.repository.CommentRepository;
+import com.example.myproject.repository.PostRepository;
+import com.example.myproject.repository.UserRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@Service
+public class CommentService {
+
+ @Autowired
+ private CommentRepository commentRepository;
+
+ @Autowired
+ private PostRepository postRepository;
+
+ @Autowired
+ private UserRepository userRepository;
+
+ // 添加评论
+ public void addComment(Long postId, Comments comment) {
+ try {
+ // 查找帖子
+ Post post = postRepository.findById(postId).orElseThrow(() -> {
+ throw new RuntimeException("Post with ID " + postId + " not found");
+ });
+
+ // 查找用户
+ Users user = userRepository.findById(comment.getUserId()).orElseThrow(() -> {
+ throw new RuntimeException("User with ID " + comment.getUserId() + " not found");
+ });
+
+ // 设置评论的相关属性
+ comment.setPost(post);
+ comment.setUserId(user.getUserId());
+ comment.setCommentTime(new java.util.Date());
+
+ if (comment.getParentComment() != null && comment.getParentComment() != 0) {
+ // 查找父评论
+ Comments parentComment = commentRepository.findById(comment.getParentComment())
+ .orElseThrow(() -> new RuntimeException("Parent comment with ID " + comment.getParentComment() + " not found"));
+ comment.setParentComment(parentComment.getCommentId()); // 设置父评论 ID
+ } else {
+ comment.setParentComment(0L); // 设置为 0，表示没有父评论
+ }
+
+ // 保存评论
+ commentRepository.save(comment);
+ } catch (Exception e) {
+ // 捕获任何异常并打印堆栈信息
+ e.printStackTrace();
+ throw new RuntimeException("An error occurred while adding the comment: " + e.getMessage());
+ }
+ }
+
+ // 获取指定帖子的所有评论
+ public List<Map<String, Object>> getCommentsByPostId(Long postId) {
+ List<Comments> comments = commentRepository.findAll()
+ .stream()
+ .filter(comment -> comment.getPost().getPostNo().equals(postId)) // 通过 post 的 postNo 过滤评论
+ .collect(Collectors.toList());
+
+ if (comments.isEmpty()) {
+ return new ArrayList<>();
+ }
+
+ List<Map<String, Object>> result = new ArrayList<>();
+ for (Comments comment : comments) {
+ Map<String, Object> commentData = new LinkedHashMap<>();
+ commentData.put("commentId", comment.getCommentId());
+ commentData.put("post_id", comment.getPost().getPostNo());
+ commentData.put("userId", comment.getUserId());
+
+ Users user = userRepository.findById(comment.getUserId()).orElse(null);
+ commentData.put("nickname", user != null ? user.getUsername() : null);
+ commentData.put("avatar_url", user != null ? user.getAvatarUrl() : null);
+
+ commentData.put("content", comment.getContent());
+ commentData.put("isAnonymous", comment.getIsAnonymous());
+ commentData.put("likesCount", comment.getLikesCount());
+ commentData.put("replyCount", comment.getReplyCount());
+ commentData.put("commentTime", comment.getCommentTime());
+ commentData.put("parentComment", comment.getParentComment());
+
+ Map<String, Object> parentCommentData = getParentCommentData(comment.getParentComment());
+ commentData.put("parentCommentData", parentCommentData);
+
+ result.add(commentData);
+ }
+
+ return result;
+ }
+
+ // 递归查找父评论的内容
+ private Map<String, Object> getParentCommentData(Long parentCommentId) {
+ Map<String, Object> parentCommentData = new LinkedHashMap<>();
+ if (parentCommentId != null && parentCommentId != 0) {
+ // 查找父评论
+ Comments parentComment = commentRepository.findById(parentCommentId).orElse(null);
+ if (parentComment != null) {
+ parentCommentData.put("commentId", parentComment.getCommentId());
+ parentCommentData.put("content", parentComment.getContent());
+ parentCommentData.put("userId", parentComment.getUserId());
+
+ Users user = userRepository.findById(parentComment.getUserId()).orElse(null);
+ parentCommentData.put("nickname", user != null ? user.getUsername() : null);
+ parentCommentData.put("avatar_url", user != null ? user.getAvatarUrl() : null);
+
+ Map<String, Object> grandParentData = getParentCommentData(parentComment.getParentComment());
+ parentCommentData.put("parentCommentData", grandParentData);
+ }
+ }
+ return parentCommentData;
+ }
+}
diff --git a/src/main/java/com/example/myproject/service/DynamicService.java b/src/main/java/com/example/myproject/service/DynamicService.java
new file mode 100644
index 0000000..853604d
--- /dev/null
+++ b/src/main/java/com/example/myproject/service/DynamicService.java
@@ -0,0 +1,275 @@
+package com.example.myproject.service;
+
+import com.example.myproject.entity.*;
+import com.example.myproject.repository.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.*;
+
+@Service
+public class DynamicService {
+
+ @Autowired
+ private UserDynamicRepository userDynamicRepository;
+
+ @Autowired
+ private UserRepository userRepository;
+
+ @Autowired
+ private DynamicCommentRepository dynamicCommentRepository;
+
+ @Autowired
+ private DynamicLikesRepository dynamicLikesRepository;
+
+ @Autowired
+ private FriendRelationRepository friendRelationRepository;
+
+ private static final String IMAGE_DIR = "uploads/post/";
+
+ // 创建好友动态
+ public Map<String, Object> createDynamic(Long userId, String title, String content, MultipartFile[] imageFiles) {
+ // 查找用户信息
+ Users user = userRepository.findById(userId)
+ .orElseThrow(() -> new RuntimeException("User not found"));
+
+ // 创建新的动态
+ UserDynamic userDynamic = new UserDynamic();
+ userDynamic.setUserId(userId);
+ userDynamic.setTitle(title != null ? title : "默认标题");
+ userDynamic.setContent(content);
+ userDynamic.setTime(new Date());
+ userDynamic.setLikesCount(0);
+ userDynamic.setCommentsCount(0);
+
+ // 处理图片上传
+ StringBuilder imageUrlsBuilder = new StringBuilder();
+ if (imageFiles != null && imageFiles.length > 0) {
+ for (int i = 0; i < imageFiles.length; i++) {
+ if (i > 0) {
+ imageUrlsBuilder.append(",");
+ }
+ try {
+ String imageUrl = saveImage(imageFiles[i]);
+ imageUrlsBuilder.append(imageUrl);
+ } catch (IOException e) {
+ throw new RuntimeException("Image upload failed: " + e.getMessage());
+ }
+ }
+ }
+
+ // 将多个图片 URL 拼接
+ userDynamic.setImageUrl(imageUrlsBuilder.toString());
+
+ // 保存数据库
+ UserDynamic savedUserDynamic = userDynamicRepository.save(userDynamic);
+
+ // 返回结果
+ Map<String, Object> response = new HashMap<>();
+ response.put("dynamicId", savedUserDynamic.getDynamicId());
+ response.put("message", "动态创建成功");
+ return response;
+ }
+
+ // 保存图片并返回图片的 URL
+ public String saveImage(MultipartFile imageFile) throws IOException {
+ String fileName = imageFile.getOriginalFilename();
+ Path path = Paths.get(IMAGE_DIR + fileName);
+ Files.createDirectories(path.getParent());
+ Files.write(path, imageFile.getBytes());
+ return "/images/" + fileName;
+ }
+
+ // 删除动态
+ public void deleteDynamic(Long dynamicId) {
+ if (userDynamicRepository.existsById(dynamicId)) {
+ userDynamicRepository.deleteById(dynamicId);
+ } else {
+ throw new RuntimeException("Dynamic with id " + dynamicId + " not found");
+ }
+ }
+
+ //好友动态评论
+ public Map<String, Object> addComment(Long userId, Long dynamicId, String commentContent) {
+ Users user = userRepository.findById(userId)
+ .orElseThrow(() -> new RuntimeException("User not found"));
+
+ UserDynamic dynamic = userDynamicRepository.findById(dynamicId)
+ .orElseThrow(() -> new RuntimeException("Dynamic not found"));
+
+ DynamicComment comment = new DynamicComment();
+ comment.setDynamicId(dynamicId);
+ comment.setUserId(userId);
+ comment.setCommentContent(commentContent);
+ comment.setCommentTime(new Date());
+
+ // 保存评论
+ DynamicComment savedComment = dynamicCommentRepository.save(comment);
+
+ // 返回成功消息
+ Map<String, Object> response = new HashMap<>();
+ response.put("comment_id", savedComment.getCommentId());
+ response.put("message", "评论成功");
+ return response;
+ }
+
+ //返回某个好友的所有动态
+ public Map<String, Object> getAllUserDynamics(Long userId) {
+ // 查找用户的所有动态
+ List<UserDynamic> userDynamics = userDynamicRepository.findByUserId(userId);
+ Map<String, Object> postData = new LinkedHashMap<>();
+ List<Map<String, Object>> dynamicList = new ArrayList<>();
+
+ // 遍历动态，获取点赞和评论
+ for (UserDynamic dynamic : userDynamics) {
+ Map<String, Object> dynamicData = new LinkedHashMap<>();
+ dynamicData.put("dynamic_id", dynamic.getDynamicId());
+ dynamicData.put("user_id", dynamic.getUserId());
+
+ Users user = userRepository.findById(dynamic.getUserId()).orElse(null);
+ if (user != null) {
+ dynamicData.put("username", user.getUsername());
+ dynamicData.put("avatar_url", user.getAvatarUrl());
+ } else {
+ dynamicData.put("username", "Unknown");
+ dynamicData.put("avatar_url", "http://example.com/default-avatar.jpg");
+ }
+
+ dynamicData.put("title", dynamic.getTitle());
+ dynamicData.put("content", dynamic.getContent());
+ dynamicData.put("images", dynamic.getImageUrl());
+ dynamicData.put("time", dynamic.getTime());
+
+ // 获取点赞
+ List<DynamicLikes> likes = dynamicLikesRepository.findByDynamicId(dynamic.getDynamicId());
+ List<Map<String, Object>> likeList = new ArrayList<>();
+ for (DynamicLikes like : likes) {
+ Map<String, Object> likeData = new HashMap<>();
+ likeData.put("user_id", like.getUserId());
+
+ // 获取点赞用户的用户名
+ Users likeUser = userRepository.findById(like.getUserId()).orElse(null);
+ if (likeUser != null) {
+ likeData.put("username", likeUser.getUsername());
+ } else {
+ likeData.put("username", "Unknown");
+ }
+
+ likeList.add(likeData);
+ }
+ dynamicData.put("likes", likeList);
+
+ // 获取评论
+ List<DynamicComment> comments = dynamicCommentRepository.findByDynamicId(dynamic.getDynamicId());
+ List<Map<String, Object>> commentList = new ArrayList<>();
+ for (DynamicComment comment : comments) {
+ Map<String, Object> commentData = new HashMap<>();
+ commentData.put("comment_id", comment.getCommentId());
+ commentData.put("user_id", comment.getUserId());
+
+ // 获取评论用户的用户名
+ Users commentUser = userRepository.findById(comment.getUserId()).orElse(null);
+ if (commentUser != null) {
+ commentData.put("username", commentUser.getUsername());
+ } else {
+ commentData.put("username", "Unknown");
+ }
+
+ commentData.put("content", comment.getCommentContent());
+ commentData.put("time", comment.getCommentTime());
+ commentList.add(commentData);
+ }
+ dynamicData.put("comments", commentList);
+
+ dynamicList.add(dynamicData);
+ }
+
+ Map<String, Object> response = new HashMap<>();
+ response.put("dynamic", dynamicList);
+ return response;
+ }
+
+ //获取当前所有好友的id
+ public List<Long> getAllFriendIds(Long userId) {
+ List<FriendRelation> friendRelations = friendRelationRepository.findByUserId(userId);
+ List<Long> friendIds = new ArrayList<>();
+
+ for (FriendRelation relation : friendRelations) {
+ // 添加好友ID
+ if (!friendIds.contains(relation.getFriendId())) {
+ friendIds.add(relation.getFriendId());
+ }
+ }
+
+ return friendIds;
+ }
+
+ public Map<String, Object> getAllUserAndFriendsDynamics(List<Long> userIds) {
+ List<Map<String, Object>> allDynamics = new ArrayList<>();
+
+ // 遍历所有用户获取他们的动态
+ for (Long userId : userIds) {
+ Map<String, Object> userDynamics = getAllUserDynamics(userId);
+ if (userDynamics != null && !userDynamics.isEmpty()) {
+ allDynamics.addAll((List<Map<String, Object>>) userDynamics.get("dynamic"));
+ }
+ }
+
+ // 返回所有动态的合集
+ Map<String, Object> response = new HashMap<>();
+ response.put("dynamic", allDynamics);
+ return response;
+ }
+
+ //点赞动态
+ public boolean likeDynamic(Long userId, Long dynamicId) {
+ // 检查该用户是否已经点赞过该动态
+ DynamicLikes existingLike = dynamicLikesRepository.findByUserIdAndDynamicId(userId, dynamicId);
+ if (existingLike != null) {
+ return false;
+ }
+
+ // 新增点赞记录
+ DynamicLikes newLike = new DynamicLikes();
+ newLike.setUserId(userId);
+ newLike.setDynamicId(dynamicId);
+ newLike.setLikeTime(new java.util.Date());
+ dynamicLikesRepository.save(newLike);
+
+ // 更新动态表的点赞数
+ UserDynamic dynamic = userDynamicRepository.findById(dynamicId).orElse(null);
+ if (dynamic != null) {
+ dynamic.setLikesCount(dynamic.getLikesCount() + 1);
+ userDynamicRepository.save(dynamic);
+ }
+
+ return true;
+ }
+
+ //取消点赞
+ public boolean unlikeDynamic(Long userId, Long dynamicId) {
+ // 查找该用户的点赞记录
+ DynamicLikes existingLike = dynamicLikesRepository.findByUserIdAndDynamicId(userId, dynamicId);
+ if (existingLike == null) {
+ return false;
+ }
+
+ // 删除点赞记录
+ dynamicLikesRepository.delete(existingLike);
+
+ // 更新动态表的点赞数
+ UserDynamic dynamic = userDynamicRepository.findById(dynamicId).orElse(null);
+ if (dynamic != null) {
+ dynamic.setLikesCount(dynamic.getLikesCount() - 1);
+ userDynamicRepository.save(dynamic);
+ }
+
+ return true;
+ }
+
+}
diff --git a/src/main/java/com/example/myproject/service/GroupService.java b/src/main/java/com/example/myproject/service/GroupService.java
new file mode 100644
index 0000000..016d7e0
--- /dev/null
+++ b/src/main/java/com/example/myproject/service/GroupService.java
@@ -0,0 +1,382 @@
+package com.example.myproject.service;
+
+import com.example.myproject.entity.*;
+
+import com.example.myproject.repository.*;
+import jakarta.transaction.Transactional;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Files;
+
+import java.util.*;
+
+@Service
+public class GroupService {
+
+ @Autowired
+ private GroupRepository groupRepository;
+
+ @Autowired
+ private GroupMembersRepository groupMembersRepository;
+
+
+ @Autowired
+ private UserRepository userRepository;
+
+ @Autowired
+ private GroupPostRepository groupPostRepository;
+
+ @Autowired
+ private GroupCommentsRepository groupCommentsRepository;
+
+ private static final String IMAGE_DIR = "uploads/groupPost/";
+
+ @Transactional
+ // 创建小组的方法
+ public ResponseEntity<Map<String, Object>> createGroup(Group groupRequest) {
+ try {
+ // 创建新的小组对象
+ Group newGroup = new Group();
+ newGroup.setGroupName(groupRequest.getGroupName());
+ newGroup.setDescription(groupRequest.getDescription());
+ newGroup.setCreateTime(new Date());
+ newGroup.setUserId(groupRequest.getUserId());
+ newGroup.setMemberCount(1);
+ newGroup.setCategory(groupRequest.getCategory());
+ newGroup.setCoverImage(groupRequest.getCoverImage());
+ Group createdGroup = groupRepository.save(newGroup);
+
+ // 返回成功响应
+ Map<String, Object> response = new HashMap<>();
+ response.put("status", "success");
+ response.put("message", "兴趣小组创建成功");
+ response.put("group_id", createdGroup.getGroupId());
+
+ return ResponseEntity.ok(response);
+ } catch (Exception e) {
+ // 返回失败响应
+ Map<String, Object> errorResponse = new HashMap<>();
+ errorResponse.put("status", "error");
+ errorResponse.put("message", "小组创建失败");
+ errorResponse.put("group_id", null);
+
+ return ResponseEntity.status(400).body(errorResponse);
+ }
+ }
+
+
+ // 加入小组
+ @Transactional
+ public ResponseEntity<Map<String, Object>> joinGroup(Long groupId, Long userId) {
+ // 查找小组
+ Optional<Group> groupOptional = groupRepository.findById(groupId);
+ if (!groupOptional.isPresent()) {
+ return ResponseEntity.status(400).body(
+ Map.of("status", "failure", "message", "小组不存在")
+ );
+ }
+
+ Group group = groupOptional.get();
+
+ // 检查用户是否已经是该小组成员
+ if (groupMembersRepository.existsByGroupIdAndUserId(groupId, userId)) {
+ return ResponseEntity.status(400).body(
+ Map.of("status", "failure", "message", "用户已经是该小组的成员")
+ );
+ }
+
+ // 插入用户和小组的关联记录
+ GroupMembers groupMembers = new GroupMembers();
+ groupMembers.setGroupId(groupId);
+ groupMembers.setUserId(userId);
+ groupMembersRepository.save(groupMembers);
+
+ // 更新小组的成员数
+ group.setMemberCount(group.getMemberCount() + 1);
+ groupRepository.save(group);
+
+ return ResponseEntity.ok().body(
+ Map.of("status", "success", "message", "成功加入小组")
+ );
+ }
+
+ // 退出小组
+ @Transactional
+ public ResponseEntity<Map<String, Object>> leaveGroup(Long groupId, Long userId) {
+ // 查找小组
+ Optional<Group> groupOptional = groupRepository.findById(groupId);
+ if (!groupOptional.isPresent()) {
+ return ResponseEntity.status(400).body(
+ Map.of("status", "failure", "message", "小组不存在")
+ );
+ }
+
+ Group group = groupOptional.get();
+
+ // 检查用户是否是该小组成员
+ if (!groupMembersRepository.existsByGroupIdAndUserId(groupId, userId)) {
+ return ResponseEntity.status(400).body(
+ Map.of("status", "failure", "message", "用户不是该小组的成员")
+ );
+ }
+
+ // 删除用户和小组的关联记录
+ groupMembersRepository.deleteByGroupIdAndUserId(groupId, userId);
+
+ // 更新小组的成员数
+ group.setMemberCount(group.getMemberCount() - 1);
+ groupRepository.save(group);
+
+ return ResponseEntity.ok().body(
+ Map.of("status", "success", "message", "成功退出小组")
+ );
+ }
+
+ // 获取所有成员
+ @Transactional
+ public ResponseEntity<Map<String, Object>> getGroupMembers(Long groupId) {
+ // 查找小组
+ Optional<Group> groupOptional = groupRepository.findById(groupId);
+ if (!groupOptional.isPresent()) {
+ return ResponseEntity.status(400).body(
+ Map.of("status", "failure", "message", "小组不存在")
+ );
+ }
+
+ Group group = groupOptional.get();
+
+ // 获取所有小组成员
+ List<GroupMembers> groupMembersList = groupMembersRepository.findByGroupId(groupId);
+
+ // 创建成员返回列表
+ List<Map<String, Object>> members = new ArrayList<>();
+ for (GroupMembers groupMember : groupMembersList) {
+ Optional<Users> userOptional = userRepository.findById(groupMember.getUserId());
+ if (userOptional.isPresent()) {
+ Users user = userOptional.get();
+ members.add(Map.of(
+ "user_id", user.getUserId(),
+ "username", user.getUsername(),
+ "avatar_url", user.getAvatarUrl()
+ ));
+ }
+ }
+
+ return ResponseEntity.ok().body(
+ Map.of("status", "success", "members", members)
+ );
+ }
+
+
+ //发布帖子
+ public Map<String, Object> createPost(Long groupId, Long userId, String postContent, String title, MultipartFile[] imageFiles) {
+ // 创建一个新的帖子对象
+ GroupPost post = new GroupPost();
+ post.setGroupId(groupId);
+ post.setUserId(userId);
+ post.setContent(postContent);
+ post.setTitle(title);
+ post.setTime(new Date());
+ post.setLikeCount(0);
+ post.setCommentCount(0);
+
+ // 处理图片上传，如果没有图片，返回空字符串
+ String imageUrls = handleImages(imageFiles);
+ post.setImage(imageUrls);
+
+ // 保存帖子到数据库
+ GroupPost savedPost = groupPostRepository.save(post);
+
+ // 返回结果
+ Map<String, Object> response = new LinkedHashMap<>();
+ response.put("post_id", savedPost.getGroupPostId());
+ response.put("message", "帖子创建成功");
+ return response;
+ }
+
+ // 处理图片上传的方法，返回图片的 URL 字符串
+ private String handleImages(MultipartFile[] imageFiles) {
+ if (imageFiles == null || imageFiles.length == 0) {
+ return "";
+ }
+
+ StringBuilder imageUrlsBuilder = new StringBuilder();
+
+ for (int i = 0; i < imageFiles.length; i++) {
+ if (i > 0) {
+ imageUrlsBuilder.append(",");
+ }
+ try {
+ String imageUrl = saveImage(imageFiles[i]);
+ imageUrlsBuilder.append(imageUrl);
+ } catch (IOException e) {
+ throw new RuntimeException("图片上传失败: " + e.getMessage());
+ }
+ }
+ return imageUrlsBuilder.toString();
+ }
+
+ // 保存图片并返回图片的 URL
+ private String saveImage(MultipartFile imageFile) throws IOException {
+ if (imageFile == null) {
+ throw new IOException("图片文件为空");
+ }
+
+ String fileName = imageFile.getOriginalFilename();
+ Path path = Path.of(IMAGE_DIR + fileName);
+ Files.createDirectories(path.getParent());
+ Files.write(path, imageFile.getBytes());
+ return "/images/" + fileName;
+ }
+
+ // 获取小组内的所有帖子
+ public Map<String, Object> getAllPosts(Long groupId) {
+ List<GroupPost> posts = groupPostRepository.findByGroupId(groupId);
+
+ List<Map<String, Object>> postList = new ArrayList<>();
+
+ for (GroupPost post : posts) {
+ Map<String, Object> postData = new HashMap<>();
+ Users user = userRepository.findById(post.getUserId()).orElseThrow(() -> new RuntimeException("User not found"));
+ postData.put("group_post_id", post.getGroupPostId());
+ postData.put("user_id", post.getUserId());
+ postData.put("username", user.getUsername());
+ postData.put("title", post.getTitle());
+ postData.put("content", post.getContent());
+ postData.put("time", post.getTime());
+
+ postList.add(postData);
+ }
+
+ // 返回响应数据
+ Map<String, Object> response = new LinkedHashMap<>();
+ response.put("status", "success");
+ response.put("posts", postList);
+ return response;
+ }
+
+
+ // 获取小组列表接口
+ public Map<String, Object> searchGroups(Map<String, Object> params) {
+ String name = (String) params.get("name");
+ String category = (String) params.get("category");
+ Integer page = (Integer) params.getOrDefault("page", 1);
+ Integer size = (Integer) params.getOrDefault("size", 10);
+ String sortBy = (String) params.getOrDefault("sort_by", "memberCount");
+
+ // 构建分页对象
+ Pageable pageable;
+
+ // 根据 `sortBy` 判断排序方式
+ if ("createTime".equals(sortBy)) {
+ pageable = PageRequest.of(page - 1, size, Sort.by(Sort.Order.asc("createTime")));
+ } else if ("groupName".equals(sortBy)) {
+ pageable = PageRequest.of(page - 1, size, Sort.by(Sort.Order.asc("groupName")));
+ } else {
+ pageable = PageRequest.of(page - 1, size, Sort.by(Sort.Order.desc("memberCount")));
+ }
+
+ Page<Group> groups;
+ if (name != null && !name.isEmpty()) {
+ // 小组名称模糊查询
+ groups = groupRepository.searchGroups(name, category, pageable);
+ } else {
+ groups = groupRepository.searchWithFilters(category, pageable);
+ }
+
+ return buildResponse(groups);
+ }
+
+ // 构建返回的响应数据
+ private Map<String, Object> buildResponse(Page<Group> groups) {
+ Map<String, Object> response = new LinkedHashMap<>();
+ response.put("status", "success");
+ response.put("total", groups.getTotalElements());
+ response.put("total_pages", groups.getTotalPages());
+ response.put("current_page", groups.getNumber() + 1);
+ response.put("items", groups.getContent());
+
+ return response;
+ }
+
+ // 点赞帖子
+ public Map<String, Object> likePost(Long GroupPostId) {
+ // 查找帖子
+ Optional<GroupPost> postOpt = groupPostRepository.findById(GroupPostId);
+ if (!postOpt.isPresent()) {
+ throw new RuntimeException("Post not found");
+ }
+
+ GroupPost post = postOpt.get();
+
+ // 更新点赞数
+ post.setLikeCount(post.getLikeCount() + 1);
+ groupPostRepository.save(post);
+
+ // 返回成功信息
+ Map<String, Object> response = new HashMap<>();
+ response.put("status", "success");
+ response.put("message", "点赞成功");
+ return response;
+ }
+
+ // 取消点赞
+ public Map<String, Object> unlikePost(Long GroupPostId) {
+ // 查找帖子
+ Optional<GroupPost> postOpt = groupPostRepository.findById(GroupPostId);
+ if (!postOpt.isPresent()) {
+ throw new RuntimeException("Post not found");
+ }
+
+ GroupPost post = postOpt.get();
+
+ // 更新点赞数
+ if (post.getLikeCount() > 0) {
+ post.setLikeCount(post.getLikeCount() - 1);
+ groupPostRepository.save(post);
+
+ // 返回成功信息
+ Map<String, Object> response = new HashMap<>();
+ response.put("status", "success");
+ response.put("message", "取消点赞成功");
+ return response;
+ } else {
+ // 如果点赞数已经是0，则返回相应消息
+ Map<String, Object> response = new HashMap<>();
+ response.put("status", "failure");
+ response.put("message", "无法取消点赞，点赞数已经为0");
+ return response;
+ }
+ }
+
+ // 添加评论并更新帖子的评论数
+ public Map<String, Object> addComment(Long postId, GroupComments comment) {
+ // 查找帖子
+ Optional<GroupPost> postOpt = groupPostRepository.findById(postId);
+ if (!postOpt.isPresent()) {
+ throw new RuntimeException("Post not found");
+ }
+
+ GroupPost post = postOpt.get();
+
+ comment.setGroupPostId(postId);
+ comment.setTime(new java.util.Date());
+ groupCommentsRepository.save(comment);
+ post.setCommentCount(post.getCommentCount() + 1);
+ groupPostRepository.save(post);
+ Map<String, Object> response = new HashMap<>();
+ response.put("status", "success");
+ response.put("message", "评论成功");
+ return response;
+ }
+
+
+}
diff --git a/src/main/java/com/example/myproject/service/LevelService.java b/src/main/java/com/example/myproject/service/LevelService.java
new file mode 100644
index 0000000..92f50ed
--- /dev/null
+++ b/src/main/java/com/example/myproject/service/LevelService.java
@@ -0,0 +1,140 @@
+package com.example.myproject.service;
+
+import com.example.myproject.entity.ExperienceHistory;
+import com.example.myproject.entity.Users;
+import com.example.myproject.entity.Level;
+import com.example.myproject.repository.ExperienceHistoryRepository;
+import com.example.myproject.repository.UserRepository;
+import com.example.myproject.repository.LevelRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+
+import java.util.Date;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.HashMap;
+
+@Service
+public class LevelService {
+
+ @Autowired
+ private UserRepository userRepository;
+
+ @Autowired
+ private LevelRepository levelRepository;
+
+ @Autowired
+ private ExperienceHistoryRepository experienceHistoryRepository;
+
+
+ public Map<String, Object> getUserExperience(Long userId) {
+ // 获取用户信息
+ Users user = userRepository.findById(userId).orElseThrow(() -> new RuntimeException("User not found"));
+
+ // 获取当前等级
+ Level currentLevel = levelRepository.findById(user.getLevel()).orElseThrow(() -> new RuntimeException("Level not found"));
+
+ // 获取下一个等级的经验需求
+ Level nextLevel = levelRepository.findById(currentLevel.getLevelId() + 1).orElse(null);
+
+ // 构建响应数据
+ Map<String, Object> response = new HashMap<>();
+ response.put("current_experience", user.getCurrentExperience());
+ response.put("level", currentLevel.getLevelName());
+ response.put("next_level_experience", nextLevel != null ? nextLevel.getRequiredExperience() : 0);
+
+ return response;
+ }
+
+ public Map<String, Object> updateExperience(Long userId, Integer experience, String source) {
+ // 获取用户信息
+ Users user = userRepository.findById(userId).orElseThrow(() -> new RuntimeException("用户不存在"));
+
+ // 更新用户的经验值
+ user.setCurrentExperience(user.getCurrentExperience() + experience);
+
+ // 保存更新后的用户信息
+ userRepository.save(user);
+
+ // 创建经验更新历史记录
+ ExperienceHistory experienceHistory = new ExperienceHistory();
+ experienceHistory.setUserId(userId);
+ experienceHistory.setExperienceChange(experience);
+ experienceHistory.setSource(source);
+ experienceHistory.setUpdateTime(new Date());
+
+ // 保存更新历史
+ experienceHistoryRepository.save(experienceHistory);
+
+ // 返回更新后的经验值和消息
+ Map<String, Object> response = new LinkedHashMap<>();
+ response.put("status", "success");
+ response.put("message", "经验更新成功");
+ response.put("current_experience", user.getCurrentExperience()); // 返回更新后的经验值
+
+ return response;
+ }
+
+ public Map<String, Object> checkUpgrade(Long userId) {
+ // 获取用户信息
+ Users user = userRepository.findById(userId).orElseThrow(() -> new RuntimeException("用户不存在"));
+
+ // 获取当前等级
+ Level currentLevel = levelRepository.findById(user.getLevel())
+ .orElseThrow(() -> new RuntimeException("用户等级信息不存在"));
+
+ // 获取下一个等级的经验需求
+ Level nextLevel = levelRepository.findById(currentLevel.getLevelId() + 1).orElse(null);
+
+ // 构建响应数据
+ Map<String, Object> response = new LinkedHashMap<>();
+
+ // 判断用户是否可以升级
+ boolean canUpgrade = user.getCurrentExperience() >= (nextLevel != null ? nextLevel.getRequiredExperience() : 0);
+ response.put("can_upgrade", canUpgrade);
+ // 构建响应数据
+
+ response.put("next_level_experience", nextLevel != null ? nextLevel.getRequiredExperience() : 0);
+ response.put("current_experience", user.getCurrentExperience());
+
+
+ return response;
+ }
+
+ public Map<String, Object> upgradeUserLevel(Long userId, Boolean canUpgrade) {
+ // 获取用户信息
+ Users user = userRepository.findById(userId).orElseThrow(() -> new RuntimeException("User not found"));
+
+ // 创建响应对象
+ Map<String, Object> response = new HashMap<>();
+
+ if (canUpgrade) {
+ // 获取当前等级
+ Level currentLevel = levelRepository.findById(user.getLevel())
+ .orElseThrow(() -> new RuntimeException("Level not found"));
+
+ // 获取下一个等级的经验需求
+ Level nextLevel = levelRepository.findById(currentLevel.getLevelId() + 1).orElse(null);
+
+ if (nextLevel != null) {
+ user.setLevel(user.getLevel() + 1);
+ userRepository.save(user);
+ Level newLevel = levelRepository.findById(user.getLevel())
+ .orElseThrow(() -> new RuntimeException("Level not found"));
+ response.put("message", "升级成功");
+ response.put("status", "success");
+ response.put("new_level", newLevel.getLevelName());
+ } else {
+ response.put("message", "用户已达到最高等级");
+ response.put("status", "error");
+ }
+ } else {
+ response.put("message", "用户不满足升级条件");
+ response.put("status", "error");
+ }
+
+ return response;
+ }
+
+}
diff --git a/src/main/java/com/example/myproject/service/PostService.java b/src/main/java/com/example/myproject/service/PostService.java
new file mode 100644
index 0000000..feb7404
--- /dev/null
+++ b/src/main/java/com/example/myproject/service/PostService.java
@@ -0,0 +1,232 @@
+package com.example.myproject.service;
+
+import com.example.myproject.entity.Likes;
+import com.example.myproject.entity.Post;
+import com.example.myproject.entity.Users;
+import com.example.myproject.repository.CollectionsRepository;
+import com.example.myproject.repository.LikesRepository;
+import com.example.myproject.repository.PostRepository;
+import com.example.myproject.repository.UserRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+import com.example.myproject.entity.Collections;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.*;
+
+@Service
+public class PostService {
+
+ @Autowired
+ private PostRepository postRepository;
+
+ @Autowired
+ private UserRepository userRepository;
+ @Autowired
+ private LikesRepository likesRepository;
+
+ @Autowired
+ private CollectionsRepository collectionsRepository;
+
+ private static final String IMAGE_DIR = "uploads/post/";
+
+
+ //创建帖子
+ public Map<String, Object> createPost(Long userId, String postContent, String title, MultipartFile[] imageFiles) {
+ // 查找用户信息
+ Users user = userRepository.findById(Long.valueOf(userId)).orElseThrow(() -> new RuntimeException("User not found"));
+ Post post = new Post();
+ post.setUser_id(user.getUserId());
+ post.setPostTime(new Date());
+ post.setPostLikeNum(0);
+ post.setPostCollectNum(0);
+ post.setPostContent(postContent);
+ post.setTitle(title);
+
+ // 处理多张图片的上传
+ StringBuilder imageUrlsBuilder = new StringBuilder();
+ if (imageFiles != null && imageFiles.length > 0) {
+ for (int i = 0; i < imageFiles.length; i++) {
+ if (i > 0) {
+ imageUrlsBuilder.append(",");
+ }
+ try {
+ String imageUrl = saveImage(imageFiles[i]);
+ imageUrlsBuilder.append(imageUrl);
+ } catch (IOException e) {
+ throw new RuntimeException("Image upload failed: " + e.getMessage());
+ }
+ }
+ }
+ post.setImageUrl(imageUrlsBuilder.toString());
+ Post savedPost = postRepository.save(post);
+ Map<String, Object> response = new HashMap<>();
+ response.put("postNo", savedPost.getPostNo());
+ response.put("message", "帖子创建成功");
+ return response;
+ }
+
+ // 保存图片并返回图片的 URL
+ public String saveImage(MultipartFile imageFile) throws IOException {
+ String fileName = imageFile.getOriginalFilename();
+ Path path = Paths.get(IMAGE_DIR + fileName);
+ Files.createDirectories(path.getParent());
+ Files.write(path, imageFile.getBytes());
+ return "/images/" + fileName;
+ }
+
+
+ //编辑帖子
+ public void updatePost(Long postId, Post post) {
+ Post existingPost = postRepository.findById(postId).orElseThrow(() -> new RuntimeException("Post not found"));
+ if (post.getTitle() != null) {
+ existingPost.setTitle(post.getTitle());
+ }
+ if (post.getPostContent() != null) {
+ existingPost.setPostContent(post.getPostContent());
+ }
+ if (post.getImageUrl() != null) {
+ existingPost.setImageUrl(post.getImageUrl());
+ }
+ existingPost.setPostTime(post.getPostTime());
+ // 保存更新后的帖子
+ postRepository.save(existingPost);
+ }
+
+ //删除帖子
+ public void deletePost(Long postId) {
+ // 查找指定 ID 的帖子，如果不存在则抛出异常
+ if (!postRepository.existsById(postId)) {
+ throw new RuntimeException("Post not found");
+ }
+ // 删除该帖子
+ postRepository.deleteById(postId);
+ }
+
+ //点赞帖子（已完成）
+ public void likePost(Long postId, Long userId) {
+ // 查找指定 ID 的帖子
+ Post post = postRepository.findById(postId).orElseThrow(() -> new RuntimeException("Post not found"));
+ post.setPostLikeNum(post.getPostLikeNum() + 1);
+
+ // 保存帖子
+ postRepository.save(post);
+ Likes like = new Likes();
+ like.setUserId(userId);
+ like.setPostNo(postId);
+ // 保存点赞记录
+ likesRepository.save(like);
+ }
+
+ // 取消点赞帖子（已完成）
+ public void unlikePost(Long postId, Long userId) {
+ // 查找指定 ID 的帖子
+ Post post = postRepository.findById(postId).orElseThrow(() -> new RuntimeException("Post not found"));
+
+ // 如果点赞数大于 0，则减少点赞数
+ if (post.getPostLikeNum() > 0) {
+ post.setPostLikeNum(post.getPostLikeNum() - 1);
+ }
+
+ // 删除点赞表中对应的记录
+ likesRepository.deleteLikeByUserIdAndPostNo(userId, postId);
+
+ // 保存更新后的帖子
+ postRepository.save(post);
+ }
+
+
+ // 获取帖子列表（已完成）
+ public Map<String, Object> getAllPosts() {
+ List<Post> posts = postRepository.findAll();
+ List<Map<String, Object>> postList = new ArrayList<>();
+
+ for (Post post : posts) {
+ Map<String, Object> postMap = new LinkedHashMap<>();
+ postMap.put("postNo", post.getPostNo());
+ postMap.put("user_id", post.getUser_id());
+ postMap.put("postContent", post.getPostContent());
+ postMap.put("imgUrl", post.getImageUrl());
+ postMap.put("title", post.getTitle());
+ postMap.put("createdAt", post.getPostTime().toString());
+ postMap.put("likeCount", post.getPostLikeNum());
+ postMap.put("collectCount", post.getPostCollectNum());
+
+ postList.add(postMap);
+ }
+
+ Map<String, Object> response = new HashMap<>();
+ // 统计帖子数量
+ response.put("total", postList.size());
+ response.put("posts", postList);
+
+ return response;
+ }
+
+ public Map<String, Object> getPostById(Long postId) {
+ // 获取帖子
+ Optional<Post> postOptional = postRepository.findById(postId);
+
+ // 如果帖子存在
+ if (postOptional.isPresent()) {
+ Post post = postOptional.get();
+ Map<String, Object> postData = new LinkedHashMap<>();
+ postData.put("postNo", post.getPostNo());
+ postData.put("user_id", post.getUser_id());
+ Long userId = post.getUser_id();
+ Users user = userRepository.findById(userId).orElse(null);
+
+ if (user != null) {
+ postData.put("username", user.getUsername());
+ postData.put("avatar_url", user.getAvatarUrl());
+ } else {
+ postData.put("username", null);
+ postData.put("avatar_url", null);
+ }
+
+ postData.put("postContent", post.getPostContent());
+ postData.put("imageUrl", post.getImageUrl());
+ postData.put("postTime", post.getPostTime());
+ postData.put("postLikeNum", post.getPostLikeNum());
+ postData.put("postCollectNum", post.getPostCollectNum());
+ postData.put("title", post.getTitle());
+
+ return postData;
+ } else {
+ throw new RuntimeException("Post not found with id: " + postId);
+ }
+ }
+
+
+ //收藏
+ public void collectPost(Long postId, Long userId) {
+ Post post = postRepository.findById(postId).orElseThrow(() -> new RuntimeException("Post not found"));
+ post.setPostCollectNum(post.getPostCollectNum() + 1);
+ postRepository.save(post);
+
+ // 添加到收藏表
+ Collections collection = new Collections();
+ collection.setUserId(userId);
+ collection.setPostNo(postId);
+ collectionsRepository.save(collection);
+ }
+
+ //取消收藏
+ public void uncollectPost(Long postId, Long userId) {
+ Post post = postRepository.findById(postId).orElseThrow(() -> new RuntimeException("Post not found"));
+ // 减少帖子收藏数
+ if (post.getPostCollectNum() > 0) {
+ post.setPostCollectNum(post.getPostCollectNum() - 1);
+ postRepository.save(post);
+ }
+
+ // 从收藏表中删除对应记录
+ collectionsRepository.deleteLikeByUserIdAndPostNo(userId, postId);
+ }
+
+
+
+}
diff --git a/src/main/java/com/example/myproject/service/TaskService.java b/src/main/java/com/example/myproject/service/TaskService.java
new file mode 100644
index 0000000..bd04661
--- /dev/null
+++ b/src/main/java/com/example/myproject/service/TaskService.java
@@ -0,0 +1,295 @@
+package com.example.myproject.service;
+
+import com.example.myproject.entity.Level;
+import com.example.myproject.entity.Task;
+import com.example.myproject.entity.UserTaskStatus;
+import com.example.myproject.repository.LevelRepository;
+import com.example.myproject.repository.TaskRepository;
+import com.example.myproject.repository.UserTaskStatusRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import com.example.myproject.entity.Users;
+import com.example.myproject.repository.UserRepository;
+
+import java.util.*;
+
+@Service
+public class TaskService {
+
+ @Autowired
+ private TaskRepository taskRepository;
+
+ @Autowired
+ private UserTaskStatusRepository userTaskStatusRepository;
+
+ @Autowired
+ private UserRepository userRepository;
+
+ @Autowired
+ private LevelRepository levelRepository;
+
+ public Map<String, Object> getAllTasksForUser(Long userId) {
+ // 获取所有任务
+ List<Task> tasks = taskRepository.findAll();
+ List<Map<String, Object>> taskList = new ArrayList<>();
+
+ for (Task task : tasks) {
+ Optional<UserTaskStatus> userTaskStatus = userTaskStatusRepository
+ .findByUserIdAndTaskId(userId, task.getTaskId());
+
+ Map<String, Object> taskData = new LinkedHashMap<>();
+ taskData.put("task_id", task.getTaskId());
+ taskData.put("title", task.getTitle());
+ taskData.put("description", task.getDescription());
+ taskData.put("status", userTaskStatus.isPresent() ? userTaskStatus.get().getStatus() : "pending");
+ taskData.put("progress", userTaskStatus.isPresent() ? userTaskStatus.get().getCurrentProgress() : 0);
+
+ // 奖励
+ Map<String, Integer> reward = new LinkedHashMap<>();
+ reward.put("experience", task.getRewardExperience());
+ reward.put("points", task.getRewardPoints());
+ taskData.put("reward", reward);
+
+ taskList.add(taskData);
+ }
+
+ Map<String, Object> response = new LinkedHashMap<>();
+ response.put("tasks", taskList);
+ return response;
+ }
+
+ public Map<String, Object> updateTaskStatus(Long userId, String taskId) {
+ // 获取用户任务状态
+ Optional<UserTaskStatus> userTaskStatusOpt = userTaskStatusRepository.findByUserIdAndTaskId(userId, taskId);
+ UserTaskStatus userTaskStatus = userTaskStatusOpt.get();
+
+ // 检查任务进度
+ if (userTaskStatus.getCurrentProgress() == 100f) {
+ Optional<Task> taskOpt = taskRepository.findById(taskId);
+ Task task = taskOpt.get();
+
+ // 更新任务状态为已完成
+ userTaskStatus.setStatus("completed");
+ userTaskStatus.setCurrentExperience(task.getRewardExperience());
+ userTaskStatus.setCurrentPoints(task.getRewardPoints());
+
+ userTaskStatusRepository.save(userTaskStatus);
+
+ // 构建返回数据
+ Map<String, Object> response = new HashMap<>();
+ response.put("status", "success");
+ response.put("message", "任务状态已更新");
+
+ Map<String, Integer> currentReward = new HashMap<>();
+ currentReward.put("current_experience", task.getRewardExperience());
+ currentReward.put("current_points", task.getRewardPoints());
+ response.put("current_reward", currentReward);
+
+ return response;
+ } else {
+ Map<String, Object> errorResponse = new HashMap<>();
+ errorResponse.put("status", "failure");
+ errorResponse.put("message", "任务未完成，无法更新状态");
+ return errorResponse;
+ }
+ }
+
+ public Map<String, Object> getUserExperience(Long userId) {
+ // 获取用户信息
+ Optional<Users> userOpt = userRepository.findById(userId);
+ if (!userOpt.isPresent()) {
+ Map<String, Object> errorResponse = new LinkedHashMap<>();
+ errorResponse.put("status", "failure");
+ errorResponse.put("message", "用户不存在");
+ return errorResponse;
+ }
+
+ Users user = userOpt.get();
+ Integer currentExperience = user.getCurrentExperience();
+ Optional<Level> levelOpt = levelRepository.findById(user.getLevel());
+ String levelName = levelOpt.isPresent() ? levelOpt.get().getLevelName() : "未知等级";
+
+ List<UserTaskStatus> completedTasks = userTaskStatusRepository.findByUserIdAndStatus(userId, "completed");
+
+ int totalExperience = 0;
+ int totalPoints = 0;
+ for (UserTaskStatus taskStatus : completedTasks) {
+ Optional<Task> taskOpt = taskRepository.findById(taskStatus.getTaskId());
+ if (taskOpt.isPresent()) {
+ Task task = taskOpt.get();
+ totalExperience += task.getRewardExperience();
+ totalPoints += task.getRewardPoints();
+ }
+ }
+
+ // 构建返回数据
+ Map<String, Object> response = new LinkedHashMap<>();
+ response.put("user_id", userId);
+ response.put("current_experience", currentExperience);
+ response.put("level", levelName);
+ response.put("tasks_completed", completedTasks.size());
+
+ Map<String, Integer> reward = new LinkedHashMap<>();
+ reward.put("experience", totalExperience);
+ reward.put("points", totalPoints);
+
+ response.put("reward", reward);
+
+ return response;
+ }
+
+ public Map<String, Object> getNewStep(Long userId) {
+ // 获取用户的第一个未完成任务
+ Optional<UserTaskStatus> userTaskStatusOpt = userTaskStatusRepository.findFirstByUserIdAndStatus(userId, "pending");
+
+ if (!userTaskStatusOpt.isPresent()) {
+ Map<String, Object> errorResponse = new LinkedHashMap<>();
+ errorResponse.put("status", "failure");
+ errorResponse.put("message", "用户当前没有未完成的任务");
+ return errorResponse;
+ }
+
+ UserTaskStatus userTaskStatus = userTaskStatusOpt.get();
+ String taskId = userTaskStatus.getTaskId();
+
+ // 获取该任务的描述
+ Optional<Task> taskOpt = taskRepository.findById(taskId);
+ if (!taskOpt.isPresent()) {
+ Map<String, Object> errorResponse = new LinkedHashMap<>();
+ errorResponse.put("status", "failure");
+ errorResponse.put("message", "任务不存在");
+ return errorResponse;
+ }
+
+ Task task = taskOpt.get();
+
+ // 获取总任务数
+ long totalTasks = taskRepository.count();
+
+ // 构建返回数据
+ Map<String, Object> response = new LinkedHashMap<>();
+ response.put("current_step", taskId);
+ response.put("total_steps", totalTasks);
+ response.put("step_description", task.getDescription());
+
+ return response;
+ }
+
+ public Map<String, Object> updateTaskProgress(Long userId, String taskId, Integer progress) {
+ Optional<UserTaskStatus> userTaskStatusOpt = userTaskStatusRepository.findByUserIdAndTaskId(userId, taskId);
+
+ if (!userTaskStatusOpt.isPresent()) {
+ Map<String, Object> errorResponse = new LinkedHashMap<>();
+ errorResponse.put("status", "failure");
+ errorResponse.put("message", "任务不存在或该任务不属于用户");
+ return errorResponse;
+ }
+
+ UserTaskStatus userTaskStatus = userTaskStatusOpt.get();
+ userTaskStatus.setCurrentProgress(Float.valueOf(progress));
+ userTaskStatusRepository.save(userTaskStatus);
+ Map<String, Object> response = new LinkedHashMap<>();
+ response.put("status", "success");
+ response.put("message", "进度已更新");
+
+ return response;
+ }
+
+ public Map<String, Object> claimReward(Long userId, String taskId) {
+ // 获取用户任务状态
+ Optional<UserTaskStatus> userTaskStatusOpt = userTaskStatusRepository.findByUserIdAndTaskId(userId, taskId);
+
+ if (!userTaskStatusOpt.isPresent()) {
+ Map<String, Object> errorResponse = new LinkedHashMap<>();
+ errorResponse.put("status", "failure");
+ errorResponse.put("message", "任务状态不存在");
+ return errorResponse;
+ }
+
+ UserTaskStatus userTaskStatus = userTaskStatusOpt.get();
+
+ if (userTaskStatus.getCurrentProgress() == 100f) {
+ if (userTaskStatus.getIsRewardClaimed()) {
+ Map<String, Object> errorResponse = new LinkedHashMap<>();
+ errorResponse.put("status", "failure");
+ errorResponse.put("message", "奖励已经领取过了");
+ return errorResponse;
+ }
+
+ Optional<Task> taskOpt = taskRepository.findById(taskId);
+ if (!taskOpt.isPresent()) {
+ Map<String, Object> errorResponse = new LinkedHashMap<>();
+ errorResponse.put("status", "failure");
+ errorResponse.put("message", "任务不存在");
+ return errorResponse;
+ }
+
+ Task task = taskOpt.get();
+
+ userTaskStatus.setIsRewardClaimed(true);
+ userTaskStatus.setCurrentExperience(task.getRewardExperience());
+ userTaskStatus.setCurrentPoints(task.getRewardPoints());
+
+ userTaskStatusRepository.save(userTaskStatus);
+
+ Optional<Users> userOpt = userRepository.findById(userId);
+ if (!userOpt.isPresent()) {
+ Map<String, Object> errorResponse = new LinkedHashMap<>();
+ errorResponse.put("status", "failure");
+ errorResponse.put("message", "用户不存在");
+ return errorResponse;
+ }
+
+ Users user = userOpt.get();
+
+ // 将任务奖励加到用户的积分和经验
+ user.setUserPoints(user.getUserPoints() + task.getRewardPoints());
+ user.setCurrentExperience(user.getCurrentExperience() + task.getRewardExperience());
+
+ userRepository.save(user);
+
+ Map<String, Object> response = new LinkedHashMap<>();
+ response.put("status", "success");
+ response.put("message", "奖励已领取");
+
+ Map<String, Integer> reward = new LinkedHashMap<>();
+ reward.put("experience", task.getRewardExperience());
+ reward.put("points", task.getRewardPoints());
+ response.put("reward", reward);
+
+ return response;
+ } else {
+ Map<String, Object> errorResponse = new LinkedHashMap<>();
+ errorResponse.put("status", "failure");
+ errorResponse.put("message", "任务未完成，无法领取奖励");
+ return errorResponse;
+ }
+ }
+
+ public Map<String, Object> checkRewardStatus(Long userId, String taskId) {
+ // 获取用户任务状态
+ Optional<UserTaskStatus> userTaskStatusOpt = userTaskStatusRepository.findByUserIdAndTaskId(userId, taskId);
+
+ if (!userTaskStatusOpt.isPresent()) {
+ Map<String, Object> errorResponse = new LinkedHashMap<>();
+ errorResponse.put("status", "failure");
+ errorResponse.put("message", "任务状态不存在");
+ return errorResponse;
+ }
+
+ UserTaskStatus userTaskStatus = userTaskStatusOpt.get();
+
+ // 检查奖励是否已领取
+ if (userTaskStatus.getIsRewardClaimed()) {
+ Map<String, Object> response = new LinkedHashMap<>();
+ response.put("status", "reward_issued");
+ response.put("message", "任务奖励已被领取");
+ return response;
+ }
+
+ Map<String, Object> response = new LinkedHashMap<>();
+ response.put("status", "reward_not_issued");
+ response.put("message", "任务奖励未被领取");
+ return response;
+ }
+}
diff --git a/src/main/java/com/example/myproject/service/UserFollowService.java b/src/main/java/com/example/myproject/service/UserFollowService.java
new file mode 100644
index 0000000..6222b48
--- /dev/null
+++ b/src/main/java/com/example/myproject/service/UserFollowService.java
@@ -0,0 +1,122 @@
+package com.example.myproject.service;
+
+import com.example.myproject.entity.Users;
+import com.example.myproject.entity.UserFollow;
+import com.example.myproject.repository.UserFollowRepository;
+import com.example.myproject.repository.UserRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+
+@Service
+public class UserFollowService {
+
+ @Autowired
+ private UserFollowRepository userFollowRepository;
+
+ @Autowired
+ private UserRepository userRepository;
+
+ // 用户关注操作
+ public Map<String, Object> follow(Long followerId, Long followedId) {
+ if (followerId.equals(followedId)) {
+ Map<String, Object> response = new LinkedHashMap<>();
+ response.put("status", "error");
+ response.put("message", "不能关注自己");
+ return response;
+ }
+
+ // 检查是否已关注该用户
+ UserFollow existingFollow = userFollowRepository.findByFollowerIdAndFollowedId(followerId, followedId);
+ if (existingFollow == null) {
+ // 创建新的关注记录
+ UserFollow userFollow = new UserFollow();
+ userFollow.setFollowerId(followerId);
+ userFollow.setFollowedId(followedId);
+ userFollow.setFollowTime(new java.util.Date());
+
+ userFollowRepository.save(userFollow);
+
+ // 返回关注成功响应
+ Map<String, Object> response = new LinkedHashMap<>();
+ response.put("status", "success");
+ response.put("message", "关注成功");
+ return response;
+ } else {
+ Map<String, Object> response = new LinkedHashMap<>();
+ response.put("status", "error");
+ response.put("message", "已经关注该用户");
+ return response;
+ }
+ }
+
+ // 取消关注操作
+ public Map<String, Object> unfollow(Long followerId, Long followedId) {
+ UserFollow userFollow = userFollowRepository.findByFollowerIdAndFollowedId(followerId, followedId);
+
+ if (userFollow != null) {
+ userFollowRepository.delete(userFollow);
+
+ Map<String, Object> response = new LinkedHashMap<>();
+ response.put("status", "success");
+ response.put("message", "取消关注成功");
+ return response;
+ } else {
+ Map<String, Object> response = new LinkedHashMap<>();
+ response.put("status", "error");
+ response.put("message", "未找到关注关系");
+ return response;
+ }
+ }
+
+ // 获取某个用户的所有粉丝
+ public Map<String, Object> getFollowers(Long userId) {
+ List<UserFollow> followers = userFollowRepository.findByFollowedId(userId);
+
+ List<Map<String, Object>> followersList = new ArrayList<>();
+ for (UserFollow follow : followers) {
+ // 获取粉丝的用户信息
+ Users follower = userRepository.findById(follow.getFollowerId()).orElse(null);
+ if (follower != null) {
+ Map<String, Object> followerInfo = new LinkedHashMap<>();
+ followerInfo.put("user_id", follower.getUserId());
+ followerInfo.put("username", follower.getUsername());
+ followerInfo.put("avatar_url", follower.getAvatarUrl());
+ followersList.add(followerInfo);
+ }
+ }
+
+ // 返回响应数据
+ Map<String, Object> response = new LinkedHashMap<>();
+ response.put("status", "success");
+ response.put("total", followersList.size());
+ response.put("followers", followersList);
+
+ return response;
+ }
+
+ // 获取某个用户的所有关注用户
+ public Map<String, Object> getFollowing(Long userId) {
+ List<UserFollow> following = userFollowRepository.findByFollowerId(userId);
+
+ List<Map<String, Object>> followingList = new ArrayList<>();
+ for (UserFollow follow : following) {
+ // 获取被关注的用户信息
+ Users followedUser = userRepository.findById(follow.getFollowedId()).orElse(null);
+ if (followedUser != null) {
+ Map<String, Object> followingInfo = new HashMap<>();
+ followingInfo.put("user_id", followedUser.getUserId());
+ followingInfo.put("username", followedUser.getUsername());
+ followingInfo.put("avatar_url", followedUser.getAvatarUrl());
+ followingList.add(followingInfo);
+ }
+ }
+ Map<String, Object> response = new HashMap<>();
+ response.put("status", "success");
+ response.put("total", followingList.size());
+ response.put("following", followingList);
+
+ return response;
+ }
+}
diff --git a/src/main/java/com/example/myproject/service/UserMessageService.java b/src/main/java/com/example/myproject/service/UserMessageService.java
new file mode 100644
index 0000000..05f62e7
--- /dev/null
+++ b/src/main/java/com/example/myproject/service/UserMessageService.java
@@ -0,0 +1,112 @@
+package com.example.myproject.service;
+
+import com.example.myproject.entity.UserMessages;
+import com.example.myproject.repository.UserMessagesRepository;
+import com.example.myproject.repository.UserRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import java.util.Optional;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Date;
+import java.util.stream.Collectors;
+
+@Service
+public class UserMessageService {
+
+ @Autowired
+ private UserMessagesRepository userMessagesRepository;
+
+ @Autowired
+ private UserRepository userRepository;
+
+ // 发送私信
+ public Map<String, Object> sendMessage(Long senderId, Long receiverId, String content) {
+ UserMessages message = new UserMessages();
+ message.setSenderId(senderId);
+ message.setReceiverId(receiverId);
+ message.setContent(content);
+ message.setTime(new Date());
+ UserMessages savedMessage = userMessagesRepository.save(message);
+
+ // 返回响应
+ Map<String, Object> response = new HashMap<>();
+ response.put("status", "success");
+ response.put("message", "私信发送成功");
+ response.put("message_id", savedMessage.getMessageId());
+ return response;
+ }
+
+ // 获取当前用户的所有消息
+ public Map<String, Object> getUserMessages(Long userId) {
+ // 查询当前用户发送和接收的所有消息
+ List<UserMessages> messages = userMessagesRepository.findBySenderIdOrReceiverId(userId, userId);
+
+ // 获取发送者和接收者的用户名
+ List<Map<String, Object>> messageDetails = messages.stream()
+ .map(message -> {
+ Map<String, Object> messageMap = new HashMap<>();
+ messageMap.put("message_id", message.getMessageId());
+ messageMap.put("sender_id", message.getSenderId());
+ messageMap.put("receiver_id", message.getReceiverId());
+ messageMap.put("content", message.getContent());
+ messageMap.put("timestamp", message.getTime());
+ String senderUsername = userRepository.findById(message.getSenderId())
+ .map(user -> user.getUsername())
+ .orElse("Unknown");
+ messageMap.put("sender_username", senderUsername);
+ String receiverUsername = userRepository.findById(message.getReceiverId())
+ .map(user -> user.getUsername())
+ .orElse("Unknown");
+ messageMap.put("receiver_username", receiverUsername);
+
+ return messageMap;
+ })
+ .collect(Collectors.toList());
+
+ Map<String, Object> response = new HashMap<>();
+ response.put("status", "success");
+ response.put("messages", messageDetails);
+ return response;
+ }
+
+ // 获取单条消息的详情
+ public Map<String, Object> getMessage(Long messageId) {
+ Optional<UserMessages> optionalMessage = userMessagesRepository.findById(messageId);
+
+ if (optionalMessage.isPresent()) {
+ UserMessages message = optionalMessage.get();
+
+ // 获取发送者和接收者的用户名
+ String senderUsername = userRepository.findById(message.getSenderId())
+ .map(user -> user.getUsername())
+ .orElse("Unknown");
+ String receiverUsername = userRepository.findById(message.getReceiverId())
+ .map(user -> user.getUsername())
+ .orElse("Unknown");
+
+ // 构建响应数据
+ Map<String, Object> response = new HashMap<>();
+ Map<String, Object> messageDetails = new HashMap<>();
+ messageDetails.put("message_id", message.getMessageId());
+ messageDetails.put("sender_id", message.getSenderId());
+ messageDetails.put("sender_username", senderUsername);
+ messageDetails.put("receiver_id", message.getReceiverId());
+ messageDetails.put("receiver_username", receiverUsername);
+ messageDetails.put("content", message.getContent());
+ messageDetails.put("timestamp", message.getTime());
+
+ response.put("status", "success");
+ response.put("message", messageDetails);
+ return response;
+ } else {
+ Map<String, Object> errorResponse = new HashMap<>();
+ errorResponse.put("status", "error");
+ errorResponse.put("message", "Message not found");
+ return errorResponse;
+ }
+ }
+
+
+}
diff --git a/src/main/java/com/example/myproject/service/UserService.java b/src/main/java/com/example/myproject/service/UserService.java
index 71435c7..0d37854 100644
--- a/src/main/java/com/example/myproject/service/UserService.java
+++ b/src/main/java/com/example/myproject/service/UserService.java
@@ -1,25 +1,269 @@
package com.example.myproject.service;
+import com.example.myproject.entity.Users;
+import com.example.myproject.entity.UserInviteCode;
+import com.example.myproject.repository.UserRepository;
+import com.example.myproject.repository.UserInviteCodeRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+
+@Service
+public class UserService {
+
+ @Autowired
+ private UserRepository userRepository;
+
+ @Autowired
+ private UserInviteCodeRepository userInviteCodeRepository;
+
+ // 生成邀请码
+ public Map<String, Object> generateInviteCode(Long userId) {
+ // 获取用户信息
+ Users user = userRepository.findById(userId).orElse(null);
+
+ // 如果用户不存在，返回错误
+ if (user == null) {
+ Map<String, Object> errorResponse = new HashMap<>();
+ errorResponse.put("status", "failure");
+ errorResponse.put("message", "用户不存在");
+ return errorResponse;
+ }
+
+ // 检查用户的邀请数量
+ if (user.getInviteCount() <= 0) {
+ Map<String, Object> errorResponse = new HashMap<>();
+ errorResponse.put("status", "failure");
+ errorResponse.put("message", "没有剩余的邀请码");
+ return errorResponse;
+ }
+
+ // 生成唯一的邀请码
+ String inviteCode = generateUniqueInviteCode();
+
+ // 将邀请码保存到 `user_invite_code` 表
+ UserInviteCode userInviteCode = new UserInviteCode();
+ userInviteCode.setUserId(userId);
+ userInviteCode.setInviteCode(inviteCode);
+ userInviteCode.setCreatedAt(java.time.LocalDateTime.now());
+
+ userInviteCodeRepository.save(userInviteCode);
+
+ // 更新用户的 `invite_count`，减少1
+ user.setInviteCount(user.getInviteCount() - 1);
+ userRepository.save(user);
+
+ // 返回成功信息
+ Map<String, Object> response = new HashMap<>();
+ response.put("status", "success");
+ response.put("message", "邀请码生成成功");
+ response.put("invite_code", inviteCode);
+
+ return response;
+ }
+
+ // 生成唯一的邀请码，使用26个字母（大小写）
+ private String generateUniqueInviteCode() {
+ String characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+ StringBuilder inviteCode = new StringBuilder();
+
+ Random random = new Random();
+ for (int i = 0; i < 10; i++) {
+ inviteCode.append(characters.charAt(random.nextInt(characters.length())));
+ }
+
+ return inviteCode.toString();
+ }
+
+ public String registerUser(String username, String email, String password, String role, String inviteCode) {
+ // 检查邮箱是否已经注册
+ Optional<Users> existingEmailUser = userRepository.findByEmail(email);
+ if (existingEmailUser.isPresent()) {
+ return "该邮箱已被注册";
+ }
+
+ // 检查用户名是否已经存在
+ Optional<Users> existingUsernameUser = userRepository.findByUsername(username); // 需要根据用户名查询
+ if (existingUsernameUser.isPresent()) {
+ return "该用户名已被注册";
+ }
+
+ // 检查邀请码是否有效
+ if (inviteCode == null || inviteCode.isEmpty()) {
+ return "邀请码不能为空";
+ }
+
+ Optional<UserInviteCode> invite = userInviteCodeRepository.findByInviteCode(inviteCode);
+ if (invite.isEmpty() || invite.get().getIsUsed()) {
+ return "邀请码无效或已被使用";
+ }
+
+ // 设置默认等级为2（由于邀请码有效）
+ Long level = 2L;
+
+ // 设置默认头像 URL
+ String avatarUrl = "https://example.com/default-avatar.jpg"; // 默认头像
+
+ // 获取邀请码对应的用户ID
+ UserInviteCode inviteEntity = invite.get();
+ Long inviteUserId = inviteEntity.getUserId();
+
+ // 创建新用户
+ Users newUser = new Users();
+ newUser.setUsername(username);
+ newUser.setEmail(email);
+ newUser.setPassword(password);
+ newUser.setRole(role);
+ newUser.setInviteCount(0); // 初始邀请码数量为 0
+ newUser.setLevel(level);
+ newUser.setAvatarUrl(avatarUrl); // 设置默认头像
+ newUser.setRegistrationDate(new java.util.Date()); // 设置注册日期
+ newUser.setCurrentExperience(0); // 默认经验为 0
+ newUser.setCurrentSeedingHours(0f); // 默认做种时长为 0
+ newUser.setRegistrationTime(new java.util.Date()); // 设置注册时间为当前时间
+
+ // 保存用户信息
+ userRepository.save(newUser);
+
+ // 更新邀请码的使用状态
+ inviteEntity.setIsUsed(true);
+ userInviteCodeRepository.save(inviteEntity);
+
+ return "用户注册成功";
+ }
-import com.baomidou.mybatisplus.extension.service.IService;
+ public String loginUser(String username, String password) {
+ // 检查用户是否存在
+ Optional<Users> userOptional = userRepository.findByUsername(username);
+ if (userOptional.isEmpty()) {
+ return "用户名不存在";
+ }
-import com.example.myproject.entity.User;
+ Users user = userOptional.get();
-public interface UserService extends IService<User> {
- User loginService(String username, String password);
+ // 检查密码是否正确
+ if (!user.getPassword().equals(password)) {
+ return "密码错误";
+ }
+
+ // 登录成功
+ return "登录成功";
+ }
+
+ public String changePassword(Long userId, String oldPassword, String newPassword, String confirmPassword) {
+ // 查找用户
+ Users user = userRepository.findById(userId).orElse(null);
+
+ if (user == null) {
+ return "用户不存在";
+ }
+
+ // 检查旧密码是否正确
+ if (!user.getPassword().equals(oldPassword)) {
+ return "旧密码错误";
+ }
+
+ // 检查新密码和确认密码是否一致
+ if (!newPassword.equals(confirmPassword)) {
+ return "新密码与确认密码不一致";
+ }
+
+ // 更新密码
+ user.setPassword(newPassword);
+ userRepository.save(user);
+
+ return "密码修改成功";
+ }
+
+ // 获取用户个人资料
+ public Map<String, Object> getProfile(Long userId) {
+ Optional<Users> userOptional = userRepository.findById(userId);
+
+ // 如果用户不存在，返回null或者可以抛出异常
+ if (userOptional.isEmpty()) {
+ return null; // 可以返回 null 或者根据需要返回错误信息
+ }
+
+ Users user = userOptional.get();
+
+ // 将需要的字段放入 Map 中
+ Map<String, Object> profile = new LinkedHashMap<>();
+ profile.put("avatarUrl", user.getAvatarUrl());
+ profile.put("username", user.getUsername());
+ profile.put("email", user.getEmail());
+ profile.put("gender", user.getGender());
+ profile.put("description", user.getDescription());
+ profile.put("hobbies", user.getHobbies());
+ profile.put("level", user.getLevel());
+ profile.put("Experience", user.getCurrentExperience());
+ profile.put("uploadCount", user.getUploadCount());
+ profile.put("downloadCount", user.getDownloadCount());
+ profile.put("shareRate", user.getShareRate());
+ profile.put("registrationTime", user.getRegistrationTime());
+
+ return profile;
+ }
+
+ // 修改用户个人资料
+ public boolean editProfile(Long userId, String avatarUrl, String nickname, String gender, String description, String hobbies) {
+ Optional<Users> userOptional = userRepository.findById(userId);
+
+ // 如果用户不存在，返回false
+ if (userOptional.isEmpty()) {
+ return false; // 用户不存在
+ }
+
+ Users user = userOptional.get();
+
+ // 更新用户资料，只有传入值才会更新对应字段
+ if (avatarUrl != null) {
+ user.setAvatarUrl(avatarUrl);
+ }
+ if (nickname != null) {
+ user.setUsername(nickname);
+ }
+ if (gender != null) {
+ user.setGender(gender);
+ }
+ if (description != null) {
+ user.setDescription(description);
+ }
+ if (hobbies != null) {
+ user.setHobbies(hobbies);
+ }
+
+ // 保存更新后的用户信息
+ userRepository.save(user);
+
+ return true; // 更新成功
+ }
+
+ public Map<String, Object> calculateShareRate(Long userId) {
+ // 查找用户
+ Users user = userRepository.findById(userId).orElse(null);
+ if (user == null) {
+ return Map.of("status", "error", "message", "用户不存在");
+ }
+
+ // 获取上传量和下载量
+ Float uploadCount = user.getUploadCount();
+ Float downloadCount = user.getDownloadCount();
+
+ // 计算分享率
+ Float shareRate = 0f; // 默认分享率为0
+ if (downloadCount != 0) {
+ shareRate = uploadCount / downloadCount; // 分享率 = 上传量 / 下载量
+ }
+
+ // 更新用户的分享率
+ user.setShareRate(shareRate);
+ userRepository.save(user);
+
+ // 返回结果
+ return Map.of("status", "success", "message", "分享率计算成功", "shareRate", shareRate);
+ }
- boolean preRegisterUser(User user);
-
-
- boolean verifyEmail(String email, String token);
-
-
- boolean checkEmailExists(String email);
-
- boolean checkPassword(Long userId, String rawPassword);
-
-
-// Integer getUserId();
-}
\ No newline at end of file
+}
diff --git a/src/main/java/com/example/myproject/service/serviceImpl/UserServiceImpl.java b/src/main/java/com/example/myproject/service/serviceImpl/UserServiceImpl.java
deleted file mode 100644
index d0718fe..0000000
--- a/src/main/java/com/example/myproject/service/serviceImpl/UserServiceImpl.java
+++ /dev/null
@@ -1,122 +0,0 @@
-
-package com.example.myproject.service.serviceImpl;
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.example.myproject.mapper.UserMapper;
-import com.example.myproject.mapper.VerificationTokenMapper;
-import com.example.myproject.entity.User;
-import com.example.myproject.entity.VerificationToken;
-import com.example.myproject.service.EmailService;
-import com.example.myproject.service.UserService;
-import org.apache.commons.lang3.RandomStringUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.security.crypto.password.PasswordEncoder;
-import org.springframework.stereotype.Service;
-import java.time.Instant;
-import java.time.temporal.ChronoUnit;
-//登录注册
-@Service
-public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
- private static final Logger log = LoggerFactory.getLogger(UserServiceImpl.class);
- @Autowired
- private UserMapper userMapper; // Using MyBatis-Plus mapper
- @Autowired
- private EmailServiceImpl emailService;
- @Autowired
- private VerificationTokenMapper verificationTokenMapper; // Using MyBatis-Plus mapper
- @Autowired
- private PasswordEncoder passwordEncoder; // Injecting password encoder
- @Override
- public User loginService(String username, String password) {
- log.debug("Attempting login with username: {}, password: {}", username, password);
- User user = userMapper.selectOne(new QueryWrapper<User>().eq("username", username).eq("password", password));
- if (user != null) {
- user.setPassword(""); // Clear the password before returning
- log.debug("Login successful, User ID: {}", user.getId());
- } else {
- log.debug("Login failed, incorrect username or password.");
- }
- return user;
- }
- @Override
- public boolean preRegisterUser(User user) {
- log.debug("Pre-registering user, username: {}, email: {}", user.getUsername(), user.getEmail());
- // 检查用户名或邮箱是否已存在
- boolean userExists = userMapper.selectOne(new QueryWrapper<User>().eq("username", user.getUsername())) != null ||
- userMapper.selectOne(new QueryWrapper<User>().eq("email", user.getEmail())) != null;
- if (userExists) {
- log.debug("Pre-registration failed, username or email already exists.");
- return false; // 用户名或邮箱已经存在
- }
- // 加密密码
- String encryptedPassword = passwordEncoder.encode(user.getPassword());
- // 生成验证码
- String token = RandomStringUtils.randomNumeric(6);
- // 设置过期时间为当前时间加一小时
- Instant expiryDate = Instant.now().plus(1, ChronoUnit.HOURS);
- // 创建验证令牌对象
- VerificationToken verificationToken = new VerificationToken(
- token,
- user.getUsername(),
- user.getEmail(),
- encryptedPassword,
- expiryDate
- );
- // 插入验证令牌
- int rowsInserted = verificationTokenMapper.insert(verificationToken);
- if (rowsInserted > 0) {
- // 发送验证邮件
- emailService.sendVerificationEmail(user.getEmail(), token);
- log.debug("Pre-registration successful, verification code: {}, expiry date: {}", token, expiryDate);
- return true; // 注册前验证成功
- } else {
- log.error("Failed to insert verification token into database.");
- return false; // 如果插入验证令牌失败，返回失败
- }
- }
- @Override
- public boolean verifyEmail(String email, String token) {
- log.debug("Verifying email, email: {}, token: {}", email, token);
- VerificationToken verificationToken = verificationTokenMapper.selectOne(
- new QueryWrapper<VerificationToken>().eq("token", token).eq("email", email)
- );
- if (verificationToken != null && !verificationToken.isExpired()) {
- log.debug("Verification code is valid, username: {}", verificationToken.getUsername());
- User user = userMapper.selectOne(new QueryWrapper<User>().eq("email", email));
- if (user == null) {
- user = new User();
- user.setEmail(email);
- user.setUsername(verificationToken.getUsername());
- user.setPassword(verificationToken.getPassword());
- user.setEmailVerified(true);
- userMapper.insert(user); // Save new user
- log.debug("New user created, User ID: {}", user.getId());
- } else {
- user.setEmailVerified(true);
- userMapper.updateById(user); // Update existing user
- log.debug("User email verified, User ID: {}", user.getId());
- }
- verificationTokenMapper.delete(new QueryWrapper<VerificationToken>().eq("token", token)); // Clean up the token
- log.debug("Verification code deleted.");
- return true;
- }
- log.debug("Verification code is invalid or expired.");
- return false;
- }
- public boolean checkEmailExists(String email) {
- log.debug("检查邮箱是否存在，邮箱：{}", email);
- boolean exists = userMapper.selectCount(new QueryWrapper<User>().eq("email", email)) > 0;
- log.debug("邮箱存在状态：{}", exists);
- return exists;
- }
- public boolean checkPassword(Long userId, String password) {
- User user = userMapper.selectById(userId);
- if (user == null) {
- throw new RuntimeException("用户不存在");
- }
- String encryptedPassword = user.getPassword();
- return passwordEncoder.matches(password, encryptedPassword);
- }
-}