InfantrySkillCalculator/controllers/player_controller.go

package controllers

import (
	"InfantrySkillCalculator/models"
	"InfantrySkillCalculator/utils"
	"fmt"
	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
	"log"
	"net/http"
	"os"
)

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

	file, err := os.ReadFile("./templates/player_list_item.html")
	if err != nil {
		return
	}
	playerItem := string(file)

	var htmlOptions string
	for _, player := range players {
		htmlOptions += fmt.Sprintf(playerItem, player.Name, "----", player.ID, player.ID)
	}

	c.Header("Content-Type", "text/html")
	c.String(http.StatusOK, htmlOptions)
}

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

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