Implemented comments

api/app.js

@@ -7,6 +7,7 @@ const JWT = require("jsonwebtoken");
 const postsRouter = require("./routes/posts");
 const tokensRouter = require("./routes/tokens");
 const usersRouter = require("./routes/users");
+const commentRouter = require("./routes/comments");
 
 const app = express();
 
@@ -19,7 +20,6 @@ app.use(express.static(path.join(__dirname, "public")));
 
 // middleware function to check for valid tokens
 const tokenChecker = (req, res, next) => {
-
   let token;
   const authHeader = req.get("Authorization")
 
@@ -29,7 +29,6 @@ const tokenChecker = (req, res, next) => {
 
   JWT.verify(token, process.env.JWT_SECRET, (err, payload) => {
     if(err) {
-      console.log(err)
       res.status(401).json({message: "auth error"});
     } else {
       req.user_id = payload.user_id;
@@ -42,6 +41,7 @@ const tokenChecker = (req, res, next) => {
 app.use("/posts", tokenChecker, postsRouter);
 app.use("/tokens", tokensRouter);
 app.use("/users", usersRouter);
+app.use("/comments", commentRouter);
 
 // catch 404 and forward to error handler
 app.use((req, res, next) => {

api/controllers/comments.js

@@ -0,0 +1,40 @@
+const Comment = require("../models/comments");
+const TokenGenerator = require("../models/token_generator");
+
+  const CommentController = {
+
+    // Create a new comment
+    CreateComment: (req, res) => {
+        const comment = new Comment(
+          {
+            comment: req.body.comment,
+            post: req.body.post,
+            poster: req.body.poster
+          }
+        );
+        comment.save(async (err) => {
+          if (err) {
+            throw err;
+          }
+
+          console.log("PASSED")
+          const token = await TokenGenerator.jsonwebtoken(req.user_id)
+          res.status(201).json({ message: 'OK', token: token });
+        });
+      },
+
+    GetCommentByPost: async (req, res) => {
+        const postId = req.params.post_id;
+
+        try {
+            const comments = await Comment.find({ post: postId }).populate('poster', 'firstName');
+            console.log(comments)
+            res.status(200).json({ comments: comments });
+        } catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    },
+
+    };
+
+module.exports = CommentController;

api/controllers/posts.js

@@ -1,27 +1,74 @@
 const Post = require("../models/post");
 const TokenGenerator = require("../models/token_generator");
 
-const PostsController = {
-  Index: (req, res) => {
-    Post.find(async (err, posts) => {
-      if (err) {
-        throw err;
-      }
-      const token = await TokenGenerator.jsonwebtoken(req.user_id)
-      res.status(200).json({ posts: posts, token: token });
-    });
-  },
-  Create: (req, res) => {
-    const post = new Post(req.body);
-    post.save(async (err) => {
-      if (err) {
-        throw err;
+
+  const PostsController = {
+    Index: async (req, res) => {
+      try {
+        const posts = await Post.find().populate('poster', 'firstName').sort({createdAt: -1});;
+        const token = await TokenGenerator.jsonwebtoken(req.user_id);
+        res.status(200).json({ posts: posts, token: token });
+        console.log(res.status);
+      } catch (err) {
+        console.error(err);
+        res.status(500).json({ error: 'Unable to retrieve posts' });
       }
+    },
+
+    Create: (req, res) => {
+      const post = new Post(req.body);
+      post.save(async (err) => {
+        if (err) {
+          throw err;
+        }
+
+        const token = await TokenGenerator.jsonwebtoken(req.user_id)
+        res.status(201).json({ message: 'OK', token: token });
+      });
+    },
+
+    NewLike: (req, res) => {
+      Post.findById(req.body.postId, (err, post) => {
+        const alreadyLiked = post.likes.includes(req.body.userId);
+        if(alreadyLiked){
+          res.status(401).json({ message: "post already liked"})
+        }
+        if (err) {
+          throw err;
+        } else {
+          post.likes.push(req.body.userId);
+          post.save((err) => {
+            if (err) {
+              throw err;
+            } else {
+              res.status(201).json({ message: 'Like added' });
+            }
+          });
+        }
+      });
+    },
 
-      const token = await TokenGenerator.jsonwebtoken(req.user_id)
-      res.status(201).json({ message: 'OK', token: token });
-    });
-  },
+    Unlike: (req, res) => {
+      Post.findById(req.body.postId, (err, post) => {
+        if (err) {
+          throw err;
+        } else {
+          const alreadyLiked = post.likes.includes(req.body.userId);
+          if (alreadyLiked) {
+            const index = post.likes.indexOf(req.body.userId);
+            post.likes.splice(index, 1);
+            post.save((err) => {
+              if (err) {
+                throw err;
+              } else {
+                res.status(201).json({ message: 'Unlike successful' });
+              }
+            })
+          } else {
+            res.status(404).json({ message: "post already unliked"})
+          }
+        }}
+      )}
 };
 
 module.exports = PostsController;

api/controllers/tokens.js

@@ -8,6 +8,7 @@ const SessionsController = {
     const password = req.body.password;
 
     User.findOne({ email: email }).then(async (user) => {
+
       if (!user) {
         console.log("auth error: user not found")
         res.status(401).json({ message: "auth error" });
@@ -16,10 +17,12 @@ const SessionsController = {
         res.status(401).json({ message: "auth error" });
       } else {
         const token = await TokenGenerator.jsonwebtoken(user.id)
-        res.status(201).json({ token: token, message: "OK" });
+        // res.status(201).json({token: token, user: user})
+        res.status(201).json({ token: token, email: user.email, firstName: user.firstName, lastName: user.lastName, _id: user._id, message: "OK"});
       }
     });
   }
 };
 
+
 module.exports = SessionsController;

api/controllers/users.js

@@ -1,6 +1,18 @@
 const User = require("../models/user");
 
 const UsersController = {
+  Index: (req, res) => {
+    const user_id = req.user_id
+
+    User.findOne({_id: user_id}).then(async (user) => {
+      if (!user) {
+        res.status(401).json({ message: "user id not found" });
+      } else {
+        res.status(201).json({username, firstName, lastName, _id})
+      }
+    });
+  },
+
   Create: (req, res) => {
     const user = new User(req.body);
     user.save((err) => {
@@ -11,6 +23,18 @@ const UsersController = {
       }
     });
   },
+
+  showUser: (req, res) => {
+    const user_id = req.user_id
+
+    User.findById(user_id).then(async (user) => {
+      if(error) {
+        throw error;
+      } else {
+        res.status(201).json({username, firstName, lastName, _id})
+      }
+    })
+  }
 };
 
 module.exports = UsersController;

api/models/comments.js

@@ -0,0 +1,14 @@
+const mongoose = require("mongoose");
+const {Schema} = mongoose
+
+const CommentSchema = new Schema({
+  comment: String,
+  poster: { type: mongoose.Schema.Types.ObjectId, ref: "User", required: true },
+  post: { type: mongoose.Schema.Types.ObjectId, ref: "Post", required: true },
+}, {
+  timestamps: true
+});
+
+const Comment = mongoose.model("Comment", CommentSchema);
+
+module.exports = Comment;

api/models/post.js

@@ -1,7 +1,12 @@
 const mongoose = require("mongoose");
+const {Schema} = mongoose
 
-const PostSchema = new mongoose.Schema({
-  message: String
+const PostSchema = new Schema({
+  message: String,
+  likes: [{ type: mongoose.Schema.Types.ObjectId, ref: 'User' }],
+  poster: { type: mongoose.Schema.Types.ObjectId, ref: "User" }
+}, {
+  timestamps: true
 });
 
 const Post = mongoose.model("Post", PostSchema);

api/models/user.js

@@ -3,6 +3,8 @@ const mongoose = require("mongoose");
 const UserSchema = new mongoose.Schema({
   email: { type: String, required: true },
   password: { type: String, required: true },
+  firstName: { type: String, required: true },
+  lastName: { type: String, required: true }
 });
 
 const User = mongoose.model("User", UserSchema);