func (gs GameService) getGame(c *gin.Context) {
leagueID := getLeagueIDFromURL(c)
if leagueID <= 0 {
c.Redirect(302, "/api/leagues")
return
}
gameID := getGameIDFromURL(c)
if gameID <= 0 {
c.Redirect(302, fmt.Sprintf("/api/leagues/%d/games", leagueID))
return
}
gameDao := dao.CreateGameDao(c)
game, err := gameDao.GetGame(leagueID, gameID)
if err != nil {
utils.GetGaeContext(c).Errorf("Error loading game: %v", err)
c.AbortWithError(500, err)
return
}
gs.addGameLinks(leagueID, game, c)
c.JSON(200, game)
}
func (gs GameService) doSaveGame(game domain.Game, c *gin.Context) {
gameDao := dao.CreateGameDao(c)
savedGame, err := gameDao.SaveGame(game)
if err != nil {
utils.GetGaeContext(c).Errorf("Error saving game: %v", err)
c.AbortWithError(500, err)
}
gs.addGameLinks(game.LeagueID, savedGame, c)
c.JSON(200, savedGame)
}
func (gs GameService) getGames(c *gin.Context) {
leagueID := getLeagueIDFromURL(c)
if leagueID <= 0 {
c.Redirect(302, "/api/leagues")
return
}
currentPage := getCurrentPage(c)
recordsPerPage := 50
start := getStartRecord(currentPage, recordsPerPage)
gameDao := dao.CreateGameDao(c)
gameArray, totalGameCount, err := gameDao.GetGames(start, recordsPerPage, leagueID)
if err != nil {
utils.GetGaeContext(c).Errorf("Error loading games: %v", err)
c.AbortWithError(500, err)
return
}
if gameArray == nil {
gameArray = []domain.Game{}
}
for index := range gameArray {
gs.addGameLinks(leagueID, &gameArray[index], c)
}
games := &domain.Games{
Games: gameArray,
Total: totalGameCount,
}
gs.addGamesLinks(games, leagueID, currentPage, recordsPerPage, totalGameCount, c)
c.JSON(200, games)
}
func (as AdminService) doImportScoreBoardV1(c *gin.Context) {
utils.GetGaeRootContext(c).Infof("%#v", c.Request)
importDao := dao.CreateImportDao(c)
body, err := ioutil.ReadAll(c.Request.Body)
if err != nil {
utils.GetGaeRootContext(c).Errorf("Error calling ioutil.ReadAll(c.Request.Body) in doImportScoreBoardV1: %v", err)
c.AbortWithError(http.StatusInternalServerError, err)
importDao.SetStatus(false, 0, 0, 0, 0, 0, 0)
return
}
dbDumpUrl := string(body)
httpClient := urlfetch.Client(utils.GetGaeRootContext(c))
response, err := httpClient.Get(dbDumpUrl)
if err != nil {
utils.GetGaeRootContext(c).Errorf("Error calling httpClient.Get in doImportScoreBoardV1: %v", err)
c.AbortWithError(http.StatusInternalServerError, err)
importDao.SetStatus(false, 0, 0, 0, 0, 0, 0)
return
}
data, err := ioutil.ReadAll(response.Body)
if err != nil {
utils.GetGaeRootContext(c).Errorf("Error calling ioutil.ReadAll(response.Body) in doImportScoreBoardV1: %v", err)
c.AbortWithError(http.StatusInternalServerError, err)
importDao.SetStatus(false, 0, 0, 0, 0, 0, 0)
return
}
dump := MysqlDump{}
err = xml.Unmarshal(data, &dump)
if err != nil {
utils.GetGaeRootContext(c).Errorf("Error calling xml.Unmarshal in doImportScoreBoardV1: %v", err)
c.AbortWithError(http.StatusInternalServerError, err)
importDao.SetStatus(false, 0, 0, 0, 0, 0, 0)
return
}
database := dump.Databases[0]
playerTable := as._getTableByName(database, "player")
leagueTable := as._getTableByName(database, "league")
gameTable := as._getTableByName(database, "game")
gameTeamTable := as._createLookupMap(as._getTableByName(database, "game_team"), "id")
teamPlayersTable := as._createLookupMap(as._getTableByName(database, "team_players"), "team_id")
playerTotal := len(playerTable.Rows)
playerCount := 0
leagueTotal := len(leagueTable.Rows)
leagueCount := 0
gameTotal := len(gameTable.Rows)
gameCount := 0
_, err = importDao.SetStatus(true, playerTotal, playerCount, leagueTotal, leagueCount, gameTotal, gameCount)
if err != nil {
utils.GetGaeRootContext(c).Errorf("importDao.setStatus: %v", err)
c.AbortWithError(http.StatusInternalServerError, err)
return
}
// Add players first
as._deleteAll(dao.EntityPlayer, utils.GetGaeContext(c))
playerDao := dao.CreatePlayerDao(c)
playerConvertIdMap := make(map[string]int64)
for _, playerRow := range playerTable.Rows {
id := as._getFieldValueByName(playerRow, "id")
name := as._getFieldValueByName(playerRow, "name")
savedPlayer, err := playerDao.SavePlayer(domain.Player{
Active: true,
Name: name,
})
if err != nil {
utils.GetGaeRootContext(c).Errorf("Error calling playerDao.savePlayer in doImportScoreBoardV1: %v", err)
c.AbortWithError(http.StatusInternalServerError, err)
importDao.SetStatus(false, 0, 0, 0, 0, 0, 0)
return
}
playerConvertIdMap[id] = savedPlayer.ID
playerCount++
_, err = importDao.SetStatus(true, playerTotal, playerCount, leagueTotal, leagueCount, gameTotal, gameCount)
if err != nil {
utils.GetGaeRootContext(c).Errorf("importDao.setStatus: %v", err)
c.AbortWithError(http.StatusInternalServerError, err)
return
}
}
// Add leagues
as._deleteAll(dao.EntityLeague, utils.GetGaeContext(c))
leagueDao := dao.CreateLeagueDao(c)
leagueConvertIdMap := make(map[string]int64)
for _, leagueRow := range leagueTable.Rows {
id := as._getFieldValueByName(leagueRow, "id")
name := as._getFieldValueByName(leagueRow, "name")
savedLeague, err := leagueDao.SaveLeague(domain.League{
Active: true,
Name: name,
})
if err != nil {
utils.GetGaeRootContext(c).Errorf("Error calling leagueDao.saveLeague in doImportScoreBoardV1: %v", err)
c.AbortWithError(http.StatusInternalServerError, err)
importDao.SetStatus(false, 0, 0, 0, 0, 0, 0)
return
}
leagueConvertIdMap[id] = savedLeague.ID
leagueCount++
_, err = importDao.SetStatus(true, playerTotal, playerCount, leagueTotal, leagueCount, gameTotal, gameCount)
if err != nil {
utils.GetGaeRootContext(c).Errorf("importDao.setStatus: %v", err)
c.AbortWithError(http.StatusInternalServerError, err)
return
}
}
// Add games
as._deleteAll(dao.EntityGame, utils.GetGaeContext(c))
gameDao := dao.CreateGameDao(c)
for _, gameRow := range gameTable.Rows {
gameDate := as._getFieldDateValueByName(gameRow, "game_date")
team1IDString := as._getFieldValueByName(gameRow, "team1_id")
team2IDString := as._getFieldValueByName(gameRow, "team2_id")
leagueIDString := as._getFieldValueByName(gameRow, "league_id")
team1 := as._createTeam(team1IDString, gameTeamTable, teamPlayersTable, playerConvertIdMap)
team2 := as._createTeam(team2IDString, gameTeamTable, teamPlayersTable, playerConvertIdMap)
game := domain.Game{
GameDate: gameDate,
LeagueID: leagueConvertIdMap[leagueIDString],
Team1: team1,
Team2: team2,
}
_, err := gameDao.SaveGame(game)
if err != nil {
utils.GetGaeRootContext(c).Errorf("Error calling gameDao.saveGame in doImportScoreBoardV1: %v", err)
c.AbortWithError(http.StatusInternalServerError, err)
importDao.SetStatus(false, 0, 0, 0, 0, 0, 0)
return
}
gameCount++
_, err = importDao.SetStatus(true, playerTotal, playerCount, leagueTotal, leagueCount, gameTotal, gameCount)
if err != nil {
utils.GetGaeRootContext(c).Errorf("importDao.setStatus: %v", err)
c.AbortWithError(http.StatusInternalServerError, err)
return
}
}
_, err = importDao.SetStatus(false, playerTotal, playerCount, leagueTotal, leagueCount, gameTotal, gameCount)
if err != nil {
utils.GetGaeRootContext(c).Errorf("importDao.setStatus: %v", err)
c.AbortWithError(http.StatusInternalServerError, err)
return
}
}