Add awards management and automatic lower third creation.

model/award.go

@@ -0,0 +1,62 @@
+// Copyright 2019 Team 254. All Rights Reserved.
+// Author: pat@patfairbank.com (Patrick Fairbank)
+//
+// Model and datastore CRUD methods for an award.
+
+package model
+
+type Award struct {
+	Id         int
+	Type       AwardType
+	AwardName  string
+	TeamId     int
+	PersonName string
+}
+
+type AwardType int
+
+const (
+	JudgedAward AwardType = iota
+	FinalistAward
+	WinnerAward
+)
+
+func (database *Database) CreateAward(award *Award) error {
+	return database.awardMap.Insert(award)
+}
+
+func (database *Database) GetAwardById(id int) (*Award, error) {
+	award := new(Award)
+	err := database.awardMap.Get(award, id)
+	if err != nil && err.Error() == "sql: no rows in result set" {
+		award = nil
+		err = nil
+	}
+	return award, err
+}
+
+func (database *Database) SaveAward(award *Award) error {
+	_, err := database.awardMap.Update(award)
+	return err
+}
+
+func (database *Database) DeleteAward(award *Award) error {
+	_, err := database.awardMap.Delete(award)
+	return err
+}
+
+func (database *Database) TruncateAwards() error {
+	return database.awardMap.TruncateTables()
+}
+
+func (database *Database) GetAllAwards() ([]Award, error) {
+	var awards []Award
+	err := database.awardMap.Select(&awards, "SELECT * FROM awards ORDER BY id")
+	return awards, err
+}
+
+func (database *Database) GetAwardsByType(awardType AwardType) ([]Award, error) {
+	var awards []Award
+	err := database.awardMap.Select(&awards, "SELECT * FROM awards WHERE type = ? ORDER BY id", awardType)
+	return awards, err
+}

model/award_test.go

@@ -0,0 +1,90 @@
+// Copyright 2019 Team 254. All Rights Reserved.
+// Author: pat@patfairbank.com (Patrick Fairbank)
+
+package model
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestGetNonexistentAward(t *testing.T) {
+	db := setupTestDb(t)
+
+	award, err := db.GetAwardById(1114)
+	assert.Nil(t, err)
+	assert.Nil(t, award)
+}
+
+func TestAwardCrud(t *testing.T) {
+	db := setupTestDb(t)
+
+	award := Award{0, JudgedAward, "Saftey Award", 254, ""}
+	db.CreateAward(&award)
+	award2, err := db.GetAwardById(1)
+	assert.Nil(t, err)
+	assert.Equal(t, award, *award2)
+
+	award2.AwardName = "Spirit Award"
+	db.CreateAward(award2)
+	awards, err := db.GetAllAwards()
+	assert.Nil(t, err)
+	if assert.Equal(t, 2, len(awards)) {
+		assert.Equal(t, award, awards[0])
+		assert.Equal(t, *award2, awards[1])
+	}
+
+	award.TeamId = 0
+	award.PersonName = "Travus Cubington"
+	db.SaveAward(&award)
+	award2, err = db.GetAwardById(1)
+	assert.Nil(t, err)
+	assert.Equal(t, award.TeamId, award2.TeamId)
+	assert.Equal(t, award.PersonName, award2.PersonName)
+
+	db.DeleteAward(&award)
+	award2, err = db.GetAwardById(1)
+	assert.Nil(t, err)
+	assert.Nil(t, award2)
+}
+
+func TestTruncateAwards(t *testing.T) {
+	db := setupTestDb(t)
+
+	award := Award{0, JudgedAward, "Saftey Award", 254, ""}
+	db.CreateAward(&award)
+	db.TruncateAwards()
+	award2, err := db.GetAwardById(1)
+	assert.Nil(t, err)
+	assert.Nil(t, award2)
+}
+
+func TestGetAwardsByType(t *testing.T) {
+	db := setupTestDb(t)
+
+	award1 := Award{0, WinnerAward, "Event Winner", 1114, ""}
+	db.CreateAward(&award1)
+	award2 := Award{0, FinalistAward, "Event Finalist", 2056, ""}
+	db.CreateAward(&award2)
+	award3 := Award{0, JudgedAward, "Saftey Award", 254, ""}
+	db.CreateAward(&award3)
+	award4 := Award{0, WinnerAward, "Event Winner", 254, ""}
+	db.CreateAward(&award4)
+
+	awards, err := db.GetAwardsByType(JudgedAward)
+	assert.Nil(t, err)
+	if assert.Equal(t, 1, len(awards)) {
+		assert.Equal(t, award3, awards[0])
+	}
+	awards, err = db.GetAwardsByType(FinalistAward)
+	assert.Nil(t, err)
+	if assert.Equal(t, 1, len(awards)) {
+		assert.Equal(t, award2, awards[0])
+	}
+	awards, err = db.GetAwardsByType(WinnerAward)
+	assert.Nil(t, err)
+	if assert.Equal(t, 2, len(awards)) {
+		assert.Equal(t, award1, awards[0])
+		assert.Equal(t, award4, awards[1])
+	}
+}

