Golang Context.JSON方法代码示例

func (ps PlayerService) handleGetSpecificPlayers(c *gin.Context, idList []string) {
	playerDao := dao.CreatePlayerDao(c)

	playerIds := make([]int64, len(idList))
	idx := 0
	for _, id := range idList {
		playerID, err := strconv.ParseInt(id, 10, 64)
		if err != nil {
			utils.GetGaeContext(c).Errorf("Not an integer: %v", err)
			c.AbortWithError(500, err)
			return
		}
		playerIds[idx] = playerID
		idx++
	}

	playerArray, err := playerDao.GetAllPlayersByID(playerIds)
	if err != nil {
		utils.GetGaeContext(c).Errorf("Error getting players by id: %v", err)
		c.AbortWithError(500, err)
		return
	}

	for index := range playerArray {
		addPlayerLinks(&playerArray[index], c)
	}

	players := &domain.Players{
		Players: playerArray,
	}

	c.JSON(200, players)
}

func (ps PlayerService) handleGetAllPlayers(c *gin.Context) {
	var currentPage = getCurrentPage(c)
	var recordsPerPage = 50
	var start = getStartRecord(currentPage, recordsPerPage)

	playerDao := dao.CreatePlayerDao(c)

	playerArray, totalPlayerCount, err := playerDao.GetPlayers(start, recordsPerPage)

	if err != nil {
		utils.GetGaeContext(c).Errorf("Error loading players: %v", err)
		c.AbortWithError(500, err)
		return
	}

	if playerArray == nil {
		playerArray = []domain.Player{}
	}

	for index := range playerArray {
		addPlayerLinks(&playerArray[index], c)
	}

	players := &domain.Players{
		Players: playerArray,
	}

	addPaginationLinks(players, "/api/players", currentPage, recordsPerPage, totalPlayerCount)
	if isAuthenticated(c) {
		players.AddLink(domain.RelCreate, "/api/players")
	}

	c.JSON(200, players)
}

func (as AdminService) prepareImportScoreBoardV1(c *gin.Context) {
	importDefinition := domain.ScoreBoardV1Import{}

	importDefinition.AddLink(relImport, "/api/admin/import/scoreboardv1")

	c.JSON(200, importDefinition)
}

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 (cds contextDefinitionService) checkID(c *gin.Context) {
	var checkResult struct {
		ID          string `json:"id"`
		IDAvailable bool   `json:"available"`
		Valid       bool   `json:"valid"`
	}

	checkResult.ID = c.Params.ByName("id")

	if cds._isIDValid(checkResult.ID) {
		contextDefinitionDao := createContextDefinitionDao(c)
		idExists, err := contextDefinitionDao.checkIDExists(checkResult.ID)

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

		checkResult.IDAvailable = idExists == false
		checkResult.Valid = true
	} else {
		checkResult.Valid = false
	}

	c.JSON(http.StatusOK, checkResult)

}

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

func (cds contextDefinitionService) saveContext(c *gin.Context) {
	var contextDefinition ContextDefinition

	c.Bind(&contextDefinition)

	if !cds._isValid(contextDefinition) {
		c.AbortWithStatus(http.StatusBadRequest)
		return
	}

	user := getCurrentUserFromGinContext(c)

	// Run all of this in a transaction (even if we are on service level)
	err := datastore.RunInTransaction(getGaeContext(c), func(gaeCtx appengine.Context) error {
		contextDao := contextDefinitionDao{dao{gaeCtx}}
		idExists, err := contextDao.checkIDExists(contextDefinition.ID)

		if err != nil {
			return err
		}

		if idExists {
			return ErrIDAlreadyExists
		}

		contextDefinition.Owner = datastore.NewKey(gaeCtx, entityUser, user.UserID, 0, nil)
		contextDefinition.Active = true

		err = contextDao.saveContext(contextDefinition)

		if err != nil {
			return err
		}

		return nil
	}, &datastore.TransactionOptions{
		XG: true,
	})

	if err != nil {
		returnStatus := http.StatusInternalServerError
		if err == ErrIDAlreadyExists {
			returnStatus = http.StatusConflict
		}

		c.AbortWithError(returnStatus, err)
		return
	}

	contextDefinition.RemoveLink(relCreate)
	contextDefinition.RemoveLink(relCheckID)

	if productionDomain := os.Getenv("PRODUCTION_DOMAIN"); productionDomain != "" {
		contextDefinition.AddLink(relSelf, fmt.Sprintf("http://%s.%s", contextDefinition.ID, productionDomain))
	}

	c.JSON(200, contextDefinition)
}

