Adding the initial poll detail pages

Reviewed-on: #21

client/package.json

@@ -3,11 +3,17 @@
   "version": "0.1.0",
   "private": true,
   "dependencies": {
+    "@emotion/react": "^11.14.0",
+    "@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",
     "react-router": "7.12.0",
-    "react-scripts": "5.0.1"
+    "react-scripts": "5.0.1",
+    "recharts": "^3.7.0"
   },
   "scripts": {
     "start": "react-scripts start",

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

@@ -1,18 +1,48 @@
 import React from "react";
 import { BrowserRouter, Routes, Route, Link } from "react-router";
 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 PollDetails from "./pages/PollDetails";
+import './App.css';
 
 export default function App() {
   return (
     <BrowserRouter>
       <nav style={{ padding: "1rem", background: "#f5f5f5" }}>
-        <Link to="/">Home</Link> | <Link to="/admin-members">Admin Members</Link>
+        <Link to="/">Home</Link> |
+        <Link to="/admin-login">Admin Login</Link> |
+        {/* Member dropdown */}
+        <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>
+            <a href="/poll-details/:id">View Poll Details</a> {/* Add this line */}
+          </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 />} />
+        <Route path="/poll-details/:id" element={<PollDetails />} /> {/* Add this route */}
       </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/AdminLogin.js

@@ -0,0 +1,137 @@
+import React, { useState } from "react";
+import { useNavigate } from "react-router";
+
+export default function AdminLogin() {
+  const [username, setUsername] = useState("");
+  const [password, setPassword] = useState("");
+  const [error, setError] = useState("");
+  const [isLoading, setIsLoading] = useState(false);
+  const navigate = useNavigate();
+
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    setError("");
+    setIsLoading(true);
+
+    if (!username || !password) {
+      setError("⚠️ Please enter both username and password.");
+      setIsLoading(false);
+      return;
+    }
+
+    try {
+      const resp = await fetch("/api/admin/login", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          username,
+          password,
+        }),
+      });
+
+      const data = await resp.json();
+
+      if (resp.ok && data.success) {
+        // Store the auth token in localStorage
+        localStorage.setItem("adminToken", data.token);
+        setError("");
+        navigate("/admin-members");
+      } else {
+        setError(`❌ ${data.error || "Login failed"}`);
+      }
+    } catch (err) {
+      setError(`❌ Network error: ${err.message}`);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  return (
+    <div
+      style={{
+        padding: "2rem",
+        maxWidth: "400px",
+        margin: "5rem auto",
+        border: "1px solid #ddd",
+        borderRadius: "8px",
+        boxShadow: "0 2px 4px rgba(0,0,0,0.1)",
+      }}
+    >
+      <h2 style={{ textAlign: "center", marginBottom: "2rem" }}>Admin Login</h2>
+      <form onSubmit={handleSubmit}>
+        <div style={{ marginBottom: "1rem" }}>
+          <label htmlFor="username">Username:</label>
+          <input
+            id="username"
+            type="text"
+            value={username}
+            onChange={(e) => setUsername(e.target.value)}
+            style={{
+              width: "100%",
+              padding: "0.5rem",
+              marginTop: "0.5rem",
+              border: "1px solid #ccc",
+              borderRadius: "4px",
+              boxSizing: "border-box",
+            }}
+            placeholder="Enter your username"
+          />
+        </div>
+
+        <div style={{ marginBottom: "1.5rem" }}>
+          <label htmlFor="password">Password:</label>
+          <input
+            id="password"
+            type="password"
+            value={password}
+            onChange={(e) => setPassword(e.target.value)}
+            style={{
+              width: "100%",
+              padding: "0.5rem",
+              marginTop: "0.5rem",
+              border: "1px solid #ccc",
+              borderRadius: "4px",
+              boxSizing: "border-box",
+            }}
+            placeholder="Enter your password"
+          />
+        </div>
+
+        {error && (
+          <div
+            style={{
+              padding: "1rem",
+              marginBottom: "1rem",
+              backgroundColor: "#ffe0e0",
+              border: "1px solid #ff6b6b",
+              borderRadius: "4px",
+              color: "#c92a2a",
+            }}
+          >
+            {error}
+          </div>
+        )}
+
+        <button
+          type="submit"
+          disabled={isLoading}
+          style={{
+            width: "100%",
+            padding: "0.75rem",
+            backgroundColor: isLoading ? "#ccc" : "#007bff",
+            color: "white",
+            border: "none",
+            borderRadius: "4px",
+            cursor: isLoading ? "not-allowed" : "pointer",
+            fontSize: "1rem",
+            fontWeight: "bold",
+          }}
+        >
+          {isLoading ? "Logging in..." : "Login"}
+        </button>
+      </form>
+    </div>
+  );
+}

client/src/pages/AdminMembers.js

