539 lines
11 KiB
Go
539 lines
11 KiB
Go
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")
|
|
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 (
|
|
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 {
|
|
log.Printf("Failed to connect to database: %s", err.Error())
|
|
return -1, err
|
|
}
|
|
defer db.Close()
|
|
|
|
get_stmt, err := db_conn.Prepare(`
|
|
SELECT id
|
|
FROM polls
|
|
WHERE question == $1
|
|
`)
|
|
if err != nil {
|
|
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 != nil {
|
|
if err != sql.ErrNoRows {
|
|
log.Printf("%s", err.Error())
|
|
return -1, err
|
|
}
|
|
return -1, ErrQuestionAlreadyExists
|
|
}
|
|
|
|
stmt, err := db_conn.Prepare(`
|
|
INSERT INTO polls (
|
|
question,
|
|
expires_at
|
|
) VALUES (
|
|
$1,
|
|
$2
|
|
) RETURNING ID;
|
|
`)
|
|
|
|
if err != nil {
|
|
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
|
|
}
|
|
|
|
polls = append(polls, new_poll)
|
|
}
|
|
|
|
return polls, nil
|
|
}
|
|
|
|
func GetPollByQuestion(question string) (*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 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,
|
|
&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
|
|
}
|
|
|
|
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 {
|
|
log.Printf("%s", err.Error())
|
|
return nil, err
|
|
}
|
|
new_poll.WhoVoted = append(new_poll.WhoVoted, voter_email)
|
|
}
|
|
|
|
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(common.DATE_FORMAT),
|
|
}
|
|
|
|
if _, err = CreatePoll(create_poll); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return GetPollByQuestion(question)
|
|
} else if err != nil {
|
|
log.Printf("%s", err.Error())
|
|
return nil, err
|
|
} else {
|
|
return new_poll, err
|
|
}
|
|
}
|
|
|
|
func SetVote(vote *models.Vote) error {
|
|
db_conn, err := db.Connect()
|
|
if err != nil {
|
|
log.Printf("%s", err.Error())
|
|
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 {
|
|
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
|
|
}
|
|
}
|
|
|
|
is_voter_member_stmt, err := db_conn.Prepare(`
|
|
SELECT 1
|
|
FROM members
|
|
WHERE email == $1
|
|
`)
|
|
if err != nil {
|
|
log.Printf("%s", err.Error())
|
|
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 {
|
|
log.Printf("%s", err.Error())
|
|
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 {
|
|
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 ErrFailedToUpdateVote
|
|
} else if err != nil {
|
|
log.Printf("%s", err.Error())
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Delete a poll by name
|
|
func DeletePollByQuestion(question string) error {
|
|
db_conn, err := db.Connect()
|
|
if err != nil {
|
|
log.Printf("%s", err.Error())
|
|
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 {
|
|
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
|
|
}
|
|
|
|
delete_poll_stmt, err := db_conn.Prepare(`
|
|
DELETE FROM polls
|
|
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 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
|
|
}
|
|
|
|
return nil
|
|
}
|