major(optimization): changed the code style to functional, optmized code, added proper logs

Author: AdityaByte

src/main/java/com/connect/controller/ChatRoomController.java

@@ -9,6 +9,7 @@
 import com.connect.service.RoomService;
 import com.connect.utils.JwtUtil;
 import jakarta.servlet.http.HttpServletRequest;
+import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
@@ -20,22 +21,20 @@
 
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.stream.Collectors;
 
 @RestController
 @Slf4j
+@AllArgsConstructor
 public class ChatRoomController {
 
-    @Autowired
     private ChatUserService chatUserService;
 
-    @Autowired
     private RoomService roomService;
 
-    @Autowired
     private JwtTokenService jwtTokenService;
 
-    @Autowired
     private SimpMessagingTemplate messagingTemplate;
 
     // Route for handling the joining message.
@@ -54,28 +53,18 @@ public void joinRoom(@Payload Map<String, String> joinReq) {
     // Person who is creating the room must give the necessary information as in body.
     @PostMapping("/room/create")
     public ResponseEntity<Map<String, String>> createRoom(@RequestBody Room room, HttpServletRequest request) {
+
         log.info("New Room request");
         String rawToken = request.getHeader("Authorization");
-        // Checking the token is valid or not.
-        // This service extracts the username till then the token is valid otherwise it will not.
-        String token = rawToken.substring(7);
-        String username = jwtTokenService.extractUsername(token);
 
-        if (username.isEmpty()) {
-            return ResponseEntity
-                    .status(HttpStatus.UNAUTHORIZED)
-                    .body(Map.of("response", "Invalid Token"));
-        }
-        // Here we need to send the data to the service class.
-        var createdRoom = roomService.addNewRoom(room, username);
-        if (createdRoom == null) {
-            return ResponseEntity
-                    .status(HttpStatus.INTERNAL_SERVER_ERROR)
-                    .body(Map.of("response", "Something went wrong at the server! Try again later."));
-        }
-        return ResponseEntity
-                .status(HttpStatus.CREATED)
-                .body(Map.of("response", createdRoom.getRoomId().toString()));
+        return Optional.ofNullable(jwtTokenService.extractUsername(rawToken.substring(7)))
+                .flatMap(username -> Optional.ofNullable(roomService.addNewRoom(room, username))
+                        .map(newRoom -> ResponseEntity.ok(Map.of("response", "Room created successfully.")))
+                )
+                .orElseGet(() -> {
+                    return ResponseEntity.status(HttpStatus.UNAUTHORIZED)
+                            .body(Map.of("response", "Invalid Token or Room Creation Failed"));
+                });
     }
 
     @GetMapping("/room/getall")

src/main/java/com/connect/controller/ChatUserController.java

@@ -53,26 +53,26 @@ public void handleMessage(@Payload MessageDTO message, SimpMessageHeaderAccessor
     public void handleHistory(SimpMessageHeaderAccessor headerAccessor) {
         String roomId = headerAccessor.getFirstNativeHeader("roomId");
         log.info("Handling the History of chats for the Room: {}", roomId);
-        Optional<List<Message>> messages = chatUserService.chatHistoryHandler(roomId);
-        messages.ifPresent(msgs -> {
-            System.out.println(messages.get().size());
-            List<MessageDTO> dtoList = msgs.stream()
-                    .map(MessageDTO::new)
-                    .collect(Collectors.toList());
 
-            messagingTemplate.convertAndSend("/topic/history/"+roomId, dtoList);
-        });
+        chatUserService.chatHistoryHandler(roomId)
+                .ifPresent(msgs -> {
+                    log.info("Message Size: {}", msgs.size());
+                    List<MessageDTO> dtoList = msgs.stream()
+                            .map(MessageDTO::new)
+                            .toList();
+                    messagingTemplate.convertAndSend("/topic/history/"+roomId, dtoList);
+                });
     }
 
     @MessageMapping("/users")
     public void fetchUsers() {
-        Optional<List<User>> users = chatUserService.fetchUser();
-        users.ifPresent(users1 -> {
-            List<UserDTO> modifiedUsers = users1
-                    .stream()
-                    .map(UserDTO::new)
-                    .collect(Collectors.toList());
-            messagingTemplate.convertAndSend("/topic/users", modifiedUsers);
-        });
+        chatUserService.fetchUser()
+                .ifPresent(users1 -> {
+                    List<UserDTO> modifiedUsers = users1
+                            .stream()
+                            .map(UserDTO::new)
+                            .collect(Collectors.toList());
+                    messagingTemplate.convertAndSend("/topic/users", modifiedUsers);
+                });
     }
 }

src/main/java/com/connect/controller/TokenController.java

@@ -1,50 +1,43 @@
 package com.connect.controller;
 
+import com.connect.service.JwtTokenService;
 import com.connect.utils.JwtUtil;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
+import java.util.Map;
+import java.util.Optional;
+
 // Controller for handling the Verify Token Request
 
 @RestController
 @RequestMapping("/api")
+@Slf4j
 public class TokenController {
 
     @Autowired
-    private JwtUtil jwtUtil;
+    private JwtTokenService tokenService;
 
     @GetMapping("/verify-token")
     public ResponseEntity<?> verifyToken(@RequestHeader("Authorization") String authHeader) {
-        try {
-
-            System.out.println("Request recieved for token verification");
-            if (authHeader == null || !authHeader.startsWith("Bearer")) {
-                return ResponseEntity
-                        .status(HttpStatus.UNAUTHORIZED)
-                        .body("Missing Authorization Header");
-            }
-
-            String token = authHeader.substring(7);
-            String username = jwtUtil.extractClaims(token).getSubject();
-
-
-           if (jwtUtil.isTokenValid(token, username)) {
-               System.out.println("Token is valid");
-               return ResponseEntity.ok("Token is valid");
-           } else {
-               System.out.println("Token is invalid");
-               return ResponseEntity
-                       .status(HttpStatus.UNAUTHORIZED)
-                       .body("Token is invalid");
-           }
-        }
-        catch (Exception e) {
-            System.out.println("[ERROR] Token Validation Failed: "+ e.getMessage());
+        log.info("Request received for token verification");
+        if (authHeader == null || !authHeader.startsWith("Bearer")) {
             return ResponseEntity
                     .status(HttpStatus.UNAUTHORIZED)
-                    .body("Token Validation Failed");
+                    .body("Missing Authorization Header");
         }
+
+        return Optional.ofNullable(tokenService.extractUsername(authHeader.substring(7)))
+                .map(username -> {
+                    return ResponseEntity.ok("Authorized");
+                })
+                .orElseGet(() -> {
+                    return ResponseEntity
+                            .status(HttpStatus.UNAUTHORIZED)
+                            .body("Invalid Token");
+                });
     }
 }