diff --git a/src/main/java/com/mtvs/devlinkbackend/channel/controller/ChannelController.java b/src/main/java/com/mtvs/devlinkbackend/channel/controller/ChannelController.java index 0ee66b2..5ef7ac6 100644 --- a/src/main/java/com/mtvs/devlinkbackend/channel/controller/ChannelController.java +++ b/src/main/java/com/mtvs/devlinkbackend/channel/controller/ChannelController.java @@ -4,7 +4,7 @@ import com.mtvs.devlinkbackend.channel.dto.ChannelUpdateRequestDTO; import com.mtvs.devlinkbackend.channel.entity.Channel; import com.mtvs.devlinkbackend.channel.service.ChannelService; -import com.mtvs.devlinkbackend.config.JwtUtil; +import com.mtvs.devlinkbackend.util.JwtUtil; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; diff --git a/src/main/java/com/mtvs/devlinkbackend/comment/controller/CommentController.java b/src/main/java/com/mtvs/devlinkbackend/comment/controller/CommentController.java index 5204461..1a9391a 100644 --- a/src/main/java/com/mtvs/devlinkbackend/comment/controller/CommentController.java +++ b/src/main/java/com/mtvs/devlinkbackend/comment/controller/CommentController.java @@ -4,7 +4,7 @@ import com.mtvs.devlinkbackend.comment.dto.CommentUpdateRequestDTO; import com.mtvs.devlinkbackend.comment.entity.Comment; import com.mtvs.devlinkbackend.comment.service.CommentService; -import com.mtvs.devlinkbackend.config.JwtUtil; +import com.mtvs.devlinkbackend.util.JwtUtil; import io.swagger.v3.oas.annotations.Operation; import io.swagger.v3.oas.annotations.responses.ApiResponse; import io.swagger.v3.oas.annotations.responses.ApiResponses; diff --git a/src/main/java/com/mtvs/devlinkbackend/config/JwtAuthenticationFilter.java b/src/main/java/com/mtvs/devlinkbackend/config/JwtAuthenticationFilter.java index b465602..cd49b00 100644 --- a/src/main/java/com/mtvs/devlinkbackend/config/JwtAuthenticationFilter.java +++ b/src/main/java/com/mtvs/devlinkbackend/config/JwtAuthenticationFilter.java @@ -1,6 +1,6 @@ package com.mtvs.devlinkbackend.config; -import com.mtvs.devlinkbackend.oauth2.service.UserService; +import com.mtvs.devlinkbackend.util.JwtUtil; import jakarta.servlet.FilterChain; import jakarta.servlet.ServletException; import jakarta.servlet.http.Cookie; @@ -17,11 +17,9 @@ @Component public class JwtAuthenticationFilter extends OncePerRequestFilter { private final JwtUtil jwtUtil; - private final UserService userService; - public JwtAuthenticationFilter(JwtUtil jwtUtil, UserService userService) { + public JwtAuthenticationFilter(JwtUtil jwtUtil) { this.jwtUtil = jwtUtil; - this.userService = userService; } @Override @@ -53,9 +51,10 @@ protected void doFilterInternal(HttpServletRequest request, HttpServletResponse } catch (Exception e) { // 검증 실패 시 401 에러 설정 if(e.getMessage().equals("JWT is expired")) - response.setStatus(HttpServletResponse.SC_UNAUTHORIZED); + response.setStatus(449); else - response.setStatus(449); // 헤더에 들어 있는 토큰이 잘못됨 + System.out.println(e.getMessage()); + response.setStatus(HttpServletResponse.SC_UNAUTHORIZED); // 헤더에 들어 있는 토큰이 잘못됨 return; } diff --git a/src/main/java/com/mtvs/devlinkbackend/config/SecurityConfig.java b/src/main/java/com/mtvs/devlinkbackend/config/SecurityConfig.java index d677600..3cd821d 100644 --- a/src/main/java/com/mtvs/devlinkbackend/config/SecurityConfig.java +++ b/src/main/java/com/mtvs/devlinkbackend/config/SecurityConfig.java @@ -1,41 +1,25 @@ package com.mtvs.devlinkbackend.config; -import com.mtvs.devlinkbackend.oauth2.entity.User; -import com.mtvs.devlinkbackend.oauth2.service.UserService; -import jakarta.servlet.http.Cookie; -import jakarta.servlet.http.HttpServletRequest; -import jakarta.servlet.http.HttpServletResponse; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer; import org.springframework.security.config.http.SessionCreationPolicy; -import org.springframework.security.core.Authentication; -import org.springframework.security.oauth2.client.OAuth2AuthorizedClient; import org.springframework.security.oauth2.client.OAuth2AuthorizedClientService; -import org.springframework.security.oauth2.client.userinfo.DefaultOAuth2UserService; -import org.springframework.security.oauth2.client.userinfo.OAuth2UserRequest; -import org.springframework.security.oauth2.client.userinfo.OAuth2UserService; -import org.springframework.security.oauth2.core.user.OAuth2User; import org.springframework.security.web.SecurityFilterChain; -import org.springframework.security.web.authentication.AuthenticationSuccessHandler; import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter; -import org.springframework.security.web.authentication.logout.LogoutHandler; -import org.springframework.security.web.session.InvalidSessionStrategy; import org.springframework.web.cors.CorsConfigurationSource; @Configuration @EnableWebSecurity public class SecurityConfig { - private final UserService userService; private final OAuth2AuthorizedClientService authorizedClientService; private final CorsConfigurationSource corsConfigurationSource; private final JwtAuthenticationFilter jwtAuthenticationFilter; - public SecurityConfig(UserService userService, CorsConfigurationSource corsConfigurationSource, OAuth2AuthorizedClientService authorizedClientService, JwtAuthenticationFilter jwtAuthenticationFilter) { - this.userService = userService; + public SecurityConfig(CorsConfigurationSource corsConfigurationSource, OAuth2AuthorizedClientService authorizedClientService, JwtAuthenticationFilter jwtAuthenticationFilter) { this.corsConfigurationSource = corsConfigurationSource; this.authorizedClientService = authorizedClientService; this.jwtAuthenticationFilter = jwtAuthenticationFilter; diff --git a/src/main/java/com/mtvs/devlinkbackend/ether/controller/EtherController.java b/src/main/java/com/mtvs/devlinkbackend/ether/controller/EtherController.java index 864aa99..98397bf 100644 --- a/src/main/java/com/mtvs/devlinkbackend/ether/controller/EtherController.java +++ b/src/main/java/com/mtvs/devlinkbackend/ether/controller/EtherController.java @@ -1,6 +1,6 @@ package com.mtvs.devlinkbackend.ether.controller; -import com.mtvs.devlinkbackend.config.JwtUtil; +import com.mtvs.devlinkbackend.util.JwtUtil; import com.mtvs.devlinkbackend.ether.dto.EtherRegistRequestDTO; import com.mtvs.devlinkbackend.ether.dto.EtherUpdateRequestDTO; import com.mtvs.devlinkbackend.ether.entity.Ether; diff --git a/src/main/java/com/mtvs/devlinkbackend/guild/controller/GuildController.java b/src/main/java/com/mtvs/devlinkbackend/guild/controller/GuildController.java index f20ba5e..62d8117 100644 --- a/src/main/java/com/mtvs/devlinkbackend/guild/controller/GuildController.java +++ b/src/main/java/com/mtvs/devlinkbackend/guild/controller/GuildController.java @@ -1,6 +1,6 @@ package com.mtvs.devlinkbackend.guild.controller; -import com.mtvs.devlinkbackend.config.JwtUtil; +import com.mtvs.devlinkbackend.util.JwtUtil; import com.mtvs.devlinkbackend.guild.dto.GuildMemberModifyRequestDTO; import com.mtvs.devlinkbackend.guild.dto.GuildRegistRequestDTO; import com.mtvs.devlinkbackend.guild.dto.GuildUpdateRequestDTO; diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/controller/Oauth2UserController.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/controller/Oauth2UserController.java index 69be88c..c83178c 100644 --- a/src/main/java/com/mtvs/devlinkbackend/oauth2/controller/Oauth2UserController.java +++ b/src/main/java/com/mtvs/devlinkbackend/oauth2/controller/Oauth2UserController.java @@ -1,10 +1,11 @@ package com.mtvs.devlinkbackend.oauth2.controller; -import com.mtvs.devlinkbackend.config.JwtUtil; +import com.mtvs.devlinkbackend.oauth2.service.UserService; +import com.mtvs.devlinkbackend.util.JwtUtil; import com.mtvs.devlinkbackend.oauth2.dto.EpicGamesCallbackRequestDTO; import com.mtvs.devlinkbackend.oauth2.entity.User; import com.mtvs.devlinkbackend.oauth2.service.EpicGamesTokenService; -import com.mtvs.devlinkbackend.oauth2.service.UserService; +import com.mtvs.devlinkbackend.oauth2.service.UserPartnerService; import io.swagger.v3.oas.annotations.Operation; import io.swagger.v3.oas.annotations.responses.ApiResponse; import io.swagger.v3.oas.annotations.responses.ApiResponses; @@ -15,41 +16,21 @@ import java.util.Map; @RestController -@RequestMapping("/api/auth") +@RequestMapping("/api/auth/epicgames") public class Oauth2UserController { private final EpicGamesTokenService epicGamesTokenService; - private final UserService userService; private final JwtUtil jwtUtil; + private final UserService userService; - public Oauth2UserController(EpicGamesTokenService epicGamesTokenService, UserService userService, JwtUtil jwtUtil) { + public Oauth2UserController(EpicGamesTokenService epicGamesTokenService, JwtUtil jwtUtil, UserService userService) { this.epicGamesTokenService = epicGamesTokenService; - this.userService = userService; this.jwtUtil = jwtUtil; - } - - // 로컬 user 정보 가져오는 API - @GetMapping("/local/user-info") - @Operation( - summary = "로컬 유저 정보 조회", - description = "DevLink만의 DB에 저장된 유저 정보를 조회한다." - ) - @ApiResponses(value = { - @ApiResponse(responseCode = "200", description = "조회 성공"), - @ApiResponse(responseCode = "400", description = "잘못된 헤더 또는 파라미터 전달"), - @ApiResponse(responseCode = "401", description = "인증되지 않음") - }) - public ResponseEntity getLocalUserInfo(@RequestHeader("Authorization") String authorizationHeader) { - - try { - return ResponseEntity.ok(userService.findUserByAuthorizationHeader(authorizationHeader)); - } catch (Exception e) { - return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Invalid token"); - } + this.userService = userService; } // epicgames 계정 정보 가져오는 API - @GetMapping("/epicgames/user-info") + @GetMapping("/user-info") @Operation( summary = "EpicGames 유저 정보 조회", description = "EpicGames의 유저 정보를 조회한다." @@ -74,18 +55,19 @@ public ResponseEntity getEpicGamesUserInfo( } } - @GetMapping("/epicgames/accountId") + @GetMapping("/accountId") public ResponseEntity getAccountId( @RequestHeader("Authorization") String authorizationHeader) { try { - return ResponseEntity.ok(jwtUtil.getSubjectFromAuthHeaderWithAuth(authorizationHeader)); + return ResponseEntity.ok(jwtUtil.getSubjectFromAuthHeaderWithoutAuth(authorizationHeader)); } catch (Exception e) { + System.out.println(e.getMessage()); return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Invalid token"); } } - @PostMapping("/epicgames/callback") + @PostMapping("/callback") @Operation( summary = "EpicGames AccessToken 요청", description = "EpicGames로부터 사용자에게 AccessToken을 전달한다." @@ -107,19 +89,13 @@ public ResponseEntity handleEpicGamesCallback( return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build(); } - @PostMapping("/login") + @GetMapping("/login") public ResponseEntity authLogin( - @RequestHeader(name = "Authorization") String authorizationHeader) { + @RequestHeader(name = "Authorization") String authorizationHeader) throws Exception { User user = userService.findUserByAuthorizationHeader(authorizationHeader); // 222 : 해당 User는 이미 서비스를 사용한 경험이 있음 // 260 : 해당 User가 처음 서비스를 사용 return user != null ? ResponseEntity.status(222).body("Existing User") : ResponseEntity.status(260).body("New User"); } - - @PatchMapping("/local/user-info") - public ResponseEntity updateLocalUserInfo() { - // User 추가 정보 확정되면 개발 예정 - return ResponseEntity.ok().build(); - } } diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/controller/UserClientGroupController.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/controller/UserClientGroupController.java new file mode 100644 index 0000000..56acfc7 --- /dev/null +++ b/src/main/java/com/mtvs/devlinkbackend/oauth2/controller/UserClientGroupController.java @@ -0,0 +1,124 @@ +package com.mtvs.devlinkbackend.oauth2.controller; + +import com.mtvs.devlinkbackend.oauth2.dto.UserClientGroupRequestDTO; +import com.mtvs.devlinkbackend.oauth2.entity.UserClientGroup; +import com.mtvs.devlinkbackend.oauth2.service.UserClientGroupService; +import com.mtvs.devlinkbackend.util.JwtUtil; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import io.swagger.v3.oas.annotations.responses.ApiResponses; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + +@RestController +@RequestMapping("/api/user/group") +public class UserClientGroupController { + private final UserClientGroupService userClientGroupService; + private final JwtUtil jwtUtil; + + public UserClientGroupController(UserClientGroupService userClientGroupService, JwtUtil jwtUtil) { + this.userClientGroupService = userClientGroupService; + this.jwtUtil = jwtUtil; + } + + @Operation(summary = "UserClientGroup 등록") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "성공적으로 UserClientGroup이 등록됨"), + @ApiResponse(responseCode = "400", description = "잘못된 입력 데이터") + }) + @PostMapping + public ResponseEntity convertUserToUserClientGroup( + @RequestBody UserClientGroupRequestDTO userClientGroupRequestDTO, + @RequestHeader("Authorization") String authorizationHeader) throws Exception { + + String accountId = jwtUtil.getSubjectFromAuthHeaderWithoutAuth(authorizationHeader); + UserClientGroup userClientGroup = + userClientGroupService.registUserClientGroup(userClientGroupRequestDTO, accountId); + return ResponseEntity.ok(userClientGroup); + } + + @Operation(summary = "Authorization Header로 UserClientGroup 조회") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "성공적으로 UserClientGroup을 조회함"), + @ApiResponse(responseCode = "404", description = "UserClientGroup을 찾을 수 없음") + }) + @GetMapping + public ResponseEntity findUserClientGroupByAuthorizationHeader( + @RequestHeader("Authorization") String authorizationHeader) throws Exception { + + String accountId = jwtUtil.getSubjectFromAuthHeaderWithoutAuth(authorizationHeader); + UserClientGroup userClientGroup = userClientGroupService.findUserClientGroupByAccountId(accountId); + return ResponseEntity.ok(userClientGroup); + } + + @Operation(summary = "담당자 이름에 특정 키워드가 포함된 UserClientGroups 조회") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "성공적으로 UserClientGroups를 조회함") + }) + @GetMapping("/manager-name/{managerName}") + public ResponseEntity> findByManagerNameContainingIgnoreCase(@PathVariable String managerName) { + List userClientGroups = userClientGroupService.findByManagerNameContainingIgnoreCase(managerName); + return ResponseEntity.ok(userClientGroups); + } + + @Operation(summary = "그룹 이름에 특정 키워드가 포함된 UserClientGroups 조회") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "성공적으로 UserClientGroups를 조회함") + }) + @GetMapping("/group-name/{groupName}") + public ResponseEntity> findByGroupNameContainingIgnoreCase(@PathVariable String groupName) { + List userClientGroups = userClientGroupService.findByGroupNameContainingIgnoreCase(groupName); + return ResponseEntity.ok(userClientGroups); + } + + @Operation(summary = "Client Type으로 UserClientGroups 조회") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "성공적으로 UserClientGroups를 조회함") + }) + @GetMapping("/client-type/{clientType}") + public ResponseEntity> findByClientType(@PathVariable String clientType) { + List userClientGroups = userClientGroupService.findByClientType(clientType); + return ResponseEntity.ok(userClientGroups); + } + + @Operation(summary = "담당자 전화번호로 UserClientGroups 조회") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "성공적으로 UserClientGroups를 조회함") + }) + @GetMapping("/manager-phone/{managerPhone}") + public ResponseEntity> findByManagerPhone(@PathVariable String managerPhone) { + List userClientGroups = userClientGroupService.findByManagerPhone(managerPhone); + return ResponseEntity.ok(userClientGroups); + } + + @Operation(summary = "UserClientGroup 정보 수정") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "성공적으로 UserClientGroup을 수정함"), + @ApiResponse(responseCode = "404", description = "UserClientGroup을 찾을 수 없음") + }) + @PatchMapping + public ResponseEntity updateUserClientGroup( + @RequestBody UserClientGroupRequestDTO userClientGroupRequestDTO, + @RequestHeader("Authorization") String authorizationHeader) throws Exception { + + String accountId = jwtUtil.getSubjectFromAuthHeaderWithoutAuth(authorizationHeader); + UserClientGroup userClientGroup = + userClientGroupService.updateUserClientGroup(userClientGroupRequestDTO, accountId); + return ResponseEntity.ok(userClientGroup); + } + + @Operation(summary = "Authorization Header의 Account ID를 기반으로 UserClientGroup 삭제") + @ApiResponses(value = { + @ApiResponse(responseCode = "204", description = "성공적으로 UserClientGroup을 삭제함"), + @ApiResponse(responseCode = "404", description = "UserClientGroup을 찾을 수 없음") + }) + @DeleteMapping + public ResponseEntity deleteUserClientGroupByAuthorizationHeader(@RequestHeader("Authorization") String authorizationHeader) throws Exception { + + String accountId = jwtUtil.getSubjectFromAuthHeaderWithoutAuth(authorizationHeader); + userClientGroupService.deleteByAccountId(accountId); + return ResponseEntity.noContent().build(); + } +} diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/controller/UserClientIndividualController.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/controller/UserClientIndividualController.java new file mode 100644 index 0000000..3ab0ef7 --- /dev/null +++ b/src/main/java/com/mtvs/devlinkbackend/oauth2/controller/UserClientIndividualController.java @@ -0,0 +1,110 @@ +package com.mtvs.devlinkbackend.oauth2.controller; + +import com.mtvs.devlinkbackend.oauth2.dto.UserClientIndividualRequestDTO; +import com.mtvs.devlinkbackend.oauth2.entity.UserClientIndividual; +import com.mtvs.devlinkbackend.oauth2.service.UserClientIndividualService; +import com.mtvs.devlinkbackend.util.JwtUtil; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import io.swagger.v3.oas.annotations.responses.ApiResponses; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + +@RestController +@RequestMapping("/api/user/individual") +public class UserClientIndividualController { + private final UserClientIndividualService userClientIndividualService; + private final JwtUtil jwtUtil; + + public UserClientIndividualController(UserClientIndividualService userClientIndividualService, JwtUtil jwtUtil) { + this.userClientIndividualService = userClientIndividualService; + this.jwtUtil = jwtUtil; + } + + @Operation(summary = "UserClientIndividual로 등록") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "성공적으로 UserClientIndividual이 등록됨"), + @ApiResponse(responseCode = "400", description = "잘못된 입력 데이터") + }) + @PostMapping + public ResponseEntity convertUserToUserClientIndividual( + @RequestBody UserClientIndividualRequestDTO userClientIndividualRequestDTO, + @RequestHeader("Authorization") String authorizationHeader) throws Exception { + + String accountId = jwtUtil.getSubjectFromAuthHeaderWithoutAuth(authorizationHeader); + UserClientIndividual userClientIndividual = + userClientIndividualService.registUserClientIndividual( + userClientIndividualRequestDTO, accountId); + return ResponseEntity.ok(userClientIndividual); + } + + @Operation(summary = "Authorization Header로 UserClientIndividual 조회") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "성공적으로 UserClientIndividual을 조회함"), + @ApiResponse(responseCode = "404", description = "UserClientIndividual을 찾을 수 없음") + }) + @GetMapping + public ResponseEntity findUserClientIndividualByAuthorizationHeader( + @RequestHeader("Authorization") String authorizationHeader) throws Exception { + + String accountId = jwtUtil.getSubjectFromAuthHeaderWithoutAuth(authorizationHeader); + UserClientIndividual userClientIndividual = + userClientIndividualService.findUserClientIndividualByAccountId(accountId); + return ResponseEntity.ok(userClientIndividual); + } + + @Operation(summary = "이름에 특정 키워드가 포함된 UserClientIndividuals 조회") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "성공적으로 UserClientIndividuals를 조회함") + }) + @GetMapping("/name/{name}") + public ResponseEntity> findUserClientIndividualsByNameContainingIgnoreCase(@PathVariable String name) { + List userClientIndividuals = + userClientIndividualService.findUserClientIndividualsByNameContainingIgnoreCase(name); + return ResponseEntity.ok(userClientIndividuals); + } + + @Operation(summary = "전화번호로 UserClientIndividuals 조회") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "성공적으로 UserClientIndividuals를 조회함") + }) + @GetMapping("/phone/{phone}") + public ResponseEntity> findUserClientIndividualsByPhone(@PathVariable String phone) { + List userClientIndividuals = + userClientIndividualService.findUserClientIndividualsByPhone(phone); + return ResponseEntity.ok(userClientIndividuals); + } + + @Operation(summary = "UserClientIndividual 정보 수정") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "성공적으로 UserClientIndividual을 수정함"), + @ApiResponse(responseCode = "404", description = "UserClientIndividual을 찾을 수 없음") + }) + @PatchMapping + public ResponseEntity updateUserClientIndividual( + @RequestBody UserClientIndividualRequestDTO userClientIndividualRequestDTO, + @RequestHeader("Authorization") String authorizationHeader) throws Exception { + + String accountId = jwtUtil.getSubjectFromAuthHeaderWithoutAuth(authorizationHeader); + UserClientIndividual userClientIndividual = + userClientIndividualService.updateUserClientIndividual( + userClientIndividualRequestDTO, accountId); + return ResponseEntity.ok(userClientIndividual); + } + + @Operation(summary = "Authorization Header의 Account ID를 기반으로 UserClientIndividual 삭제") + @ApiResponses(value = { + @ApiResponse(responseCode = "204", description = "성공적으로 UserClientIndividual을 삭제함"), + @ApiResponse(responseCode = "404", description = "UserClientIndividual을 찾을 수 없음") + }) + @DeleteMapping + public ResponseEntity deleteUserClientIndividualByAuthorizationHeader( + @RequestHeader("Authorization") String authorizationHeader) throws Exception { + + String accountId = jwtUtil.getSubjectFromAuthHeaderWithoutAuth(authorizationHeader); + userClientIndividualService.deleteByAccountId(accountId); + return ResponseEntity.noContent().build(); + } +} diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/controller/UserPartnerController.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/controller/UserPartnerController.java new file mode 100644 index 0000000..c625c19 --- /dev/null +++ b/src/main/java/com/mtvs/devlinkbackend/oauth2/controller/UserPartnerController.java @@ -0,0 +1,123 @@ +package com.mtvs.devlinkbackend.oauth2.controller; + +import com.mtvs.devlinkbackend.oauth2.dto.UserPartnerRequestDTO; +import com.mtvs.devlinkbackend.oauth2.entity.UserPartner; +import com.mtvs.devlinkbackend.oauth2.service.UserPartnerService; +import com.mtvs.devlinkbackend.util.JwtUtil; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import io.swagger.v3.oas.annotations.responses.ApiResponses; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + +@RestController +@RequestMapping("/api/user/partner") +public class UserPartnerController { + private final UserPartnerService userPartnerService; + private final JwtUtil jwtUtil; + + public UserPartnerController(UserPartnerService userPartnerService, JwtUtil jwtUtil) { + this.userPartnerService = userPartnerService; + this.jwtUtil = jwtUtil; + } + + @Operation(summary = "UserPartner 등록") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "성공적으로 UserPartner로 등록됨"), + @ApiResponse(responseCode = "400", description = "잘못된 입력 데이터") + }) + @PostMapping + public ResponseEntity convertUserToUserPartner( + @RequestBody UserPartnerRequestDTO userPartnerRequestDTO, + @RequestHeader("Authorization") String authorizationHeader) throws Exception { + + String accountId = jwtUtil.getSubjectFromAuthHeaderWithoutAuth(authorizationHeader); + UserPartner userPartner = userPartnerService.registUserPartner(userPartnerRequestDTO, accountId); + return ResponseEntity.ok(userPartner); + } + + @Operation(summary = "Account ID로 UserPartner 조회") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "성공적으로 UserPartner를 조회함"), + @ApiResponse(responseCode = "404", description = "UserPartner를 찾을 수 없음") + }) + @GetMapping + public ResponseEntity findUserPartnerByAccountId( + @RequestHeader(name = "Authorization") String authorizationHeader) throws Exception { + + String accountId = jwtUtil.getSubjectFromAuthHeaderWithoutAuth(authorizationHeader); + UserPartner userPartner = userPartnerService.findUserPartnerByAccountId(accountId); + return ResponseEntity.ok(userPartner); + } + + @Operation(summary = "이름에 특정 키워드가 포함된 UserPartners 조회") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "성공적으로 UserPartners를 조회함") + }) + @GetMapping("/name/{name}") + public ResponseEntity> findUserPartnersByNameContainingIgnoreCase(@PathVariable String name) { + List userPartners = userPartnerService.findUserPartnersByNameContainingIgnoreCase(name); + return ResponseEntity.ok(userPartners); + } + + @Operation(summary = "닉네임에 특정 키워드가 포함된 UserPartners 조회") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "성공적으로 UserPartners를 조회함") + }) + @GetMapping("/nickname/{nickname}") + public ResponseEntity> findUserPartnersByNicknameContainingIgnoreCase(@PathVariable String nickname) { + List userPartners = userPartnerService.findUserPartnersByNicknameContainingIgnoreCase(nickname); + return ResponseEntity.ok(userPartners); + } + + @Operation(summary = "이메일로 UserPartners 조회") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "성공적으로 UserPartners를 조회함") + }) + @GetMapping("/email/{email}") + public ResponseEntity> findUserPartnersByEmail(@PathVariable String email) { + List userPartners = userPartnerService.findUserPartnersByEmail(email); + return ResponseEntity.ok(userPartners); + } + + @Operation(summary = "전화번호로 UserPartner 조회") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "성공적으로 UserPartner를 조회함") + }) + @GetMapping("/phone/{phone}") + public ResponseEntity findUserPartnerByPhone(@PathVariable String phone) { + UserPartner userPartner = userPartnerService.findUserPartnerByPhone(phone); + return ResponseEntity.ok(userPartner); + } + + @Operation(summary = "UserPartner 정보 수정") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "성공적으로 UserPartner를 수정함"), + @ApiResponse(responseCode = "404", description = "UserPartner를 찾을 수 없음") + }) + @PatchMapping + public ResponseEntity updateUserPartner( + @RequestBody UserPartnerRequestDTO userPartnerRequestDTO, + @RequestHeader("Authorization") String authorizationHeader) throws Exception { + + String accountId = jwtUtil.getSubjectFromAuthHeaderWithoutAuth(authorizationHeader); + UserPartner userPartner = userPartnerService.updateUserPartner(userPartnerRequestDTO, accountId); + return ResponseEntity.ok(userPartner); + } + + @Operation(summary = "Authorization Header의 Account ID를 기반으로 UserPartner 삭제") + @ApiResponses(value = { + @ApiResponse(responseCode = "204", description = "성공적으로 UserPartner를 삭제함"), + @ApiResponse(responseCode = "404", description = "UserPartner를 찾을 수 없음") + }) + @DeleteMapping("/delete") + public ResponseEntity deleteUserPartnerByAuthorizationHeader( + @RequestHeader("Authorization") String authorizationHeader) throws Exception { + + String accountId = jwtUtil.getSubjectFromAuthHeaderWithoutAuth(authorizationHeader); + userPartnerService.deleteByAccountId(accountId); + return ResponseEntity.noContent().build(); + } +} diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/dto/UserClientGroupRequestDTO.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/dto/UserClientGroupRequestDTO.java new file mode 100644 index 0000000..13f668c --- /dev/null +++ b/src/main/java/com/mtvs/devlinkbackend/oauth2/dto/UserClientGroupRequestDTO.java @@ -0,0 +1,16 @@ +package com.mtvs.devlinkbackend.oauth2.dto; + +import lombok.*; + +@Getter @Setter +@NoArgsConstructor +@AllArgsConstructor +@ToString +public class UserClientGroupRequestDTO { + private String purpose = "UserClientGroup"; + private String clientType; + private String groupName; + private String managerName; + private String managerPhone; +} + diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/dto/UserClientIndividualRequestDTO.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/dto/UserClientIndividualRequestDTO.java new file mode 100644 index 0000000..dd88896 --- /dev/null +++ b/src/main/java/com/mtvs/devlinkbackend/oauth2/dto/UserClientIndividualRequestDTO.java @@ -0,0 +1,14 @@ +package com.mtvs.devlinkbackend.oauth2.dto; + +import lombok.*; + +@Getter +@Setter +@NoArgsConstructor +@AllArgsConstructor +@ToString +public class UserClientIndividualRequestDTO { + private String purpose = "UserClientIndividual"; + private String name; + private String phone; +} diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/dto/UserPartnerRequestDTO.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/dto/UserPartnerRequestDTO.java new file mode 100644 index 0000000..19583d8 --- /dev/null +++ b/src/main/java/com/mtvs/devlinkbackend/oauth2/dto/UserPartnerRequestDTO.java @@ -0,0 +1,22 @@ +package com.mtvs.devlinkbackend.oauth2.dto; + +import lombok.*; + +import java.util.List; +import java.util.Map; + +@Getter @Setter +@NoArgsConstructor +@AllArgsConstructor +@ToString +public class UserPartnerRequestDTO { + private String purpose = "UserClientPartner"; + private String nickname; + private String name; + private String email; + private String phone; + private List portfolioList; + private String experience; + private Map skillSet; + private String message; +} diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/dto/UserRegistRequestDTO.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/dto/UserRegistRequestDTO.java deleted file mode 100644 index a819075..0000000 --- a/src/main/java/com/mtvs/devlinkbackend/oauth2/dto/UserRegistRequestDTO.java +++ /dev/null @@ -1,12 +0,0 @@ -package com.mtvs.devlinkbackend.oauth2.dto; - -import lombok.*; - -@Getter @Setter -@NoArgsConstructor -@AllArgsConstructor -@ToString -public class UserRegistRequestDTO { - private String userName; - private String email; -} diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/dto/UserUpdateRequestDTO.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/dto/UserUpdateRequestDTO.java deleted file mode 100644 index b819504..0000000 --- a/src/main/java/com/mtvs/devlinkbackend/oauth2/dto/UserUpdateRequestDTO.java +++ /dev/null @@ -1,12 +0,0 @@ -package com.mtvs.devlinkbackend.oauth2.dto; - -import lombok.*; - -@Getter @Setter -@NoArgsConstructor -@AllArgsConstructor -@ToString -public class UserUpdateRequestDTO { - private String userName; - private String email; -} diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/entity/User.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/entity/User.java index e6b2eb6..5494b1e 100644 --- a/src/main/java/com/mtvs/devlinkbackend/oauth2/entity/User.java +++ b/src/main/java/com/mtvs/devlinkbackend/oauth2/entity/User.java @@ -10,6 +10,8 @@ @Table(name = "USER") @Entity(name = "User") @Getter +@Inheritance(strategy = InheritanceType.JOINED) +@DiscriminatorColumn(name = "purpose") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @@ -19,11 +21,11 @@ public class User { @Column(name = "ACCOUNT_ID", unique = true) private String accountId; - @Column(name = "EMAIL") - private String email; + @Column(name = "PURPOSE", insertable = false, updatable = false) // "UserClient", "UserPartners" 둘 중 한개 + private String purpose; - @Column(name = "USER_NAME") - private String userName; + @Column(name = "CHARACTER_ID", unique = true) + private Long characterId; @CreationTimestamp @Column(name = "CREATED_AT", updatable = false) @@ -33,25 +35,15 @@ public class User { @Column(name = "MODIFIED_AT") private LocalDateTime modifiedAt; - @Column(name = "REFRESH_TOKEN") - private String refreshToken; - // 추후 추가 정보 필요시 Entity에 Column 추가 예정 - public User() {} public User(String accountId) { this.accountId = accountId; } - public void setEmail(String email) { - this.email = email; - } - - public void setUserName(String userName) { - this.userName = userName; - } - - public void setRefreshToken(String refreshToken) { - this.refreshToken = refreshToken; + public User(String accountId, String purpose) { + this.userId = userId; + this.accountId = accountId; + this.purpose = purpose; } } diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/entity/UserClientGroup.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/entity/UserClientGroup.java new file mode 100644 index 0000000..17dede9 --- /dev/null +++ b/src/main/java/com/mtvs/devlinkbackend/oauth2/entity/UserClientGroup.java @@ -0,0 +1,37 @@ +package com.mtvs.devlinkbackend.oauth2.entity; + +import jakarta.persistence.Column; +import jakarta.persistence.DiscriminatorValue; +import jakarta.persistence.Entity; +import jakarta.persistence.Table; +import lombok.Getter; +import lombok.Setter; + +@Table(name = "USER_CLIENT_GROUP") +@Entity(name = "UserClientGroup") +@DiscriminatorValue("UserClientGroup") // purpose 값으로 지정 +@Getter @Setter +public class UserClientGroup extends User { + @Column(name = "CLIENT_TYPE") + private String clientType; + + @Column(name = "GROUP_NAME") // 회사명/팀명 + private String groupName; + + @Column(name = "MANAGER_NAME") + private String managerName; + + @Column(name = "MANAGER_PHONE") + private String managerPhone; + + public UserClientGroup() { + } + + public UserClientGroup(String accountId, String purpose, String clientType, String groupName, String managerName, String managerPhone) { + super(accountId, purpose); + this.clientType = clientType; + this.groupName = groupName; + this.managerName = managerName; + this.managerPhone = managerPhone; + } +} diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/entity/UserClientIndividual.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/entity/UserClientIndividual.java new file mode 100644 index 0000000..5e63cba --- /dev/null +++ b/src/main/java/com/mtvs/devlinkbackend/oauth2/entity/UserClientIndividual.java @@ -0,0 +1,29 @@ +package com.mtvs.devlinkbackend.oauth2.entity; + +import jakarta.persistence.Column; +import jakarta.persistence.DiscriminatorValue; +import jakarta.persistence.Entity; +import jakarta.persistence.Table; +import lombok.Getter; +import lombok.Setter; + +@Table(name = "USER_CLIENT_INDIVIDUAL") +@Entity(name = "UserClientIndividual") +@DiscriminatorValue("UserClientIndividual") // purpose 값으로 지정 +@Getter @Setter +public class UserClientIndividual extends User { + @Column(name = "NAME") + private String name; + + @Column(name = "PHONE") + private String phone; + + public UserClientIndividual() { + } + + public UserClientIndividual(String accountId, String purpose, String name, String phone) { + super(accountId, purpose); + this.name = name; + this.phone = phone; + } +} diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/entity/UserPartner.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/entity/UserPartner.java new file mode 100644 index 0000000..4e9c4a4 --- /dev/null +++ b/src/main/java/com/mtvs/devlinkbackend/oauth2/entity/UserPartner.java @@ -0,0 +1,58 @@ +package com.mtvs.devlinkbackend.oauth2.entity; + +import com.mtvs.devlinkbackend.util.StringListConverter; +import jakarta.persistence.*; +import lombok.Getter; +import lombok.Setter; + +import java.util.List; +import java.util.Map; + +@Table(name = "USER_PARTNER") +@Entity(name = "UserPartner") +@DiscriminatorValue("UserPartner") // purpose 값으로 지정 +@Getter @Setter +public class UserPartner extends User { + @Column(name = "NICKNAME") + private String nickname; + + @Column(name = "NAME") + private String name; + + @Column(name = "EMAIL") + private String email; + + @Column(name = "PHONE") + private String phone; + + @Convert(converter = StringListConverter.class) + @Column(name = "PORTFOLIO_LIST", columnDefinition = "TEXT") + private List portfolioList; + + @Column(name = "EXPERIENCE", columnDefinition = "TEXT") // 경력 기술 + private String experience; + + @ElementCollection + @CollectionTable(name = "SKILL", joinColumns = @JoinColumn(name = "SKILL_ID")) + @MapKeyColumn(name = "SKILL_NAME") + @Column(name = "SKILL_PROFICIENCY") + private Map skillSet; + + @Column(name = "MESSAGE", columnDefinition = "TEXT") // 하고 싶은 말 + private String messsage; + + public UserPartner(String accountId, String purpose, String nickname, String name, String email, String phone, List portfolioList, String experience, Map skillSet, String messsage) { + super(accountId, purpose); + this.nickname = nickname; + this.name = name; + this.email = email; + this.phone = phone; + this.portfolioList = portfolioList; + this.experience = experience; + this.skillSet = skillSet; + this.messsage = messsage; + } + + +} + diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/repository/UserClientGroupRepository.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/repository/UserClientGroupRepository.java new file mode 100644 index 0000000..80ca3c1 --- /dev/null +++ b/src/main/java/com/mtvs/devlinkbackend/oauth2/repository/UserClientGroupRepository.java @@ -0,0 +1,22 @@ +package com.mtvs.devlinkbackend.oauth2.repository; + +import com.mtvs.devlinkbackend.oauth2.entity.UserClientGroup; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +import java.util.List; + +@Repository +public interface UserClientGroupRepository extends JpaRepository { + UserClientGroup findUserClientGroupByAccountId(String accountId); + + List findByManagerNameContainingIgnoreCase(String managerName); + + List findByGroupNameContainingIgnoreCase(String groupName); + + List findByClientType(String clientType); + + List findByManagerPhone(String managerPhone); + + void deleteByAccountId(String accountId); +} diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/repository/UserClientIndividualRepository.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/repository/UserClientIndividualRepository.java new file mode 100644 index 0000000..b02a230 --- /dev/null +++ b/src/main/java/com/mtvs/devlinkbackend/oauth2/repository/UserClientIndividualRepository.java @@ -0,0 +1,18 @@ +package com.mtvs.devlinkbackend.oauth2.repository; + +import com.mtvs.devlinkbackend.oauth2.entity.UserClientIndividual; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +import java.util.List; + +@Repository +public interface UserClientIndividualRepository extends JpaRepository { + UserClientIndividual findUserClientIndividualByAccountId(String accountId); + + List findUserClientIndividualsByNameContainingIgnoreCase(String name); + + List findUserClientIndividualsByPhone(String phone); + + void deleteByAccountId(String accountId); +} diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/repository/UserPartnersRepository.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/repository/UserPartnersRepository.java new file mode 100644 index 0000000..a82e005 --- /dev/null +++ b/src/main/java/com/mtvs/devlinkbackend/oauth2/repository/UserPartnersRepository.java @@ -0,0 +1,29 @@ +package com.mtvs.devlinkbackend.oauth2.repository; + +import com.mtvs.devlinkbackend.oauth2.entity.UserPartner; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; +import org.springframework.stereotype.Repository; + +import java.util.List; + +@Repository +public interface UserPartnersRepository extends JpaRepository { + UserPartner findUserPartnerByAccountId(String accountId); + + UserPartner findUserPartnerByPhone(String phone); + + List findUserPartnersByNameContainingIgnoreCase(String name); + + List findUserPartnersByNicknameContainingIgnoreCase(String nickname); + + List findUserPartnersByEmail(String email); + + @Query("SELECT u FROM UserPartner u JOIN u.skillSet s WHERE KEY(s) = :skillName AND VALUE(s) >= :proficiency") + List findBySkillSetWithMinProficiency( + @Param("skillName") String skillName, @Param("proficiency") Integer proficiency + ); + + void deleteUserByAccountId(String accountId); +} diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/repository/UserRepository.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/repository/UserRepository.java index 1c5dc0a..b038141 100644 --- a/src/main/java/com/mtvs/devlinkbackend/oauth2/repository/UserRepository.java +++ b/src/main/java/com/mtvs/devlinkbackend/oauth2/repository/UserRepository.java @@ -2,10 +2,8 @@ import com.mtvs.devlinkbackend.oauth2.entity.User; import org.springframework.data.jpa.repository.JpaRepository; -import org.springframework.stereotype.Repository; -@Repository public interface UserRepository extends JpaRepository { User findUserByAccountId(String accountId); - void deleteUserByAccountId(String accountId); + void deleteByAccountId(String accountId); } diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/service/EpicGamesTokenService.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/service/EpicGamesTokenService.java index 64c6cd8..2fd1285 100644 --- a/src/main/java/com/mtvs/devlinkbackend/oauth2/service/EpicGamesTokenService.java +++ b/src/main/java/com/mtvs/devlinkbackend/oauth2/service/EpicGamesTokenService.java @@ -1,6 +1,6 @@ package com.mtvs.devlinkbackend.oauth2.service; -import com.mtvs.devlinkbackend.config.JwtUtil; +import com.mtvs.devlinkbackend.util.JwtUtil; import com.mtvs.devlinkbackend.oauth2.component.EpicGamesJWKCache; import org.springframework.beans.factory.annotation.Value; import org.springframework.core.ParameterizedTypeReference; @@ -83,7 +83,7 @@ public List> getEpicGamesUserAccount(String authorizationHea HttpHeaders headers = new HttpHeaders(); // Bearer Authentication 헤더 추가 - headers.set("Authorization", authorizationHeader); + headers.set("Authorization", authorizationHeader.replaceAll("\\r?\\n","")); headers.set("Content-Type", "application/x-www-form-urlencoded"); HttpEntity> request = new HttpEntity<>(new LinkedMultiValueMap<>(), headers); diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/service/UserClientGroupService.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/service/UserClientGroupService.java new file mode 100644 index 0000000..cf92533 --- /dev/null +++ b/src/main/java/com/mtvs/devlinkbackend/oauth2/service/UserClientGroupService.java @@ -0,0 +1,71 @@ +package com.mtvs.devlinkbackend.oauth2.service; + +import com.mtvs.devlinkbackend.oauth2.dto.UserClientGroupRequestDTO; +import com.mtvs.devlinkbackend.oauth2.entity.UserClientGroup; +import com.mtvs.devlinkbackend.oauth2.repository.UserClientGroupRepository; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.util.List; + +@Service +public class UserClientGroupService { + private final UserClientGroupRepository userClientGroupRepository; + + public UserClientGroupService(UserClientGroupRepository userClientGroupRepository) { + this.userClientGroupRepository = userClientGroupRepository; + } + + @Transactional + public UserClientGroup registUserClientGroup(UserClientGroupRequestDTO userClientGroupRequestDTO, + String accountId) { + return userClientGroupRepository.save(new UserClientGroup( + accountId, + userClientGroupRequestDTO.getPurpose(), + userClientGroupRequestDTO.getClientType(), + userClientGroupRequestDTO.getGroupName(), + userClientGroupRequestDTO.getManagerName(), + userClientGroupRequestDTO.getManagerPhone() + )); + } + public UserClientGroup findUserClientGroupByAccountId(String accountId) { + return userClientGroupRepository.findUserClientGroupByAccountId(accountId); + + }; + public List findByManagerNameContainingIgnoreCase(String managerName) { + return userClientGroupRepository.findByManagerNameContainingIgnoreCase(managerName); + + }; + public List findByGroupNameContainingIgnoreCase(String groupName) { + return userClientGroupRepository.findByGroupNameContainingIgnoreCase(groupName); + + }; + public List findByClientType(String clientType) { + return userClientGroupRepository.findByClientType(clientType); + + }; + public List findByManagerPhone(String managerPhone) { + return userClientGroupRepository.findByManagerPhone(managerPhone); + + }; + + @Transactional + public UserClientGroup updateUserClientGroup(UserClientGroupRequestDTO userClientGroupRequestDTO, + String accountId) { + + UserClientGroup userClientGroup = userClientGroupRepository.findUserClientGroupByAccountId(accountId); + if (userClientGroup == null) + throw new IllegalArgumentException("잘못된 계정으로 그룹 정보 수정 시도"); + + userClientGroup.setClientType(userClientGroupRequestDTO.getClientType()); + userClientGroup.setGroupName(userClientGroup.getGroupName()); + userClientGroup.setManagerName(userClientGroup.getManagerName()); + userClientGroup.setManagerPhone(userClientGroup.getManagerPhone()); + + return userClientGroup; + } + + public void deleteByAccountId(String accountId) { + userClientGroupRepository.deleteByAccountId(accountId); + } +} diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/service/UserClientIndividualService.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/service/UserClientIndividualService.java new file mode 100644 index 0000000..6d3331d --- /dev/null +++ b/src/main/java/com/mtvs/devlinkbackend/oauth2/service/UserClientIndividualService.java @@ -0,0 +1,61 @@ +package com.mtvs.devlinkbackend.oauth2.service; + +import com.mtvs.devlinkbackend.oauth2.dto.UserClientIndividualRequestDTO; +import com.mtvs.devlinkbackend.oauth2.entity.UserClientIndividual; +import com.mtvs.devlinkbackend.oauth2.repository.UserClientIndividualRepository; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.util.List; + +@Service +public class UserClientIndividualService { + + private final UserClientIndividualRepository userClientIndividualRepository; + + public UserClientIndividualService(UserClientIndividualRepository userClientIndividualRepository) { + this.userClientIndividualRepository = userClientIndividualRepository; + } + + @Transactional + public UserClientIndividual registUserClientIndividual(UserClientIndividualRequestDTO userClientIndividualRequestDTO, + String accountId) { + + return userClientIndividualRepository.save(new UserClientIndividual( + accountId, + userClientIndividualRequestDTO.getPurpose(), + userClientIndividualRequestDTO.getName(), + userClientIndividualRequestDTO.getPhone() + )); + } + public UserClientIndividual findUserClientIndividualByAccountId(String accountId) { + return userClientIndividualRepository.findUserClientIndividualByAccountId(accountId); + + }; + public List findUserClientIndividualsByNameContainingIgnoreCase(String name) { + return userClientIndividualRepository.findUserClientIndividualsByNameContainingIgnoreCase(name); + + }; + public List findUserClientIndividualsByPhone(String phone) { + return userClientIndividualRepository.findUserClientIndividualsByPhone(phone); + + }; + + @Transactional + public UserClientIndividual updateUserClientIndividual(UserClientIndividualRequestDTO userClientIndividualRequestDTO, + String accountId) { + + UserClientIndividual userClientIndividual = userClientIndividualRepository.findUserClientIndividualByAccountId(accountId); + if(userClientIndividual == null) + throw new IllegalArgumentException("잘못된 계정으로 개인 정보 수정 시도"); + + userClientIndividual.setName(userClientIndividualRequestDTO.getName()); + userClientIndividual.setPhone(userClientIndividualRequestDTO.getPhone()); + + return userClientIndividual; + } + + public void deleteByAccountId(String accountId) { + userClientIndividualRepository.deleteByAccountId(accountId); + }; +} diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/service/UserPartnerService.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/service/UserPartnerService.java new file mode 100644 index 0000000..547cbef --- /dev/null +++ b/src/main/java/com/mtvs/devlinkbackend/oauth2/service/UserPartnerService.java @@ -0,0 +1,80 @@ +package com.mtvs.devlinkbackend.oauth2.service; + +import com.mtvs.devlinkbackend.oauth2.dto.UserPartnerRequestDTO; +import com.mtvs.devlinkbackend.oauth2.entity.UserPartner; +import com.mtvs.devlinkbackend.oauth2.repository.UserPartnersRepository; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.util.List; + +@Service +public class UserPartnerService { + private final UserPartnersRepository userPartnersRepository; + + public UserPartnerService(UserPartnersRepository userPartnersRepository) { + this.userPartnersRepository = userPartnersRepository; + } + + @Transactional + public UserPartner registUserPartner(UserPartnerRequestDTO userPartnerRequestDTO, + String accountId) { + + return userPartnersRepository.save(new UserPartner( + accountId, + userPartnerRequestDTO.getPurpose(), + userPartnerRequestDTO.getNickname(), + userPartnerRequestDTO.getName(), + userPartnerRequestDTO.getEmail(), + userPartnerRequestDTO.getPhone(), + userPartnerRequestDTO.getPortfolioList(), + userPartnerRequestDTO.getExperience(), + userPartnerRequestDTO.getSkillSet(), + userPartnerRequestDTO.getMessage() + )); + } + + public UserPartner findUserPartnerByAccountId(String accountId) { + return userPartnersRepository.findUserPartnerByAccountId(accountId); + }; + + public List findUserPartnersByNameContainingIgnoreCase(String name) { + return userPartnersRepository.findUserPartnersByNameContainingIgnoreCase(name); + }; + + public List findUserPartnersByNicknameContainingIgnoreCase(String nickname) { + return userPartnersRepository.findUserPartnersByNicknameContainingIgnoreCase(nickname); + }; + + public List findUserPartnersByEmail(String email) { + return userPartnersRepository.findUserPartnersByEmail(email); + }; + + public UserPartner findUserPartnerByPhone(String phone) { + return userPartnersRepository.findUserPartnerByPhone(phone); + }; + + @Transactional + public UserPartner updateUserPartner(UserPartnerRequestDTO userPartnerRequestDTO, + String accountId) { + + UserPartner userPartner = userPartnersRepository.findUserPartnerByAccountId(accountId); + if(userPartner == null) + throw new IllegalArgumentException("잘못된 계정으로 파트너스 정보 수정 시도"); + + userPartner.setNickname(userPartnerRequestDTO.getNickname()); + userPartner.setName(userPartnerRequestDTO.getName()); + userPartner.setEmail(userPartnerRequestDTO.getEmail()); + userPartner.setPhone(userPartnerRequestDTO.getPhone()); + userPartner.setPortfolioList(userPartnerRequestDTO.getPortfolioList()); + userPartner.setExperience(userPartnerRequestDTO.getExperience()); + userPartner.setSkillSet(userPartnerRequestDTO.getSkillSet()); + userPartner.setMesssage(userPartnerRequestDTO.getMessage()); + + return userPartner; + } + + public void deleteByAccountId(String accountId) { + userPartnersRepository.deleteUserByAccountId(accountId); + } +} diff --git a/src/main/java/com/mtvs/devlinkbackend/oauth2/service/UserService.java b/src/main/java/com/mtvs/devlinkbackend/oauth2/service/UserService.java index fdb5882..1f99717 100644 --- a/src/main/java/com/mtvs/devlinkbackend/oauth2/service/UserService.java +++ b/src/main/java/com/mtvs/devlinkbackend/oauth2/service/UserService.java @@ -1,70 +1,29 @@ package com.mtvs.devlinkbackend.oauth2.service; -import com.mtvs.devlinkbackend.config.JwtUtil; -import com.mtvs.devlinkbackend.oauth2.dto.UserUpdateRequestDTO; import com.mtvs.devlinkbackend.oauth2.entity.User; import com.mtvs.devlinkbackend.oauth2.repository.UserRepository; +import com.mtvs.devlinkbackend.util.JwtUtil; import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; @Service public class UserService { - - private final UserRepository userRepository; private final JwtUtil jwtUtil; + private final UserRepository userRepository; - public UserService(UserRepository userRepository, JwtUtil jwtUtil) { - this.userRepository = userRepository; + public UserService(JwtUtil jwtUtil, UserRepository userRepository) { this.jwtUtil = jwtUtil; + this.userRepository = userRepository; } - public User registUserByAccessToken(String accessToken) { - try { - String accountId = jwtUtil.getSubjectFromAuthHeaderWithoutAuth(accessToken); - return userRepository.save(new User( - accountId - )); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - public User findUserByAuthorizationHeader(String authorizationHeader) { - try { - String accountId = jwtUtil.getSubjectFromAuthHeaderWithoutAuth(extractToken(authorizationHeader)); - return userRepository.findUserByAccountId(accountId); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - public void updateUserByAccessToken(String accessToken, UserUpdateRequestDTO userUpdateRequestDTO) { - try { - String accountId = jwtUtil.getSubjectFromAuthHeaderWithoutAuth(accessToken); - User user = userRepository.findUserByAccountId(accountId); - if(user != null) { - user.setEmail(userUpdateRequestDTO.getEmail()); - user.setUserName(userUpdateRequestDTO.getUserName()); - } - else throw new RuntimeException("user not found"); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - public void deleteUserByAccessToken(String accessToken) { - try { - String accountId = jwtUtil.getSubjectFromAuthHeaderWithAuth(accessToken); - userRepository.deleteUserByAccountId(accountId); - } catch (Exception e) { - throw new RuntimeException(e); - } + @Transactional + public User registUserByAuthorizationHeader(String authorizationHeader) throws Exception { + String accountId = jwtUtil.getSubjectFromAuthHeaderWithoutAuth(authorizationHeader); + return userRepository.save(new User(accountId)); } - private String extractToken(String authorizationHeader) { - if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) { - return authorizationHeader.substring(7); - } else { - throw new IllegalArgumentException("Authorization header must start with 'Bearer '"); - } + public User findUserByAuthorizationHeader(String authorizationHeader) throws Exception { + String accountId = jwtUtil.getSubjectFromAuthHeaderWithoutAuth(authorizationHeader); + return userRepository.findUserByAccountId(accountId); } } diff --git a/src/main/java/com/mtvs/devlinkbackend/question/controller/QuestionController.java b/src/main/java/com/mtvs/devlinkbackend/question/controller/QuestionController.java index c51567d..c331915 100644 --- a/src/main/java/com/mtvs/devlinkbackend/question/controller/QuestionController.java +++ b/src/main/java/com/mtvs/devlinkbackend/question/controller/QuestionController.java @@ -1,6 +1,6 @@ package com.mtvs.devlinkbackend.question.controller; -import com.mtvs.devlinkbackend.config.JwtUtil; +import com.mtvs.devlinkbackend.util.JwtUtil; import com.mtvs.devlinkbackend.question.dto.QuestionRegistRequestDTO; import com.mtvs.devlinkbackend.question.dto.QuestionUpdateRequestDTO; import com.mtvs.devlinkbackend.question.entity.Question; diff --git a/src/main/java/com/mtvs/devlinkbackend/reply/controller/ReplyController.java b/src/main/java/com/mtvs/devlinkbackend/reply/controller/ReplyController.java index e010ac2..e5f67b1 100644 --- a/src/main/java/com/mtvs/devlinkbackend/reply/controller/ReplyController.java +++ b/src/main/java/com/mtvs/devlinkbackend/reply/controller/ReplyController.java @@ -1,6 +1,6 @@ package com.mtvs.devlinkbackend.reply.controller; -import com.mtvs.devlinkbackend.config.JwtUtil; +import com.mtvs.devlinkbackend.util.JwtUtil; import com.mtvs.devlinkbackend.reply.dto.ReplyRegistRequestDTO; import com.mtvs.devlinkbackend.reply.dto.ReplyUpdateRequestDTO; import com.mtvs.devlinkbackend.reply.entity.Reply; diff --git a/src/main/java/com/mtvs/devlinkbackend/request/controller/RequestController.java b/src/main/java/com/mtvs/devlinkbackend/request/controller/RequestController.java index 76f7f67..b968fa3 100644 --- a/src/main/java/com/mtvs/devlinkbackend/request/controller/RequestController.java +++ b/src/main/java/com/mtvs/devlinkbackend/request/controller/RequestController.java @@ -1,6 +1,6 @@ package com.mtvs.devlinkbackend.request.controller; -import com.mtvs.devlinkbackend.config.JwtUtil; +import com.mtvs.devlinkbackend.util.JwtUtil; import com.mtvs.devlinkbackend.request.dto.RequestRegistRequestDTO; import com.mtvs.devlinkbackend.request.dto.RequestUpdateRequestDTO; import com.mtvs.devlinkbackend.request.entity.Request; diff --git a/src/main/java/com/mtvs/devlinkbackend/team/controller/TeamController.java b/src/main/java/com/mtvs/devlinkbackend/team/controller/TeamController.java index 4ed5681..2a92939 100644 --- a/src/main/java/com/mtvs/devlinkbackend/team/controller/TeamController.java +++ b/src/main/java/com/mtvs/devlinkbackend/team/controller/TeamController.java @@ -1,6 +1,6 @@ package com.mtvs.devlinkbackend.team.controller; -import com.mtvs.devlinkbackend.config.JwtUtil; +import com.mtvs.devlinkbackend.util.JwtUtil; import com.mtvs.devlinkbackend.team.dto.TeamMemberModifyRequestDTO; import com.mtvs.devlinkbackend.team.dto.TeamRegistRequestDTO; import com.mtvs.devlinkbackend.team.dto.TeamUpdateRequestDTO; diff --git a/src/main/java/com/mtvs/devlinkbackend/config/JwtUtil.java b/src/main/java/com/mtvs/devlinkbackend/util/JwtUtil.java similarity index 98% rename from src/main/java/com/mtvs/devlinkbackend/config/JwtUtil.java rename to src/main/java/com/mtvs/devlinkbackend/util/JwtUtil.java index 0947631..afa36bb 100644 --- a/src/main/java/com/mtvs/devlinkbackend/config/JwtUtil.java +++ b/src/main/java/com/mtvs/devlinkbackend/util/JwtUtil.java @@ -1,4 +1,4 @@ -package com.mtvs.devlinkbackend.config; +package com.mtvs.devlinkbackend.util; import com.mtvs.devlinkbackend.oauth2.component.EpicGamesJWKCache; import com.nimbusds.jose.JWSAlgorithm; @@ -31,6 +31,7 @@ public JwtUtil(EpicGamesJWKCache jwkCache) { public Map getClaimsFromAuthHeaderWithAuth(String authorizationHeader) throws Exception { // Claims 검증 JWTClaimsSet claims = getClaimsFromToken(extractToken(authorizationHeader)); + System.out.println(claims); validateClaims(claims); // 검증이 완료되었을 경우 모든 Claims을 Map으로 변환하여 반환 diff --git a/src/main/java/com/mtvs/devlinkbackend/util/StringListConverter.java b/src/main/java/com/mtvs/devlinkbackend/util/StringListConverter.java new file mode 100644 index 0000000..8f9b2c4 --- /dev/null +++ b/src/main/java/com/mtvs/devlinkbackend/util/StringListConverter.java @@ -0,0 +1,34 @@ +package com.mtvs.devlinkbackend.util; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import jakarta.persistence.AttributeConverter; +import jakarta.persistence.Converter; + +import java.io.IOException; +import java.util.Arrays; +import java.util.List; + +@Converter +public class StringListConverter implements AttributeConverter, String> { + + private final ObjectMapper objectMapper = new ObjectMapper(); + + @Override + public String convertToDatabaseColumn(List attribute) { + try { + return objectMapper.writeValueAsString(attribute); + } catch (JsonProcessingException e) { + throw new RuntimeException("Could not convert list to JSON", e); + } + } + + @Override + public List convertToEntityAttribute(String dbData) { + try { + return Arrays.asList(objectMapper.readValue(dbData, String[].class)); + } catch (IOException e) { + throw new RuntimeException("Could not convert JSON to list", e); + } + } +} \ No newline at end of file diff --git a/src/test/java/com/mtvs/devlinkbackend/crud/CommentCRUDTest.java b/src/test/java/com/mtvs/devlinkbackend/crud/CommentCRUDTest.java index 451166f..c734d91 100644 --- a/src/test/java/com/mtvs/devlinkbackend/crud/CommentCRUDTest.java +++ b/src/test/java/com/mtvs/devlinkbackend/crud/CommentCRUDTest.java @@ -31,8 +31,8 @@ private static Stream newComment() { private static Stream modifiedComment() { return Stream.of( - Arguments.of(new CommentUpdateRequestDTO(1L, "내용0"), "계정1"), - Arguments.of(new CommentUpdateRequestDTO(2L, "내용00"), "계정2") + Arguments.of(new CommentUpdateRequestDTO(3L, "내용0"), "계정1"), + Arguments.of(new CommentUpdateRequestDTO(4L, "내용00"), "계정2") ); } diff --git a/src/test/java/com/mtvs/devlinkbackend/crud/UserClientGroupCRUDTest.java b/src/test/java/com/mtvs/devlinkbackend/crud/UserClientGroupCRUDTest.java new file mode 100644 index 0000000..14ffcc2 --- /dev/null +++ b/src/test/java/com/mtvs/devlinkbackend/crud/UserClientGroupCRUDTest.java @@ -0,0 +1,143 @@ +package com.mtvs.devlinkbackend.crud; + +import com.mtvs.devlinkbackend.oauth2.dto.UserClientGroupRequestDTO; +import com.mtvs.devlinkbackend.oauth2.service.UserClientGroupService; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Order; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.transaction.annotation.Transactional; +import java.util.stream.Stream; + +@SpringBootTest +@Transactional +public class UserClientGroupCRUDTest { + @Autowired + private UserClientGroupService userClientGroupService; + + private static Stream registUserClientGroup() { + return Stream.of( + Arguments.of(new UserClientGroupRequestDTO( + "UserClientGroup", + "팀", + "그룹이름3", + "담당자이름3", + "담당자핸드폰번호3" + ), "계정3"), + Arguments.of(new UserClientGroupRequestDTO( + "UserClientGroup", + "팀2", + "그룹이름4", + "담당자이름4", + "담당자핸드폰번호4" + ), "계정4") + ); + } + + private static Stream modifyUserClientGroup() { + return Stream.of( + Arguments.of(new UserClientGroupRequestDTO( + "UserClientGroup", + "팀", + "그룹이름2", + "담당자이름2", + "담당자핸드폰번호2" + ), "계정1"), + Arguments.of(new UserClientGroupRequestDTO( + "UserClientGroup", + "팀", + "그룹이름1", + "담당자이름1", + "담당자핸드폰번호1" + ), "계정2") + ); + } + + @BeforeEach + public void setUp() { + userClientGroupService.registUserClientGroup(new UserClientGroupRequestDTO( + "UserClientGroup", + "팀", + "그룹이름1", + "담당자이름1", + "담당자핸드폰번호1" + ), "계정1"); + userClientGroupService.registUserClientGroup(new UserClientGroupRequestDTO( + "UserClientGroup", + "팀", + "그룹이름2", + "담당자이름2", + "담당자핸드폰번호2" + ), "계정2"); + } + + @Order(1) + @DisplayName("UserClientGroup 등록") + @MethodSource("registUserClientGroup") + @ParameterizedTest + public void testRegistUserClientGroup(UserClientGroupRequestDTO UserClientGroupRequestDTO, String accountId) { + Assertions.assertDoesNotThrow(() -> userClientGroupService.registUserClientGroup(UserClientGroupRequestDTO, accountId)); + } + + @Order(2) + @DisplayName("계정 ID로 UserClientGroup 조회") + @ValueSource(strings = {"계정1", "계정2"}) + @ParameterizedTest + public void testFindUserClientGroupByAccountId(String accountId) { + Assertions.assertDoesNotThrow(() -> userClientGroupService.findUserClientGroupByAccountId(accountId)); + } + + @Order(3) + @DisplayName("담당자이름으로 UserClientGroup 조회") + @ValueSource(strings = {"담당자이름1", "담당자이름2"}) + @ParameterizedTest + public void findByManagerNameContainingIgnoreCase(String managerName) { + Assertions.assertDoesNotThrow(() -> userClientGroupService.findByManagerNameContainingIgnoreCase(managerName)); + } + + @Order(4) + @DisplayName("그룹이름으로 UserClientGroup 조회") + @ValueSource(strings = {"그룹이름1", "그룹이름2"}) + @ParameterizedTest + public void testFindByGroupNameContainingIgnoreCase(String groupName) { + Assertions.assertDoesNotThrow(() -> userClientGroupService.findByGroupNameContainingIgnoreCase(groupName)); + } + + @Order(5) + @DisplayName("이메일로 UserClientGroup 조회") + @ValueSource(strings = {"팀", "법인"}) + @ParameterizedTest + public void testFindUserClientGroupsByEmail(String clientType) { + Assertions.assertDoesNotThrow(() -> userClientGroupService.findByClientType(clientType)); + } + + @Order(6) + @DisplayName("담당자 핸드폰 번호로 UserClientGroup 조회") + @ValueSource(strings = {"담당자핸드폰1", "담당자핸드폰2"}) + @ParameterizedTest + public void testFindUserClientGroupByPhone(String managerPhone) { + Assertions.assertDoesNotThrow(() -> userClientGroupService.findByManagerPhone(managerPhone)); + } + + @Order(7) + @DisplayName("UserClientGroup 수정") + @MethodSource("modifyUserClientGroup") + @ParameterizedTest + public void testUpdateUserClientGroup(UserClientGroupRequestDTO UserClientGroupRequestDTO, String accountId) { + Assertions.assertDoesNotThrow(() -> userClientGroupService.updateUserClientGroup(UserClientGroupRequestDTO, accountId)); + } + + @Order(8) + @DisplayName("UserClientGroup 삭제") + @ValueSource(strings = {"계정1", "계정2"}) + @ParameterizedTest + public void testDeleteByAccountId(String accountId) { + Assertions.assertDoesNotThrow(() -> userClientGroupService.deleteByAccountId(accountId)); + } +} diff --git a/src/test/java/com/mtvs/devlinkbackend/crud/UserClientIndividualCRUDTest.java b/src/test/java/com/mtvs/devlinkbackend/crud/UserClientIndividualCRUDTest.java new file mode 100644 index 0000000..e0f8c35 --- /dev/null +++ b/src/test/java/com/mtvs/devlinkbackend/crud/UserClientIndividualCRUDTest.java @@ -0,0 +1,117 @@ +package com.mtvs.devlinkbackend.crud; + +import com.mtvs.devlinkbackend.oauth2.dto.UserClientIndividualRequestDTO; +import com.mtvs.devlinkbackend.oauth2.service.UserClientIndividualService; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Order; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.transaction.annotation.Transactional; + +import java.util.stream.Stream; + +@SpringBootTest +@Transactional +public class UserClientIndividualCRUDTest { + + @Autowired + private UserClientIndividualService userClientIndividualService; + + private static Stream registUserClientIndividual() { + return Stream.of( + Arguments.of(new UserClientIndividualRequestDTO( + "UserClientIndividual", + "이름3", + "핸드폰번호3" + ), "계정3"), + Arguments.of(new UserClientIndividualRequestDTO( + "UserClientIndividual", + "이름4", + "핸드폰번호4" + ), "계정4") + ); + } + + private static Stream modifyUserClientIndividual() { + return Stream.of( + Arguments.of(new UserClientIndividualRequestDTO( + "UserClientIndividual", + "이름2", + "핸드폰번호2" + ), "계정1"), + Arguments.of(new UserClientIndividualRequestDTO( + "UserClientIndividual", + "이름1", + "핸드폰번호1" + ), "계정2") + ); + } + + @BeforeEach + public void setUp() { + userClientIndividualService.registUserClientIndividual(new UserClientIndividualRequestDTO( + "UserClientIndividual", + "이름1", + "핸드폰번호1" + ), "계정1"); + userClientIndividualService.registUserClientIndividual(new UserClientIndividualRequestDTO( + "UserClientIndividual", + "이름2", + "핸드폰번호2" + ), "계정2"); + } + + @Order(1) + @DisplayName("UserClientIndividual 등록") + @MethodSource("registUserClientIndividual") + @ParameterizedTest + public void testRegistUserClientIndividual(UserClientIndividualRequestDTO UserClientIndividualRequestDTO, String accountId) { + Assertions.assertDoesNotThrow(() -> userClientIndividualService.registUserClientIndividual(UserClientIndividualRequestDTO, accountId)); + } + + @Order(2) + @DisplayName("계정 ID로 UserClientIndividual 조회") + @ValueSource(strings = {"계정1", "계정2"}) + @ParameterizedTest + public void testFindUserClientIndividualByAccountId(String accountId) { + Assertions.assertDoesNotThrow(() -> userClientIndividualService.findUserClientIndividualByAccountId(accountId)); + } + + @Order(3) + @DisplayName("이름으로 UserClientIndividual 조회") + @ValueSource(strings = {"이름1", "이름2"}) + @ParameterizedTest + public void findByManagerNameContainingIgnoreCase(String name) { + Assertions.assertDoesNotThrow(() -> userClientIndividualService.findUserClientIndividualsByNameContainingIgnoreCase(name)); + } + + @Order(4) + @DisplayName("핸드폰 번호로 UserClientIndividual 조회") + @ValueSource(strings = {"핸드폰1", "핸드폰2"}) + @ParameterizedTest + public void testFindUserClientIndividualByPhone(String phone) { + Assertions.assertDoesNotThrow(() -> userClientIndividualService.findUserClientIndividualsByPhone(phone)); + } + + @Order(5) + @DisplayName("UserClientIndividual 수정") + @MethodSource("modifyUserClientIndividual") + @ParameterizedTest + public void testUpdateUserClientIndividual(UserClientIndividualRequestDTO UserClientIndividualRequestDTO, String accountId) { + Assertions.assertDoesNotThrow(() -> userClientIndividualService.updateUserClientIndividual(UserClientIndividualRequestDTO, accountId)); + } + + @Order(6) + @DisplayName("UserClientIndividual 삭제") + @ValueSource(strings = {"계정1", "계정2"}) + @ParameterizedTest + public void testDeleteByAccountId(String accountId) { + Assertions.assertDoesNotThrow(() -> userClientIndividualService.deleteByAccountId(accountId)); + } +} diff --git a/src/test/java/com/mtvs/devlinkbackend/crud/UserPartnerCRUDTest.java b/src/test/java/com/mtvs/devlinkbackend/crud/UserPartnerCRUDTest.java new file mode 100644 index 0000000..2410f89 --- /dev/null +++ b/src/test/java/com/mtvs/devlinkbackend/crud/UserPartnerCRUDTest.java @@ -0,0 +1,171 @@ +package com.mtvs.devlinkbackend.crud; + +import com.mtvs.devlinkbackend.oauth2.dto.UserPartnerRequestDTO; +import com.mtvs.devlinkbackend.oauth2.service.UserPartnerService; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Order; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.transaction.annotation.Transactional; + +import java.util.List; +import java.util.Map; +import java.util.stream.Stream; + +@SpringBootTest +@Transactional +public class UserPartnerCRUDTest { + + @Autowired + private UserPartnerService userPartnerService; + + private static Stream registUserPartner() { + return Stream.of( + Arguments.of(new UserPartnerRequestDTO( + "UserClientPartner", + "닉네임3", + "이름3", + "이메일3", + "핸드폰3", + List.of("http://s","http://w"), + "경험3", + Map.of("Java",3), + "하고싶은말3" + ), "계정3"), + Arguments.of(new UserPartnerRequestDTO( + "UserClientPartner", + "닉네임4", + "이름4", + "이메일4", + "핸드폰4", + List.of("http://s","http://w"), + "경험4", + Map.of("Java",1), + "하고싶은말4" + ), "계정4") + ); + } + + private static Stream modifyUserPartner() { + return Stream.of( + Arguments.of(new UserPartnerRequestDTO( + "UserClientPartner", + "닉네임1", + "이름1", + "이메일1", + "핸드폰1", + List.of("http://s","http://w"), + "경험1", + Map.of("Java",3), + "하고싶은말1" + ), "계정1"), + Arguments.of(new UserPartnerRequestDTO( + "UserClientPartner", + "닉네임2", + "이름2", + "이메일2", + "핸드폰2", + List.of("http://s","http://w"), + "경험2", + Map.of("Java",1), + "하고싶은말2" + ), "계정2") + ); + } + + @BeforeEach + public void setUp() { + userPartnerService.registUserPartner(new UserPartnerRequestDTO( + "UserClientPartner", + "닉네임1", + "이름1", + "이메일1", + "핸드폰1", + List.of("http://s","http://w"), + "경험1", + Map.of("Java",3), + "하고싶은말1" + ), "계정1"); + userPartnerService.registUserPartner(new UserPartnerRequestDTO( + "UserClientPartner", + "닉네임2", + "이름2", + "이메일2", + "핸드폰2", + List.of("http://s","http://w"), + "경험2", + Map.of("Java",1), + "하고싶은말2" + ), "계정2"); + } + + @Order(1) + @DisplayName("UserPartner 등록") + @MethodSource("registUserPartner") + @ParameterizedTest + public void testRegistUserPartner(UserPartnerRequestDTO userPartnerRequestDTO, String accountId) { + Assertions.assertDoesNotThrow(() -> userPartnerService.registUserPartner(userPartnerRequestDTO, accountId)); + } + + @Order(2) + @DisplayName("계정 ID로 UserPartner 조회") + @ValueSource(strings = {"계정1", "계정2"}) + @ParameterizedTest + public void testFindUserPartnerByAccountId(String accountId) { + Assertions.assertDoesNotThrow(() -> userPartnerService.findUserPartnerByAccountId(accountId)); + } + + @Order(3) + @DisplayName("이름으로 UserPartner 조회") + @ValueSource(strings = {"이름1", "이름2"}) + @ParameterizedTest + public void testFindUserPartnersByNameContainingIgnoreCase(String name) { + Assertions.assertDoesNotThrow(() -> userPartnerService.findUserPartnersByNameContainingIgnoreCase(name)); + } + + @Order(4) + @DisplayName("닉네임으로 UserPartner 조회") + @ValueSource(strings = {"닉네임1", "닉네임2"}) + @ParameterizedTest + public void testFindUserPartnersByNicknameContainingIgnoreCase(String nickname) { + Assertions.assertDoesNotThrow(() -> userPartnerService.findUserPartnersByNicknameContainingIgnoreCase(nickname)); + } + + @Order(5) + @DisplayName("이메일로 UserPartner 조회") + @ValueSource(strings = {"계정1", "계정2"}) + @ParameterizedTest + public void testFindUserPartnersByEmail(String email) { + Assertions.assertDoesNotThrow(() -> userPartnerService.findUserPartnersByEmail(email)); + } + + @Order(6) + @DisplayName("핸드폰 번호로 UserPartner 조회") + @ValueSource(strings = {"핸드폰1", "핸드폰2"}) + @ParameterizedTest + public void testFindUserPartnerByPhone(String phone) { + Assertions.assertDoesNotThrow(() -> userPartnerService.findUserPartnerByPhone(phone)); + } + + @Order(7) + @DisplayName("UserPartner 수정") + @MethodSource("modifyUserPartner") + @ParameterizedTest + public void testUpdateUserPartner(UserPartnerRequestDTO userPartnerRequestDTO, String accountId) { + Assertions.assertDoesNotThrow(() -> userPartnerService.updateUserPartner(userPartnerRequestDTO, accountId)); + } + + @Order(8) + @DisplayName("UserPartner 삭제") + @ValueSource(strings = {"계정1", "계정2"}) + @ParameterizedTest + public void testDeleteByAccountId(String accountId) { + Assertions.assertDoesNotThrow(() -> userPartnerService.deleteByAccountId(accountId)); + } +}