server/libfic/team_my.go

package fic

import (
	"encoding/hex"
	"fmt"
	"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"`
	Cost     int64  `json:"cost"`
	Unlocked bool   `json:"unlocked"`
}
type myTeamExercice struct {
	ThemeId      int          `json:"theme_id"`
	Statement    string       `json:"statement"`
	Hints        []myTeamHint `json:"hints"`
	Gain         int64        `json:"gain"`
	Files        []myTeamFile `json:"files"`
	Keys         []string     `json:"keys"`
	Solved       bool         `json:"solved"`
	SolvedMat    []bool       `json:"solved_matrix"`
	SolvedTime   time.Time    `json:"solved_time"`
	SolvedNumber int64        `json:"solved_number"`
	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
		ret.Points, _ = t.GetPoints()
		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.Solved = true
					exercice.SolvedNumber = e.TriedCount()
				} else {
					exercice.Solved, exercice.SolvedTime, exercice.SolvedNumber = t.HasSolved(e)
				}

				// 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.Cost, true})
						} else {
							exercice.Hints = append(exercice.Hints, myTeamHint{h.Id, h.Title, "", h.Cost, false})
						}
					}
				}

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