Show playoff alliance numbers and 4th teams on Match Play screen.

model/alliance_team.go

@@ -72,3 +72,42 @@ func (database *Database) GetAllAlliances() ([][]AllianceTeam, error) {
 	}
 	return alliances, nil
 }
+
+// Returns two arrays containing the IDs of any teams for the red and blue alliances, respectively, who are part of the
+// elimination alliance but are not playing in the given match.
+// If the given match isn't an elimination match, empty arrays are returned.
+func (database *Database) GetOffFieldTeamIds(match *Match) ([]int, []int, error) {
+	redOffFieldTeams, err := database.getOffFieldTeamIdsForAlliance(
+		match.ElimRedAlliance, match.Red1, match.Red2, match.Red3,
+	)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	blueOffFieldTeams, err := database.getOffFieldTeamIdsForAlliance(
+		match.ElimBlueAlliance, match.Blue1, match.Blue2, match.Blue3,
+	)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return redOffFieldTeams, blueOffFieldTeams, nil
+}
+
+func (database *Database) getOffFieldTeamIdsForAlliance(allianceId int, teamId1, teamId2, teamId3 int) ([]int, error) {
+	if allianceId == 0 {
+		return []int{}, nil
+	}
+
+	allianceTeams, err := database.GetTeamsByAlliance(allianceId)
+	if err != nil {
+		return nil, err
+	}
+	offFieldTeamIds := []int{}
+	for _, allianceTeam := range allianceTeams {
+		if allianceTeam.TeamId != teamId1 && allianceTeam.TeamId != teamId2 && allianceTeam.TeamId != teamId3 {
+			offFieldTeamIds = append(offFieldTeamIds, allianceTeam.TeamId)
+		}
+	}
+	return offFieldTeamIds, nil
+}

model/alliance_team_test.go

