Merge pull request 'Adding page to create votes and view the votes, rearanging some methods' (#21) from create-vote into main

Reviewed-on: #21

client/package-lock.json

@@ -12,6 +12,7 @@
         "@emotion/styled": "^11.14.1",
         "@mui/icons-material": "^7.3.7",
         "@mui/material": "^7.3.7",
+        "axios": "^1.13.2",
         "cra-template-pwa": "2.0.0",
         "react": "^19.2.3",
         "react-dom": "^19.2.3",
@@ -4763,6 +4764,31 @@
         "node": ">=4"
       }
     },
+    "node_modules/axios": {
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.13.2.tgz",
+      "integrity": "sha512-VPk9ebNqPcy5lRGuSlKx752IlDatOjT9paPlm8A7yOuW2Fbvp4X3JznJtT4f0GzGLLiWE9W8onz51SqLYwzGaA==",
+      "dependencies": {
+        "follow-redirects": "^1.15.6",
+        "form-data": "^4.0.4",
+        "proxy-from-env": "^1.1.0"
+      }
+    },
+    "node_modules/axios/node_modules/form-data": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
+      "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.2",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
     "node_modules/axobject-query": {
       "version": "4.1.0",
       "resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-4.1.0.tgz",
@@ -12713,6 +12739,11 @@
         "node": ">= 0.10"
       }
     },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg=="
+    },
     "node_modules/psl": {
       "version": "1.15.0",
       "resolved": "https://registry.npmjs.org/psl/-/psl-1.15.0.tgz",

client/package.json

@@ -7,6 +7,7 @@
     "@emotion/styled": "^11.14.1",
     "@mui/icons-material": "^7.3.7",
     "@mui/material": "^7.3.7",
+    "axios": "^1.13.2",
     "cra-template-pwa": "2.0.0",
     "react": "^19.2.3",
     "react-dom": "^19.2.3",

client/src/App.css

@@ -36,3 +36,38 @@
     transform: rotate(360deg);
   }
 }
+
+.dropdown {
+  display: inline-block;
+}
+
+.dropbtn {
+  background-color: #f5f5f5;
+  border: none;
+  cursor: pointer;
+}
+
+.dropdown-content {
+  display: none; /* Hidden by default */
+  position: absolute;
+  background-color: #f9f9f9;
+  min-width: 160px;
+  box-shadow: 0px 8px 16px 0px rgba(0,0,0,0.2);
+}
+
+.dropdown-content a {
+  color: black;
+  padding: 12px 16px;
+  text-decoration: none;
+  display: block;
+}
+
+/* Show the dropdown menu on hover */
+.dropdown:hover .dropdown-content {
+  display: block;
+}
+
+/* Add zebra striping to tables */
+table tr:nth-child(odd) {
+  background-color: #f5f5f5;
+}

client/src/App.js

@@ -4,22 +4,42 @@ import Home from "./pages/Home";
 import AdminLogin from "./pages/AdminLogin";
 import AdminMembers from "./pages/AdminMembers";
 import AdminMembersView from "./pages/AdminMembersView";
