Artscope 3.1.4 릴리즈

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,14 @@
+## 📝 작업 내용
+> 이번 PR에서 작업한 내용을 간단하게 설명해주세요.
+>
+> 고민한 내용이나, 문제를 어떻게 해결했는지 작성해주는것도 좋습니다.
+> 
+> ![이미지 첨부하면 더 좋아요]()
+
+## 🦾 연관된 이슈
+> ex) JIRA링크, #이슈번호
+
+## 💬리뷰 요구사항
+> 리뷰어가 특별히 봐주었으면 하는 부분이 있다면 작성해주세요
+>
+> ex) 메서드 XXX의 이름을 더 잘 짓고 싶은데 혹시 좋은 명칭이 있을까요?

.github/workflows/test.yaml

@@ -55,6 +55,8 @@ jobs:
 
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v3.1.1
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
 
       - name: Cleanup Gradle Cache
         if: ${{ always() }}

src/main/java/com/example/codebase/annotation/CheckDuplicatedRequest.java

@@ -0,0 +1,14 @@
+package com.example.codebase.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface CheckDuplicatedRequest {
+    String target() default "";
+
+    int aliveMillisecondTime() default 3000;
+}

src/main/java/com/example/codebase/aop/CheckDuplicatedRequestAspect.java

@@ -0,0 +1,60 @@
+package com.example.codebase.aop;
+
+import com.example.codebase.annotation.CheckDuplicatedRequest;
+import com.example.codebase.annotation.LoginOnly;
+import com.example.codebase.annotation.UserAdminOnly;
+import com.example.codebase.annotation.UserOnly;
+import com.example.codebase.exception.DuplicatedRequestException;
+import com.example.codebase.exception.LoginRequiredException;
+import com.example.codebase.util.RedisUtil;
+import com.example.codebase.util.SecurityUtil;
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Before;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Component;
+
+import java.lang.reflect.Method;
+import java.time.LocalDateTime;
+
+@Aspect
+@Component
+@Profile("!test")
+public class CheckDuplicatedRequestAspect {
+
+    private final RedisUtil redisUtil;
+
+    @Autowired
+    protected CheckDuplicatedRequestAspect(RedisUtil redisUtil) {
+        this.redisUtil = redisUtil;
+    }
+
+    @Before("@annotation(com.example.codebase.annotation.CheckDuplicatedRequest)")
+    public void checkDuplicateRequest(JoinPoint joinPoint) {
+        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
+        Method method = signature.getMethod();
+        CheckDuplicatedRequest annotation = method.getAnnotation(CheckDuplicatedRequest.class);
+
+        if (!isValidAnnotation(method)) return;
+
+        String key = SecurityUtil.getCurrentUsername().orElseThrow(LoginRequiredException::new);
+
+        if (key.isEmpty()) return;
+
+        String target = annotation.target().isEmpty() ? String.valueOf(method) : annotation.target();
+
+        String uniqueKey = key + "->" + target;
+        if (redisUtil.getData(uniqueKey).isPresent()) {
+            throw new DuplicatedRequestException();
+        }
+        redisUtil.setDataAndExpire(uniqueKey, String.valueOf(LocalDateTime.now()), annotation.aliveMillisecondTime());
+    }
+
+    private boolean isValidAnnotation(Method method) {
+        return method.isAnnotationPresent(LoginOnly.class)
+                || method.isAnnotationPresent(UserOnly.class)
+                || method.isAnnotationPresent(UserAdminOnly.class);
+    }
+}

src/main/java/com/example/codebase/controller/AuthController.java

@@ -1,23 +1,32 @@
 package com.example.codebase.controller;
 
+import static com.example.codebase.util.SecurityUtil.getCookieAccessTokenValue;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
 import com.example.codebase.domain.auth.dto.LoginDTO;
 import com.example.codebase.domain.auth.dto.TokenResponseDTO;
 import com.example.codebase.domain.auth.service.AuthService;
+import com.example.codebase.domain.member.dto.MemberResponseDTO;
+import com.example.codebase.domain.member.service.MemberService;
 import com.example.codebase.jwt.TokenProvider;
+import com.example.codebase.util.SecurityUtil;
+
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
 import io.swagger.v3.oas.annotations.responses.ApiResponses;
 import io.swagger.v3.oas.annotations.tags.Tag;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