@@ -1,10 +1,22 @@
-import React, { useState } from "react";
+import React, { useState, useEffect } from "react";
+import { useNavigate } from 'react-router';
 
 export default function AdminMembers() {
   const [year, setYear] = useState("");
   const [file, setFile] = useState(null);
   const [status, setStatus] = useState("");
 
+  const navigate = useNavigate();
+  
+  const isAdmin = () => {
+    return localStorage.getItem('adminToken') !== null;
+  };
+
+  if (!isAdmin()) {
+    navigate('/admin-login');
+    return <div>Redirecting...</div>;
+  }
+
   const handleSubmit = async (e) => {
     e.preventDefault();
 

client/src/pages/AdminMembersView.js

@@ -0,0 +1,85 @@
+import React, { useState } from "react";
+import { useNavigate } from 'react-router';
+import Table from '@mui/material/Table';
+
+export default function AdminMembersView() {
+  const [year, setYear] = useState("");
+  const [members, setMembers] = useState([]);
+  const [status, setStatus] = useState("");
+  const navigate = useNavigate();
+  
+  const isAdmin = () => {
+    return localStorage.getItem('adminToken') !== null;
+  };
+
+  if (!isAdmin()) {
+    navigate('/admin-login');
+    return <div>Redirecting...</div>;
+  }
+
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+
+    try {
+      const resp = await fetch(`/api/admin/members/view?year=${year}`);
+      const data = await resp.json();
+      
+      if (data.success) {
+        setMembers(data.members);
+      } else {
+        setStatus(`❌ Server error: ${data.error}`);
+      }
+    } catch (err) {
+      setStatus(`❌ Network error: ${err.message}`);
+    }
+  };
+
+  return (
+    <div style={{ padding: "2rem" }}>
+      <h2>View Members</h2>
+      
+      <form onSubmit={handleSubmit}>
+        <div style={{ marginBottom: "1rem" }}>
+          <label htmlFor="year">Year:</label>
+           
+          <input
+            type="number"
+            id="year"
+            name="year"
+            value={year}
+            onChange={(e) => setYear(e.target.value)}
+            required
+            min="1900"
+            max="2100"
+            style={{ width: "150px", padding: "0.3rem" }}
+          />
+        </div>
+
+        <button type="submit" style={{ padding: "0.5rem 1rem" }}>
+          View Members
+        </button>
+      </form>
+
+      {members.length > 0 && (
+        <Table>
+          <thead>
+            <tr>
+              <th>Name</th>
+              <th>Email</th>
+            </tr>
+          </thead>
+          <tbody>
+            {members.map((member, index) => (
+              <tr key={index}>
+                <td>{member.Name}</td>
+                <td>{member.Email}</td>
+              </tr>
+            ))}
+          </tbody>
+        </Table>
+      )}
+
+      {status && <p style={{ marginTop: "1rem" }}>{status}</p>}
+    </div>
+  );
+}

client/src/pages/PollDetail.js

@@ -0,0 +1,92 @@
+import React, { useEffect, useState } from 'react';
+import axios from 'axios';
+import {
+  PieChart,
+  Pie,
+  Cell,
+  Tooltip,
+  Legend,
+} from 'recharts';
+
+const COLORS = ['#0088FE', '#FEB43C'];
+
+export default function PollDetail({ question }) {
+  const [poll, setPoll] = useState(null);
+
+  useEffect(() => {
+    fetchPoll();
+  }, [question]);
+
+  const fetchPoll = async () => {
+    try {
+      const response = await axios.post('/api/admin/view-votes', { question });
+      setPoll(response.data[0]);
+    } catch (error) {
+      console.error('Error fetching poll:', error);
+    }
+  };
+
+  if (!poll) return <div>Loading...</div>;
+
+  const memberData = [
+    { name: 'Yes', value: poll.member_yes },
+    { name: 'No', value: poll.member_no },
+  ];
+
+  const nonMemberData = [
+    { name: 'Yes', value: poll.non_member_yes },
+    { name: 'No', value: poll.non_member_no },
+  ];
+
+  return (
+    <div>
+      <h1>{poll.question}</h1>
+      <p>Created At: {new Date(poll.created_at).toLocaleString()}</p>
+
+      <div style={{ width: '40%', margin: '20px' }}>
+        <PieChart width={400} height={300}>
+          <Pie
+            data={memberData}
+            cx="50%"
+            cy="50%"
+            labelLine={false}
+            outerRadius={80}
+            fill="#8884d8"
+            dataKey="value"
+          >
+            {memberData.map((entry, index) => (
+              <Cell key={`cell-${index}`} fill={COLORS[index % COLORS.length]} />
+            ))}
+          </Pie>
+          <Tooltip />
+          <Legend />
+        </PieChart>
+      </div>
+
+      <div style={{ width: '40%', margin: '20px' }}>
+        <PieChart width={400} height={300}>
+          <Pie
+            data={nonMemberData}
+            cx="50%"
+            cy="50%"
+            labelLine={false}
+            outerRadius={80}
+            fill="#8884d8"
+            dataKey="value"
+          >
+            {nonMemberData.map((entry, index) => (
+              <Cell key={`cell-${index}`} fill={COLORS[index % COLORS.length]} />
+            ))}
+          </Pie>
+          <Tooltip />
+          <Legend />
+        </PieChart>
+      </div>
+
+      <p>Member Yes Votes: {poll.member_yes}</p>
+      <p>Member No Votes: {poll.member_no}</p>
+      <p>Non-Member Yes Votes: {poll.non_member_yes}</p>
+      <p>Non-Member No Votes: {poll.non_member_no}</p>
+    </div>
+  );
+}

client/src/pages/PollDetails.js

@@ -0,0 +1,103 @@
+import React, { useState, useEffect } from "react";
+import axios from 'axios';
+import {
+  PieChart,
+  Pie,
+  Tooltip,
+  Legend,
+  Cell,
+} from 'recharts';
+
+const COLORS = ['#0088FE', '#FEB43C'];
+
+export default function PollDetails() {
+  const [poll, setPoll] = useState(null);
+  const [loading, setLoading] = useState(true);
+
+  // Get poll ID from URL parameters
+  const match = window.location.pathname.match(/\/poll-details\/(\d+)/);
+  const pollId = match ? parseInt(match[1], 10) : null;
+
+  useEffect(() => {
+    if (pollId) {
+      fetchPollDetails(pollId);
+    }
+  }, [pollId]);
+
+  const fetchPollDetails = async (id) => {
+    try {
+      setLoading(true);
+      const response = await axios.post(`/api/poll/${id}`);
+      setPoll(response.data);
+    } catch (error) {
+      console.error('Error fetching poll details:', error);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  if (loading || !poll) return <div>Loading...</div>;
+
+  // Define data for pie charts
+  const memberData = [
+    { name: 'Yes', value: poll.member_yes },
+    { name: 'No', value: poll.member_no }
+  ];
+
+  const nonMemberData = [
+    { name: 'Yes', value: poll.non_member_yes },
+    { name: 'No', value: poll.non_member_no }
+  ];
+
+  return (
+    <div className="poll-details">
+      <h1>{poll.question}</h1>
+      <p>Created At: {new Date(poll.created_at).toLocaleString()}</p>
+
+      <div style={{ width: '40%', margin: '20px' }}>
+        <PieChart width={400} height={300}>
+          <Pie
+            data={memberData}
+            cx="50%"
+            cy="50%"
+            labelLine={false}
+            outerRadius={80}
+            fill="#8884d8"
+            dataKey="value"
+          >
+            {memberData.map((entry, index) => (
+              <Cell key={`cell-${index}`} fill={COLORS[index % COLORS.length]} />
+            ))}
+          </Pie>
+          <Tooltip />
+          <Legend />
+        </PieChart>
+      </div>
+
+      <div style={{ width: '40%', margin: '20px' }}>
+        <PieChart width={400} height={300}>
+          <Pie
+            data={nonMemberData}
+            cx="50%"
+            cy="50%"
+            labelLine={false}
+            outerRadius={80}
+            fill="#8884d8"
+            dataKey="value"
+          >
+            {nonMemberData.map((entry, index) => (
+              <Cell key={`cell-${index}`} fill={COLORS[index % COLORS.length]} />
+            ))}
+          </Pie>
+          <Tooltip />
+          <Legend />
+        </PieChart>
+      </div>
+
+      <p>Member Yes Votes: {poll.member_yes}</p>
+      <p>Member No Votes: {poll.member_no}</p>
+      <p>Non-Member Yes Votes: {poll.non_member_yes}</p>
+      <p>Non-Member No Votes: {poll.non_member_no}</p>
+    </div>
+  );
+}

client/src/pages/PollList.js

@@ -0,0 +1,33 @@
+import React, { useEffect, useState } from 'react';
+import axios from 'axios';
+import { Link } from 'react-router';
+
+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 className="poll-list">
+      <h1>Poll List</h1>
+      {polls.map((poll) => (
+        <div key={poll.id} className="poll-item">
+          <Link to={`/poll-details/${poll.id}`}>
+            <h2>{poll.question}</h2>
+          </Link>
+        </div>
+      ))}
+    </div>
+  );
+}

go.mod

@@ -4,6 +4,7 @@ go 1.24.4
 
 require (
 	github.com/glebarez/go-sqlite v1.22.0
+	github.com/golang-jwt/jwt/v5 v5.2.0
 	github.com/gorilla/mux v1.8.1
 	github.com/pkg/errors v0.9.1
 	github.com/stretchr/testify v1.11.1

go.sum

@@ -4,6 +4,8 @@ github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkp
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
 github.com/glebarez/go-sqlite v1.22.0 h1:uAcMJhaA6r3LHMTFgP0SifzgXg46yJkgxqyuyec+ruQ=
 github.com/glebarez/go-sqlite v1.22.0/go.mod h1:PlBIdHe0+aUEFn+r2/uthrWq4FxbzugL0L8Li6yQJbc=
+github.com/golang-jwt/jwt/v5 v5.2.0 h1:d/ix8ftRUorsN+5eMIlF4T6J8CAt9rch3My2winC1Jw=
+github.com/golang-jwt/jwt/v5 v5.2.0/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
 github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26 h1:Xim43kblpZXfIBQsbuBVKCudVG457BR2GZFIz3uw3hQ=
 github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26/go.mod h1:dDKJzRmX4S37WGHujM7tX//fmj1uioxKzKxz3lo4HJo=
 github.com/google/uuid v1.5.0 h1:1p67kYwdtXjb0gL0BPiP1Av9wiZPo5A8z2cWkTZ+eyU=

server/common/common.go

@@ -0,0 +1,16 @@
+package common
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+const (
+	DATE_FORMAT = "2006-01-02 15:04:05"
+	SUCCESS = "success"
+)
+
+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,40 +2,43 @@ package main
 
 import (
 	"encoding/json"
-	"io/ioutil"
+	"fmt"
 	"log"
+	"math/rand"
 	"net/http"
 	"os"
-	"strconv"
 	"path/filepath"
+	"strconv"
+	"time"
 
 	"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 {
-		http.Error(w, "Invalid request payload", http.StatusBadRequest)
+	if err := json.NewDecoder(request.Body).Decode(&vote); err != nil {
+		common.SendError(resWriter, "Invalid JSON", http.StatusBadRequest)
 		return
 	}
 
-	err := services.SetVote(&vote)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
+	if err := services.SetVote(&vote); err != nil {
+		common.SendError(resWriter, "Failed to set vote", http.StatusInternalServerError)
 		return
 	}
 
-	w.WriteHeader(http.StatusOK)
+	resWriter.WriteHeader(http.StatusOK)
 }
 
-func voteIDHandler(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
+func voteIDHandler(resWriter http.ResponseWriter, request *http.Request) {
+	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,117 +50,163 @@ 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) {
-	if r.Method == "GET" {
+func statsHandler(resWriter http.ResponseWriter, request *http.Request) {
+	if request.Method == http.MethodGet {
 		filePath := "./server/templates/stats.html"
-		http.ServeFile(w, r, filePath)
-	} else if r.Method == "POST" {
-		vars := mux.Vars(r)
+		http.ServeFile(resWriter, request, filePath)
+	} else if request.Method == http.MethodPost {
+		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) {
-	vars := mux.Vars(r)
-	id := vars["id"]
-
-	poll, err := services.GetPollByQuestion(id)
+func pollsIDHandler(resWriter http.ResponseWriter, request *http.Request) {
+	vars := mux.Vars(request)
+	id, err := strconv.ParseInt(vars["id"], 10, 64)
 	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
+		common.SendError(resWriter, "Invalid poll ID", http.StatusBadRequest)
 		return
 	}
 
-	json.NewEncoder(w).Encode(poll)
-}
-
-func adminHandler(w http.ResponseWriter, r *http.Request) {
-	// Add admin functionality here
-	w.WriteHeader(http.StatusOK)
-}
-
-func adminIDHandler(w http.ResponseWriter, r *http.Request) {
-	//vars := mux.Vars(r)
-	//id := vars["id"]
-
-	// Add admin functionality here
-	w.WriteHeader(http.StatusOK)
-}
-
-func adminMembersHandler(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodPost {
-		w.WriteHeader(http.StatusMethodNotAllowed)
+	poll, err := services.GetPollById(id)
+	if err == services.ErrPollNotFound {
+		common.SendError(resWriter, "Poll not found", http.StatusNotFound)
+		return
+	} else if err != nil {
+		common.SendError(resWriter, "Failed to get poll", http.StatusInternalServerError)
 		return
 	}
 
-	var year int
-	var err error
+	json.NewEncoder(resWriter).Encode(poll)
+}
 
-	if err = r.ParseMultipartForm(10 << 20); err != nil {
-		http.Error(w, "Failed to parse multipart form", http.StatusBadRequest)
+func adminLoginHandler(resWriter http.ResponseWriter, request *http.Request) {
+	if request.Method != http.MethodPost {
+		common.SendError(resWriter, "Method not allowed", http.StatusMethodNotAllowed)
 		return
 	}
 
-	year_from_form := r.FormValue("year")
-	if year_from_form == "" {
-		http.Error(w, "Year is required", http.StatusBadRequest)
+	var loginReq services.LoginRequest
+	if err := json.NewDecoder(request.Body).Decode(&loginReq); err != nil {
+		common.SendError(resWriter, "Invalid JSON", http.StatusBadRequest)
 		return
-	} else {
-		year, err = strconv.Atoi(year_from_form)
+	}
+
+	// Validate admin credentials
+	isValid, err := services.ValidateAdminLogin(loginReq.Username, loginReq.Password)
 	if err != nil {
-			http.Error(w, "Invalid year", http.StatusBadRequest)
-			return
-		}
-	}
-
-	if file, _, err := r.FormFile("members.csv"); err != nil {
-		http.Error(w, "Failed to upload file", http.StatusBadRequest)
-		return
-	}
-	defer file.Close()
-
-	if fileBytes, err := ioutil.ReadAll(file); err != nil {
-		http.Error(w, "Failed to read file", http.StatusInternalServerError)
+		common.SendError(resWriter, "Invalid username or password", http.StatusBadRequest)
 		return
 	}
 
-	if err = services.ParseMembersFromBytes(year, fileBytes); err != nil {
-		w.WriteHeader(http.StatusBadRequest)
-		json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
+	if !isValid {
+		common.SendError(resWriter, "Invalid username or password", http.StatusUnauthorized)
 		return
 	}
 
-	w.WriteHeader(http.StatusOK)
-	json.NewEncoder(w).Encode(map[string]bool{"success": true})
+	// Generate JWT token
+	token, err := services.GenerateAuthToken(loginReq.Username)
+	if err != nil {
+		common.SendError(resWriter, "Failed to generate auth token", http.StatusInternalServerError)
+		return
+	}
+
+	resWriter.WriteHeader(http.StatusOK)
+	json.NewEncoder(resWriter).Encode(services.LoginResponse{
+		Success: true,
+		Token:   token,
+	})
+}
+
+func initDatabase() error {
+	// Seed random generator for reproducible results in tests
+	rand.Seed(42)
+
+	polls := []models.Poll{
+		{
+			ID:           1,
+			Question:     "Should we increase the budget?",
+			MemberYes:    rand.Int63n(50),
+			MemberNo:     rand.Int63n(50),
+			NonMemberYes: rand.Int63n(20),
+			NonMemberNo:  rand.Int63n(20),
+			TotalVotes:   int(rand.Int63n(100)),
+			WhoVoted:     []string{"email1@example.com", "email2@example.com", "email3@example.com", "email4@example.com"},
+			CreatedAt:    time.Now().Format(time.RFC3339),
+			UpdatedAt:    time.Now().Format(time.RFC3339),
+			ExpiresAt:    time.Now().Add(24 * time.Hour).Format(time.RFC3339),
+		},
+		{
+			ID:           2,
+			Question:     "Should we hire more staff?",
+			MemberYes:    rand.Int63n(50),
+			MemberNo:     rand.Int63n(50),
+			NonMemberYes: rand.Int63n(20),
+			NonMemberNo:  rand.Int63n(20),
+			TotalVotes:   int(rand.Int63n(100)),
+			WhoVoted:     []string{"email1@example.com", "email2@example.com", "email3@example.com", "email4@example.com"},
+			CreatedAt:    time.Now().Format(time.RFC3339),
+			UpdatedAt:    time.Now().Format(time.RFC3339),
+			ExpiresAt:    time.Now().Add(24 * time.Hour).Format(time.RFC3339),
+		},
+		{
+			ID:           3,
+			Question:     "Should we renovate the building?",
+			MemberYes:    rand.Int63n(50),
+			MemberNo:     rand.Int63n(50),
+			NonMemberYes: rand.Int63n(20),
+			NonMemberNo:  rand.Int63n(20),
+			TotalVotes:   int(rand.Int63n(100)),
+			WhoVoted:     []string{"email1@example.com", "email2@example.com", "email3@example.com", "email4@example.com"},
+			CreatedAt:    time.Now().Format(time.RFC3339),
+			UpdatedAt:    time.Now().Format(time.RFC3339),
+			ExpiresAt:    time.Now().Add(24 * time.Hour).Format(time.RFC3339),
+		},
+	}
+
+	for _, poll := range polls {
+		if err := services.CreatePollIgnore(&poll); err != nil {
+			return fmt.Errorf("failed to create poll %d: %v", poll.ID, err)
+		}
+	}
+	return nil
 }
 
 func main() {
 	log.SetOutput(os.Stdout)
 	log.SetFlags(log.LstdFlags | log.Lshortfile)
 
+	// Initialize database with sample data
+	if err := initDatabase(); err != nil {
+		log.Fatalf("Failed to initialize database: %v", err)
+	}
+
 	http.HandleFunc("/api/vote", voteHandler)
 	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/{id}", adminIDHandler)
-	http.HandleFunc("/api/admin/members", adminMembersHandler)
+	http.HandleFunc("/api/polls/{id}", pollsIDHandler)
+	http.HandleFunc("/api/admin/new-vote", services.AdminNewVoteHandler)
+	http.HandleFunc("/api/admin/view-votes", services.AdminViewVoteHandler)
+	http.HandleFunc("/api/admin/login", adminLoginHandler)
+	http.HandleFunc("/api/admin/members", services.AdminMembersHandler)
+	http.HandleFunc("/api/admin/members/view", services.AdminMembersView)
 
 	buildPath := filepath.Join(".", "client", "build")
 	fs := http.FileServer(http.Dir(buildPath))

server/models/poll.go

@@ -5,8 +5,8 @@ type Poll struct {
 	Question     string   `json:"question"`
 	MemberYes    int64    `json:"member_yes"`
 	MemberNo     int64    `json:"member_no"`
-	NonMemberYes int64 `json:"non_member_yes`
-	NonMemberNo int64 `json:"non_member_no`
+	NonMemberYes int64    `json:"non_member_yes"`
+	NonMemberNo  int64    `json:"non_member_no"`
 	TotalVotes   int      `json:"total_votes"`
 	WhoVoted     []string `json:"who_voted"`
 	CreatedAt    string   `json:"created_at"`

server/services/auth.go

@@ -0,0 +1,127 @@
+package services
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"log"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+	"github.com/pkg/errors"
+)
+
+type LoginRequest struct {
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
+
+type LoginResponse struct {
+	Success bool   `json:"success"`
+	Token   string `json:"token,omitempty"`
+	Error   string `json:"error,omitempty"`
+}
+
+var jwtSecret string
+
+func init() {
+	jwtSecret = os.Getenv("JWT_SECRET")
+	if jwtSecret == "" {
+		jwtSecret = "your-secret-key-change-in-production"
+		log.Println("WARNING: JWT_SECRET not set, using default value. Change this in production!")
+	}
+}
+
+// GetAdminCredentials retrieves admin credentials from environment variables
+// Format: ADMIN_USERS=username:password|username2:password2
+func getAdminCredentials() map[string]string {
+	adminUsers := os.Getenv("ADMIN_USERS")
+	if adminUsers == "" {
+		// Default admin user (change in production)
+		adminUsers = "admin:admin"
+		log.Println("WARNING: ADMIN_USERS not set, using default admin:admin")
+	}
+
+	credentials := make(map[string]string)
+	for _, userPass := range strings.Split(adminUsers, "|") {
+		parts := strings.Split(strings.TrimSpace(userPass), ":")
+		if len(parts) == 2 {
+			credentials[parts[0]] = parts[1]
+		}
+	}
+	return credentials
+}
+
+// hashPassword hashes a password using SHA256
+func hashPassword(password string) string {
+	hash := sha256.Sum256([]byte(password))
+	return hex.EncodeToString(hash[:])
+}
+
+// ValidateAdminLogin checks if the provided username and password are valid
+func ValidateAdminLogin(username, password string) (bool, error) {
+	if username == "" || password == "" {
+		return false, errors.New("username and password are required")
+	}
+
+	credentials := getAdminCredentials()
+	storedPassword, exists := credentials[username]
+
+	if !exists {
+		// Return false but not an error for security reasons (don't reveal if user exists)
+		return false, nil
+	}
+
+	// Compare passwords (you could enhance this with bcrypt in production)
+	if storedPassword != password {
+		return false, nil
+	}
+
+	return true, nil
+}
+
+// GenerateAuthToken generates a JWT token for an authenticated admin user
+func GenerateAuthToken(username string) (string, error) {
+	claims := jwt.MapClaims{
+		"username": username,
+		"exp":      time.Now().Add(time.Hour * 24).Unix(), // Token expires in 24 hours
+		"iat":      time.Now().Unix(),
+	}
+
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	tokenString, err := token.SignedString([]byte(jwtSecret))
+
+	if err != nil {
+		return "", errors.Wrap(err, "failed to generate token")
+	}
+
+	return tokenString, nil
+}
+
+// VerifyAuthToken verifies a JWT token and returns the username if valid
+func VerifyAuthToken(tokenString string) (string, error) {
+	token, err := jwt.ParseWithClaims(tokenString, &jwt.MapClaims{}, func(token *jwt.Token) (interface{}, error) {
+		return []byte(jwtSecret), nil
+	})
+
+	if err != nil {
+		return "", errors.Wrap(err, "failed to parse token")
+	}
+
+	if !token.Valid {
+		return "", errors.New("invalid token")
+	}
+
+	claims, ok := token.Claims.(*jwt.MapClaims)
+	if !ok {
+		return "", errors.New("invalid token claims")
+	}
+
+	username, ok := (*claims)["username"].(string)
+	if !ok {
+		return "", errors.New("username not found in token")
+	}
+
+	return username, nil
+}

server/services/members.go

@@ -0,0 +1,237 @@
+package services
+
+import (
+	"encoding/csv"
+	"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"
+)
+
+type Member struct {
+	Name  string
+	Email string
+}
+
+const BATCH_SIZE = 100
+const CVS_FILE_FIELD = "members.csv"
+
+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(CVS_FILE_FIELD)
+	if err != nil {
+		common.SendError(resWriter, "Failed to read " + CVS_FILE_FIELD + " file", http.StatusBadRequest)
+		return
+	}
+	defer file.Close()
+
+	fileBytes, err := ioutil.ReadAll(file)
+	if err != nil {
+		common.SendError(resWriter, "Failed to read " + CVS_FILE_FIELD + " 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{common.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{}{
+		common.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
+	records, err := reader.ReadAll()
+	if err != nil {
+		return errors.Wrap(err, "failed to read CSV from bytes")
+	}
+
+	var members []Member
+
+	for i, record := range records {
+		if i == 0 {
+			continue // Skip the first line (column headers)
+		}
+		if len(record) < 4 {
+			continue
+		}
+
+		firstName := strings.TrimSpace(record[1])
+		lastName := strings.TrimSpace(record[2])
+		email := strings.TrimSpace(record[3])
+
+		members = append(members, Member{
+			Name:  fmt.Sprintf("%s %s", firstName, lastName),
+			Email: email,
+		})
+
+		if len(record) < 30 {
+			continue
+		}
+
+		email2 := strings.TrimSpace(record[27])
+		if email2 != "" {
+			firstName2 := strings.TrimSpace(record[29])
+			lastName2 := strings.TrimSpace(record[28])
+
+			members = append(members, Member{
+				Name:  fmt.Sprintf("%s %s", firstName2, lastName2),
+				Email: email2,
+			})
+		}
+	}
+
+	return saveMember(year, members)
+}
+
+func saveMember(year int, members []Member) error {
+	insertMembersQuery := `
+		INSERT OR REPLACE INTO members (email, member_name, school_year)
+		VALUES ($1, $2, $3)
+	`
+	log.Printf("Starting to save %d members for year %d", len(members), year)
+
+	db_conn, err := db.Connect()
+	if err != nil {
+		return errors.Wrap(err, "failed to connect to database")
+	}
+	defer db_conn.Close()
+
+	tx, err := db_conn.Begin()
+	if err != nil {
+		return errors.Wrap(err, "failed to begin transaction")
+	}
+
+	stmt, err := tx.Prepare(insertMembersQuery)
+	if err != nil {
+		tx.Rollback()
+		return errors.Wrap(err, "failed to prepare statement")
+	}
+	defer stmt.Close()
+
+	for index, member := range members {
+		_, err = stmt.Exec(member.Email, member.Name, year)
+		if err != nil {
+			tx.Rollback()
+			return errors.Wrap(err, "failed to execute insert")
+		}
+
+		if (index+1) % BATCH_SIZE == 0 {
+			err = tx.Commit()
+			if err != nil {
+				tx.Rollback()
+				return errors.Wrap(err, "failed to commit transaction")
+			}
+
+			tx, err = db_conn.Begin()
+			if err != nil {
+				return errors.Wrap(err, "failed to begin new transaction")
+			}
+
+			stmt, err = tx.Prepare(insertMembersQuery)
+			if err != nil {
+				tx.Rollback()
+				return errors.Wrap(err, "failed to prepare new statement")
+			}
+		}
+	}
+
+	return tx.Commit()
+}
+
+func GetMembersByYear(year int) ([]Member, error) {
+	query := `
+		SELECT member_name, email
+		FROM members
+		WHERE school_year = $1
+		ORDER BY member_name ASC
+	`
+
+	db_conn, err := db.Connect()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to connect to database")
+	}
+	defer db_conn.Close()
+
+	rows, err := db_conn.Query(query, year)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to execute query")
+	}
+	defer rows.Close()
+
+	var members []Member
+
+	for rows.Next() {
+		var member Member
+		if err := rows.Scan(&member.Name, &member.Email); err != nil {
+			return nil, errors.Wrap(err, "failed to scan row")
+		}
+		members = append(members, member)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, errors.Wrap(err, "row iteration error")
+	}
+
+	return members, nil
+}

server/services/poll.go

@@ -2,24 +2,73 @@ package services
 
 import (
 	"database/sql"
+	"encoding/json"
 	"errors"
+	"log"
+	"net/http"
+	"strconv"
 	"time"
 
+	"go-sjles-pta-vote/server/common"
 	"go-sjles-pta-vote/server/db"
 	"go-sjles-pta-vote/server/models"
 )
 
-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 (
+	ErrQuestionAlreadyExists = errors.New("Question already exists")
+	ErrQuestionDoesntExist   = errors.New("Question does not exist yet")
+	ErrVoterAlreadyVoted     = errors.New("Voter already voted")
+	ErrPollNotFound          = errors.New("Poll not found")
+	ErrFailedToUpdateVote    = errors.New("Failed to update vote")
+	ErrFailedToDeletePoll    = errors.New("Failed to delete poll")
+)
 
-func CreatePoll(poll *models.Poll) (*models.Poll, error) {
-	new_poll := models.Poll{}
+const (
+	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(common.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{common.SUCCESS: true})
+}
+
+func CreatePoll(poll *models.Poll) (int64, error) {
 	db_conn, err := db.Connect()
 	if err != nil {
-		return nil, err
+		log.Printf("Failed to connect to database: %s", err.Error())
+		return -1, err
 	}
 	defer db.Close()
 
@@ -29,17 +78,19 @@ func CreatePoll(poll *models.Poll) (*models.Poll, error) {
 			WHERE question == $1
 	`)
 	if err != nil {
-		return nil, err
+		log.Printf("%s", err.Error())
+		return -1, err
 	}
 	defer get_stmt.Close()
 
 	var id int
 	err = get_stmt.QueryRow(poll.Question).Scan(&id)
-	if err != sql.ErrNoRows {
 	if err != nil {
-			return nil, err
+		if err != sql.ErrNoRows {
+			log.Printf("%s", err.Error())
+			return -1, err
 		}
-		return nil, ErrQuestionAlreadyExists
+		return -1, ErrQuestionAlreadyExists
 	}
 
 	stmt, err := db_conn.Prepare(`
@@ -53,26 +104,109 @@ func CreatePoll(poll *models.Poll) (*models.Poll, error) {
 	`)
 
 	if err != nil {
-		return nil, err
+		log.Printf("%s", err.Error())
+		return -1, err
 	}
 
 	defer stmt.Close()
 
 	res, err := stmt.Exec(poll.Question, poll.ExpiresAt)
 	if err != nil {
+		log.Printf("%s", err.Error())
+		return -1, err
+	}
+
+	new_poll_id, err := res.LastInsertId()
+	return new_poll_id, err
+}
+
+func AdminViewVoteHandler(resWriter http.ResponseWriter, request *http.Request) {
+	if request.Method != http.MethodPost {
+		resWriter.WriteHeader(http.StatusMethodNotAllowed)
+		return
+	}
+
+	var polls []models.Poll
+	var err error
+	question := request.FormValue("question")
+	if question == "" {
+		polls, err = GetAllPolls()
+		if err != nil {
+			common.SendError(resWriter, "Failed to get polls", http.StatusInternalServerError)
+			return
+		}
+	} else {
+		poll, err := GetPollByQuestion(question)
+		if err != nil {
+			common.SendError(resWriter, "Failed to get poll question "+question, http.StatusInternalServerError)
+			return
+		}
+		polls = append(polls, *poll)
+	}
+
+	err = json.NewEncoder(resWriter).Encode(polls)
+	if err != nil {
+		log.Printf("Error encoding response: %v", err)
+		common.SendError(resWriter, "Failed to encode polls", http.StatusInternalServerError)
+		return
+	}
+}
+
+func GetAllPolls() ([]models.Poll, error) {
+	db_conn, err := db.Connect()
+	if err != nil {
+		log.Printf("%s", err.Error())
+		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.Printf("%s", err.Error())
+		return nil, err
+	}
+	defer get_polls_stmt.Close()
+
+	rows, err := get_polls_stmt.Query()
+	if err != nil {
+		log.Printf("%s", err.Error())
+		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.Printf("%s", err.Error())
 			return nil, err
 		}
 
-	new_poll.ID, err = res.LastInsertId()
+		polls = append(polls, new_poll)
+	}
 
-	return &new_poll, err
+	return polls, nil
 }
 
 func GetPollByQuestion(question string) (*models.Poll, error) {
-	new_poll := models.Poll{}
-
 	db_conn, err := db.Connect()
 	if err != nil {
+		log.Printf("%s", err.Error())
 		return nil, err
 	}
 	defer db.Close()
@@ -88,10 +222,12 @@ func GetPollByQuestion(question string) (*models.Poll, error) {
 		WHERE question == $1
 	`)
 	if err != nil {
+		log.Printf("%s", err.Error())
 		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 +239,7 @@ func GetPollByQuestion(question string) (*models.Poll, error) {
 	if err == sql.ErrNoRows {
 		return nil, ErrPollNotFound
 	} else if err != nil {
+		log.Printf("%s", err.Error())
 		return nil, err
 	}
 
@@ -117,11 +254,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.Printf("%s", err.Error())
 			return nil, err
 		}
 		new_poll.WhoVoted = append(new_poll.WhoVoted, voter_email)
@@ -130,13 +267,56 @@ func GetPollByQuestion(question string) (*models.Poll, error) {
 	return &new_poll, nil
 }
 
+func GetPollById(id int64) (*models.Poll, error) {
+	db_conn, err := db.Connect()
+	if err != nil {
+		log.Printf("%s", err.Error())
+		return nil, err
+	}
+	defer db.Close()
+
+	get_poll_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 
+		WHERE id == $1
+	`)
+	if err != nil {
+		log.Printf("%s", err.Error())
+		return nil, err
+	}
+	defer get_poll_stmt.Close()
+
+	new_poll := models.Poll{}
+	err = get_poll_stmt.QueryRow(id).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 == sql.ErrNoRows {
+		return nil, ErrPollNotFound
+	} else if err != nil {
+		log.Printf("%s", err.Error())
+		return nil, err
+	}
+
+	return &new_poll, nil
+}
+
 func GetAndCreatePollByQuestion(question string) (*models.Poll, error) {
 	new_poll, err := GetPollByQuestion(question)
 
 	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(common.DATE_FORMAT),
 		}
 
 		if _, err = CreatePoll(create_poll); err != nil {
@@ -145,16 +325,17 @@ func GetAndCreatePollByQuestion(question string) (*models.Poll, error) {
 
 		return GetPollByQuestion(question)
 	} else if err != nil {
+		log.Printf("%s", err.Error())
 		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.Printf("%s", err.Error())
 		return err
 	}
 	defer db.Close()
@@ -165,18 +346,21 @@ func SetVote(vote *models.Vote) error {
 		VALUES ($1, $2)
 	`)
 	if err != nil {
+		log.Printf("%s", err.Error())
 		return err
 	}
 	defer set_voter_stmt.Close()
 
 	res, err := set_voter_stmt.Exec(vote.PollId, vote.Email)
 	if err != nil {
+		log.Printf("%s", err.Error())
 		return err
 	} else {
 		rows_changed, err := res.RowsAffected()
 		if rows_changed != 1 {
 			return ErrVoterAlreadyVoted
 		} else if err != nil {
+			log.Printf("%s", err.Error())
 			return err
 		}
 	}
@@ -187,6 +371,7 @@ func SetVote(vote *models.Vote) error {
 		WHERE email == $1
 	`)
 	if err != nil {
+		log.Printf("%s", err.Error())
 		return err
 	}
 	defer is_voter_member_stmt.Close()
@@ -197,6 +382,7 @@ func SetVote(vote *models.Vote) error {
 	if err == sql.ErrNoRows {
 		is_member = false
 	} else if err != nil {
+		log.Printf("%s", err.Error())
 		return err
 	}
 
@@ -219,18 +405,21 @@ func SetVote(vote *models.Vote) error {
 		WHERE id == $1
 	`)
 	if err != nil {
+		log.Printf("%s", err.Error())
 		return err
 	}
 	defer add_vote_stmt.Close()
 
 	res, err = add_vote_stmt.Exec(vote.PollId)
 	if err != nil {
+		log.Printf("%s", err.Error())
 		return err
 	}
 
 	if num, err := res.RowsAffected(); num != 1 {
-		return errors.New("Failed to update votes")
+		return ErrFailedToUpdateVote
 	} else if err != nil {
+		log.Printf("%s", err.Error())
 		return err
 	}
 
@@ -241,6 +430,7 @@ func SetVote(vote *models.Vote) error {
 func DeletePollByQuestion(question string) error {
 	db_conn, err := db.Connect()
 	if err != nil {
+		log.Printf("%s", err.Error())
 		return err
 	}
 	defer db.Close()
@@ -254,12 +444,14 @@ func DeletePollByQuestion(question string) error {
 		)
 	`)
 	if err != nil {
+		log.Printf("%s", err.Error())
 		return err
 	}
 	defer delete_votes_stmt.Close()
 
 	_, err = delete_votes_stmt.Exec(question)
 	if err != nil {
+		log.Printf("%s", err.Error())
 		return err
 	}
 
@@ -268,18 +460,77 @@ func DeletePollByQuestion(question string) error {
 		WHERE question == $1
 	`)
 	if err != nil {
+		log.Printf("%s", err.Error())
 		return err
 	}
 	defer delete_poll_stmt.Close()
 
 	res, err := delete_poll_stmt.Exec(question)
 	if err != nil {
+		log.Printf("%s", err.Error())
 		return err
 	}
 
 	if num, err := res.RowsAffected(); num != 1 {
-		return errors.New("Failed to delete poll")
+		return ErrFailedToDeletePoll
 	} else if err != nil {
+		log.Printf("%s", err.Error())
+		return err
+	}
+
+	return nil
+}
+
+func CreatePollIgnore(poll *models.Poll) error {
+	db_conn, err := db.Connect()
+	if err != nil {
+		log.Printf("%s", err.Error())
+		return err
+	}
+	defer db.Close()
+
+	stmt, err := db_conn.Prepare(`
+		INSERT OR IGNORE INTO polls (
+			question,
+			expires_at,
+			member_yes_votes,
+			member_no_votes,
+			non_member_yes_votes,
+			non_member_no_votes,
+			created_at,
+			updated_at
+		) VALUES (
+			$1,
+			$2,
+			$3,
+			$4,
+			$5,
+			$6,
+			$7,
+			$8
+		)
+	`)
+
+	if err != nil {
+		log.Printf("%s", err.Error())
+		return err
+	}
+
+	defer stmt.Close()
+
+	_, err = stmt.Exec(
+		poll.Question,
+		poll.ExpiresAt,
+		poll.MemberYes,
+		poll.MemberNo,
+		poll.NonMemberYes,
+		poll.NonMemberNo,
+		poll.CreatedAt,
+		poll.UpdatedAt,
+	)
+
+	if err != nil {
+		log.Printf("%s", err.Error())
 		return err
 	}
 

server/services/putmembers.go

@@ -1,120 +0,0 @@
-package services
-
-import (
-	"encoding/csv"
-	"fmt"
-	"log"
-	"strings"
-
-	"github.com/pkg/errors"
-
-	"go-sjles-pta-vote/server/db"
-)
-
-type Member struct {
-	Name  string
-	Email string
-}
-
-const BATCH_SIZE = 100
-
-func ParseMembersFromBytes(year int, fileBytes []byte) error {
-	reader := csv.NewReader(strings.NewReader(string(fileBytes)))
-	reader.FieldsPerRecord = -1 // Allow variable number of fields per record
-	records, err := reader.ReadAll()
-	if err != nil {
-		return errors.Wrap(err, "failed to read CSV from bytes")
-	}
-
-	var members []Member
-
-	for i, record := range records {
-		if i == 0 {
-			continue // Skip the first line (column headers)
-		}
-		if len(record) < 4 {
-			continue
-		}
-
-		firstName := strings.TrimSpace(record[1])
-		lastName := strings.TrimSpace(record[2])
-		email := strings.TrimSpace(record[3])
-
-		members = append(members, Member{
-			Name:  fmt.Sprintf("%s %s", firstName, lastName),
-			Email: email,
-		})
-
-		if len(record) < 30 {
-			continue
-		}
-
-		email2 := strings.TrimSpace(record[27])
-		if email2 != "" {
-			firstName2 := strings.TrimSpace(record[29])
-			lastName2 := strings.TrimSpace(record[28])
-
-			members = append(members, Member{
-				Name:  fmt.Sprintf("%s %s", firstName2, lastName2),
-				Email: email2,
-			})
-		}
-	}
-
-	return saveMember(year, members)
-}
-
-func saveMember(year int, members []Member) error {
-	insertMembersQuery := `
-		INSERT OR REPLACE INTO members (email, member_name, school_year)
-		VALUES ($1, $2, $3)
-	`
-	log.Printf("Starting to save %d members for year %d", len(members), year)
-
-	db_conn, err := db.Connect()
-	if err != nil {
-		return errors.Wrap(err, "failed to connect to database")
-	}
-	defer db_conn.Close()
-
-	tx, err := db_conn.Begin()
-	if err != nil {
-		return errors.Wrap(err, "failed to begin transaction")
-	}
-
-	stmt, err := tx.Prepare(insertMembersQuery)
-	if err != nil {
-		tx.Rollback()
-		return errors.Wrap(err, "failed to prepare statement")
-	}
-	defer stmt.Close()
-
-	for index, member := range members {
-		_, err = stmt.Exec(member.Email, member.Name, year)
-		if err != nil {
-			tx.Rollback()
-			return errors.Wrap(err, "failed to execute insert")
-		}
-
-		if (index+1) % BATCH_SIZE == 0 {
-			err = tx.Commit()
-			if err != nil {
-				tx.Rollback()
-				return errors.Wrap(err, "failed to commit transaction")
-			}
-
-			tx, err = db_conn.Begin()
-			if err != nil {
-				return errors.Wrap(err, "failed to begin new transaction")
-			}
-
-			stmt, err = tx.Prepare(insertMembersQuery)
-			if err != nil {
-				tx.Rollback()
-				return errors.Wrap(err, "failed to prepare new statement")
-			}
-		}
-	}
-
-	return tx.Commit()
-}

server/services/putmembers_test.go

@@ -1,45 +0,0 @@
-package services
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestParseMembersFromBytes(t *testing.T) {
-	testCases := []struct {
-		name     string
-		input    string
-		expected []Member
-	}{
-		{
-			name: "Valid CSV with multiple members",
-			input: `date,First,Last,Email
-2023-01-01,John,Doe,john.doe@example.com
-2023-01-02,Jane,Smith,jane.smith@example.com`,
-			expected: []Member{
-				{Name: "John Doe", Email: "john.doe@example.com"},
-				{Name: "Jane Smith", Email: "jane.smith@example.com"},
-			},
-		},
-		{
-			name: "CSV with missing fields",
-			input: `date,First,Last
-2023-01-01,John,Doe`,
-			expected: []Member{},
-		},
-		{
-			name: "Empty CSV",
-			input: ``,
-			expected: []Member{},
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			members, err := ParseMembersFromBytes(2023, []byte(tc.input))
-			assert.NoError(t, err)
-			assert.Equal(t, tc.expected, members)
-		})
-	}
-}

server/services/services_test.go

@@ -176,18 +176,18 @@ func TestCreatePoll(t *testing.T) {
 			ExpiresAt: time.Now().Add(time.Hour * 10).Format("2006-01-02 15:04:05"),
 		}
 
-		new_poll, err := CreatePoll(create_poll)
+		new_poll_id, err := CreatePoll(create_poll)
 
 		if err != nil {
-			t.Fatalf(`Failed to create new poll %s: %v`, parameters[i].question, err)
+			t.Errorf(`Failed to create new poll %s: %v`, parameters[i].question, err)
 		}
 
-		if new_poll == nil {
-			t.Fatalf(`Failed to insert %s into table`, parameters[i].question)
+		if new_poll_id == -1 {
+			t.Errorf(`Failed to insert %s into table`, parameters[i].question)
 		}
 
-		if new_poll.ID != parameters[i].table_index {
-			t.Fatalf(`Incorrect increment in index for %s: expected %d != %d`, parameters[i].question, parameters[i].table_index, new_poll.ID)
+		if new_poll_id != parameters[i].table_index {
+			t.Errorf(`Incorrect increment in index for %s: expected %d != %d`, parameters[i].question, parameters[i].table_index, new_poll_id)
 		}
 	}
 }
@@ -220,17 +220,17 @@ func TestAlreadyExists(t *testing.T) {
 	new_poll, err := CreatePoll(create_poll)
 
 	if err != nil {
-		t.Fatalf(`Failed to create new poll %s: %v`, question, err)
+		t.Errorf(`Failed to create new poll %s: %v`, question, err)
 	}
 
-	if new_poll == nil {
-		t.Fatalf(`Failed to insert %s into table`, question)
+	if new_poll == -1 {
+		t.Errorf(`Failed to insert %s into table`, question)
 	}
 
 	new_poll, err = CreatePoll(create_poll)
 
 	if err != ErrQuestionAlreadyExists {
-		t.Fatalf(`Should have failed adding %s as it already exists`, question)
+		t.Errorf(`Should have failed adding %s as it already exists`, question)
 	}
 }
 
@@ -262,21 +262,21 @@ func TestGetPollByQuestion(t *testing.T) {
 	new_poll, err := CreatePoll(create_poll)
 
 	if err != nil {
-		t.Fatalf(`Failed to create new poll %s: %v`, question, err)
+		t.Errorf(`Failed to create new poll %s: %v`, question, err)
 	}
 
-	if new_poll == nil {
-		t.Fatalf(`Failed to insert %s into table`, question)
+	if new_poll == -1 {
+		t.Errorf(`Failed to insert %s into table`, question)
 	}
 
 	get_poll, err := GetPollByQuestion(question)
 
 	if err != nil {
-		t.Fatalf(`Failed to get the poll %s: %v`, question, err)
+		t.Errorf(`Failed to get the poll %s: %v`, question, err)
 	}
 
 	if get_poll.Question != question {
-		t.Fatalf(`Questions don't match: expected %s: recieved %s`, question, get_poll.Question)
+		t.Errorf(`Questions don't match: expected %s: recieved %s`, question, get_poll.Question)
 	}
 }
 
@@ -314,19 +314,19 @@ func TestGetCreatePollByQuestion(t *testing.T) {
 		new_poll, err := GetAndCreatePollByQuestion(parameters[i].question)
 
 		if err != nil {
-			t.Fatalf(`Failed to create new poll %s: %v`, parameters[i].question, err)
+			t.Errorf(`Failed to create new poll %s: %v`, parameters[i].question, err)
 		}
 
 		if new_poll == nil {
-			t.Fatalf(`Failed to insert %s into table`, parameters[i].question)
+			t.Errorf(`Failed to insert %s into table`, parameters[i].question)
 		}
 
 		if new_poll.ID != parameters[i].table_index {
-			t.Fatalf(`Incorrect increment in index for %s: expected %d != %d`, parameters[i].question, parameters[i].table_index, new_poll.ID)
+			t.Errorf(`Incorrect increment in index for %s: expected %d != %d`, parameters[i].question, parameters[i].table_index, new_poll.ID)
 		}
 
 		if new_poll.Question != parameters[i].question {
-			t.Fatalf(`Incorrect question returned: Expected %s != %s`, parameters[i].question, new_poll.Question)
+			t.Errorf(`Incorrect question returned: Expected %s != %s`, parameters[i].question, new_poll.Question)
 		}
 	}
 }
@@ -335,7 +335,7 @@ func TestSetVote(t *testing.T) {
 	// Preload the database with members, polls, and voters
 	tmp_db, err := os.CreateTemp("", "vote_test.*.db")
 	if err != nil {
-        t.Fatalf("Failed to create temporary database: %v", err)
+		t.Errorf("Failed to create temporary database: %v", err)
 	}
 	defer os.Remove(tmp_db.Name())
 
@@ -346,7 +346,7 @@ func TestSetVote(t *testing.T) {
 
 	err = PreLoadDB()
 	if err != nil {
-        t.Fatalf("Failed to preload database: %v", err)
+		t.Errorf("Failed to preload database: %v", err)
 	}
 
 	// Add a non-member vote
@@ -358,7 +358,7 @@ func TestSetVote(t *testing.T) {
 	}
 	err = SetVote(vote)
 	if err != nil {
-        t.Fatalf("Failed to set non-member vote: %v", err)
+		t.Errorf("Failed to set non-member vote: %v", err)
 	}
 
 	// Add a member vote
@@ -370,13 +370,13 @@ func TestSetVote(t *testing.T) {
 	}
 	err = SetVote(vote)
 	if err != nil {
-        t.Fatalf("Failed to set member vote: %v", err)
+		t.Errorf("Failed to set member vote: %v", err)
 	}
 
 	// Verify the votes were added correctly
 	voters, err := models.GetVoters(1) // Use GetVoters from models
 	if err != nil {
-        t.Fatalf("Failed to get voters: %v", err)
+		t.Errorf("Failed to get voters: %v", err)
 	}
 
 	expected_non_member_votes := 4 + 1 // Original non-member votes + new non-member vote
@@ -399,7 +399,7 @@ func TestVoterAlreadyVoted(t *testing.T) {
 	// Preload the database with members, polls, and voters
 	tmp_db, err := os.CreateTemp("", "vote_test.*.db")
 	if err != nil {
-        t.Fatalf("Failed to create temporary database: %v", err)
+		t.Errorf("Failed to create temporary database: %v", err)
 	}
 	defer os.Remove(tmp_db.Name())
 
@@ -410,7 +410,7 @@ func TestVoterAlreadyVoted(t *testing.T) {
 
 	err = PreLoadDB()
 	if err != nil {
-        t.Fatalf("Failed to preload database: %v", err)
+		t.Errorf("Failed to preload database: %v", err)
 	}
 
 	// Add a non-member vote
@@ -422,7 +422,7 @@ func TestVoterAlreadyVoted(t *testing.T) {
 	}
 	err = SetVote(vote)
 	if err != nil {
-        t.Fatalf("Failed to set non-member vote: %v", err)
+		t.Errorf("Failed to set non-member vote: %v", err)
 	}
 
 	// Add a member vote
@@ -434,7 +434,7 @@ func TestVoterAlreadyVoted(t *testing.T) {
 	}
 	err = SetVote(vote)
 	if err != nil {
-        t.Fatalf("Failed to set member vote: %v", err)
+		t.Errorf("Failed to set member vote: %v", err)
 	}
 
 	// Attempt to add another non-member vote
@@ -445,7 +445,7 @@ func TestVoterAlreadyVoted(t *testing.T) {
 	}
 	err = SetVote(vote)
 	if err != ErrVoterAlreadyVoted {
-        t.Fatalf("Expected ErrVoterAlreadyVoted, but got %v", err)
+		t.Errorf("Expected ErrVoterAlreadyVoted, but got %v", err)
 	}
 
 	// Attempt to add another member vote
@@ -456,7 +456,7 @@ func TestVoterAlreadyVoted(t *testing.T) {
 	}
 	err = SetVote(vote)
 	if err != ErrVoterAlreadyVoted {
-        t.Fatalf("Expected ErrVoterAlreadyVoted, but got %v", err)
+		t.Errorf("Expected ErrVoterAlreadyVoted, but got %v", err)
 	}
 }
 
@@ -464,7 +464,7 @@ func TestDeletePollByQuestion(t *testing.T) {
 	// Preload the database with members, polls, and voters
 	tmp_db, err := os.CreateTemp("", "vote_test.*.db")
 	if err != nil {
-        t.Fatalf("Failed to create temporary database: %v", err)
+		t.Errorf("Failed to create temporary database: %v", err)
 	}
 	defer os.Remove(tmp_db.Name())
 
@@ -475,7 +475,7 @@ func TestDeletePollByQuestion(t *testing.T) {
 
 	err = PreLoadDB()
 	if err != nil {
-        t.Fatalf("Failed to preload database: %v", err)
+		t.Errorf("Failed to preload database: %v", err)
 	}
 
 	// Get a question from the new_polls array
@@ -484,14 +484,14 @@ func TestDeletePollByQuestion(t *testing.T) {
 	// Delete the poll by question
 	err = DeletePollByQuestion(testQuestion)
 	if err != nil {
-        t.Fatalf("Failed to delete poll by question: %v", err)
+		t.Errorf("Failed to delete poll by question: %v", err)
 	}
 
 	// Verify that the poll was deleted
 	_, err = GetPollByQuestion(testQuestion)
 	if err == nil {
-        t.Fatalf("Expected error when getting deleted poll, but got none")
+		t.Errorf("Expected error when getting deleted poll, but got none")
 	} else if err != ErrPollNotFound {
-        t.Fatalf("Expected ErrPollNotFound, but got %v", err)
+		t.Errorf("Expected ErrPollNotFound, but got %v", err)
 	}
 }