282 lines
7.5 KiB
Go
282 lines
7.5 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,omitempty"`
|
|
File string `json:"file,omitempty"`
|
|
Cost int64 `json:"cost"`
|
|
}
|
|
type myTeamMCQ struct {
|
|
Title string `json:"title"`
|
|
Justify []int64 `json:"justify,omitempty"`
|
|
Choices map[int64]string `json:"choices,omitempty"`
|
|
Solved *time.Time `json:"solved,omitempty"`
|
|
PSolved map[int64]int `json:"checks_solved,omitempty"`
|
|
Soluce string `json:"soluce,omitempty"`
|
|
}
|
|
type myTeamFlag struct {
|
|
Label string `json:"label"`
|
|
Help string `json:"help,omitempty"`
|
|
Solved *time.Time `json:"found,omitempty"`
|
|
Soluce string `json:"soluce,omitempty"`
|
|
Choices map[string]string `json:"choices,omitempty"`
|
|
}
|
|
type myTeamExercice struct {
|
|
ThemeId int `json:"theme_id"`
|
|
Statement string `json:"statement"`
|
|
Overview string `json:"overview,omitempty"`
|
|
Hints []myTeamHint `json:"hints,omitempty"`
|
|
Gain int `json:"gain"`
|
|
Files []myTeamFile `json:"files,omitempty"`
|
|
Flags map[int64]myTeamFlag `json:"flags,omitempty"`
|
|
MCQs map[int64]myTeamMCQ `json:"mcqs,omitempty"`
|
|
SolveDist int64 `json:"solve_dist,omitempty"`
|
|
SolvedTime *time.Time `json:"solved_time,omitempty"`
|
|
SolvedRank int64 `json:"solved_rank,omitempty"`
|
|
Tries int64 `json:"tries,omitempty"`
|
|
VideoURI string `json:"video_uri,omitempty"`
|
|
Issue string `json:"issue,omitempty"`
|
|
IssueKind string `json:"issuekind,omitempty"`
|
|
}
|
|
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 len(e.Issue) > 0 {
|
|
exercice.Issue = e.Issue
|
|
exercice.IssueKind = e.IssueKind
|
|
}
|
|
|
|
if t == nil {
|
|
exercice.Overview = e.Overview
|
|
exercice.VideoURI = e.VideoURI
|
|
exercice.Tries = e.TriedCount()
|
|
exercice.Gain = int(float64(e.Gain) * e.Coefficient)
|
|
} else {
|
|
solved, stime := t.HasSolved(e)
|
|
exercice.SolvedTime = &stime
|
|
exercice.SolvedRank, _ = t.GetSolvedRank(e)
|
|
|
|
if solved {
|
|
exercice.Tries, _ = t.CountTries(e)
|
|
} else {
|
|
exercice.Tries, stime = t.CountTries(e)
|
|
exercice.SolvedTime = &stime
|
|
if exercice.Tries > 0 {
|
|
exercice.SolveDist = t.LastTryDist(e)
|
|
}
|
|
}
|
|
|
|
if gain, err := e.EstimateGain(*t, solved); err == nil {
|
|
exercice.Gain = int(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 {
|
|
if t == nil || t.CanDownload(f) {
|
|
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, "", "", h.Cost})
|
|
}
|
|
}
|
|
}
|
|
|
|
// Expose exercice flags
|
|
|
|
justifiedMCQ := map[string][]byte{}
|
|
justifiedMCQ_ids := map[string]int64{}
|
|
exercice.Flags = map[int64]myTeamFlag{}
|
|
|
|
if flags, err := e.GetFlags(); err != nil {
|
|
return nil, err
|
|
} else {
|
|
for _, k := range flags {
|
|
var flag myTeamFlag
|
|
|
|
if k.Label[0] == '%' {
|
|
justifiedMCQ[k.Label[1:]] = k.Checksum
|
|
if t == nil || t.HasPartiallySolved(k) == nil {
|
|
justifiedMCQ_ids[k.Label[1:]] = k.Id
|
|
}
|
|
continue
|
|
} else if t == nil {
|
|
flag.Soluce = hex.EncodeToString(k.Checksum)
|
|
} else if PartialValidation {
|
|
flag.Solved = t.HasPartiallySolved(k)
|
|
}
|
|
|
|
flag.Label = k.Label
|
|
|
|
if flag.Solved == nil {
|
|
flag.Help = k.Help
|
|
if choices, err := k.GetChoices(); err != nil {
|
|
return nil, err
|
|
} else {
|
|
flag.Choices = map[string]string{}
|
|
for _, c := range choices {
|
|
flag.Choices[c.Value] = c.Label
|
|
}
|
|
}
|
|
}
|
|
|
|
exercice.Flags[k.Id] = flag
|
|
}
|
|
}
|
|
|
|
// Expose exercice MCQs
|
|
|
|
exercice.MCQs = map[int64]myTeamMCQ{}
|
|
|
|
if mcqs, err := e.GetMCQ(); err != nil {
|
|
return nil, err
|
|
} else {
|
|
for _, mcq := range mcqs {
|
|
m := myTeamMCQ{
|
|
Title: mcq.Title,
|
|
Choices: map[int64]string{},
|
|
}
|
|
|
|
soluce := ""
|
|
solved_justify := true
|
|
var nb_gen_justify_id int64
|
|
var max_justify_id int64
|
|
|
|
for _, e := range mcq.Entries {
|
|
m.Choices[e.Id] = e.Label
|
|
if e.Response {
|
|
soluce += "t"
|
|
} else {
|
|
soluce += "f"
|
|
}
|
|
if v, ok := justifiedMCQ[m.Title + "%" + e.Label]; ok {
|
|
if m.Justify == nil {
|
|
m.Justify = []int64{}
|
|
}
|
|
|
|
if t == nil {
|
|
soluce += hex.EncodeToString(v)
|
|
}
|
|
|
|
if v, ok := justifiedMCQ_ids[m.Title + "%" + e.Label]; ok {
|
|
solved_justify = false
|
|
m.Justify = append(m.Justify, v)
|
|
if v > max_justify_id {
|
|
max_justify_id = v
|
|
}
|
|
}
|
|
} else {
|
|
nb_gen_justify_id += 1
|
|
}
|
|
}
|
|
|
|
// Fill the rest of the array with factice values in order to hide number of valid choices
|
|
for i := int64(0); i < nb_gen_justify_id; i++ {
|
|
m.Justify = append(m.Justify, max_justify_id + 1 + i)
|
|
}
|
|
|
|
if t != nil {
|
|
if solved_justify {
|
|
m.Solved = t.HasPartiallyRespond(mcq)
|
|
} else if PartialValidation && t.HasPartiallyRespond(mcq) != nil {
|
|
m.PSolved = map[int64]int{}
|
|
for _, e := range mcq.Entries {
|
|
if _, ok := justifiedMCQ[m.Title + "%" + e.Label]; ok {
|
|
if _, ok := justifiedMCQ_ids[m.Title + "%" + e.Label]; !ok {
|
|
m.PSolved[e.Id] = 2
|
|
} else if e.Response {
|
|
m.PSolved[e.Id] = 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
h := getHashedFlag([]byte(soluce))
|
|
m.Soluce = hex.EncodeToString(h[:])
|
|
}
|
|
|
|
exercice.MCQs[mcq.Id] = m
|
|
}
|
|
}
|
|
|
|
// Hash table ordered by exercice Id
|
|
ret.Exercices[fmt.Sprintf("%d", e.Id)] = exercice
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret, nil
|
|
}
|