토이 프로젝트 스터디 #16

• 스터디 진행 날짜 : 7/4
• 스터디 작업 날짜 : 7/1 ~ 7/4

---

토이 프로젝트 진행 사항

• 게시글 관련 코드 작성

내용

Repository

public interface PostRepository extends JpaRepository<Post, Long> {
}

---

Service

@Service
@Transactional
@RequiredArgsConstructor
public class PostService {

    private final PostRepository postRepository;
    private final ImageRepository imageRepository;
    private final AccountRepository accountRepository;
    private final CategoryRepository categoryRepository;
    private final LikeRepository likeRepository;
    private final ImageUtils imageUtils;
    private final PostValueRepository postValueRepository;
    private final RedisKeyValueTemplate redisKeyValueTemplate;

    public CreatePostResponse addPost(AccountInfo accountInfo, CreatePostRequest request) {
        Post post = PostEntityConverter.converter(
                request,
                accountRepository.findById(accountInfo.getAccountId()).orElseThrow(AccountNotFoundException::new),
                categoryRepository.findByName(request.getCategoryName()).orElseThrow(CategoryNotFoundException::new),
                convertCreateRequestImages(request.getImageIds())
        );

        Post savePost = postRepository.save(post);
        initPostValue(savePost.getId());

        return CreatePostResponseConverter.convert(savePost);
    }

    @Transactional(readOnly = true)
    public GetPostResponse getPost(AccountInfo accountInfo, Long postId) {
        Post post = postRepository.findById(postId).orElseThrow(PostNotFoundException::new);

        verifyPost(post.isDeleted());
        PostValue updatePostValue = updateGetPostValue(post.getId());

        return GetPostResponseConverter.convert(
                post, updatePostValue.getViews(), updatePostValue.getLikes(),
                likeRepository.findByAccountIdAndPostId(accountInfo.getAccountId(), postId).isPresent(),
                post.getImages().stream().map(i -> i.getId()).collect(Collectors.toList()),
                post.getImages().stream().map(i -> imageUtils.getImageFilePath(i)).collect(Collectors.toList()));
    }

    public UpdatePostResponse updatePost(AccountInfo accountInfo, UpdatePostRequest request) {
        Post post = postRepository.findById(request.getPostId()).orElseThrow(PostNotFoundException::new);

        verifyPost(post.isDeleted());

        post.updatePost(request, categoryRepository.findByName(request.getCategoryName()).orElseThrow(CategoryNotFoundException::new));

        return UpdatePostResponseConverter.convert(post);
    }

    public void deletePost(AccountInfo accountInfo, Long postId) {
        Post post = postRepository.findById(postId).orElseThrow(PostNotFoundException::new);

        verifyPost(post.isDeleted());

        post.deletePost();
    }

    public GetPostsResponse getPosts(AccountInfo accountInfo, PageRequest pageRequest) {
        Page<Post> posts = postRepository.findAll(pageRequest);

        List<GetPostResponse> postResponses = posts.get().map(post -> {
            PostValue postValue = postValueRepository.findById(post.getId()).orElseThrow(PostValueNotFoundException::new);
            return GetPostResponseConverter.convert(post,
                    postValue.getViews(), postValue.getLikes(),
                    likeRepository.findByAccountIdAndPostId(accountInfo.getAccountId(), post.getId()).isPresent(),
                    post.getImages().stream().map(i -> i.getId()).collect(Collectors.toList()),
                    post.getImages().stream().map(i -> imageUtils.getImageFilePath(i)).collect(Collectors.toList()));
        }).collect(Collectors.toList());

        PageMaker pageMaker =
                new PageMaker(
                        posts.getNumber(),
                        posts.getSize(),
                        3,
                        posts.getTotalElements());

        return GetPostsResponseConverter.convert(postResponses, pageMaker);
    }

    private List<Image> convertCreateRequestImages(List<Long> imageIds) {
        if (imageIds == null || imageIds.isEmpty()) {
            return List.of();
        }
        return imageIds.stream().map(i -> imageRepository.findById(i).orElseThrow(ImageNotFoundException::new)).collect(Collectors.toList());
    }

    private void initPostValue(Long postId) {
        postValueRepository.save(new PostValue(postId, 0, 0));
    }

    private PostValue updateGetPostValue(Long postId) {
        PostValue postValue = postValueRepository.findById(postId).orElseThrow(PostValueNotFoundException::new);
        postValue.setViews(postValue.getViews() + 1);
        return redisKeyValueTemplate.update(postValue);
    }

    private void verifyPost(boolean isDeleted) {
        if (isDeleted) {
            throw new DeletedPostException();
        }
    }
}

---

Controller

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/posts")
public class PostController {

    private final PostService postService;

    @PostMapping("/add")
    public ResponseEntity addPost(@LoginAccount AccountInfo accountInfo, @Validated @RequestBody CreatePostRequest request) {
        return new ResponseEntity(postService.addPost(accountInfo, request), HttpStatus.CREATED);
    }

    @GetMapping("/{id}")
    public ResponseEntity getPost(@LoginAccount AccountInfo accountInfo, @PathVariable Long id) {
        return new ResponseEntity(postService.getPost(accountInfo, id), HttpStatus.OK);
    }

    @GetMapping
    public ResponseEntity getPosts(@LoginAccount AccountInfo accountInfo, @ModelAttribute PageRequest pageRequest) {
        return new ResponseEntity(postService.getPosts(accountInfo, pageRequest.of()), HttpStatus.OK);
    }

    @PostMapping("/update")
    public ResponseEntity updatePost(@LoginAccount AccountInfo accountInfo, @Validated @RequestBody UpdatePostRequest request) {
        return new ResponseEntity(postService.updatePost(accountInfo, request), HttpStatus.OK);
    }

    @PostMapping("/delete/{id}")
    public ResponseEntity deletePost(@LoginAccount AccountInfo accountInfo, @PathVariable Long id) {
        postService.deletePost(accountInfo, id);
        return new ResponseEntity(HttpStatus.OK);
    }
}