Develop pull request to main

build.gradle

@@ -24,6 +24,7 @@ repositories {
 }
 
 dependencies {
+	implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.0.2'
 	implementation 'javax.annotation:javax.annotation-api:1.3.2'
 	implementation 'javax.servlet:javax.servlet-api:4.0.1'
 	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

src/main/java/codeview/main/auth/handler/OAuth2SuccessHandler.java

@@ -28,13 +28,20 @@ public void onAuthenticationSuccess(HttpServletRequest request, HttpServletRespo
         String accessToken = tokenProvider.generateAccessToken(authentication);
         String refreshToken = tokenProvider.generateRefreshToken(authentication, accessToken);
 
-        // JSON 형태로 응답
-        Map<String, String> tokens = new HashMap<>();
-        tokens.put("accessToken", accessToken);
-        tokens.put("refreshToken", refreshToken);
-
-        response.setContentType("application/json");
-        response.setCharacterEncoding("UTF-8");
-        response.getWriter().write(objectMapper.writeValueAsString(tokens));
+
+        String redirectUrl = request.getParameter("redirect");
+
+
+        if (redirectUrl == null || redirectUrl.isEmpty()) {
+            redirectUrl = "http://localhost:3000";
+        }
+
+
+        String redirectWithTokens = String.format("%s/auth/token?accessToken=%s&refreshToken=%s",
+                redirectUrl, accessToken, refreshToken);
+
+
+        response.sendRedirect(redirectWithTokens);
     }
 }
+

src/main/java/codeview/main/config/CustomRequestFilter.java

@@ -10,7 +10,7 @@
 import java.io.IOException;
 
 @Component
