Adding file for new hugging face docker space

Dockerfile

@@ -0,0 +1,28 @@
+# -------- Stage 1: Build the Spring Boot application --------
+FROM maven:3.9.6-eclipse-temurin-21 AS build
+
+# Create a working directory
+WORKDIR /app
+
+# Copy the Maven project files
+COPY pom.xml .
+COPY src ./src
+
+# Build the project (skip tests to speed up)
+RUN mvn clean package -DskipTests
+
+
+# -------- Stage 2: Create a lightweight runtime image --------
+FROM openjdk:21-jdk
+
+# Set working directory in runtime container
+WORKDIR /app
+
+# Copy the built jar file from the build stage
+COPY --from=build /app/target/*.jar app.jar
+
+# Expose the Spring Boot default port
+EXPOSE 8080
+
+# Run the app
+ENTRYPOINT ["java", "-jar", "app.jar"]

README.md

@@ -1,10 +1,11 @@
 ---
-title: Mymedia Java Backend
-emoji: 📉
-colorFrom: pink
-colorTo: blue
+title: My Media
+emoji: 🏢
+colorFrom: green
+colorTo: pink
 sdk: docker
 pinned: false
+license: mit
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

docker-compose.yml

@@ -0,0 +1,38 @@
+version: '3.7'
+services:
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    ports:
+      - 8081:8080
+    depends_on:
+      mysqldb:
+        condition: service_healthy
+    environment:
+      - SPRING_DATASOURCE_URL=jdbc:mysql://mysqldb:3306/mystara
+      - SPRING_DATASOURCE_USERNAME=root
+      - SPRING_DATASOURCE_PASSWORD=root
+    networks:
+      - springboot-mysql-network
+  mysqldb:
+    image: mysql:8.0
+    ports:
+      - 3307:3306
+    environment:
+      - MYSQL_DATABASE=mystara
+      - MYSQL_ROOT_PASSWORD=root
+    volumes:
+      - mysql-data:/var/lib/mysql
+    networks:
+      - springboot-mysql-network
+    healthcheck:
+      test: ["CMD", "mysqladmin" ,"ping", "-h", "localhost", "-proot"]
+      retries: 10
+      interval: 3s
+      timeout: 30s
+volumes:
+  mysql-data:
+networks:
+  springboot-mysql-network:
+    name: springboot-mysql-network

pom.xml

@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>3.1.5</version>
+        <relativePath />
+    </parent>
+    <groupId>com.bezkoder</groupId>
+    <artifactId>My_media</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>spring-boot-data-jpa</name>
+    <description>Demo project for Spring Boot Apis CRUD using Spring Data JPA</description>
+
+    <properties>
+        <java.version>21</java.version>
+    </properties>
+
+    <dependencies>
+        <!-- Web -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+
+        <!-- Spring Data JPA -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-jpa</artifactId>
+        </dependency>
+
+        <!-- MySQL Driver -->
+        <dependency>
+            <groupId>com.mysql</groupId>
+            <artifactId>mysql-connector-j</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+
+        <!-- Validation (optional but useful for input checks) -->
+        <dependency>
+            <groupId>jakarta.validation</groupId>
+            <artifactId>jakarta.validation-api</artifactId>
+        </dependency>
+
+        <!-- Lombok (optional, for cleaner model code) -->
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+        </dependency>
+
+        <!-- Testing -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+        <!--Swagger-->
+        <dependency>
+            <groupId>org.springdoc</groupId>
+            <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
+            <version>2.2.0</version>
+        </dependency>
+        <!-- JWT -->
+        <dependency>
+            <groupId>com.auth0</groupId>
+            <artifactId>java-jwt</artifactId>
+            <version>4.4.0</version>
+        </dependency>
+
+
+        <dependency>
+            <groupId>commons-codec</groupId>
+            <artifactId>commons-codec</artifactId>
+            <version>1.15</version>
+        </dependency>
+    </dependencies>
+
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

src/main/java/com/krishna/FormApplication.java

@@ -0,0 +1,13 @@
+package com.krishna;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class FormApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(FormApplication.class, args);
+    }
+
+}

src/main/java/com/krishna/config/WebConfig.java

@@ -0,0 +1,28 @@
+package com.krishna.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.CorsRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+@Configuration
+public class WebConfig {
+
+    @Bean
+    public WebMvcConfigurer corsConfigurer() {
+        return new WebMvcConfigurer() {
+            @Override
+            public void addCorsMappings(CorsRegistry registry) {
+                registry.addMapping("/**")
+                        .allowedOrigins(
+                                "http://127.0.0.1:5500",
+                                "http://localhost:5173",
+                                "https://my-media-718.netlify.app"
+                        )
+                        .allowedMethods("*")
+                        .allowedHeaders("*")
+                        .allowCredentials(true);
+            }
+        };
+    }
+}

src/main/java/com/krishna/controller/CommentController.java

@@ -0,0 +1,46 @@
+package com.krishna.controller;
+
+import com.krishna.dto.CommentDTO;
+import com.krishna.model.CommentModel;
+import com.krishna.service.CommentService;
+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.List;
+
+@CrossOrigin(origins = {"http://localhost:8080", "http://localhost:8081", "http://127.0.0.1:5500", "http://localhost:5173/", "https://my-media-718.netlify.app/"})
+@RestController
+@RequestMapping("/comments")
+public class CommentController {
+
+    @Autowired
+    private CommentService commentService;
+
+    @PostMapping("/add")
+    public ResponseEntity<?> addComment(@RequestBody CommentDTO dto) {
+        try {
+            CommentModel comment = commentService.addComment(dto);
+            return ResponseEntity.ok(comment);
+        } catch (Exception e) {
+            return ResponseEntity.badRequest().body("Error: " + e.getMessage());
+        }
+    }
+
+    @GetMapping("/post/{postId}")
+    public ResponseEntity<List<CommentModel>> getComments(@PathVariable Long postId) {
+        return ResponseEntity.ok(commentService.getCommentsByPost(postId));
+    }
+
+    // ✅ Corrected delete mapping for deleting a COMMENT
+    @DeleteMapping("/{commentId}")
+    public ResponseEntity<String> deleteComment(@PathVariable Long commentId) {
+        try {
+            commentService.deleteComment(commentId);
+            return ResponseEntity.ok("Comment deleted successfully.");
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body("Error: " + e.getMessage());
+        }
+    }
+}

src/main/java/com/krishna/controller/LikeController.java

@@ -0,0 +1,40 @@
+package com.krishna.controller;
+
+import com.krishna.service.LikeService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.UUID;
+
+@CrossOrigin(origins = {"http://localhost:8080", "http://localhost:8081", "http://127.0.0.1:5500", "http://localhost:5173/", "https://my-media-718.netlify.app"})
+@RestController
+@RequestMapping("/likes")
+public class LikeController {
+
+    @Autowired
+    private LikeService likeService;
+
+    @PostMapping("/toggle")
+    public ResponseEntity<String> toggleLike(
+            @RequestParam UUID userId,
+            @RequestParam Long postId
+    ) {
+        boolean liked = likeService.toggleLike(userId, postId);
+        return ResponseEntity.ok(liked ? "Post liked successfully" : "Post unliked");
+    }
+
+    @GetMapping("/count/{postId}")
+    public Long getLikeCount(@PathVariable Long postId) {
+        return likeService.getLikeCount(postId);
+    }
+
+    @GetMapping("/status")
+    public ResponseEntity<Boolean> checkIfUserLikedPost(
+            @RequestParam UUID userId,
+            @RequestParam Long postId
+    ) {
+        boolean liked = likeService.hasUserLikedPost(userId, postId);
+        return ResponseEntity.ok(liked);
+    }
+}

src/main/java/com/krishna/controller/PostController.java

@@ -0,0 +1,115 @@
+package com.krishna.controller;
+
+import com.krishna.dto.PostRequestDTO;
+import com.krishna.dto.PostUpdateDTO;
+import com.krishna.model.PostModel;
+import com.krishna.model.UserModel;
+import com.krishna.repository.LikeRepository;
+import com.krishna.repository.PostRepository;
+import com.krishna.repository.UserRepository;
+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.List;
+import java.util.Optional;
+import java.util.UUID;
+
+@RestController
+@RequestMapping("/posts")
+@CrossOrigin(origins = {"http://localhost:8080", "http://localhost:8081", "http://127.0.0.1:5500", "http://localhost:5173/", "https://my-media-718.netlify.app/"})
+public class PostController {
+
+    @Autowired
+    private PostRepository postRepository;
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @Autowired
+    private LikeRepository likeRepository;
+
+    @PostMapping("/add")
+    public ResponseEntity<PostModel> createPost(@RequestBody PostRequestDTO postRequestDTO) {
+        try {
+            UUID userId = postRequestDTO.getUserId();
+            if (userId == null) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(null);
+            }
+
+            UserModel user = userRepository.findById(userId).orElse(null);
+            if (user == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body(null);
+            }
+
+            PostModel postModel = new PostModel();
+            postModel.setUserModel(user);
+            postModel.setContent(postRequestDTO.getContent());
+            postModel.setImageUrl(postRequestDTO.getImageUrl());
+
+            PostModel savedPost = postRepository.save(postModel);
+            return ResponseEntity.status(HttpStatus.CREATED).body(savedPost);
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
+        }
+    }
+
+    // READ: All Posts
+    @GetMapping
+    public ResponseEntity<List<PostModel>> getAllPosts() {
+        try {
+            List<PostModel> posts = postRepository.findAll();
+            return ResponseEntity.ok(posts);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+
+    // UPDATE
+    @PutMapping("/{id}")
+    public ResponseEntity<PostModel> updatePost(@PathVariable Long id, @RequestBody PostUpdateDTO postUpdateDTO) {
+        try {
+            Optional<PostModel> optionalPost = postRepository.findById(id);
+            if (optionalPost.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body(null);
+            }
+
+            PostModel post = optionalPost.get();
+            post.setContent(postUpdateDTO.getContent());
+            post.setImageUrl(postUpdateDTO.getImageUrl());
+
+            PostModel updatedPost = postRepository.save(post);
+            return ResponseEntity.ok(updatedPost);
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
+        }
+    }
+
+    // DELETE
+    @DeleteMapping("/{id}")
+    public ResponseEntity<String> deletePost(@PathVariable Long id) {
+        try {
+            Optional<PostModel> optionalPost = postRepository.findById(id);
+            if (optionalPost.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("Post not found");
+            }
+
+            // Delete associated likes first
+            likeRepository.deleteByPostId(id);
+
+
+            postRepository.deleteById(id);
+            return ResponseEntity.ok("Post deleted successfully");
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Something went wrong");
+        }
+    }
+}

src/main/java/com/krishna/controller/UserController.java

@@ -0,0 +1,131 @@
+package com.krishna.controller;
+
+import com.auth0.jwt.JWT;
+import com.auth0.jwt.algorithms.Algorithm;
+import com.krishna.dto.LoginResponseDTO;
+import com.krishna.model.UserModel;
+import com.krishna.repository.UserRepository;
+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.security.MessageDigest;
+import java.util.Date;
+import java.util.List;
+import java.util.Optional;
+
+@CrossOrigin(origins = {"http://localhost:8080", "http://localhost:8081", "http://127.0.0.1:5500", "http://localhost:5173/", "https://my-media-718.netlify.app/"})
+@RestController
+@RequestMapping("/user")
+public class UserController {
+
+    @Autowired
+    private UserRepository userRepository;
+
+    private final String JWT_SECRET = "your_secret_key";  // Replace with a secure secret in production
+
+    // 🔐 Utility method to hash password with SHA-1
+    private String hashPasswordSHA1(String password) throws Exception {
+        MessageDigest sha1 = MessageDigest.getInstance("SHA-1");
+        byte[] hashBytes = sha1.digest(password.getBytes("UTF-8"));
+        StringBuilder sb = new StringBuilder();
+        for (byte b : hashBytes) {
+            sb.append(String.format("%02x", b));
+        }
+        return sb.toString();
+    }
+
+    // 📝 Register a new user
+    @PostMapping("/register")
+    public ResponseEntity<?> registerUser(@RequestBody UserModel user) {
+        try {
+            if (user.getEmail() == null || user.getPassword() == null) {
+                return ResponseEntity.badRequest().body("Email, password and username are required.");
+            }
+
+            Optional<UserModel> existingUser = userRepository.findByEmail(user.getEmail());
+            if (existingUser.isPresent()) {
+                return ResponseEntity.badRequest().body("Email already registered.");
+            }
+
+            // 🔐 Hash password before storing
+            String hashedPassword = hashPasswordSHA1(user.getPassword());
+            user.setPassword(hashedPassword);
+
+            // ✅ Set default profile image if not provided
+            if (user.getProfileUrl() == null || user.getProfileUrl().isEmpty()) {
+                user.setProfileUrl("../assets/images/profile-pic.jpg");
+            }
+
+            UserModel savedUser = userRepository.save(user);
+            return ResponseEntity.ok(savedUser);
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            return ResponseEntity.status(500).body("Error: " + e.getMessage());
+        }
+    }
+
+
+    // 🔐 Login a user
+    @PostMapping("/login")
+    public ResponseEntity<?> loginUser(@RequestBody UserModel loginRequest) {
+        try {
+            if (loginRequest.getEmail() == null || loginRequest.getPassword() == null) {
+                return ResponseEntity.badRequest().body("Email and password are required.");
+            }
+
+            Optional<UserModel> userOpt = userRepository.findByEmail(loginRequest.getEmail());
+            if (userOpt.isPresent()) {
+                UserModel user = userOpt.get();
+
+                // 🔐 Hash incoming password
+                String hashedInputPassword = hashPasswordSHA1(loginRequest.getPassword());
+
+                // ✅ Match hashed password
+                if (user.getPassword().equals(hashedInputPassword)) {
+                    String token = generateToken(user);
+
+                    LoginResponseDTO response = new LoginResponseDTO(
+                            user.getId(),
+                            user.getEmail(),
+                            token,
+                            user.getUsername(),
+                            user.getFullName(),
+                            user.getProfileUrl()
+                    );
+
+                    return ResponseEntity.ok(response);
+                } else {
+                    return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Invalid password.");
+                }
+            } else {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("User not found.");
+            }
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Login error: " + e.getMessage());
+        }
+    }
+
+    // 🔐 JWT Token generation
+    private String generateToken(UserModel user) {
+        Algorithm algorithm = Algorithm.HMAC256(JWT_SECRET);
+        return JWT.create()
+                .withSubject(user.getEmail())
+                .withClaim("fullName", user.getFullName())
+                .withIssuedAt(new Date())
+                .withExpiresAt(new Date(System.currentTimeMillis() + 3600 * 1000))
+                .sign(algorithm);
+    }
+
+    // 🔍 Search users by username or fullName
+    @GetMapping("/search")
+    public ResponseEntity<List<UserModel>> searchUsers(@RequestParam("query") String query) {
+        List<UserModel> users = userRepository.findByUsernameContainingIgnoreCaseOrFullNameContainingIgnoreCase(query, query);
+        return ResponseEntity.ok(users);
+    }
+
+}

src/main/java/com/krishna/dto/CommentDTO.java

@@ -0,0 +1,23 @@
+package com.krishna.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import java.util.UUID;
+
+public class CommentDTO {
+    @JsonProperty("userId")
+    private UUID userId;
+    @JsonProperty("postId")
+    private Long postId;
+
+    private String content;
+
+    public UUID getUserId() { return userId; }
+    public void setUserId(UUID userId) { this.userId = userId; }
+
+    public Long getPostId() { return postId; }
+    public void setPostId(Long postId) { this.postId = postId; }
+
+    public String getContent() { return content; }
+    public void setContent(String content) { this.content = content; }
+}

src/main/java/com/krishna/dto/LoginResponseDTO.java

@@ -0,0 +1,70 @@
+package com.krishna.dto;
+
+import java.util.UUID;
+
+public class LoginResponseDTO {
+    private UUID userId;
+    private String email;
+    private String token;
+    private String username;
+    private String fullName;
+    private String profileUrl;
+
+    public LoginResponseDTO(UUID userId, String email, String token, String username, String fullName, String profileUrl) {
+        this.userId = userId;
+        this.email = email;
+        this.username = username;
+        this.token = token;
+        this.fullName = fullName;
+        this.profileUrl = profileUrl;
+    }
+
+    // Getters and Setters
+    public UUID getUserId() {
+        return userId;
+    }
+
+    public void setUserId(UUID userId) {
+        this.userId = userId;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    public String getToken() {
+        return token;
+    }
+
+    public void setToken(String token) {
+        this.token = token;
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public String getFullName() {
+        return fullName;
+    }
+
+    public void setFullName(String fullName) {
+        this.fullName = fullName;
+    }
+
+    public String getProfileUrl() {
+        return profileUrl;
+    }
+
+    public void setProfileUrl(String profileUrl) {
+        this.profileUrl = profileUrl;
+    }
+}

src/main/java/com/krishna/dto/PostRequestDTO.java

@@ -0,0 +1,30 @@
+package com.krishna.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import java.util.UUID;
+
+public class PostRequestDTO {
+    private String content;
+
+    @JsonProperty("imageUrl")
+    private String imageUrl;
+
+    @JsonProperty("userId")
+    private UUID userId;
+
+    public PostRequestDTO(UUID userId, String content, String imageUrl) {
+        this.userId = userId;
+        this.content = content;
+        this.imageUrl = imageUrl;
+    }
+
+    public String getContent() { return content; }
+    public void setContent(String content) { this.content = content; }
+
+    public String getImageUrl() { return imageUrl; }
+    public void setImageUrl(String imageUrl) { this.imageUrl = imageUrl; }
+
+    public UUID getUserId() { return userId; }
+    public void setUserId(UUID userId) { this.userId = userId; }
+}

src/main/java/com/krishna/dto/PostUpdateDTO.java

@@ -0,0 +1,29 @@
+package com.krishna.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import java.util.UUID;
+
+public class PostUpdateDTO {
+    private String content;
+
+    @JsonProperty("image_url")
+    private String imageUrl;
+
+    @JsonProperty("userId")
+    private UUID userId;
+
+    public PostUpdateDTO( String content, String imageUrl) {
+        this.content = content;
+        this.imageUrl = imageUrl;
+    }
+
+    public String getContent() { return content; }
+    public void setContent(String content) { this.content = content; }
+
+    public String getImageUrl() { return imageUrl; }
+    public void setImageUrl(String imageUrl) { this.imageUrl = imageUrl; }
+
+    public UUID getUserId() { return userId; }
+    public void setUserId(UUID userId) { this.userId = userId; }
+}

src/main/java/com/krishna/model/CommentModel.java

@@ -0,0 +1,46 @@
+package com.krishna.model;
+
+import jakarta.persistence.*;
+import java.util.UUID;
+
+@Entity
+@Table(name = "comments")
+public class CommentModel {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    private String content;
+
+    @ManyToOne
+    @JoinColumn(name = "user_id", nullable = false)
+    private UserModel user;
+
+    @ManyToOne
+    @JoinColumn(name = "post_id", nullable = false)
+    private PostModel post;
+
+    // Constructors
+    public CommentModel() {}
+
+    public CommentModel(String content, UserModel user, PostModel post) {
+        this.content = content;
+        this.user = user;
+        this.post = post;
+    }
+
+    // Getters and Setters
+    public Long getId() { return id; }
+    public void setId(Long id) { this.id = id; }
+
+    public String getContent() { return content; }
+    public void setContent(String content) { this.content = content; }
+
+    public UserModel getUser() { return user; }
+    public void setUser(UserModel user) { this.user = user; }
+
+    public PostModel getPost() { return post; }
+    public void setPost(PostModel post) { this.post = post; }
+}

src/main/java/com/krishna/model/LikeModel.java

@@ -0,0 +1,56 @@
+package com.krishna.model;
+
+import jakarta.persistence.*;
+import java.util.*;
+
+@Entity
+@Table(name = "likes", uniqueConstraints = {
+        @UniqueConstraint(columnNames = {"user_id", "post_id"})
+})
+public class LikeModel {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @ManyToOne
+    private UserModel user;
+
+    @ManyToOne
+    private PostModel post;
+
+
+
+    public LikeModel() {}
+
+    public LikeModel(UserModel user, PostModel post) {
+        this.user = user;
+        this.post = post;
+    }
+
+    // Getters and setters
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public PostModel getPost() {
+        return post;
+    }
+
+    public void setPost(PostModel post) {
+        this.post = post;
+    }
+
+    public UserModel getUser() {
+        return user;
+    }
+
+    public void setUser(UserModel user) {
+        this.user = user;
+    }
+}

src/main/java/com/krishna/model/PostModel.java

@@ -0,0 +1,53 @@
+package com.krishna.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import jakarta.persistence.*;
+import org.hibernate.annotations.CreationTimestamp;
+import org.hibernate.annotations.UpdateTimestamp;
+
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "posts")
+public class PostModel {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @ManyToOne(fetch = FetchType.EAGER)
+    @JoinColumn(name = "user_id", nullable = false)
+    @JsonIgnoreProperties({"hibernateLazyInitializer", "handler"})
+    private UserModel userModel;
+
+    @Column(nullable = false, columnDefinition = "TEXT")
+    private String content;
+
+    @Column(name = "image_url", columnDefinition = "TEXT")
+    private String imageUrl;
+
+    @CreationTimestamp
+    private LocalDateTime createdAt;
+
+    @UpdateTimestamp
+    private LocalDateTime updatedAt;
+
+    // Getters and setters
+    public Long getId() { return id; }
+    public void setId(Long id) { this.id = id; }
+
+    public UserModel getUserModel() { return userModel; }
+    public void setUserModel(UserModel userModel) { this.userModel = userModel; }
+
+    public String getContent() { return content; }
+    public void setContent(String content) { this.content = content; }
+
+    public String getImageUrl() { return imageUrl; }
+    public void setImageUrl(String imageUrl) { this.imageUrl = imageUrl; }
+
+    public LocalDateTime getCreatedAt() { return createdAt; }
+    public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; }
+
+    public LocalDateTime getUpdatedAt() { return updatedAt; }
+    public void setUpdatedAt(LocalDateTime updatedAt) { this.updatedAt = updatedAt; }
+}

src/main/java/com/krishna/model/UserModel.java

@@ -0,0 +1,96 @@
+package com.krishna.model;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import jakarta.persistence.*;
+import org.hibernate.annotations.GenericGenerator;
+
+import java.util.UUID;
+
+@Entity
+@Table(name = "Users")
+
+public class UserModel {
+
+    @Id
+    @GeneratedValue(generator = "UUID")
+    @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator")
+    @Column(name = "id", updatable = false, nullable = false)
+    private UUID id;
+
+    @Column(name = "fullName")
+    @JsonProperty("full_name")
+    private String fullName;
+
+    @Column(name = "userName")
+    @JsonProperty("user_name")
+    private String username;
+
+    @Column(name = "email")
+    private String email;
+
+    @Column(name = "password")
+    private String password;
+
+    @Column(name = "profile_url", columnDefinition = "TEXT")
+    @JsonProperty("profile_url")
+    private String profileUrl;
+
+    public UserModel() {
+    }
+
+    public UserModel(String fullName, String username, String email, String password, String profileUrl) {
+        this.fullName = fullName;
+        this.username = username;
+        this.email = email;
+        this.password = password;
+        this.profileUrl = profileUrl;
+    }
+
+    public UUID getId() {
+        return id;
+    }
+
+    public void setId(UUID id) {
+        this.id = id;
+    }
+
+    public String getFullName() {
+        return fullName;
+    }
+
+    public void setFullName(String fullName) {
+        this.fullName = fullName;
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public String getProfileUrl() {
+        return profileUrl;
+    }
+
+    public void setProfileUrl(String profileUrl) {
+        this.profileUrl = profileUrl;
+    }
+}

src/main/java/com/krishna/repository/CommentRepository.java

@@ -0,0 +1,11 @@
+package com.krishna.repository;
+
+import com.krishna.model.CommentModel;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+import java.util.UUID;
+
+public interface CommentRepository extends JpaRepository<CommentModel, Long> {
+    List<CommentModel> findByPostId(Long postId);
+}

src/main/java/com/krishna/repository/LikeRepository.java

@@ -0,0 +1,23 @@
+package com.krishna.repository;
+
+import com.krishna.model.LikeModel;
+import com.krishna.model.PostModel;
+import com.krishna.model.UserModel;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Optional;
+
+public interface LikeRepository extends JpaRepository<LikeModel, Long> {
+
+    Optional<LikeModel> findByUserAndPost(UserModel user, PostModel post);
+
+    Long countByPost(PostModel post);
+
+    @Transactional
+    @Modifying
+    @Query("DELETE FROM LikeModel l WHERE l.post.id = :postId")
+    void deleteByPostId(Long postId);
+}

src/main/java/com/krishna/repository/PostRepository.java

@@ -0,0 +1,13 @@
+package com.krishna.repository;
+
+import com.krishna.model.PostModel;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.UUID;
+
+@Repository
+public interface PostRepository extends JpaRepository<PostModel, Long> {
+    List<PostModel> findByUserModelId(UUID id);
+}

src/main/java/com/krishna/repository/UserRepository.java

@@ -0,0 +1,13 @@
+package com.krishna.repository;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+import org.springframework.data.jpa.repository.JpaRepository;
+import com.krishna.model.UserModel;
+
+public interface UserRepository extends JpaRepository<UserModel, UUID> {
+    Optional<UserModel> findByEmail(String email);
+
+    List<UserModel> findByUsernameContainingIgnoreCaseOrFullNameContainingIgnoreCase(String username, String fullName);
+}

src/main/java/com/krishna/service/CommentService.java

@@ -0,0 +1,48 @@
+package com.krishna.service;
+
+import com.krishna.dto.CommentDTO;
+import com.krishna.model.CommentModel;
+import com.krishna.model.PostModel;
+import com.krishna.model.UserModel;
+import com.krishna.repository.CommentRepository;
+import com.krishna.repository.PostRepository;
+import com.krishna.repository.UserRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.UUID;
+
+@Service
+public class CommentService {
+
+    @Autowired
+    private CommentRepository commentRepository;
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @Autowired
+    private PostRepository postRepository;
+
+    public CommentModel addComment(CommentDTO dto) throws Exception {
+        System.out.println("Received DTO: " + dto.getPostId() + ", " + dto.getUserId());
+
+        UserModel user = userRepository.findById(dto.getUserId())
+                .orElseThrow(() -> new Exception("User not found"));
+
+        PostModel post = postRepository.findById(dto.getPostId())
+                .orElseThrow(() -> new Exception("Post not found"));
+
+        CommentModel comment = new CommentModel(dto.getContent(), user, post);
+        return commentRepository.save(comment);
+    }
+
+    public List<CommentModel> getCommentsByPost(Long postId) {
+        return commentRepository.findByPostId(postId);
+    }
+
+    public void deleteComment(Long commentId) {
+        commentRepository.deleteById(commentId); // Or custom logic if needed
+    }
+}

src/main/java/com/krishna/service/LikeService.java

@@ -0,0 +1,66 @@
+package com.krishna.service;
+
+import com.krishna.model.LikeModel;
+import com.krishna.model.PostModel;
+import com.krishna.model.UserModel;
+import com.krishna.repository.LikeRepository;
+import com.krishna.repository.PostRepository;
+import com.krishna.repository.UserRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+import java.util.UUID;
+
+@Service
+public class LikeService {
+
+    @Autowired
+    private LikeRepository likeRepository;
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @Autowired
+    private PostRepository postRepository;
+
+
+    public boolean toggleLike(UUID userId, Long postId) {
+        Optional<UserModel> userOpt = userRepository.findById(userId);
+        Optional<PostModel> postOpt = postRepository.findById(postId);
+
+        if (userOpt.isEmpty() || postOpt.isEmpty()) {
+            return false;
+        }
+
+        UserModel user = userOpt.get();
+        PostModel post = postOpt.get();
+
+        Optional<LikeModel> likeOpt = likeRepository.findByUserAndPost(user, post);
+
+        if (likeOpt.isPresent()) {
+            likeRepository.delete(likeOpt.get());
+            return false;
+        } else {
+            LikeModel newLike = new LikeModel(user, post);
+            likeRepository.save(newLike);
+            return true;
+        }
+    }
+
+    public Long getLikeCount(Long postId) {
+        Optional<PostModel> postOpt = postRepository.findById(postId);
+        return postOpt.map(likeRepository::countByPost).orElse(0L);
+    }
+
+    public boolean hasUserLikedPost(UUID userId, Long postId) {
+        Optional<UserModel> userOpt = userRepository.findById(userId);
+        Optional<PostModel> postOpt = postRepository.findById(postId);
+
+        if (userOpt.isEmpty() || postOpt.isEmpty()) {
+            return false;
+        }
+
+        return likeRepository.findByUserAndPost(userOpt.get(), postOpt.get()).isPresent();
+    }
+}

src/main/resources/application.properties

@@ -0,0 +1,16 @@
+#MySQL configuration
+spring.datasource.url=jdbc:mysql://localhost:3306/mystara
+spring.datasource.username = root
+spring.datasource.password = root
+spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
+
+spring.jpa.hibernate.ddl-auto=update
+spring.jpa.show-sql=true
+spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect
+
+spring.jackson.property-naming-strategy=SNAKE_CASE
+
+spring.cache.type=simple
+
+server.port=8080
+logging.level.org.springframework=DEBUG

src/test/java/com/krishna/controller/CommentControllerTest.java

@@ -0,0 +1,80 @@
+package com.krishna.controller;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.krishna.dto.CommentDTO;
+import com.krishna.model.CommentModel;
+import com.krishna.service.CommentService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+
+import java.util.List;
+import java.util.UUID;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+@WebMvcTest(CommentController.class)
+public class CommentControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private CommentService commentService;
+
+    @Autowired
+    private ObjectMapper objectMapper;
+
+    private CommentModel mockComment;
+
+    @BeforeEach
+    void setup() {
+        mockComment = new CommentModel();
+        mockComment.setId(1L);
+        mockComment.setContent("Test comment");
+        // Optional: You can mock user/post if needed in your model
+    }
+
+    @Test
+    void testAddComment() throws Exception {
+        CommentDTO dto = new CommentDTO();
+        dto.setContent("Test comment");
+        dto.setPostId(100L);
+        dto.setUserId(UUID.randomUUID());
+
+        Mockito.when(commentService.addComment(any(CommentDTO.class))).thenReturn(mockComment);
+
+        mockMvc.perform(post("/comments/add")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(dto)))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.content").value("Test comment"));
+    }
+
+    @Test
+    void testGetCommentsByPost() throws Exception {
+        Mockito.when(commentService.getCommentsByPost(100L)).thenReturn(List.of(mockComment));
+
+        mockMvc.perform(get("/comments/post/100"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$[0].content").value("Test comment"));
+    }
+
+    @Test
+    void testDeletePost() throws Exception {
+        Mockito.doNothing().when(commentService).deleteComment(100L);
+
+        mockMvc.perform(delete("/comments/100"))
+                .andExpect(status().isOk())
+                .andExpect(content().string("Comment deleted successfully."));
+    }
+}

src/test/java/com/krishna/controller/LikeControllerTest.java

@@ -0,0 +1,92 @@
+package com.krishna.controller;
+
+import com.krishna.service.LikeService;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+
+import java.util.UUID;
+
+import static org.mockito.Mockito.when;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+@WebMvcTest(LikeController.class)
+class LikeControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private LikeService likeService;
+
+    @Test
+    void toggleLike_ShouldReturnLikedMessage() throws Exception {
+        UUID userId = UUID.randomUUID();
+        Long postId = 1L;
+
+        when(likeService.toggleLike(userId, postId)).thenReturn(true);
+
+        mockMvc.perform(post("/likes/toggle")
+                        .param("userId", userId.toString())
+                        .param("postId", postId.toString()))
+                .andExpect(status().isOk())
+                .andExpect(content().string("Post liked successfully"));
+    }
+
+    @Test
+    void toggleLike_ShouldReturnUnlikedMessage() throws Exception {
+        UUID userId = UUID.randomUUID();
+        Long postId = 2L;
+
+        when(likeService.toggleLike(userId, postId)).thenReturn(false);
+
+        mockMvc.perform(post("/likes/toggle")
+                        .param("userId", userId.toString())
+                        .param("postId", postId.toString()))
+                .andExpect(status().isOk())
+                .andExpect(content().string("Post unliked"));
+    }
+
+    @Test
+    void getLikeCount_ShouldReturnCount() throws Exception {
+        Long postId = 3L;
+        when(likeService.getLikeCount(postId)).thenReturn(42L);
+
+        mockMvc.perform(get("/likes/count/{postId}", postId))
+                .andExpect(status().isOk())
+                .andExpect(content().string("42"));
+    }
+
+    @Test
+    void checkIfUserLikedPost_ShouldReturnTrue() throws Exception {
+        UUID userId = UUID.randomUUID();
+        Long postId = 4L;
+
+        when(likeService.hasUserLikedPost(userId, postId)).thenReturn(true);
+
+        mockMvc.perform(get("/likes/status")
+                        .param("userId", userId.toString())
+                        .param("postId", postId.toString()))
+                .andExpect(status().isOk())
+                .andExpect(content().string("true"));
+    }
+
+    @Test
+    void checkIfUserLikedPost_ShouldReturnFalse() throws Exception {
+        UUID userId = UUID.randomUUID();
+        Long postId = 5L;
+
+        when(likeService.hasUserLikedPost(userId, postId)).thenReturn(false);
+
+        mockMvc.perform(get("/likes/status")
+                        .param("userId", userId.toString())
+                        .param("postId", postId.toString()))
+                .andExpect(status().isOk())
+                .andExpect(content().string("false"));
+    }
+}

src/test/java/com/krishna/controller/PostControllerTest.java

@@ -0,0 +1,147 @@
+package com.krishna.controller;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.krishna.dto.PostRequestDTO;
+import com.krishna.dto.PostUpdateDTO;
+import com.krishna.model.PostModel;
+import com.krishna.model.UserModel;
+import com.krishna.repository.LikeRepository;
+import com.krishna.repository.PostRepository;
+import com.krishna.repository.UserRepository;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+
+import java.util.*;
+
+import static org.mockito.Mockito.*;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+@WebMvcTest(PostController.class)
+class PostControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private PostRepository postRepository;
+
+    @MockBean
+    private UserRepository userRepository;
+
+    @MockBean
+    private LikeRepository likeRepository;
+
+    @Autowired
+    private ObjectMapper objectMapper;
+
+    private UUID userId;
+    private UserModel user;
+    private PostModel post;
+
+    @BeforeEach
+    void setUp() {
+        userId = UUID.randomUUID();
+        user = new UserModel();
+        user.setId(userId);
+        user.setFullName("Krishna");
+        user.setUsername("krish");
+        user.setEmail("krish@example.com");
+
+        post = new PostModel();
+        post.setId(1L);
+        post.setContent("Hello world");
+        post.setImageUrl("image.jpg");
+        post.setUserModel(user);
+    }
+
+    @Test
+    void createPost_ShouldReturnCreated() throws Exception {
+        PostRequestDTO request = new PostRequestDTO(userId, "New post", "img.jpg");
+
+        when(userRepository.findById(userId)).thenReturn(Optional.of(user));
+        when(postRepository.save(any(PostModel.class))).thenReturn(post);
+
+        mockMvc.perform(post("/posts/add")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(request)))
+                .andExpect(status().isCreated());
+    }
+
+    @Test
+    void createPost_ShouldReturnNotFound_WhenUserNotFound() throws Exception {
+        PostRequestDTO request = new PostRequestDTO(userId, "Post", "img.jpg");
+
+        when(userRepository.findById(userId)).thenReturn(Optional.empty());
+
+        mockMvc.perform(post("/posts/add")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(request)))
+                .andExpect(status().isNotFound());
+    }
+
+    @Test
+    void getAllPosts_ShouldReturnListOfPosts() throws Exception {
+        List<PostModel> posts = List.of(post);
+        when(postRepository.findAll()).thenReturn(posts);
+
+        mockMvc.perform(get("/posts"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$[0].content").value("Hello world"));
+    }
+
+    @Test
+    void updatePost_ShouldReturnUpdatedPost() throws Exception {
+        PostUpdateDTO updateDTO = new PostUpdateDTO("Updated content", "updated.jpg");
+
+        // Simulate that the post has been updated
+        post.setContent(updateDTO.getContent());
+        post.setImageUrl(updateDTO.getImageUrl());
+
+        when(postRepository.findById(1L)).thenReturn(Optional.of(post));
+        when(postRepository.save(any(PostModel.class))).thenReturn(post);
+
+        mockMvc.perform(put("/posts/1")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(updateDTO)))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.content").value("Updated content"));
+    }
+
+    @Test
+    void updatePost_ShouldReturnNotFound() throws Exception {
+        PostUpdateDTO updateDTO = new PostUpdateDTO("No post", "no.jpg");
+
+        when(postRepository.findById(2L)).thenReturn(Optional.empty());
+
+        mockMvc.perform(put("/posts/2")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(updateDTO)))
+                .andExpect(status().isNotFound());
+    }
+
+    @Test
+    void deletePost_ShouldReturnSuccess() throws Exception {
+        when(postRepository.findById(1L)).thenReturn(Optional.of(post));
+        doNothing().when(likeRepository).deleteByPostId(1L);
+        doNothing().when(postRepository).deleteById(1L);
+
+        mockMvc.perform(delete("/posts/1"))
+                .andExpect(status().isOk())
+                .andExpect(content().string("Post deleted successfully"));
+    }
+
+    @Test
+    void deletePost_ShouldReturnNotFound() throws Exception {
+        when(postRepository.findById(99L)).thenReturn(Optional.empty());
+
+        mockMvc.perform(delete("/posts/99"))
+                .andExpect(status().isNotFound())
+                .andExpect(content().string("Post not found"));
+    }
+}

src/test/java/com/krishna/controller/UserControllerTest.java

@@ -0,0 +1,118 @@
+package com.krishna.controller;
+
+import com.krishna.model.UserModel;
+import com.krishna.repository.UserRepository;
+import org.apache.commons.codec.digest.DigestUtils;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+@WebMvcTest(UserController.class)
+class UserControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private UserRepository userRepository;
+
+    private ObjectMapper objectMapper;
+    private UserModel user;
+
+    @BeforeEach
+    void setUp() {
+        objectMapper = new ObjectMapper();
+
+        String rawPassword = "Password@123";
+        String hashedPassword = DigestUtils.sha1Hex(rawPassword); // from Apache Commons Codec
+
+        user = new UserModel("Krishna Dev", "krish123", "krishna@example.com", hashedPassword, rawPassword);
+        user.setId(UUID.randomUUID());
+    }
+
+    @Test
+    void registerUser_Success() throws Exception {
+        when(userRepository.findByEmail(user.getEmail())).thenReturn(Optional.empty());
+        when(userRepository.save(any(UserModel.class))).thenReturn(user);
+
+        mockMvc.perform(post("/user/register")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(user)))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.email").value(user.getEmail()));
+    }
+
+    @Test
+    void registerUser_EmailAlreadyExists() throws Exception {
+        when(userRepository.findByEmail(user.getEmail())).thenReturn(Optional.of(user));
+
+        mockMvc.perform(post("/user/register")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(user)))
+                .andExpect(status().isBadRequest())
+                .andExpect(content().string("Email already registered."));
+    }
+
+    @Test
+    void loginUser_Success() throws Exception {
+        when(userRepository.findByEmail(user.getEmail())).thenReturn(Optional.of(user));
+
+        Map<String, String> loginRequest = new HashMap<>();
+        loginRequest.put("email", user.getEmail());
+        loginRequest.put("password", "Password@123");
+
+        mockMvc.perform(post("/user/login")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(loginRequest)))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.email").value("krishna@example.com"))
+                .andExpect(jsonPath("$.username").value("krish123"))
+                .andExpect(jsonPath("$.token").exists());
+    }
+
+    @Test
+    void loginUser_InvalidPassword() throws Exception {
+        when(userRepository.findByEmail(user.getEmail())).thenReturn(Optional.of(user));
+
+        Map<String, String> loginRequest = new HashMap<>();
+        loginRequest.put("email", user.getEmail());
+        loginRequest.put("password", "WrongPassword123");
+
+        mockMvc.perform(post("/user/login")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(loginRequest)))
+                .andExpect(status().isUnauthorized())
+                .andExpect(content().string("Invalid password."));
+    }
+
+    @Test
+    void loginUser_UserNotFound() throws Exception {
+        when(userRepository.findByEmail(user.getEmail())).thenReturn(Optional.empty());
+
+        mockMvc.perform(post("/user/login")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(user)))
+                .andExpect(status().isNotFound())
+                .andExpect(content().string("User not found."));
+    }
+}