From 4039a394b540a6f4ce604aac915eb909436ad856 Mon Sep 17 00:00:00 2001 From: Pierre-Olivier Mercier Date: Fri, 5 Jul 2019 22:28:56 +0200 Subject: [PATCH] sync: Extract function that import flags from importer --- admin/api/exercice.go | 20 +- admin/sync/exercice_defines.go | 60 +++- admin/sync/exercice_keys.go | 483 +++++++++++++++++++-------------- libfic/exercice.go | 54 ++-- libfic/flag.go | 9 +- libfic/flag_choice.go | 19 +- libfic/flag_key.go | 65 +++-- libfic/mcq.go | 54 ++-- 8 files changed, 454 insertions(+), 310 deletions(-) diff --git a/admin/api/exercice.go b/admin/api/exercice.go index 30b7aff6..b7f36487 100644 --- a/admin/api/exercice.go +++ b/admin/api/exercice.go @@ -103,8 +103,8 @@ func exportResolutionMovies(_ httprouter.Params, body []byte) (interface{}, erro } else { export = append(export, map[string]string{ "videoURI": exercice.VideoURI, - "theme": theme.Name, - "title": exercice.Title, + "theme": theme.Name, + "title": exercice.Title, }) } } @@ -141,7 +141,7 @@ func getExerciceHistory(exercice fic.Exercice, body []byte) (interface{}, error) } type uploadedExerciceHistory struct { - IdTeam int64 `json:"team_id"` + IdTeam int64 `json:"team_id"` Kind string Time time.Time Secondary *int64 @@ -407,13 +407,8 @@ func deleteExerciceFlag(flag fic.FlagKey, _ fic.Exercice, _ []byte) (interface{} return flag.Delete() } -type uploadedChoice struct { - Label string - Value string -} - func createFlagChoice(flag fic.FlagKey, exercice fic.Exercice, body []byte) (interface{}, error) { - var uc uploadedChoice + var uc fic.FlagChoice if err := json.Unmarshal(body, &uc); err != nil { return nil, err } @@ -422,7 +417,7 @@ func createFlagChoice(flag fic.FlagKey, exercice fic.Exercice, body []byte) (int uc.Label = uc.Value } - return flag.AddChoice(uc.Label, uc.Value) + return flag.AddChoice(uc) } func showFlagChoice(choice fic.FlagChoice, _ fic.Exercice, body []byte) (interface{}, error) { @@ -430,7 +425,7 @@ func showFlagChoice(choice fic.FlagChoice, _ fic.Exercice, body []byte) (interfa } func updateFlagChoice(choice fic.FlagChoice, _ fic.Exercice, body []byte) (interface{}, error) { - var uc uploadedChoice + var uc fic.FlagChoice if err := json.Unmarshal(body, &uc); err != nil { return nil, err } @@ -503,7 +498,7 @@ func updateExerciceQuiz(quiz fic.MCQ, exercice fic.Exercice, body []byte) (inter // Add new choices for _, choice := range uq.Entries { if choice.Id == 0 { - if c, err := quiz.AddEntry(choice.Label, choice.Response); err != nil { + if c, err := quiz.AddEntry(choice); err != nil { return nil, err } else { quiz.Entries = append(quiz.Entries, c) @@ -553,7 +548,6 @@ func deleteExerciceFile(file fic.EFile, _ []byte) (interface{}, error) { return file.Delete() } - func listExerciceTags(exercice fic.Exercice, _ []byte) (interface{}, error) { return exercice.GetTags() } diff --git a/admin/sync/exercice_defines.go b/admin/sync/exercice_defines.go index 20666fde..aa389929 100644 --- a/admin/sync/exercice_defines.go +++ b/admin/sync/exercice_defines.go @@ -1,9 +1,11 @@ package sync import ( + "fmt" "path" "github.com/BurntSushi/toml" + "srs.epita.fr/fic-server/libfic" ) // ExerciceHintParams holds EHint definition infomation. @@ -35,15 +37,15 @@ type ExerciceFlagChoice struct { // ExerciceFlag holds informations about one flag. type ExerciceFlag struct { Id int64 - Label string `toml:",omitempty"` - Type string `toml:",omitempty"` + Label string `toml:",omitempty"` + Type string `toml:",omitempty"` Raw interface{} - Separator string `toml:",omitempty"` - Ordered bool `toml:",omitempty"` - IgnoreCase bool `toml:",omitempty"` - ValidatorRe string `toml:"validator_regexp,omitempty"` - Help string `toml:",omitempty"` - ChoicesCost int64 `toml:"choices_cost,omitempty"` + Separator string `toml:",omitempty"` + Ordered bool `toml:",omitempty"` + IgnoreCase bool `toml:",omitempty"` + ValidatorRe string `toml:"validator_regexp,omitempty"` + Help string `toml:",omitempty"` + ChoicesCost int64 `toml:"choices_cost,omitempty"` Choice []ExerciceFlagChoice LockedFile []ExerciceUnlockFile `toml:"unlock_file,omitempty"` NeedFlag []ExerciceDependency `toml:"need_flag,omitempty"` @@ -70,3 +72,45 @@ func parseExerciceParams(i Importer, exPath string) (p ExerciceParams, err error return } + +// getExerciceParams returns normalized +func getExerciceParams(i Importer, exercice fic.Exercice) (params ExerciceParams, errs []string) { + var err error + if params, err = parseExerciceParams(i, exercice.Path); err != nil { + errs = append(errs, fmt.Sprintf("%q: challenge.txt: %s", path.Base(exercice.Path), err)) + } else if len(params.Flags) == 0 && len(params.FlagsUCQ) == 0 && len(params.FlagsMCQ) == 0 { + errs = append(errs, fmt.Sprintf("%q: has no flag", path.Base(exercice.Path))) + } else { + // Treat legacy UCQ flags as ExerciceFlag + for _, flag := range params.FlagsUCQ { + params.Flags = append(params.Flags, ExerciceFlag{ + Id: flag.Id, + Label: flag.Label, + Type: "ucq", + Raw: flag.Raw, + ValidatorRe: flag.ValidatorRe, + Help: flag.Help, + ChoicesCost: flag.ChoicesCost, + Choice: flag.Choice, + LockedFile: flag.LockedFile, + NeedFlag: flag.NeedFlag, + }) + } + params.FlagsUCQ = []ExerciceFlag{} + + // Treat legacy MCQ flags as ExerciceFlag + for _, flag := range params.FlagsMCQ { + params.Flags = append(params.Flags, ExerciceFlag{ + Id: flag.Id, + Label: flag.Label, + Type: "mcq", + ChoicesCost: flag.ChoicesCost, + Choice: flag.Choice, + LockedFile: flag.LockedFile, + NeedFlag: flag.NeedFlag, + }) + } + params.FlagsMCQ = []ExerciceFlag{} + } + return +} diff --git a/admin/sync/exercice_keys.go b/admin/sync/exercice_keys.go index a20bbbd0..5e7c86b7 100644 --- a/admin/sync/exercice_keys.go +++ b/admin/sync/exercice_keys.go @@ -82,234 +82,299 @@ func getRawKey(input interface{}, validatorRe string, ordered bool) (raw string, return } -// SyncExerciceFlags reads the content of challenge.txt and import "classic" flags as Key for the given challenge. +func buildKeyFlag(exercice fic.Exercice, flag ExerciceFlag, flagline int, defaultLabel string) (f *fic.Flag, choices []fic.FlagChoice, errs []string) { + if len(flag.Label) == 0 { + flag.Label = defaultLabel + } + + if flag.Label[0] == '`' { + errs = append(errs, fmt.Sprintf("%q: flag #%d: Label should not begin with `.", path.Base(exercice.Path), flagline)) + flag.Label = flag.Label[1:] + } + + raw, prep, terrs := getRawKey(flag.Raw, flag.ValidatorRe, flag.Ordered) + + if len(terrs) > 0 { + for _, err := range terrs { + errs = append(errs, fmt.Sprintf("%q: flag #%d: %s", path.Base(exercice.Path), flagline, err)) + } + f = nil + return + } + flag.Label = prep + flag.Label + + if !isFullGraphic(raw) { + errs = append(errs, fmt.Sprintf("%q: WARNING flag #%d: non-printable characters in flag, is this really expected?", path.Base(exercice.Path), flagline)) + } + + hashedFlag := fic.ComputeHashedFlag([]byte(raw)) + fl := fic.Flag(fic.FlagKey{ + IdExercice: exercice.Id, + Label: flag.Label, + Help: flag.Help, + IgnoreCase: flag.IgnoreCase, + ValidatorRegexp: validatorRegexp(flag.ValidatorRe), + Checksum: hashedFlag[:], + ChoicesCost: flag.ChoicesCost, + }) + f = &fl + + if len(flag.Choice) > 0 || flag.Type == "ucq" { + // Import choices + hasOne := false + + if !flag.NoShuffle { + rand.Shuffle(len(flag.Choice), func(i, j int) { + flag.Choice[i], flag.Choice[j] = flag.Choice[j], flag.Choice[i] + }) + } + + for _, choice := range flag.Choice { + val, prep, terrs := getRawKey(choice.Value, "", false) + if len(terrs) > 0 { + for _, err := range terrs { + errs = append(errs, fmt.Sprintf("%q: flag #%d: %s", path.Base(exercice.Path), flagline, err)) + } + continue + } + + if len(choice.Label) == 0 { + choice.Label = val + } + choice.Label = prep + choice.Label + + choices = append(choices, fic.FlagChoice{ + Label: choice.Label, + Value: val, + }) + + if val == raw { + hasOne = true + } + } + if !hasOne { + errs = append(errs, fmt.Sprintf("%q: error in flag #%d: no valid answer defined.", path.Base(exercice.Path), flagline)) + } + } + return +} + +type importFlag struct { + Line int + Flag fic.Flag + Choices []fic.FlagChoice + FilesDeps []string + FlagsDeps []int64 +} + +// buildExerciceFlags read challenge.txt and extract all flags. +func buildExerciceFlags(i Importer, exercice fic.Exercice) (flags map[int64]importFlag, errs []string) { + params, gerrs := getExerciceParams(i, exercice) + if len(gerrs) > 0 { + return flags, gerrs + } + + flags = map[int64]importFlag{} + + for nline, flag := range params.Flags { + if flag.Id == 0 { + // TODO: should be more smart than that. Perhaps search to increment if possible. + flag.Id = rand.Int63() + } + + // Ensure flag ID is unique + for _, ok := flags[flag.Id]; ok; _, ok = flags[flag.Id] { + errs = append(errs, fmt.Sprintf("%q: flag #%d: identifier already used (%d), using a random one.", path.Base(exercice.Path), nline+1, flag.Id)) + flag.Id = rand.Int63() + } + + switch strings.ToLower(flag.Type) { + case "": + flag.Type = "key" + case "key": + flag.Type = "key" + case "ucq": + flag.Type = "ucq" + case "mcq": + flag.Type = "mcq" + default: + errs = append(errs, fmt.Sprintf("%q: flag #%d: invalid type of flag: should be 'key', 'mcq' or 'ucq'.", path.Base(exercice.Path), nline+1)) + continue + } + + if flag.Type == "key" || flag.Type == "ucq" { + addedFlag, choices, berrs := buildKeyFlag(exercice, flag, nline+1, "Flag") + if len(berrs) > 0 { + errs = append(errs, berrs...) + } + if addedFlag != nil { + flags[flag.Id] = importFlag{ + Line: nline + 1, + Flag: *addedFlag, + Choices: choices, + } + } + } else if flag.Type == "mcq" { + addedFlag := fic.MCQ{ + IdExercice: exercice.Id, + Title: flag.Label, + Entries: []fic.MCQ_entry{}, + } + + hasOne := false + isJustified := false + + if !flag.NoShuffle { + rand.Shuffle(len(flag.Choice), func(i, j int) { + flag.Choice[i], flag.Choice[j] = flag.Choice[j], flag.Choice[i] + }) + } + + for cid, choice := range flag.Choice { + var val bool + + if choice.Justification != nil { + if hasOne && !isJustified { + errs = append(errs, fmt.Sprintf("%q: error MCQ #%d: all true items has to be justified in this MCQ.", path.Base(exercice.Path), nline+1)) + continue + } + + val = true + isJustified = true + } else if p, ok := choice.Value.(bool); ok { + val = p + if isJustified { + errs = append(errs, fmt.Sprintf("%q: error MCQ #%d: all true items has to be justified in this MCQ.", path.Base(exercice.Path), nline+1)) + continue + } + } else if choice.Value == nil { + val = false + } else { + errs = append(errs, fmt.Sprintf("%q: error in MCQ %d choice %d: incorrect type for value: %T is not boolean.", path.Base(exercice.Path), nline+1, cid, choice.Value)) + continue + } + + addedFlag.Entries = append(addedFlag.Entries, fic.MCQ_entry{ + Label: choice.Label, + Response: val, + }) + + if isJustified && choice.Justification != nil { + addedFlag, choices, berrs := buildKeyFlag(exercice, *choice.Justification, nline+1, "Flag correspondant") + if len(berrs) > 0 { + errs = append(errs, berrs...) + } + if addedFlag != nil { + flags[flag.Id] = importFlag{ + Line: nline, + Flag: *addedFlag, + Choices: choices, + } + } + } + } + } + + // Read dependency to flag + for _, nf := range flag.NeedFlag { + if v, ok := flags[flag.Id]; ok { + v.FlagsDeps = append(v.FlagsDeps, nf.Id) + flags[flag.Id] = v + } + } + + // Read dependency to file + for _, lf := range flag.LockedFile { + if v, ok := flags[flag.Id]; ok { + v.FilesDeps = append(v.FilesDeps, lf.Filename) + flags[flag.Id] = v + } + } + } + + return +} + +// CheckExerciceFlags checks if all flags for the given challenge are correct. +func CheckExerciceFlags(i Importer, exercice fic.Exercice, files []fic.EFile) (rf []fic.Flag, errs []string) { + flags, berrs := buildExerciceFlags(i, exercice) + errs = append(errs, berrs...) + + for _, flag := range flags { + // Check dependency to flag + for _, nf := range flag.FlagsDeps { + if _, ok := flags[nf]; !ok { + errs = append(errs, fmt.Sprintf("%q: error flag #%d dependency to flag id=%d: id not defined", path.Base(exercice.Path), flag.Line, nf)) + } + } + + // Check dependency to file + for _, lf := range flag.FilesDeps { + found := false + for _, f := range files { + if f.Name == lf { + found = true + break + } + } + if !found { + errs = append(errs, fmt.Sprintf("%q: error flag #%d dependency to %s: No such file", path.Base(exercice.Path), flag.Line, lf)) + } + } + + rf = append(rf, flag.Flag) + } + + return +} + +// SyncExerciceFlags imports all kind of flags for the given challenge. func SyncExerciceFlags(i Importer, exercice fic.Exercice) (errs []string) { if _, err := exercice.WipeFlags(); err != nil { errs = append(errs, err.Error()) } else if _, err := exercice.WipeMCQs(); err != nil { errs = append(errs, err.Error()) - } else if params, err := parseExerciceParams(i, exercice.Path); err != nil { - errs = append(errs, fmt.Sprintf("%q: challenge.txt: %s", path.Base(exercice.Path), err)) - } else if len(params.Flags) == 0 && len(params.FlagsUCQ) == 0 && len(params.FlagsMCQ) == 0 { - errs = append(errs, fmt.Sprintf("%q: has no flag", path.Base(exercice.Path))) } else { + flags, berrs := buildExerciceFlags(i, exercice) + errs = append(errs, berrs...) + kmap := map[int64]fic.Flag{} - // Import UCQ flags - for _, flag := range params.FlagsUCQ { - params.Flags = append(params.Flags, ExerciceFlag{ - Id: flag.Id, - Label: flag.Label, - Type: "ucq", - Raw: flag.Raw, - ValidatorRe: flag.ValidatorRe, - Help: flag.Help, - ChoicesCost: flag.ChoicesCost, - Choice: flag.Choice, - LockedFile: flag.LockedFile, - NeedFlag: flag.NeedFlag, - }) - } - - // Import MCQ flags - for _, flag := range params.FlagsMCQ { - params.Flags = append(params.Flags, ExerciceFlag{ - Id: flag.Id, - Label: flag.Label, - Type: "mcq", - ChoicesCost: flag.ChoicesCost, - Choice: flag.Choice, - LockedFile: flag.LockedFile, - NeedFlag: flag.NeedFlag, - }) - } - - // Import normal flags - for nline, flag := range params.Flags { - if len(flag.Label) == 0 { - flag.Label = "Flag" - } - - if flag.Label[0] == '`' { - errs = append(errs, fmt.Sprintf("%q: flag #%d: Label should not begin with `.", path.Base(exercice.Path), nline + 1)) - flag.Label = flag.Label[1:] - } - - switch strings.ToLower(flag.Type) { - case "": - flag.Type = "key" - case "key": - flag.Type = "key" - case "ucq": - flag.Type = "ucq" - case "mcq": - flag.Type = "mcq" - default: - errs = append(errs, fmt.Sprintf("%q: flag #%d: invalid type of flag: should be 'key', 'mcq' or 'ucq'.", path.Base(exercice.Path), nline + 1)) - continue - } - - var addedFlag fic.Flag - - if flag.Type == "key" || flag.Type == "ucq" { - raw, prep, terrs := getRawKey(flag.Raw, flag.ValidatorRe, flag.Ordered) - - if len(terrs) > 0 { - for _, err := range terrs { - errs = append(errs, fmt.Sprintf("%q: flag #%d: %s", path.Base(exercice.Path), nline + 1, err)) - } - continue - } - flag.Label = prep + flag.Label - - if !isFullGraphic(raw) { - errs = append(errs, fmt.Sprintf("%q: WARNING flag #%d: non-printable characters in flag, is this really expected?", path.Base(exercice.Path), nline + 1)) - } - - if k, err := exercice.AddRawFlagKey(flag.Label, flag.Help, flag.IgnoreCase, validatorRegexp(flag.ValidatorRe), []byte(raw), flag.ChoicesCost); err != nil { - errs = append(errs, fmt.Sprintf("%q: error flag #%d: %s", path.Base(exercice.Path), nline + 1, err)) - continue - } else { - addedFlag = k - if len(flag.Choice) > 0 || flag.Type == "ucq" { - // Import choices - hasOne := false - - if !flag.NoShuffle { - rand.Shuffle(len(flag.Choice), func(i, j int) { - flag.Choice[i], flag.Choice[j] = flag.Choice[j], flag.Choice[i] - }) - } - - for cid, choice := range flag.Choice { - val, prep, terrs := getRawKey(choice.Value, "", false) - if len(terrs) > 0 { - for _, err := range terrs { - errs = append(errs, fmt.Sprintf("%q: flag UCQ #%d: %s", path.Base(exercice.Path), nline + 1, err)) - } - continue - } - - if len(choice.Label) == 0 { - choice.Label = val - } - choice.Label = prep + choice.Label - - if _, err := k.AddChoice(choice.Label, val); err != nil { - errs = append(errs, fmt.Sprintf("%q: error in UCQ %d choice %d: %s", path.Base(exercice.Path), nline + 1, cid, err)) - continue - } - - if val == raw { - hasOne = true - } - } - if !hasOne { - errs = append(errs, fmt.Sprintf("%q: error in UCQ %d: no valid answer defined.", path.Base(exercice.Path), nline + 1)) + // Import flags + for flagid, flag := range flags { + if addedFlag, err := exercice.AddFlag(flag.Flag); err != nil { + errs = append(errs, fmt.Sprintf("%q: error flag #%d: %s", path.Base(exercice.Path), flag.Line, err)) + } else { + if f, ok := addedFlag.(fic.FlagKey); ok { + for _, choice := range flag.Choices { + if _, err := f.AddChoice(choice); err != nil { + errs = append(errs, fmt.Sprintf("%q: error in flag #%d choice #FIXME: %s", path.Base(exercice.Path), flag.Line, err)) } } } - } else if flag.Type == "mcq" { - if f, err := exercice.AddMCQ(flag.Label); err != nil { - errs = append(errs, fmt.Sprintf("%q: error flag MCQ #%d: %s", path.Base(exercice.Path), nline + 1, err)) - continue - } else { - addedFlag = f - hasOne := false - isJustified := false - if !flag.NoShuffle { - rand.Shuffle(len(flag.Choice), func(i, j int) { - flag.Choice[i], flag.Choice[j] = flag.Choice[j], flag.Choice[i] - }) - } + kmap[flagid] = addedFlag - for cid, choice := range flag.Choice { - var val bool - var justify string - - if choice.Justification != nil { - if hasOne && !isJustified { - errs = append(errs, fmt.Sprintf("%q: error MCQ #%d: all true items has to be justified in this MCQ.", path.Base(exercice.Path), nline + 1)) - continue - } - - val = true - isJustified = true - } else if p, ok := choice.Value.(bool); ok { - val = p - if isJustified { - errs = append(errs, fmt.Sprintf("%q: error MCQ #%d: all true items has to be justified in this MCQ.", path.Base(exercice.Path), nline + 1)) - continue - } - } else if choice.Value == nil { - val = false - } else { - errs = append(errs, fmt.Sprintf("%q: error in MCQ %d choice %d: incorrect type for value: %T is not boolean.", path.Base(exercice.Path), nline + 1, cid, choice.Value)) - continue - } - - if e, err := f.AddEntry(choice.Label, val); err != nil { - errs = append(errs, fmt.Sprintf("%q: error in MCQ %d choice %d: %s", path.Base(exercice.Path), nline + 1, cid, err)) - continue - } else if isJustified && choice.Justification != nil { - var prep string - var terrs []string - justify, prep, terrs = getRawKey(choice.Justification.Raw, choice.Justification.ValidatorRe, choice.Justification.Ordered) - if len(terrs) > 0 { - for _, err := range terrs { - errs = append(errs, fmt.Sprintf("%q: flag MCQ #%d, choice #%d: %s", path.Base(exercice.Path), nline + 1, cid, err)) - } - continue - } - - if len(choice.Justification.Label) == 0 { - choice.Justification.Label = "Flag correspondant" - } - choice.Justification.Label = prep + choice.Justification.Label - - if _, err := exercice.AddRawFlagKey(fmt.Sprintf("%%%d%%%s", e.Id, choice.Justification.Label), choice.Justification.Help, choice.Justification.IgnoreCase, validatorRegexp(choice.Justification.ValidatorRe), []byte(justify), flag.ChoicesCost); err != nil { - errs = append(errs, fmt.Sprintf("%q: error MCQ #%d: %s", path.Base(exercice.Path), nline + 1, err)) - continue - } - } - - if val { - hasOne = true - } - } - if !hasOne { - errs = append(errs, fmt.Sprintf("%q: warning MCQ %d: no valid answer defined, is this really expected?", path.Base(exercice.Path), nline + 1)) + // Import dependency to flag + for _, nf := range flag.FlagsDeps { + if rf, ok := kmap[nf]; !ok { + errs = append(errs, fmt.Sprintf("%q: error flag #%d dependency to flag id=%d: id not defined, perhaps not available at time of processing", path.Base(exercice.Path), flag.Line, nf)) + } else if err := addedFlag.AddDepend(rf); err != nil { + errs = append(errs, fmt.Sprintf("%q: error flag #%d dependency to id=%d: %s", path.Base(exercice.Path), flag.Line, nf, err)) } } - } - if flag.Id != 0 { - kmap[flag.Id] = addedFlag - } - - // Import dependency to flag - for _, nf := range flag.NeedFlag { - if rf, ok := kmap[nf.Id]; !ok { - errs = append(errs, fmt.Sprintf("%q: error flag #%d dependency to flag id=%d: id not defined, perhaps not available at time of processing", path.Base(exercice.Path), nline + 1, nf.Id)) - continue - } else if err := addedFlag.AddDepend(rf); err != nil { - errs = append(errs, fmt.Sprintf("%q: error flag #%d dependency to id=%d: %s", path.Base(exercice.Path), nline + 1, nf.Id, err)) - continue - } - } - - // Import dependency to file - for _, lf := range flag.LockedFile { - if rf, err := exercice.GetFileByFilename(lf.Filename); err != nil { - errs = append(errs, fmt.Sprintf("%q: error flag #%d dependency to %s: %s", path.Base(exercice.Path), nline + 1, lf.Filename, err)) - continue - } else if err := rf.AddDepend(addedFlag); err != nil { - errs = append(errs, fmt.Sprintf("%q: error flag #%d dependency to %s: %s", path.Base(exercice.Path), nline + 1, lf.Filename, err)) - continue + // Import dependency to file + for _, lf := range flag.FilesDeps { + if rf, err := exercice.GetFileByFilename(lf); err != nil { + errs = append(errs, fmt.Sprintf("%q: error flag #%d dependency to %s: %s", path.Base(exercice.Path), flag.Line, lf, err)) + } else if err := rf.AddDepend(addedFlag); err != nil { + errs = append(errs, fmt.Sprintf("%q: error flag #%d dependency to %s: %s", path.Base(exercice.Path), flag.Line, lf, err)) + } } } } } + return } diff --git a/libfic/exercice.go b/libfic/exercice.go index ea2a3795..3709272c 100644 --- a/libfic/exercice.go +++ b/libfic/exercice.go @@ -20,35 +20,35 @@ var ExerciceCurrentCoefficient = 1.0 // Exercice represents a challenge inside a Theme. type Exercice struct { - Id int64 `json:"id"` - IdTheme int64 `json:"id_theme"` - Title string `json:"title"` + Id int64 `json:"id"` + IdTheme int64 `json:"id_theme"` + Title string `json:"title"` // URLid is used to reference the challenge from the URL path - URLId string `json:"urlid"` + URLId string `json:"urlid"` // Path is the relative import location where find challenge data - Path string `json:"path"` + Path string `json:"path"` // Statement is the challenge description shown to players - Statement string `json:"statement"` + Statement string `json:"statement"` // Overview is the challenge description shown to public - Overview string `json:"overview"` + Overview string `json:"overview"` // Headline is the challenge headline to fill in small part - Headline string `json:"headline"` + Headline string `json:"headline"` // Finished is the text shown when the exercice is solved - Finished string `json:"finished"` + Finished string `json:"finished"` // Issue is an optional text describing an issue with the exercice - Issue string `json:"issue"` + Issue string `json:"issue"` // IssueKind is the criticity level of the previous issue - IssueKind string `json:"issuekind"` - Depend *int64 `json:"depend"` + IssueKind string `json:"issuekind"` + Depend *int64 `json:"depend"` // Gain is the basis amount of points player will earn if it solve the challenge // If this value fluctuate during the challenge, players' scores will follow changes. // Use Coefficient value to create temporary bonus/malus. - Gain int64 `json:"gain"` + Gain int64 `json:"gain"` // Coefficient is a temporary bonus/malus applied on Gain when the challenge is solved. // This value is saved along with solved informations: changing it doesn't affect Team that already solved the challenge. Coefficient float64 `json:"coefficient"` // VideoURI is the link to the resolution video - VideoURI string `json:"videoURI"` + VideoURI string `json:"videoURI"` } // GetExercice retrieves the challenge with the given id. @@ -163,7 +163,7 @@ func (t Theme) addExercice(e *Exercice) (err error) { cc = fmt.Sprintf("%f", e.Coefficient) } - if res, err := DBExec("INSERT INTO exercices (id_theme, title, url_id, path, statement, overview, finished, headline, issue, depend, gain, video_uri, issue_kind, coefficient_cur) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, " + ik + ", " + cc + ")", t.Id, e.Title, e.URLId, e.Path, e.Statement, e.Overview, e.Finished, e.Headline, e.Issue, e.Depend, e.Gain, e.VideoURI); err != nil { + if res, err := DBExec("INSERT INTO exercices (id_theme, title, url_id, path, statement, overview, finished, headline, issue, depend, gain, video_uri, issue_kind, coefficient_cur) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, "+ik+", "+cc+")", t.Id, e.Title, e.URLId, e.Path, e.Statement, e.Overview, e.Finished, e.Headline, e.Issue, e.Depend, e.Gain, e.VideoURI); err != nil { return err } else if eid, err := res.LastInsertId(); err != nil { return err @@ -182,16 +182,16 @@ func (t Theme) AddExercice(title string, urlId string, path string, statement st } e = Exercice{ - Title: title, - URLId: urlId, - Path: path, + Title: title, + URLId: urlId, + Path: path, Statement: statement, - Overview: overview, - Headline: headline, - Depend: dpd, - Finished: finished, - Gain: gain, - VideoURI: videoURI, + Overview: overview, + Headline: headline, + Depend: dpd, + Finished: finished, + Gain: gain, + VideoURI: videoURI, } err = t.addExercice(&e) @@ -313,7 +313,7 @@ func (e Exercice) UpdateTry(t Team, nbdiff int) error { // Solved registers that the given Team solves the challenge. func (e Exercice) Solved(t Team) error { - if _, err := DBExec("INSERT INTO exercice_solved (id_exercice, id_team, time, coefficient) VALUES (?, ?, ?, ?)", e.Id, t.Id, time.Now(), e.Coefficient * ExerciceCurrentCoefficient); err != nil { + if _, err := DBExec("INSERT INTO exercice_solved (id_exercice, id_team, time, coefficient) VALUES (?, ?, ?, ?)", e.Id, t.Id, time.Now(), e.Coefficient*ExerciceCurrentCoefficient); err != nil { return err } else { return nil @@ -338,7 +338,7 @@ func (e Exercice) TriedTeamCount() int64 { } var nb int64 - if err := DBQueryRow("SELECT COUNT(DISTINCT id_team) FROM " + tries_table + " WHERE id_exercice = ?", e.Id).Scan(&nb); err != nil { + if err := DBQueryRow("SELECT COUNT(DISTINCT id_team) FROM "+tries_table+" WHERE id_exercice = ?", e.Id).Scan(&nb); err != nil { return 0 } else { return nb @@ -353,7 +353,7 @@ func (e Exercice) TriedCount() int64 { } var nb int64 - if err := DBQueryRow("SELECT COUNT(id_team) FROM " + tries_table + " WHERE id_exercice = ?", e.Id).Scan(&nb); err != nil { + if err := DBQueryRow("SELECT COUNT(id_team) FROM "+tries_table+" WHERE id_exercice = ?", e.Id).Scan(&nb); err != nil { return 0 } else { return nb diff --git a/libfic/flag.go b/libfic/flag.go index 9f9eee7b..0e70093a 100644 --- a/libfic/flag.go +++ b/libfic/flag.go @@ -3,9 +3,11 @@ package fic import () type Flag interface { + GetId() int64 + Create(e Exercice) (Flag, error) Update() (int64, error) Delete() (int64, error) - AddDepend(d Flag) (error) + AddDepend(d Flag) error GetDepends() ([]Flag, error) Check(val interface{}) int FoundBy(t Team) @@ -34,6 +36,11 @@ func (e Exercice) GetFlags() ([]Flag, error) { return flags, nil } +// AddFlag add the given flag and eventually its entries (from MCQ). +func (e Exercice) AddFlag(flag Flag) (f Flag, err error) { + return flag.Create(e) +} + // WipeFlags deletes flags coming with the challenge. func (e Exercice) WipeFlags() (int64, error) { if _, err := DBExec("DELETE FROM exercice_files_deps WHERE id_flag IN (SELECT id_flag FROM exercice_flags WHERE id_exercice = ?)", e.Id); err != nil { diff --git a/libfic/flag_choice.go b/libfic/flag_choice.go index ce8c80de..0d7b9290 100644 --- a/libfic/flag_choice.go +++ b/libfic/flag_choice.go @@ -4,13 +4,13 @@ import () // FlagChoice represents a choice a respond to a classic flag type FlagChoice struct { - Id int64 `json:"id"` + Id int64 `json:"id"` // IdFlag is the identifier of the underlying flag - IdFlag int64 `json:"idFlag"` + IdFlag int64 `json:"idFlag"` // Label is the title of the choice as displayed to players - Label string `json:"label"` + Label string `json:"label"` // Value is the raw content that'll be written as response if this choice is selected - Value string `json:"value"` + Value string `json:"value"` } // GetChoices returns a list of choices for the given Flag. @@ -48,13 +48,12 @@ func (f FlagKey) GetChoice(id int64) (c FlagChoice, err error) { } // AddChoice creates and fills a new struct FlagChoice, from a label and a value. -func (f FlagKey) AddChoice(label string, value string) (FlagChoice, error) { - if res, err := DBExec("INSERT INTO flag_choices (id_flag, label, response) VALUES (?, ?, ?)", f.Id, label, value); err != nil { - return FlagChoice{}, err - } else if cid, err := res.LastInsertId(); err != nil { - return FlagChoice{}, err +func (f FlagKey) AddChoice(c FlagChoice) (FlagChoice, error) { + if res, err := DBExec("INSERT INTO flag_choices (id_flag, label, response) VALUES (?, ?, ?)", f.Id, c.Label, c.Value); err != nil { + return c, err } else { - return FlagChoice{cid, f.Id, label, value}, nil + c.Id, err = res.LastInsertId() + return c, err } } diff --git a/libfic/flag_key.go b/libfic/flag_key.go index 30e6e130..9dd3308e 100644 --- a/libfic/flag_key.go +++ b/libfic/flag_key.go @@ -12,21 +12,21 @@ import ( // FlagKey represents a flag's challenge, stored as hash. type FlagKey struct { - Id int64 `json:"id"` + Id int64 `json:"id"` // IdExercice is the identifier of the underlying challenge - IdExercice int64 `json:"idExercice"` + IdExercice int64 `json:"idExercice"` // Label is the title of the flag as displayed to players - Label string `json:"label"` + Label string `json:"label"` // Help is a small piece of text that aims to add useful information like flag format, ... - Help string `json:"help"` + Help string `json:"help"` // IgnoreCase indicates if the case is sensitive to case or not - IgnoreCase bool `json:"ignorecase"` + IgnoreCase bool `json:"ignorecase"` // ValidatorRegexp extracts a subset of the player's answer, that will be checked. ValidatorRegexp *string `json:"validator_regexp"` // Checksum is the expected hashed flag - Checksum []byte `json:"value"` + Checksum []byte `json:"value"` // ChoicesCost is the number of points lost to display choices. - ChoicesCost int64 `json:"choices_cost"` + ChoicesCost int64 `json:"choices_cost"` } // GetFlagKeys returns a list of key's flags comming with the challenge. @@ -67,14 +67,14 @@ func (e Exercice) GetFlagKeyByLabel(label string) (k FlagKey, err error) { return } -// getHashedFlag calculates the expected checksum for the given raw_value. -func getHashedFlag(raw_value []byte) [blake2b.Size]byte { +// ComputeHashedFlag calculates the expected checksum for the given raw_value. +func ComputeHashedFlag(raw_value []byte) [blake2b.Size]byte { hash := blake2b.Sum512(raw_value) return hash } func ExecValidatorRegexp(vre string, val []byte, ignorecase bool) ([]byte, error) { - if (ignorecase) { + if ignorecase { vre = "(?i)" + vre } if re, err := regexp.Compile(vre); err != nil { @@ -87,38 +87,55 @@ func ExecValidatorRegexp(vre string, val []byte, ignorecase bool) ([]byte, error } // AddRawFlagKey creates and fills a new struct FlagKey, from a non-hashed flag, and registers it into the database. -func (e Exercice) AddRawFlagKey(name string, help string, ignorecase bool, validator_regexp *string, raw_value []byte, choicescost int64) (FlagKey, error) { +func (e Exercice) AddRawFlagKey(name string, help string, ignorecase bool, validator_regexp *string, raw_value []byte, choicescost int64) (f FlagKey, err error) { if ignorecase { raw_value = bytes.ToLower(raw_value) } // Check that raw value passes through the regexp if validator_regexp != nil { - var err error if raw_value, err = ExecValidatorRegexp(*validator_regexp, raw_value, ignorecase); err != nil { - return FlagKey{}, err + return } } - hash := getHashedFlag(raw_value) - return e.AddFlagKey(name, help, ignorecase, validator_regexp, hash[:], choicescost) + hash := ComputeHashedFlag(raw_value) + + f = FlagKey{ + Label: name, + Help: help, + IgnoreCase: ignorecase, + ValidatorRegexp: validator_regexp, + Checksum: hash[:], + ChoicesCost: choicescost, + } + + _, err = f.Create(e) + return +} + +// GetId returns the Flag identifier. +func (k FlagKey) GetId() int64 { + return k.Id } // AddFlagKey creates and fills a new struct Flag, from a hashed flag, and registers it into the database. -func (e Exercice) AddFlagKey(name string, help string, ignorecase bool, validator_regexp *string, checksum []byte, choicescost int64) (FlagKey, error) { +func (k FlagKey) Create(e Exercice) (Flag, error) { // Check the regexp compile - if validator_regexp != nil { - if _, err := regexp.Compile(*validator_regexp); err != nil { - return FlagKey{}, err + if k.ValidatorRegexp != nil { + if _, err := regexp.Compile(*k.ValidatorRegexp); err != nil { + return k, err } } - if res, err := DBExec("INSERT INTO exercice_flags (id_exercice, type, help, ignorecase, validator_regexp, cksum, choices_cost) VALUES (?, ?, ?, ?, ?, ?, ?)", e.Id, name, help, ignorecase, validator_regexp, checksum, choicescost); err != nil { - return FlagKey{}, err + if res, err := DBExec("INSERT INTO exercice_flags (id_exercice, type, help, ignorecase, validator_regexp, cksum, choices_cost) VALUES (?, ?, ?, ?, ?, ?, ?)", e.Id, k.Label, k.Help, k.IgnoreCase, k.ValidatorRegexp, k.Checksum, k.ChoicesCost); err != nil { + return k, err } else if kid, err := res.LastInsertId(); err != nil { - return FlagKey{}, err + return k, err } else { - return FlagKey{kid, e.Id, name, help, ignorecase, validator_regexp, checksum, choicescost}, nil + k.Id = kid + k.IdExercice = e.Id + return k, nil } } @@ -140,7 +157,7 @@ func (k FlagKey) ComputeChecksum(val []byte) (cksum []byte, err error) { err = errors.New("Empty flag after applying filters") } - hash := getHashedFlag(val) + hash := ComputeHashedFlag(val) return hash[:], err } diff --git a/libfic/mcq.go b/libfic/mcq.go index e007d0e1..a589bad7 100644 --- a/libfic/mcq.go +++ b/libfic/mcq.go @@ -8,22 +8,22 @@ import ( // MCQ represents a flag's challenge, in the form of checkbox. type MCQ struct { - Id int64 `json:"id"` + Id int64 `json:"id"` // IdExercice is the identifier of the underlying challenge - IdExercice int64 `json:"idExercice"` + IdExercice int64 `json:"idExercice"` // Title is the label of the question - Title string `json:"title"` + Title string `json:"title"` // Entries stores the set of proposed answers - Entries []MCQ_entry `json:"entries"` + Entries []MCQ_entry `json:"entries"` } // MCQ_entry represents a proposed response for a given MCQ. type MCQ_entry struct { - Id int64 `json:"id"` + Id int64 `json:"id"` // Label is the text displayed to players as proposed answer - Label string `json:"label"` + Label string `json:"label"` // Response stores if expected checked state. - Response bool `json:"response"` + Response bool `json:"response"` } // GetMCQ returns the MCQs coming with the challenge. @@ -97,14 +97,31 @@ func GetMCQbyChoice(cid int64) (m MCQ, c MCQ_entry, err error) { return } -// AddMCQ creates and fills a new struct MCQ and registers it into the database. -func (e Exercice) AddMCQ(title string) (MCQ, error) { - if res, err := DBExec("INSERT INTO exercice_mcq (id_exercice, title) VALUES (?, ?)", e.Id, title); err != nil { - return MCQ{}, err +// GetId returns the MCQ identifier. +func (m MCQ) GetId() int64 { + return m.Id +} + +// Create registers a MCQ into the database and recursively add its entries. +func (m MCQ) Create(e Exercice) (Flag, error) { + if res, err := DBExec("INSERT INTO exercice_mcq (id_exercice, title) VALUES (?, ?)", e.Id, m.Title); err != nil { + return m, err } else if qid, err := res.LastInsertId(); err != nil { - return MCQ{}, err + return m, err } else { - return MCQ{qid, e.Id, title, []MCQ_entry{}}, nil + m.Id = qid + m.IdExercice = e.Id + + // Add entries + for k, entry := range m.Entries { + if entry, err = m.AddEntry(entry); err != nil { + return m, err + } else { + m.Entries[k] = entry + } + } + + return m, nil } } @@ -135,13 +152,14 @@ func (m MCQ) Delete() (int64, error) { } // AddEntry creates and fills a new struct MCQ_entry and registers it into the database. -func (m MCQ) AddEntry(label string, response bool) (MCQ_entry, error) { - if res, err := DBExec("INSERT INTO mcq_entries (id_mcq, label, response) VALUES (?, ?, ?)", m.Id, label, response); err != nil { - return MCQ_entry{}, err +func (m MCQ) AddEntry(e MCQ_entry) (MCQ_entry, error) { + if res, err := DBExec("INSERT INTO mcq_entries (id_mcq, label, response) VALUES (?, ?, ?)", m.Id, e.Label, e.Response); err != nil { + return e, err } else if nid, err := res.LastInsertId(); err != nil { - return MCQ_entry{}, err + return e, err } else { - return MCQ_entry{nid, label, response}, nil + e.Id = nid + return e, nil } }