Kim hwan jun

ping/src/main/java/com/b6122/ping/config/SecurityConfig.java

@@ -14,6 +14,7 @@
 import org.springframework.security.core.userdetails.UserDetailsService;
 import org.springframework.security.web.SecurityFilterChain;
 import org.springframework.security.web.context.SecurityContextPersistenceFilter;
+import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
 import org.springframework.web.filter.CorsFilter;
 
 @Configuration
@@ -45,11 +46,10 @@ public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Excepti
                 .httpBasic((httpBasic) -> httpBasic.disable()) //Bearer 방식을 사용하기 위해 basic 인증 비활성화
                 .authorizeHttpRequests((authorize) ->
                         authorize
-                                .requestMatchers("/user/**").hasAnyRole("ADMIN", "MANAGER", "USER")
+                                .requestMatchers("/oauth/jwt/**").permitAll()
                                 .requestMatchers("/admin/**").hasAnyRole("ADMIN")
-                                .anyRequest().permitAll());
-
-
+                                .requestMatchers("/**").hasAnyRole("ADMIN", "USER")
+                                .anyRequest().authenticated());
 
 
         return http.build();

ping/src/main/java/com/b6122/ping/config/jwt/JwtAuthorizationFilter.java

@@ -2,9 +2,14 @@
 
 import com.auth0.jwt.JWT;
 import com.auth0.jwt.algorithms.Algorithm;
+import com.auth0.jwt.exceptions.JWTVerificationException;
+import com.auth0.jwt.interfaces.DecodedJWT;
 import com.b6122.ping.auth.PrincipalDetails;
 import com.b6122.ping.domain.User;
+import com.b6122.ping.dto.UserDto;
 import com.b6122.ping.repository.UserRepository;
+import com.b6122.ping.repository.datajpa.UserDataRepository;
+import com.b6122.ping.service.JwtService;
 import jakarta.servlet.FilterChain;
 import jakarta.servlet.ServletException;
 import jakarta.servlet.http.HttpServletRequest;
@@ -16,10 +21,13 @@
 import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;
 
 import java.io.IOException;
