ictgj-voting/admin_votes.go

172 lines
3.9 KiB
Go

package main
import (
"errors"
"net/http"
"time"
"github.com/gorilla/mux"
)
type Ranking struct {
Rank int
Teams []Team
}
// getCondorcetResult returns the ranking of teams based on the condorcet method
// https://en.wikipedia.org/wiki/Condorcet_method
func getCondorcetResult() []Ranking {
type teamPair struct {
winner *Team
loser *Team
majority float32
}
var allPairs []teamPair
var ret []Ranking
for i := 0; i < len(m.jam.Teams); i++ {
for j := i + 1; j < len(m.jam.Teams); j++ {
// For each pairing find a winner
winner, pct, _ := findWinnerBetweenTeams(&m.jam.Teams[i], &m.jam.Teams[j])
newPair := new(teamPair)
if winner != nil {
newPair.winner = winner
if winner.UUID == m.jam.Teams[i].UUID {
newPair.loser = &m.jam.Teams[j]
} else {
newPair.loser = &m.jam.Teams[i]
}
newPair.majority = pct
} else {
newPair.winner = &m.jam.Teams[i]
newPair.loser = &m.jam.Teams[j]
newPair.majority = 50
}
allPairs = append(allPairs, *newPair)
}
}
// initialize map of team wins
teamWins := make(map[string]int)
for i := range m.jam.Teams {
teamWins[m.jam.Teams[i].UUID] = 0
}
// Figure out how many wins each team has
for i := range allPairs {
if allPairs[i].majority != 50 {
teamWins[allPairs[i].winner.UUID]++
}
}
// Rank them by wins
rankedWins := make(map[int][]string)
for k, v := range teamWins {
rankedWins[v] = append(rankedWins[v], k)
}
currRank := 1
for len(rankedWins) > 0 {
topWins := 0
for k, _ := range rankedWins {
if k > topWins {
topWins = k
}
}
nR := new(Ranking)
nR.Rank = currRank
for i := range rankedWins[topWins] {
tm, _ := m.jam.GetTeamById(rankedWins[topWins][i])
if tm != nil {
nR.Teams = append(nR.Teams, *tm)
}
}
ret = append(ret, *nR)
delete(rankedWins, topWins)
currRank++
}
return ret
}
// This is a helper function for calculating results
func uuidIsInRankingSlice(uuid string, sl []Ranking) bool {
for _, v := range sl {
for i := range v.Teams {
if v.Teams[i].UUID == uuid {
return true
}
}
}
return false
}
// findWinnerBetweenTeams returns the team that got the most votes
// and the percentage of votes they received
// or an error if a winner couldn't be determined.
func findWinnerBetweenTeams(tm1, tm2 *Team) (*Team, float32, error) {
// tally gets incremented for a tm1 win, decremented for a tm2 win
var tm1votes, tm2votes float32
for _, v := range m.jam.Votes {
for _, chc := range v.Choices {
if chc.Team == tm1.UUID {
tm1votes++
break
} else if chc.Team == tm2.UUID {
tm2votes++
break
}
}
}
ttlVotes := tm1votes + tm2votes
if tm1votes > tm2votes {
return tm1, 100 * (tm1votes / ttlVotes), nil
} else if tm1votes < tm2votes {
return tm2, 100 * (tm2votes / ttlVotes), nil
}
return nil, 50, errors.New("Unable to determine a winner")
}
func getInstantRunoffResult() []Team {
var ret []Team
return ret
}
func handleAdminVotes(w http.ResponseWriter, req *http.Request, page *pageData) {
vars := mux.Vars(req)
page.SubTitle = "Votes"
type vpdVote struct {
Timestamp string
ClientId string
Choices []Team
}
type votePageData struct {
AllVotes []vpdVote
Results []Ranking
}
vpd := new(votePageData)
now := time.Now()
dayThresh := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
for i := range m.jam.Votes {
v := new(vpdVote)
if m.jam.Votes[i].Timestamp.Before(dayThresh) {
v.Timestamp = m.jam.Votes[i].Timestamp.Format("Jan _2 15:04")
} else {
v.Timestamp = m.jam.Votes[i].Timestamp.Format(time.Kitchen)
}
v.ClientId = m.jam.Votes[i].ClientId
for _, choice := range m.jam.Votes[i].Choices {
for _, fndTm := range m.jam.Teams {
if fndTm.UUID == choice.Team {
v.Choices = append(v.Choices, fndTm)
break
}
}
}
vpd.AllVotes = append(vpd.AllVotes, *v)
}
vpd.Results = getCondorcetResult()
page.TemplateData = vpd
switch vars["function"] {
default:
page.show("admin-votes.html", w)
}
}