동아리 등록까지(백엔드) 답변쪽

컨트롤러

package com.app.businessBridge.domain.Answer.Controller;

import com.app.businessBridge.domain.Answer.DTO.AnswerDto;
import com.app.businessBridge.domain.Answer.Entity.Answer;
import com.app.businessBridge.domain.Answer.Service.AnswerService;
import com.app.businessBridge.domain.Article.Controller.ApiV1ArticleController;
import com.app.businessBridge.domain.Article.DTO.ArticleDto;
import com.app.businessBridge.domain.Article.Entity.Article;
import com.app.businessBridge.domain.Article.Service.ArticleService;
import com.app.businessBridge.domain.Club.Entity.Club;
import com.app.businessBridge.global.RsData.RsCode;
import com.app.businessBridge.global.RsData.RsData;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/v1/answers")
public class ApiV1AnswerController {
    private final ArticleService articleService;
    private final AnswerService answerService;

    @GetMapping("")
    public RsData<AnswersResponses> getAnswers() {
        List<AnswerDto> answerDtoList = this.answerService
                .getList()
                .stream()
                .map(answer -> new AnswerDto(answer))
                .toList();

        return RsData.of(RsCode.S_01, "성공", new AnswersResponses(answerDtoList));
    }

    @GetMapping("/{id}")
    public RsData<AnswersResponse> getAnswer(@PathVariable("id") Long id) {
        return answerService.getAnswer(id).map(answer -> RsData.of(RsCode.S_01,
                "성공",
                new AnswersResponse(new AnswerDto(answer))
        )).orElseGet(() -> RsData.of(RsCode.F_01,
                "%d 번  댓글은 존재하지 않습니다.".formatted(id),
                null
        ));
    }
    @GetMapping("/{articleId}/articles")
    public RsData<AnswersResponses> getAnswerAndArticle(@PathVariable(value = "articleId") Long articleId) {
        List<Answer> answers = this.answerService.findAllByArticleId(articleId);
        List<AnswerDto> answerDTOS = new ArrayList<>();
        for (Answer answer : answers) {
            answerDTOS.add(new AnswerDto(answer));
        }

        return RsData.of(RsCode.S_01, "성공", new AnswersResponses(answerDTOS));
    }


    @PostMapping("")
    public RsData<AnswerResponse> write(@Valid @RequestBody AnswerRequest answerRequest) {

        RsData<Answer> writeRs = this.answerService.create(answerRequest.getContent(), answerRequest.getArticle());

        return RsData.of(
                writeRs.getRsCode(),
                writeRs.getMsg(),
                new AnswerResponse(new AnswerDto(writeRs.getData()))
        );
    }
    @PatchMapping("/{id}")
    public RsData<ModifyResponse> modify(@Valid @RequestBody ModifyRequest modifyRequest, @PathVariable("id") Long id) {
        Optional<Answer> optionalAnswer = this.answerService.findById(id);


        if (optionalAnswer.isEmpty()) return RsData.of(RsCode.F_01,
                "%d번 댓글은 존재하지 않습니다.".formatted(id),
                null
        );

        RsData<Answer> modifyRs = this.answerService.modify(optionalAnswer.get(),modifyRequest.getContent());

        return RsData.of(
                modifyRs.getRsCode(),
                modifyRs.getMsg(),
                new ApiV1AnswerController.ModifyResponse(modifyRs.getData())
        );
    }

    @DeleteMapping("/{id}")
    public RsData<RemoveResponse> remove(@PathVariable("id") Long id) {
        Optional<Answer> optionalAnswer = this.answerService.findById(id);

        if (optionalAnswer.isEmpty()) return RsData.of(RsCode.F_01,
                "%d번 댓글은 존재하지 않습니다.".formatted(id),
                null
        );

        RsData<Answer> deleteRs = answerService.deleteById(id);

        return RsData.of(
                deleteRs.getRsCode(),
                deleteRs.getMsg(),
                new ApiV1AnswerController.RemoveResponse(optionalAnswer.get())
        );
    }
    @AllArgsConstructor
    @Getter
    public static class AnswersResponses {
        private final List<AnswerDto> answers;
    }

    @AllArgsConstructor
    @Getter
    public static class AnswersResponse {
        private final AnswerDto answer;
    }


    @Data
    public static class AnswerRequest{
        @NotBlank
        private String content;

        private Article article;


//        @NotBlank
//        private List<Article> articleList;
    }
    @AllArgsConstructor
    @Getter
    public static class AnswerResponse{
        private final AnswerDto answerDto;
    }
    @Data
    public static class ModifyRequest {
        @NotBlank
        private String content;
    }

    @AllArgsConstructor
    @Getter
    public static class ModifyResponse {
        private final Answer answer;
    }

    @AllArgsConstructor
    @Getter
    public static class RemoveResponse {
        private final Answer answer;
    }

}

엔티티

package com.app.businessBridge.domain.Answer.Entity;

import com.app.businessBridge.domain.Article.Entity.Article;
import com.app.businessBridge.domain.Club.Entity.Club;
import com.app.businessBridge.global.Jpa.BaseEntity;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.ManyToOne;
import lombok.*;
import lombok.experimental.SuperBuilder;

@Entity
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@SuperBuilder
@ToString(callSuper = true)
public class Answer extends BaseEntity {

    private String content;

    @ManyToOne
    private Article article;


}

리포지터리

package com.app.businessBridge.domain.Answer.Repository;

import com.app.businessBridge.domain.Answer.Entity.Answer;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.List;

public interface AnswerRepository extends JpaRepository<Answer,Long> {
    List<Answer> findAllByArticleId(Long articleId);

}

서비스

package com.app.businessBridge.domain.Answer.Service;

import com.app.businessBridge.domain.Answer.Entity.Answer;
import com.app.businessBridge.domain.Answer.Repository.AnswerRepository;
import com.app.businessBridge.domain.Article.Entity.Article;
import com.app.businessBridge.domain.Article.Repository.ArticleRepository;
import com.app.businessBridge.domain.Article.Service.ArticleService;
import com.app.businessBridge.domain.Club.Entity.Club;
import com.app.businessBridge.global.RsData.RsCode;
import com.app.businessBridge.global.RsData.RsData;
import jakarta.transaction.Transactional;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
@RequiredArgsConstructor
public class AnswerService {
    private final ArticleRepository articleRepository;
    private final AnswerRepository answerRepository;

    public List<Answer> getList() {
        return this.answerRepository.findAll();
    }

    public Optional<Answer> getAnswer(Long id){
        return this.answerRepository.findById(id);
    }

    @Transactional
    public RsData<Answer> create(String content, Article article) {
        Answer answer = Answer.builder()
                .content(content)
                .article(article)

                .build();

        this.answerRepository.save(answer);

        return RsData.of(RsCode.S_02,
                "게시물이 생성 되었습니다.",
                answer
        );
    }
    public Optional<Answer> findById(Long id) {
        return answerRepository.findById(id);
    }
    public RsData<Answer> modify(Answer answer,String content) {
        answer.setContent(content);
        answerRepository.save(answer);

        return RsData.of(RsCode.S_03,
                "%d번 게시물이 수정 되었습니다.".formatted(answer.getId()),
                answer
        );
    }

    public RsData<Answer> deleteById(Long id) {
        answerRepository.deleteById(id);

        return RsData.of(RsCode.S_04,
                "%d번 게시물이 삭제 되었습니다.".formatted(id),
                null
        );
    }
    public List<Answer> findAllByArticleId(Long articleId) {
        return this.answerRepository.findAllByArticleId(articleId);
    }

}