+import AdminCreateVote from "./pages/AdminCreateVote";
+import PollList from "./pages/PollList";
+import './App.css';
 
 export default function App() {
   return (
     <BrowserRouter>
       <nav style={{ padding: "1rem", background: "#f5f5f5" }}>
-        <Link to="/">Home</Link> | 
+        <Link to="/">Home</Link> |
-        <Link to="/admin-login">Admin Login</Link> | 
+        <Link to="/admin-login">Admin Login</Link> |
-        <Link to="/admin-members">Admin Members</Link> | 
+        {/* Member dropdown */}
-        <Link to="/admin-members-view">View Members</Link>
+        <div className="dropdown">
+          <button className="dropbtn">Member ▼</button>
+          <div className="dropdown-content">
+            <a href="/admin-members">Upload Members</a>
+            <a href="/admin-members-view">View Members</a>
+          </div>
+        </div> | 
+        <div className="dropdown">
+          <button className="dropbtn">Vote ▼</button>
+          <div className="dropdown-content">
+            <a href="/create-vote">Create Vote</a>
+            <a href="/polls">Poll List</a>
+          </div>
+        </div>
       </nav>
 
       <Routes>
         <Route path="/" element={<Home />} />
         <Route path="/admin-login" element={<AdminLogin />} />
+        {/* Member routes */}
         <Route path="/admin-members" element={<AdminMembers />} />
         <Route path="/admin-members-view" element={<AdminMembersView />} />
+        {/* Vote routes */}
+        <Route path="/create-vote" element={<AdminCreateVote />} />
+        <Route path="/polls" element={<PollList />} />
       </Routes>
     </BrowserRouter>
   );

client/src/pages/AdminCreateVote.js

@@ -0,0 +1,67 @@
+import React, { useState } from 'react';
+
+function AdminCreateVote() {
+  const [question, setQuestion] = useState('');
+  const [expiresInHours, setExpiresInHours] = useState('');
+  const [status, setStatus] = useState("");
+  
+
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    
+    const formData = new FormData();
+    formData.append("question", question);
+    formData.append("expiresInHours", expiresInHours);
+
+    try {
+      const resp = await fetch("/api/admin/new-vote", {
+        method: "POST",
+        body: formData,
+      });
+
+      const data = await resp.json();
+
+      if (data.success) {
+        setStatus(`✅ Vote created with ID`);
+      } else {
+        setStatus(`❌ Server error: ${data.error}`);
+      }
+    } catch (error) {
+      setStatus("❌ Failed to create vote. Please try again: " + (error.response?.data?.error || error.message));
+    }
+  };
+
+  return (
+    <div>
+      <h1>Create New Vote</h1>
+      <form onSubmit={handleSubmit}>
+        <div>
+          <label>Question:</label>
+          <input
+            type="text"
+            value={question}
+            onChange={(e) => setQuestion(e.target.value)}
+            required
+          />
+        </div>
+        
+        <div>
+          <label>Expires In (hours):</label>
+          <input
+            type="number"
+            min="1"
+            value={expiresInHours}
+            onChange={(e) => setExpiresInHours(e.target.value)}
+            required
+          />
+        </div>
+
+        <button type="submit">Create Vote</button>
+      </form>
+
+      {status && <p style={{ marginTop: "1rem" }}>{status}</p>}
+    </div>
+  );
+}
+
+export default AdminCreateVote;

client/src/pages/PollList.js

@@ -0,0 +1,46 @@
+import React, { useEffect, useState } from 'react';
+import axios from 'axios';
+import Table from '@mui/material/Table';
+
+export default function PollList() {
+  const [polls, setPolls] = useState([]);
+
+  useEffect(() => {
+    fetchPolls();
+  }, []);
+
+  const fetchPolls = async () => {
+    try {
+      const response = await axios.post('/api/admin/view-votes');
+      setPolls(response.data);
+    } catch (error) {
+      console.error('Error fetching polls:', error);
+    }
+  };
+
+  return (
+    <div>
+      <h1>Poll List</h1>
+      <Table>
+        <thead>
+          <tr>
+            <th>Created At</th>
+            <th>Question</th>
+            <th>Member Yes Votes</th>
+            <th>Member No Votes</th>
+          </tr>
+        </thead>
+        <tbody>
+          {polls.map((poll) => (
+            <tr key={poll.id}>
+              <td>{new Date(poll.created_at).toLocaleString()}</td>
+              <td>{poll.question}</td>
+              <td>{poll.member_yes}</td>
+              <td>{poll.member_no}</td>
+            </tr>
+          ))}
+        </tbody>
+      </Table>
+    </div>
+  );
+}

server/common/common.go

@@ -0,0 +1,11 @@
+package common
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+func SendError(w http.ResponseWriter, errStr string, statusCode int) {
+	w.WriteHeader(statusCode)
+	json.NewEncoder(w).Encode(map[string]string{"error": errStr})
+}

server/main.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"encoding/json"
-	"io/ioutil"
 	"log"
 	"net/http"
 	"os"