+import java.util.Map;
 
 public class JwtAuthorizationFilter extends BasicAuthenticationFilter {
 
     private UserRepository userRepository;
+    private UserDataRepository userDataRepository;
+    private JwtService jwtService;
 
     public JwtAuthorizationFilter(AuthenticationManager authenticationManager, UserRepository userRepository) {
         super(authenticationManager);
@@ -38,9 +46,40 @@ protected void doFilterInternal(HttpServletRequest request, HttpServletResponse
         }
 
         //토큰 검증(동일한 토큰인지, 만료시간은 안지났는지 com.auth0.jwt 라이브러리가 확인해줌)
+        //access token과 refresh token을 검증
+        String username = null;
         String token = request.getHeader(JwtProperties.HEADER_STRING).replace(JwtProperties.TOKEN_PREFIX, "");
-        String username = JWT.require(Algorithm.HMAC512(JwtProperties.SECRET)).build().verify(token)
-                .getClaim("username").asString();
+        String tokenType = JWT.decode(token).getClaim("token_type").asString();
+
+        if (tokenType.equals("access")) {
+
+            try {
+                username = JWT.require(Algorithm.HMAC512(JwtProperties.SECRET)).build().verify(token).getClaim("username").asString();
+
+            } catch(JWTVerificationException e) {
+                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
+                response.getWriter().write("Access token is not valid. Please send refersh token.");
+                return;
+            }
+        } else if (tokenType.equals("refresh")) {
+
+            try {
+                username = JWT.require(Algorithm.HMAC512(JwtProperties.SECRET)).build().verify(token).getClaim("username").asString();
+                User user = userDataRepository.findByUsername(username).orElseThrow(RuntimeException::new);
+                UserDto userDto = new UserDto(user.getId(), user.getUsername());
+                Map<String, String> jwtAccessToken = jwtService.createJwtAccessToken(userDto);
+
+                //refersh token이 유효하면 access token 새로 발급
+                response.setStatus(HttpServletResponse.SC_OK);
+                response.getWriter().write("{\"access_token\": \"" + jwtAccessToken.get("access_token") + "\"}");
+                return;
+
+            } catch (JWTVerificationException e) {
+                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
+                response.getWriter().write("Refresh token is not valid. Please login again.");
+                return;
+            }
+        }
 
         if (username != null) {
             User user = userRepository.findByUsername(username);

ping/src/main/java/com/b6122/ping/controller/RestApiController.java

@@ -1,84 +1,173 @@
 package com.b6122.ping.controller;
 
+import com.b6122.ping.auth.PrincipalDetails;
+import com.b6122.ping.domain.Friendship;
 import com.b6122.ping.dto.UserDto;
-import com.b6122.ping.service.JwtService;
-import com.b6122.ping.service.KakaoOAuthService;
-import com.b6122.ping.service.UserService;
-import com.b6122.ping.service.GoogleOAuthService;
-import com.b6122.ping.service.NaverOAuthService;
+import com.b6122.ping.dto.UserProfileDto;
+import com.b6122.ping.service.*;
+import jakarta.persistence.EntityNotFoundException;
 import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.security.core.Authentication;
 import org.springframework.web.bind.annotation.*;
+
 import java.io.IOException;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.multipart.MultipartFile;
 
-import java.io.IOException;
+import java.util.HashMap;
 import java.util.Map;
+import java.util.Optional;
 
 
 @RestController
 @RequiredArgsConstructor
 public class RestApiController {
 
-    private final NaverOAuthService naverOAuthService;
     private final GoogleOAuthService googleOAuthService;
-
     private final JwtService jwtService;
     private final UserService userService;
-    private final KakaoOAuthService oAuthService;
+    private final KakaoOAuthService kakaoOAuthService;
+    private final FriendshipService friendshipService;
+
+    //프론트엔드로부터 authorization code 받고 -> 그 code로 카카오에 accesstoken 요청
+    // 받아 온 access token으로 카카오 리소스 서버로부터 카카오 유저 정보 가져오기
+    // 가져온 정보를 기반으로 회원가입
+    // jwt accessToken을 리액트 서버에 return
+    @PostMapping("/oauth/jwt/{serverName}")
+    public ResponseEntity<Map<String, Object>> oauthLogin(@PathVariable("serverName") String server,
+                                                         @RequestBody Map<String, Object> request) throws IOException {
+        if ("kakao".equals(server)) {
+            String accessToken = kakaoOAuthService.getKakaoAccessToken(request.get("code").toString());
+            Map<String, Object> userInfo = kakaoOAuthService.getKakaoUserInfo(accessToken);
+            UserDto userDto = userService.joinOAuthUser(userInfo);
+
+            return ResponseEntity.ok().body(jwtService.createJwtAccessAndRefreshToken(userDto));
+        } else if ("google".equals(server)) {
+            String accessToken = googleOAuthService.getGoogleAccessToken(request.get("code").toString());
+            Map<String, Object> userInfo = googleOAuthService.getGoogleUserInfo(accessToken);
+            UserDto userDto = userService.joinOAuthUser(userInfo);
+
+            return ResponseEntity.ok().body(jwtService.createJwtAccessAndRefreshToken(userDto));
+        } else {
+            Map<String, Object> data = new HashMap<>();
+            data.put("error", "Nothing matches to request");
+
+            return ResponseEntity.badRequest().body(data);
+        }
+    }
 
 
-    @PostMapping("/oauth/jwt/kakao")
-    public ResponseEntity<Map<String, String>> createJwt(@RequestBody Map<String, Object> request) throws IOException {
-        // 프론트엔드로부터 authorization code 받고 -> 그 code로 카카오에 accesstoken 요청
-        String accessToken = oAuthService.getKakaoAccessToken(request.get("code").toString());
+    /**
+     * @param file     : 사용자가 업로드한 이미지 파일 (form data)
+     * @param nickname : 사용자가 설정한 고유 nickname
+     */
+    @PostMapping("/profile")
+    public void setInitialProfile(@RequestParam("profileImg") MultipartFile file,
+                                  @RequestParam("nickname") String nickname,
+                                  Authentication authentication) {
+        PrincipalDetails principalDetails = (PrincipalDetails) authentication.getPrincipal();
+        Long userId = principalDetails.getUser().getId();
+        userService.updateProfile(file, nickname, userId);
 
-        // 받아 온 access token으로 카카오 리소스 서버로부터 카카오 유저 정보 가져오기
-        Map<String, Object> userInfo = oAuthService.getKakaoUserInfo(accessToken);
+    }
+
+    //회원 탈퇴
+    @DeleteMapping("/account")
+    public void deleteAccount(Authentication authentication) {
+        PrincipalDetails principalDetails = (PrincipalDetails) authentication.getPrincipal();
+        userService.deleteAccount(principalDetails.getUser().getId());
+    }
 
-        // 가져온 정보를 기반으로 회원가입
-        UserDto userDto = userService.joinOAuthUser(userInfo);
+    //사용자 정보(닉네임, 사진) 가져오기
+    @GetMapping("/account")
+    public ResponseEntity<Map<String, Object>> account(Authentication authentication) {
+        PrincipalDetails principalDetails = (PrincipalDetails) authentication.getPrincipal();
+        UserProfileDto userInfoDto = userService.getUserProfile(principalDetails.getUser().getId());
+        Map<String, Object> data = new HashMap<>();
+        data.put("userInfo", userInfoDto);
 
-        // jwt accessToken을 리액트 서버에 return
-        return ResponseEntity.ok().body(jwtService.createJwtAccessToken(userDto));
+        return ResponseEntity.ok().body(data);
     }
 
-    @PostMapping("/oauth/jwt/google")
-    public ResponseEntity<Map<String, String>> createGoogleJwt(@RequestBody Map<String, Object> request) throws IOException {
-        // Frontend sends the authorization code to the server
-        String authorizationCode = request.get("code").toString();
+    //회원정보 변경(일단 사진만, 닉네임까지 확장 가능)
+    @PostMapping("/account")
+    public void updateProfileImage(@RequestParam("profileImg") MultipartFile file,
+                                   Authentication authentication) {
+        PrincipalDetails principalDetails = (PrincipalDetails) authentication.getPrincipal();
+        userService.updateProfile(file,
+                principalDetails.getUser().getNickname(),
+                principalDetails.getUser().getId());
+    }
 
-        // Exchange the authorization code for an access token from Google
-        String accessToken = googleOAuthService.getGoogleAccessToken(authorizationCode);
+    /**
+     * 친구삭제
+     *
+     * @param request {"nickname" : "xxx"}
+     */
+    @DeleteMapping("/friends")
+    public void deleteFriend(@RequestBody Map<String, Object> request, Authentication authentication) {
+        String friendNickname = request.get("nickname").toString();
+        UserProfileDto findUserDto = userService.findUserByNickname(friendNickname);
+        Long friendId = findUserDto.getId();
 
-        // Use the access token to fetch user information from Google
-        Map<String, Object> userInfo = googleOAuthService.getGoogleUserInfo(accessToken);
+        PrincipalDetails principalDetails = (PrincipalDetails) authentication.getPrincipal();
+        Long userId = principalDetails.getUser().getId();
 
-        // Process the user information and perform user registration if needed
-        UserDto userDto = userService.joinOAuthUser(userInfo);
+        friendshipService.deleteFriend(friendId, userId);
 
-        // Return the JWT access token to the React server
-        return ResponseEntity.ok().body(jwtService.createJwtAccessToken(userDto));
     }
 
-    @CrossOrigin
-    @PostMapping("/oauth/jwt/naver")
-    public ResponseEntity<Map<String, String>> createJwtNaver(@RequestBody Map<String, Object> request) throws IOException {
-        // Frontend sends the authorization code, use it to request Naver for an access token
-        String accessToken = naverOAuthService.getNaverAccessToken(request.get("code").toString());
-
-        // Use the obtained access token to fetch Naver user information from Naver resource server
-        Map<String, Object> userInfo = naverOAuthService.getNaverUserInfo(accessToken);
 
-        // Based on the retrieved information, perform user registration
-        UserDto userDto = userService.joinOAuthUser(userInfo);
+    /**
+     * 사용자의 nickname을 검색하여 찾기
+     *
+     * @param nickname 쿼리 파라미터로 전달
+     * @return 사용자 정보(UserProfileDto -> nickname, profileImg), 친구 여부
+     */
+    @GetMapping("/friends/search")
+    public ResponseEntity<Map<String, Object>> searchUser(@RequestParam("nickname") String nickname,
+                                                          Authentication authentication) {
+        PrincipalDetails principalDetails = (PrincipalDetails) authentication.getPrincipal();
+        Map<String, Object> data = new HashMap<>();
+        try {
+            UserProfileDto result = userService.findUserByNickname(nickname);
+            Optional<Friendship> friendship =
+                    friendshipService.findFriendByIds(principalDetails.getUser().getId(), result.getId());
+            data.put("userInfo", result);
+            data.put("isFriendWithMe", friendship.isPresent());
+            return ResponseEntity.ok().body(data);
+        } catch (EntityNotFoundException e) {
+            data.put("error", e.getMessage());
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(data);
+        }
+    }
 
-        // Return the JWT access token to the React server
-        return ResponseEntity.ok().body(jwtService.createJwtAccessToken(userDto));
+    //친구 신청
+    @PostMapping("/friends/search")
+    public void sendFriendRequest(Authentication authentication,
+                                                                 @RequestParam("id") Long toUserId) {
+        PrincipalDetails principalDetails = (PrincipalDetails) authentication.getPrincipal();
+        Long fromUserId = principalDetails.getUser().getId();
+        //userId는 친구 신청 하는 유저, friendId는 친구 신청 받는 유저
+        friendshipService.sendRequest(fromUserId, toUserId);
     }
 
+    //친구 요청 수락
+    @PostMapping("/friends/pendinglist")
+    public void addFriend(Authentication authentication, @RequestParam("nickname") String nickname) {
+        PrincipalDetails principalDetails = (PrincipalDetails) authentication.getPrincipal();
+        Long toUserId = principalDetails.getUser().getId();
 
+        UserProfileDto findUserDto = userService.findUserByNickname(nickname);
+        Long fromUserId = findUserDto.getId();
+
+        //toUserId -> 친구 요청을 받은 유저
+        //fromUserId -> 친구 요청을 보낸 유저
+        friendshipService.addFriend(toUserId, fromUserId);
+
+    }
 }

ping/src/main/java/com/b6122/ping/domain/Friendship.java

@@ -4,9 +4,11 @@
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
+import lombok.Setter;
 
 @Entity
 @Getter
+@Setter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class Friendship {
 
@@ -25,12 +27,22 @@ public class Friendship {
     @Enumerated(EnumType.STRING)
     private FriendshipRequestStatus requestStatus; // PENDING, ACCEPTED, REJECTED
 
-    private boolean isFriend;
+    private boolean isFriend = false;
 
+    public void setIsFriend(boolean isFriend) {
+        this.isFriend = isFriend;
+    }
+
+    public void setRequestStatus(FriendshipRequestStatus requestStatus) {
+        this.requestStatus = requestStatus;
+    }
     //친구 요청 시 메소드
-    //fromUser와 toUser사이 정방향/역방향 레코드 모두 추가
-//    public static Friendship createFriendship() {
-//
-//    }
+    public static Friendship createFriendship(User fromUser, User toUser) {
+        Friendship friendship = new Friendship();
+        friendship.fromUser = fromUser;
+        friendship.toUser = toUser;
+        friendship.requestStatus = FriendshipRequestStatus.PENDING;
+        return friendship;
+    }
 }
 

ping/src/main/java/com/b6122/ping/domain/Post.java

@@ -7,7 +7,6 @@
 import lombok.RequiredArgsConstructor;
 import lombok.Setter;
 import org.hibernate.annotations.ColumnDefault;
-
 import java.util.ArrayList;
 import java.util.List;
 
@@ -25,6 +24,7 @@
 @Table(name = "post")
 @NoArgsConstructor
 public class Post extends TimeEntity{
+
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     @Column(name = "post_id")
@@ -53,16 +53,13 @@ public class Post extends TimeEntity{
     @OneToMany(mappedBy = "post")
     private List<Like> likes = new ArrayList<>();
 
-
-
     //연관관계 매서드//
     public void setUser(User user) {
         user.addPost(this); //user의 posts list에 post(this) 추가
     }
 
     /*
 
-    //like 눌렀을때
     public void pushLike(Long uid){
         postRepository.createLike(this.pid,uid);
         postRepository.updateLikeCount(this.getLikeCount()+1, this.pid);