go-sjles-pta-vote/server/services/poll.go

package services

import (
	"database/sql"
	"errors"
	"time"

	"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")

func CreatePoll(poll *models.Poll) (*models.Poll, error) {
	new_poll := models.Poll{}

	db_conn, err := db.Connect()
	if err != nil {
		return nil, err
	}
	defer db.Close()

	get_stmt, err := db_conn.Prepare(`
		SELECT id 
			FROM polls 
			WHERE question == $1
	`)
	if err != nil {
		return nil, 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
		}
		return nil, ErrQuestionAlreadyExists
	}
	
	stmt, err := db_conn.Prepare(`
		INSERT INTO polls (
			question,
			expires_at
		) VALUES (
		 	$1,
			$2
		) RETURNING ID;
	`)

	if err != nil {
		return nil, err
	}

	defer stmt.Close()

	res, err := stmt.Exec(poll.Question, poll.ExpiresAt)
	if err != nil {
		return nil, err
	}

	new_poll.ID, err = res.LastInsertId()
	
	return &new_poll, err
}

func GetPollByQuestion(question string) (*models.Poll, error) {
	new_poll := models.Poll{}

	db_conn, err := db.Connect()
	if err != nil {
		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 question == $1
	`)
	if err != nil {
		return nil, err
	}
	defer get_poll_stmt.Close()

	err = get_poll_stmt.QueryRow(question).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 {
		return nil, err
	}

	get_voters_stmt, err := db_conn.Prepare (`
		SELECT voter_email 
		FROM voters
		WHERE poll_id == $1
	`)
	if err != nil {
		return nil, err
	}
	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 {
			return nil, err
		}
		new_poll.WhoVoted = append(new_poll.WhoVoted, voter_email)
	}

	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"),
		}

		if _, err = CreatePoll(create_poll); err != nil {
			return nil, err
		}

		return GetPollByQuestion(question)
	} else if err != nil {
		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 {
		return err
	}
	defer db.Close()

	set_voter_stmt, err := db_conn.Prepare(`
		INSERT OR IGNORE INTO voters
			(poll_id, voter_email)
		VALUES ($1, $2)
	`)
	if err != nil {
		return err
	}
	defer set_voter_stmt.Close()

	res, err := set_voter_stmt.Exec(vote.PollId, vote.Email)
	if err != nil {
		return err
	} else {
		rows_changed, err := res.RowsAffected()
		if rows_changed != 1 {
			return ErrVoterAlreadyVoted
		} else if err != nil {
			return err
		}
	}

	is_voter_member_stmt, err := db_conn.Prepare(`
		SELECT 1
		FROM members
		WHERE email == $1
	`)
	if err != nil {
		return err
	}
	defer is_voter_member_stmt.Close()

	var member_check int64
	is_member := true
	err = is_voter_member_stmt.QueryRow(vote.Email).Scan(&member_check)
	if err == sql.ErrNoRows {
		is_member = false
	} else if err != nil {
		return err
	}

	// Member column name is not dependant on user input
	//	So it's ok to put it directly in the query
	member_column_name := "member_"
	if !is_member {
		member_column_name = "non_" + member_column_name
	}

	if vote.Vote {
		member_column_name += "yes_votes"
	} else {
		member_column_name += "no_votes"
	}

	add_vote_stmt, err := db_conn.Prepare(`
		UPDATE polls
		SET ` + member_column_name + ` = ` + member_column_name + ` + 1
		WHERE id == $1
	`)
	if err != nil {
		return err
	}
	defer add_vote_stmt.Close()

	res, err = add_vote_stmt.Exec(vote.PollId)
	if err != nil {
		return err
	}

	if num, err := res.RowsAffected(); num != 1 {
		return errors.New("Failed to update votes")
	} else if err != nil {
		return err
	}

	return nil
}

// Delete a poll by name
func DeletePollByQuestion(question string) error {
	db_conn, err := db.Connect()
	if err != nil {
		return err
	}
	defer db.Close()

	delete_votes_stmt, err := db_conn.Prepare(`
		DELETE FROM voters
		WHERE poll_id IN (
			SELECT id 
			FROM polls 
			WHERE question == $1
		)
	`)
	if err != nil {
		return err
	}
	defer delete_votes_stmt.Close()

	_, err = delete_votes_stmt.Exec(question)
	if err != nil {
		return err
	}

	delete_poll_stmt, err := db_conn.Prepare(`
		DELETE FROM polls
		WHERE question == $1
	`)
	if err != nil {
		return err
	}
	defer delete_poll_stmt.Close()

	res, err := delete_poll_stmt.Exec(question)
	if err != nil {
		return err
	}

	if num, err := res.RowsAffected(); num != 1 {
		return errors.New("Failed to delete poll")
	} else if err != nil {
		return err
	}

	return nil
}