Merge branch 'feature/chamode_dev' into 'master'

Feature/chamode dev

See merge request !2

src/main/java/com/kaluwa/enterprises/babycarebackendservice/config/SecurityConfig.java

@@ -47,6 +47,7 @@ public class SecurityConfig {
             "/webjars/**",
             "/swagger-ui.html",
             "/emotional/video-process",
+            "/test/**"
     };
 
     @Bean

src/main/java/com/kaluwa/enterprises/babycarebackendservice/config/WebSocketClient.java

@@ -2,25 +2,38 @@ package com.kaluwa.enterprises.babycarebackendservice.config;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.kaluwa.enterprises.babycarebackendservice.socketHandlers.EmotionPrediction;
+import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.web.socket.BinaryMessage;
 import org.springframework.web.socket.TextMessage;
 import org.springframework.web.socket.WebSocketSession;
 import org.springframework.web.socket.client.standard.StandardWebSocketClient;
 import org.springframework.web.socket.handler.TextWebSocketHandler;
 
-import static com.kaluwa.enterprises.babycarebackendservice.config.WebSocketConfig.SendVideoHandler.sendTextMessageToClient;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+import static com.kaluwa.enterprises.babycarebackendservice.config.WebSocketConfig.VideoFrameHandler.sendTextMessageToClient;
 
 public class WebSocketClient {
 
     private WebSocketSession session;
+    private static final String WEBSOCKET_URL = "ws://localhost:8000/ws/emotion";
+    private static final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
+
+     public WebSocketClient() {
+        connectToWebSocket();
+    }
 
-    public WebSocketClient() {
+    private void connectToWebSocket() {
         try {
             this.session = new StandardWebSocketClient()
-                    .doHandshake(new MyWebSocketHandler(), "ws://localhost:8000/ws/emotion")
+                    .doHandshake(new MyWebSocketHandler(this), WEBSOCKET_URL)
                     .get();
+            System.out.println("Connected to WebSocket!");
         } catch (Exception e) {
-            e.printStackTrace();
+            System.out.println("Failed to connect to WebSocket, scheduling reconnection...");
+            scheduleReconnection();
         }
     }
 
@@ -32,10 +45,29 @@ public class WebSocketClient {
         }
     }
 
+    private void scheduleReconnection() {
+        scheduler.schedule(this::connectToWebSocket, 2, TimeUnit.MINUTES);
+    }
+
+    @Scheduled(fixedDelay = 120000) // Check every 5 minutes
+    private void checkConnection() {
+        if (session == null || !session.isOpen()) {
+            System.out.println("WebSocket connection is closed. Reconnecting...");
+            connectToWebSocket();
+        }
+    }
+
     static ObjectMapper objectMapper = new ObjectMapper();
     public static EmotionPrediction[] predictions;
 
     static class MyWebSocketHandler extends TextWebSocketHandler {
+
+        private final WebSocketClient webSocketClient;
+
+        public MyWebSocketHandler(WebSocketClient webSocketClient) {
+            this.webSocketClient = webSocketClient;
+        }
+
         @Override
         protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
             // This method will be called when the server sends a text message
@@ -48,5 +80,11 @@ public class WebSocketClient {
                 sendTextMessageToClient(lastPrediction);
             }
         }
+
+         @Override
+        public void afterConnectionClosed(WebSocketSession session, org.springframework.web.socket.CloseStatus status) {
+            System.out.println("WebSocket connection closed. Status: " + status);
+            webSocketClient.scheduleReconnection();
+        }
     }
 }

src/main/java/com/kaluwa/enterprises/babycarebackendservice/config/WebSocketConfig.java

@@ -28,7 +28,6 @@ public class WebSocketConfig implements WebSocketConfigurer {
     @Override
     public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
         registry.addHandler(new VideoFrameHandler(), "/emotional/video-process").setAllowedOrigins("*");
-        registry.addHandler(new SendVideoHandler(), "/emotional/video-send").setAllowedOrigins("*");
     }
 
     @Bean
