Merge pull request #181 from bounswe/mobile-posts2

Merge mobile posts branch into main mobile branch

application/.gitignore

@@ -0,0 +1,2 @@
+.idea
+.env

application/README.md

@@ -0,0 +1,53 @@
+# Architecture
+
+Fanatic consists of three main parts, namely ```./fanatic-backend```, ```./frontend``` and ```./mobile``` that contain the respective codebase for backend,
+frontend and mobile modules.
+
+## Development
+
+To build and start the app locally, run:
+
+```
+cd bounswe2024group8/application
+docker-compose up --build
+```
+
+The script above builds and runs the images on the local Docker client to allow developers to develop and test the application simultaneously. If everything goes as intended, the application should be accessible on:
+
+```
+http://localhost:3000
+```
+
+## Deployment
+
+Google Cloud Run is our choice of platform to deploy containers for this project. We deploy our project with the following steps:
+
+1. Run a postgres instance in the Cloud App and create a database
+
+2. To deploy backend, use the URL from 1. and run:
+
+   ```
+   cd bounswe2024group8/application/fanatic-backend
+   gcloud run deploy
+   ```
+
+3.  To deploy frontend, use the URL from 2. and run:
+
+   ```   
+   cd bounswe2024group8/application/frontend
+   gcloud run deploy
+   ```
+
+
+If everything goes as intended, the backend should be accessible at:
+
+```
+https://fanatic-backend-bjbpof6jaq-oa.a.run.app/
+```
+
+Frontend should be accessible at:
+
+```
+https://frontend-bjbpof6jaq-oa.a.run.app/
+```
+

application/docker-compose.yml

@@ -30,7 +30,7 @@ services:
       context: ./frontend
       dockerfile: Dockerfile
     ports:
-      - "80:80"
+      - "3000:3000"
     depends_on:
       - backend
 

application/fanatic-backend/pom.xml

@@ -44,6 +44,11 @@
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-actuator</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-validation</artifactId>
+            <version>3.2.1</version>
+        </dependency>
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
@@ -75,6 +80,11 @@
             <type>pom</type>
             <version>3.17.0</version>
         </dependency>
+        <dependency>
+            <groupId>com.google.cloud.sql</groupId>
+            <artifactId>postgres-socket-factory</artifactId>
+            <version>1.18.0</version>
+        </dependency>
     </dependencies>
 
     <build>

application/fanatic-backend/src/main/java/com/example/fanaticbackend/config/SecurityConfiguration.java

@@ -40,6 +40,7 @@ public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Excepti
                         .requestMatchers(HttpMethod.GET, "/api/v1/auth/login").permitAll()
                         .requestMatchers(HttpMethod.POST, "/api/v1/auth/register").permitAll()
                         .requestMatchers("/api/v1/auth/**").permitAll()
+                        .requestMatchers("/api/v1/communities").permitAll()
                         .anyRequest().authenticated()
                 )
                 .sessionManagement(session -> session.sessionCreationPolicy(STATELESS))

application/fanatic-backend/src/main/java/com/example/fanaticbackend/controller/AuthenticationController.java

@@ -4,6 +4,7 @@
 import com.example.fanaticbackend.payload.AuthenticationResponse;
 import com.example.fanaticbackend.payload.RegisterRequest;
 import com.example.fanaticbackend.service.AuthenticationService;
+import jakarta.validation.Valid;
 import lombok.AccessLevel;
 import lombok.RequiredArgsConstructor;
 import lombok.experimental.FieldDefaults;
