Frank

README.md

@@ -1,23 +1 @@
-# Capstone I 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`
-
-After that, you can get started with these commands
-
-```
-npm install # 📦 To install the packages
-npm run seed # 🌱 To seed the database
-npm run start-dev # 🚀 To start the server in development mode
-```
-
-This project runs in the Node.js runtime environment. We're not using Webpack here, but we are using a tool called nodemon, which re-runs our app whenever we save a file. You should see a message in the terminal telling you that the server is running on port 8080.
-
-When an error occurs on the backend (Express), you'll see a message in the terminal. When an error occurs on the frontend (React), you'll see that error in the browser.
-
-## Deployment
-
-This project has a vercel.json file, which will make it easier to deploy this project to Vercel. Check the video listed in the cohort repository for a walkthrough of how to connect your deployed Express server to Neon Postgres.
+# FriendPollster Backend

api/admins.js

@@ -0,0 +1,184 @@
+const express = require('express');
+const { authenticateJWT, requireAdmin } = require('../auth');
+const router = express.Router();
+const { User, Poll, Ballot, PollOption } = require("../database");
+
+router.get(
+  '/users',
+  authenticateJWT,
+  requireAdmin,
+  async (req, res) => {
+    try {
+      const users = await User.findAll({ include: [Poll, Ballot] });
+      res.status(200).send(users);
+    } catch (error) {
+      console.error("Error fetching users: ", error);
+      res.status(500).send("Error fetching users");
+    }
+  }
+);
+
+router.get(
+  '/polls',
+  authenticateJWT,
+  requireAdmin,
+  async (req, res) => {
+    try {
+      const polls = await Poll.findAll({
+        include: [
+          {
+            model: PollOption,
+            as: "PollOptions"
+          },
+          {
+            model: User,
+            as: "creator",
+            attributes: ["id", "username", "imageUrl"]
+          },
+          {
+            model: Ballot,
+            required: false
+          }
+        ],
+        order: [["createdAt", "DESC"]]
+      });
+      res.status(200).json(polls);
+    } catch (error) {
+      console.error("Error fetching polls for admin:", error);
+      res.status(500).json({ error: "Failed to fetch polls" });
+    }
+  }
+);
+
+router.patch(
+  "/polls/:id/disable",
+  authenticateJWT,
+  requireAdmin,
+  async (req, res) => {
+    try {
+      const poll = await Poll.findByPk(req.params.id, {
+        include: [
+          {
+            model: User,
+            as: "creator",
+            attributes: ["id", "username"]
+          }
+        ]
+      });
+
+      if (!poll) {
+        return res.status(404).json({ error: "Poll not found" });
+      }
+
+      poll.isActive = !poll.isActive;
+
+      if (!poll.isActive && !poll.endAt) {
+        poll.endAt = new Date();
+      }
+
+      await poll.save();
+
+      res.json({
+        id: poll.id,
+        isActive: poll.isActive,
+        title: poll.title,
+        creator: poll.creator?.username,
+        message: `Poll ${poll.isActive ? 'enabled' : 'disabled'} successfully`
+      });
+    } catch (err) {
+      console.error("Error toggling poll status:", err);
+      res.status(500).json({ error: "Failed to update poll status" });
+    }
+  }
+);
+
+router.patch(
+  "/polls/:id/close",
+  authenticateJWT,
+  requireAdmin,
+  async (req, res) => {
+    try {
+      const poll = await Poll.findByPk(req.params.id, {
+        include: [PollOption, Ballot],
+      });
+      if (!poll) return res.status(404).json({ error: "Poll not found" });
+      if (poll.status === "closed")
+        return res.status(400).json({ error: "Poll already closed" });
+
+      poll.status = "closed";
+      poll.isActive = false;
+      if (!poll.endAt) poll.endAt = new Date();
+      await poll.save();
+
+      res.json(poll);
+    } catch (err) {
+      console.error("Error closing poll:", err);
+      res.status(500).json({ error: "Failed to close poll" });
+    }
+  }
+);
+
+router.delete(
+  "/polls/:id",
+  authenticateJWT,
+  requireAdmin,
+  async (req, res) => {
+    try {
+      const poll = await Poll.findByPk(req.params.id, {
+        include: [
+          {
+            model: User,
+            as: "creator",
+            attributes: ["id", "username"]
+          }
+        ]
+      });
+
+      if (!poll) {
+        return res.status(404).json({ error: "Poll not found" });
+      }
+
+      const pollInfo = {
+        id: poll.id,
+        title: poll.title,
+        creator: poll.creator?.username
+      };
+
+      await poll.destroy();
+
+      res.json({
+        message: "Poll deleted successfully",
+        deletedPoll: pollInfo
+      });
+    } catch (err) {
+      console.error("Error deleting poll:", err);
+      res.status(500).json({ error: "Failed to delete poll" });
+    }
+  }
+);
+
+router.patch(
+  "/users/:id/disable",
+  authenticateJWT,
+  requireAdmin,
+  async (req, res) => {
+    try {
+      const target = await User.findByPk(req.params.id);
+      if (!target) return res.status(404).json({ error: "User not found" });
+
+      if (target.role === "admin") {
+        return res.status(403).json({ error: "Cannot disable an admin account" });
+      }
+
+      target.disabled = !target.disabled;
+      await target.save();
+
+      res.json({ id: target.id, disabled: target.disabled });
+    } catch (err) {
+      console.error("Error disabling user:", err);
+      res.status(500).json({ error: "Failed to modify user" });
+    }
+  }
+);
+
+module.exports = router;

