Switching dev machines

model_clients.go

@@ -15,6 +15,15 @@ type Client struct {
 	Auth bool
 	Name string
 	IP   string
+
+	mPath []string // The path in the DB to this client
+}
+
+func NewClient(id string) *Client {
+	return &Client{
+		UUID:  id,
+		mPath: []string{"clients", id},
+	}
 }
 
 // Load all clients
@@ -26,7 +35,8 @@ func (m *model) LoadAllClients() []Client {
 	defer m.closeDB()
 
 	var clientUids []string
-	if clientUids, err = m.bolt.GetBucketList([]string{"clients"}); err != nil {
+	cliPath := []string{"clients"}
+	if clientUids, err = m.bolt.GetBucketList(cliPath); err != nil {
 		return err
 	}
 	for _, v := range clientUids {
@@ -44,11 +54,10 @@ func (m *model) LoadClient(clId string) *Client {
 	}
 	defer m.closeDB()
 
-	cl := new(Client)
+	cl := NewClient(clId)
-	cl.UUID = id
+	cl.Auth, _ = m.bolt.GetBool(cl.mPath, "auth")
-	cl.Auth, _ = m.bolt.GetBool([]string{"clients", id}, "auth")
+	cl.Name, _ = m.bolt.GetValue(cl.mPath, "name")
-	cl.Name, _ = m.bolt.GetValue([]string{"clients", id}, "name")
+	cl.IP, _ = m.bolt.GetValue(cl.mPath, "ip")
-	cl.IP, _ = m.bolt.GetValue([]string{"clients", id}, "ip")
 	return cl
 }
 
@@ -61,25 +70,25 @@ func (m *model) getClientById(ip string) *Client {
 	return nil
 }
 
+func (m *model) SaveClient(cl *Client) error {
+	var err error
+	if err = m.openDB(); err != nil {
+		return nil
+	}
+	defer m.closeDB()
+
+	if err = db.bolt.SetBool(cl.mPath, "auth", c.Auth); err != nil {
+		return err
+	}
+	if err = db.bolt.SetValue(cl.mPath, "name", c.Name); err != nil {
+		return err
+	}
+	return db.bolt.SetValue(cl.mPath, "ip", c.IP)
+}
+
 /**
  * OLD FUNCTIONS
  */
-func (c *Client) save() error {
-	var err error
-	if err = db.open(); err != nil {
-		return nil
-	}
-	defer db.close()
-
-	if err = db.bolt.SetBool([]string{"clients", c.UUID}, "auth", c.Auth); err != nil {
-		return err
-	}
-	if err = db.bolt.SetValue([]string{"clients", c.UUID}, "name", c.Name); err != nil {
-		return err
-	}
-	return db.bolt.SetValue([]string{"clients", c.UUID}, "ip", c.IP)
-}
-
 func (c *Client) saveVote(timestamp time.Time, votes []string) error {
 	var err error
 	if err = db.open(); err != nil {

model_gamejam.go

@@ -13,13 +13,15 @@ type Gamejam struct {
 	Teams []Team
 	Votes []Vote
 
-	m       *model
+	m       *model   // The model that holds this gamejam's data
+	mPath   []string // The path in the db to this gamejam
 	updates []string
 }
 
 func NewGamejam(m *model) *Gamejam {
 	gj := new(Gamejam)
 	gj.m = m
+	gj.mPath = []string{"jam"}
 	return gj
 }
 
@@ -30,9 +32,8 @@ func (m *model) LoadCurrentJam() *Gamejam {
 	defer m.closeDB()
 
 	var err error
-	jamPath := []string{"jam"}
 	gj := NewGamejam(m)
-	gj.Name, _ = m.bolt.GetValue(jamPath, "name")
+	gj.Name, _ = m.bolt.GetValue(gj.mPath, "name")
 
 	// Load all teams
 	gj.Teams = gj.LoadAllTeams()
@@ -57,10 +58,10 @@ func (gj *Gamejam) needsSave() bool {
 }
 
 func (gj *Gamejam) saveToDB() error {
-	if err := s.m.openDB(); err != nil {
+	if err := gj.m.openDB(); err != nil {
 		return err
 	}
-	defer s.m.closeDB()
+	defer gj.m.closeDB()
 
 	for i := range updates {
 		// TODO: Save

model_games.go

@@ -1,7 +1,5 @@
 package main
 
-import "errors"
-
 /**
  * Game
  * A team's game, including links, description, and screenshots
@@ -12,6 +10,25 @@ type Game struct {
 	Link        string
 	Description string
 	Screenshots []Screenshot
+
+	mPath []string // The path in the DB to this game
+}
+
+// Create a new game object
+func NewGame(tmId string) *Game {
+	return &Game{
+		TeamId: tmId,
+		mPath:  []string{"jam", "teams", tmId, "game"},
+	}
+}
+
+func (gm *Game) GetScreenshot(ssId string) *Screenshot {
+	for _, ss := range gm.Screenshots {
+		if ss.UUID == ssId {
+			return ss
+		}
+	}
+	return nil
 }
 
 type Screenshot struct {
@@ -20,6 +37,16 @@ type Screenshot struct {
 	Image       string
 	Thumbnail   string
 	Filetype    string
+
+	mPath []string // The path in the DB to this screenshot
+}
+
+// Create a Screenshot Object
+func NewScreenshot(tmId, ssId string) *Screenshot {
+	return &Screenshot{
+		UUID:  ssId,
+		mPath: []string{"jam", "teams", tmId, "game", "screenshots", ssId},
+	}
 }
 
 // Load a team's game from the DB and return it
@@ -30,16 +57,14 @@ func (gj *Gamejam) LoadTeamGame(tmId string) *Game {
 	}
 	defer gj.m.closeDB()
 
-	gamePath := []string{"jam", "teams", tmId, "game"}
+	gm := NewGame(tmId)
-	gm := new(Game)
+	if gm.Name, err = gj.m.bolt.GetValue(gm.mPath, "name"); err != nil {
-	gm.TeamId = tm.UUID
-	if gm.Name, err = gj.m.bolt.GetValue(gamePath, "name"); err != nil {
 		gm.Name = ""
 	}
-	if gm.Description, err = gj.m.bolt.GetValue(gamePath, "description"); err != nil {
+	if gm.Description, err = gj.m.bolt.GetValue(gm.mPath, "description"); err != nil {
 		gm.Description = ""
 	}
-	if gm.Link, err = gj.m.bolt.GetValue(gamePath, "link"); err != nil {
+	if gm.Link, err = gj.m.bolt.GetValue(gm.mPath, "link"); err != nil {
 		gm.Link = ""
 	}
 	// Now get the game screenshots
@@ -48,6 +73,7 @@ func (gj *Gamejam) LoadTeamGame(tmId string) *Game {
 	return &gm
 }
 
+// Load a games screenshots from the DB
 func (gj *Gamejam) LoadTeamGameScreenshots(tmId string) []Screenshot {
 	var err error
 	if err = gj.m.openDB(); err != nil {
@@ -56,7 +82,8 @@ func (gj *Gamejam) LoadTeamGameScreenshots(tmId string) []Screenshot {
 	defer gj.m.closeDB()
 
 	var ret []Screenshot
-	ssBktPath := []string{"jam", "teams", tmId, "game", "screenshots"}
+	gm := NewGame(tmId)
+	ssBktPath := append(gm.mPath, "screenshots")
 	var ssIds []string
 	ssIds, _ = gj.m.bolt.GetBucketList(ssBktPath)
 	for _, v := range ssIds {
@@ -68,6 +95,7 @@ func (gj *Gamejam) LoadTeamGameScreenshots(tmId string) []Screenshot {
 	return ret
 }
 
+// Load a screenshot from the DB
 func (gj *Gamejam) LoadTeamGameScreenshot(tmId, ssId string) *Screenshot {
 	var err error
 	if err = gj.m.openDB(); err != nil {
@@ -75,87 +103,121 @@ func (gj *Gamejam) LoadTeamGameScreenshot(tmId, ssId string) *Screenshot {
 	}
 	defer gj.m.closeDB()
 
-	var ret []Screenshot
+	ret := NewScreenshot(tmId, ssId)
-	ssPath := []string{"jam", "teams", tmId, "game", "screenshots", ssId}
+	if ret.Description, err = gj.m.bolt.GetValue(ret.mPath, "description"); err != nil {
-	ret := new(Screenshot)
-	ret.UUID = ssId
-	if ret.Description, err = gj.m.bolt.GetValue(ssPath, "description"); err != nil {
 		return nil
 	}
-	if ret.Image, err = gj.m.bolt.GetValue(ssPath, "image"); err != nil {
+	if ret.Image, err = gj.m.bolt.GetValue(ret.mPath, "image"); err != nil {
 		return nil
 	}
-	if ret.Thumbnail, err = gj.m.bolt.GetValue(ssPath, "thumbnail"); err != nil {
+	if ret.Thumbnail, err = gj.m.bolt.GetValue(ret.mPath, "thumbnail"); err != nil {
 		return nil
 	}
 	if ret.Thumbnail == "" {
 		ret.Thumbnail = ret.Image
 	}
-	if ret.Filetype, err = gj.m.bolt.GetValue(ssPath, "filetype"); err != nil {
+	if ret.Filetype, err = gj.m.bolt.GetValue(ret.mPath, "filetype"); err != nil {
 		return nil
 	}
 	return ret
 }
 
-/**
+// Save a game to the given model's DB
- * OLD FUNCTIONS
+func (gj *Gamejam) SaveGame(gm *Game) error {
- */
+	//func (gm *Game) save(m *model) error {
-
-// Create a new game object, must have a valid team id
-func (db *currJamDb) newGame(tmId string) *Game {
 	var err error
-	if err = db.open(); err != nil {
+	if err = gj.m.openDB(); err != nil {
-		return nil
-	}
-	defer db.close()
-
-	tm := db.getTeam(tmId)
-	if tm == nil {
-		return nil
-	}
-	return &Game{TeamId: tmId}
-}
-
-func (db *currJamDb) getAllGames() []Game {
-	var ret []Game
-	tms := db.getAllTeams()
-	for i := range tms {
-		ret = append(ret, *tms[i].getGame())
-	}
-	return ret
-}
-
-func (gm *Game) save() error {
-	var err error
-	if err = db.open(); err != nil {
 		return err
 	}
-	defer db.close()
+	defer gj.m.closeDB()
 
-	tm := db.getTeam(gm.TeamId)
+	/*
+		tm := gj.getTeam(gm.TeamId)
 		if tm == nil {
 			return errors.New("Invalid Team: " + gm.TeamId)
 		}
-	gamePath := []string{"teams", gm.TeamId, "game"}
+	*/
-	if err := db.bolt.MkBucketPath(gamePath); err != nil {
+	if err := gj.m.bolt.MkBucketPath(gm.mPath); err != nil {
 		return err
 	}
 
 	if gm.Name == "" {
 		gm.Name = tm.Name + "'s Game"
 	}
-	if err := db.bolt.SetValue(gamePath, "name", gm.Name); err != nil {
+	if err := gj.m.bolt.SetValue(gm.mPath, "name", gm.Name); err != nil {
 		return err
 	}
-	if err := db.bolt.SetValue(gamePath, "link", gm.Link); err != nil {
+	if err := gj.m.bolt.SetValue(gm.mPath, "link", gm.Link); err != nil {
 		return err
 	}
-	if err := db.bolt.SetValue(gamePath, "description", gm.Description); err != nil {
+	if err := gj.m.bolt.SetValue(gm.mPath, "description", gm.Description); err != nil {
 		return err
 	}
-	if err := db.bolt.MkBucketPath(append(gamePath, "screenshots")); err != nil {
+	if err := gj.m.bolt.MkBucketPath(append(gm.mPath, "screenshots")); err != nil {
 		return err
 	}
+	return gj.SaveScreenshots(gm)
+}
 
+// Save all of the game's screenshots to the DB
+// Remove screenshots from the DB that aren't in the game object
+func (gj *Gamejam) SaveScreenshots(gm *Game) error {
+	var err error
+	if err = gj.m.openDB(); err != nil {
 		return err
 	}
+	defer gj.m.closeDB()
+
+	for _, ss := range gm.Screenshots {
+		if err = gj.SaveScreenshot(gm.TeamId, ss); err != nil {
+			return err
+		}
+	}
+	// Now remove unused screenshots
+	ssPath := append(gm.mPath, "screenshots")
+	if ssIds, err = gj.m.bolt.GetBucketList(ssPath); err != nil {
+		return err
+	}
+	for i := range ssIds {
+		if gm.GetScreenshot(ssIds[i]) == nil {
+			if err = gj.DeleteScreenshot(NewScreenshot(tm.TeamId, ssIds[i])); err != nil {
+				return err
+			}
+		}
+	}
+}
+
+// Save a screenshot
+func (gj *Gamejam) SaveScreenshot(tmId string, ss *Screenshot) error {
+	var err error
+	if err = gj.m.openDB(); err != nil {
+		return err
+	}
+	defer gj.m.closeDB()
+
+	if err = gj.m.bolt.MkBucketPath(ss.mPath); err != nil {
+		return err
+	}
+	if err = gj.m.bolt.SetValue(ss.mPath, "description", ss.Description); err != nil {
+		return err
+	}
+	if err = gj.m.bolt.SetValue(ss.mPath, "image", ss.Image); err != nil {
+		return err
+	}
+	if err = gj.m.bolt.SetValue(ss.mPath, "filetype", ss.Filetype); err != nil {
+		return err
+	}
+	return nil
+}
+
+// Delete a screenshot
+func (gj *Gamejam) DeleteScreenshot(ss *Screenshot) error {
+	var err error
+	if err = gj.m.openDB(); err != nil {
+		return nil
+	}
+	defer gj.m.closeDB()
+
+	ssPath := ss.mPath[:len(ss.mPath)-1]
+	return gj.m.bolt.DeleteBucket(ssPath, ss.UUID)
+}

model_teams.go

@@ -14,13 +14,15 @@ type Team struct {
 	Name    string
 	Members []TeamMember
 	Game    *Game
+
+	mPath []string // The path in the DB to this team
 }
 
 // Create a team
-func NewTeam(nm string) *Team {
+func NewTeam(id string) *Team {
 	return &Team{
-		UUID: uuid.New(),
+		UUID:  id,
-		Name: nm,
+		mPath: []string{"jam", "teams", id},
 	}
 }
 
@@ -32,10 +34,12 @@ type TeamMember struct {
 	Email   string
 }
 
-// Create a new team member, only a name is required
+// Create a new team member
-func NewTeamMember(nm string) *TeamMember {
+func NewTeamMember(tmId, uId string) *TeamMember {
-	m := TeamMember{Name: nm}
+	return &TeamMember{
-	return &m
+		UUID:  uId,
+		mPath: []string{"jam", "teams", tmId, "members", uId},
+	}
 }
 
 // LoadAllTeams loads all teams for the jam out of the database
@@ -47,7 +51,6 @@ func (gj *Gamejam) LoadAllTeams() []Team {
 	}
 	defer gj.m.closeDB()
 
-	teamsPath := []string{"jam", "teams"}
 	if tmUUIDs, err = m.bolt.GetBucketList(mbrsPath); err != nil {
 		return ret
 	}
@@ -69,10 +72,8 @@ func (gj *Gamejam) LoadTeam(uuid string) *Team {
 	defer gj.m.closeDB()
 
 	// Team Data
-	tmPath := []string{"jam", "teams", uuid}
+	tm := NewTeam(uuid)
-	tm := new(Team)
+	if tm.Name, err = gj.m.bolt.GetValue(tm.mPath, "name"); err != nil {
-	tm.UUID = uuid
-	if tm.Name, err = gj.m.bolt.GetValue(tmPath, "name"); err != nil {
 		return nil
 	}
 
@@ -82,6 +83,7 @@ func (gj *Gamejam) LoadTeam(uuid string) *Team {
 	// Team Game
 	tm.Game = gj.LoadTeamGame(uuid)
 
+	return tm
 }
 
 // Load the members of a team from the DB and return them
@@ -95,7 +97,8 @@ func (gj *Gamejam) LoadTeamMembers(tmId string) []TeamMember {
 
 	// Team Members
 	var memberUuids []string
-	mbrsPath := []string{"jam", "teams", tmId, "members"}
+	tm := NewTeam(tmId)
+	mbrsPath := append(tm.mPath, "members")
 	if memberUuids, err = gj.m.bolt.GetBucketList(mbrsPath); err == nil {
 		for _, v := range memberUuids {
 			mbr := gj.LoadTeamMember(tmId, v)
@@ -115,25 +118,57 @@ func (gj *Gamejam) LoadTeamMember(tmId, mbrId string) *TeamMember {
 	}
 	defer gj.m.closeDB()
 
-	mbr := new(TeamMember)
+	mbr := NewTeamMember(tmId, mbrId)
-	mbr.UUID = v
-	teamMbrPath := append(mbrsPath, mbr.UUID)
 	// Name is the only required field
-	if mbr.Name, err = gj.m.bolt.GetValue(teamMbrPath, "name"); err != nil {
+	if mbr.Name, err = gj.m.bolt.GetValue(mbr.mPath, "name"); err != nil {
 		return nil
 	}
-	if mbr.SlackId, err = gj.m.bolt.GetValue(teamMbrPath, "slackid"); err != nil {
+	if mbr.SlackId, err = gj.m.bolt.GetValue(mbr.mPath, "slackid"); err != nil {
 		mbr.SlackId = ""
 	}
-	if mbr.Twitter, err = gj.m.bolt.GetValue(teamMbrPath, "twitter"); err != nil {
+	if mbr.Twitter, err = gj.m.bolt.GetValue(mbr.mPath, "twitter"); err != nil {
 		mbr.Twitter = ""
 	}
-	if mbr.Email, err = gj.m.bolt.GetValue(teamMbrPath, "email"); err != nil {
+	if mbr.Email, err = gj.m.bolt.GetValue(mbr.mPath, "email"); err != nil {
 		mbr.Email = ""
 	}
 	return mbr
 }
 
+func (gj *Gamejam) SaveTeam(tm *Team) error {
+	var err error
+	if err = gj.m.openDB(); err != nil {
+		return err
+	}
+	defer gj.m.closeDB()
+
+	// Save team data
+	if err = gj.m.bolt.SetValue(tm.mPath, "name"); err != nil {
+		return err
+	}
+
+	// Save team members
+	for _, mbr := range tm.Members {
+		if err = gj.m.bolt.SetValue(mbr.mPath, "name", mbr.Name); err != nil {
+			return err
+		}
+		if err = gj.m.bolt.SetValue(mbr.mPath, "slackid", mbr.SlackId); err != nil {
+			return err
+		}
+		if err = gj.m.bolt.SetValue(mbr.mPath, "twitter", mbr.Twitter); err != nil {
+			return err
+		}
+		if err = gj.m.bolt.SetValue(mbr.mPath, "email", mbr.Email); err != nil {
+			return err
+		}
+	}
+
+	// Save team game
+	if err = gj.m.bolt.SetValue(tm.
+
+}
+
+
 /**
  * OLD FUNCTIONS
  */
@@ -284,95 +319,6 @@ func (tm *Team) delete() error {
 	return db.bolt.DeleteBucket(teamPath, tm.UUID)
 }
 
-func (tm *Team) getGame() *Game {
-	var err error
-	if err = db.open(); err != nil {
-		return nil
-	}
-	defer db.close()
-
-	gamePath := []string{"teams", tm.UUID, "game"}
-	gm := new(Game)
-	if gm.Name, err = db.bolt.GetValue(gamePath, "name"); err != nil {
-		gm.Name = ""
-	}
-	gm.TeamId = tm.UUID
-	if gm.Description, err = db.bolt.GetValue(gamePath, "description"); err != nil {
-		gm.Description = ""
-	}
-	if gm.Link, err = db.bolt.GetValue(gamePath, "link"); err != nil {
-		gm.Link = ""
-	}
-	gm.Screenshots = tm.getScreenshots()
-	return gm
-}
-
-// Screenshots are saved as base64 encoded pngs
-func (tm *Team) saveScreenshot(ss *Screenshot) error {
-	var err error
-	if err = db.open(); err != nil {
-		return nil
-	}
-	defer db.close()
-
-	ssPath := []string{"teams", tm.UUID, "game", "screenshots"}
-	// Generate a UUID for this screenshot
-	uuid := uuid.New()
-	ssPath = append(ssPath, uuid)
-	if err := db.bolt.MkBucketPath(ssPath); err != nil {
-		return err
-	}
-	if err := db.bolt.SetValue(ssPath, "description", ss.Description); err != nil {
-		return err
-	}
-	if err := db.bolt.SetValue(ssPath, "image", ss.Image); err != nil {
-		return err
-	}
-	if err := db.bolt.SetValue(ssPath, "thumbnail", ss.Thumbnail); err != nil {
-		return err
-	}
-	if err := db.bolt.SetValue(ssPath, "filetype", ss.Filetype); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (tm *Team) deleteScreenshot(ssId string) error {
-	var err error
-	if err = db.open(); err != nil {
-		return nil
-	}
-	defer db.close()
-
-	ssPath := []string{"teams", tm.UUID, "game", "screenshots"}
-	return db.bolt.DeleteBucket(ssPath, ssId)
-}
-
-func (tm *Team) getTeamMember(mbrId string) *TeamMember {
-	var err error
-	if err = db.open(); err != nil {
-		return nil
-	}
-	defer db.close()
-
-	mbr := new(TeamMember)
-	mbr.UUID = mbrId
-	teamMbrPath := []string{"teams", tm.UUID, "members", mbr.UUID}
-	if mbr.Name, err = db.bolt.GetValue(teamMbrPath, "name"); err != nil {
-		return nil
-	}
-	if mbr.SlackId, err = db.bolt.GetValue(teamMbrPath, "slackid"); err != nil {
-		return nil
-	}
-	if mbr.Twitter, err = db.bolt.GetValue(teamMbrPath, "twitter"); err != nil {
-		return nil
-	}
-	if mbr.Email, err = db.bolt.GetValue(teamMbrPath, "email"); err != nil {
-		return nil
-	}
-	return mbr
-}
-
 func (tm *Team) getTeamMembers() []TeamMember {
 	var ret []TeamMember
 	var err error