289 lines
8.9 KiB
Go
289 lines
8.9 KiB
Go
package api
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"path"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"srs.epita.fr/fic-server/admin/sync"
|
|
"srs.epita.fr/fic-server/libfic"
|
|
"srs.epita.fr/fic-server/settings"
|
|
|
|
"github.com/julienschmidt/httprouter"
|
|
)
|
|
|
|
func init() {
|
|
router.GET("/api/themes", apiHandler(listThemes))
|
|
router.POST("/api/themes", apiHandler(createTheme))
|
|
router.GET("/api/themes.json", apiHandler(exportThemes))
|
|
router.GET("/api/session-forensic.yaml", apiHandler(func(_ httprouter.Params, _ []byte) (interface{}, error) {
|
|
if s, err := settings.ReadSettings(path.Join(settings.SettingsDir, settings.SettingsFile)); err != nil {
|
|
return nil, err
|
|
} else if c, err := settings.ReadChallengeInfo(path.Join(settings.SettingsDir, settings.ChallengeFile)); err != nil {
|
|
return nil, err
|
|
} else {
|
|
return fic.GenZQDSSessionFile(c, s)
|
|
}
|
|
}))
|
|
router.GET("/api/files-bindings", apiHandler(bindingFiles))
|
|
|
|
router.GET("/api/themes/:thid", apiHandler(themeHandler(showTheme)))
|
|
router.PUT("/api/themes/:thid", apiHandler(themeHandler(updateTheme)))
|
|
router.DELETE("/api/themes/:thid", apiHandler(themeHandler(deleteTheme)))
|
|
|
|
router.GET("/api/themes/:thid/exercices", apiHandler(themeHandler(listThemedExercices)))
|
|
router.POST("/api/themes/:thid/exercices", apiHandler(themeHandler(createExercice)))
|
|
|
|
router.GET("/api/themes/:thid/exercices_stats.json", apiHandler(themeHandler(getThemedExercicesStats)))
|
|
|
|
router.GET("/api/themes/:thid/exercices/:eid", apiHandler(exerciceHandler(showExercice)))
|
|
router.PUT("/api/themes/:thid/exercices/:eid", apiHandler(exerciceHandler(updateExercice)))
|
|
router.DELETE("/api/themes/:thid/exercices/:eid", apiHandler(exerciceHandler(deleteExercice)))
|
|
|
|
router.GET("/api/themes/:thid/exercices/:eid/files", apiHandler(exerciceHandler(listExerciceFiles)))
|
|
router.POST("/api/themes/:thid/exercices/:eid/files", apiHandler(exerciceHandler(createExerciceFile)))
|
|
|
|
router.GET("/api/themes/:thid/exercices/:eid/hints", apiHandler(exerciceHandler(listExerciceHints)))
|
|
router.POST("/api/themes/:thid/exercices/:eid/hints", apiHandler(exerciceHandler(createExerciceHint)))
|
|
|
|
router.GET("/api/themes/:thid/exercices/:eid/keys", apiHandler(exerciceHandler(listExerciceFlags)))
|
|
router.POST("/api/themes/:thid/exercices/:eid/keys", apiHandler(exerciceHandler(createExerciceFlag)))
|
|
|
|
// Remote
|
|
router.GET("/api/remote/themes", apiHandler(sync.ApiListRemoteThemes))
|
|
router.GET("/api/remote/themes/:thid", apiHandler(sync.ApiGetRemoteTheme))
|
|
router.GET("/api/remote/themes/:thid/exercices", apiHandler(sync.ApiListRemoteExercices))
|
|
|
|
// Synchronize
|
|
router.GET("/api/sync/deep", apiHandler(
|
|
func(_ httprouter.Params, _ []byte) (interface{}, error) {
|
|
if sync.DeepSyncProgress == 0 {
|
|
return nil, errors.New("Pas de synchronisation en cours")
|
|
} else {
|
|
return map[string]interface{}{"progress": sync.DeepSyncProgress}, nil
|
|
}
|
|
}))
|
|
router.POST("/api/sync/base", apiHandler(
|
|
func(_ httprouter.Params, _ []byte) (interface{}, error) {
|
|
err := sync.GlobalImporter.Sync()
|
|
return true, err
|
|
}))
|
|
router.POST("/api/sync/speed", apiHandler(
|
|
func(_ httprouter.Params, _ []byte) (interface{}, error) {
|
|
st := sync.SpeedySyncDeep(sync.GlobalImporter)
|
|
sync.EditDeepReport(st, false)
|
|
return st, nil
|
|
}))
|
|
router.POST("/api/sync/deep", apiHandler(
|
|
func(_ httprouter.Params, _ []byte) (interface{}, error) {
|
|
return sync.SyncDeep(sync.GlobalImporter), nil
|
|
}))
|
|
router.POST("/api/sync/deep/:thid", apiHandler(themeHandler(
|
|
func(theme *fic.Theme, _ []byte) (interface{}, error) {
|
|
st := sync.SyncThemeDeep(sync.GlobalImporter, theme, 0, 250)
|
|
sync.EditDeepReport(map[string][]string{theme.Name: st}, false)
|
|
sync.DeepSyncProgress = 255
|
|
return st, nil
|
|
})))
|
|
router.POST("/api/sync/auto/*p", apiHandler(
|
|
func(ps httprouter.Params, _ []byte) (interface{}, error) {
|
|
p := strings.TrimPrefix(ps.ByName("p"), "/")
|
|
|
|
themes, err := fic.GetThemes()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if p == "" {
|
|
if !IsProductionEnv {
|
|
for _, theme := range themes {
|
|
theme.DeleteDeep()
|
|
}
|
|
}
|
|
|
|
st := sync.SyncDeep(sync.GlobalImporter)
|
|
return st, nil
|
|
}
|
|
|
|
for _, theme := range themes {
|
|
if theme.Path == p {
|
|
if !IsProductionEnv {
|
|
exercices, err := theme.GetExercices()
|
|
if err == nil {
|
|
for _, exercice := range exercices {
|
|
exercice.DeleteDeep()
|
|
}
|
|
}
|
|
}
|
|
|
|
st := sync.SyncThemeDeep(sync.GlobalImporter, theme, 0, 250)
|
|
sync.EditDeepReport(map[string][]string{theme.Name: st}, false)
|
|
sync.DeepSyncProgress = 255
|
|
|
|
settings.ForceRegeneration()
|
|
|
|
return st, nil
|
|
}
|
|
}
|
|
|
|
return nil, fmt.Errorf("Theme not found %q", p)
|
|
}))
|
|
router.POST("/api/sync/themes", apiHandler(
|
|
func(_ httprouter.Params, _ []byte) (interface{}, error) {
|
|
return sync.SyncThemes(sync.GlobalImporter), nil
|
|
}))
|
|
router.POST("/api/sync/themes/:thid/exercices", apiHandler(themeHandler(
|
|
func(theme *fic.Theme, _ []byte) (interface{}, error) {
|
|
return sync.SyncExercices(sync.GlobalImporter, theme), nil
|
|
})))
|
|
router.POST("/api/sync/themes/:thid/exercices/:eid/files", apiHandler(exerciceHandler(
|
|
func(exercice *fic.Exercice, _ []byte) (interface{}, error) {
|
|
return sync.SyncExerciceFiles(sync.GlobalImporter, exercice), nil
|
|
})))
|
|
router.POST("/api/sync/themes/:thid/exercices/:eid/hints", apiHandler(exerciceHandler(
|
|
func(exercice *fic.Exercice, _ []byte) (interface{}, error) {
|
|
_, errs := sync.SyncExerciceHints(sync.GlobalImporter, exercice, sync.ExerciceFlagsMap(sync.GlobalImporter, exercice))
|
|
return errs, nil
|
|
})))
|
|
router.POST("/api/sync/themes/:thid/exercices/:eid/keys", apiHandler(exerciceHandler(
|
|
func(exercice *fic.Exercice, _ []byte) (interface{}, error) {
|
|
_, errs := sync.SyncExerciceFlags(sync.GlobalImporter, exercice)
|
|
_, herrs := sync.SyncExerciceHints(sync.GlobalImporter, exercice, sync.ExerciceFlagsMap(sync.GlobalImporter, exercice))
|
|
return append(errs, herrs...), nil
|
|
})))
|
|
|
|
router.POST("/api/sync/themes/:thid/fixurlid", apiHandler(themeHandler(
|
|
func(theme *fic.Theme, _ []byte) (interface{}, error) {
|
|
if theme.FixURLId() {
|
|
return theme.Update()
|
|
}
|
|
return 0, nil
|
|
})))
|
|
router.POST("/api/sync/fixurlids", apiHandler(fixAllURLIds))
|
|
}
|
|
|
|
func fixAllURLIds(_ httprouter.Params, _ []byte) (interface{}, error) {
|
|
nbFix := 0
|
|
if themes, err := fic.GetThemes(); err == nil {
|
|
for _, theme := range themes {
|
|
if theme.FixURLId() {
|
|
theme.Update()
|
|
nbFix += 1
|
|
}
|
|
|
|
if exercices, err := theme.GetExercices(); err == nil {
|
|
for _, exercice := range exercices {
|
|
if exercice.FixURLId() {
|
|
exercice.Update()
|
|
nbFix += 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return nbFix, nil
|
|
}
|
|
|
|
func bindingFiles(_ httprouter.Params, body []byte) (interface{}, error) {
|
|
if files, err := fic.GetFiles(); err != nil {
|
|
return "", err
|
|
} else {
|
|
ret := ""
|
|
for _, file := range files {
|
|
ret += fmt.Sprintf("%s;%s\n", file.GetOrigin(), file.Path)
|
|
}
|
|
return ret, nil
|
|
}
|
|
}
|
|
|
|
func getExercice(args []string) (*fic.Exercice, error) {
|
|
if tid, err := strconv.ParseInt(string(args[0]), 10, 64); err != nil {
|
|
return nil, err
|
|
} else if theme, err := fic.GetTheme(tid); err != nil {
|
|
return nil, err
|
|
} else if eid, err := strconv.Atoi(string(args[1])); err != nil {
|
|
return nil, err
|
|
} else {
|
|
return theme.GetExercice(eid)
|
|
}
|
|
}
|
|
|
|
func listThemes(_ httprouter.Params, _ []byte) (interface{}, error) {
|
|
return fic.GetThemes()
|
|
}
|
|
|
|
func exportThemes(_ httprouter.Params, _ []byte) (interface{}, error) {
|
|
return fic.ExportThemes()
|
|
}
|
|
|
|
func showTheme(theme *fic.Theme, _ []byte) (interface{}, error) {
|
|
return theme, nil
|
|
}
|
|
|
|
func listThemedExercices(theme *fic.Theme, _ []byte) (interface{}, error) {
|
|
return theme.GetExercices()
|
|
}
|
|
|
|
func showThemedExercice(theme *fic.Theme, exercice fic.Exercice, body []byte) (interface{}, error) {
|
|
return exercice, nil
|
|
}
|
|
|
|
func createTheme(_ httprouter.Params, body []byte) (interface{}, error) {
|
|
var ut fic.Theme
|
|
if err := json.Unmarshal(body, &ut); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if len(ut.Name) == 0 {
|
|
return nil, errors.New("Theme's name not filled")
|
|
}
|
|
|
|
return fic.CreateTheme(&ut)
|
|
}
|
|
|
|
func updateTheme(theme *fic.Theme, body []byte) (interface{}, error) {
|
|
var ut fic.Theme
|
|
if err := json.Unmarshal(body, &ut); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
ut.Id = theme.Id
|
|
|
|
if len(ut.Name) == 0 {
|
|
return nil, errors.New("Theme's name not filled")
|
|
}
|
|
|
|
if _, err := ut.Update(); err != nil {
|
|
return nil, err
|
|
} else {
|
|
return ut, nil
|
|
}
|
|
}
|
|
|
|
func deleteTheme(theme *fic.Theme, _ []byte) (interface{}, error) {
|
|
return theme.Delete()
|
|
}
|
|
|
|
func getThemedExercicesStats(theme *fic.Theme, body []byte) (interface{}, error) {
|
|
if exercices, err := theme.GetExercices(); err != nil {
|
|
return nil, err
|
|
} else {
|
|
ret := []exerciceStats{}
|
|
for _, e := range exercices {
|
|
ret = append(ret, exerciceStats{
|
|
IdExercice: e.Id,
|
|
TeamTries: e.TriedTeamCount(),
|
|
TotalTries: e.TriedCount(),
|
|
SolvedCount: e.SolvedCount(),
|
|
FlagSolved: e.FlagSolved(),
|
|
MCQSolved: e.MCQSolved(),
|
|
})
|
|
}
|
|
return ret, nil
|
|
}
|
|
}
|