-public class CustomRequestFilter extends OncePerRequestFilter {
+public class  CustomRequestFilter extends OncePerRequestFilter {
 
     @Override
     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)

src/main/java/codeview/main/config/SecurityConfig.java

@@ -49,6 +49,12 @@ public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Excepti
                 .headers(c -> c.frameOptions(HeadersConfigurer.FrameOptionsConfig::disable).disable())
                 .sessionManagement(c -> c.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
                 .authorizeHttpRequests(request -> request.requestMatchers(
+                                new AntPathRequestMatcher("/swagger"),
+                                new AntPathRequestMatcher("/swagger-ui.html"),
+                                new AntPathRequestMatcher("/swagger-ui/**"),
+                                new AntPathRequestMatcher("/api-docs"),
+                                new AntPathRequestMatcher("/api-docs/**"),
+                                new AntPathRequestMatcher("/v3/api-docs/**"),
                                 new AntPathRequestMatcher("/"),
                                 new AntPathRequestMatcher("/home"),
                                 new AntPathRequestMatcher("/login"),
@@ -81,4 +87,4 @@ public CorsConfigurationSource corsConfigurationSource() {
         source.registerCorsConfiguration("/**", config);
         return source;
     }
-}
+}

src/main/java/codeview/main/config/SwaggerConfig.java

@@ -0,0 +1,39 @@
+package codeview.main.config;
+
+
+import io.swagger.v3.oas.models.Components;
+import io.swagger.v3.oas.models.OpenAPI;
+import io.swagger.v3.oas.models.info.Info;
+import io.swagger.v3.oas.models.security.SecurityRequirement;
+import io.swagger.v3.oas.models.security.SecurityScheme;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class SwaggerConfig {
+    private static final String BEARER_TOKEN_PREFIX = "Bearer";
+
+    @Bean
+    public OpenAPI openAPI(){
+
+        Components components = new Components()
+                .addSecuritySchemes("Authorization", new SecurityScheme()
+                        .type(SecurityScheme.Type.HTTP)
+                        .scheme("bearer")
+                        .bearerFormat("JWT"));
+
+
+        Info info = new Info()
+                .version("v1.0.0")
+                .title("codeView API");
+
+
+
+        return new OpenAPI()
+                .addSecurityItem(new SecurityRequirement().addList("Authorization"))
+                .components(components)
+                .info(info);
+
+    }
+
+}

src/main/java/codeview/main/controller/BlogController.java

@@ -0,0 +1,49 @@
+package codeview.main.controller;
+
+
+import codeview.main.dto.blog.BlogReqDto;
+import codeview.main.dto.blog.BlogResDto;
+import codeview.main.global.ApiResponse;
+import codeview.main.service.BlogService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/blog")
+public class BlogController {
+    private final BlogService blogService;
+
+    @PostMapping
+    public ApiResponse<BlogResDto> createBlog(Long userId, BlogReqDto blogReqDto){
+        BlogResDto blogResDto = new BlogResDto(blogService.createBlog(userId, blogReqDto));
+        return ApiResponse.createResponse("S100", "SUCCESS", blogResDto);
+    }
+
+    @GetMapping
+    public ApiResponse<List<BlogResDto>> getBlogList(Long userId) {
+        List<BlogResDto> blogResDtoList = blogService.getBlogList(userId).stream().map(BlogResDto::new).toList();
+        return ApiResponse.createResponse("S101", "SUCCESS", blogResDtoList);
+    }
+
+    @GetMapping("/{id}")
+    public ApiResponse<BlogResDto> getBlog(@PathVariable Long id) {
+        BlogResDto blogResDto = new BlogResDto(blogService.getBlog(id));
+        return ApiResponse.createResponse("S101", "SUCCESS", blogResDto);
+    }
+
+    @PutMapping("/{id}")
+    public ApiResponse<BlogResDto> updateBlog(Long userId, @PathVariable Long id, BlogReqDto blogReqDto) {
+        BlogResDto blogResDto = new BlogResDto(blogService.updateBlog(userId, id, blogReqDto));
+        return ApiResponse.createResponse("S102", "SUCCESS", blogResDto);
+    }
+
+    @DeleteMapping("/{id}")
+    public ApiResponse<Void> deleteBlog(Long userId, @PathVariable Long id) {
+        blogService.deleteBlog(userId, id);
+        return ApiResponse.createResponse("S103", "SUCCESS", null);
+    }
+}

src/main/java/codeview/main/controller/BoardController.java

@@ -1,71 +1,51 @@
 package codeview.main.controller;
 
-import codeview.main.dto.ApiResponse;
-import codeview.main.dto.BoardRequest;
-import codeview.main.dto.BoardResponse;
-import codeview.main.entity.Board;
+import codeview.main.global.ApiResponse;
+import codeview.main.dto.board.BoardReqDto;
+import codeview.main.dto.board.BoardResDto;
 import codeview.main.service.BoardService;
 import lombok.RequiredArgsConstructor;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
-import java.util.List;
-import java.util.Optional;
+
 
 @RestController
 @RequiredArgsConstructor
-@RequestMapping("/board")
+@RequestMapping("/{blogId}/board")
 public class BoardController {
     private final BoardService boardService;
 
-    @GetMapping("/{id}")
-    public ResponseEntity<BoardResponse> getBoardById(@PathVariable Long id) {
-        Optional<Board> findBoardObj = boardService.findBoardById(id);
-        if (findBoardObj.isPresent()) {
-            BoardResponse response = new BoardResponse(findBoardObj.get());
-            return ResponseEntity.ok(response);
-        } else {
-            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(null);
-        }
-    }
 
-    @GetMapping
-    public ResponseEntity<List<BoardResponse>> getAllBoards() {
-        List<BoardResponse> boardResponses = boardService.findAll();
-        return ResponseEntity.ok(boardResponses);
+    @PostMapping
+    public ApiResponse<BoardResDto> createBoard(Long userId, @PathVariable Long blogId, @RequestBody BoardReqDto boardReqDto) {
+        BoardResDto boardResponse = new BoardResDto(boardService.createBoard(userId, blogId, boardReqDto));
+        return ApiResponse.createResponse("S100", "Board Write Success", boardResponse);
     }
 
-    @PostMapping("/write")
-    public ResponseEntity<ApiResponse<BoardResponse>> boardSave(@RequestBody BoardRequest boardRequest) {
-        Board saveBoard = new Board(boardRequest.getTitle());
-        Board savedBoard = boardService.save(saveBoard);
-        BoardResponse boardResponse = new BoardResponse(savedBoard);
-        ApiResponse<BoardResponse> response = new ApiResponse<>(HttpStatus.CREATED, "Board Write Success", boardResponse);
-        return ResponseEntity.status(HttpStatus.CREATED).body(response);
+
+    @GetMapping
+    public ApiResponse<BoardResDto> getBoardById(@RequestParam("boardId") Long boardId) {
+        BoardResDto boardResDto = new BoardResDto(boardService.getBoard(boardId));
+        return ApiResponse.createResponse("S101", "Success create board", boardResDto);
     }
 
-    @PutMapping("/{id}")
-    public ResponseEntity<BoardResponse> updateBoard(@PathVariable Long id, @RequestBody BoardRequest boardRequest) {
-        Board updatedBoard = new Board();
-        updatedBoard.setTitle(boardRequest.getTitle());
 
-        try {
-            Board savedBoard = boardService.updateBoard(id, updatedBoard);
-            BoardResponse responseDto = new BoardResponse(savedBoard);
-            return ResponseEntity.ok(responseDto);
-        } catch (RuntimeException e) {
-            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(null);
-        }
+    @PutMapping
+    public ApiResponse<Void> updateBoard(
+            Long userId,
+            @PathVariable Long blogId,
+            @RequestParam("boardId") Long boardId,
+            @RequestBody BoardReqDto boardReqDto) {
+        boardService.updateBoard(userId, blogId, boardId, boardReqDto);
+        return ApiResponse.createResponse("S102", "Success update board");
     }
 
     @DeleteMapping("/{id}")
-    public ResponseEntity<Void> deleteBoard(@PathVariable Long id) {
-        try {
-            boardService.deleteBoard(id);
-            return ResponseEntity.noContent().build();
-        } catch (RuntimeException e) {
-            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
-        }
+    public ApiResponse<Void> deleteBoard(
+            Long userId,
+            @PathVariable Long blogId
+    ) {
+        boardService.deleteBoard(userId, blogId);
+        return ApiResponse.createResponse("S103", "Success delete board");
     }
 }

src/main/java/codeview/main/dto/blog/BlogReqDto.java

@@ -0,0 +1,8 @@
+package codeview.main.dto.blog;
+
+import lombok.Getter;
+
+@Getter
+public class BlogReqDto {
+    private String name;
+}

src/main/java/codeview/main/dto/blog/BlogResDto.java

@@ -0,0 +1,15 @@
+package codeview.main.dto.blog;
+
+import codeview.main.entity.Blog;
+import lombok.Getter;
+
+@Getter
+public class BlogResDto {
+
+
+    public BlogResDto(Blog blog) {
+        if (blog != null) {
+
+        }
+    }
+}

src/main/java/codeview/main/dto/board/BoardReqDto.java

@@ -0,0 +1,9 @@
+package codeview.main.dto.board;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+public class BoardReqDto {
+    private String title;
+    private String content;
+}

src/main/java/codeview/main/dto/BoardResponse.java → src/main/java/codeview/main/dto/board/BoardResDto.java

@@ -1,16 +1,16 @@
-package codeview.main.dto;
+package codeview.main.dto.board;
 
 import codeview.main.entity.Board;
 import lombok.Getter;
 import lombok.Setter;
 
 @Getter
 @Setter
-public class BoardResponse {
+public class BoardResDto {
     private Long id;
     private String title;
 
-    public BoardResponse(Board board) {
+    public BoardResDto(Board board) {
         this.id = board.getId();
         this.title = board.getTitle();
     }

src/main/java/codeview/main/entity/Blog.java

@@ -0,0 +1,49 @@
+package codeview.main.entity;
+
+import codeview.main.dto.blog.BlogReqDto;
+import codeview.main.dto.blog.BlogResDto;
+import codeview.main.dto.board.BoardReqDto;
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Getter
+@Entity
+@NoArgsConstructor
+public class Blog {
+    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+    private String name;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name="user_id")
+    private User user;
+
+    @OneToMany(mappedBy = "blog", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<Board> boardList = new ArrayList<>();
+
+    public Blog(BlogReqDto blogReqDto) {
+        this.name = blogReqDto.getName();
+    }
+
+    public void update(BlogReqDto blogReqDto) {
+        if (blogReqDto != null) {
+            this.name = blogReqDto.getName();
+        }
+    }
+    public void addUser(User user) {
+        this.user = user;
+    }
+
+    public void addBoard(Board board) {
+        boardList.add(board);
+        board.addBlog(this);
+    }
+    public void removeBoard(Board board) {
+        boardList.remove(board);
+        board.addBlog(null);
+    }
+}