@@ -39,34 +38,11 @@ public class WebSocketConfig implements WebSocketConfigurer {
 
     @Component
     class VideoFrameHandler extends BinaryWebSocketHandler {
-        WebSocketClient webSocketClient = customWebSocketClient();
-
-        @Override
-        protected void handleBinaryMessage(WebSocketSession session, BinaryMessage message) throws Exception {
-            byte[] binaryData = message.getPayload().array();
-            // Process the binary data representing the video frame
-//            log.info("Received binary data from client: {}", binaryData);
-
-            // Here you can process the binary data as needed, such as saving it to a file, performing image processing, etc.
-            webSocketClient.sendBytesToWebSocket(binaryData);
-            SendVideoHandler.sendBinaryMessageToClient(binaryData);
-
-        }
-
-        @Override
-        protected void handleTextMessage(WebSocketSession session, TextMessage message) {
-            super.handleTextMessage(session, message);
-        }
-    }
-
-    @Component
-    class SendVideoHandler extends BinaryWebSocketHandler {
-        WebSocketClient webSocketClient = customWebSocketClient();
-        private static StandardWebSocketSession session;
+        private static WebSocketSession currentSession;
 
         @Override
         public void afterConnectionEstablished(WebSocketSession session) throws Exception {
-            SendVideoHandler.session = (StandardWebSocketSession) session;
+            currentSession = session; // Store the current session
             log.info("Connection established with client: {}", session);
             super.afterConnectionEstablished(session);
         }
@@ -74,13 +50,21 @@ public class WebSocketConfig implements WebSocketConfigurer {
         @Override
         protected void handleBinaryMessage(WebSocketSession session, BinaryMessage message) throws Exception {
             byte[] binaryData = message.getPayload().array();
+            // Process the binary data as needed
+
+            // Send binary data back to the client
+            sendBinaryMessageToClient(binaryData);
+
+            // Optionally, send a text message
+            EmotionPrediction emotionPrediction = new EmotionPrediction(); // Example object
+            sendTextMessageToClient(emotionPrediction);
         }
 
         @Override
         public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
-            // Handle session closure here
-            // For example, cleanup resources or attempt to reconnect
-            SendVideoHandler.session = null; // Reset session variable
+            if (currentSession == session) {
+                currentSession = null; // Reset session variable
+            }
             log.info("Connection closed with client: {}", session);
             super.afterConnectionClosed(session, status);
         }
@@ -89,37 +73,37 @@ public class WebSocketConfig implements WebSocketConfigurer {
         protected void handleTextMessage(WebSocketSession session, TextMessage message) {
             super.handleTextMessage(session, message);
             try {
-                System.out.println("Received text message from client: "+message.getPayload());
+                System.out.println("Received text message from client: " + message.getPayload());
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
 
-        // Method to send a message back to the client
-        public static void sendBinaryMessageToClient(byte[] bytes) {
+        // Method to send a binary message back to the client
+        public void sendBinaryMessageToClient(byte[] bytes) {
             try {
-                if (session != null && session.isOpen()) {
-                    session.sendMessage(new BinaryMessage(bytes));
-                    System.out.println("Sent message to client: "+bytes.length);
+                if (currentSession != null && currentSession.isOpen()) {
+                    currentSession.sendMessage(new BinaryMessage(bytes));
+                    System.out.println("Sent binary message to client: " + bytes.length);
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
 
+        // Method to send a text message back to the client
         public static void sendTextMessageToClient(EmotionPrediction emotionPrediction) {
             try {
-                if (session != null && session.isOpen()) {
+                if (currentSession != null && currentSession.isOpen()) {
                     ObjectMapper objectMapper = new ObjectMapper();
                     String json = objectMapper.writeValueAsString(emotionPrediction);
-                    session.sendMessage(new TextMessage(json));
-                    System.out.println("Sent message to client: " + json);
+                    currentSession.sendMessage(new TextMessage(json));
+                    System.out.println("Sent text message to client: " + json);
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
-
     }
 
 }
\ No newline at end of file

src/main/java/com/kaluwa/enterprises/babycarebackendservice/constants/DocumetTypes.java

+package com.kaluwa.enterprises.babycarebackendservice.constants;
+
+public class DocumetTypes {
+
+    public static final String PROFILE_IMAGE = "profile_image";
+
+}

src/main/java/com/kaluwa/enterprises/babycarebackendservice/constants/TableNames.java

@@ -4,5 +4,6 @@ public class TableNames {
 
     public final static String USER_TABLE = "users";
     public final static String BABY_TABLE = "babies";
+    public final static String DOCUMENT_TABLE = "documents";
 
 }

src/main/java/com/kaluwa/enterprises/babycarebackendservice/dao/DocumentDao.java

+package com.kaluwa.enterprises.babycarebackendservice.dao;
+
+import com.kaluwa.enterprises.babycarebackendservice.model.Document;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+public interface DocumentDao extends JpaRepository<Document, Long> {
+
+  Optional<Document> findByUserUserIdAndDocumentType(Long userId, String profileImage);
+}
\ No newline at end of file

src/main/java/com/kaluwa/enterprises/babycarebackendservice/dto/BabyDto.java

@@ -8,20 +8,54 @@ import lombok.NoArgsConstructor;
 
 import java.time.LocalDate;
 
+import static com.kaluwa.enterprises.babycarebackendservice.constants.Status.STATUS_NEW;
+
 @Data
 @AllArgsConstructor
 @NoArgsConstructor
 public class BabyDto {
     private Long babyId;
-    @NotNull(message = "Baby name is required")
-    @NotEmpty(message = "Baby name is required")
-    private String babyName;
-    private String babyGender;
-    private LocalDate babyDob;
-    private String babyWeight;
+    @NotNull(message = "Baby's first name is required")
+    @NotEmpty(message = "Baby's first name is required")
+    private String firstName;
+    private String lastName;
+    @NotNull(message = "Baby's date of birth is required")
+    @NotEmpty(message = "Baby's date of birth is required")
+    private LocalDate dob;
+    @NotNull(message = "Baby's gender is required")
+    @NotEmpty(message = "Baby's gender is required")
+    private String sex;
+    private String status = STATUS_NEW;
+    private Boolean isActive;
+    private Float weight;
+    private Float height;
+    private String bloodType;
+    private String eyeColor;
+    private String hairColor;
+    private String allergies;
+    private String medicalConditions;
+    private String medications;
+    private String vaccinateRecords;
+    private String docName;
+    private String docContactNumber;
+    private String healthInsuranceInfo;
+    private LocalDate firstSmileDate;
+    private LocalDate firstToothDate;
+    private LocalDate firstWordDate;
+    private LocalDate firstStepDate;
+    private String favFoods;
+    private String foodsDislikes;
+    private String primaryEmergencyContactName;
+    private String primaryEmergencyRelationship;
+    private String primaryEmergencyContactNumber;
+    private String secondaryEmergencyContactName;
+    private String secondaryEmergencyRelationship;
+    private String secondaryEmergencyContactNumber;
+    private String notes;
     private UserDto user;
 
     @NotNull(message = "Logged user id is required")
     @NotEmpty(message = "Logged user id is required")
     private Long userId;
+    private Long documentId;
 }

src/main/java/com/kaluwa/enterprises/babycarebackendservice/dto/DocumentDto.java

+package com.kaluwa.enterprises.babycarebackendservice.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.Value;
+
+import java.io.Serializable;
+
+/**
+ * DTO for {@link com.kaluwa.enterprises.babycarebackendservice.model.Document}
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class DocumentDto implements Serializable {
+    private Long documentId;
+    private String documentType;
+    private String documentName;
+    private byte[] data;
+    private UserDto user;
+
+    private Long userId;
+}
\ No newline at end of file

src/main/java/com/kaluwa/enterprises/babycarebackendservice/dto/UserDto.java

@@ -5,6 +5,8 @@ import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
+import java.time.LocalDate;
+
 @Data
 @AllArgsConstructor
 @NoArgsConstructor
@@ -16,4 +18,5 @@ public class UserDto {
     private String phone;
     private String role;
     private String status;
+    private LocalDate dob;
 }

src/main/java/com/kaluwa/enterprises/babycarebackendservice/mappers/DocumentMapper.java

+package com.kaluwa.enterprises.babycarebackendservice.mappers;
+
+import com.kaluwa.enterprises.babycarebackendservice.dto.DocumentDto;
+import com.kaluwa.enterprises.babycarebackendservice.model.Document;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import org.mapstruct.Mappings;
+
+import java.util.List;
+
+@Mapper(componentModel = "spring")
+public interface DocumentMapper {
+
+    @Mappings({
+            @Mapping(target = "userId", source = "user.userId")
+    })
+    DocumentDto toDto(Document document);
+
+    @Mappings({
+            @Mapping(target = "user.userId", source = "userId")
+    })
+    Document toEntity(DocumentDto documentDto);
+
+    @Mappings({
+            @Mapping(target = "userId", source = "user.userId")
+    })
+    List<DocumentDto> listToDto(List<Document> documents);
+
+}

src/main/java/com/kaluwa/enterprises/babycarebackendservice/model/Baby.java

@@ -18,11 +18,39 @@ public class Baby {
     @Id
     @GeneratedValue(strategy= GenerationType.AUTO)
     private Long babyId;
-    private String babyName;
-    private String babyGender;
-    private LocalDate babyDob;
-    private String babyWeight;
+    private String firstName;
+    private String lastName;
+    private LocalDate dob;
+    private String sex;
+    private String status;
+    private Boolean isActive;
+    private Float weight;
+    private Float height;
+    private String bloodType;
+    private String eyeColor;
+    private String hairColor;
+    private String allergies;
+    private String medicalConditions;
+    private String medications;
+    private String vaccinateRecords;
+    private String docName;
+    private String docContactNumber;
+    private String healthInsuranceInfo;
+    private LocalDate firstSmileDate;
+    private LocalDate firstToothDate;
+    private LocalDate firstWordDate;
+    private LocalDate firstStepDate;
+    private String favFoods;
+    private String foodsDislikes;
+    private String primaryEmergencyContactName;
+    private String primaryEmergencyRelationship;
+    private String primaryEmergencyContactNumber;
+    private String secondaryEmergencyContactName;
+    private String secondaryEmergencyRelationship;
+    private String secondaryEmergencyContactNumber;
+    private String notes;
     @ManyToOne(fetch = FetchType.LAZY)
     @JoinColumn(name = "userId", referencedColumnName = "userId", nullable = false)
     private User user;
+    private Long documentId;
 }

src/main/java/com/kaluwa/enterprises/babycarebackendservice/model/Document.java

+package com.kaluwa.enterprises.babycarebackendservice.model;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import static com.kaluwa.enterprises.babycarebackendservice.constants.TableNames.DOCUMENT_TABLE;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Entity
+@Table(name = DOCUMENT_TABLE)
+public class Document {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private Long documentId;
+    private String documentType;
+    private String documentName;
+    @Lob
+    @Column(name = "data", columnDefinition = "LONGBLOB")
+    private byte[] data;
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "userId", referencedColumnName = "userId", nullable = false)
+    private User user;
+}

src/main/java/com/kaluwa/enterprises/babycarebackendservice/model/User.java

@@ -8,6 +8,7 @@ import org.springframework.security.core.GrantedAuthority;
 import org.springframework.security.core.authority.SimpleGrantedAuthority;
 import org.springframework.security.core.userdetails.UserDetails;
 
+import java.time.LocalDate;
 import java.util.Collection;
 import java.util.List;
 
@@ -29,6 +30,7 @@ public class User implements UserDetails {
     private String phone;
     private String role;
     private String status;
+    private LocalDate dob;
 
     @Override
     public Collection<? extends GrantedAuthority> getAuthorities() {

src/main/java/com/kaluwa/enterprises/babycarebackendservice/rest/BabyController.java

@@ -33,19 +33,19 @@ public class BabyController {
         return ResponseEntity.ok(babyService.getAllBabies());
     }
 
-    @GetMapping("/{id}")
+    @GetMapping("/{babyId}")
     public ResponseEntity<BabyDto> getBabyById(@PathVariable Long babyId) {
         log.info("Inside baby controller getBabyById method");
         return ResponseEntity.ok(babyService.getBabyById(babyId));
     }
 
-    @PutMapping("/{id}")
+    @PutMapping("/{babyId}")
     public ResponseEntity<BabyDto> updateBaby(@PathVariable Long babyId, @RequestBody BabyDto babyDto) {
         log.info("Inside baby controller updateBaby method");
         return ResponseEntity.ok(babyService.updateBaby(babyId, babyDto));
     }
 
-    @DeleteMapping("/{id}")
+    @DeleteMapping("/{babyId}")
     public ResponseEntity<ResponseDto> deleteBaby(@PathVariable Long babyId) {
         log.info("Inside baby controller deleteBaby method");
         return ResponseEntity.ok(babyService.deleteBaby(babyId));

src/main/java/com/kaluwa/enterprises/babycarebackendservice/rest/TestController.java

 package com.kaluwa.enterprises.babycarebackendservice.rest;
 
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.core.io.Resource;
+import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
@@ -18,4 +22,52 @@ public class TestController {
         return new ResponseEntity<>("Test OK!", HttpStatus.OK);
     }
 
+    String lightStatus = "OFF";
+
+    @GetMapping("/light/on")
+    public ResponseEntity<String> lightOn() {
+        log.info("Inside lightOn controller");
+        lightStatus = "ON";
+        return new ResponseEntity<>("Light is ON", HttpStatus.OK);
+    }
+
+    @GetMapping("/light/off")
+    public ResponseEntity<String> lightOff() {
+        log.info("Inside lightOff controller");
+        lightStatus = "OFF";
+        return new ResponseEntity<>("Light is OFF", HttpStatus.OK);
+    }
+
+    @GetMapping("/light/status")
+    public ResponseEntity<String> lightStatus() {
+        log.info("Inside lightStatus controller");
+        return new ResponseEntity<>(lightStatus, HttpStatus.OK);
+    }
+
+    @GetMapping("/music/play")
+    public ResponseEntity<Resource> getMusicFile() {
+        log.info("Inside getMusicFile controller");
+
+        try {
+            // Load the music.wav file from the resources folder
+            ClassPathResource resource = new ClassPathResource("music.wav");
+
+            // Check if the resource exists
+            if (!resource.exists()) {
+                return ResponseEntity.notFound().build();
+            }
+
+            // Set the headers to specify the content type
+            HttpHeaders headers = new HttpHeaders();
+            headers.add(HttpHeaders.CONTENT_TYPE, "audio/wav");
+
+            // Return the file as the response
+            return new ResponseEntity<>(resource, headers, HttpStatus.OK);
+        } catch (Exception e) {
+            log.error("Error serving music file", e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+
+
 }

src/main/java/com/kaluwa/enterprises/babycarebackendservice/rest/UserController.java

@@ -7,6 +7,7 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
 
 import java.util.List;
 
@@ -47,4 +48,16 @@ public class UserController {
         log.info("Inside user controller delete user method");
         return new ResponseEntity<>(userService.deleteUser(userId), HttpStatus.OK);
     }
+
+    @PutMapping("/image/{userId}")
+    public ResponseEntity<ResponseDto>  uploadImage(@PathVariable Long userId, @RequestParam("image") MultipartFile file) {
+        log.info("Inside user controller upload image method");
+        return new ResponseEntity<>(userService.uploadImage(userId, file), HttpStatus.OK);
+    }
+
+    @GetMapping("/image/{userId}")
+    public ResponseEntity<byte[]> getImage(@PathVariable Long userId) {
+        log.info("Inside user controller get image method");
+        return userService.getImage(userId);
+    }
 }

src/main/java/com/kaluwa/enterprises/babycarebackendservice/service/UserService.java

 package com.kaluwa.enterprises.babycarebackendservice.service;
 
 import com.kaluwa.enterprises.babycarebackendservice.dto.*;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.multipart.MultipartFile;
 
 import java.util.List;
 
@@ -16,4 +18,8 @@ public interface UserService {
     UserDto updateUser(Long userId, UserDto userDto);
 
     ResponseDto deleteUser(Long userId);
+
+    ResponseDto uploadImage(Long userId, MultipartFile file);
+
+    ResponseEntity<byte[]> getImage(Long userId);
 }

src/main/java/com/kaluwa/enterprises/babycarebackendservice/service/impl/BabyServiceImpl.java

 package com.kaluwa.enterprises.babycarebackendservice.service.impl;
 
 import com.kaluwa.enterprises.babycarebackendservice.dao.BabyDao;
+import com.kaluwa.enterprises.babycarebackendservice.dao.DocumentDao;
 import com.kaluwa.enterprises.babycarebackendservice.dto.BabyDto;
 import com.kaluwa.enterprises.babycarebackendservice.dto.ResponseDto;
 import com.kaluwa.enterprises.babycarebackendservice.error.BadRequestAlertException;
 import com.kaluwa.enterprises.babycarebackendservice.mappers.BabyMapper;
 import com.kaluwa.enterprises.babycarebackendservice.model.Baby;
+import com.kaluwa.enterprises.babycarebackendservice.model.Document;
 import com.kaluwa.enterprises.babycarebackendservice.service.BabyService;
+import lombok.extern.slf4j.Slf4j;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
@@ -15,15 +18,17 @@ import java.util.List;
 import java.util.Optional;
 
 @Service
+@Slf4j
 public class BabyServiceImpl implements BabyService {
-
-    private static final Logger log = LoggerFactory.getLogger(BabyServiceImpl.class);
     private final BabyDao babyDao;
     private final BabyMapper babyMapper;
+    private final DocumentDao documentDao;
+
 
-    public BabyServiceImpl(BabyDao babyDao, BabyMapper babyMapper) {
+    public BabyServiceImpl(BabyDao babyDao, BabyMapper babyMapper, DocumentDao documentDao) {
         this.babyDao = babyDao;
         this.babyMapper = babyMapper;
+        this.documentDao = documentDao;
     }
 
     @Override
@@ -92,6 +97,10 @@ public class BabyServiceImpl implements BabyService {
             if (babyOp.isEmpty()) {
                 throw new BadRequestAlertException("Baby not found", "baby", "baby.error");
             } else {
+                Optional<Document> documentOp = documentDao.findById(babyOp.get().getDocumentId());
+                if (documentOp.isPresent()) {
+                    documentDao.deleteById(babyOp.get().getDocumentId());
+                }
                 babyDao.deleteById(babyId);
                 ResponseDto responseDto = new ResponseDto();
                 responseDto.setId(babyId);

src/main/java/com/kaluwa/enterprises/babycarebackendservice/service/impl/UserServiceImpl.java

 package com.kaluwa.enterprises.babycarebackendservice.service.impl;
 
+import com.kaluwa.enterprises.babycarebackendservice.dao.DocumentDao;
 import com.kaluwa.enterprises.babycarebackendservice.dao.UserDao;
 import com.kaluwa.enterprises.babycarebackendservice.dto.*;
 import com.kaluwa.enterprises.babycarebackendservice.error.BadRequestAlertException;
+import com.kaluwa.enterprises.babycarebackendservice.mappers.DocumentMapper;
 import com.kaluwa.enterprises.babycarebackendservice.mappers.UserMapper;
+import com.kaluwa.enterprises.babycarebackendservice.model.Document;
 import com.kaluwa.enterprises.babycarebackendservice.model.User;
 import com.kaluwa.enterprises.babycarebackendservice.service.UserService;
 import com.kaluwa.enterprises.babycarebackendservice.utils.JWTUtils;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
 import org.springframework.security.authentication.AuthenticationManager;
 import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
 import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
 
 import java.util.HashMap;
 import java.util.List;
 import java.util.Optional;
 
 import static com.kaluwa.enterprises.babycarebackendservice.constants.Common.TOKEN_TYPE;
+import static com.kaluwa.enterprises.babycarebackendservice.constants.DocumetTypes.PROFILE_IMAGE;
 import static com.kaluwa.enterprises.babycarebackendservice.constants.Status.STATUS_NEW;
 import static com.kaluwa.enterprises.babycarebackendservice.constants.UserRoles.USER;
 import static com.kaluwa.enterprises.babycarebackendservice.utils.JWTUtils.EXPIRATION_TIME;
+import static com.kaluwa.enterprises.babycarebackendservice.utils.Utils.ALLOWED_CONTENT_TYPES;
+import static com.kaluwa.enterprises.babycarebackendservice.utils.Utils.determineImageContentType;
 
 @Service
 @Slf4j
 public class UserServiceImpl implements UserService {
 
     private final UserDao userDao;
+    private final DocumentDao documentDao;
     private final BabyCareUserDetailsService userDetailsService;
     private final JWTUtils jwtUtils;
     private final PasswordEncoder passwordEncoder;
     private final AuthenticationManager authenticationManager;
     private final UserMapper userMapper;
+    private final DocumentMapper documentMapper;
 
-    public UserServiceImpl(UserDao userDao, BabyCareUserDetailsService userDetailsService, JWTUtils jwtUtils, PasswordEncoder passwordEncoder, AuthenticationManager authenticationManager, UserMapper userMapper) {
+    public UserServiceImpl(UserDao userDao, DocumentDao documentDao, BabyCareUserDetailsService userDetailsService, JWTUtils jwtUtils, PasswordEncoder passwordEncoder, AuthenticationManager authenticationManager, UserMapper userMapper, DocumentMapper documentMapper) {
         this.userDao = userDao;
+        this.documentDao = documentDao;
         this.userDetailsService = userDetailsService;
         this.jwtUtils = jwtUtils;
         this.passwordEncoder = passwordEncoder;
         this.authenticationManager = authenticationManager;
         this.userMapper = userMapper;
+        this.documentMapper = documentMapper;
     }
 
 
@@ -116,7 +129,7 @@ public class UserServiceImpl implements UserService {
             }
         } catch (Exception e) {
             e.printStackTrace();
-            throw new BadRequestAlertException(e.getMessage(), "User", "User registration failed");
+            throw new BadRequestAlertException(e.getMessage(), "User", "error");
         }
     }
 
@@ -128,7 +141,7 @@ public class UserServiceImpl implements UserService {
             return userMapper.listToDto(users);
         } catch (Exception e) {
             e.printStackTrace();
-            throw new BadRequestAlertException(e.getMessage(), "User", "User registration failed");
+            throw new BadRequestAlertException(e.getMessage(), "User", "error");
         }
     }
 
@@ -154,11 +167,12 @@ public class UserServiceImpl implements UserService {
                 user.setFirstName(userDto.getFirstName());
                 user.setLastName(userDto.getLastName());
                 user.setPhone(userDto.getPhone());
+                user.setDob(userDto.getDob());
                 return userMapper.toDto(userDao.save(user));
             }
         } catch (Exception e) {
             e.printStackTrace();
-            throw new BadRequestAlertException(e.getMessage(), "User", "User registration failed");
+            throw new BadRequestAlertException(e.getMessage(), "User", "error");
         }
     }
 
@@ -178,7 +192,73 @@ public class UserServiceImpl implements UserService {
             }
         } catch (Exception e) {
             e.printStackTrace();
-            throw new BadRequestAlertException(e.getMessage(), "User", "User registration failed");
+            throw new BadRequestAlertException(e.getMessage(), "User", "error");
+        }
+    }
+
+    @Override
+    public ResponseDto uploadImage(Long userId, MultipartFile file) {
+        log.info("Inside user service upload image method");
+        try {
+            Optional<User> userOp = userDao.findById(userId);
+            if (userOp.isEmpty()) {
+                throw new BadRequestAlertException("User not found", "User", "User not found");
+            } else {
+                Optional<Document> documentOp = documentDao.findByUserUserIdAndDocumentType(userId, PROFILE_IMAGE);
+                DocumentDto documentDto = new DocumentDto();
+                if (documentOp.isPresent()) {
+                    documentDto = documentMapper.toDto(documentOp.get());
+                }
+                // save file into system
+                if (file.isEmpty()) {
+                    throw new BadRequestAlertException("Please select a Image to upload", "User", "Image upload failed");
+                }
+                // Validate file content type
+                String contentType = file.getContentType();
+                if (!ALLOWED_CONTENT_TYPES.contains(contentType)) {
+                    throw new BadRequestAlertException("Invalid file type. Only JPEG, PNG, and JPG files are allowed.", "User", "Image upload failed");
+                }
+                documentDto.setDocumentType(PROFILE_IMAGE);
+                documentDto.setDocumentName(file.getOriginalFilename());
+                documentDto.setData(file.getBytes());
+                documentDto.setUserId(userId);
+
+                // save image
+                documentDto = documentMapper.toDto(documentDao.save(documentMapper.toEntity(documentDto)));
+
+                // response
+                ResponseDto responseDto = new ResponseDto();
+                responseDto.setId(documentDto.getDocumentId());
+                responseDto.setMessage("Image uploaded successfully");
+                return responseDto;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw new BadRequestAlertException(e.getMessage(), "User", "error");
+        }
+    }
+
+    @Override
+    public ResponseEntity<byte[]> getImage(Long userId) {
+        log.info("Inside user service get image method");
+        try {
+            Optional<User> userOp = userDao.findById(userId);
+            if (userOp.isEmpty()) {
+                throw new BadRequestAlertException("User not found", "User", "User not found");
+            } else {
+                Optional<Document> documentOp = documentDao.findByUserUserIdAndDocumentType(userId, PROFILE_IMAGE);
+                if (documentOp.isEmpty()) {
+                    throw new BadRequestAlertException("Image not found", "User", "Image not found");
+                } else {
+                    DocumentDto documentDto = documentMapper.toDto(documentOp.get());
+                    return ResponseEntity.ok()
+                            .contentType(MediaType.valueOf(determineImageContentType(documentDto.getDocumentName())))
+                            .body(documentDto.getData());
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw new BadRequestAlertException(e.getMessage(), "User", "error");
         }
     }
 }

src/main/java/com/kaluwa/enterprises/babycarebackendservice/utils/Utils.java

+package com.kaluwa.enterprises.babycarebackendservice.utils;
+
+import org.springframework.web.multipart.MultipartFile;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class Utils {
+
+    // List of allowed image MIME types
+    public static final List<String> ALLOWED_CONTENT_TYPES = Arrays.asList(
+            "image/jpeg",
+            "image/png",
+            "image/jpg"
+    );
+
+    public static final String determineImageContentType(String filename) {
+        String contentType;
+        if (filename.endsWith(".jpeg")) {
+            contentType = "image/jpeg";
+        } else if (filename.endsWith(".png")) {
+            contentType = "image/png";
+        } else if (filename.endsWith(".jpg")) {
+            contentType = "image/jpg";
+        } else {
+            contentType = "application/octet-stream";
+        }
+        return contentType;
+    }
+
+}

src/main/resources/application.yaml

@@ -16,9 +16,15 @@ spring:
     show-sql: false
     properties:
       hibernate:
+        dialect: org.hibernate.dialect.MySQLDialect
         format_sql: true
+  servlet:
+    multipart:
+      enabled: true
+      max-file-size: 5MB
+      max-request-size: 5MB
 
 server:
   port: 8080
   servlet:
-    context-path: /api/v1/baby-care
\ No newline at end of file
+    context-path: /api/v1/baby-care