api/ballots.js

@@ -0,0 +1,168 @@
+const express = require("express");
+const router = express.Router();
+const {
+  Poll,
+  User,
+  PollOption,
+  Ballot,
+  BallotRanking,
+  db,
+} = require("../database");
+const { requireAuth } = require("../auth");
+
+    //      _______
+    //     |       |
+    //     |   ✔   |
+    //     |_______|
+    //         ||
+    //         \/
+    //   ______________________
+    //  |                      |
+    //  |        _____         |
+    //  |       |     |        |
+    //  |       | VOTE|        |
+    //  |       |_____|        |
+    //  |                      |
+    //  |______________________|
+    //    \__________________/
+    //     ||              ||
+    //     ||              ||
+
+router.get("/", async (req, res) => {
+  try {
+    const ballots = await Ballot.findAll({
+      include: [{ model: BallotRanking }],
+    });
+    console.log(`Found ${ballots.length} ballots`);
+    res.status(200).json(ballots);
+  } catch (error) {
+    console.error("Error fetching ballots:", error);
+    res.status(500).json({
+      error: "Failed to fetch ballots",
+      message: "Check your database connection",
+    });
+  }
+});
+
+router.get("/:id", async (req, res) => {
+  try {
+    const ballot = await Ballot.findByPk(req.params.id, {
+      include: [{ model: BallotRanking }],
+    });
+    if (!ballot) {
+      return res.status(404).json({ error: "Ballot not found" });
+    }
+    res.status(200).json(ballot);
+  } catch (error) {
+    console.error(`Error fetching ballot`, error);
+    res.status(500).json({
+      error: "Failed to fetch ballot",
+      message: "Check your database connection",
+    });
+  }
+});
+
+router.post("/", async (req, res) => {
+  const { userId = null, pollId, rankings } = req.body;
+
+  if (!pollId) return res.status(400).json({ error: "pollId is required" });
+
+  if (!Array.isArray(rankings) || rankings.length === 0)
+    return res
+      .status(400)
+      .json({ error: "rankings must be a non-empty array" });
+
+  for (const r of rankings) {
+    if (typeof r !== "object" || r.rank == null || r.pollOptionId == null) {
+      return res.status(400).json({
+        error: "Each ranking must be an object { pollOptionId, rank }",
+      });
+    }
+  }
+
+  let tx;
+  try {
+    tx = await db.transaction();
+
+    const poll = await Poll.findByPk(pollId);
+    if (!poll) {
+      await tx.rollback();
+      return res.status(404).json({ error: "Poll not found" });
+    }
+
+    if (!poll.isActive) {
+      await tx.rollback();
+      return res.status(403).json({ 
+        error: "This poll has been disabled by an administrator" 
+      });
+    }
+
+    if (poll.endAt && new Date() > new Date(poll.endAt)) {
+      await tx.rollback();
+      return res.status(400).json({ error: "Poll has ended" });
+    }
+
+    if (poll.status !== "published") {
+      await tx.rollback();
+      return res.status(400).json({ error: "Cannot vote on unpublished polls" });
+    }
+
+    if (!poll.allowAnonymous && !userId) {
+      await tx.rollback();
+      return res.status(401).json({ 
+        error: "Please log in to vote on this poll" 
+      });
+    }
+
+    if (userId && !poll.allowAnonymous) {
+      const existingBallot = await Ballot.findOne({
+        where: { 
+          user_id: userId, 
+          poll_id: pollId 
+        }
+      });
+
+      if (existingBallot) {
+        await tx.rollback();
+        return res.status(400).json({ 
+          error: "You have already voted on this poll" 
+        });
+      }
+    }
+
+    const ballot = await Ballot.create(
+      {
+        user_id: userId,
+        poll_id: pollId,
+      },
+      { transaction: tx }
+    );
+
+    const rankingRows = rankings.map(({ pollOptionId, rank }) => ({
+      ballot_id: ballot.id,
+      option_id: pollOptionId,
+      rank,
+    }));
+    await BallotRanking.bulkCreate(rankingRows, { transaction: tx });
+
+    await tx.commit();
+
+    const result = await Ballot.findByPk(ballot.id, {
+      include: [{ model: BallotRanking, order: [["rank", "ASC"]] }],
+    });
+
+    return res.status(201).json({
+      message: "Vote recorded successfully",
+      ballot: result
+    });
+  } catch (err) {
+    if (tx) await tx.rollback();
+    console.error("Failed to create ballot:", err);
+    return res.status(500).json({
+      error: "Failed to submit ballot",
+      message: err.message,
+    });
+  }
+});
+
+module.exports = router;