fic/server
Archived
1
0
Fork 0
Code Issues Pull requests 10 Releases Wiki Activity

sync: Extract function that import flags from importer

Browse source
This commit is contained in:
nemunaire 2019-07-05 22:28:56 +02:00
parent 3f55845374
commit 4039a394b5
8 changed files with 454 additions and 310 deletions
Download patch file Download diff file Expand all files Collapse all files

14
admin/api/exercice.go
View file

@ -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()
}

44
admin/sync/exercice_defines.go
View file

@ -1,9 +1,11 @@
package sync
import (
"fmt"
"path"
"github.com/BurntSushi/toml"
"srs.epita.fr/fic-server/libfic"
)
// ExerciceHintParams holds EHint definition infomation.
@ -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
}

363
admin/sync/exercice_keys.go
View file

@ -82,59 +82,112 @@ 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 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 {
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 = "Flag"
flag.Label = defaultLabel
}
if flag.Label[0] == '`' {
errs = append(errs, fmt.Sprintf("%q: flag #%d: Label should not begin with `.", path.Base(exercice.Path), nline + 1))
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"
@ -149,72 +202,25 @@ func SyncExerciceFlags(i Importer, exercice fic.Exercice) (errs []string) {
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))
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" {
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
addedFlag := fic.MCQ{
IdExercice: exercice.Id,
Title: flag.Label,
Entries: []fic.MCQ_entry{},
}
hasOne := false
isJustified := false
@ -226,7 +232,6 @@ func SyncExerciceFlags(i Importer, exercice fic.Exercice) (errs []string) {
for cid, choice := range flag.Choice {
var val bool
var justify string
if choice.Justification != nil {
if hasOne && !isJustified {
@ -249,67 +254,127 @@ func SyncExerciceFlags(i Importer, exercice fic.Exercice) (errs []string) {
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
}
addedFlag.Entries = append(addedFlag.Entries, fic.MCQ_entry{
Label: choice.Label,
Response: val,
})
if len(choice.Justification.Label) == 0 {
choice.Justification.Label = "Flag correspondant"
if isJustified && choice.Justification != nil {
addedFlag, choices, berrs := buildKeyFlag(exercice, *choice.Justification, nline+1, "Flag correspondant")
if len(berrs) > 0 {
errs = append(errs, berrs...)
}
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 addedFlag != nil {
flags[flag.Id] = importFlag{
Line: nline,
Flag: *addedFlag,
Choices: choices,
}
}
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
// 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 {
flags, berrs := buildExerciceFlags(i, exercice)
errs = append(errs, berrs...)
kmap := map[int64]fic.Flag{}
// 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))
}
}
}
kmap[flagid] = 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
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), nline + 1, nf.Id, err))
continue
errs = append(errs, fmt.Sprintf("%q: error flag #%d dependency to id=%d: %s", path.Base(exercice.Path), flag.Line, nf, err))
}
}
// 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
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), nline + 1, lf.Filename, err))
continue
errs = append(errs, fmt.Sprintf("%q: error flag #%d dependency to %s: %s", path.Base(exercice.Path), flag.Line, lf, err))
}
}
}
}
}
return
}

9
libfic/flag.go
View file

@ -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 {

11
libfic/flag_choice.go
View file

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

51
libfic/flag_key.go
View file

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

40
libfic/mcq.go
View file

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