model/database.go

@@ -36,6 +36,7 @@ type Database struct {
 	lowerThirdMap    *modl.DbMap
 	sponsorSlideMap  *modl.DbMap
 	scheduleBlockMap *modl.DbMap
+	awardMap         *modl.DbMap
 }
 
 // Opens the SQLite database at the given path, creating it if it doesn't exist, and runs any pending
@@ -124,6 +125,9 @@ func (database *Database) mapTables() {
 
 	database.scheduleBlockMap = modl.NewDbMap(database.db, dialect)
 	database.scheduleBlockMap.AddTableWithName(ScheduleBlock{}, "schedule_blocks").SetKeys(true, "Id")
+
+	database.awardMap = modl.NewDbMap(database.db, dialect)
+	database.awardMap.AddTableWithName(Award{}, "awards").SetKeys(true, "Id")
 }
 
 func serializeHelper(target *string, source interface{}) error {

model/lower_third.go

@@ -10,6 +10,7 @@ type LowerThird struct {
 	TopText      string
 	BottomText   string
 	DisplayOrder int
+	AwardId      int
 }
 
 func (database *Database) CreateLowerThird(lowerThird *LowerThird) error {
@@ -45,3 +46,16 @@ func (database *Database) GetAllLowerThirds() ([]LowerThird, error) {
 	err := database.lowerThirdMap.Select(&lowerThirds, "SELECT * FROM lower_thirds ORDER BY displayorder")
 	return lowerThirds, err
 }
+
+func (database *Database) GetLowerThirdsByAwardId(awardId int) ([]LowerThird, error) {
+	var lowerThirds []LowerThird
+	err := database.lowerThirdMap.Select(&lowerThirds, "SELECT * FROM lower_thirds WHERE awardid = ? ORDER BY id",
+		awardId)
+	return lowerThirds, err
+}
+
+func (database *Database) GetNextLowerThirdDisplayOrder() int {
+	var count int
+	_ = database.lowerThirdMap.SelectOne(&count, "SELECT MAX(displayorder) + 1 FROM lower_thirds")
+	return count
+}

model/lower_third_test.go

@@ -19,7 +19,7 @@ func TestGetNonexistentLowerThird(t *testing.T) {
 func TestLowerThirdCrud(t *testing.T) {
 	db := setupTestDb(t)
 
-	lowerThird := LowerThird{0, "Top Text", "Bottom Text", 0}
+	lowerThird := LowerThird{0, "Top Text", "Bottom Text", 0, 0}
 	db.CreateLowerThird(&lowerThird)
 	lowerThird2, err := db.GetLowerThirdById(1)
 	assert.Nil(t, err)
@@ -40,10 +40,36 @@ func TestLowerThirdCrud(t *testing.T) {
 func TestTruncateLowerThirds(t *testing.T) {
 	db := setupTestDb(t)
 
-	lowerThird := LowerThird{0, "Top Text", "Bottom Text", 0}
+	lowerThird := LowerThird{0, "Top Text", "Bottom Text", 0, 0}
 	db.CreateLowerThird(&lowerThird)
 	db.TruncateLowerThirds()
 	lowerThird2, err := db.GetLowerThirdById(1)
 	assert.Nil(t, err)
 	assert.Nil(t, lowerThird2)
 }
+
+func TestGetLowerThirdsByAwardId(t *testing.T) {
+	db := setupTestDb(t)
+	lowerThird1 := LowerThird{0, "Top Text", "Bottom Text", 0, 0}
+	db.CreateLowerThird(&lowerThird1)
+	lowerThird2 := LowerThird{0, "Award 1", "", 1, 5}
+	db.CreateLowerThird(&lowerThird2)
+	lowerThird3 := LowerThird{0, "Award 2", "", 2, 2}
+	db.CreateLowerThird(&lowerThird3)
+	lowerThird4 := LowerThird{0, "Award 1", "Award 1 Winner", 3, 5}
+	db.CreateLowerThird(&lowerThird4)
+	nextDisplayOrder := db.GetNextLowerThirdDisplayOrder()
+	assert.Equal(t, 4, nextDisplayOrder)
+
+	lowerThirds, err := db.GetLowerThirdsByAwardId(5)
+	assert.Nil(t, err)
+	if assert.Equal(t, 2, len(lowerThirds)) {
+		assert.Equal(t, lowerThird2, lowerThirds[0])
+		assert.Equal(t, lowerThird4, lowerThirds[1])
+	}
+	lowerThirds, err = db.GetLowerThirdsByAwardId(2)
+	assert.Nil(t, err)
+	if assert.Equal(t, 1, len(lowerThirds)) {
+		assert.Equal(t, lowerThird3, lowerThirds[0])
+	}
+}