151 lines
3.8 KiB
Go
151 lines
3.8 KiB
Go
package fic
|
|
|
|
import (
|
|
"encoding/hex"
|
|
"fmt"
|
|
"log"
|
|
"time"
|
|
"path"
|
|
)
|
|
|
|
type myTeamFile struct {
|
|
Path string `json:"path"`
|
|
Name string `json:"name"`
|
|
Checksum string `json:"checksum"`
|
|
Size int64 `json:"size"`
|
|
}
|
|
type myTeamHint struct {
|
|
HintId int64 `json:"id"`
|
|
Title string `json:"title"`
|
|
Content *string `json:"content"`
|
|
File *string `json:"file"`
|
|
Cost int64 `json:"cost"`
|
|
}
|
|
type myTeamExercice struct {
|
|
ThemeId int `json:"theme_id"`
|
|
Statement string `json:"statement"`
|
|
Hints []myTeamHint `json:"hints"`
|
|
Gain float64 `json:"gain"`
|
|
Files []myTeamFile `json:"files"`
|
|
Keys []string `json:"keys"`
|
|
SolvedMat []bool `json:"solved_matrix"`
|
|
SolvedTime time.Time `json:"solved_time"`
|
|
SolvedRank int64 `json:"solved_rank"`
|
|
Tries int64 `json:"tries"`
|
|
VideoURI string `json:"video_uri"`
|
|
}
|
|
type myTeam struct {
|
|
Id int64 `json:"team_id"`
|
|
Name string `json:"name"`
|
|
Points int64 `json:"score"`
|
|
Members []Member `json:"members"`
|
|
Exercices map[string]myTeamExercice `json:"exercices"`
|
|
}
|
|
|
|
func MyJSONTeam(t *Team, started bool) (interface{}, error) {
|
|
ret := myTeam{}
|
|
|
|
// Fill information about the team
|
|
if t == nil {
|
|
ret.Id = 0
|
|
} else {
|
|
ret.Name = t.Name
|
|
ret.Id = t.Id
|
|
points, _ := t.GetPoints()
|
|
ret.Points = int64(points)
|
|
if members, err := t.GetMembers(); err == nil {
|
|
ret.Members = members
|
|
}
|
|
|
|
}
|
|
|
|
// Fill exercices, only if the challenge is started
|
|
ret.Exercices = map[string]myTeamExercice{}
|
|
if exos, err := GetExercices(); err != nil {
|
|
return ret, err
|
|
} else if started {
|
|
for _, e := range exos {
|
|
if t == nil || t.HasAccess(e) {
|
|
exercice := myTeamExercice{}
|
|
if tid, err := e.GetThemeId(); err == nil {
|
|
exercice.ThemeId = tid
|
|
}
|
|
exercice.Statement = e.Statement
|
|
if t == nil {
|
|
exercice.VideoURI = e.VideoURI
|
|
exercice.SolvedRank = 1
|
|
exercice.Tries = e.TriedCount()
|
|
exercice.Gain = float64(e.Gain) * e.Coefficient
|
|
} else {
|
|
var solved bool
|
|
solved, exercice.SolvedTime, exercice.SolvedRank = t.HasSolved(e)
|
|
|
|
if solved {
|
|
exercice.Tries, _ = t.CountTries(e)
|
|
} else {
|
|
exercice.Tries, exercice.SolvedTime = t.CountTries(e)
|
|
}
|
|
|
|
if gain, err := e.EstimateGain(*t, solved); err == nil {
|
|
exercice.Gain = gain
|
|
} else {
|
|
log.Println("ERROR during gain estimation:", err)
|
|
}
|
|
}
|
|
|
|
// Expose exercice files
|
|
|
|
exercice.Files = []myTeamFile{}
|
|
|
|
if files, err := e.GetFiles(); err != nil {
|
|
return nil, err
|
|
} else {
|
|
for _, f := range files {
|
|
exercice.Files = append(exercice.Files, myTeamFile{path.Join(FilesDir, f.Path), f.Name, hex.EncodeToString(f.Checksum), f.Size})
|
|
}
|
|
}
|
|
|
|
// Expose exercice hints
|
|
|
|
exercice.Hints = []myTeamHint{}
|
|
|
|
if hints, err := e.GetHints(); err != nil {
|
|
return nil, err
|
|
} else {
|
|
for _, h := range hints {
|
|
if t == nil || t.HasHint(h) {
|
|
exercice.Hints = append(exercice.Hints, myTeamHint{h.Id, h.Title, &h.Content, &h.File, h.Cost})
|
|
} else {
|
|
exercice.Hints = append(exercice.Hints, myTeamHint{h.Id, h.Title, nil, nil, h.Cost})
|
|
}
|
|
}
|
|
}
|
|
|
|
// Expose exercice keys
|
|
|
|
exercice.Keys = []string{}
|
|
|
|
if keys, err := e.GetKeys(); err != nil {
|
|
return nil, err
|
|
} else {
|
|
for _, k := range keys {
|
|
if t == nil {
|
|
exercice.Keys = append(exercice.Keys, fmt.Sprintf("%x", k.Value)+k.Type)
|
|
} else {
|
|
exercice.Keys = append(exercice.Keys, k.Type)
|
|
if PartialValidation {
|
|
exercice.SolvedMat = append(exercice.SolvedMat, t.HasPartiallySolved(k) != nil)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Hash table ordered by exercice Id
|
|
ret.Exercices[fmt.Sprintf("%d", e.Id)] = exercice
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret, nil
|
|
}
|