@@ -48,17 +48,19 @@ func TestGetTeamsByAlliance(t *testing.T) {
 	BuildTestAlliances(db)
 	allianceTeams, err := db.GetTeamsByAlliance(1)
 	assert.Nil(t, err)
-	if assert.Equal(t, 4, len(allianceTeams)) {
+	if assert.Equal(t, 5, len(allianceTeams)) {
 		assert.Equal(t, 254, allianceTeams[0].TeamId)
 		assert.Equal(t, 469, allianceTeams[1].TeamId)
 		assert.Equal(t, 2848, allianceTeams[2].TeamId)
 		assert.Equal(t, 74, allianceTeams[3].TeamId)
+		assert.Equal(t, 3175, allianceTeams[4].TeamId)
 	}
 	allianceTeams, err = db.GetTeamsByAlliance(2)
 	assert.Nil(t, err)
-	if assert.Equal(t, 2, len(allianceTeams)) {
+	if assert.Equal(t, 3, len(allianceTeams)) {
 		assert.Equal(t, 1718, allianceTeams[0].TeamId)
 		assert.Equal(t, 2451, allianceTeams[1].TeamId)
+		assert.Equal(t, 1619, allianceTeams[2].TeamId)
 	}
 }
 
@@ -86,15 +88,68 @@ func TestGetAllAlliances(t *testing.T) {
 	alliances, err = db.GetAllAlliances()
 	assert.Nil(t, err)
 	if assert.Equal(t, 2, len(alliances)) {
-		if assert.Equal(t, 4, len(alliances[0])) {
+		if assert.Equal(t, 5, len(alliances[0])) {
 			assert.Equal(t, 254, alliances[0][0].TeamId)
 			assert.Equal(t, 469, alliances[0][1].TeamId)
 			assert.Equal(t, 2848, alliances[0][2].TeamId)
 			assert.Equal(t, 74, alliances[0][3].TeamId)
+			assert.Equal(t, 3175, alliances[0][4].TeamId)
 		}
-		if assert.Equal(t, 2, len(alliances[1])) {
+		if assert.Equal(t, 3, len(alliances[1])) {
 			assert.Equal(t, 1718, alliances[1][0].TeamId)
 			assert.Equal(t, 2451, alliances[1][1].TeamId)
+			assert.Equal(t, 1619, alliances[1][2].TeamId)
 		}
 	}
 }
+
+func TestGetOffFieldTeamIds(t *testing.T) {
+	db := setupTestDb(t)
+	defer db.Close()
+	BuildTestAlliances(db)
+
+	match := &Match{
+		ElimRedAlliance:  1,
+		ElimBlueAlliance: 2,
+		Red1:             469,
+		Red2:             254,
+		Red3:             2848,
+		Blue1:            1619,
+		Blue2:            1718,
+		Blue3:            2451,
+	}
+
+	redOffFieldTeams, blueOffFieldTeams, err := db.GetOffFieldTeamIds(match)
+	assert.Nil(t, err)
+	assert.Equal(t, []int{74, 3175}, redOffFieldTeams)
+	assert.Equal(t, []int{}, blueOffFieldTeams)
+
+	match.Red1 = 74
+	match.Red2 = 3175
+	redOffFieldTeams, blueOffFieldTeams, err = db.GetOffFieldTeamIds(match)
+	assert.Nil(t, err)
+	assert.Equal(t, []int{254, 469}, redOffFieldTeams)
+	assert.Equal(t, []int{}, blueOffFieldTeams)
+
+	match.ElimRedAlliance = 0
+	match.ElimBlueAlliance = 0
+	redOffFieldTeams, blueOffFieldTeams, err = db.GetOffFieldTeamIds(match)
+	assert.Nil(t, err)
+	assert.Equal(t, []int{}, redOffFieldTeams)
+	assert.Equal(t, []int{}, blueOffFieldTeams)
+
+	match = &Match{
+		ElimRedAlliance:  2,
+		ElimBlueAlliance: 1,
+		Red1:             1718,
+		Red2:             2451,
+		Red3:             1619,
+		Blue1:            3175,
+		Blue2:            74,
+		Blue3:            2848,
+	}
+	redOffFieldTeams, blueOffFieldTeams, err = db.GetOffFieldTeamIds(match)
+	assert.Nil(t, err)
+	assert.Equal(t, []int{}, redOffFieldTeams)
+	assert.Equal(t, []int{254, 469}, blueOffFieldTeams)
+}

model/test_helpers.go

@@ -36,5 +36,7 @@ func BuildTestAlliances(database *Database) {
 	database.CreateAllianceTeam(&AllianceTeam{0, 1, 1, 469})
 	database.CreateAllianceTeam(&AllianceTeam{0, 1, 0, 254})
 	database.CreateAllianceTeam(&AllianceTeam{0, 1, 2, 2848})
+	database.CreateAllianceTeam(&AllianceTeam{0, 2, 2, 1619})
 	database.CreateAllianceTeam(&AllianceTeam{0, 2, 1, 2451})
+	database.CreateAllianceTeam(&AllianceTeam{0, 1, 4, 3175})
 }

partner/tba_test.go

@@ -96,8 +96,11 @@ func TestPublishAlliances(t *testing.T) {
 	tbaServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		var reader bytes.Buffer
 		reader.ReadFrom(r.Body)
-		assert.Equal(t, "[[\"frc254\",\"frc469\",\"frc2848\",\"frc74\"],[\"frc1718\",\"frc2451\"]]",
-			reader.String())
+		assert.Equal(
+			t,
+			"[[\"frc254\",\"frc469\",\"frc2848\",\"frc74\",\"frc3175\"],[\"frc1718\",\"frc2451\",\"frc1619\"]]",
+			reader.String(),
+		)
 	}))
 	defer tbaServer.Close()
 	client := NewTbaClient("my_event_code", "my_secret_id", "my_secret")

templates/match_play.html

@@ -73,6 +73,14 @@
         {{template "matchPlayTeam" dict "team" .Match.Blue1 "color" "B" "position" 1 "data" .}}
         {{template "matchPlayTeam" dict "team" .Match.Blue2 "color" "B" "position" 2 "data" .}}
         {{template "matchPlayTeam" dict "team" .Match.Blue3 "color" "B" "position" 3 "data" .}}
+        {{if eq .Match.Type "elimination" }}
+          <div>
+            <b>Alliance {{.Match.ElimBlueAlliance}}</b>
+            {{if .BlueOffFieldTeams}}
+              (not on field: {{range $i, $team := .BlueOffFieldTeams}}{{if $i}}, {{end}}{{$team}}{{end}})
+            {{end}}
+          </div>
+        {{end}}
       </div>
       <div class="col-lg-6 well well-darkred status-well">
         <div class="row form-group">
@@ -85,6 +93,14 @@
         {{template "matchPlayTeam" dict "team" .Match.Red3 "color" "R" "position" 3 "data" .}}
         {{template "matchPlayTeam" dict "team" .Match.Red2 "color" "R" "position" 2 "data" .}}
         {{template "matchPlayTeam" dict "team" .Match.Red1 "color" "R" "position" 1 "data" .}}
+        {{if eq .Match.Type "elimination" }}
+        <div>
+          <b>Alliance {{.Match.ElimRedAlliance}}</b>
+          {{if .RedOffFieldTeams}}
+            (not on field: {{range $i, $team := .RedOffFieldTeams}}{{if $i}}, {{end}}{{$team}}{{end}})
+          {{end}}
+        </div>
+        {{end}}
       </div>
     </div>
     <div class="row text-center">

web/api_test.go

@@ -113,15 +113,17 @@ func TestAlliancesApi(t *testing.T) {
 	err := json.Unmarshal([]byte(recorder.Body.String()), &alliances)
 	assert.Nil(t, err)
 	if assert.Equal(t, 2, len(alliances)) {
-		if assert.Equal(t, 4, len(alliances[0])) {
+		if assert.Equal(t, 5, len(alliances[0])) {
 			assert.Equal(t, 254, alliances[0][0].TeamId)
 			assert.Equal(t, 469, alliances[0][1].TeamId)
 			assert.Equal(t, 2848, alliances[0][2].TeamId)
 			assert.Equal(t, 74, alliances[0][3].TeamId)
+			assert.Equal(t, 3175, alliances[0][4].TeamId)
 		}
-		if assert.Equal(t, 2, len(alliances[1])) {
+		if assert.Equal(t, 3, len(alliances[1])) {
 			assert.Equal(t, 1718, alliances[1][0].TeamId)
 			assert.Equal(t, 2451, alliances[1][1].TeamId)
+			assert.Equal(t, 1619, alliances[1][2].TeamId)
 		}
 	}
 }

web/match_play.go

@@ -65,6 +65,11 @@ func (web *Web) matchPlayHandler(w http.ResponseWriter, r *http.Request) {
 	if currentMatchType == "test" {
 		currentMatchType = "practice"
 	}
+	redOffFieldTeams, blueOffFieldTeams, err := web.arena.Database.GetOffFieldTeamIds(web.arena.CurrentMatch)
+	if err != nil {
+		handleWebErr(w, err)
+		return
+	}
 	matchResult, err := web.arena.Database.GetMatchResultForMatch(web.arena.CurrentMatch.Id)
 	if err != nil {
 		handleWebErr(w, err)
@@ -77,14 +82,27 @@ func (web *Web) matchPlayHandler(w http.ResponseWriter, r *http.Request) {
 		MatchesByType         map[string]MatchPlayList
 		CurrentMatchType      string
 		Match                 *model.Match
+		RedOffFieldTeams      []int
+		BlueOffFieldTeams     []int
 		RedScore              *game.Score
 		BlueScore             *game.Score
 		AllowSubstitution     bool
 		IsReplay              bool
 		PlcArmorBlockStatuses map[string]bool
-	}{web.arena.EventSettings, web.arena.Plc.IsEnabled(), matchesByType, currentMatchType, web.arena.CurrentMatch,
-		web.arena.RedScore, web.arena.BlueScore,
-		web.arena.CurrentMatch.ShouldAllowSubstitution(), isReplay, web.arena.Plc.GetArmorBlockStatuses()}
+	}{
+		web.arena.EventSettings,
+		web.arena.Plc.IsEnabled(),
+		matchesByType,
+		currentMatchType,
+		web.arena.CurrentMatch,
+		redOffFieldTeams,
+		blueOffFieldTeams,
+		web.arena.RedScore,
+		web.arena.BlueScore,
+		web.arena.CurrentMatch.ShouldAllowSubstitution(),
+		isReplay,
+		web.arena.Plc.GetArmorBlockStatuses(),
+	}
 	err = template.ExecuteTemplate(w, "base", data)
 	if err != nil {
 		handleWebErr(w, err)