original commit

src/main/java/com/ziplinegreen/vault/Controller/PostController.java

 import com.ziplinegreen.vault.Model.Post;
 import com.ziplinegreen.vault.Model.User;
 import com.ziplinegreen.vault.Repository.PostRepository;
-import com.ziplinegreen.vault.Repository.UserRepository;
+import com.ziplinegreen.vault.Repository.UsersRepository;
 import com.ziplinegreen.vault.Service.PostService;
 import com.ziplinegreen.vault.Service.UserService;
 import org.springframework.beans.factory.annotation.Autowired;
 import javax.validation.Valid;
 import java.util.Set;
 
-@Controller
+@RestController
 public class PostController {
 
-    @Autowired
     private PostService postService;
-    @Autowired
     private UserController userController;
 
-    @Autowired
-    private PostRepository repository;
 
     @Autowired
-    public PostController(PostService postService) {
+    public PostController(PostService postService, UserController userController) {
         this.postService = postService;
+        this.userController = userController;
     }
 
-//    @PostMapping("/posts/{userId}")
-//    public ResponseEntity createPost(@PathVariable Long userId, @RequestBody Post post) {
-//        //userController.updatePosts(userId,post);
-//        return new ResponseEntity(userController.updatePosts(userId, post), HttpStatus.OK);
-//
-//    }
 
-    @MessageMapping("/posts/{userId}")
+    @MessageMapping("/posts")
     @SendTo("/topic/posts")
-    public Post createPost(@DestinationVariable("userId") Long userId, @RequestBody Post post) {
-    //public Post createPost(@RequestBody Post post) {
-        System.out.println(post.getMessage());
-        post.setUserName(userController.getUserById(userId).getBody().getUsername());
-        //return userController.updatePosts(userId,post);
-        return repository.save(post);
-        //return post;
-        //return new ResponseEntity(userController.updatePosts(userId, post), HttpStatus.OK);
-
+    public Post createPost(@RequestBody Post post) {
+        post.setUserName(userController.getUserById(post.getUserId()).getUsername());
+        return postService.createPost(post);
     }
 
     @GetMapping("/posts/all")
     public Iterable<Post> getAllPosts() {
-        return repository.findAll();
+        return postService.getAllPosts();
     }
 
-
-
     @GetMapping("/posts/{userId}")
-    //@SendTo("/topic/posts")
-    public ResponseEntity<Iterable<Post>> getAllPostsByUserId(@PathVariable Long userId) {
+    public Iterable<Post> getAllPostsByUserId(@PathVariable Long userId) {
         return postService.findByUserId(userId);
     }
 
-//    @PutMapping("/users/{userId/posts")
-//    public ResponseEntity<Post> updatePost(@PathVariable Long userId, @RequestBody Post post){
-//        return postService.updatePost(userId, post);
-//    }
+    @DeleteMapping("/posts/delete")
+    public ResponseEntity deletePost(@RequestBody Long postId) {
+        return postService.deletePost(postId);
+    }
 
+    @DeleteMapping("/posts/deleteAll")
+    public ResponseEntity deleteAllPosts(@RequestBody Long userId) {
+        return postService.deleteAllPosts(userId);
+    }
 
+    @PutMapping("/posts/update/{postId}")
+    public Post updatePost(@PathVariable Long postId, @RequestBody String message) {
+        return postService.updatePost(postId,message);
+    }
 
-//    @PutMapping("/users/{userId}/posts/{postId}")
-//    public Post updateComment(@PathVariable (value = "userId") Long userId,
-//                                 @PathVariable (value = "postId") Long postId,
-//                                 @Valid @RequestBody Post postRequest) {
-//        if(!userRepository.existsById(userId)) {
-//            throw new ResourceNotFoundException("UserId " + userId + " not found");
-//        }
-//
-//        return postRepository.findById(postId).map(post -> {
-//            post.setMessage(postRequest.getMessage());
-//            return postRepository.save(post);
-//        }).orElseThrow(() -> new ResourceNotFoundException("PostId " + postId + "not found"));
-//    }
-//
-//    @DeleteMapping("/posts/{postId}/comments/{commentId}")
-//    public ResponseEntity<?> deleteComment(@PathVariable (value = "userId") Long userId,
-//                                           @PathVariable (value = "postId") Long postId) {
-//        if(!userRepository.existsById(userId)) {
-//            throw new ResourceNotFoundException("UserId " + userId + " not found");
-//        }
-//
-//        return postRepository.findById(postId).map(post -> {
-//            postRepository.delete(post);
-//            return ResponseEntity.ok().build();
-//        }).orElseThrow(() -> new ResourceNotFoundException("PostId " + postId + " not found"));
-//    }
 }

src/main/java/com/ziplinegreen/vault/Controller/UserController.java

 import com.ziplinegreen.vault.Exception.ResourceNotFoundException;
 import com.ziplinegreen.vault.Model.Post;
 import com.ziplinegreen.vault.Model.User;
-import com.ziplinegreen.vault.Repository.UserRepository;
+import com.ziplinegreen.vault.Repository.UsersRepository;
 import com.ziplinegreen.vault.Service.UserService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.Page;
     }
 
     @PostMapping("/users")
-    public ResponseEntity<User> createUser(@RequestBody User user) {
+    public User createUser(@RequestBody User user) {
         return userService.createUser(user);
     }
 
     @GetMapping("/users/{userId}")
-    public ResponseEntity<User> getUserById(@PathVariable Long userId) {
+    public User getUserById(@PathVariable Long userId) {
         return userService.findUserById(userId);
     }
 
     @PutMapping("/users/{userId}")
-    public ResponseEntity<User> updateUsername(@PathVariable Long userId, @Valid @RequestBody User userRequest) {
-        return new ResponseEntity<>(userService.updateUsername(userId,userRequest), HttpStatus.OK);
+    public User updateUsername(@PathVariable Long userId, @RequestBody String username) {
+        return userService.updateUsername(userId, username);
     }
 
-
     @DeleteMapping("/users/{userId}")
     public ResponseEntity<?> deleteUser(@PathVariable Long userId) {
         return userService.deleteUser(userId);
     }
-
-    @PutMapping("/users/{userId}/updatepost")
-    public ResponseEntity<?> updatePosts(@PathVariable Long userId, @RequestBody Post post){
-        return userService.updatePosts(userId, post);
-    }
-
-
 }

src/main/java/com/ziplinegreen/vault/Model/Post.java

     private Long Id;
 
     @NotNull
-    @Lob
     private String message;
     @OnDelete(action = OnDeleteAction.CASCADE)
-    @JsonIgnore
     private Long userId;
     private String userName;
 
         this.userName = userName;
     }
 
+    @Override
+    public String toString() {
+        return "Post{" +
+                "Id=" + Id +
+                ", message='" + message + '\'' +
+                ", userId=" + userId +
+                ", userName='" + userName + '\'' +
+                '}';
+    }
 }

src/main/java/com/ziplinegreen/vault/Model/User.java

     private String username;
     private String email;
     private String password;
-    @OneToMany(fetch = FetchType.LAZY,
+    @OneToMany(
             cascade= {
                 CascadeType.PERSIST,
                 CascadeType.MERGE
-            })
-    @JoinTable(name = "user_posts",
-            joinColumns = {@JoinColumn(name = "user_id")})
+            }, mappedBy = "userId")
     private List<Post> posts = new ArrayList<>();
 
     public List<Post> getPosts() {

src/main/java/com/ziplinegreen/vault/Repository/UserRepository.java

-package com.ziplinegreen.vault.Repository;
-
-import com.ziplinegreen.vault.Model.User;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.rest.core.annotation.RepositoryRestResource;
-import org.springframework.stereotype.Repository;
-
-@RepositoryRestResource
-public interface UserRepository extends JpaRepository<User,Long> {
-}

src/main/java/com/ziplinegreen/vault/Repository/UsersRepository.java

+package com.ziplinegreen.vault.Repository;
+
+import com.ziplinegreen.vault.Model.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface UsersRepository extends JpaRepository<User, Long> {
+}

src/main/java/com/ziplinegreen/vault/Service/PostService.java

         this.postRepository = postRepository;
     }
 
-    public ResponseEntity<Post> createPost(Post post){
-        return new ResponseEntity<>(postRepository.save(post), HttpStatus.CREATED);
+    public Post createPost(Post post){
+        return postRepository.save(post);
     }
 
-    public ResponseEntity<Post> deletePost(Long id){
-        Post post = postRepository.getOne(id);
-        postRepository.delete(post);
+    public Iterable<Post> getAllPosts(){
+        return postRepository.findAll();
+    }
+
+    public ResponseEntity deletePost(Long postId){
+        postRepository.delete(postRepository.findById(postId).get());
         return new ResponseEntity<>(HttpStatus.OK);
     }
 
-    public ResponseEntity<Iterable<Post>> findByUserId(Long userId) {
-        return new ResponseEntity<>(postRepository.findByUserId(userId), HttpStatus.OK);
+    public ResponseEntity deleteAllPosts(Long userId){
+        Iterable<Post> posts = findByUserId(userId);
+        for(Post post: posts){
+            deletePost(post.getId());
+        }
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+    public Iterable<Post> findByUserId(Long userId) {
+        return postRepository.findByUserId(userId);
+    }
+
+    public Post updatePost(Long postId, String message){
+        Post post = postRepository.findById(postId).get();
+        post.setMessage(message);
+        return postRepository.save(post);
     }
 
-//    public ResponseEntity<Post> updatePost(Long userId, Post post) {
-//
-//    }
 }
 

src/main/java/com/ziplinegreen/vault/Service/UserService.java

 import com.ziplinegreen.vault.Exception.ResourceNotFoundException;
 import com.ziplinegreen.vault.Model.Post;
 import com.ziplinegreen.vault.Model.User;
-import com.ziplinegreen.vault.Repository.UserRepository;
+import com.ziplinegreen.vault.Repository.UsersRepository;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 public class UserService {
 
     @Autowired
-    private UserRepository userRepository;
+    private UsersRepository userRepository;
+    private PostService postService;
     //private PostController postController;
 
     @Autowired
-    public UserService(UserRepository userRepository) {
+    public UserService(UsersRepository userRepository, PostService postService) {
         this.userRepository = userRepository;
+        this.postService = postService;
     }
 
-    public ResponseEntity<User> createUser(User user){
-        return new ResponseEntity<>(userRepository.save(user), HttpStatus.CREATED);
+    public User createUser(User user){
+        return userRepository.save(user);
     }
 
-    public ResponseEntity<User> findUserById(Long id){
-        return new ResponseEntity<>(userRepository.findById(id).get(),HttpStatus.OK);
+    public User findUserById(Long id){
+        return userRepository.findById(id).get();
     }
 
-    public User updateUsername(Long id, User updatedUser){return userRepository.findById(id).map(user -> {
-        user.setUsername(updatedUser.getUsername());
+    public User updateUsername(Long userId, String username){
+        User user = findUserById(userId);
+        user.setUsername(username);
         return userRepository.save(user);
-    }).orElseThrow(() -> new ResourceNotFoundException("UserId " + id + " not found"));
     }
 
-    public ResponseEntity deleteUser(Long id){return userRepository.findById(id).map(user -> {
-        userRepository.delete(user);
+    public ResponseEntity deleteUser(Long userId){
+        postService.deleteAllPosts(userId);
+        userRepository.delete(userRepository.findById(userId).get());
         return new ResponseEntity(HttpStatus.OK);
-    }).orElseThrow(() -> new ResourceNotFoundException("UserId " + id + " not found"));
-
-    }
-
-    public ResponseEntity<User> updatePosts(Long userId, Post post) {
-        User user = findUserById(userId).getBody();
-        List<Post> posts = user.getPosts();
-        posts.add(post);
-        return new ResponseEntity<>(userRepository.save(user), HttpStatus.OK);
     }
 }
 

src/main/resources/static/app.js

 }
 
 var userId = 1;
-var userPostUrl = "/app/posts/1";
+var userPostUrl = "/app/posts";
 
 function user1() {
     $('#user1').prop("disabled", true);
     $('#user1').prop("disabled", false);
     $('#user2').prop("disabled", true);
     userId = 2;
-    userPostUrl = "/app/posts/2";
 }