server/libfic/exercice.go

package fic

import (
	"errors"
	"time"
)

var PartialValidation bool

type Exercice struct {
	Id        int64  `json:"id"`
	Title     string `json:"title"`
	Statement string `json:"statement"`
	Depend    *int64 `json:"depend"`
	Gain      int64  `json:"gain"`
	VideoURI  string `json:"videoURI"`
}

func GetExercice(id int64) (Exercice, error) {
	var e Exercice
	if err := DBQueryRow("SELECT id_exercice, title, statement, depend, gain, video_uri FROM exercices WHERE id_exercice = ?", id).Scan(&e.Id, &e.Title, &e.Statement, &e.Depend, &e.Gain, &e.VideoURI); err != nil {
		return Exercice{}, err
	}

	return e, nil
}

func (t Theme) GetExercice(id int) (Exercice, error) {
	var e Exercice
	if err := DBQueryRow("SELECT id_exercice, title, statement, depend, gain, video_uri FROM exercices WHERE id_theme = ? AND id_exercice = ?", t.Id, id).Scan(&e.Id, &e.Title, &e.Statement, &e.Depend, &e.Gain, &e.VideoURI); err != nil {
		return Exercice{}, err
	}

	return e, nil
}

func GetExercices() ([]Exercice, error) {
	if rows, err := DBQuery("SELECT id_exercice, title, statement, depend, gain, video_uri FROM exercices"); err != nil {
		return nil, err
	} else {
		defer rows.Close()

		var exos = make([]Exercice, 0)
		for rows.Next() {
			var e Exercice
			if err := rows.Scan(&e.Id, &e.Title, &e.Statement, &e.Depend, &e.Gain, &e.VideoURI); err != nil {
				return nil, err
			}
			exos = append(exos, e)
		}
		if err := rows.Err(); err != nil {
			return nil, err
		}

		return exos, nil
	}
}

func (t Theme) GetExercices() ([]Exercice, error) {
	if rows, err := DBQuery("SELECT id_exercice, title, statement, depend, gain, video_uri FROM exercices WHERE id_theme = ?", t.Id); err != nil {
		return nil, err
	} else {
		defer rows.Close()

		var exos = make([]Exercice, 0)
		for rows.Next() {
			var e Exercice
			if err := rows.Scan(&e.Id, &e.Title, &e.Statement, &e.Depend, &e.Gain, &e.VideoURI); err != nil {
				return nil, err
			}
			exos = append(exos, e)
		}
		if err := rows.Err(); err != nil {
			return nil, err
		}

		return exos, nil
	}
}

func (t Theme) AddExercice(title string, statement string, depend *Exercice, gain int, videoURI string) (Exercice, error) {
	var dpd interface{}
	if depend == nil {
		dpd = nil
	} else {
		dpd = depend.Id
	}
	if res, err := DBExec("INSERT INTO exercices (id_theme, title, statement, depend, gain, video_uri) VALUES (?, ?, ?, ?, ?, ?)", t.Id, title, statement, dpd, gain, videoURI); err != nil {
		return Exercice{}, err
	} else if eid, err := res.LastInsertId(); err != nil {
		return Exercice{}, err
	} else {
		if depend == nil {
			return Exercice{eid, title, statement, nil, int64(gain), videoURI}, nil
		} else {
			return Exercice{eid, title, statement, &depend.Id, int64(gain), videoURI}, nil
		}
	}
}

func (e Exercice) Update() (int64, error) {
	if res, err := DBExec("UPDATE exercices SET title = ?, statement = ?, depend = ?, gain = ?, video_uri = ? WHERE id_exercice = ?", e.Title, e.Statement, e.Depend, e.Gain, e.VideoURI, e.Id); err != nil {
		return 0, err
	} else if nb, err := res.RowsAffected(); err != nil {
		return 0, err
	} else {
		return nb, err
	}
}

func (e Exercice) GetThemeId() (int, error) {
	var tid int
	if err := DBQueryRow("SELECT id_theme FROM exercices WHERE id_exercice=?", e.Id).Scan(&tid); err != nil {
		return 0, err
	}
	return tid, nil
}

func (e Exercice) GetTheme() (Theme, error) {
	if tid, err := e.GetThemeId(); err != nil {
		return Theme{}, err
	} else {
		return GetTheme(tid)
	}
}

func (e Exercice) Delete() (int64, error) {
	if res, err := DBExec("DELETE FROM exercices WHERE id_exercice = ?", e.Id); err != nil {
		return 0, err
	} else if nb, err := res.RowsAffected(); err != nil {
		return 0, err
	} else {
		return nb, err
	}
}

func (e Exercice) GetLevel() (int, error) {
	dep := e.Depend
	nb := 1
	for dep != nil {
		nb += 1
		if edep, err := GetExercice(*dep); err != nil {
			return nb, err
		} else {
			dep = edep.Depend
		}
	}
	return nb, nil
}

func (e Exercice) NewTry(t Team) error {
	if _, err := DBExec("INSERT INTO exercice_tries (id_exercice, id_team, time) VALUES (?, ?, ?)", e.Id, t.Id, time.Now()); err != nil {
		return err
	} else {
		return nil
	}
}

func (e Exercice) Solved(t Team) error {
	if _, err := DBExec("INSERT INTO exercice_solved (id_exercice, id_team, time) VALUES (?, ?, ?)", e.Id, t.Id, time.Now()); err != nil {
		return err
	} else {
		return nil
	}
}

func (e Exercice) SolvedCount() int64 {
	var nb int64
	if err := DBQueryRow("SELECT COUNT(id_exercice) FROM exercice_solved WHERE id_exercice = ?", e.Id).Scan(&nb); err != nil {
		return 0
	} else {
		return nb
	}
}

func (e Exercice) TriedTeamCount() int64 {
	var nb int64
	if err := DBQueryRow("SELECT COUNT(DISTINCT id_team) FROM exercice_tries WHERE id_exercice = ?", e.Id).Scan(&nb); err != nil {
		return 0
	} else {
		return nb
	}
}

func (e Exercice) TriedCount() int64 {
	var nb int64
	if err := DBQueryRow("SELECT COUNT(id_team) FROM exercice_tries WHERE id_exercice = ?", e.Id).Scan(&nb); err != nil {
		return 0
	} else {
		return nb
	}
}

func (e Exercice) CheckResponse(resps map[string]string, t Team) (bool, error) {
	if err := e.NewTry(t); err != nil {
		return false, err
	} else if keys, err := e.GetKeys(); err != nil {
		return false, err
	} else {
		if len(keys) < 1 {
			return true, errors.New("Exercice with no key registered")
		}

		valid := true
		for _, key := range keys {
			if res, ok := resps[key.Type]; !ok {
				valid = false
			} else if !key.Check(res) {
				if !PartialValidation || t.HasPartiallySolved(key) == nil {
					valid = false
				}
			} else {
				key.FoundBy(t)
			}
		}

		return valid, nil
	}
}