302 lines
9.0 KiB
Go
302 lines
9.0 KiB
Go
package api
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"path"
|
|
"time"
|
|
|
|
"srs.epita.fr/fic-server/libfic"
|
|
|
|
"github.com/julienschmidt/httprouter"
|
|
)
|
|
|
|
func init() {
|
|
router.GET("/api/teams/:tid/issue.json", apiHandler(teamHandler(
|
|
func(team fic.Team, _ []byte) (interface{}, error) {
|
|
return team.MyIssueFile()
|
|
})))
|
|
|
|
// Tasks
|
|
router.GET("/api/claims", apiHandler(getClaims))
|
|
router.POST("/api/claims", apiHandler(newClaim))
|
|
router.DELETE("/api/claims", apiHandler(clearClaims))
|
|
router.GET("/api/teams/:tid/claims", apiHandler(teamHandler(getTeamClaims)))
|
|
router.GET("/api/exercices/:eid/claims", apiHandler(exerciceHandler(getExerciceClaims)))
|
|
router.GET("/api/themes/:thid/exercices/:eid/claims", apiHandler(exerciceHandler(getExerciceClaims)))
|
|
|
|
router.GET("/api/claims/:cid", apiHandler(claimHandler(showClaim)))
|
|
router.PUT("/api/claims/:cid", apiHandler(claimHandler(updateClaim)))
|
|
router.POST("/api/claims/:cid", apiHandler(claimHandler(addClaimDescription)))
|
|
router.DELETE("/api/claims/:cid", apiHandler(claimHandler(deleteClaim)))
|
|
|
|
router.GET("/api/claims/:cid/last_update", apiHandler(claimHandler(getClaimLastUpdate)))
|
|
router.PUT("/api/claims/:cid/descriptions", apiHandler(claimHandler(updateClaimDescription)))
|
|
|
|
// Assignees
|
|
router.GET("/api/claims-assignees", apiHandler(getAssignees))
|
|
router.POST("/api/claims-assignees", apiHandler(newAssignee))
|
|
|
|
router.GET("/api/claims-assignees/:aid", apiHandler(claimAssigneeHandler(showClaimAssignee)))
|
|
router.PUT("/api/claims-assignees/:aid", apiHandler(claimAssigneeHandler(updateClaimAssignee)))
|
|
router.DELETE("/api/claims-assignees/:aid", apiHandler(claimAssigneeHandler(deleteClaimAssignee)))
|
|
}
|
|
|
|
func getClaims(_ httprouter.Params, _ []byte) (interface{}, error) {
|
|
return fic.GetClaims()
|
|
}
|
|
|
|
func getTeamClaims(team fic.Team, _ []byte) (interface{}, error) {
|
|
return team.GetClaims()
|
|
}
|
|
|
|
func getExerciceClaims(exercice fic.Exercice, _ []byte) (interface{}, error) {
|
|
return exercice.GetClaims()
|
|
}
|
|
|
|
func getClaimLastUpdate(claim fic.Claim, _ []byte) (interface{}, error) {
|
|
return claim.GetLastUpdate()
|
|
}
|
|
|
|
type ClaimExported struct {
|
|
Id int64 `json:"id"`
|
|
Subject string `json:"subject"`
|
|
IdTeam *int64 `json:"id_team"`
|
|
Team *fic.Team `json:"team"`
|
|
IdExercice *int64 `json:"id_exercice"`
|
|
Exercice *fic.Exercice `json:"exercice"`
|
|
IdAssignee *int64 `json:"id_assignee"`
|
|
Assignee *fic.ClaimAssignee `json:"assignee"`
|
|
Creation time.Time `json:"creation"`
|
|
LastUpdate time.Time `json:"last_update"`
|
|
State string `json:"state"`
|
|
Priority string `json:"priority"`
|
|
Descriptions []fic.ClaimDescription `json:"descriptions"`
|
|
}
|
|
|
|
func showClaim(claim fic.Claim, _ []byte) (interface{}, error) {
|
|
var e ClaimExported
|
|
var err error
|
|
if e.Team, err = claim.GetTeam(); err != nil {
|
|
return nil, fmt.Errorf("Unable to find associated team: %w", err)
|
|
}
|
|
if e.Exercice, err = claim.GetExercice(); err != nil {
|
|
return nil, fmt.Errorf("Unable to find associated exercice: %w", err)
|
|
}
|
|
if e.Assignee, err = claim.GetAssignee(); err != nil {
|
|
return nil, fmt.Errorf("Unable to find associated assignee: %w", err)
|
|
}
|
|
if e.Descriptions, err = claim.GetDescriptions(); err != nil {
|
|
return nil, fmt.Errorf("Unable to find claim's descriptions: %w", err)
|
|
}
|
|
|
|
e.LastUpdate = e.Creation
|
|
for _, d := range e.Descriptions {
|
|
if d.Date.After(e.LastUpdate) {
|
|
e.LastUpdate = d.Date
|
|
}
|
|
}
|
|
|
|
e.Id = claim.Id
|
|
e.IdAssignee = claim.IdAssignee
|
|
e.IdTeam = claim.IdTeam
|
|
e.IdExercice = claim.IdExercice
|
|
e.Subject = claim.Subject
|
|
e.Creation = claim.Creation
|
|
e.State = claim.State
|
|
e.Priority = claim.Priority
|
|
return e, nil
|
|
}
|
|
|
|
type ClaimUploaded struct {
|
|
fic.Claim
|
|
Whoami *int64 `json:"whoami"`
|
|
}
|
|
|
|
func newClaim(_ httprouter.Params, body []byte) (interface{}, error) {
|
|
var uc ClaimUploaded
|
|
if err := json.Unmarshal(body, &uc); err != nil {
|
|
return nil, fmt.Errorf("Unable to decode JSON: %w", err)
|
|
}
|
|
|
|
if uc.Subject == "" {
|
|
return nil, errors.New("Claim's subject cannot be empty.")
|
|
}
|
|
|
|
var t *fic.Team
|
|
if uc.IdTeam != nil {
|
|
if team, err := fic.GetTeam(*uc.IdTeam); err != nil {
|
|
return nil, fmt.Errorf("Unable to get associated team: %w", err)
|
|
} else {
|
|
t = &team
|
|
}
|
|
} else {
|
|
t = nil
|
|
}
|
|
|
|
var e *fic.Exercice
|
|
if uc.IdExercice != nil {
|
|
if exercice, err := fic.GetExercice(*uc.IdExercice); err != nil {
|
|
return nil, fmt.Errorf("Unable to get associated exercice: %w", err)
|
|
} else {
|
|
e = &exercice
|
|
}
|
|
} else {
|
|
e = nil
|
|
}
|
|
|
|
var a *fic.ClaimAssignee
|
|
if uc.IdAssignee != nil {
|
|
if assignee, err := fic.GetAssignee(*uc.IdAssignee); err != nil {
|
|
return nil, fmt.Errorf("Unable to get associated assignee: %w", err)
|
|
} else {
|
|
a = &assignee
|
|
}
|
|
} else {
|
|
a = nil
|
|
}
|
|
|
|
if uc.Priority == "" {
|
|
uc.Priority = "medium"
|
|
}
|
|
|
|
return fic.NewClaim(uc.Subject, t, e, a, uc.Priority)
|
|
}
|
|
|
|
func clearClaims(_ httprouter.Params, _ []byte) (interface{}, error) {
|
|
return fic.ClearClaims()
|
|
}
|
|
|
|
func generateTeamIssuesFile(team fic.Team) error {
|
|
if my, err := team.MyIssueFile(); err != nil {
|
|
return fmt.Errorf("Unable to generate issue FILE (tid=%d): %w", team.Id, err)
|
|
} else if j, err := json.Marshal(my); err != nil {
|
|
return fmt.Errorf("Unable to encode issues' file JSON: %w", err)
|
|
} else if err = ioutil.WriteFile(path.Join(TeamsDir, fmt.Sprintf("%d", team.Id), "issues.json"), j, 0644); err != nil {
|
|
return fmt.Errorf("Unable to write issues' file: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func addClaimDescription(claim fic.Claim, body []byte) (interface{}, error) {
|
|
var ud fic.ClaimDescription
|
|
if err := json.Unmarshal(body, &ud); err != nil {
|
|
return nil, fmt.Errorf("Unable to decode JSON: %w", err)
|
|
}
|
|
|
|
if assignee, err := fic.GetAssignee(ud.IdAssignee); err != nil {
|
|
return nil, fmt.Errorf("Unable to get associated assignee: %w", err)
|
|
} else if description, err := claim.AddDescription(ud.Content, assignee, ud.Publish); err != nil {
|
|
return nil, fmt.Errorf("Unable to add description: %w", err)
|
|
} else {
|
|
if team, _ := claim.GetTeam(); team != nil {
|
|
err = generateTeamIssuesFile(*team)
|
|
}
|
|
|
|
return description, err
|
|
}
|
|
}
|
|
|
|
func updateClaimDescription(claim fic.Claim, body []byte) (interface{}, error) {
|
|
var ud fic.ClaimDescription
|
|
if err := json.Unmarshal(body, &ud); err != nil {
|
|
return nil, fmt.Errorf("Unable to decode JSON: %w", err)
|
|
}
|
|
|
|
if _, err := ud.Update(); err != nil {
|
|
return nil, fmt.Errorf("Unable to update description: %w", err)
|
|
} else {
|
|
if team, _ := claim.GetTeam(); team != nil {
|
|
err = generateTeamIssuesFile(*team)
|
|
}
|
|
|
|
return ud, err
|
|
}
|
|
}
|
|
|
|
func updateClaim(claim fic.Claim, body []byte) (interface{}, error) {
|
|
var uc ClaimUploaded
|
|
if err := json.Unmarshal(body, &uc); err != nil {
|
|
return nil, fmt.Errorf("Unable to decode JSON: %w", err)
|
|
}
|
|
|
|
uc.Id = claim.Id
|
|
|
|
if _, err := uc.Update(); err != nil {
|
|
return nil, fmt.Errorf("Unable to update claim: %w", err)
|
|
} else {
|
|
if claim.State != uc.State {
|
|
if uc.Whoami != nil {
|
|
if assignee, err := fic.GetAssignee(*uc.Whoami); err == nil {
|
|
claim.AddDescription(fmt.Sprintf("%s a changé l'état de la tâche vers %q (était %q).", assignee.Name, uc.State, claim.State), assignee, true)
|
|
}
|
|
}
|
|
}
|
|
|
|
if claim.IdAssignee != uc.IdAssignee {
|
|
if uc.Whoami != nil {
|
|
if whoami, err := fic.GetAssignee(*uc.Whoami); err == nil {
|
|
if uc.IdAssignee != nil {
|
|
if assignee, err := fic.GetAssignee(*uc.IdAssignee); err == nil {
|
|
if assignee.Id != whoami.Id {
|
|
claim.AddDescription(fmt.Sprintf("%s a assigné la tâche à %s.", whoami.Name, assignee.Name), whoami, false)
|
|
} else {
|
|
claim.AddDescription(fmt.Sprintf("%s s'est assigné la tâche.", assignee.Name), whoami, false)
|
|
}
|
|
}
|
|
} else {
|
|
claim.AddDescription(fmt.Sprintf("%s a retiré l'attribution de la tâche.", whoami.Name), whoami, false)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if team, _ := claim.GetTeam(); team != nil {
|
|
err = generateTeamIssuesFile(*team)
|
|
}
|
|
|
|
return uc, err
|
|
}
|
|
}
|
|
|
|
func deleteClaim(claim fic.Claim, _ []byte) (interface{}, error) {
|
|
return claim.Delete()
|
|
}
|
|
|
|
func getAssignees(_ httprouter.Params, _ []byte) (interface{}, error) {
|
|
return fic.GetAssignees()
|
|
}
|
|
|
|
func showClaimAssignee(assignee fic.ClaimAssignee, _ []byte) (interface{}, error) {
|
|
return assignee, nil
|
|
}
|
|
func newAssignee(_ httprouter.Params, body []byte) (interface{}, error) {
|
|
var ua fic.ClaimAssignee
|
|
if err := json.Unmarshal(body, &ua); err != nil {
|
|
return nil, fmt.Errorf("Unable to decode JSON: %w", err)
|
|
}
|
|
|
|
return fic.NewClaimAssignee(ua.Name)
|
|
}
|
|
|
|
func updateClaimAssignee(assignee fic.ClaimAssignee, body []byte) (interface{}, error) {
|
|
var ua fic.ClaimAssignee
|
|
if err := json.Unmarshal(body, &ua); err != nil {
|
|
return nil, fmt.Errorf("Unable to decode JSON: %w", err)
|
|
}
|
|
|
|
ua.Id = assignee.Id
|
|
|
|
if _, err := ua.Update(); err != nil {
|
|
return nil, fmt.Errorf("Unable to update claim assignee: %w", err)
|
|
} else {
|
|
return ua, nil
|
|
}
|
|
}
|
|
|
|
func deleteClaimAssignee(assignee fic.ClaimAssignee, _ []byte) (interface{}, error) {
|
|
return assignee.Delete()
|
|
}
|