동아리까지(백엔드),게시글

컨트롤러

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

import com.app.businessBridge.domain.Answer.Controller.ApiV1AnswerController;
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.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 lombok.AllArgsConstructor;
import lombok.Data;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;

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

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/v1/articles")
public class ApiV1ArticleController {

    private final ArticleService articleService;
    private final AnswerService answerService;

    @GetMapping("")
    public RsData<ArticlesResponse> getArticles() {
        List<ArticleDto> articleDtoList = this.articleService
                .getList()
                .stream()
                .map(article -> new ArticleDto(article))
                .toList();

        return RsData.of(RsCode.S_01, "성공", new ArticlesResponse(articleDtoList));
    }

    @GetMapping("/{id}")
    public RsData<ArticleResponse> getArticle(@PathVariable("id") Long id) {
        return articleService.getArticle(id).map(article -> RsData.of(RsCode.S_01,
                "성공",
                new ArticleResponse(new ArticleDto(article))
        )).orElseGet(() -> RsData.of(RsCode.F_01,
                "%d 번 게시물은 존재하지 않습니다.".formatted(id),
                null
        ));
    }
    @GetMapping("/{clubId}/clubs")
    public RsData<ArticlesResponse> getArticleAndClub(@PathVariable(value = "clubId") Long clubId) {
        List<Article> articles = this.articleService.findAllByClubId(clubId);
        List<ArticleDto> articleDTOS = new ArrayList<>();
        for (Article article : articles) {
            articleDTOS.add(new ArticleDto(article));
        }

        return RsData.of(RsCode.S_01, "성공", new ArticlesResponse(articleDTOS));
    }

    @PostMapping("")
    public RsData<WriteResponse> write(@Valid @RequestBody WriteRequest writeRequest) {

        RsData<Article> writeRs = this.articleService.create(writeRequest.getSubject(), writeRequest.getContent(),
                writeRequest.getClub());

//        if (writeRs.isFail()) return (RsData) writeRs;

        return RsData.of(
                writeRs.getRsCode(),
                writeRs.getMsg(),
                new WriteResponse(new ArticleDto(writeRs.getData()))
        );
    }

    @PatchMapping("/{id}")
    public RsData<ModifyResponse> modify(@Valid @RequestBody ModifyRequest modifyRequest, @PathVariable("id") Long id) {
        Optional<Article> optionalArticle = this.articleService.findById(id);

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

        RsData<Article> modifyRs = this.articleService.modify(optionalArticle.get(), modifyRequest.getSubject(), modifyRequest.getContent());

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

    @DeleteMapping("/{id}")
    public RsData<RemoveResponse> remove(@PathVariable("id") Long id) {
        Optional<Article> optionalArticle = this.articleService.findById(id);

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

        RsData<Article> deleteRs = articleService.deleteById(id);

        return RsData.of(
                deleteRs.getRsCode(),
                deleteRs.getMsg(),
                new RemoveResponse(optionalArticle.get())
        );
    }

    @AllArgsConstructor
    @Getter
    public static class ArticlesResponse {
        private final List<ArticleDto> articles;
    }

    @AllArgsConstructor
    @Getter
    public static class ArticleResponse {
        private final ArticleDto article;
    }

    @Data
    public static class WriteRequest {
        @NotBlank
        private String subject;
        @NotBlank
        private String content;

        private Club club;
    }

    @AllArgsConstructor
    @Getter
    public static class WriteResponse {
        private final ArticleDto articledto;
    }
    @Data
    public static class ModifyRequest {
        @NotBlank
        private String subject;
        @NotBlank
        private String content;
    }

    @AllArgsConstructor
    @Getter
    public static class ModifyResponse {
        private final Article article;
    }

    @AllArgsConstructor
    @Getter
    public static class RemoveResponse {
        private final Article article;
    }
}

디티오

package com.app.businessBridge.domain.Article.DTO;

import com.app.businessBridge.domain.Answer.DTO.AnswerDto;
import com.app.businessBridge.domain.Article.Entity.Article;
import lombok.Getter;
import java.util.List;
import java.util.stream.Collectors;

@Getter
public class ArticleDto {
    private Long id;
    private String subject;
    private String content;
    private List<AnswerDto> answers;

    public ArticleDto (Article article){
        this.id = article.getId();
        this.subject = article.getSubject();
        this.content = article.getContent();
        this.answers = article.getAnswerList().stream()
                .map(AnswerDto::new)
                .collect(Collectors.toList());
    }
}

엔티티

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

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

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

@Entity
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@SuperBuilder
@ToString(callSuper = true)
public class Article extends BaseEntity {
    private String subject;
    private String content;

    @OneToMany(mappedBy = "article", cascade = CascadeType.REMOVE, fetch = FetchType.LAZY)
    private List<Answer> answerList = new ArrayList<>();

    @ManyToOne
    private Club club;
}

리포지터리

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

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

import java.util.List;

public interface ArticleRepository extends JpaRepository<Article ,Long> {
    List<Article> findAllByClubId(Long clubId);
}

서비스

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

import com.app.businessBridge.domain.Article.Entity.Article;
import com.app.businessBridge.domain.Article.Repository.ArticleRepository;
import com.app.businessBridge.domain.Club.Entity.Club;
import com.app.businessBridge.domain.Club.Repository.ClubRepository;
import com.app.businessBridge.global.RsData.RsCode;
import com.app.businessBridge.global.RsData.RsData;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import jakarta.transaction.Transactional;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

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

@Service
@RequiredArgsConstructor
public class ArticleService {

    @PersistenceContext
    private final EntityManager entityManager;
    private final ArticleRepository articleRepository;
    private final ClubRepository clubRepository;

    public List<Article> getList() {
        return this.articleRepository.findAll();
    }

    public Optional<Article> getArticle(Long id) {
        return this.articleRepository.findById(id);
    }
    @Transactional
    public RsData<Article> create(String subject, String content, Club club) {
        Article article = Article.builder()
                .subject(subject)
                .content(content)
                .club(club)
                .answerList(new ArrayList<>()) // 초기화
                .build();

        this.articleRepository.save(article);

        return RsData.of(RsCode.S_02,
                "게시물이 생성 되었습니다.",
                article
        );
    }

    public Optional<Article> findById(Long id) {
        return articleRepository.findById(id);
    }
    public RsData<Article> modify(Article article, String subject, String content) {



        // 기존 article 객체를 기반으로 article1 객체 생성

        // article1 객체의 subject와 content 필드를 새 값으로 설정
        article.setSubject(subject);
        article.setContent(content);


        // article1 객체를 저장하여 수정된 내용을 DB에 반영
        articleRepository.save(article);
        return RsData.of(RsCode.S_03,
                "%d번 게시물이 수정 되었습니다.".formatted(article.getId()),
                article
        );
    }
    public RsData<Article> deleteById(Long id) {
        articleRepository.deleteById(id);

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


}