Merge pull request #455 from TaskFlow-CLAP/release

joowojr · web-flow · commit 5edeb9ed8560 · 2025-02-10T14:40:57.000+09:00
Release-Develop 병합
diff --git a/src/main/java/clap/server/adapter/inbound/security/filter/LoginAttemptFilter.java b/src/main/java/clap/server/adapter/inbound/security/filter/LoginAttemptFilter.java
@@ -1,7 +1,6 @@
 package clap.server.adapter.inbound.security.filter;
 
 import clap.server.application.port.inbound.auth.CheckAccountLockStatusUseCase;
-import clap.server.application.service.auth.LoginAttemptService;
 import clap.server.exception.AuthException;
 import jakarta.servlet.FilterChain;
 import jakarta.servlet.ServletException;
@@ -14,8 +13,10 @@
 import org.springframework.security.core.context.SecurityContextHolder;
 import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
 import org.springframework.web.filter.OncePerRequestFilter;
+import org.springframework.web.util.ContentCachingRequestWrapper;
 
 import java.io.IOException;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 
 import static clap.server.adapter.inbound.security.WebSecurityUrl.LOGIN_ENDPOINT;
@@ -33,9 +34,8 @@ protected void doFilterInternal(HttpServletRequest request, HttpServletResponse
             throws ServletException, IOException {
         try {
             if (request.getRequestURI().equals(LOGIN_ENDPOINT)) {
-                String clientIp = getClientIp(request);
-
-                checkAccountLockStatusUseCase.checkAccountIsLocked(clientIp);
+                String nickname = request.getParameter("nickname");
+                checkAccountLockStatusUseCase.checkAccountIsLocked(nickname);
 
             }
         } catch (AuthException e) {
@@ -54,4 +54,14 @@ protected void doFilterInternal(HttpServletRequest request, HttpServletResponse
         filterChain.doFilter(request, response);
     }
 
+    private String getRequestBody(HttpServletRequest request) {
+        try {
+            ContentCachingRequestWrapper cachingRequest = (ContentCachingRequestWrapper) request;
+            byte[] content = cachingRequest.getContentAsByteArray();
+            return new String(content, StandardCharsets.UTF_8);
+        } catch (Exception e) {
+            return "요청 바디의 내용을 읽을 수 없음";
+        }
+    }
+
 }
diff --git a/src/main/java/clap/server/adapter/inbound/web/auth/AuthController.java b/src/main/java/clap/server/adapter/inbound/web/auth/AuthController.java
@@ -12,6 +12,7 @@
 import io.swagger.v3.oas.annotations.Parameter;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.servlet.http.HttpServletRequest;
+import jakarta.validation.constraints.NotBlank;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.ResponseEntity;
@@ -32,11 +33,11 @@ public class AuthController {
     @LogType(LogStatus.LOGIN)
     @Operation(summary = "로그인 API")
     @PostMapping("/login")
-    public ResponseEntity<LoginResponse> login(
+    public ResponseEntity<LoginResponse> login(@RequestParam @NotBlank String nickname,
                                                @RequestBody LoginRequest request,
                                                HttpServletRequest httpRequest) {
         String clientIp = getClientIp(httpRequest);
-        LoginResponse response = loginUsecase.login(request.nickname(), request.password(), clientIp);
+        LoginResponse response = loginUsecase.login(nickname, request.password(), clientIp);
         return ResponseEntity.ok(response);
     }
 
diff --git a/src/main/java/clap/server/adapter/inbound/web/dto/auth/request/LoginRequest.java b/src/main/java/clap/server/adapter/inbound/web/dto/auth/request/LoginRequest.java
@@ -1,11 +1,9 @@
 package clap.server.adapter.inbound.web.dto.auth.request;
 
-import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.NotBlank;
 
 public record LoginRequest(
-        @NotNull
-        String nickname,
-        @NotNull
+        @NotBlank
         String password
 ) {
 }
diff --git a/src/main/java/clap/server/adapter/outbound/infrastructure/redis/log/LoginLogAdapter.java b/src/main/java/clap/server/adapter/outbound/infrastructure/redis/log/LoginLogAdapter.java
@@ -25,7 +25,8 @@ public void deleteById(String clientIp) {
 		loginLogRepository.deleteById(clientIp);
 	}
 
-	public Optional<LoginLog> findByClientIp(String clientIp) {
-		return loginLogRepository.findById(clientIp).map(loginLogMapper::toDomain);
+	@Override
+	public Optional<LoginLog> findByNickname(String nickname) {
+		return loginLogRepository.findById(nickname).map(loginLogMapper::toDomain);
 	}
 }
diff --git a/src/main/java/clap/server/adapter/outbound/infrastructure/redis/log/LoginLogEntity.java b/src/main/java/clap/server/adapter/outbound/infrastructure/redis/log/LoginLogEntity.java
@@ -14,15 +14,15 @@
 import java.time.LocalDateTime;
 
 @Getter
-@RedisHash("loginLog")
+@RedisHash(value = "loginLog", timeToLive = 3600)
 @Builder
-@ToString(of = {"clientIp", "attemptNickname", "lastAttemptAt", "failedCount", "isLocked"})
-@EqualsAndHashCode(of = {"clientIp"})
+@ToString(of = {"nickname", "clientIp", "lastAttemptAt", "failedCount", "isLocked"})
+@EqualsAndHashCode(of = {"nickname"})
 public class LoginLogEntity {
 	@Id
-	private String clientIp;
+	private String nickname;
 
-	private String attemptNickname;
+	private String clientIp;
 
 	@JsonSerialize(using = ToStringSerializer.class)
 	@JsonDeserialize(using = LocalDateTimeDeserializer.class)
diff --git a/src/main/java/clap/server/application/port/inbound/auth/CheckAccountLockStatusUseCase.java b/src/main/java/clap/server/application/port/inbound/auth/CheckAccountLockStatusUseCase.java
@@ -1,5 +1,5 @@
 package clap.server.application.port.inbound.auth;
 
 public interface CheckAccountLockStatusUseCase {
-    void checkAccountIsLocked(String clientIp);
+    void checkAccountIsLocked(String nickname);
 }
diff --git a/src/main/java/clap/server/application/port/outbound/auth/loginLog/LoadLoginLogPort.java b/src/main/java/clap/server/application/port/outbound/auth/loginLog/LoadLoginLogPort.java
@@ -5,5 +5,5 @@
 import java.util.Optional;
 
 public interface LoadLoginLogPort {
-    Optional<LoginLog> findByClientIp(String clientIp);
+    Optional<LoginLog> findByNickname(String nickname);
 }
diff --git a/src/main/java/clap/server/application/service/auth/AuthService.java b/src/main/java/clap/server/application/service/auth/AuthService.java
@@ -46,7 +46,7 @@ public LoginResponse login(String nickname, String password, String clientIp) {
 
         CustomJwts jwtTokens = manageTokenService.issueTokens(member);
         refreshTokenService.saveRefreshToken(manageTokenService.issueRefreshToken(member.getMemberId()));
-        loginAttemptService.resetFailedAttempts(clientIp);
+        loginAttemptService.resetFailedAttempts(nickname);
         return AuthResponseMapper.toLoginResponse(jwtTokens.accessToken(), jwtTokens.refreshToken());
     }
 
@@ -71,14 +71,14 @@ private void deleteAccessToken(Long memberId, String accessToken) {
     private Member getMember(String inputNickname, String clientIp) {
         return loadMemberPort.findByNickname(inputNickname).orElseThrow(() ->
         {
-            loginAttemptService.recordFailedAttempt(clientIp, inputNickname);
+            loginAttemptService.recordFailedAttempt(inputNickname, clientIp);
             return new AuthException(AuthErrorCode.LOGIN_REQUEST_FAILED);
         });
     }
 
     private void validatePassword(String inputPassword, String encodedPassword, String inputNickname, String clientIp) {
         if (!passwordEncoder.matches(inputPassword, encodedPassword)) {
-            loginAttemptService.recordFailedAttempt(clientIp, inputNickname);
+            loginAttemptService.recordFailedAttempt(inputNickname, clientIp);
             throw new AuthException(AuthErrorCode.LOGIN_REQUEST_FAILED);
         }
     }
diff --git a/src/main/java/clap/server/application/service/auth/LoginAttemptService.java b/src/main/java/clap/server/application/service/auth/LoginAttemptService.java
@@ -22,10 +22,10 @@ public class LoginAttemptService implements CheckAccountLockStatusUseCase {
     private static final int MAX_FAILED_ATTEMPTS = 5;
     private static final long LOCK_TIME_DURATION = 30 * 60 * 1000; // 30분 (밀리초)
 
-    public void recordFailedAttempt(String clientIp, String attemptNickname) {
-        LoginLog loginLog = loadLoginLogPort.findByClientIp(clientIp).orElse(null);
+    public void recordFailedAttempt(String nickname, String clientIp) {
+        LoginLog loginLog = loadLoginLogPort.findByNickname(nickname).orElse(null);
         if (loginLog == null) {
-            loginLog = LoginLog.createLoginLog(clientIp, attemptNickname);
+            loginLog = LoginLog.createLoginLog(nickname, clientIp);
         } else {
             int attemptCount = loginLog.recordFailedAttempt();
             if (attemptCount >= MAX_FAILED_ATTEMPTS) {
@@ -38,8 +38,8 @@ public void recordFailedAttempt(String clientIp, String attemptNickname) {
     }
 
     @Override
-    public void checkAccountIsLocked(String clientIp) {
-        LoginLog loginLog = loadLoginLogPort.findByClientIp(clientIp).orElse(null);
+    public void checkAccountIsLocked(String nickname) {
+        LoginLog loginLog = loadLoginLogPort.findByNickname(nickname).orElse(null);
         if (loginLog == null) {
             return;
         }
@@ -53,12 +53,12 @@ public void checkAccountIsLocked(String clientIp) {
             if (minutesSinceLastAttemptInMillis <= LOCK_TIME_DURATION) {
                 throw new AuthException(AuthErrorCode.ACCOUNT_IS_LOCKED);
             }
-            else commandLoginLogPort.deleteById(clientIp);
+            else commandLoginLogPort.deleteById(nickname);
         }
     }
 
 
-    public void resetFailedAttempts(String clientIp) {
-        commandLoginLogPort.deleteById(clientIp);
+    public void resetFailedAttempts(String nickname) {
+        commandLoginLogPort.deleteById(nickname);
     }
 }
diff --git a/src/main/java/clap/server/application/service/log/LogService.java b/src/main/java/clap/server/application/service/log/LogService.java
@@ -35,7 +35,7 @@ public void createMemberLog(HttpServletRequest request, int statusCode, String c
     }
 
     public void createLoginFailedLog(HttpServletRequest request, int statusCode, String customCode, LogStatus logStatus, String requestBody, String nickName) {
-        LoginLog loginLog = loadLoginLogPort.findByClientIp(ClientIpParseUtil.getClientIp(request)).orElse(null);
+        LoginLog loginLog = loadLoginLogPort.findByNickname(nickName).orElse(null);
         String responseBody = loginLog != null ? loginLog.toSummaryString() : null;
         AnonymousLog anonymousLog = AnonymousLog.createAnonymousLog(request, statusCode,customCode, logStatus, responseBody, requestBody, nickName);
         commandLogPort.saveAnonymousLog(anonymousLog);
diff --git a/src/main/java/clap/server/config/security/SecurityFilterConfig.java b/src/main/java/clap/server/config/security/SecurityFilterConfig.java
@@ -6,6 +6,7 @@
 import clap.server.application.port.outbound.auth.forbidden.ForbiddenTokenPort;
 import clap.server.application.port.outbound.auth.JwtProvider;
 import clap.server.application.service.auth.LoginAttemptService;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import lombok.AccessLevel;
 import lombok.RequiredArgsConstructor;
 import org.springframework.context.annotation.Bean;
diff --git a/src/main/java/clap/server/domain/model/auth/LoginLog.java b/src/main/java/clap/server/domain/model/auth/LoginLog.java
@@ -11,35 +11,35 @@
 @SuperBuilder
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class LoginLog {
-	private String clientIp;
-	private String attemptNickname;
-	private LocalDateTime lastAttemptAt;
-	private int failedCount;
-	private boolean isLocked;
+    private String nickname;
+    private String clientIp;
+    private LocalDateTime lastAttemptAt;
+    private int failedCount;
+    private boolean isLocked;
 
-	public static LoginLog createLoginLog(String clientIp, String attemptNickname) {
-		return LoginLog.builder()
-				.clientIp(clientIp)
-				.attemptNickname(attemptNickname)
-				.lastAttemptAt(LocalDateTime.now())
-				.failedCount(1)
-				.isLocked(false)
-				.build();
-	}
+    public static LoginLog createLoginLog(String nickname, String clientIp) {
+        return LoginLog.builder()
+                .nickname(nickname)
+                .clientIp(clientIp)
+                .lastAttemptAt(LocalDateTime.now())
+                .failedCount(1)
+                .isLocked(false)
+                .build();
+    }
 
-	public int recordFailedAttempt() {
-		this.failedCount++;
-		return this.failedCount;
-	}
+    public int recordFailedAttempt() {
+        this.failedCount++;
+        return this.failedCount;
+    }
 
-	public void setLocked(boolean locked) {
-		isLocked = locked;
-	}
+    public void setLocked(boolean locked) {
+        isLocked = locked;
+    }
 
-	public String toSummaryString() {
-			return "{" +
-					", failedCount=" + failedCount +
-					", isLocked=" + isLocked +
-					'}';
-	}
+    public String toSummaryString() {
+        return "{" +
+                "failedCount=" + failedCount +
+                ", isLocked=" + isLocked +
+                '}';
+    }
 }
diff --git a/src/main/java/clap/server/domain/policy/member/ManagerDepartmentPolicy.java b/src/main/java/clap/server/domain/policy/member/ManagerDepartmentPolicy.java
@@ -9,9 +9,10 @@
 @Policy
 public class ManagerDepartmentPolicy {
     public void validateDepartment(final Department department, final MemberRole memberRole) {
-        if (!(department.isManager()
-                && memberRole == MemberRole.ROLE_MANAGER)) {
-            throw new DomainException(MemberErrorCode.MANAGER_PERMISSION_DENIED);
+        if (!department.isManager() ){
+            if(memberRole == MemberRole.ROLE_MANAGER){
+                throw new DomainException(MemberErrorCode.MANAGER_PERMISSION_DENIED);
+            }
         }
     }
 }
diff --git a/src/test/java/clap/server/application/service/auth/AuthServiceTest.java b/src/test/java/clap/server/application/service/auth/AuthServiceTest.java
@@ -67,7 +67,7 @@ void loginSuccess() {
         assertNotNull(response);
         assertEquals(jwtTokens.accessToken(), response.accessToken());
         assertEquals(jwtTokens.refreshToken(), response.refreshToken());
-        verify(loginAttemptService).resetFailedAttempts(clientIp);
+        verify(loginAttemptService).resetFailedAttempts(nickname);
         verify(refreshTokenService).saveRefreshToken(any());
     }
 
@@ -85,7 +85,7 @@ void loginFailureWrongPassword() {
 
         // When & Then
         assertThrows(AuthException.class, () -> authService.login(nickname, inputPassword, clientIp));
-        verify(loginAttemptService).recordFailedAttempt(clientIp, nickname);
+        verify(loginAttemptService).recordFailedAttempt(nickname, clientIp);
     }
 
 
diff --git a/src/test/java/clap/server/application/service/auth/LoginAttemptServiceTest.java b/src/test/java/clap/server/application/service/auth/LoginAttemptServiceTest.java

Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,8 @@ public void deleteById(String clientIp) {`
`25`	`25`	`loginLogRepository.deleteById(clientIp);`
`26`	`26`	`}`
`27`	`27`
`28`		`- public Optional<LoginLog> findByClientIp(String clientIp) {`
`29`		`- return loginLogRepository.findById(clientIp).map(loginLogMapper::toDomain);`
	`28`	`+ @Override`
	`29`	`+ public Optional<LoginLog> findByNickname(String nickname) {`
	`30`	`+ return loginLogRepository.findById(nickname).map(loginLogMapper::toDomain);`
`30`	`31`	`}`
`31`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`package clap.server.application.port.inbound.auth;`
`2`	`2`
`3`	`3`	`public interface CheckAccountLockStatusUseCase {`
`4`		`- void checkAccountIsLocked(String clientIp);`
	`4`	`+ void checkAccountIsLocked(String nickname);`
`5`	`5`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,5 +5,5 @@`
`5`	`5`	`import java.util.Optional;`
`6`	`6`
`7`	`7`	`public interface LoadLoginLogPort {`
`8`		`- Optional<LoginLog> findByClientIp(String clientIp);`
	`8`	`+ Optional<LoginLog> findByNickname(String nickname);`
`9`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ public LoginResponse login(String nickname, String password, String clientIp) {`
`46`	`46`
`47`	`47`	`CustomJwts jwtTokens = manageTokenService.issueTokens(member);`
`48`	`48`	`refreshTokenService.saveRefreshToken(manageTokenService.issueRefreshToken(member.getMemberId()));`
`49`		`- loginAttemptService.resetFailedAttempts(clientIp);`
	`49`	`+ loginAttemptService.resetFailedAttempts(nickname);`
`50`	`50`	`return AuthResponseMapper.toLoginResponse(jwtTokens.accessToken(), jwtTokens.refreshToken());`
`51`	`51`	`}`
`52`	`52`
`@@ -71,14 +71,14 @@ private void deleteAccessToken(Long memberId, String accessToken) {`
`71`	`71`	`private Member getMember(String inputNickname, String clientIp) {`
`72`	`72`	`return loadMemberPort.findByNickname(inputNickname).orElseThrow(() ->`
`73`	`73`	`{`
`74`		`- loginAttemptService.recordFailedAttempt(clientIp, inputNickname);`
	`74`	`+ loginAttemptService.recordFailedAttempt(inputNickname, clientIp);`
`75`	`75`	`return new AuthException(AuthErrorCode.LOGIN_REQUEST_FAILED);`
`76`	`76`	`});`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`private void validatePassword(String inputPassword, String encodedPassword, String inputNickname, String clientIp) {`
`80`	`80`	`if (!passwordEncoder.matches(inputPassword, encodedPassword)) {`
`81`		`- loginAttemptService.recordFailedAttempt(clientIp, inputNickname);`
	`81`	`+ loginAttemptService.recordFailedAttempt(inputNickname, clientIp);`
`82`	`82`	`throw new AuthException(AuthErrorCode.LOGIN_REQUEST_FAILED);`
`83`	`83`	`}`
`84`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,10 +22,10 @@ public class LoginAttemptService implements CheckAccountLockStatusUseCase {`
`22`	`22`	`private static final int MAX_FAILED_ATTEMPTS = 5;`
`23`	`23`	`private static final long LOCK_TIME_DURATION = 30 * 60 * 1000; // 30분 (밀리초)`
`24`	`24`
`25`		`- public void recordFailedAttempt(String clientIp, String attemptNickname) {`
`26`		`- LoginLog loginLog = loadLoginLogPort.findByClientIp(clientIp).orElse(null);`
	`25`	`+ public void recordFailedAttempt(String nickname, String clientIp) {`
	`26`	`+ LoginLog loginLog = loadLoginLogPort.findByNickname(nickname).orElse(null);`
`27`	`27`	`if (loginLog == null) {`
`28`		`- loginLog = LoginLog.createLoginLog(clientIp, attemptNickname);`
	`28`	`+ loginLog = LoginLog.createLoginLog(nickname, clientIp);`
`29`	`29`	`} else {`
`30`	`30`	`int attemptCount = loginLog.recordFailedAttempt();`
`31`	`31`	`if (attemptCount >= MAX_FAILED_ATTEMPTS) {`
`@@ -38,8 +38,8 @@ public void recordFailedAttempt(String clientIp, String attemptNickname) {`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`@Override`
`41`		`- public void checkAccountIsLocked(String clientIp) {`
`42`		`- LoginLog loginLog = loadLoginLogPort.findByClientIp(clientIp).orElse(null);`
	`41`	`+ public void checkAccountIsLocked(String nickname) {`
	`42`	`+ LoginLog loginLog = loadLoginLogPort.findByNickname(nickname).orElse(null);`
`43`	`43`	`if (loginLog == null) {`
`44`	`44`	`return;`
`45`	`45`	`}`
`@@ -53,12 +53,12 @@ public void checkAccountIsLocked(String clientIp) {`
`53`	`53`	`if (minutesSinceLastAttemptInMillis <= LOCK_TIME_DURATION) {`
`54`	`54`	`throw new AuthException(AuthErrorCode.ACCOUNT_IS_LOCKED);`
`55`	`55`	`}`
`56`		`- else commandLoginLogPort.deleteById(clientIp);`
	`56`	`+ else commandLoginLogPort.deleteById(nickname);`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`
`60`	`60`
`61`		`- public void resetFailedAttempts(String clientIp) {`
`62`		`- commandLoginLogPort.deleteById(clientIp);`
	`61`	`+ public void resetFailedAttempts(String nickname) {`
	`62`	`+ commandLoginLogPort.deleteById(nickname);`
`63`	`63`	`}`
`64`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ public void createMemberLog(HttpServletRequest request, int statusCode, String c`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`public void createLoginFailedLog(HttpServletRequest request, int statusCode, String customCode, LogStatus logStatus, String requestBody, String nickName) {`
`38`		`- LoginLog loginLog = loadLoginLogPort.findByClientIp(ClientIpParseUtil.getClientIp(request)).orElse(null);`
	`38`	`+ LoginLog loginLog = loadLoginLogPort.findByNickname(nickName).orElse(null);`
`39`	`39`	`String responseBody = loginLog != null ? loginLog.toSummaryString() : null;`
`40`	`40`	`AnonymousLog anonymousLog = AnonymousLog.createAnonymousLog(request, statusCode,customCode, logStatus, responseBody, requestBody, nickName);`
`41`	`41`	`commandLogPort.saveAnonymousLog(anonymousLog);`