Postlikes and replylikes

README.md

@@ -1,10 +1,10 @@
-# Capstone I Backend
+# Capstone II Backend
 
 ## Getting Started
 
 This project uses Express.js to serve up an API server, and Sequelize to connect to a PostgreSQL database. It uses JWTs for authentication with username and password.
 
-You will also need to create the database: by default it is called `capstone-1`, but you are welcome to rename it in `database/db.js`
+You will also need to create the database: by default it is called `capstone-2`, but you are welcome to rename it in `database/db.js`
 
 After that, you can get started with these commands
 

api/forum.js

@@ -0,0 +1,68 @@
+const express = require('express');
+const router = express.Router();
+const {Forum, Post, Reply, User} = require('../database')
+
+// Get posts for a specific forum
+router.get('/:forumId/posts', async (req, res) => {
+    const { forumId } = req.params;
+    console.log(`Fetching posts for forum ID: ${forumId}`);
+    try {
+      const posts = await Post.findAll({
+        where: { forumId },
+        include: [{ model: User, attributes: ['username'] }],
+        order: [['createdAt', 'DESC']],
+      });
+      res.json(posts);
+    } catch (err) {
+      console.error('Error fetching posts: ', err);
+      res.status(500).json({ error: 'Failed to fetch posts for this forum.' });
+    }
+  });
+
+  router.get('/:forumId/posts/:postId', async (req, res) => {
+    const { postId, forumId } = req.params;
+    console.log(`Fetching post for post ID: ${postId}`);
+    try {
+      const post = await Post.findOne({
+        where: { forumId, id: postId },
+        include: [{ model: User, attributes: ['username']}],
+      });
+      res.json(post);
+    } catch (err) {
+      console.error('Error fetching post by id: ', err);
+      res.status(500).json({ error: 'Failed to fetch posts for this forum.' });
+    }
+  });
+
+//Create a new post in a forum
+router.post('/:forumId/post/', async(req, res) => {
+  const { forumId } = req.params;
+  try {
+    const { title, content, userId, likes = 0 } = req.body;
+    const newPost = await Post.create({
+      title,
+      content,
+      likes,
+      userId,
+      forumId: forumId,
+    });
+
+    res.status(201).json(newPost);
+  } catch (error) {
+    console.error(error);
+    res.status(500).send("Error from the post new post route");
+  }
+});
+
+// Get all forums
+router.get('/', async (req, res) => {
+    try {
+      const forums = await Forum.findAll();
+      res.json(forums);
+    } catch (err) {
+      console.error('Error fetching forums:', err);
+      res.status(500).json({ error: 'Failed to fetch forums.' });
+    }
+  });
+
+module.exports = router;

api/index.js

@@ -1,7 +1,15 @@
 const express = require("express");
 const router = express.Router();
 const testDbRouter = require("./test-db");
+const forumRouter = require("./forum");
+const postRouter = require("./post");
+const postLikesRouter = require("./postlikes");
+const replyLikesRouter = require("./replylikes");
 
 router.use("/test-db", testDbRouter);
+router.use("/forum", forumRouter);
+router.use("/post", postRouter);
+router.use("/postlikes", postLikesRouter);
+router.use("/replylikes", replyLikesRouter);
 
 module.exports = router;

api/post.js

