Merge pull request #4 from CAPS-DGU/revert-3-feat/#2-wiki

Revert "[feat] 위키 수정 기록 로직 수정"

Author: floreo1242

src/main/java/kr/dgucaps/caps/domain/member/entity/Member.java

@@ -3,7 +3,6 @@
 import jakarta.persistence.*;
 import kr.dgucaps.caps.domain.common.entity.BaseTimeEntity;
 import kr.dgucaps.caps.domain.wiki.entity.Wiki;
-import kr.dgucaps.caps.domain.wiki.entity.WikiHistory;
 import lombok.AccessLevel;
 import lombok.Builder;
 import lombok.Getter;
@@ -85,12 +84,9 @@ public Member(String kakaoId, String name, String email, String phoneNumber, Str
         this.isDeleted = false;
     }
 
-    @OneToMany(mappedBy = "member")
+    @OneToMany(mappedBy = "editor")
     List<Wiki> wikis = new ArrayList<>();
 
-    @OneToMany(mappedBy = "member")
-    List<WikiHistory> wikiHistories = new ArrayList<>();
-
     public void completeRegistration(String studentNumber, float grade) {
         this.studentNumber = studentNumber;
         this.grade = grade;

src/main/java/kr/dgucaps/caps/domain/wiki/controller/WikiApi.java

@@ -21,27 +21,17 @@
 public interface WikiApi {
 
     @Operation(
-            summary = "위키 작성",
-            description = "위키를 작성합니다."
+            summary = "위키 작성 & 수정",
+            description = "위키를 작성하거나 수정합니다.  \n" +
+                    "title이 존재하지 않으면 새로 작성하고, 존재하면 수정합니다."
     )
-    @ApiResponse(responseCode = "200", description = "위키 작성 성공",
+    @ApiResponse(responseCode = "200", description = "위키 작성/수정 성공",
             content = @Content(mediaType = "application/json",
                     schema = @Schema(implementation = WikiResponse.class))
     )
     ResponseEntity<SuccessResponse<?>> createWiki(@AuthenticationPrincipal Long memberId,
                                                   @Valid @RequestBody CreateOrModifyWikiRequest request);
 
-    @Operation(
-            summary = "위키 수정",
-            description = "위키를 수정합니다."
-    )
-    @ApiResponse(responseCode = "200", description = "위키 수정 성공",
-            content = @Content(mediaType = "application/json",
-                    schema = @Schema(implementation = WikiResponse.class))
-    )
-    ResponseEntity<SuccessResponse<?>> modifyWiki(@AuthenticationPrincipal Long memberId,
-                                                  @Valid @RequestBody CreateOrModifyWikiRequest request);
-
     @Operation(
             summary = "위키 조회",
             description = "title에 해당하는 위키를 조회합니다."

src/main/java/kr/dgucaps/caps/domain/wiki/controller/WikiController.java

@@ -21,14 +21,7 @@ public class WikiController implements WikiApi {
     @PostMapping
     public ResponseEntity<SuccessResponse<?>> createWiki(@AuthenticationPrincipal Long memberId,
                                                          @Valid @RequestBody CreateOrModifyWikiRequest request) {
-        return SuccessResponse.ok(wikiService.createWiki(memberId, request));
-    }
-
-    @PreAuthorize("hasAnyRole('MEMBER', 'GRADUATE', 'COUNCIL', 'PRESIDENT', 'ADMIN')")
-    @PatchMapping
-    public ResponseEntity<SuccessResponse<?>> modifyWiki(@AuthenticationPrincipal Long memberId,
-                                                         @Valid @RequestBody CreateOrModifyWikiRequest request) {
-        return SuccessResponse.ok(wikiService.modifyWiki(memberId, request));
+        return SuccessResponse.ok(wikiService.createOrModifyWiki(memberId, request));
     }
 
     @GetMapping("/{title}")

src/main/java/kr/dgucaps/caps/domain/wiki/dto/request/CreateOrModifyWikiRequest.java

@@ -10,7 +10,7 @@ public record CreateOrModifyWikiRequest(
 ) {
     public Wiki toEntity(Member member) {
         return Wiki.builder()
-                .member(member)
+                .editor(member)
                 .title(title)
                 .content(content)
                 .build();

src/main/java/kr/dgucaps/caps/domain/wiki/dto/response/WikiResponse.java

@@ -2,7 +2,6 @@
 
 import kr.dgucaps.caps.domain.dto.MemberSummary;
 import kr.dgucaps.caps.domain.wiki.entity.Wiki;
-import kr.dgucaps.caps.domain.wiki.entity.WikiHistory;
 import lombok.Builder;
 
 import java.time.LocalDateTime;
@@ -11,27 +10,15 @@
 public record WikiResponse(
         String title,
         String content,
-        MemberSummary member,
-        LocalDateTime createdAt,
-        LocalDateTime updatedAt
+        MemberSummary editor,
+        LocalDateTime createdAt
 ) {
     public static WikiResponse from(Wiki wiki) {
         return WikiResponse.builder()
                 .title(wiki.getTitle())
                 .content(wiki.getContent())
-                .member(MemberSummary.from(wiki.getMember()))
+                .editor(MemberSummary.from(wiki.getEditor()))
                 .createdAt(wiki.getCreatedAt())
-                .updatedAt(wiki.getUpdatedAt())
-                .build();
-    }
-
-    public static WikiResponse from(WikiHistory wikiHistory) {
-        return WikiResponse.builder()
-                .title(wikiHistory.getTitle())
-                .content(wikiHistory.getContent())
-                .member(MemberSummary.from(wikiHistory.getMember()))
-                .createdAt(wikiHistory.getCreatedAt())
-                .updatedAt(wikiHistory.getUpdatedAt())
                 .build();
     }
 }

src/main/java/kr/dgucaps/caps/domain/wiki/entity/Wiki.java

@@ -7,43 +7,39 @@
 import lombok.Builder;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
-
-import java.util.ArrayList;
-import java.util.List;
+import org.hibernate.annotations.ColumnDefault;
+import org.hibernate.annotations.SQLDelete;
 
 @Entity
 @Getter
 @Table(name = "wiki")
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
+@SQLDelete(sql = "UPDATE wiki SET is_deleted = true WHERE id = ?")
 public class Wiki extends BaseTimeEntity {
 
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
 
     @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "member_id", nullable = false)
-    private Member member;
+    @JoinColumn(name = "editor_id", nullable = false)
+    private Member editor;
 
     @Column(nullable = false)
     private String title;
 
     @Column(nullable = false, columnDefinition = "TEXT")
     private String content;
 
-    @Builder
-    public Wiki(Member member, String title, String content) {
-        this.member = member;
-        this.title = title;
-        this.content = content;
-    }
-
-    @OneToMany(mappedBy = "wiki")
-    private List<WikiHistory> wikiHistories = new ArrayList<>();
+    @Column(nullable = false)
+    @ColumnDefault("false")
+    private boolean isDeleted;
 
-    public void updateWiki(Member member, String title, String content) {
-        this.member = member;
+    @Builder
+    public Wiki(Member editor, String title, String content) {
+        this.editor = editor;
         this.title = title;
         this.content = content;
+        this.isDeleted = false;
     }
 }

src/main/java/kr/dgucaps/caps/domain/wiki/entity/WikiHistory.java

@@ -1,7 +1,6 @@
 package kr.dgucaps.caps.domain.wiki.repository;
 
 import kr.dgucaps.caps.domain.wiki.entity.Wiki;
-import org.springframework.data.jpa.repository.EntityGraph;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.stereotype.Repository;
@@ -12,13 +11,18 @@
 @Repository
 public interface WikiRepository extends JpaRepository<Wiki, Long> {
 
-    @EntityGraph(attributePaths = {"member"})
-    Optional<Wiki> findByTitle(String title);
+    boolean existsByTitleAndIsDeletedFalse(String title);
 
-    @Query("SELECT w FROM Wiki w ORDER BY RAND() LIMIT 1")
+    void deleteByTitleAndIsDeletedFalse(String title);
+
+    Optional<Wiki> findByTitleAndIsDeletedFalse(String title);
+
+    List<Wiki> findByTitleOrderByCreatedAtDesc(String title);
+
+    @Query("SELECT w FROM Wiki w WHERE w.isDeleted = false ORDER BY RAND() LIMIT 1")
     Optional<Wiki> findRandomWiki();
 
-    List<Wiki> findFirst10ByOrderByUpdatedAtDesc();
+    List<Wiki> findFirst10ByIsDeletedFalseOrderByCreatedAtDesc();
 
     @Query("SELECT w.title FROM Wiki w WHERE w.isDeleted = false")
     List<String> findAllTitle();

src/main/java/kr/dgucaps/caps/domain/wiki/repository/WikiHistoryRepository.java

@@ -8,8 +8,6 @@
 import kr.dgucaps.caps.domain.wiki.dto.response.WikiResponse;
 import kr.dgucaps.caps.domain.wiki.dto.response.WikiTitleResponse;
 import kr.dgucaps.caps.domain.wiki.entity.Wiki;
-import kr.dgucaps.caps.domain.wiki.entity.WikiHistory;
-import kr.dgucaps.caps.domain.wiki.repository.WikiHistoryRepository;
 import kr.dgucaps.caps.domain.wiki.repository.WikiRepository;
 import kr.dgucaps.caps.global.error.ErrorCode;
 import kr.dgucaps.caps.global.error.exception.EntityNotFoundException;
@@ -31,43 +29,27 @@ public class WikiService {
     private final WikiRepository wikiRepository;
     private final MemberRepository memberRepository;
     private final AutocompleteService autocompleteService;
-    private final WikiHistoryRepository wikiHistoryRepository;
 
     @Transactional
-    public WikiResponse createWiki(Long memberId, CreateOrModifyWikiRequest request) {
+    public WikiResponse createOrModifyWiki(Long memberId, CreateOrModifyWikiRequest request) {
+        if (wikiRepository.existsByTitleAndIsDeletedFalse(request.title())) {
+            wikiRepository.deleteByTitleAndIsDeletedFalse(request.title());
+        }
         Member member = memberRepository.findById(memberId)
                 .orElseThrow(() -> new EntityNotFoundException(ErrorCode.MEMBER_NOT_FOUND));
         Wiki savedWiki = wikiRepository.save(request.toEntity(member));
         return WikiResponse.from(savedWiki);
     }
 
-    @Transactional
-    public WikiResponse modifyWiki(Long memberId, CreateOrModifyWikiRequest request) {
-        Member member = memberRepository.findById(memberId)
-                .orElseThrow(() -> new EntityNotFoundException(ErrorCode.MEMBER_NOT_FOUND));
-        Wiki wiki = wikiRepository.findByTitle(request.title())
-                .orElseThrow(() -> new EntityNotFoundException(ErrorCode.WIKI_NOT_FOUND));
-        WikiHistory wikiHistory = WikiHistory.builder()
-                .wiki(wiki)
-                .member(wiki.getMember())
-                .title(wiki.getTitle())
-                .content(wiki.getContent())
-                .build();
-        wikiHistoryRepository.save(wikiHistory);
-        wiki.updateWiki(member, request.title(), request.content());
-        Wiki updatedWiki = wikiRepository.save(wiki);
-        return WikiResponse.from(updatedWiki);
-    }
-
     public WikiResponse getWiki(String title) {
-        Wiki wiki = wikiRepository.findByTitle(title)
+        Wiki wiki = wikiRepository.findByTitleAndIsDeletedFalse(title)
                 .orElseThrow(() -> new EntityNotFoundException(ErrorCode.WIKI_NOT_FOUND));
         return WikiResponse.from(wiki);
     }
 
     public List<WikiResponse> getWikiHistory(String title) {
-        List<WikiHistory> wikiHistories = wikiHistoryRepository.findByTitleOrderByCreatedAtDesc(title);
-        return wikiHistories.stream()
+        List<Wiki> wikiHistory = wikiRepository.findByTitleOrderByCreatedAtDesc(title);
+        return wikiHistory.stream()
                 .map(WikiResponse::from)
                 .collect(Collectors.toList());
     }
@@ -79,7 +61,7 @@ public WikiResponse getRandomWiki() {
     }
 
     public List<WikiTitleResponse> getRecentWiki() {
-        List<Wiki> recentWikis = wikiRepository.findFirst10ByOrderByUpdatedAtDesc();
+        List<Wiki> recentWikis = wikiRepository.findFirst10ByIsDeletedFalseOrderByCreatedAtDesc();
         return recentWikis.stream()
                 .map(WikiTitleResponse::from)
                 .collect(Collectors.toList());