server/admin/sync/exercice_keys.go

package sync

import (
	"fmt"
	"path"
	"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
}

// 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 {
		// Import normal flags
		for nline, flag := range params.Flags {
			if len(flag.Label) == 0 {
				flag.Label = "Flag"
			}

			if !isFullGraphic(flag.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.AddRawFlag(flag.Label, flag.Help, flag.IgnoreCase, validatorRegexp(flag.ValidatorRe), []byte(flag.Raw)); err != nil {
				errs = append(errs, fmt.Sprintf("%q: error flag #%d: %s", path.Base(exercice.Path), nline + 1, err))
				continue
			} else {
				// 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(k); 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 UCQ flags
		for nline, flag := range params.FlagsUCQ {
			if len(flag.Label) == 0 {
				flag.Label = "Flag"
			}

			if !isFullGraphic(flag.Raw) {
				errs = append(errs, fmt.Sprintf("%q: WARNING flag UCQ #%d: non-printable characters in flag, is this really expected?", path.Base(exercice.Path), nline + 1))
			}

			if k, err := exercice.AddRawFlag(flag.Label, flag.Help, flag.IgnoreCase, validatorRegexp(flag.ValidatorRe), []byte(flag.Raw)); err != nil {
				errs = append(errs, fmt.Sprintf("%q: error flag UCQ #%d: %s", path.Base(exercice.Path), nline + 1, err))
				continue
			} else {
				// 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 UCQ #%d dependency to %s: %s", path.Base(exercice.Path), nline + 1, lf.Filename, err))
						continue
					} else if err := rf.AddDepend(k); err != nil {
						errs = append(errs, fmt.Sprintf("%q: error flag UCQ #%d dependency to %s: %s", path.Base(exercice.Path), nline + 1, lf.Filename, err))
						continue
					}
				}

				// Import choices
				hasOne := false
				for cid, choice := range flag.Choice {
					if len(choice.Label) == 0 {
						choice.Label = choice.Value
					}

					if _, err := k.AddChoice(choice.Label, choice.Value); 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 choice.Value == flag.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 MCQ flags
		for nline, quest := range params.FlagsMCQ {
			if flag, err := exercice.AddMCQ(quest.Label); err != nil {
				errs = append(errs, fmt.Sprintf("%q: error flag MCQ #%d: %s", path.Base(exercice.Path), nline + 1, err))
				continue
			} else {
				hasOne := false
				isJustified := false
				for cid, choice := range quest.Choice {
					var val bool
					if choice.Value == nil {
						val = false
					} 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 p, ok := choice.Value.(string); ok {
						val = true
						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
						}
						isJustified = true
						if _, err := exercice.AddRawFlag("%" + quest.Label + "%" + choice.Label, "", false, nil, []byte(p)); err != nil {
							errs = append(errs, fmt.Sprintf("%q: error MCQ #%d: %s", path.Base(exercice.Path), nline + 1, err))
							continue
						}
					} else {
						errs = append(errs, fmt.Sprintf("%q: error in MCQ %d choice %d: has an invalid type. Expected true, false or a string", path.Base(exercice.Path), nline + 1, cid))
						continue
					}

					if _, err := flag.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
					}

					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))
				}
			}
		}
	}
	return
}