InfantrySkillCalculator/controllers/player_controller.go

package controllers

import (
	"InfantrySkillCalculator/models"
	"InfantrySkillCalculator/utils"
	"fmt"
	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
	"gorm.io/gorm/clause"
	"html/template"
	"internal/cache"
	"log"
	"net/http"
)

type AddPlayerInput struct {
	Name   string `json:"name" binding:"required"`
	ClanID uint   `json:"clan_id" binding:"required"`
}

type UpdatePlayerInput struct {
	Name   string `json:"name"`
	ClanID uint   `json:"clan_id"`
}

// GetAllPlayers GET /player
func GetAllPlayers(c *gin.Context) {
	var players []models.Player
	models.DB.Find(&players)

	c.JSON(http.StatusOK, players)
}

// GetPlayersByClanHTML GET /players_html
func GetPlayersByClanHTML(c *gin.Context) {
	var players []models.Player
	clanId := c.Request.URL.Query().Get("clan_id")
	if err := models.DB.
		Where("clan_id = ?", utils.StringToUint(clanId)).
		Find(&players).Error; err != nil {

		c.String(http.StatusBadRequest, "")
		log.Fatal(err)
		return
	}

	game, err := GetActiveGame(c)
	if err != nil {
		c.String(http.StatusBadRequest, "")
		log.Fatal(err)
		return
	}

	scores, err := cache.GetScores(players, game.Tag)
	if err != nil {
		c.String(http.StatusBadRequest, "")
		log.Fatal(err)
	}

	userRole := GetUserRoleByCtx(c)

	var data []map[string]interface{}
	for i, player := range players {

		score := scores[i]
		var scoreStr string
		if score == -1.0 {
			scoreStr = "<i class=\"bi bi-dash me-2\" style=\"margin-left:0.7rem;\"></i>"
		} else {
			scoreStr = fmt.Sprintf("%.2f", score)
		}

		data = append(data, map[string]interface{}{
			"PlayerName": player.Name,
			"Score":      template.HTML(scoreStr),
			"PlayerID":   player.ID,
			"UserRole":   userRole,
		})
	}

	err = utils.PlayerItemTemplate.Execute(c.Writer, data)
	if err != nil {
		log.Fatal(err)
	}
}

// AddPlayer POST /player
func AddPlayer(c *gin.Context) {
	var input AddPlayerInput
	if err := c.BindJSON(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	var player models.Player
	if err := models.DB.Where("name = ?", input.Name).First(&player).Error; err == nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Player with this name already exists!"})
		return
	}

	player = models.Player{Name: input.Name, ClanID: input.ClanID}
	models.DB.Create(&player)

	c.JSON(http.StatusOK, player)

	_, err := fmt.Fprintf(utils.GinWriter, "Added player '"+player.Name+"'\n")
	if err != nil {
		log.Fatal(err)
	}
}

// GetPlayerByID GET /player/:id
func GetPlayerByID(c *gin.Context) {
	player := FindPlayerByID(utils.StringToUint(c.Param("id")))
	if player == nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
		return
	}

	c.JSON(http.StatusOK, player)
}

// GetPlayerIDByName GET /playerid/:name
func GetPlayerIDByName(c *gin.Context) {
	var player models.Player

	if err := FindPlayerByName(&player, c).Error; err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
		return
	}

	c.JSON(http.StatusOK, player.ID)
}

// UpdatePlayerByID PATCH /player/:id
func UpdatePlayerByID(c *gin.Context) {
	var input UpdatePlayerInput
	if err := c.ShouldBindJSON(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	res := models.DB.Model(&models.Player{}).
		Where("id = ?", utils.StringToUint(c.Param("id"))).
		Updates(map[string]interface{}{
			"Name":   input.Name,
			"ClanID": input.ClanID,
		})
	if res.Error != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": res.Error.Error()})
		return
	}

	c.JSON(http.StatusOK, nil)

	_, err := fmt.Fprintf(utils.GinWriter, "Updated player '"+input.Name+"'\n")
	if err != nil {
		log.Fatal(err)
	}
}

// DeletePlayerByID DELETE /player/:id
func DeletePlayerByID(c *gin.Context) {
	player := FindPlayerByID(utils.StringToUint(c.Param("id")))
	if player == nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
		return
	}

	models.DB.Delete(&player)

	c.JSON(http.StatusOK, true)

	_, err := fmt.Fprintf(utils.GinWriter, "Deleted player '"+player.Name+"'\n")
	if err != nil {
		log.Fatal(err)
	}
}

// DeleteAllPlayers DELETE /admin/player
func DeleteAllPlayers(c *gin.Context) {
	var players []models.Player
	if err := models.DB.
		Session(&gorm.Session{AllowGlobalUpdate: true}).
		Clauses(clause.Returning{}).
		Delete(&players).Error; err != nil {
		c.String(http.StatusBadRequest, "Purge failed! Error: "+err.Error())
		return
	}

	c.String(http.StatusOK, "Purged "+utils.UintToString(uint(len(players)))+" players!")
}

func FindPlayerByID(id uint) *models.Player {
	var res models.Player
	if err := models.DB.Where("id = ?", id).First(&res).Error; err != nil {
		return nil
	} else {
		return &res
	}
}

func FindPlayerByName(out interface{}, c *gin.Context) *gorm.DB {
	return models.DB.Where("name = ?", c.Param("name")).First(out)
}