admin: Use gin-gonic as router

admin/api/team.go

@@ -3,167 +3,312 @@ package api
 import (
 	"encoding/json"
 	"fmt"
+	"log"
 	"math/rand"
+	"net/http"
+	"strconv"
 	"strings"
 	"time"
 
 	"srs.epita.fr/fic-server/admin/pki"
 	"srs.epita.fr/fic-server/libfic"
 
-	"github.com/julienschmidt/httprouter"
+	"github.com/gin-gonic/gin"
 )
 
-func init() {
-	router.GET("/api/teams.json", apiHandler(
-		func(httprouter.Params, []byte) (interface{}, error) {
-			return fic.ExportTeams(false)
-		}))
-	router.GET("/api/teams-members.json", apiHandler(
-		func(httprouter.Params, []byte) (interface{}, error) {
-			return fic.ExportTeams(true)
-		}))
-	router.GET("/api/teams-binding", apiHandler(
-		func(httprouter.Params, []byte) (interface{}, error) {
-			return bindingTeams()
-		}))
-	router.GET("/api/teams-nginx", apiHandler(
-		func(httprouter.Params, []byte) (interface{}, error) {
-			return nginxGenTeams()
-		}))
-	router.POST("/api/disableinactiveteams", apiHandler(disableInactiveTeams))
-	router.POST("/api/enableallteams", apiHandler(enableAllTeams))
-	router.GET("/api/teams-members-nginx", apiHandler(
-		func(httprouter.Params, []byte) (interface{}, error) {
-			return nginxGenMember()
-		}))
-	router.GET("/api/teams-tries.json", apiHandler(
-		func(httprouter.Params, []byte) (interface{}, error) {
-			return fic.GetTries(nil, nil)
-		}))
-
-	router.GET("/api/teams/", apiHandler(
-		func(httprouter.Params, []byte) (interface{}, error) {
-			return fic.GetTeams()
-		}))
-	router.POST("/api/teams/", apiHandler(createTeam))
-
-	router.GET("/api/teams/:tid/", apiHandler(teamHandler(
-		func(team *fic.Team, _ []byte) (interface{}, error) {
-			return team, nil
-		})))
-	router.PUT("/api/teams/:tid/", apiHandler(teamHandler(updateTeam)))
-	router.POST("/api/teams/:tid/", apiHandler(teamHandler(addTeamMember)))
-	router.DELETE("/api/teams/:tid/", apiHandler(teamHandler(deleteTeam)))
-	router.GET("/api/teams/:tid/score-grid.json", apiHandler(teamHandler(
-		func(team *fic.Team, _ []byte) (interface{}, error) {
-			return team.ScoreGrid()
-		})))
-	router.GET("/api/teams/:tid/my.json", apiHandler(teamPublicHandler(
-		func(team *fic.Team, _ []byte) (interface{}, error) {
-			return fic.MyJSONTeam(team, true)
-		})))
-	router.GET("/api/teams/:tid/wait.json", apiHandler(teamPublicHandler(
-		func(team *fic.Team, _ []byte) (interface{}, error) {
-			return fic.MyJSONTeam(team, false)
-		})))
-	router.GET("/api/teams/:tid/stats.json", apiHandler(teamPublicHandler(
-		func(team *fic.Team, _ []byte) (interface{}, error) {
-			if team != nil {
-				return team.GetStats()
-			} else {
-				return fic.GetTeamsStats(nil)
-			}
-		})))
-	router.GET("/api/teams/:tid/history.json", apiHandler(teamPublicHandler(
-		func(team *fic.Team, _ []byte) (interface{}, error) {
-			if team != nil {
-				return team.GetHistory()
-			} else {
-				return fic.GetTeamsStats(nil)
-			}
-		})))
-	router.DELETE("/api/teams/:tid/history.json", apiHandler(teamPublicHandler(delHistory)))
-	router.GET("/api/teams/:tid/tries", apiHandler(teamPublicHandler(
-		func(team *fic.Team, _ []byte) (interface{}, error) {
-			return fic.GetTries(team, nil)
-		})))
-	router.GET("/api/teams/:tid/members", apiHandler(teamHandler(
-		func(team *fic.Team, _ []byte) (interface{}, error) {
-			return team.GetMembers()
-		})))
-	router.POST("/api/teams/:tid/members", apiHandler(teamHandler(addTeamMember)))
-	router.PUT("/api/teams/:tid/members", apiHandler(teamHandler(setTeamMember)))
-}
-
-func nginxGenTeams() (string, error) {
-	if teams, err := fic.GetTeams(); err != nil {
-		return "", err
-	} else {
-		ret := ""
-		for _, team := range teams {
-			ret += fmt.Sprintf("        if ($remote_user = \"%s\") { set $team \"%d\"; }\n", strings.ToLower(team.Name), team.Id)
+func declareTeamsRoutes(router *gin.RouterGroup) {
+	router.GET("/teams.json", func(c *gin.Context) {
+		teams, err := fic.ExportTeams(false)
+		if err != nil {
+			log.Println("Unable to ExportTeams:", err.Error())
+			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during teams export."})
+			return
 		}
 
-		return ret, nil
-	}
-}
-
-func nginxGenMember() (string, error) {
-	if teams, err := fic.GetTeams(); err != nil {
-		return "", err
-	} else {
-		ret := ""
-		for _, team := range teams {
-			if members, err := team.GetMembers(); err == nil {
-				for _, member := range members {
-					ret += fmt.Sprintf("        if ($remote_user = \"%s\") { set $team \"%d\"; }\n", member.Nickname, team.Id)
-				}
-			} else {
-				return "", err
-			}
+		c.JSON(http.StatusOK, teams)
+	})
+	router.GET("/teams-members.json", func(c *gin.Context) {
+		teams, err := fic.ExportTeams(true)
+		if err != nil {
+			log.Println("Unable to ExportTeams:", err.Error())
+			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during teams export."})
+			return
 		}
 
-		return ret, nil
-	}
-}
-
-func bindingTeams() (string, error) {
-	if teams, err := fic.GetTeams(); err != nil {
-		return "", err
-	} else {
-		ret := ""
-		for _, team := range teams {
-			if members, err := team.GetMembers(); err != nil {
-				return "", err
-			} else {
-				var mbs []string
-				for _, member := range members {
-					mbs = append(mbs, fmt.Sprintf("%s %s", member.Firstname, member.Lastname))
-				}
-				ret += fmt.Sprintf("%d;%s;%s\n", team.Id, team.Name, strings.Join(mbs, ";"))
-			}
+		c.JSON(http.StatusOK, teams)
+	})
+	router.GET("/teams-binding", bindingTeams)
+	router.GET("/teams-nginx", nginxGenTeams)
+	router.POST("/disableinactiveteams", disableInactiveTeams)
+	router.POST("/enableallteams", enableAllTeams)
+	router.GET("/teams-members-nginx", nginxGenMember)
+	router.GET("/teams-tries.json", func(c *gin.Context) {
+		tries, err := fic.GetTries(nil, nil)
+		if err != nil {
+			log.Println("Unable to GetTries:", err.Error())
+			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "Unable to retrieves tries."})
+			return
 		}
-		return ret, nil
-	}
+
+		c.JSON(http.StatusOK, tries)
+	})
+
+	router.GET("/teams", func(c *gin.Context) {
+		teams, err := fic.GetTeams()
+		if err != nil {
+			log.Println("Unable to GetTeams:", err.Error())
+			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during teams listing."})
+			return
+		}
+
+		c.JSON(http.StatusOK, teams)
+	})
+	router.POST("/teams", createTeam)
+
+	apiTeamsRoutes := router.Group("/teams/:tid")
+	apiTeamsRoutes.Use(TeamHandler)
+	apiTeamsRoutes.GET("/", func(c *gin.Context) {
+		c.JSON(http.StatusOK, c.MustGet("team").(*fic.Team))
+	})
+	apiTeamsRoutes.PUT("/", updateTeam)
+	apiTeamsRoutes.POST("/", addTeamMember)
+	apiTeamsRoutes.DELETE("/", deleteTeam)
+	apiTeamsRoutes.GET("/score-grid.json", func(c *gin.Context) {
+		team := c.MustGet("team").(*fic.Team)
+
+		sg, err := team.ScoreGrid()
+		if err != nil {
+			log.Printf("Unable to get ScoreGrid(tid=%d): %s", team.Id, err.Error())
+			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during score grid calculation."})
+			return
+		}
+
+		c.JSON(http.StatusOK, sg)
+	})
+
+	apiTeamsPublicRoutes := router.Group("/teams/:tid")
+	apiTeamsPublicRoutes.Use(TeamPublicHandler)
+	apiTeamsPublicRoutes.GET("/my.json", func(c *gin.Context) {
+		tfile, err := fic.MyJSONTeam(c.MustGet("team").(*fic.Team), true)
+		if err != nil {
+			log.Println("Unable to get MyJSONTeam:", err.Error())
+			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during team JSON generation."})
+			return
+		}
+
+		c.JSON(http.StatusOK, tfile)
+	})
+	apiTeamsPublicRoutes.GET("/wait.json", func(c *gin.Context) {
+		tfile, err := fic.MyJSONTeam(c.MustGet("team").(*fic.Team), false)
+		if err != nil {
+			log.Println("Unable to get MyJSONTeam:", err.Error())
+			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during team JSON generation."})
+			return
+		}
+
+		c.JSON(http.StatusOK, tfile)
+	})
+	apiTeamsPublicRoutes.GET("/stats.json", func(c *gin.Context) {
+		team := c.MustGet("team").(*fic.Team)
+		if team != nil {
+			stats, err := team.GetStats()
+			if err != nil {
+				log.Println("Unable to get GetStats:", err.Error())
+				c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during stats calculation."})
+				return
+			}
+
+			c.JSON(http.StatusOK, stats)
+		} else {
+			stats, err := fic.GetTeamsStats(nil)
+			if err != nil {
+				log.Println("Unable to get GetTeamsStats:", err.Error())
+				c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during global stats calculation."})
+				return
+			}
+
+			c.JSON(http.StatusOK, stats)
+		}
+	})
+	apiTeamsRoutes.GET("/history.json", func(c *gin.Context) {
+		team := c.MustGet("team").(*fic.Team)
+
+		history, err := team.GetHistory()
+		if err != nil {
+			log.Println("Unable to get GetHistory:", err.Error())
+			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during history calculation."})
+			return
+		}
+
+		c.JSON(http.StatusOK, history)
+	})
+	apiTeamsRoutes.DELETE("/history.json", delHistory)
+	apiTeamsPublicRoutes.GET("/tries", func(c *gin.Context) {
+		team := c.MustGet("team").(*fic.Team)
+
+		tries, err := fic.GetTries(team, nil)
+		if err != nil {
+			log.Println("Unable to GetTries:", err.Error())
+			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during tries calculation."})
+			return
+		}
+
+		c.JSON(http.StatusOK, tries)
+	})
+	apiTeamsRoutes.GET("/members", func(c *gin.Context) {
+		team := c.MustGet("team").(*fic.Team)
+
+		members, err := team.GetMembers()
+		if err != nil {
+			log.Println("Unable to GetMembers:", err.Error())
+			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during members retrieval."})
+			return
+		}
+
+		c.JSON(http.StatusOK, members)
+	})
+	apiTeamsRoutes.POST("/members", addTeamMember)
+	apiTeamsRoutes.PUT("/members", setTeamMember)
+
+	declareTeamsPasswordRoutes(apiTeamsRoutes)
+	declareTeamClaimsRoutes(apiTeamsRoutes)
+	declareTeamCertificateRoutes(apiTeamsRoutes)
 }
 
-func createTeam(_ httprouter.Params, body []byte) (interface{}, error) {
+func TeamHandler(c *gin.Context) {
+	tid, err := strconv.ParseInt(string(c.Params.ByName("tid")), 10, 64)
+	if err != nil {
+		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": "Invalid team identifier"})
+		return
+	}
+
+	team, err := fic.GetTeam(tid)
+	if err != nil {
+		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"errmsg": "Team not found"})
+		return
+	}
+
+	c.Set("team", team)
+
+	c.Next()
+}
+
+func TeamPublicHandler(c *gin.Context) {
+	tid, err := strconv.ParseInt(string(c.Params.ByName("tid")), 10, 64)
+	if err != nil {
+		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": "Invalid team identifier"})
+		return
+	}
+
+	if tid != 0 {
+		team, err := fic.GetTeam(tid)
+		if err != nil {
+			c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"errmsg": "Team not found"})
+			return
+		}
+
+		c.Set("team", team)
+	} else {
+		c.Set("team", nil)
+	}
+
+	c.Next()
+}
+
+func nginxGenTeams(c *gin.Context) {
+	teams, err := fic.GetTeams()
+	if err != nil {
+		log.Println("Unable to GetTeams:", err.Error())
+		c.AbortWithError(http.StatusInternalServerError, err)
+		return
+	}
+
+	ret := ""
+	for _, team := range teams {
+		ret += fmt.Sprintf("        if ($remote_user = \"%s\") { set $team \"%d\"; }\n", strings.ToLower(team.Name), team.Id)
+	}
+
+	c.String(http.StatusOK, ret)
+}
+
+func nginxGenMember(c *gin.Context) {
+	teams, err := fic.GetTeams()
+	if err != nil {
+		log.Println("Unable to GetTeams:", err.Error())
+		c.AbortWithError(http.StatusInternalServerError, err)
+		return
+	}
+
+	ret := ""
+	for _, team := range teams {
+		if members, err := team.GetMembers(); err == nil {
+			for _, member := range members {
+				ret += fmt.Sprintf("        if ($remote_user = \"%s\") { set $team \"%d\"; }\n", member.Nickname, team.Id)
+			}
+		} else {
+			c.AbortWithError(http.StatusInternalServerError, err)
+			return
+		}
+	}
+
+	c.String(http.StatusOK, ret)
+}
+
+func bindingTeams(c *gin.Context) {
+	teams, err := fic.GetTeams()
+	if err != nil {
+		log.Println("Unable to GetTeams:", err.Error())
+		c.AbortWithError(http.StatusInternalServerError, err)
+		return
+	}
+
+	ret := ""
+	for _, team := range teams {
+		if members, err := team.GetMembers(); err != nil {
+			c.AbortWithError(http.StatusInternalServerError, err)
+			return
+		} else {
+			var mbs []string
+			for _, member := range members {
+				mbs = append(mbs, fmt.Sprintf("%s %s", member.Firstname, member.Lastname))
+			}
+			ret += fmt.Sprintf("%d;%s;%s\n", team.Id, team.Name, strings.Join(mbs, ";"))
+		}
+	}
+
+	c.String(http.StatusOK, ret)
+}
+
+func createTeam(c *gin.Context) {
 	var ut fic.Team
-	if err := json.Unmarshal(body, &ut); err != nil {
-		return nil, err
+	err := c.ShouldBindJSON(&ut)
+	if err != nil {
+		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": err.Error()})
+		return
 	}
 
 	if ut.Color == 0 {
 		ut.Color = fic.HSL{rand.Float64(), 1, 0.5}.ToRGB()
 	}
 
-	return fic.CreateTeam(strings.TrimSpace(ut.Name), ut.Color, ut.ExternalId)
+	team, err := fic.CreateTeam(strings.TrimSpace(ut.Name), ut.Color, ut.ExternalId)
+	if err != nil {
+		log.Println("Unable to CreateTeam:", err.Error())
+		c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during team creation."})
+		return
+	}
+
+	c.JSON(http.StatusOK, team)
 }
 
-func updateTeam(team *fic.Team, body []byte) (interface{}, error) {
+func updateTeam(c *gin.Context) {
+	team := c.MustGet("team").(*fic.Team)
+
 	var ut fic.Team
-	if err := json.Unmarshal(body, &ut); err != nil {
-		return nil, err
+	err := c.ShouldBindJSON(&ut)
+	if err != nil {
+		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": err.Error()})
+		return
 	}
 
 	ut.Id = team.Id
@@ -172,102 +317,132 @@ func updateTeam(team *fic.Team, body []byte) (interface{}, error) {
 		ut.Password = nil
 	}
 
-	if _, err := ut.Update(); err != nil {
-		return nil, err
+	_, err = ut.Update()
+	if err != nil {
+		log.Println("Unable to updateTeam:", err.Error())
+		c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during team updating."})
+		return
 	}
 
-	return ut, nil
+	c.JSON(http.StatusOK, team)
 }
 
-func disableInactiveTeams(_ httprouter.Params, _ []byte) (interface{}, error) {
-	if teams, err := fic.GetTeams(); err != nil {
-		return nil, err
-	} else {
-		for _, team := range teams {
-			var serials []uint64
-			serials, err = pki.GetTeamSerials(TeamsDir, team.Id)
-			if err != nil {
-				return nil, err
-			}
+func disableInactiveTeams(c *gin.Context) {
+	teams, err := fic.GetTeams()
+	if err != nil {
+		log.Println("Unable to GetTeams:", err.Error())
+		c.AbortWithError(http.StatusInternalServerError, err)
+		return
+	}
 
-			var assocs []string
-			assocs, err = pki.GetTeamAssociations(TeamsDir, team.Id)
-			if err != nil {
-				return nil, err
-			}
-
-			if len(serials) == 0 && len(assocs) == 0 {
-				if team.Active {
-					team.Active = false
-					team.Update()
-				}
-			} else if !team.Active {
-				team.Active = true
-				team.Update()
-			}
+	for _, team := range teams {
+		var serials []uint64
+		serials, err = pki.GetTeamSerials(TeamsDir, team.Id)
+		if err != nil {
+			c.AbortWithError(http.StatusInternalServerError, err)
+			return
 		}
 
-		return true, nil
-	}
-}
-
-func enableAllTeams(_ httprouter.Params, _ []byte) (interface{}, error) {
-	if teams, err := fic.GetTeams(); err != nil {
-		return nil, err
-	} else {
-		for _, team := range teams {
-			if !team.Active {
-				team.Active = true
-				team.Update()
-			}
+		var assocs []string
+		assocs, err = pki.GetTeamAssociations(TeamsDir, team.Id)
+		if err != nil {
+			c.AbortWithError(http.StatusInternalServerError, err)
+			return
 		}
 
-		return true, nil
+		if len(serials) == 0 && len(assocs) == 0 {
+			if team.Active {
+				team.Active = false
+				team.Update()
+			}
+		} else if !team.Active {
+			team.Active = true
+			team.Update()
+		}
 	}
+
+	c.JSON(http.StatusOK, true)
 }
 
-func deleteTeam(team *fic.Team, _ []byte) (interface{}, error) {
+func enableAllTeams(c *gin.Context) {
+	teams, err := fic.GetTeams()
+	if err != nil {
+		log.Println("Unable to GetTeams:", err.Error())
+		c.AbortWithError(http.StatusInternalServerError, err)
+		return
+	}
+
+	for _, team := range teams {
+		if !team.Active {
+			team.Active = true
+			team.Update()
+		}
+	}
+
+	c.JSON(http.StatusOK, true)
+}
+
+func deleteTeam(c *gin.Context) {
+	team := c.MustGet("team").(*fic.Team)
+
 	assocs, err := pki.GetTeamAssociations(TeamsDir, team.Id)
 	if err != nil {
-		return nil, err
+		log.Printf("Unable to GetTeamAssociations(tid=%s): %s", team.Id, err.Error())
+		c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs when trying to retrieve team association."})
+		return
 	}
 
 	for _, assoc := range assocs {
 		err = pki.DeleteTeamAssociation(TeamsDir, assoc)
+		if err != nil {
+			log.Printf("Unable to DeleteTeamAssociation(assoc=%s): %s", assoc, err.Error())
+			return
+		}
 	}
 
+	_, err = team.Delete()
 	if err != nil {
-		return nil, err
+		log.Println("Unable to deleteTeam:", err.Error())
+		c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during team deletion."})
+		return
 	}
 
-	return team.Delete()
+	c.JSON(http.StatusOK, true)
 }
 
-func addTeamMember(team *fic.Team, body []byte) (interface{}, error) {
+func addTeamMember(c *gin.Context) {
+	team := c.MustGet("team").(*fic.Team)
+
 	var members []fic.Member
-	if err := json.Unmarshal(body, &members); err != nil {
-		return nil, err
+	err := c.ShouldBindJSON(&members)
+	if err != nil {
+		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": err.Error()})
+		return
 	}
 
 	for _, member := range members {
-		team.AddMember(strings.TrimSpace(member.Firstname), strings.TrimSpace(member.Lastname), strings.TrimSpace(member.Nickname), strings.TrimSpace(member.Company))
+		_, err := team.AddMember(strings.TrimSpace(member.Firstname), strings.TrimSpace(member.Lastname), strings.TrimSpace(member.Nickname), strings.TrimSpace(member.Company))
+		if err != nil {
+			log.Println("Unable to AddMember:", err.Error())
+			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "An error occurs during member creation."})
+			return
+		}
 	}
 
-	return team.GetMembers()
+	mmbrs, err := team.GetMembers()
+	if err != nil {
+		log.Println("Unable to retrieve members list:", err.Error())
+		c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": "Unable to retrieve members list."})
+		return
+	}
+
+	c.JSON(http.StatusOK, mmbrs)
 }
 
-func setTeamMember(team *fic.Team, body []byte) (interface{}, error) {
-	var members []fic.Member
-	if err := json.Unmarshal(body, &members); err != nil {
-		return nil, err
-	}
-
+func setTeamMember(c *gin.Context) {
+	team := c.MustGet("team").(*fic.Team)
 	team.ClearMembers()
-	for _, member := range members {
-		team.AddMember(strings.TrimSpace(member.Firstname), strings.TrimSpace(member.Lastname), strings.TrimSpace(member.Nickname), strings.TrimSpace(member.Company))
-	}
-
-	return team.GetMembers()
+	addTeamMember(c)
 }
 
 type uploadedHistory struct {
@@ -294,11 +469,21 @@ func updateHistory(team *fic.Team, body []byte) (interface{}, error) {
 	return team.UpdateHistoryCoeff(uh.Kind, uh.Time, givenId, uh.Coefficient)
 }
 
-func delHistory(team *fic.Team, body []byte) (interface{}, error) {
+func delHistory(c *gin.Context) {
+	team := c.MustGet("team").(*fic.Team)
+
 	var uh uploadedHistory
-	if err := json.Unmarshal(body, &uh); err != nil {
-		return nil, err
+	err := c.ShouldBindJSON(&uh)
+	if err != nil {
+		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"errmsg": err.Error()})
+		return
 	}
 
-	return team.DelHistoryItem(uh.Kind, uh.Time, uh.Primary, uh.Secondary)
+	_, err = team.DelHistoryItem(uh.Kind, uh.Time, uh.Primary, uh.Secondary)
+	if err != nil {
+		c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"errmsg": fmt.Sprintf("Unable to delete this history line: %s", err.Error())})
+		return
+	}
+
+	c.JSON(http.StatusOK, true)
 }