Adding page to create votes and view the votes, rearanging some methods

2026-01-23 13:54:05 -05:00
parent 0f6e8a8350
commit 3b0a8625bc
10 changed files with 479 additions and 152 deletions
--- a/server/common/common.go
+++ b/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})
+}
--- a/server/main.go
+++ b/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 {
-		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,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) {
-	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)
+func statsIDHandler(resWriter http.ResponseWriter, request *http.Request) {
+	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) {
-	// 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 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"})
+func adminLoginHandler(resWriter http.ResponseWriter, request *http.Request) {
+	if request.Method != http.MethodPost {
+		common.SendError(resWriter, "Method not allowed", http.StatusMethodNotAllowed)
 		return
 	}

 	var loginReq services.LoginRequest
-	if err := json.NewDecoder(r.Body).Decode(&loginReq); err != nil {
-		w.WriteHeader(http.StatusBadRequest)
-		json.NewEncoder(w).Encode(map[string]string{"error": "Invalid request payload"})
+	if err := json.NewDecoder(request.Body).Decode(&loginReq); err != nil {
+		common.SendError(resWriter, "Invalid JSON", http.StatusBadRequest)
 		return
 	}

 	// Validate admin credentials
 	isValid, err := services.ValidateAdminLogin(loginReq.Username, loginReq.Password)
 	if err != nil {
-		w.WriteHeader(http.StatusBadRequest)
-		json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
+		common.SendError(resWriter, "Invalid username or password", http.StatusBadRequest)
 		return
 	}

 	if !isValid {
-		w.WriteHeader(http.StatusUnauthorized)
-		json.NewEncoder(w).Encode(map[string]string{"error": "Invalid username or password"})
+		common.SendError(resWriter, "Invalid username or password", http.StatusUnauthorized)
 		return
 	}

 	// Generate JWT token
 	token, err := services.GenerateAuthToken(loginReq.Username)
 	if err != nil {
-		w.WriteHeader(http.StatusInternalServerError)
-		json.NewEncoder(w).Encode(map[string]string{"error": "Failed to generate token"})
+		common.SendError(resWriter, "Failed to generate auth token", http.StatusInternalServerError)
 		return
 	}

-	w.WriteHeader(http.StatusOK)
-	json.NewEncoder(w).Encode(services.LoginResponse{
+	resWriter.WriteHeader(http.StatusOK)
+	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/{id}", adminIDHandler)
+	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", adminMembersHandler)
-	http.HandleFunc("/api/admin/members/view", adminMembersView)
+	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))
--- a/server/services/members.go
+++ b/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
--- a/server/services/poll.go
+++ b/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) {
-	new_poll := models.Poll{}
+const ( 
+	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()
-	
-	return &new_poll, 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
+	}
+
+	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
 	}