@@ -23,7 +24,7 @@ public class AuthenticationController {
 
     @PostMapping("/register")
     public ResponseEntity<AuthenticationResponse> register(
-            @RequestBody RegisterRequest request
+            @Valid @RequestBody RegisterRequest request
     ) {
         return ResponseEntity.ok(authenticationService.register(request));
     }

application/fanatic-backend/src/main/java/com/example/fanaticbackend/controller/CommentController.java

@@ -0,0 +1,44 @@
+package com.example.fanaticbackend.controller;
+
+import com.example.fanaticbackend.model.User;
+import com.example.fanaticbackend.payload.CommentResponse;
+import com.example.fanaticbackend.service.CommentService;
+import com.example.fanaticbackend.service.CommunityService;
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/v1/comments")
+@RequiredArgsConstructor
+@FieldDefaults(level = AccessLevel.PRIVATE)
+public class CommentController {
+
+    final CommentService commentService;
+
+
+    @GetMapping("/post/{postId}")
+    public ResponseEntity<List<CommentResponse>> getComments(
+            @AuthenticationPrincipal UserDetails userDetails,
+            @PathVariable Long postId) {
+
+        List<CommentResponse> comments = commentService.getCommentsByPostId((User) userDetails, postId);
+
+        if (comments.isEmpty()) {
+            return ResponseEntity.notFound().build();
+        }
+
+        return ResponseEntity.ok(comments);
+
+    }
+
+}

application/fanatic-backend/src/main/java/com/example/fanaticbackend/controller/CommunityController.java

@@ -0,0 +1,38 @@
+package com.example.fanaticbackend.controller;
+
+import com.example.fanaticbackend.model.Community;
+import com.example.fanaticbackend.service.CommunityService;
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/api/v1/communities")
+@RequiredArgsConstructor
+@FieldDefaults(level = AccessLevel.PRIVATE)
+public class CommunityController {
+
+    final CommunityService communityService;
+
+
+    @GetMapping("{communityName}")
+    public ResponseEntity<Community> getCommunityByName(
+            @PathVariable String communityName
+    ) {
+
+        Community community = communityService.findCommunityByTeamElseThrow(communityName);
+
+        return ResponseEntity.ok(community);
+    }
+
+
+    @PostMapping("")
+    public ResponseEntity<Boolean> createAll() {
+
+        communityService.createAllCommunities();
+
+        return ResponseEntity.ok(true);
+    }
+}

application/fanatic-backend/src/main/java/com/example/fanaticbackend/controller/PostController.java

@@ -1,13 +1,20 @@
 package com.example.fanaticbackend.controller;
 
+import com.example.fanaticbackend.model.Comment;
 import com.example.fanaticbackend.model.Post;
-import com.example.fanaticbackend.payload.PostCreateRequest;
-import com.example.fanaticbackend.payload.SearchResponse;
+import com.example.fanaticbackend.model.User;
+import com.example.fanaticbackend.model.enums.ReactionType;
+import com.example.fanaticbackend.payload.*;
+import com.example.fanaticbackend.service.CommentService;
 import com.example.fanaticbackend.service.PostService;
+import com.example.fanaticbackend.service.UserService;
+import jakarta.validation.Valid;
 import lombok.AccessLevel;
 import lombok.RequiredArgsConstructor;
 import lombok.experimental.FieldDefaults;
 import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.security.core.userdetails.UserDetails;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
@@ -19,21 +26,26 @@
 public class PostController {
 
     final PostService postService;
+    final CommentService commentService;
 
     @PostMapping("")
     public ResponseEntity<Post> create(
-            @RequestBody PostCreateRequest request) {
+            @AuthenticationPrincipal UserDetails userDetails,
+            @Valid @ModelAttribute PostCreateRequest request) {
 
-        Post savedPost = postService.create(request);
+        User user = (User) userDetails;
+
+        Post savedPost = postService.create(user, request);
 
         return ResponseEntity.ok(savedPost);
     }
 
     @GetMapping("")
     public ResponseEntity<SearchResponse> search(
+            @AuthenticationPrincipal UserDetails userDetails,
             @RequestParam String param) {
 
-        var result = postService.searchPost(param);
+        var result = postService.searchPost((User) userDetails, param);
 
         if (result.getPosts().isEmpty() && result.getTeam() == null) {
             return ResponseEntity.notFound().build();
@@ -43,9 +55,60 @@ public ResponseEntity<SearchResponse> search(
     }
 
     @GetMapping("/feed")
-    public ResponseEntity<List<Post>> getFeed() {
+    public ResponseEntity<List<PostResponse>> getFeed(
+            @AuthenticationPrincipal UserDetails userDetails) {
+
+        List<PostResponse> posts = postService.getFeed((User) userDetails);
+
+        if (posts.isEmpty()) {
+            return ResponseEntity.notFound().build();
+        }
+
+        return ResponseEntity.ok(posts);
+    }
+
+    @PostMapping("/{postId}/react")
+    public ResponseEntity<ReactionResponse> reactPost(
+            @AuthenticationPrincipal UserDetails userDetails,
+            @Valid @RequestBody ReactionRequest request,
+            @PathVariable Long postId) {
+        // @oguz
+        ReactionResponse result = postService.reactToPost((User) userDetails, request, postId);
+
+
+        return ResponseEntity.ok(result);
+
+    }
+
+    @PostMapping("/comment")
+    public ResponseEntity<Comment> createComment(
+            @AuthenticationPrincipal UserDetails userDetails,
+            @RequestBody CommentCreateRequest request) {
+
+        User user = (User) userDetails;
+        Comment savedComment = commentService.createComment((User) userDetails, request);
+
+        return ResponseEntity.ok(savedComment);
+    }
+
+    @PostMapping("/comment/{commentId}/react")
+    public ResponseEntity<CommentReactionResponse> reactComment(
+            @AuthenticationPrincipal UserDetails userDetails,
+            @RequestParam ReactionType reactionType,
+            @PathVariable Long commentId) {
+        // @oguz
+        CommentReactionResponse result = commentService.reactToComment((User) userDetails, reactionType, commentId);
+
+        return ResponseEntity.ok(result);
+
+    }
+
+    @GetMapping("/community/{communityTeam}")
+    public ResponseEntity<List<PostResponse>> getPostsOfCommunity(
+            @AuthenticationPrincipal UserDetails userDetails,
+            @PathVariable String communityTeam) {
 
-        List<Post> posts = postService.getFeed();
+        List<PostResponse> posts = postService.getPostsByCommunity((User) userDetails, communityTeam);
 
         if (posts.isEmpty()) {
             return ResponseEntity.notFound().build();
@@ -54,5 +117,50 @@ public ResponseEntity<List<Post>> getFeed() {
         return ResponseEntity.ok(posts);
     }
 
+    @GetMapping("/user/{userId}")
+    public ResponseEntity<List<PostResponse>> getPostsOfUser(
+            @AuthenticationPrincipal UserDetails userDetails,
+            @PathVariable Long userId) {
+
+        List<PostResponse> posts = postService.getPostsByUser((User) userDetails, userId);
+
+        if (posts.isEmpty()) {
+            return ResponseEntity.notFound().build();
+        }
+
+        return ResponseEntity.ok(posts);
+    }
+
+
+    @GetMapping("/user/{userId}/reacted")
+    public ResponseEntity<List<PostResponse>> getPostsUserReactedTo(
+            @AuthenticationPrincipal UserDetails userDetails,
+            @PathVariable Long userId) {
+
+        List<PostResponse> posts = postService.getPostsUserReactedTo((User) userDetails, userId);
+
+        if (posts.isEmpty()) {
+            return ResponseEntity.notFound().build();
+        }
+
+        return ResponseEntity.ok(posts);
+    }
+
+    @GetMapping("/user/{userId}/bookmarked")
+    public ResponseEntity<List<PostResponse>> getBookmarkedPosts(
+            @AuthenticationPrincipal UserDetails userDetails,
+            @PathVariable Long userId) {
+
+        List<PostResponse> posts = postService.getBookmarkedPosts((User) userDetails, userId);
+
+        if (posts.isEmpty()) {
+            return ResponseEntity.notFound().build();
+        }
+
+        return ResponseEntity.ok(posts);
+    }
+
+
+
 
 }