func (cds contextDefinitionService) prepareNewContext(c *gin.Context) {
	newContextDefinition := ContextDefinition{}
	newContextDefinition.Active = true

	newContextDefinition.AddLink(relCheckID, "/api/context/checkid/")
	newContextDefinition.AddLink(relCreate, "/api/context")

	c.JSON(http.StatusOK, newContextDefinition)
}

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

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 (ps PlayerService) doSavePlayer(player domain.Player, c *gin.Context) {
	playerDao := dao.CreatePlayerDao(c)

	savedPlayer, err := playerDao.SavePlayer(player)

	if err != nil {
		utils.GetGaeContext(c).Errorf("Error saving player: %v", err)
		c.AbortWithError(500, err)
	}

	addPlayerLinks(savedPlayer, c)
	c.JSON(200, savedPlayer)
}

func (as AdminService) importScoreBoardV1Status(c *gin.Context) {
	importDao := dao.CreateImportDao(c)

	importStatus, err := importDao.GetStatus()

	if err != nil {
		utils.GetGaeRootContext(c).Errorf("%v", err)
		c.AbortWithError(http.StatusInternalServerError, err)
		return
	}

	if importStatus == nil {
		importStatus = &domain.ScoreBoardV1ImportStatus{}
	}

	importStatus.AddLink(relImportStatus, "/api/admin/import/scoreboardv1/status")

	c.JSON(200, importStatus)
}

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

func (ps PlayerService) getPlayer(c *gin.Context) {
	playerID := getPlayerIDFromURL(c)

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

	playerDao := dao.CreatePlayerDao(c)

	player, err := playerDao.GetPlayer(playerID)

	if err != nil {
		utils.GetGaeContext(c).Errorf("Error loading player: %v", err)
		c.AbortWithError(500, err)
		return
	}

	addPlayerLinks(player, c)
	c.JSON(200, player)
}

func (as AdminService) importScoreBoardV1(c *gin.Context) {
	var importDefinition domain.ScoreBoardV1Import

	c.Bind(&importDefinition)

	if importDefinition.DbDumpUrl == "" {
		c.AbortWithStatus(http.StatusBadRequest)
		return
	}

	createTask := &taskqueue.Task{
		Path:    "/tasks/import/scoreboardv1",
		Payload: []byte(importDefinition.DbDumpUrl),
	}
	hostName, _ := appengine.ModuleHostname(utils.GetGaeRootContext(c), appengine.ModuleName(utils.GetGaeRootContext(c)), "", "")
	createTask.Header = http.Header{}
	createTask.Header.Set("Host", hostName)
	createTask.Header.Set(utils.NamespaceHeader, utils.GetNamespace(c))

	_, err := taskqueue.Add(utils.GetGaeRootContext(c), createTask, "contextqueue")

	if err != nil {
		utils.GetGaeRootContext(c).Errorf("Error calling taskqueue.Add in importScoreBoardV1: %v", err)
		c.AbortWithError(http.StatusInternalServerError, err)
		return
	}

	importDao := dao.CreateImportDao(c)
	importStatus, err := importDao.SetStatus(true, 0, 0, 0, 0, 0, 0)

	if err != nil {
		utils.GetGaeRootContext(c).Errorf("Error calling importDao.setStatus in importScoreBoardV1: %v", err)
		c.AbortWithError(http.StatusInternalServerError, err)
		return
	}

	importStatus.AddLink(relImportStatus, "/api/admin/import/scoreboardv1/status")

	c.JSON(200, importStatus)
}