Fixing up the go code, adding initial work for the stats pages, adding a function to pre-populate the database with some example polls for testing. Will be removed later

server/common/common.go

@@ -5,6 +5,11 @@ import (
 	"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,11 +2,14 @@ package main
 
 import (
 	"encoding/json"
+	"fmt"
 	"log"
+	"math/rand"
 	"net/http"
 	"os"
-	"strconv"
 	"path/filepath"
+	"strconv"
+	"time"
 
 	"github.com/gorilla/mux"
 
@@ -42,7 +45,7 @@ func voteIDHandler(resWriter http.ResponseWriter, request *http.Request) {
 	vote := models.Vote{
 		PollId: id,
 		Email:  "example@example.com", // Replace with actual email retrieval logic
-		Vote:   true,                    // Replace with actual vote retrieval logic
+		Vote:   true,                  // Replace with actual vote retrieval logic
 	}
 
 	err = services.SetVote(&vote)
@@ -74,12 +77,19 @@ func statsHandler(resWriter http.ResponseWriter, request *http.Request) {
 	}
 }
 
-func statsIDHandler(resWriter http.ResponseWriter, request *http.Request) {
+func pollsIDHandler(resWriter http.ResponseWriter, request *http.Request) {
 	vars := mux.Vars(request)
-	id := vars["id"]
-
-	poll, err := services.GetPollByQuestion(id)
+	id, err := strconv.ParseInt(vars["id"], 10, 64)
 	if err != nil {
+		common.SendError(resWriter, "Invalid poll ID", http.StatusBadRequest)
+		return
+	}
+
+	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
 	}
@@ -125,14 +135,73 @@ func adminLoginHandler(resWriter http.ResponseWriter, request *http.Request) {
 	})
 }
 
+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/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)
@@ -141,7 +210,7 @@ func main() {
 
 	buildPath := filepath.Join(".", "client", "build")
 	fs := http.FileServer(http.Dir(buildPath))
-	
+
 	http.Handle("/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		// If the file exists on disk, let the file server handle it.
 		if _, err := os.Stat(filepath.Join(buildPath, r.URL.Path)); err == nil {

server/models/poll.go

@@ -1,15 +1,15 @@
 package models
 
 type Poll struct {
-	ID int64 `json:"id"`
-	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`
-	TotalVotes int `json:"total_votes"`
-	WhoVoted []string `json:"who_voted"`
-	CreatedAt string `json:"created_at"`
-	UpdatedAt string `json:"updated_at"`
-	ExpiresAt string `json:"expires_at"`
-}
+	ID           int64    `json:"id"`
+	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"`
+	TotalVotes   int      `json:"total_votes"`
+	WhoVoted     []string `json:"who_voted"`
+	CreatedAt    string   `json:"created_at"`
+	UpdatedAt    string   `json:"updated_at"`
+	ExpiresAt    string   `json:"expires_at"`
+}

server/services/members.go

@@ -22,6 +22,7 @@ type Member struct {
 }
 
 const BATCH_SIZE = 100
+const CVS_FILE_FIELD = "members.csv"
 
 func AdminMembersHandler(resWriter http.ResponseWriter, request *http.Request) {
 	if request.Method != http.MethodPost {
@@ -49,16 +50,16 @@ func AdminMembersHandler(resWriter http.ResponseWriter, request *http.Request) {
 		}
 	}
 
-	file, _, err := request.FormFile("members.csv")
+	file, _, err := request.FormFile(CVS_FILE_FIELD)
 	if err != nil {
-		common.SendError(resWriter, "Failed to read members.csv file", http.StatusBadRequest)
+		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 members.csv file", http.StatusInternalServerError)
+		common.SendError(resWriter, "Failed to read " + CVS_FILE_FIELD + " file", http.StatusInternalServerError)
 		return
 	}
 
@@ -68,7 +69,7 @@ func AdminMembersHandler(resWriter http.ResponseWriter, request *http.Request) {
 	}
 
 	resWriter.WriteHeader(http.StatusOK)
-	json.NewEncoder(resWriter).Encode(map[string]bool{"success": true})
+	json.NewEncoder(resWriter).Encode(map[string]bool{common.SUCCESS: true})
 }
 
 func AdminMembersView(resWriter http.ResponseWriter, request *http.Request) {
@@ -92,7 +93,7 @@ func AdminMembersView(resWriter http.ResponseWriter, request *http.Request) {
 
 	resWriter.WriteHeader(http.StatusOK)
 	json.NewEncoder(resWriter).Encode(map[string]interface{}{
-		"success": true,
+		common.SUCCESS: true,
 		"members": members,
 	})
 }

server/services/poll.go

@@ -2,27 +2,28 @@ package services
 
 import (
 	"database/sql"
-	"errors"
-	"time"
-	"log"
 	"encoding/json"
-	"strconv"
+	"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 ErrFailedToUpdateVote = errors.New("Failed to update vote")
-var ErrFailedToDeletePoll = errors.New("Failed to delete poll")
+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")
+)
 
-const ( 
-	DATE_FORMAT = "2006-01-02 15:04:05"
+const (
 	DEFAULT_POLL_DURATION_HOURS = 24
 )
 
@@ -49,8 +50,8 @@ func AdminNewVoteHandler(resWriter http.ResponseWriter, request *http.Request) {
 	}
 
 	poll := models.Poll{
-		Question:     question,
-		ExpiresAt:    time.Now().Add(time.Duration(durationHours) * time.Hour).Format(DATE_FORMAT),
+		Question:  question,
+		ExpiresAt: time.Now().Add(time.Duration(durationHours) * time.Hour).Format(common.DATE_FORMAT),
 	}
 
 	_, err := CreatePoll(&poll)
@@ -60,14 +61,14 @@ func AdminNewVoteHandler(resWriter http.ResponseWriter, request *http.Request) {
 	}
 
 	resWriter.WriteHeader(http.StatusOK)
-	json.NewEncoder(resWriter).Encode(map[string]bool{"success": true})
+	json.NewEncoder(resWriter).Encode(map[string]bool{common.SUCCESS: true})
 }
 
-func CreatePoll(poll *models.Poll) (*int64, error) {
+func CreatePoll(poll *models.Poll) (int64, error) {
 	db_conn, err := db.Connect()
 	if err != nil {
-		log.Fatal(err)
-		return nil, err
+		log.Printf("Failed to connect to database: %s", err.Error())
+		return -1, err
 	}
 	defer db.Close()
 
@@ -77,21 +78,21 @@ func CreatePoll(poll *models.Poll) (*int64, error) {
 			WHERE question == $1
 	`)
 	if err != nil {
-		log.Fatal(err)
-		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 {
-			log.Fatal(err)
-			return nil, err
+	if err != nil {
+		if err != sql.ErrNoRows {
+			log.Printf("%s", err.Error())
+			return -1, err
 		}
-		return nil, ErrQuestionAlreadyExists
+		return -1, ErrQuestionAlreadyExists
 	}
-	
+
 	stmt, err := db_conn.Prepare(`
 		INSERT INTO polls (
 			question,
@@ -103,20 +104,20 @@ func CreatePoll(poll *models.Poll) (*int64, error) {
 	`)
 
 	if err != nil {
-		log.Fatal(err)
-		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.Fatal(err)
-		return nil, err
+		log.Printf("%s", err.Error())
+		return -1, err
 	}
 
-	new_poll_id, err := res.LastInsertId()	
-	return &new_poll_id, err
+	new_poll_id, err := res.LastInsertId()
+	return new_poll_id, err
 }
 
 func AdminViewVoteHandler(resWriter http.ResponseWriter, request *http.Request) {
@@ -125,19 +126,36 @@ func AdminViewVoteHandler(resWriter http.ResponseWriter, request *http.Request)
 		return
 	}
 
-	polls, err := GetAllPolls()
-	if err != nil {
-		common.SendError(resWriter, "Failed to get polls", http.StatusInternalServerError)
-		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)
 	}
 
-	json.NewEncoder(resWriter).Encode(polls)
+	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.Fatal(err)
+		log.Printf("%s", err.Error())
 		return nil, err
 	}
 	defer db.Close()
@@ -152,14 +170,14 @@ func GetAllPolls() ([]models.Poll, error) {
 		FROM polls 
 	`)
 	if err != nil {
-		log.Fatal(err)
+		log.Printf("%s", err.Error())
 		return nil, err
 	}
 	defer get_polls_stmt.Close()
 
 	rows, err := get_polls_stmt.Query()
 	if err != nil {
-		log.Fatal(err)
+		log.Printf("%s", err.Error())
 		return nil, err
 	}
 	defer rows.Close()
@@ -175,7 +193,7 @@ func GetAllPolls() ([]models.Poll, error) {
 			&new_poll.ExpiresAt,
 		)
 		if err != nil {
-			log.Fatal(err)
+			log.Printf("%s", err.Error())
 			return nil, err
 		}
 
@@ -188,7 +206,7 @@ func GetAllPolls() ([]models.Poll, error) {
 func GetPollByQuestion(question string) (*models.Poll, error) {
 	db_conn, err := db.Connect()
 	if err != nil {
-		log.Fatal(err)
+		log.Printf("%s", err.Error())
 		return nil, err
 	}
 	defer db.Close()
@@ -204,7 +222,7 @@ func GetPollByQuestion(question string) (*models.Poll, error) {
 		WHERE question == $1
 	`)
 	if err != nil {
-		log.Fatal(err)
+		log.Printf("%s", err.Error())
 		return nil, err
 	}
 	defer get_poll_stmt.Close()
@@ -221,11 +239,11 @@ func GetPollByQuestion(question string) (*models.Poll, error) {
 	if err == sql.ErrNoRows {
 		return nil, ErrPollNotFound
 	} else if err != nil {
-		log.Fatal(err)
+		log.Printf("%s", err.Error())
 		return nil, err
 	}
 
-	get_voters_stmt, err := db_conn.Prepare (`
+	get_voters_stmt, err := db_conn.Prepare(`
 		SELECT voter_email 
 		FROM voters
 		WHERE poll_id == $1
@@ -240,7 +258,7 @@ func GetPollByQuestion(question string) (*models.Poll, error) {
 		var voter_email string
 		err = rows.Scan(&voter_email)
 		if err != nil {
-			log.Fatal(err)
+			log.Printf("%s", err.Error())
 			return nil, err
 		}
 		new_poll.WhoVoted = append(new_poll.WhoVoted, voter_email)
@@ -249,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(DATE_FORMAT),
+			Question:  question,
+			ExpiresAt: time.Now().Add(time.Hour * 10).Format(common.DATE_FORMAT),
 		}
 
 		if _, err = CreatePoll(create_poll); err != nil {
@@ -264,7 +325,7 @@ func GetAndCreatePollByQuestion(question string) (*models.Poll, error) {
 
 		return GetPollByQuestion(question)
 	} else if err != nil {
-		log.Fatal(err)
+		log.Printf("%s", err.Error())
 		return nil, err
 	} else {
 		return new_poll, err
@@ -274,7 +335,7 @@ func GetAndCreatePollByQuestion(question string) (*models.Poll, error) {
 func SetVote(vote *models.Vote) error {
 	db_conn, err := db.Connect()
 	if err != nil {
-		log.Fatal(err)
+		log.Printf("%s", err.Error())
 		return err
 	}
 	defer db.Close()
@@ -285,21 +346,21 @@ func SetVote(vote *models.Vote) error {
 		VALUES ($1, $2)
 	`)
 	if err != nil {
-		log.Fatal(err)
+		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.Fatal(err)
+		log.Printf("%s", err.Error())
 		return err
 	} else {
 		rows_changed, err := res.RowsAffected()
 		if rows_changed != 1 {
 			return ErrVoterAlreadyVoted
 		} else if err != nil {
-			log.Fatal(err)
+			log.Printf("%s", err.Error())
 			return err
 		}
 	}
@@ -310,7 +371,7 @@ func SetVote(vote *models.Vote) error {
 		WHERE email == $1
 	`)
 	if err != nil {
-		log.Fatal(err)
+		log.Printf("%s", err.Error())
 		return err
 	}
 	defer is_voter_member_stmt.Close()
@@ -321,7 +382,7 @@ func SetVote(vote *models.Vote) error {
 	if err == sql.ErrNoRows {
 		is_member = false
 	} else if err != nil {
-		log.Fatal(err)
+		log.Printf("%s", err.Error())
 		return err
 	}
 
@@ -344,21 +405,21 @@ func SetVote(vote *models.Vote) error {
 		WHERE id == $1
 	`)
 	if err != nil {
-		log.Fatal(err)
+		log.Printf("%s", err.Error())
 		return err
 	}
 	defer add_vote_stmt.Close()
 
 	res, err = add_vote_stmt.Exec(vote.PollId)
 	if err != nil {
-		log.Fatal(err)
+		log.Printf("%s", err.Error())
 		return err
 	}
 
 	if num, err := res.RowsAffected(); num != 1 {
 		return ErrFailedToUpdateVote
 	} else if err != nil {
-		log.Fatal(err)
+		log.Printf("%s", err.Error())
 		return err
 	}
 
@@ -369,8 +430,8 @@ 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
-		log.Fatal(err)
 	}
 	defer db.Close()
 
@@ -383,14 +444,14 @@ func DeletePollByQuestion(question string) error {
 		)
 	`)
 	if err != nil {
-		log.Fatal(err)
+		log.Printf("%s", err.Error())
 		return err
 	}
 	defer delete_votes_stmt.Close()
 
 	_, err = delete_votes_stmt.Exec(question)
 	if err != nil {
-		log.Fatal(err)
+		log.Printf("%s", err.Error())
 		return err
 	}
 
@@ -399,23 +460,79 @@ func DeletePollByQuestion(question string) error {
 		WHERE question == $1
 	`)
 	if err != nil {
-		log.Fatal(err)
+		log.Printf("%s", err.Error())
 		return err
 	}
 	defer delete_poll_stmt.Close()
 
 	res, err := delete_poll_stmt.Exec(question)
 	if err != nil {
-		log.Fatal(err)
+		log.Printf("%s", err.Error())
 		return err
 	}
 
 	if num, err := res.RowsAffected(); num != 1 {
 		return ErrFailedToDeletePoll
 	} else if err != nil {
-		log.Fatal(err)
+		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
+	}
+
+	return nil
+}

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

@@ -13,8 +13,8 @@ import (
 
 const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-=`~!@#$%^&*()_+[]\\;',./{}|:\"<>?"
 
-var new_members = []struct{
-	email string
+var new_members = []struct {
+	email       string
 	member_name string
 }{
 	{"test1@mail.me", "test1"},
@@ -32,20 +32,20 @@ var new_members = []struct{
 	{"test105@mail.me", "test105"},
 }
 
-var new_polls = []struct{
-	question string
-	member_yes_votes int64
-	member_no_votes int64
+var new_polls = []struct {
+	question             string
+	member_yes_votes     int64
+	member_no_votes      int64
 	non_member_yes_votes int64
-	non_member_no_votes int64
+	non_member_no_votes  int64
 }{
 	{"ques1", 1, 2, 3, 4},
 	{"ques2", 3, 2, 4, 5},
 	{"ques3", 4, 3, 6, 5},
 }
 
-var new_voters = []struct{
-	poll_id int64
+var new_voters = []struct {
+	poll_id     int64
 	voter_email string
 }{
 	{1, "test1@mail.me"},
@@ -117,7 +117,7 @@ func PreLoadDB() error {
 
 	// Insert polls
 	for i := range new_polls {
-		result, err := db_conn.Exec(`INSERT INTO polls (question, member_yes_votes, member_no_votes, non_member_yes_votes, non_member_no_votes, expires_at) VALUES (?, ?, ?, ?, ?, ?)`, new_polls[i].question, new_polls[i].member_yes_votes, new_polls[i].member_no_votes, new_polls[i].non_member_yes_votes, new_polls[i].non_member_no_votes, time.Now().Add(time.Hour * 10).Format("2006-01-02 15:04:05"))
+		result, err := db_conn.Exec(`INSERT INTO polls (question, member_yes_votes, member_no_votes, non_member_yes_votes, non_member_no_votes, expires_at) VALUES (?, ?, ?, ?, ?, ?)`, new_polls[i].question, new_polls[i].member_yes_votes, new_polls[i].member_no_votes, new_polls[i].non_member_yes_votes, new_polls[i].non_member_no_votes, time.Now().Add(time.Hour*10).Format("2006-01-02 15:04:05"))
 		if err != nil {
 			return err
 		}
@@ -139,8 +139,8 @@ func PreLoadDB() error {
 }
 
 func TestCreatePoll(t *testing.T) {
-	parameters := []struct{
-		question string
+	parameters := []struct {
+		question    string
 		table_index int64
 	}{
 		{RandString(10) + "1", 1},
@@ -165,29 +165,29 @@ func TestCreatePoll(t *testing.T) {
 
 	defer os.Remove(tmp_db.Name())
 	tmp_db.Close()
-	
+
 	if _, err := db.Connect(); err != nil {
 		t.Errorf(`Failed to create the database: %v`, err)
 	}
 
 	for i := range parameters {
 		create_poll := &models.Poll{
-			Question: parameters[i].question,
+			Question:  parameters[i].question,
 			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)
 		}
 	}
 }
@@ -207,30 +207,30 @@ func TestAlreadyExists(t *testing.T) {
 
 	defer os.Remove(tmp_db.Name())
 	tmp_db.Close()
-	
+
 	if _, err := db.Connect(); err != nil {
 		t.Errorf(`Failed to create the database: %v`, err)
 	}
 
 	create_poll := &models.Poll{
-		Question: question,
+		Question:  question,
 		ExpiresAt: time.Now().Add(time.Hour * 10).Format("2006-01-02 15:04:05"),
 	}
 
 	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)
 	}
 }
 
@@ -249,40 +249,40 @@ func TestGetPollByQuestion(t *testing.T) {
 
 	defer os.Remove(tmp_db.Name())
 	tmp_db.Close()
-	
+
 	if _, err := db.Connect(); err != nil {
 		t.Errorf(`Failed to create the database: %v`, err)
 	}
 
 	create_poll := &models.Poll{
-		Question: question,
+		Question:  question,
 		ExpiresAt: time.Now().Add(time.Hour * 10).Format("2006-01-02 15:04:05"),
 	}
 
 	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)
 	}
 }
 
 func TestGetCreatePollByQuestion(t *testing.T) {
-	parameters := []struct{
-		question string
+	parameters := []struct {
+		question    string
 		table_index int64
 	}{
 		{RandString(10) + "1", 1},
@@ -305,7 +305,7 @@ func TestGetCreatePollByQuestion(t *testing.T) {
 
 	defer os.Remove(tmp_db.Name())
 	tmp_db.Close()
-	
+
 	if _, err := db.Connect(); err != nil {
 		t.Errorf(`Failed to create the database: %v`, err)
 	}
@@ -314,184 +314,184 @@ 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)
 		}
 	}
 }
 
 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)
-    }
-    defer os.Remove(tmp_db.Name())
+	// Preload the database with members, polls, and voters
+	tmp_db, err := os.CreateTemp("", "vote_test.*.db")
+	if err != nil {
+		t.Errorf("Failed to create temporary database: %v", err)
+	}
+	defer os.Remove(tmp_db.Name())
 
-    init_conf := &config.Config{
-        DBPath: string(tmp_db.Name()),
-    }
-    config.SetConfig(init_conf)
+	init_conf := &config.Config{
+		DBPath: string(tmp_db.Name()),
+	}
+	config.SetConfig(init_conf)
 
-    err = PreLoadDB()
-    if err != nil {
-        t.Fatalf("Failed to preload database: %v", err)
-    }
+	err = PreLoadDB()
+	if err != nil {
+		t.Errorf("Failed to preload database: %v", err)
+	}
 
-    // Add a non-member vote
-    random_email := RandString(10) + "@mail.me"
-    vote := &models.Vote{
-        PollId: 1,
-        Email: random_email,
-        Vote: true,
-    }
-    err = SetVote(vote)
-    if err != nil {
-        t.Fatalf("Failed to set non-member vote: %v", err)
-    }
+	// Add a non-member vote
+	random_email := RandString(10) + "@mail.me"
+	vote := &models.Vote{
+		PollId: 1,
+		Email:  random_email,
+		Vote:   true,
+	}
+	err = SetVote(vote)
+	if err != nil {
+		t.Errorf("Failed to set non-member vote: %v", err)
+	}
 
-    // Add a member vote
-    member_email := "test100@mail.me"
-    vote = &models.Vote{
-        PollId: 1,
-        Email: member_email,
-        Vote: true,
-    }
-    err = SetVote(vote)
-    if err != nil {
-        t.Fatalf("Failed to set member vote: %v", err)
-    }
+	// Add a member vote
+	member_email := "test100@mail.me"
+	vote = &models.Vote{
+		PollId: 1,
+		Email:  member_email,
+		Vote:   true,
+	}
+	err = SetVote(vote)
+	if err != nil {
+		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)
-    }
+	// Verify the votes were added correctly
+	voters, err := models.GetVoters(1) // Use GetVoters from models
+	if err != nil {
+		t.Errorf("Failed to get voters: %v", err)
+	}
 
-    expected_non_member_votes := 4 + 1 // Original non-member votes + new non-member vote
-    expected_member_votes := 3 + 1    // Original member votes + new member vote
+	expected_non_member_votes := 4 + 1 // Original non-member votes + new non-member vote
+	expected_member_votes := 3 + 1     // Original member votes + new member vote
 
-    for _, voter := range voters {
-        if voter.Email == random_email && voter.YesVote {
-            expected_non_member_votes--
-        } else if voter.Email == member_email && voter.YesVote {
-            expected_member_votes--
-        }
-    }
+	for _, voter := range voters {
+		if voter.Email == random_email && voter.YesVote {
+			expected_non_member_votes--
+		} else if voter.Email == member_email && voter.YesVote {
+			expected_member_votes--
+		}
+	}
 
-    if expected_non_member_votes != 5 || expected_member_votes != 4 {
-        t.Errorf("Expected %d non-member votes and %d member votes, but got %d non-member votes and %d member votes", 4+1, 3+1, expected_non_member_votes, expected_member_votes)
-    }
+	if expected_non_member_votes != 5 || expected_member_votes != 4 {
+		t.Errorf("Expected %d non-member votes and %d member votes, but got %d non-member votes and %d member votes", 4+1, 3+1, expected_non_member_votes, expected_member_votes)
+	}
 }
 
 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)
-    }
-    defer os.Remove(tmp_db.Name())
+	// Preload the database with members, polls, and voters
+	tmp_db, err := os.CreateTemp("", "vote_test.*.db")
+	if err != nil {
+		t.Errorf("Failed to create temporary database: %v", err)
+	}
+	defer os.Remove(tmp_db.Name())
 
-    init_conf := &config.Config{
-        DBPath: string(tmp_db.Name()),
-    }
-    config.SetConfig(init_conf)
+	init_conf := &config.Config{
+		DBPath: string(tmp_db.Name()),
+	}
+	config.SetConfig(init_conf)
 
-    err = PreLoadDB()
-    if err != nil {
-        t.Fatalf("Failed to preload database: %v", err)
-    }
+	err = PreLoadDB()
+	if err != nil {
+		t.Errorf("Failed to preload database: %v", err)
+	}
 
-    // Add a non-member vote
-    random_email := RandString(10) + "@mail.me"
-    vote := &models.Vote{
-        PollId: 1,
-        Email: random_email,
-        Vote: true,
-    }
-    err = SetVote(vote)
-    if err != nil {
-        t.Fatalf("Failed to set non-member vote: %v", err)
-    }
+	// Add a non-member vote
+	random_email := RandString(10) + "@mail.me"
+	vote := &models.Vote{
+		PollId: 1,
+		Email:  random_email,
+		Vote:   true,
+	}
+	err = SetVote(vote)
+	if err != nil {
+		t.Errorf("Failed to set non-member vote: %v", err)
+	}
 
-    // Add a member vote
-    member_email := "test100@mail.me"
-    vote = &models.Vote{
-        PollId: 1,
-        Email: member_email,
-        Vote: true,
-    }
-    err = SetVote(vote)
-    if err != nil {
-        t.Fatalf("Failed to set member vote: %v", err)
-    }
+	// Add a member vote
+	member_email := "test100@mail.me"
+	vote = &models.Vote{
+		PollId: 1,
+		Email:  member_email,
+		Vote:   true,
+	}
+	err = SetVote(vote)
+	if err != nil {
+		t.Errorf("Failed to set member vote: %v", err)
+	}
 
-    // Attempt to add another non-member vote
-    vote = &models.Vote{
-        PollId: 1,
-        Email: random_email,
-        Vote: true,
-    }
-    err = SetVote(vote)
-    if err != ErrVoterAlreadyVoted {
-        t.Fatalf("Expected ErrVoterAlreadyVoted, but got %v", err)
-    }
+	// Attempt to add another non-member vote
+	vote = &models.Vote{
+		PollId: 1,
+		Email:  random_email,
+		Vote:   true,
+	}
+	err = SetVote(vote)
+	if err != ErrVoterAlreadyVoted {
+		t.Errorf("Expected ErrVoterAlreadyVoted, but got %v", err)
+	}
 
-    // Attempt to add another member vote
-    vote = &models.Vote{
-        PollId: 1,
-        Email: member_email,
-        Vote: true,
-    }
-    err = SetVote(vote)
-    if err != ErrVoterAlreadyVoted {
-        t.Fatalf("Expected ErrVoterAlreadyVoted, but got %v", err)
-    }
+	// Attempt to add another member vote
+	vote = &models.Vote{
+		PollId: 1,
+		Email:  member_email,
+		Vote:   true,
+	}
+	err = SetVote(vote)
+	if err != ErrVoterAlreadyVoted {
+		t.Errorf("Expected ErrVoterAlreadyVoted, but got %v", err)
+	}
 }
 
 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)
-    }
-    defer os.Remove(tmp_db.Name())
+	// Preload the database with members, polls, and voters
+	tmp_db, err := os.CreateTemp("", "vote_test.*.db")
+	if err != nil {
+		t.Errorf("Failed to create temporary database: %v", err)
+	}
+	defer os.Remove(tmp_db.Name())
 
-    init_conf := &config.Config{
-        DBPath: string(tmp_db.Name()),
-    }
-    config.SetConfig(init_conf)
+	init_conf := &config.Config{
+		DBPath: string(tmp_db.Name()),
+	}
+	config.SetConfig(init_conf)
 
-    err = PreLoadDB()
-    if err != nil {
-        t.Fatalf("Failed to preload database: %v", err)
-    }
+	err = PreLoadDB()
+	if err != nil {
+		t.Errorf("Failed to preload database: %v", err)
+	}
 
-    // Get a question from the new_polls array
-    testQuestion := new_polls[0].question
+	// Get a question from the new_polls array
+	testQuestion := new_polls[0].question
 
-    // Delete the poll by question
-    err = DeletePollByQuestion(testQuestion)
-    if err != nil {
-        t.Fatalf("Failed to delete poll by question: %v", err)
-    }
+	// Delete the poll by question
+	err = DeletePollByQuestion(testQuestion)
+	if err != nil {
+		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")
-    } else if err != ErrPollNotFound {
-        t.Fatalf("Expected ErrPollNotFound, but got %v", err)
-    }
-}
+	// Verify that the poll was deleted
+	_, err = GetPollByQuestion(testQuestion)
+	if err == nil {
+		t.Errorf("Expected error when getting deleted poll, but got none")
+	} else if err != ErrPollNotFound {
+		t.Errorf("Expected ErrPollNotFound, but got %v", err)
+	}
+}