Api create poll

api/index.js

@@ -1,7 +1,9 @@
 const express = require("express");
 const router = express.Router();
+const pollRouter = require("./polls");
 const testDbRouter = require("./test-db");
 
 router.use("/test-db", testDbRouter);
+router.use("/polls", pollRouter)
 
 module.exports = router;

api/polls.js

@@ -0,0 +1,73 @@
+const express = require("express");
+const router = express.Router();
+const { Poll, PollOption } = require("../database");
+const { authenticateJWT } = require("../auth")
+
+
+// Create polls
+router.post("/", authenticateJWT, async (req, res) => {
+    const userId = req.user.id
+    const { title, description, deadline, status, options = [] } = req.body;
+
+    if (status === "published" && options.length < 2) {
+        res.status(400).json({
+            error: " 2 options are requires to  publish a poll"
+        })
+    };
+
+    try {
+        const newPoll = await Poll.create({
+            title,
+            description,
+            deadline,
+            status,
+            userId,
+        });
+        //[opttion1, option2, option3]
+        if (options.length > 0) {
+            const formattedOptions = options.map(text => ({
+                optionText: text,
+                pollId: newPoll.id
+            }));
+
+            await PollOption.bulkCreate(formattedOptions)
+            res.status(201).json({
+                message: "Poll and options created",
+                poll: newPoll
+            });
+        }
+    } catch (error) {
+        res.status(500).json({
+            error: "Failed to create poll",
+            message: "Check that API fields and data are correct"
+        })
+    }
+});
+
+
+
+//delete draft poll
+router.delete("/:id", authenticateJWT, async (req, res) => {
+    try {
+        const pollId = req.params.id;
+        const userId = req.user.id;
+
+        const poll = await Poll.findByPk(pollId);
+
+        if (!poll) { res.status(404).json({ error: "Poll not found" }) };
+
+        if (poll.userId !== userId) { res.status(401).json({ error: "Unauthorized action: You do not own this poll" }) };
+
+        if (poll.status !== "draft") { res.status(401).json({ error: "Unauthorized action: Only draft polls can be deleted" }) };
+
+        await poll.destroy();
+
+        res.json({ message: "Draft poll deleted successfully" });
+
+    }
+    catch (error) {
+        res.status(500).json({ error: "Failed to delete draft poll" });
+    }
+});
+
+module.exports = router;

app.js

@@ -4,11 +4,14 @@ const morgan = require("morgan");
 const path = require("path");
 const jwt = require("jsonwebtoken");
 const cookieParser = require("cookie-parser");
+const passport = require("passport");
+const session = require("express-session");
 const app = express();
 const apiRouter = require("./api");
 const { router: authRouter } = require("./auth");
 const { db } = require("./database");
 const cors = require("cors");
+const oAuthRouter = require("./auth/routes")
 
 const PORT = process.env.PORT || 8080;
 const FRONTEND_URL = process.env.FRONTEND_URL || "http://localhost:3000";