-import org.springframework.security.access.prepost.PreAuthorize;
-import org.springframework.security.core.context.SecurityContextHolder;
-import org.springframework.web.bind.annotation.*;
-
 import jakarta.validation.Valid;
 
-import static com.example.codebase.util.SecurityUtil.getCookieAccessTokenValue;
-
 @Tag(name = "Auth", description = "인증 API")
 @RestController
 @RequestMapping("/api")
@@ -27,9 +36,12 @@ public class AuthController {
 
     private final AuthService authService;
 
-    public AuthController(TokenProvider tokenProvider, AuthService authService) {
+    private final MemberService memberService;
+
+    public AuthController(TokenProvider tokenProvider, AuthService authService, MemberService memberService) {
         this.tokenProvider = tokenProvider;
         this.authService = authService;
+        this.memberService = memberService;
     }
 
     @Operation(summary = "로그인", description = "로그인")
@@ -39,8 +51,8 @@ public ResponseEntity login(@Valid @RequestBody LoginDTO loginDTO) {
 
         // Set Cookie
         return ResponseEntity.ok()
-            .header("Set-Cookie", getCookieAccessTokenValue(responseDTO))
-            .body(responseDTO);
+                .header("Set-Cookie", getCookieAccessTokenValue(responseDTO))
+                .body(responseDTO);
     }
 
     @Operation(summary = "로그아웃", description = "로그아웃")
@@ -57,20 +69,29 @@ public ResponseEntity logout() {
     public ResponseEntity refresh(@RequestBody String refreshToken) {
         TokenResponseDTO responseDTO = tokenProvider.regenerateToken(refreshToken);
         return ResponseEntity.ok()
-            .header("Set-Cookie", getCookieAccessTokenValue(responseDTO))
-            .body(responseDTO);
+                .header("Set-Cookie", getCookieAccessTokenValue(responseDTO))
+                .body(responseDTO);
     }
 
     @Operation(summary = "이메일 인증", description = "이메일 인증")
     @ApiResponses({
-        @ApiResponse(responseCode = "200", description = "이메일 인증 성공"),
-        @ApiResponse(responseCode = "400", description = "이메일 인증 실패")
+            @ApiResponse(responseCode = "200", description = "이메일 인증 성공"),
+            @ApiResponse(responseCode = "400", description = "이메일 인증 실패")
     })
     @PreAuthorize("permitAll()")
     @GetMapping("/mail/authenticate")
     public ResponseEntity authenticateMailLink(
-        @RequestParam String code) {
+            @RequestParam String code) {
         authService.authenticateMail(code);
         return new ResponseEntity("이메일 인증되었습니다.", HttpStatus.OK);
     }
-}
+
+    @Operation(summary = "내 프로필 조회", description = "[USER] 내 프로필을 조회합니다.")
+    @PreAuthorize("isAuthenticated() and hasAnyRole('ROLE_USER')")
+    @GetMapping("/auth/me")
+    public ResponseEntity getProfile() {
+        String username = SecurityUtil.getCurrentUsernameValue();
+        MemberResponseDTO member = memberService.getProfile(username);
+        return new ResponseEntity(member, HttpStatus.OK);
+    }
+}

src/main/java/com/example/codebase/controller/FollowController.java

@@ -1,13 +1,19 @@
 package com.example.codebase.controller;
 
-import com.example.codebase.domain.follow.dto.FollowMembersResponseDTO;
+import com.example.codebase.domain.follow.dto.FollowRequest;
+import com.example.codebase.domain.follow.dto.FollowResponseDTO;
 import com.example.codebase.domain.follow.service.FollowService;
 import com.example.codebase.domain.notification.entity.NotificationType;
 import com.example.codebase.domain.notification.service.NotificationSendService;
 import com.example.codebase.exception.LoginRequiredException;
 import com.example.codebase.util.SecurityUtil;
 import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
 import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.Pattern;
 import jakarta.validation.constraints.PositiveOrZero;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.PageRequest;
@@ -35,49 +41,87 @@ public FollowController(FollowService followService, NotificationSendService not
         this.notificationService = notificationService;
     }
 
-    @Operation(summary = "팔로우", description = "상대방을 팔로잉 합니다")
+    @Operation(summary = "팔로우/언팔로우", description = "상대방을 팔로우/언팔로우 합니다.",
+            parameters = @Parameter(name = "action", description = "follow: 팔로우, unfollow: 언팔로우", required = true, example = "follow"),
+            requestBody = @io.swagger.v3.oas.annotations.parameters.RequestBody(
+                    description = "팔로우할 대상 URN", required = true, content = @io.swagger.v3.oas.annotations.media.Content(
+                    schema = @io.swagger.v3.oas.annotations.media.Schema(implementation = FollowRequest.Create.class),
+                    examples = @io.swagger.v3.oas.annotations.media.ExampleObject(value = "{\"urn\": \"urn:member:admin\"}"))
+            )
+    )
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "201", description = "팔로우 성공"),
+            @ApiResponse(responseCode = "200", description = "언팔로우 성공")
+    })
     @PreAuthorize("isAuthenticated() and hasAnyRole('ROLE_USER', 'ROLE_ADMIN')")