@@ -0,0 +1,64 @@
+const express = require('express');
+const router = express.Router();
+const {Forum, Post, Reply, User} = require('../database');
+
+//Get all posts
+router.get("/", async (req, res) => {
+    try {
+        const posts = await Post.findAll();
+        res.status(200).json(posts);
+    } catch (error) {
+        console.error(error);
+        res.status(500).send("Error from the get all posts route");
+    }
+});
+
+//Get a specific post
+router.get("/:id", async (req, res) => {
+    try {
+        const postID = Number(req.params.id);
+        console.log(postID);
+        const post = await Post.findByPk(postID);
+        if (!post) {
+            return res.status(404).send("Post not found");
+        }
+        res.status(200).json(post);
+    } catch (error) {
+        console.error(error);
+        res.status(500).send("Error from the get single post route");
+    }
+});
+
+router.delete("/:postId", async (req, res) => {
+    try{
+        const post = await Post.findByPk(req.params.postId);
+        if (!post) {
+            return res.status(404).send("Post not found");
+        }
+
+        await post.destroy();
+        res.status(200).send("Post deleted successfully");
+    } catch (error) {
+        console.error(error);
+        res.status(500).send("Error from the delete existing post route");
+    }
+});
+
+// Get all replies from a post
+router.get('/:postId/replies', async (req, res) => {
+  const { postId } = req.params;
+
+  try { 
+    const replies = await Reply.findAll({
+        where: { postId },
+        include: [{ model: User, attributes: ['username'] }],
+        order: [['createdAt', 'DESC']],
+      });
+      res.json(replies);
+  } catch (err) {
+    console.error('Error fetching replies:', err);
+    res.status(500).json({ error: 'Failed to fetch replies for this post.' });
+  }
+});
+
+module.exports = router;

api/postlikes.js

@@ -0,0 +1,70 @@
+const express = require("express");
+const router = express.Router();
+const { Postlikes, Post, User } = require("../database");
+
+// Check if the user has liked a specific post
+router.get("/:postId/likes/:userId", async (req, res) => {
+  try {
+    const { postId, userId } = req.params;
+
+    if (!userId) {
+      return res.status(401).json({ error: "User not authenticated." });
+    }
+
+    if (!postId || isNaN(postId)) {
+      return res.status(400).json({ error: "Invalid post ID." });
+    }
+
+    const like = await Postlikes.findOne({ where: { postId, userId } });
+
+    return res.status(200).json({ liked: !!like });
+  } catch (error) {
+    console.error("Error checking post like:", error);
+    return res.status(500).json({ error: "Internal server error." });
+  }
+});
+
+// Like a post
+router.post("/:postId/like/:userId", async (req, res) => {
+  const { postId, userId } = req.params;
+
+  try {
+    const existing = await Postlikes.findOne({ where: { userId, postId } });
+    if (existing) {
+      return res.status(400).json({ error: "You already liked this post" });
+    }
+
+    await Postlikes.create({ userId, postId });
+
+    // Increment post.likes count
+    await Post.increment("likes", { where: { id: postId } });
+
+    res.status(201).json({ message: "Post liked" });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Failed to like post" });
+  }
+});
+
+// Unlike a post
+router.delete("/:postId/unlike/:userId", async (req, res) => {
+  const { postId, userId } = req.params;
+
+  try {
+    const deleted = await Postlikes.destroy({ where: { userId, postId } });
+
+    if (!deleted) {
+      return res.status(404).json({ error: "Like not found" });
+    }
+
+    // Decrement post.likes count
+    await Post.decrement("likes", { where: { id: postId } });
+
+    res.status(200).json({ message: "Post unliked" });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Failed to unlike post" });
+  }
+});
+
+module.exports = router;

api/replylikes.js

@@ -0,0 +1,70 @@
+const express = require("express");
+const router = express.Router();
+const { Replylikes, Reply } = require("../database");
+
+// Check if the user has liked a specific reply
+router.get("/:replyId/likes/:userId", async (req, res) => {
+  try {
+    const { replyId, userId } = req.params;
+
+    if (!userId) {
+      return res.status(401).json({ error: "User not authenticated." });
+    }
+
+    if (!replyId || isNaN(replyId)) {
+      return res.status(400).json({ error: "Invalid reply ID." });
+    }
+
+    const like = await Replylikes.findOne({ where: { replyId, userId } });
+
+    return res.status(200).json({ liked: !!like });
+  } catch (error) {
+    console.error("Error checking reply like:", error);
+    return res.status(500).json({ error: "Internal server error." });
+  }
+});
+
+// Like a reply
+router.post("/:replyId/like/:userId", async (req, res) => {
+  const { replyId, userId } = req.params;
+
+  try {
+    const existing = await Replylikes.findOne({ where: { userId, replyId } });
+    if (existing) {
+      return res.status(400).json({ error: "You already liked this reply" });
+    }
+
+    await Replylikes.create({ userId, replyId });
+
+    // Optional: increment reply.likes
+    await Reply.increment("likes", { where: { id: replyId } });
+
+    res.status(201).json({ message: "Reply liked" });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Failed to like reply" });
+  }
+});
+
+// Unlike a reply
+router.delete("/:replyId/unlike/:userId", async (req, res) => {
+  const { replyId, userId } = req.params;
+
+  try {
+    const deleted = await Replylikes.destroy({ where: { userId, replyId } });
+
+    if (!deleted) {
+      return res.status(404).json({ error: "Like not found" });
+    }
+
+    // Optional: decrement reply.likes
+    await Reply.decrement("likes", { where: { id: replyId } });
+
+    res.status(200).json({ message: "Reply unliked" });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Failed to unlike reply" });
+  }
+});
+
+module.exports = router;