@@ -26,10 +29,22 @@ app.use(
 // cookie parser middleware
 app.use(cookieParser());
 
+// Session middleware for passport
+app.use(session({
+  secret: process.env.JWT_SECRET || 'your-secret-key',
+  resave: false,
+  saveUninitialized: false
+}));
+
+// Initialize passport
+app.use(passport.initialize());
+app.use(passport.session());
+
 app.use(morgan("dev")); // logging middleware
 app.use(express.static(path.join(__dirname, "public"))); // serve static files from public folder
 app.use("/api", apiRouter); // mount api router
 app.use("/auth", authRouter); // mount auth router
+app.use("/auth", oAuthRouter); //mount oAuth router
 
 // error handling middleware
 app.use((err, req, res, next) => {

auth/index.js

@@ -1,6 +1,7 @@
 const express = require("express");
 const jwt = require("jsonwebtoken");
 const { User } = require("../database");
+const { Op } = require("sequelize");
 
 const router = express.Router();
 
@@ -167,9 +168,15 @@ router.post("/login", async (req, res) => {
       return;
     }
 
-    // Find user
-    const user = await User.findOne({ where: { username } });
-    user.checkPassword(password);
+    // Find user by username or email
+    const user = await User.findOne({ 
+      where: { 
+        [Op.or]: [
+          { username: username },
+          { email: username }
+        ]
+      } 
+    });
     if (!user) {
       return res.status(401).send({ error: "Invalid credentials" });
     }
@@ -230,4 +237,173 @@ router.get("/me", (req, res) => {
   });
 });
 
+// Helper function to check if input looks like email
+const looksLikeEmail = (input) => {
+  return input.includes("@");
+};
+
+// Signup with username and password
+router.post("/signup/username", async (req, res) => {
+  try {
+    const { username, password, firstName, lastName } = req.body;
+
+    if (!username || !password) {
+      return res
+        .status(400)
+        .send({ error: "Username and password are required" });
+    }
+
+    if (password.length < 6) {
+      return res
+        .status(400)
+        .send({ error: "Password must be at least 6 characters long" });
+    }
+
+    // Check if input looks like email
+    if (looksLikeEmail(username)) {
+      return res
+        .status(400)
+        .send({
+          error:
+            "Username cannot be an email address. Please use a regular username.",
+        });
+    }
+
+    // Check if username already exists (check both username and email fields to prevent duplicates)
+    const existingUser = await User.findOne({
+      where: {
+        [Op.or]: [{ username }, { email: username }],
+      },
+    });
+
+    if (existingUser) {
+      return res.status(409).send({ error: "Username already exists" });
+    }
+
+    // Create new user
+    const passwordHash = User.hashPassword(password);
+    const userData = {
+      username,
+      passwordHash,
+      firstName: firstName || null,
+      lastName: lastName || null,
+    };
+
+    const user = await User.create(userData);
+
+    // Generate JWT token
+    const token = jwt.sign(
+      {
+        id: user.id,
+        username: user.username,
+        email: user.email,
+      },
+      JWT_SECRET,
+      { expiresIn: "24h" }
+    );
+
+    res.cookie("token", token, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "strict",
+      maxAge: 24 * 60 * 60 * 1000, // 24 hours
+    });
+
+    res.send({
+      message: "User created successfully with username",
+      user: {
+        id: user.id,
+        username: user.username,
+        firstName: user.firstName,
+        lastName: user.lastName,
+      },
+    });
+  } catch (error) {
+    console.error("Username signup error:", error);
+    res.status(500).send({ error: "Internal server error" });
+  }
+});
+
+// Helper function to validate email format
+const isValidEmail = (email) => {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+};
+
+// Signup with email and password
+router.post("/signup/email", async (req, res) => {
+  try {
+    const { email, password, firstName, lastName } = req.body;
+
+    if (!email || !password) {
+      return res.status(400).send({ error: "Email and password are required" });
+    }
+
+    if (password.length < 6) {
+      return res.status(400).send({ error: "Password must be at least 6 characters long" });
+    }
+
+    // Validate email format
+    if (!isValidEmail(email)) {
+      return res.status(400).send({ error: "Please provide a valid email address" });
+    }
+
+    // Check if email already exists (check both email and username fields to prevent duplicates)
+    const existingUser = await User.findOne({
+      where: {
+        [Op.or]: [
+          { email: email },
+          { username: email }
+        ]
+      }
+    });
+
+    if (existingUser) {
+      return res.status(409).send({ error: "Email already exists" });
+    }
+
+    // Create new user
+    const passwordHash = User.hashPassword(password);
+    const userData = {
+      email: email,
+      passwordHash,
+      firstName: firstName || null,
+      lastName: lastName || null
+    };
+
+    const user = await User.create(userData);
+
+    // Generate JWT token
+    const token = jwt.sign(
+      {
+        id: user.id,
+        username: user.username,
+        email: user.email,
+      },
+      JWT_SECRET,
+      { expiresIn: "24h" }
+    );
+
+    res.cookie("token", token, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "strict",
+      maxAge: 24 * 60 * 60 * 1000, // 24 hours
+    });
+
+    res.send({
+      message: "User created successfully with email",
+      user: {
+        id: user.id,
+        email: user.email,
+        firstName: user.firstName,
+        lastName: user.lastName,
+      },
+    });
+  } catch (error) {
+    console.error("Email signup error:", error);
+    res.status(500).send({ error: "Internal server error" });
+  }
+});
+
 module.exports = { router, authenticateJWT };