-    @PostMapping("{username}")
-    public ResponseEntity followMember(@PathVariable("username") String followUser) {
+    @PostMapping
+    public ResponseEntity follow(
+            @RequestParam("action") @Pattern(regexp = "follow|unfollow", message = "잘못된 action 값입니다.") String action,
+            @RequestBody @Valid FollowRequest.Create request
+    ) {
         String username = SecurityUtil.getCurrentUsername().orElseThrow(LoginRequiredException::new);
-        followService.followMember(username, followUser);
-        notificationService.send(username, followUser, NotificationType.NEW_FOLLOWER);
+        FollowRequest.FollowEntityUrn entityUrn = FollowRequest.FollowEntityUrn.from(request.getUrn());
 
-        return new ResponseEntity("팔로잉 했습니다.", HttpStatus.CREATED);
+        if (action.equals("unfollow")) {
+            return unfollow(username, entityUrn);
+        }
+        return follow(username, entityUrn);
     }
 
-    @Operation(summary = "언팔로우" , description = "상대방을 언 팔로잉 합니다")
-    @PreAuthorize("isAuthenticated() and hasAnyRole('ROLE_USER', 'ROLE_ADMIN')")
-    @DeleteMapping("{username}")
-    public ResponseEntity unfollowMember(@PathVariable("username") String followUser) {
-        String username = SecurityUtil.getCurrentUsername().orElseThrow(LoginRequiredException::new);
-        followService.unfollowMember(username, followUser);
+    private ResponseEntity follow(String username, FollowRequest.FollowEntityUrn entityUrn) {
+        switch (entityUrn) {
+            case MEMBER -> {
+                checkSameMember(username, entityUrn.getId(), "팔로우");
+                followService.followMember(username, entityUrn.getId());
+                notificationService.send(username, entityUrn.getId(), NotificationType.NEW_FOLLOWER);
+            }
+            case TEAM -> {
+                followService.followTeam(username, entityUrn.getId());
+            }
+        }
+        return new ResponseEntity("팔로잉 했습니다.", HttpStatus.CREATED);
+    }
 
-        return new ResponseEntity("언팔로잉 했습니다.", HttpStatus.NO_CONTENT);
+    private ResponseEntity unfollow(String username, FollowRequest.FollowEntityUrn entityUrn) {
+        switch (entityUrn) {
+            case MEMBER -> {
+                checkSameMember(username, entityUrn.getId(), "언팔로우");
+                followService.unfollowMember(username, entityUrn.getId());
+            }
+            case TEAM -> {
+                followService.unfollowTeam(username, entityUrn.getId());
+            }
+        }
+        return new ResponseEntity("언팔로잉 했습니다.", HttpStatus.OK);
     }
 
+    private void checkSameMember(String username1, String username2, String message) {
+        if (username1.equals(username2)) {
+            throw new RuntimeException("자기 자신을 %s 할 수 없습니다".formatted(message));
+        }
+    }
 
-    @Operation(summary = "팔로잉", description = "해당 유저가 팔로잉 하는 사람 목록을 조회 합니다")
+    @Operation(summary = "팔로잉 조회", description = "해당 유저가 팔로잉 하는 사람 목록을 조회 합니다")
     @GetMapping("/{username}/following")
     public ResponseEntity getFollowingList(@PathVariable("username") String username,
                                            @PositiveOrZero @RequestParam(defaultValue = "0") int page,
                                            @PositiveOrZero @RequestParam(defaultValue = "10") int size) {
         Optional<String> loginUsername = SecurityUtil.getCurrentUsername();
         PageRequest pageRequest = PageRequest.of(page, size);
-        FollowMembersResponseDTO followingListResponse = followService.getFollowingList(loginUsername, username, pageRequest);
+        FollowResponseDTO followingListResponse = followService.getFollowingList(loginUsername, username, pageRequest);
 
         return new ResponseEntity(followingListResponse, HttpStatus.OK);
     }
 
 
-    @Operation(summary = "팔로워", description = "해당 유저를 팔로워 하는 사람 목록을 조회 합니다")
+    @Operation(summary = "팔로워 조회", description = "해당 유저를 팔로워 하는 사람 목록을 조회 합니다")
     @GetMapping("{username}/follower")
     public ResponseEntity getFollowerList(@PathVariable("username") String username,
                                           @PositiveOrZero @RequestParam(defaultValue = "0") int page,
                                           @PositiveOrZero @RequestParam(defaultValue = "10") int size) {
         Optional<String> loginUsername = SecurityUtil.getCurrentUsername();
         PageRequest pageRequest = PageRequest.of(page, size);
-        FollowMembersResponseDTO followingListResponse = followService.getFollowerList(loginUsername, username, pageRequest);
+        FollowResponseDTO followingListResponse = followService.getFollowerList(loginUsername, username, pageRequest);
 
         return new ResponseEntity(followingListResponse, HttpStatus.OK);
     }

src/main/java/com/example/codebase/controller/MagazineCategoryController.java

@@ -2,15 +2,14 @@
 
 
 import com.example.codebase.annotation.AdminOnly;
+import com.example.codebase.domain.magazine.dto.MagazineCategoryRequest;
 import com.example.codebase.domain.magazine.dto.MagazineCategoryResponse;
 import com.example.codebase.domain.magazine.service.MagazineCategoryService;
 import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.*;
 
 @Tag(name = "매거진 카테고리 API", description = "매거진 카테고리 관련 API")
 @RestController
@@ -25,15 +24,35 @@ public MagazineCategoryController(MagazineCategoryService magazineCategoryServic
 
     @PostMapping
     @AdminOnly
-    public ResponseEntity createCategory(String name) {
-        MagazineCategoryResponse.Get category = magazineCategoryService.createCategory(name);
+    public ResponseEntity createCategory(@RequestBody @Valid MagazineCategoryRequest.Create request) {
+        MagazineCategoryResponse.Create category = magazineCategoryService.createCategory(request);
         return new ResponseEntity(category, HttpStatus.CREATED);
     }
 
     @GetMapping
-    public ResponseEntity getCategories() {
+    public ResponseEntity getAllCategories() {
         MagazineCategoryResponse.GetAll allCategory = magazineCategoryService.getAllCategory();
         return new ResponseEntity(allCategory, HttpStatus.OK);
     }
 
+    @GetMapping("/{slug}")
+    public ResponseEntity getSubCategories(@PathVariable String slug) {
+        MagazineCategoryResponse.GetAll subCategory = magazineCategoryService.getSubCategories(slug);
+        return new ResponseEntity(subCategory, HttpStatus.OK);
+    }
+
+    @DeleteMapping("/{categoryId}")
+    @AdminOnly
+    public ResponseEntity deleteCategory(@PathVariable Long categoryId) {
+        magazineCategoryService.deleteCategory(categoryId);
+        return new ResponseEntity(HttpStatus.NO_CONTENT);
+    }
+
+    @PutMapping("/{categoryId}")
+    @AdminOnly
+    public ResponseEntity updateCategory(@PathVariable Long categoryId, @RequestBody @Valid MagazineCategoryRequest.Update request) {
+        MagazineCategoryResponse.Get category = magazineCategoryService.updateCategory(categoryId, request);
+        return new ResponseEntity(category, HttpStatus.OK);
+    }
+
 }