oef/orm/question.go

package orm

import (
	"net/http"

	"git.andreafazzi.eu/andrea/oef/renderer"
	"github.com/jinzhu/gorm"
)

type Question struct {
	gorm.Model

	Text      string `gorm:"type:varchar(1024)"`
	Contest   *Contest
	ContestID uint `schema:"contest_id"`

	Answers []*Answer

	SelectedContest map[uint]string `gorm:"-"`
	AllContests     []*Contest      `gorm:"-"`
}

func (q *Question) GetID() uint { return q.ID }

func (q *Question) String() string {
	return q.Text
}

func (q *Question) BeforeCreate(tx *gorm.DB) error {
	if len(q.Answers) > 0 {
		q.Answers[0].Correct = true
	}
	return nil
}

func (q *Question) Create(db *Database, args map[string]string, w http.ResponseWriter, r *http.Request) (interface{}, error) {
	if r.Method == "GET" {
		question := new(Question)
		if err := db._db.Find(&question.AllContests).Error; err != nil {
			return nil, err
		}
		return question, nil
	} else {
		question := new(Question)
		err := renderer.Decode(question, r)
		if err != nil {
			return nil, err
		}
		question, err = CreateQuestion(db, question)
		if err != nil {
			return nil, err
		}
		return question, nil
	}
}

func (q *Question) Read(db *Database, args map[string]string, w http.ResponseWriter, r *http.Request) (interface{}, error) {
	var question Question

	id := args["id"]

	if err := db._db.Preload("Answers", func(db *gorm.DB) *gorm.DB {
		return db.Order("answers.correct DESC")
	}).Preload("Contest").First(&question, id).Error; err != nil {
		return nil, err
	}

	return &question, nil
}

func (q *Question) ReadAll(db *Database, args map[string]string, w http.ResponseWriter, r *http.Request) (interface{}, error) {
	var questions []*Question
	if err := db._db.Preload("Contest").Order("created_at").Find(&questions).Error; err != nil {
		return nil, err
	}
	return questions, nil
}

func (q *Question) Update(db *Database, args map[string]string, w http.ResponseWriter, r *http.Request) (interface{}, error) {
	if r.Method == "GET" {
		result, err := q.Read(db, args, w, r)
		if err != nil {
			return nil, err
		}

		question := result.(*Question)

		if err := db._db.Find(&question.AllContests).Error; err != nil {
			return nil, err
		}

		question.SelectedContest = make(map[uint]string)
		question.SelectedContest[question.ContestID] = "selected"

		return question, nil
	} else {
		question, err := q.Read(db, args, w, r)
		if err != nil {
			return nil, err
		}
		err = renderer.Decode(question, r)
		if err != nil {
			return nil, err
		}
		_, err = SaveQuestion(db, question)
		if err != nil {
			return nil, err
		}
		question, err = q.Read(db, args, w, r)
		if err != nil {
			return nil, err
		}
		return question.(*Question), nil
	}
}

func (model *Question) Delete(db *Database, args map[string]string, w http.ResponseWriter, r *http.Request) (interface{}, error) {
	question, err := model.Read(db, args, w, r)
	if err != nil {
		return nil, err
	}
	if err := db._db.Unscoped().Delete(question.(*Question)).Error; err != nil {
		return nil, err
	}
	return question.(*Question), nil
}

func CreateQuestion(db *Database, question *Question) (*Question, error) {
	if err := db._db.Create(question).Error; err != nil {
		return nil, err
	}
	return question, nil
}

func SaveQuestion(db *Database, question interface{}) (interface{}, error) {
	if err := db._db.Omit("Answers", "Contest").Save(question).Error; err != nil {
		return nil, err
	}
	return question, nil
}