@@ -10,32 +9,33 @@ import (
 	"path/filepath"
 
 	"github.com/gorilla/mux"
+
+	"go-sjles-pta-vote/server/common"
 	"go-sjles-pta-vote/server/models"
 	"go-sjles-pta-vote/server/services"
 )
 
-func voteHandler(w http.ResponseWriter, r *http.Request) {
+func voteHandler(resWriter http.ResponseWriter, request *http.Request) {
 	var vote models.Vote
-	if err := json.NewDecoder(r.Body).Decode(&vote); err != nil {
+	if err := json.NewDecoder(request.Body).Decode(&vote); err != nil {
-		http.Error(w, "Invalid request payload", http.StatusBadRequest)
+		common.SendError(resWriter, "Invalid JSON", http.StatusBadRequest)
 		return
 	}
 
-	err := services.SetVote(&vote)
+	if err := services.SetVote(&vote); err != nil {
-	if err != nil {
+		common.SendError(resWriter, "Failed to set vote", http.StatusInternalServerError)
-		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 
-	w.WriteHeader(http.StatusOK)
+	resWriter.WriteHeader(http.StatusOK)
 }
 
-func voteIDHandler(w http.ResponseWriter, r *http.Request) {
+func voteIDHandler(resWriter http.ResponseWriter, request *http.Request) {
-	vars := mux.Vars(r)
+	vars := mux.Vars(request)
 	idStr := vars["id"]
 	id, err := strconv.ParseInt(idStr, 10, 64)
 	if err != nil {
-		http.Error(w, "Invalid poll ID", http.StatusBadRequest)
+		common.SendError(resWriter, "Invalid poll ID", http.StatusBadRequest)
 		return
 	}
 
@@ -47,181 +47,84 @@ func voteIDHandler(w http.ResponseWriter, r *http.Request) {
 
 	err = services.SetVote(&vote)
 	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
+		common.SendError(resWriter, "Failed to set vote", http.StatusInternalServerError)
 		return
 	}
 
-	w.WriteHeader(http.StatusOK)
+	resWriter.WriteHeader(http.StatusOK)
 }
 
-func statsHandler(w http.ResponseWriter, r *http.Request) {
+func statsHandler(resWriter http.ResponseWriter, request *http.Request) {
-	if r.Method == "GET" {
+	if request.Method == http.MethodGet {
 		filePath := "./server/templates/stats.html"
-		http.ServeFile(w, r, filePath)
+		http.ServeFile(resWriter, request, filePath)
-	} else if r.Method == "POST" {
+	} else if request.Method == http.MethodPost {
-		vars := mux.Vars(r)
+		vars := mux.Vars(request)
 		id := vars["id"]
 
 		poll, err := services.GetPollByQuestion(id)
 		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
+			common.SendError(resWriter, "Failed to get poll", http.StatusInternalServerError)
 			return
 		}
 
-		json.NewEncoder(w).Encode(poll)
+		json.NewEncoder(resWriter).Encode(poll)
 	} else {
-		w.WriteHeader(http.StatusMethodNotAllowed)
+		resWriter.WriteHeader(http.StatusMethodNotAllowed)
 	}
 }
 
-func statsIDHandler(w http.ResponseWriter, r *http.Request) {
+func statsIDHandler(resWriter http.ResponseWriter, request *http.Request) {
-	vars := mux.Vars(r)
+	vars := mux.Vars(request)
 	id := vars["id"]
 
 	poll, err := services.GetPollByQuestion(id)
 	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
+		common.SendError(resWriter, "Failed to get poll", http.StatusInternalServerError)
 		return
 	}
 
-	json.NewEncoder(w).Encode(poll)
+	json.NewEncoder(resWriter).Encode(poll)
 }
 
-func adminHandler(w http.ResponseWriter, r *http.Request) {
+func adminLoginHandler(resWriter http.ResponseWriter, request *http.Request) {
-	// Add admin functionality here
+	if request.Method != http.MethodPost {
-	w.WriteHeader(http.StatusOK)
+		common.SendError(resWriter, "Method not allowed", http.StatusMethodNotAllowed)
-}
-
-func adminIDHandler(w http.ResponseWriter, r *http.Request) {
-	//vars := mux.Vars(r)
-	//id := vars["id"]
-
-	// Add admin functionality here
-	w.WriteHeader(http.StatusOK)
-}
-
-func adminLoginHandler(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodPost {
-		w.WriteHeader(http.StatusMethodNotAllowed)
-		json.NewEncoder(w).Encode(map[string]string{"error": "Method not allowed"})
 		return
 	}
 
 	var loginReq services.LoginRequest
-	if err := json.NewDecoder(r.Body).Decode(&loginReq); err != nil {
+	if err := json.NewDecoder(request.Body).Decode(&loginReq); err != nil {
-		w.WriteHeader(http.StatusBadRequest)
+		common.SendError(resWriter, "Invalid JSON", http.StatusBadRequest)
-		json.NewEncoder(w).Encode(map[string]string{"error": "Invalid request payload"})
 		return
 	}
 
 	// Validate admin credentials
 	isValid, err := services.ValidateAdminLogin(loginReq.Username, loginReq.Password)
 	if err != nil {
-		w.WriteHeader(http.StatusBadRequest)
+		common.SendError(resWriter, "Invalid username or password", http.StatusBadRequest)
-		json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
 		return
 	}
 
 	if !isValid {
-		w.WriteHeader(http.StatusUnauthorized)
+		common.SendError(resWriter, "Invalid username or password", http.StatusUnauthorized)
-		json.NewEncoder(w).Encode(map[string]string{"error": "Invalid username or password"})
 		return
 	}
 
 	// Generate JWT token
 	token, err := services.GenerateAuthToken(loginReq.Username)
 	if err != nil {
-		w.WriteHeader(http.StatusInternalServerError)
+		common.SendError(resWriter, "Failed to generate auth token", http.StatusInternalServerError)
-		json.NewEncoder(w).Encode(map[string]string{"error": "Failed to generate token"})
 		return
 	}
 
-	w.WriteHeader(http.StatusOK)
+	resWriter.WriteHeader(http.StatusOK)
-	json.NewEncoder(w).Encode(services.LoginResponse{
+	json.NewEncoder(resWriter).Encode(services.LoginResponse{
 		Success: true,
 		Token:   token,
 	})
 }
 
-func adminMembersHandler(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodPost {
-		w.WriteHeader(http.StatusMethodNotAllowed)
-		return
-	}
-
-	var year int
-	var err error
-
-	if err = r.ParseMultipartForm(10 << 20); err != nil {
-		http.Error(w, "Failed to parse multipart form", http.StatusBadRequest)
-		return
-	}
-
-	year_from_form := r.FormValue("year")
-	if year_from_form == "" {
-		http.Error(w, "Year is required", http.StatusBadRequest)
-		return
-	} else {
-		year, err = strconv.Atoi(year_from_form)
-		if err != nil {
-			http.Error(w, "Invalid year", http.StatusBadRequest)
-			return
-		}
-	}
-
-	file, _, err := r.FormFile("members.csv")
-	if err != nil {
-		http.Error(w, "Failed to upload file", http.StatusBadRequest)
-		return
-	}
-	defer file.Close()
-
-	fileBytes, err := ioutil.ReadAll(file)
-	if err != nil {
-		http.Error(w, "Failed to read file", http.StatusInternalServerError)
-		return
-	}
-
-	if err = services.ParseMembersFromBytes(year, fileBytes); err != nil {
-		w.WriteHeader(http.StatusBadRequest)
-		json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
-		return
-	}
-
-	w.WriteHeader(http.StatusOK)
-	json.NewEncoder(w).Encode(map[string]bool{"success": true})
-}
-
-func adminMembersView(w http.ResponseWriter, r *http.Request) {
-	yearStr := r.URL.Query().Get("year")
-	if yearStr == "" {
-		http.Error(w, "Year is required", http.StatusBadRequest)
-		return
-	}
-
-	year, err := strconv.Atoi(yearStr)
-	if err != nil {
-		http.Error(w, "Invalid year", http.StatusBadRequest)
-		return
-	}
-
-	members, err := services.GetMembersByYear(year)
-	if err != nil {
-		w.WriteHeader(http.StatusInternalServerError)
-		json.NewEncoder(w).Encode(map[string]interface{}{
-			"success": false,
-			"error":   err.Error(),
-		})
-		return
-	}
-
-	w.WriteHeader(http.StatusOK)
-	json.NewEncoder(w).Encode(map[string]interface{}{
-		"success": true,
-		"members": members,
-	})
-}
-
 func main() {
 	log.SetOutput(os.Stdout)
 	log.SetFlags(log.LstdFlags | log.Lshortfile)
@@ -230,11 +133,11 @@ func main() {
 	http.HandleFunc("/api/vote/{id}", voteIDHandler)
 	http.HandleFunc("/api/stats", statsHandler)
 	http.HandleFunc("/api/stats/{id}", statsIDHandler)
-	http.HandleFunc("/api/admin", adminHandler)
+	http.HandleFunc("/api/admin/new-vote", services.AdminNewVoteHandler)
-	http.HandleFunc("/api/admin/{id}", adminIDHandler)
+	http.HandleFunc("/api/admin/view-votes", services.AdminViewVoteHandler)
 	http.HandleFunc("/api/admin/login", adminLoginHandler)
-	http.HandleFunc("/api/admin/members", adminMembersHandler)
+	http.HandleFunc("/api/admin/members", services.AdminMembersHandler)
-	http.HandleFunc("/api/admin/members/view", adminMembersView)
+	http.HandleFunc("/api/admin/members/view", services.AdminMembersView)
 
 	buildPath := filepath.Join(".", "client", "build")
 	fs := http.FileServer(http.Dir(buildPath))

server/services/members.go

@@ -5,9 +5,14 @@ import (
 	"fmt"
 	"log"
 	"strings"
+	"net/http"
+	"strconv"
+	"io/ioutil"
+	"encoding/json"
 
 	"github.com/pkg/errors"
 
+	"go-sjles-pta-vote/server/common"
 	"go-sjles-pta-vote/server/db"
 )
 
@@ -18,6 +23,80 @@ type Member struct {
 
 const BATCH_SIZE = 100
 
+func AdminMembersHandler(resWriter http.ResponseWriter, request *http.Request) {
+	if request.Method != http.MethodPost {
+		resWriter.WriteHeader(http.StatusMethodNotAllowed)
+		return
+	}
+
+	var year int
+	var err error
+
+	if err = request.ParseMultipartForm(10 << 20); err != nil {
+		common.SendError(resWriter, "Failed to parse multipart form", http.StatusBadRequest)
+		return
+	}
+
+	year_from_form := request.FormValue("year")
+	if year_from_form == "" {
+		common.SendError(resWriter, "Year is required", http.StatusBadRequest)
+		return
+	} else {
+		year, err = strconv.Atoi(year_from_form)
+		if err != nil {
+			common.SendError(resWriter, "Invalid year", http.StatusBadRequest)
+			return
+		}
+	}
+
+	file, _, err := request.FormFile("members.csv")
+	if err != nil {
+		common.SendError(resWriter, "Failed to read members.csv file", http.StatusBadRequest)
+		return
+	}
+	defer file.Close()
+
+	fileBytes, err := ioutil.ReadAll(file)
+	if err != nil {
+		common.SendError(resWriter, "Failed to read members.csv file", http.StatusInternalServerError)
+		return
+	}
+
+	if err = ParseMembersFromBytes(year, fileBytes); err != nil {
+		common.SendError(resWriter, "Failed to parse members from CSV", http.StatusBadRequest)
+		return
+	}
+
+	resWriter.WriteHeader(http.StatusOK)
+	json.NewEncoder(resWriter).Encode(map[string]bool{"success": true})
+}
+
+func AdminMembersView(resWriter http.ResponseWriter, request *http.Request) {
+	yearStr := request.URL.Query().Get("year")
+	if yearStr == "" {
+		common.SendError(resWriter, "Year is required", http.StatusBadRequest)
+		return
+	}
+
+	year, err := strconv.Atoi(yearStr)
+	if err != nil {
+		common.SendError(resWriter, "Invalid year", http.StatusBadRequest)
+		return
+	}
+
+	members, err := GetMembersByYear(year)
+	if err != nil {
+		common.SendError(resWriter, "Failed to get members", http.StatusInternalServerError)
+		return
+	}
+
+	resWriter.WriteHeader(http.StatusOK)
+	json.NewEncoder(resWriter).Encode(map[string]interface{}{
+		"success": true,
+		"members": members,
+	})
+}
+
 func ParseMembersFromBytes(year int, fileBytes []byte) error {
 	reader := csv.NewReader(strings.NewReader(string(fileBytes)))
 	reader.FieldsPerRecord = -1 // Allow variable number of fields per record

server/services/poll.go

@@ -4,7 +4,12 @@ import (
 	"database/sql"
 	"errors"
 	"time"
+	"log"
+	"encoding/json"
+	"strconv"
+	"net/http"
 
+	"go-sjles-pta-vote/server/common"
 	"go-sjles-pta-vote/server/db"
 	"go-sjles-pta-vote/server/models"
 )
@@ -13,12 +18,55 @@ var ErrQuestionAlreadyExists = errors.New("Question already exists")
 var ErrQuestionDoesntExist = errors.New("Question does not exist yet")
 var ErrVoterAlreadyVoted = errors.New("Voter already voted")
 var ErrPollNotFound = errors.New("Poll not found")
+var ErrFailedToUpdateVote = errors.New("Failed to update vote")
+var ErrFailedToDeletePoll = errors.New("Failed to delete poll")
 
-func CreatePoll(poll *models.Poll) (*models.Poll, error) {
+const ( 
-	new_poll := models.Poll{}
+	DATE_FORMAT = "2006-01-02 15:04:05"
+	DEFAULT_POLL_DURATION_HOURS = 24
+)
 
+func AdminNewVoteHandler(resWriter http.ResponseWriter, request *http.Request) {
+	if request.Method != http.MethodPost {
+		resWriter.WriteHeader(http.StatusMethodNotAllowed)
+		return
+	}
+
+	question := request.FormValue("question")
+	if question == "" {
+		common.SendError(resWriter, "Question is required", http.StatusBadRequest)
+		return
+	}
+
+	durationHours := DEFAULT_POLL_DURATION_HOURS
+	if durationStr := request.FormValue("duration"); durationStr != "" {
+		var err error
+		durationHours, err = strconv.Atoi(durationStr)
+		if err != nil {
+			common.SendError(resWriter, "Invalid duration", http.StatusBadRequest)
+			return
+		}
+	}
+
+	poll := models.Poll{
+		Question:     question,
+		ExpiresAt:    time.Now().Add(time.Duration(durationHours) * time.Hour).Format(DATE_FORMAT),
+	}
+
+	_, err := CreatePoll(&poll)
+	if err != nil {
+		common.SendError(resWriter, "Failed to create poll", http.StatusInternalServerError)
+		return
+	}
+
+	resWriter.WriteHeader(http.StatusOK)
+	json.NewEncoder(resWriter).Encode(map[string]bool{"success": true})
+}
+
+func CreatePoll(poll *models.Poll) (*int64, error) {
 	db_conn, err := db.Connect()
 	if err != nil {
+		log.Fatal(err)
 		return nil, err
 	}
 	defer db.Close()
@@ -29,6 +77,7 @@ func CreatePoll(poll *models.Poll) (*models.Poll, error) {
 			WHERE question == $1
 	`)
 	if err != nil {
+		log.Fatal(err)
 		return nil, err
 	}
 	defer get_stmt.Close()
@@ -37,6 +86,7 @@ func CreatePoll(poll *models.Poll) (*models.Poll, error) {
 	err = get_stmt.QueryRow(poll.Question).Scan(&id)
 	if err != sql.ErrNoRows {
 		if err != nil {
+			log.Fatal(err)
 			return nil, err
 		}
 		return nil, ErrQuestionAlreadyExists
@@ -53,6 +103,7 @@ func CreatePoll(poll *models.Poll) (*models.Poll, error) {
 	`)
 
 	if err != nil {
+		log.Fatal(err)
 		return nil, err
 	}
 
@@ -60,19 +111,84 @@ func CreatePoll(poll *models.Poll) (*models.Poll, error) {
 
 	res, err := stmt.Exec(poll.Question, poll.ExpiresAt)
 	if err != nil {
+		log.Fatal(err)
 		return nil, err
 	}
 
-	new_poll.ID, err = res.LastInsertId()
+	new_poll_id, err := res.LastInsertId()	
-	
+	return &new_poll_id, err
-	return &new_poll, err
+}
+
+func AdminViewVoteHandler(resWriter http.ResponseWriter, request *http.Request) {
+	if request.Method != http.MethodPost {
+		resWriter.WriteHeader(http.StatusMethodNotAllowed)
+		return
+	}
+
+	polls, err := GetAllPolls()
+	if err != nil {
+		common.SendError(resWriter, "Failed to get polls", http.StatusInternalServerError)
+		return
+	}
+
+	json.NewEncoder(resWriter).Encode(polls)
+}
+
+func GetAllPolls() ([]models.Poll, error) {
+	db_conn, err := db.Connect()
+	if err != nil {
+		log.Fatal(err)
+		return nil, err
+	}
+	defer db.Close()
+
+	get_polls_stmt, err := db_conn.Prepare(`
+		SELECT 
+			id, question, 
+			member_yes_votes, member_no_votes,
+			non_member_yes_votes, non_member_no_votes,
+			created_at, updated_at,
+			expires_at
+		FROM polls 
+	`)
+	if err != nil {
+		log.Fatal(err)
+		return nil, err
+	}
+	defer get_polls_stmt.Close()
+
+	rows, err := get_polls_stmt.Query()
+	if err != nil {
+		log.Fatal(err)
+		return nil, err
+	}
+	defer rows.Close()
+
+	var polls []models.Poll
+	for rows.Next() {
+		new_poll := models.Poll{}
+		err = rows.Scan(
+			&new_poll.ID, &new_poll.Question,
+			&new_poll.MemberYes, &new_poll.MemberNo,
+			&new_poll.NonMemberYes, &new_poll.NonMemberNo,
+			&new_poll.CreatedAt, &new_poll.UpdatedAt,
+			&new_poll.ExpiresAt,
+		)
+		if err != nil {
+			log.Fatal(err)
+			return nil, err
+		}
+
+		polls = append(polls, new_poll)
+	}
+
+	return polls, nil
 }
 
 func GetPollByQuestion(question string) (*models.Poll, error) {
-	new_poll := models.Poll{}
-
 	db_conn, err := db.Connect()
 	if err != nil {
+		log.Fatal(err)
 		return nil, err
 	}
 	defer db.Close()
@@ -88,10 +204,12 @@ func GetPollByQuestion(question string) (*models.Poll, error) {
 		WHERE question == $1
 	`)
 	if err != nil {
+		log.Fatal(err)
 		return nil, err
 	}
 	defer get_poll_stmt.Close()
 
+	new_poll := models.Poll{}
 	err = get_poll_stmt.QueryRow(question).Scan(
 		&new_poll.ID, &new_poll.Question,
 		&new_poll.MemberYes, &new_poll.MemberNo,
@@ -103,6 +221,7 @@ func GetPollByQuestion(question string) (*models.Poll, error) {
 	if err == sql.ErrNoRows {
 		return nil, ErrPollNotFound
 	} else if err != nil {
+		log.Fatal(err)
 		return nil, err
 	}
 
@@ -117,11 +236,11 @@ func GetPollByQuestion(question string) (*models.Poll, error) {
 	defer get_voters_stmt.Close()
 
 	rows, err := get_voters_stmt.Query(new_poll.ID)
-
 	for rows.Next() {
 		var voter_email string
 		err = rows.Scan(&voter_email)
 		if err != nil {
+			log.Fatal(err)
 			return nil, err
 		}
 		new_poll.WhoVoted = append(new_poll.WhoVoted, voter_email)
@@ -136,7 +255,7 @@ func GetAndCreatePollByQuestion(question string) (*models.Poll, error) {
 	if err == ErrPollNotFound {
 		create_poll := &models.Poll{
 			Question: question,
-			ExpiresAt: time.Now().Add(time.Hour * 10).Format("2006-01-02 15:04:05"),
+			ExpiresAt: time.Now().Add(time.Hour * 10).Format(DATE_FORMAT),
 		}
 
 		if _, err = CreatePoll(create_poll); err != nil {
@@ -145,16 +264,17 @@ func GetAndCreatePollByQuestion(question string) (*models.Poll, error) {
 
 		return GetPollByQuestion(question)
 	} else if err != nil {
+		log.Fatal(err)
 		return nil, err
 	} else {
 		return new_poll, err
 	}
 }
 
-// Use models.Vote to set votes
 func SetVote(vote *models.Vote) error {
 	db_conn, err := db.Connect()
 	if err != nil {
+		log.Fatal(err)
 		return err
 	}
 	defer db.Close()
@@ -165,18 +285,21 @@ func SetVote(vote *models.Vote) error {
 		VALUES ($1, $2)
 	`)
 	if err != nil {
+		log.Fatal(err)
 		return err
 	}
 	defer set_voter_stmt.Close()
 
 	res, err := set_voter_stmt.Exec(vote.PollId, vote.Email)
 	if err != nil {
+		log.Fatal(err)
 		return err
 	} else {
 		rows_changed, err := res.RowsAffected()
 		if rows_changed != 1 {
 			return ErrVoterAlreadyVoted
 		} else if err != nil {
+			log.Fatal(err)
 			return err
 		}
 	}
@@ -187,6 +310,7 @@ func SetVote(vote *models.Vote) error {
 		WHERE email == $1
 	`)
 	if err != nil {
+		log.Fatal(err)
 		return err
 	}
 	defer is_voter_member_stmt.Close()
@@ -197,6 +321,7 @@ func SetVote(vote *models.Vote) error {
 	if err == sql.ErrNoRows {
 		is_member = false
 	} else if err != nil {
+		log.Fatal(err)
 		return err
 	}
 
@@ -219,18 +344,21 @@ func SetVote(vote *models.Vote) error {
 		WHERE id == $1
 	`)
 	if err != nil {
+		log.Fatal(err)
 		return err
 	}
 	defer add_vote_stmt.Close()
 
 	res, err = add_vote_stmt.Exec(vote.PollId)
 	if err != nil {
+		log.Fatal(err)
 		return err
 	}
 
 	if num, err := res.RowsAffected(); num != 1 {
-		return errors.New("Failed to update votes")
+		return ErrFailedToUpdateVote
 	} else if err != nil {
+		log.Fatal(err)
 		return err
 	}
 
@@ -242,6 +370,7 @@ func DeletePollByQuestion(question string) error {
 	db_conn, err := db.Connect()
 	if err != nil {
 		return err
+		log.Fatal(err)
 	}
 	defer db.Close()
 
@@ -254,12 +383,14 @@ func DeletePollByQuestion(question string) error {
 		)
 	`)
 	if err != nil {
+		log.Fatal(err)
 		return err
 	}
 	defer delete_votes_stmt.Close()
 
 	_, err = delete_votes_stmt.Exec(question)
 	if err != nil {
+		log.Fatal(err)
 		return err
 	}
 
@@ -268,18 +399,21 @@ func DeletePollByQuestion(question string) error {
 		WHERE question == $1
 	`)
 	if err != nil {
+		log.Fatal(err)
 		return err
 	}
 	defer delete_poll_stmt.Close()
 
 	res, err := delete_poll_stmt.Exec(question)
 	if err != nil {
+		log.Fatal(err)
 		return err
 	}
 
 	if num, err := res.RowsAffected(); num != 1 {
-		return errors.New("Failed to delete poll")
+		return ErrFailedToDeletePoll
 	} else if err != nil {
+		log.Fatal(err)
 		return err
 	}