Golang CreateLeagueDao示例

说明

golang createleaguedao示例是从最受好评的开源项目中提取的实现代码，你可以参考下面示例的使用方式。

编程语言: Golang

命名空间/包名称: api/dao

示例#1

文件： leagueservice.go 项目： gamescores/gamescores.info

func (ls LeagueService) getLeagues(c *gin.Context) {
	var currentPage = getCurrentPage(c)
	var recordsPerPage = 50
	var start = getStartRecord(currentPage, recordsPerPage)

	leagueDao := dao.CreateLeagueDao(c)

	leagueArray, totalLeagueCount, err := leagueDao.GetLeagues(start, recordsPerPage)

	if err != nil {
		c.AbortWithError(500, err)
		return
	}

	if leagueArray == nil {
		leagueArray = []domain.League{}
	}

	for index := range leagueArray {
		addLeagueLinks(&leagueArray[index], c)
	}

	leagues := &domain.Leagues{
		Leagues: leagueArray,
	}

	addPaginationLinks(leagues, "/api/leagues", currentPage, recordsPerPage, totalLeagueCount)

	if isAuthenticated(c) {
		leagues.AddLink(domain.RelCreate, "/api/leagues")
	}

	c.JSON(200, leagues)
}

示例#2

文件： leagueservice.go 项目： gamescores/gamescores.info

func (ls LeagueService) doSaveLeague(league domain.League, c *gin.Context) {
	leagueDao := dao.CreateLeagueDao(c)

	savedLeague, err := leagueDao.SaveLeague(league)

	if err != nil {
		c.AbortWithError(500, err)
	}

	addLeagueLinks(savedLeague, c)
	c.JSON(200, savedLeague)
}

示例#3

文件： leagueservice.go 项目： gamescores/gamescores.info

func (ls LeagueService) getLeague(c *gin.Context) {
	leagueID := getLeagueIDFromURL(c)

	if leagueID <= 0 {
		c.Redirect(304, "/api/leagues")
		return
	}

	leagueDao := dao.CreateLeagueDao(c)

	league, err := leagueDao.GetLeague(leagueID)

	if err != nil {
		c.AbortWithError(500, err)
		return
	}

	addLeagueLinks(league, c)
	c.JSON(200, league)
}

示例#4

文件： importscoreboardv1.go 项目： gamescores/gamescores.info

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
	}
}