server/admin/api/claim.go

package api

import (
	"encoding/json"
	"errors"
	"time"

	"srs.epita.fr/fic-server/libfic"

	"github.com/julienschmidt/httprouter"
)

func init() {
	// 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)))

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

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, err
	}
	if e.Exercice, err = claim.GetExercice(); err != nil {
		return nil, err
	}
	if e.Assignee, err = claim.GetAssignee(); err != nil {
		return nil, err
	}
	if e.Descriptions, err = claim.GetDescriptions(); err != nil {
		return nil, 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 {
	Subject  string `json:"subject"`
	Team     *int64 `json:"id_team"`
	Exercice *int64 `json:"id_exercice"`
	Assignee *int64 `json:"id_assignee"`
	Priority string `json:"priority"`
}

func newClaim(_ httprouter.Params, body []byte) (interface{}, error) {
	var uc ClaimUploaded
	if err := json.Unmarshal(body, &uc); err != nil {
		return nil, err
	}

	if uc.Subject == "" {
		return nil, errors.New("Claim's subject cannot be empty.")
	}

	var t *fic.Team
	if uc.Team != nil {
		if team, err := fic.GetTeam(*uc.Team); err != nil {
			return nil, err
		} else {
			t = &team
		}
	} else {
		t = nil
	}

	var e *fic.Exercice
	if uc.Exercice != nil {
		if exercice, err := fic.GetExercice(*uc.Exercice); err != nil {
			return nil, err
		} else {
			e = &exercice
		}
	} else {
		e = nil
	}

	var a *fic.ClaimAssignee
	if uc.Assignee != nil {
		if assignee, err := fic.GetAssignee(*uc.Assignee); err != nil {
			return nil, 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 addClaimDescription(claim fic.Claim, body []byte) (interface{}, error) {
	var ud fic.ClaimDescription
	if err := json.Unmarshal(body, &ud); err != nil {
		return nil, err
	}

	if assignee, err := fic.GetAssignee(ud.IdAssignee); err != nil {
		return nil, err
	} else {
		return claim.AddDescription(ud.Content, assignee)
	}
}

func updateClaim(claim fic.Claim, body []byte) (interface{}, error) {
	var uc fic.Claim
	if err := json.Unmarshal(body, &uc); err != nil {
		return nil, err
	}

	uc.Id = claim.Id

	if _, err := uc.Update(); err != nil {
		return nil, err
	} else {
		return uc, nil
	}
}

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, 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, err
	}

	ua.Id = assignee.Id

	if _, err := ua.Update(); err != nil {
		return nil, err
	} else {
		return ua, nil
	}
}

func deleteClaimAssignee(assignee fic.ClaimAssignee, _ []byte) (interface{}, error) {
	return assignee.Delete()
}