app.js

@@ -9,7 +9,7 @@ const apiRouter = require("./api");
 const { router: authRouter } = require("./auth");
 const { db } = require("./database");
 const cors = require("cors");
-
+const initSocketServer = require("./socket-server");
 const PORT = process.env.PORT || 8080;
 const FRONTEND_URL = process.env.FRONTEND_URL || "http://localhost:3000";
 
@@ -41,9 +41,12 @@ const runApp = async () => {
   try {
     await db.sync();
     console.log("✅ Connected to the database");
-    app.listen(PORT, () => {
+    const server = app.listen(PORT, () => {
       console.log(`🚀 Server is running on port ${PORT}`);
     });
+
+    initSocketServer(server);
+    console.log("🧦 Socket server initialized");
   } catch (err) {
     console.error("❌ Unable to connect to the database:", err);
   }

auth/index.js

@@ -6,6 +6,13 @@ const router = express.Router();
 
 const JWT_SECRET = process.env.JWT_SECRET || "your-secret-key";
 
+const cookieSettings = {
+  httpOnly: true,
+  secure: process.env.NODE_ENV === "production",
+  sameSite: process.env.NODE_ENV === "production" ? "none" : "strict",
+  maxAge: 24 * 60 * 60 * 1000, // 24 hours
+};
+
 // Middleware to authenticate JWT tokens
 const authenticateJWT = (req, res, next) => {
   const token = req.cookies.token;
@@ -79,12 +86,7 @@ router.post("/auth0", async (req, res) => {
       { expiresIn: "24h" }
     );
 
-    res.cookie("token", token, {
-      httpOnly: true,
-      secure: process.env.NODE_ENV === "production",
-      sameSite: "strict",
-      maxAge: 24 * 60 * 60 * 1000, // 24 hours
-    });
+    res.cookie("token", token, cookieSettings);
 
     res.send({
       message: "Auth0 authentication successful",
@@ -140,12 +142,7 @@ router.post("/signup", async (req, res) => {
       { expiresIn: "24h" }
     );
 
-    res.cookie("token", token, {
-      httpOnly: true,
-      secure: true,
-      sameSite: "strict",
-      maxAge: 24 * 60 * 60 * 1000, // 24 hours
-    });
+    res.cookie("token", token, cookieSettings);
 
     res.send({
       message: "User created successfully",
@@ -191,12 +188,7 @@ router.post("/login", async (req, res) => {
       { expiresIn: "24h" }
     );
 
-    res.cookie("token", token, {
-      httpOnly: true,
-      secure: process.env.NODE_ENV === "production",
-      sameSite: "strict",
-      maxAge: 24 * 60 * 60 * 1000, // 24 hours
-    });
+    res.cookie("token", token, cookieSettings);
 
     res.send({
       message: "Login successful",

database/db.js

@@ -3,7 +3,7 @@ const { Sequelize } = require("sequelize");
 const pg = require("pg");
 
 // Feel free to rename the database to whatever you want!
-const dbName = "capstone-1";
+const dbName = "capstone-2";
 
 const db = new Sequelize(
   process.env.DATABASE_URL || `postgres://localhost:5432/${dbName}`,