319 lines
9.6 KiB
Go
319 lines
9.6 KiB
Go
package sync
|
|
|
|
import (
|
|
"fmt"
|
|
"math/rand"
|
|
"path"
|
|
"sort"
|
|
"strings"
|
|
"unicode"
|
|
|
|
"srs.epita.fr/fic-server/libfic"
|
|
)
|
|
|
|
// isFullGraphic detects if some rune are not graphic one.
|
|
// This function is usefull to display warning when importing key ending with \r.
|
|
func isFullGraphic(s string) bool {
|
|
for _, c := range s {
|
|
if !unicode.IsGraphic(c) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func validatorRegexp(vre string) (validator_regexp *string) {
|
|
if len(vre) > 0 {
|
|
validator_regexp = &vre
|
|
} else {
|
|
validator_regexp = nil
|
|
}
|
|
return
|
|
}
|
|
|
|
func getRawKey(flag ExerciceFlag) (raw string, prep string, errs []string) {
|
|
// Concatenate array
|
|
if f, ok := flag.Raw.([]interface{}); ok {
|
|
if len(flag.ValidatorRe) > 0 {
|
|
errs = append(errs, "ValidatorRe cannot be defined for this kind of flag.")
|
|
flag.ValidatorRe = ""
|
|
}
|
|
|
|
if len(flag.Separator) == 0 {
|
|
flag.Separator = ","
|
|
} else if len(flag.Separator) > 1 {
|
|
flag.Separator = string(flag.Separator[0])
|
|
errs = append(errs, "separator truncated to %q")
|
|
}
|
|
|
|
var fitems []string
|
|
for _, v := range f {
|
|
if g, ok := v.(string); ok {
|
|
if strings.Index(g, flag.Separator) != -1 {
|
|
errs = append(errs, "flag items cannot contain %q character as it is used as separator. Change the separator attribute for this flag.")
|
|
return
|
|
} else {
|
|
fitems = append(fitems, g)
|
|
}
|
|
} else {
|
|
errs = append(errs, "item %d has an invalid type: can only be string, is %T.")
|
|
return
|
|
}
|
|
}
|
|
|
|
ignord := "t"
|
|
if flag.Ordered {
|
|
sort.Strings(fitems)
|
|
ignord = "f"
|
|
}
|
|
raw = strings.Join(fitems, flag.Separator) + flag.Separator
|
|
|
|
prep = "`" + flag.Separator + ignord
|
|
} else if f, ok := flag.Raw.(int64); ok {
|
|
raw = fmt.Sprintf("%d", f)
|
|
} else if f, ok := flag.Value.(string); ok && len(f) > 0 {
|
|
raw = f
|
|
} else if f, ok := flag.Raw.(string); !ok {
|
|
errs = append(errs, fmt.Sprintf("has an invalid type: can only be []string or string, not %T", flag.Raw))
|
|
return
|
|
} else {
|
|
raw = f
|
|
}
|
|
return
|
|
}
|
|
|
|
// SyncExerciceFlags reads the content of challenge.txt and import "classic" flags as Key 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 {
|
|
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)
|
|
|
|
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)
|
|
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
|
|
}
|
|
choice.Label = prep + choice.Label
|
|
|
|
if len(choice.Label) == 0 {
|
|
choice.Label = val
|
|
}
|
|
|
|
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))
|
|
}
|
|
}
|
|
}
|
|
} 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]
|
|
})
|
|
}
|
|
|
|
for cid, choice := range flag.Choice {
|
|
var val bool
|
|
var justify string
|
|
|
|
if choice.Value == nil {
|
|
val = false
|
|
} else if p, ok := choice.Value.(bool); ok {
|
|
val = p
|
|
if len(choice.Help) > 0 {
|
|
errs = append(errs, fmt.Sprintf("%q: error MCQ #%d: help field has to be used only with justified mcq.", path.Base(exercice.Path), nline + 1))
|
|
continue
|
|
}
|
|
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.Raw == nil && choice.Value != nil {
|
|
choice.Raw = choice.Value
|
|
choice.Value = nil
|
|
}
|
|
if len(choice.Help) == 0 {
|
|
choice.Help = "Flag correspondant"
|
|
}
|
|
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
|
|
}
|
|
|
|
var prep string
|
|
var terrs []string
|
|
val = true
|
|
isJustified = true
|
|
justify, prep, terrs = getRawKey(choice)
|
|
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
|
|
}
|
|
choice.Help = prep + choice.Help
|
|
}
|
|
|
|
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 len(justify) > 0 {
|
|
if _, err := exercice.AddRawFlagKey(fmt.Sprintf("%%%d%%%s", e.Id, choice.Help), "", false, nil, []byte(justify), 0); 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))
|
|
}
|
|
}
|
|
}
|
|
|
|
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
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|