feat: create, publish, import and report on quizzes over MCP
- quizzes_create_quiz, update_quiz, delete_quiz (confirm repeats the slug), publish, unpublish, import_quiz (the existing import route) and quiz_stats on new manage routes - stats close expired open test attempts first, then report per student over completed whole-quiz attempts and per question over every completed attempt - input is checked before the database; TestManageAPIAgainstDatabase is written and skipped under -short
This commit is contained in:
@@ -8,11 +8,300 @@ package classes
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"math"
|
||||
"slices"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
|
||||
"git.golem15.com/golem15/sm-quizzes-plugin/models"
|
||||
"git.golem15.com/golem15/summercms/modules/lagoon"
|
||||
"gorm.io/gorm"
|
||||
"gorm.io/gorm/clause"
|
||||
)
|
||||
|
||||
// ValidationError is manage input that breaks a rule (a 422). Problems
|
||||
// read like the importer's: "title is required".
|
||||
type ValidationError struct {
|
||||
Problems []string
|
||||
}
|
||||
|
||||
func (e *ValidationError) Error() string { return "invalid quiz: " + strings.Join(e.Problems, "; ") }
|
||||
|
||||
// invalid wraps problems in a ValidationError, or returns nil for none.
|
||||
func invalid(problems []string) error {
|
||||
if len(problems) == 0 {
|
||||
return nil
|
||||
}
|
||||
return &ValidationError{Problems: problems}
|
||||
}
|
||||
|
||||
// QuizInput is the quiz fields of a create or a partial update; nil means
|
||||
// not sent. There is no IsPublished: a created quiz starts unpublished and
|
||||
// only SetPublished changes it.
|
||||
type QuizInput struct {
|
||||
Title *string `json:"title"`
|
||||
Slug *string `json:"slug"`
|
||||
Description *string `json:"description"`
|
||||
Context *string `json:"context"`
|
||||
Mode *string `json:"mode"`
|
||||
Navigation *string `json:"navigation"`
|
||||
MaxAttempts *int `json:"max_attempts"`
|
||||
TimeLimitSeconds *int `json:"time_limit_seconds"`
|
||||
PassingScore *int `json:"passing_score"`
|
||||
RoundSize *int `json:"round_size"`
|
||||
ShuffleQuestions *bool `json:"shuffle_questions"`
|
||||
}
|
||||
|
||||
// CheckQuizInput returns the rule problems of in. On create the title is
|
||||
// required and max_attempts, time_limit_seconds and round_size are at least
|
||||
// 1; on update 0 is allowed for them, as it clears the value.
|
||||
func CheckQuizInput(in QuizInput, create bool) []string {
|
||||
var problems []string
|
||||
switch {
|
||||
case in.Title == nil:
|
||||
if create {
|
||||
problems = append(problems, "title is required")
|
||||
}
|
||||
case strings.TrimSpace(*in.Title) == "":
|
||||
problems = append(problems, "title is required")
|
||||
case utf8.RuneCountInString(strings.TrimSpace(*in.Title)) > 255:
|
||||
problems = append(problems, "title must be at most 255 characters")
|
||||
}
|
||||
if create && in.Slug != nil && strings.TrimSpace(*in.Slug) != "" && models.Slugify(*in.Slug) == "" {
|
||||
problems = append(problems, "slug is empty after normalising it")
|
||||
}
|
||||
if create && (in.Slug == nil || strings.TrimSpace(*in.Slug) == "") && in.Title != nil &&
|
||||
strings.TrimSpace(*in.Title) != "" && models.Slugify(*in.Title) == "" {
|
||||
problems = append(problems, "slug is empty after normalising the title")
|
||||
}
|
||||
if in.Context != nil && utf8.RuneCountInString(strings.TrimSpace(*in.Context)) > 255 {
|
||||
problems = append(problems, "context must be at most 255 characters")
|
||||
}
|
||||
if in.Mode != nil && !slices.Contains(models.QuizModes, *in.Mode) {
|
||||
problems = append(problems, "mode must be one of "+strings.Join(models.QuizModes, ", "))
|
||||
}
|
||||
if in.Navigation != nil && !slices.Contains(models.QuizNavigations, *in.Navigation) {
|
||||
problems = append(problems, "navigation must be one of "+strings.Join(models.QuizNavigations, ", "))
|
||||
}
|
||||
if in.PassingScore != nil && (*in.PassingScore < 0 || *in.PassingScore > 100) {
|
||||
problems = append(problems, "passing_score must be between 0 and 100")
|
||||
}
|
||||
least, word := 1, "at least 1"
|
||||
if !create {
|
||||
least, word = 0, "0 (clears it) or more"
|
||||
}
|
||||
for _, f := range []struct {
|
||||
name string
|
||||
v *int
|
||||
}{{"max_attempts", in.MaxAttempts}, {"time_limit_seconds", in.TimeLimitSeconds}, {"round_size", in.RoundSize}} {
|
||||
if f.v != nil && *f.v < least {
|
||||
problems = append(problems, f.name+" must be "+word)
|
||||
}
|
||||
}
|
||||
return problems
|
||||
}
|
||||
|
||||
// positive is v, or nil when v is nil or not positive (0 clears).
|
||||
func positive(v *int) *int {
|
||||
if v == nil || *v <= 0 {
|
||||
return nil
|
||||
}
|
||||
n := *v
|
||||
return &n
|
||||
}
|
||||
|
||||
// CreateQuiz creates an unpublished quiz from in. The slug comes from Slug,
|
||||
// or from the title when Slug is empty; a taken slug is ErrQuizExists. The
|
||||
// passing score defaults to 50, mode and navigation to learning / free.
|
||||
func CreateQuiz(ctx context.Context, db *gorm.DB, in QuizInput) (*models.Quiz, error) {
|
||||
if err := invalid(CheckQuizInput(in, true)); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
quiz := models.Quiz{Title: strings.TrimSpace(*in.Title), PassingScore: 50}
|
||||
if in.Slug != nil && strings.TrimSpace(*in.Slug) != "" {
|
||||
quiz.Slug = models.Slugify(*in.Slug)
|
||||
} else {
|
||||
quiz.Slug = models.Slugify(quiz.Title)
|
||||
}
|
||||
applyQuizInput(&quiz, in)
|
||||
err := lagoon.Transaction(ctx, db, func(ctx context.Context, tx *gorm.DB) error {
|
||||
tx = tx.WithContext(ctx)
|
||||
var n int64
|
||||
if err := tx.Model(&models.Quiz{}).Where("slug = ?", quiz.Slug).Count(&n).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
if n > 0 {
|
||||
return ErrQuizExists
|
||||
}
|
||||
return tx.Create(&quiz).Error
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &quiz, nil
|
||||
}
|
||||
|
||||
// applyQuizInput sets the sent fields of in on quiz, except the slug and
|
||||
// the title's presence check. An empty description or context is NULL, a
|
||||
// 0 limit is NULL.
|
||||
func applyQuizInput(quiz *models.Quiz, in QuizInput) {
|
||||
if in.Title != nil {
|
||||
quiz.Title = strings.TrimSpace(*in.Title)
|
||||
}
|
||||
if in.Description != nil {
|
||||
quiz.Description = nilIfBlank(*in.Description, false)
|
||||
}
|
||||
if in.Context != nil {
|
||||
quiz.Context = nilIfBlank(*in.Context, true)
|
||||
}
|
||||
if in.Mode != nil {
|
||||
quiz.Mode = *in.Mode
|
||||
}
|
||||
if in.Navigation != nil {
|
||||
quiz.Navigation = *in.Navigation
|
||||
}
|
||||
if in.MaxAttempts != nil {
|
||||
quiz.MaxAttempts = positive(in.MaxAttempts)
|
||||
}
|
||||
if in.TimeLimitSeconds != nil {
|
||||
quiz.TimeLimitSeconds = positive(in.TimeLimitSeconds)
|
||||
}
|
||||
if in.RoundSize != nil {
|
||||
quiz.RoundSize = positive(in.RoundSize)
|
||||
}
|
||||
if in.PassingScore != nil {
|
||||
quiz.PassingScore = *in.PassingScore
|
||||
}
|
||||
if in.ShuffleQuestions != nil {
|
||||
quiz.ShuffleQuestions = *in.ShuffleQuestions
|
||||
}
|
||||
}
|
||||
|
||||
// nilIfBlank is nil for a blank s, else s (trimmed when trim is set).
|
||||
func nilIfBlank(s string, trim bool) *string {
|
||||
if strings.TrimSpace(s) == "" {
|
||||
return nil
|
||||
}
|
||||
if trim {
|
||||
s = strings.TrimSpace(s)
|
||||
}
|
||||
return &s
|
||||
}
|
||||
|
||||
// UpdateQuiz changes only the sent fields of the quiz with this slug: 0
|
||||
// clears max_attempts, time_limit_seconds and round_size, an empty string
|
||||
// clears description and context. Slug is ignored, and it cannot publish
|
||||
// (A10). A missing slug is ErrNotFound.
|
||||
func UpdateQuiz(ctx context.Context, db *gorm.DB, slug string, in QuizInput) (*models.Quiz, error) {
|
||||
if err := invalid(CheckQuizInput(in, false)); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var quiz models.Quiz
|
||||
err := lagoon.Transaction(ctx, db, func(ctx context.Context, tx *gorm.DB) error {
|
||||
tx = tx.WithContext(ctx)
|
||||
if err := lockedQuiz(tx, slug, &quiz); err != nil {
|
||||
return err
|
||||
}
|
||||
applyQuizInput(&quiz, in)
|
||||
return tx.Omit(clause.Associations).Save(&quiz).Error
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &quiz, nil
|
||||
}
|
||||
|
||||
// lockedQuiz loads the quiz with this slug FOR UPDATE, or ErrNotFound.
|
||||
func lockedQuiz(tx *gorm.DB, slug string, quiz *models.Quiz) error {
|
||||
err := tx.Clauses(clause.Locking{Strength: "UPDATE", Table: clause.Table{Name: clause.CurrentTable}}).
|
||||
Where("slug = ?", slug).Take(quiz).Error
|
||||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||||
return ErrNotFound
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
// ValidateDeleteConfirm refuses a delete whose confirm value is not the
|
||||
// quiz slug, so a stray DELETE cannot remove a quiz by accident.
|
||||
func ValidateDeleteConfirm(slug, confirm string) error {
|
||||
if strings.TrimSpace(confirm) == "" || confirm != slug {
|
||||
return &ValidationError{Problems: []string{"confirm must repeat the quiz slug"}}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// DeletedQuiz is the answer of a quiz delete: what was removed.
|
||||
type DeletedQuiz struct {
|
||||
ID uint
|
||||
Slug string
|
||||
Title string
|
||||
Questions int64
|
||||
Attempts int64
|
||||
}
|
||||
|
||||
// DeleteQuiz removes the quiz with this slug for good. The foreign keys
|
||||
// cascade to its questions, answers, attempts and attempt answers; the
|
||||
// counts are taken first. A missing slug is ErrNotFound.
|
||||
func DeleteQuiz(ctx context.Context, db *gorm.DB, slug string) (*DeletedQuiz, error) {
|
||||
var out DeletedQuiz
|
||||
err := lagoon.Transaction(ctx, db, func(ctx context.Context, tx *gorm.DB) error {
|
||||
tx = tx.WithContext(ctx)
|
||||
var quiz models.Quiz
|
||||
if err := lockedQuiz(tx, slug, &quiz); err != nil {
|
||||
return err
|
||||
}
|
||||
out = DeletedQuiz{ID: quiz.ID, Slug: quiz.Slug, Title: quiz.Title}
|
||||
if err := tx.Model(&models.Question{}).Where("quiz_id = ?", quiz.ID).Count(&out.Questions).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
if err := tx.Model(&models.Attempt{}).Where("quiz_id = ?", quiz.ID).Count(&out.Attempts).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
return tx.Where("id = ?", quiz.ID).Delete(&models.Quiz{}).Error
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &out, nil
|
||||
}
|
||||
|
||||
// SetPublished publishes or unpublishes the quiz with this slug; doing it
|
||||
// twice is the same as once. A missing slug is ErrNotFound.
|
||||
func SetPublished(ctx context.Context, db *gorm.DB, slug string, published bool) (*models.Quiz, error) {
|
||||
var quiz models.Quiz
|
||||
err := lagoon.Transaction(ctx, db, func(ctx context.Context, tx *gorm.DB) error {
|
||||
tx = tx.WithContext(ctx)
|
||||
if err := lockedQuiz(tx, slug, &quiz); err != nil {
|
||||
return err
|
||||
}
|
||||
if quiz.IsPublished == published {
|
||||
return nil
|
||||
}
|
||||
quiz.IsPublished = published
|
||||
return tx.Model(&models.Quiz{}).Where("id = ?", quiz.ID).
|
||||
Updates(map[string]any{"is_published": published, "updated_at": time.Now().UTC()}).Error
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &quiz, nil
|
||||
}
|
||||
|
||||
// ManagedRow counts the questions and completed attempts of one quiz, for
|
||||
// the answers of the quiz writes.
|
||||
func ManagedRow(ctx context.Context, db *gorm.DB, quiz models.Quiz) (ManagedQuizRow, error) {
|
||||
row := ManagedQuizRow{Quiz: quiz}
|
||||
var n int64
|
||||
if err := db.WithContext(ctx).Model(&models.Question{}).Where("quiz_id = ?", quiz.ID).Count(&n).Error; err != nil {
|
||||
return row, err
|
||||
}
|
||||
row.QuestionCount = int(n)
|
||||
attempts, err := CompletedAttemptCount(ctx, db, quiz.ID)
|
||||
row.AttemptsCount = attempts
|
||||
return row, err
|
||||
}
|
||||
|
||||
// ManagedQuizRow is one quiz of the owner list with its question count and
|
||||
// the number of completed attempts (of every user).
|
||||
type ManagedQuizRow struct {
|
||||
@@ -95,3 +384,210 @@ func CompletedAttemptCount(ctx context.Context, db *gorm.DB, quizID uint) (int,
|
||||
Where("quiz_id = ? AND completed_at IS NOT NULL", quizID).Count(&n).Error
|
||||
return int(n), err
|
||||
}
|
||||
|
||||
// StudentStat is one student's results on a quiz, over their completed
|
||||
// whole-quiz attempts (category IS NULL, A9).
|
||||
type StudentStat struct {
|
||||
UserID uint
|
||||
Email string
|
||||
Name *string
|
||||
Surname *string
|
||||
Attempts int
|
||||
BestScorePercent *float64
|
||||
LastScorePercent *float64
|
||||
LastCompletedAt *time.Time
|
||||
// Passed is BestScorePercent >= the quiz's passing score.
|
||||
Passed bool
|
||||
}
|
||||
|
||||
// WrongAnswerStat is the wrong answer chosen most often for a question.
|
||||
type WrongAnswerStat struct {
|
||||
AnswerID uint
|
||||
Text string
|
||||
Count int
|
||||
}
|
||||
|
||||
// QuestionStat is one question's results over every completed attempt's
|
||||
// answers. CorrectPercent is nil when nobody answered it; MostChosenWrong
|
||||
// is nil for a self_check question and when no wrong answer was chosen.
|
||||
type QuestionStat struct {
|
||||
ID uint
|
||||
Text string
|
||||
Type string
|
||||
Answered int
|
||||
Correct int
|
||||
CorrectPercent *float64
|
||||
MostChosenWrong *WrongAnswerStat
|
||||
}
|
||||
|
||||
// Stats is the owner's report on one quiz (D-15).
|
||||
type Stats struct {
|
||||
Quiz models.Quiz
|
||||
QuestionCount int
|
||||
Students []StudentStat
|
||||
Questions []QuestionStat
|
||||
}
|
||||
|
||||
// StudentRow is one row of the per-student stats query.
|
||||
type StudentRow struct {
|
||||
UserID uint
|
||||
Email string
|
||||
Name *string
|
||||
Surname *string
|
||||
Attempts int
|
||||
BestScorePercent *float64
|
||||
LastScorePercent *float64
|
||||
LastCompletedAt *time.Time
|
||||
}
|
||||
|
||||
// AnswerRow is one row of the per-question answered/correct query.
|
||||
type AnswerRow struct {
|
||||
QuestionID uint
|
||||
Answered int
|
||||
Correct int
|
||||
}
|
||||
|
||||
// WrongRow is one wrong answer chosen N times for a question.
|
||||
type WrongRow struct {
|
||||
QuestionID uint
|
||||
AnswerID uint
|
||||
Text string
|
||||
N int
|
||||
}
|
||||
|
||||
const (
|
||||
statsStudentsSQL = `SELECT a.user_id, u.email, u.name, u.surname, COUNT(*) AS attempts,
|
||||
MAX(a.score_percent) AS best_score_percent,
|
||||
(ARRAY_AGG(a.score_percent ORDER BY a.completed_at DESC, a.id DESC))[1] AS last_score_percent,
|
||||
MAX(a.completed_at) AS last_completed_at
|
||||
FROM golem15_quizzes_attempts a JOIN users u ON u.id = a.user_id
|
||||
WHERE a.quiz_id = ? AND a.completed_at IS NOT NULL AND a.category IS NULL
|
||||
GROUP BY a.user_id, u.email, u.name, u.surname
|
||||
ORDER BY u.surname ASC NULLS LAST, u.name ASC NULLS LAST, u.email ASC, a.user_id ASC`
|
||||
|
||||
statsAnswersSQL = `SELECT aa.question_id, COUNT(*) AS answered, COUNT(*) FILTER (WHERE aa.is_correct) AS correct
|
||||
FROM golem15_quizzes_attempt_answers aa
|
||||
JOIN golem15_quizzes_attempts a ON a.id = aa.attempt_id
|
||||
WHERE a.quiz_id = ? AND a.completed_at IS NOT NULL
|
||||
GROUP BY aa.question_id`
|
||||
|
||||
// A stored answer_ids that is SQL NULL or not an array (self_check
|
||||
// rows) yields no elements instead of an error.
|
||||
statsWrongSQL = `SELECT aa.question_id, ans.id AS answer_id, ans.text, COUNT(*) AS n
|
||||
FROM golem15_quizzes_attempt_answers aa
|
||||
JOIN golem15_quizzes_attempts a ON a.id = aa.attempt_id
|
||||
CROSS JOIN LATERAL jsonb_array_elements_text(CASE WHEN jsonb_typeof(aa.answer_ids) = 'array' THEN aa.answer_ids ELSE '[]'::jsonb END) AS e(value)
|
||||
JOIN golem15_quizzes_answers ans ON ans.id = e.value::bigint AND ans.question_id = aa.question_id AND ans.is_correct = FALSE
|
||||
WHERE a.quiz_id = ? AND a.completed_at IS NOT NULL
|
||||
GROUP BY aa.question_id, ans.id, ans.text
|
||||
ORDER BY aa.question_id, n DESC, ans.id`
|
||||
)
|
||||
|
||||
// QuizStats reports on the quiz with this slug. For a test it first closes
|
||||
// every expired open attempt at its deadline, through svc, so a student who
|
||||
// left a test counts with the answers given in time. Students are counted
|
||||
// over completed whole-quiz attempts, questions over the answers of every
|
||||
// completed attempt. A missing slug is ErrNotFound.
|
||||
func QuizStats(ctx context.Context, db *gorm.DB, slug string, svc *Service) (*Stats, error) {
|
||||
if svc == nil {
|
||||
svc = &Service{DB: db, Grace: DefaultTestGrace}
|
||||
}
|
||||
var quiz models.Quiz
|
||||
err := db.WithContext(ctx).Where("slug = ?", slug).Take(&quiz).Error
|
||||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if IsTest(&quiz) {
|
||||
if err := svc.closeExpired(ctx, db, &quiz); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
tx := db.WithContext(ctx)
|
||||
var questions []models.Question
|
||||
if err := tx.Where("quiz_id = ?", quiz.ID).Order("sort_order ASC, id ASC").Find(&questions).Error; err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var students []StudentRow
|
||||
if err := tx.Raw(statsStudentsSQL, quiz.ID).Scan(&students).Error; err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var answers []AnswerRow
|
||||
if err := tx.Raw(statsAnswersSQL, quiz.ID).Scan(&answers).Error; err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var wrong []WrongRow
|
||||
if err := tx.Raw(statsWrongSQL, quiz.ID).Scan(&wrong).Error; err != nil {
|
||||
return nil, err
|
||||
}
|
||||
stats := BuildStats(quiz, questions, students, answers, wrong)
|
||||
return &stats, nil
|
||||
}
|
||||
|
||||
// closeExpired closes every expired open attempt of a test at its
|
||||
// deadline, in one transaction, with the rows locked as Start locks them.
|
||||
func (s *Service) closeExpired(ctx context.Context, db *gorm.DB, quiz *models.Quiz) error {
|
||||
return lagoon.Transaction(ctx, db, func(ctx context.Context, tx *gorm.DB) error {
|
||||
var open []models.Attempt
|
||||
if err := tx.WithContext(ctx).Clauses(clause.Locking{Strength: "UPDATE", Table: clause.Table{Name: clause.CurrentTable}}).
|
||||
Where("quiz_id = ? AND completed_at IS NULL", quiz.ID).Order("id ASC").Find(&open).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
now := s.now()
|
||||
for i := range open {
|
||||
a := &open[i]
|
||||
a.Quiz = quiz
|
||||
if Expired(a, now, s.Grace) {
|
||||
if err := s.close(ctx, tx, a, *Deadline(a)); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
// BuildStats assembles the report from the query rows. Every question of
|
||||
// questions appears, in that order, with zero counts when nobody answered
|
||||
// it; correct_percent is rounded to one decimal.
|
||||
func BuildStats(quiz models.Quiz, questions []models.Question, students []StudentRow, answers []AnswerRow, wrong []WrongRow) Stats {
|
||||
out := Stats{
|
||||
Quiz: quiz,
|
||||
QuestionCount: len(questions),
|
||||
Students: make([]StudentStat, 0, len(students)),
|
||||
Questions: make([]QuestionStat, 0, len(questions)),
|
||||
}
|
||||
for _, r := range students {
|
||||
out.Students = append(out.Students, StudentStat{
|
||||
UserID: r.UserID, Email: r.Email, Name: r.Name, Surname: r.Surname, Attempts: r.Attempts,
|
||||
BestScorePercent: r.BestScorePercent, LastScorePercent: r.LastScorePercent, LastCompletedAt: r.LastCompletedAt,
|
||||
Passed: r.BestScorePercent != nil && *r.BestScorePercent >= float64(quiz.PassingScore),
|
||||
})
|
||||
}
|
||||
answeredBy := map[uint]AnswerRow{}
|
||||
for _, r := range answers {
|
||||
answeredBy[r.QuestionID] = r
|
||||
}
|
||||
wrongBy := map[uint]*WrongAnswerStat{}
|
||||
for _, r := range wrong {
|
||||
best := wrongBy[r.QuestionID]
|
||||
if best == nil || r.N > best.Count || (r.N == best.Count && r.AnswerID < best.AnswerID) {
|
||||
wrongBy[r.QuestionID] = &WrongAnswerStat{AnswerID: r.AnswerID, Text: r.Text, Count: r.N}
|
||||
}
|
||||
}
|
||||
for _, q := range questions {
|
||||
a := answeredBy[q.ID]
|
||||
st := QuestionStat{ID: q.ID, Text: q.Text, Type: q.Type, Answered: a.Answered, Correct: a.Correct}
|
||||
if a.Answered > 0 {
|
||||
pct := math.Round(float64(a.Correct)*1000/float64(a.Answered)) / 10
|
||||
st.CorrectPercent = &pct
|
||||
}
|
||||
if q.Type != models.TypeSelfCheck {
|
||||
st.MostChosenWrong = wrongBy[q.ID]
|
||||
}
|
||||
out.Questions = append(out.Questions, st)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user